pcbjam/wasm
Repository files (latest commit first)
Filename Latest commit message Latest commit date
Istvan Matejcsok c14e76651c findings(E-5,E-8,E-9): module-identity ngspice events + runWaitCompletion admission gate
E-8 (re-implemented for JSPI — the codex gate is entangled with the dropped
execution owner; under JSPI a fresh non-suspending JS→wasm entry while
another activation is suspended is structurally safe on its own stack, so
the admission boundary for worker completions is liveness + trap state, not
execution ownership):
- jspi-scheduler.js grows `terminal` (trapped instance; distinct from `dead`),
  canTouchNative(), _terminalizeNativeTrap() (WebAssembly.RuntimeError +
  cross-realm string classification), and runWaitCompletion(site, token,
  prepare, inertResult): prepare runs immediately and owns ALL native work;
  stale tokens and dead/terminal instances drop loudly without resolving
  (resolving would resume the parked frame inside the damaged module); a
  trap latches terminal; a plain JS bug resolves inertResult so the wait
  fails instead of stranding. beginWait refuses (token 0) when dead/terminal.
- all four delayed completion sites route their native work through the
  gate: 'OCC export completion' (exporter_step_stub), 'OCC model completion'
  (oce_plugin_stub — the MEMFS cache write moves inside the gate too),
  'ngspice request completion' and 'ngspice vector completion'
  (sharedspice_client — every HEAP32/HEAPF64/malloc write inside prepare,
  inertResult 1 = transport error). Every wxWasmBeginWait caller in the
  stubs bails on token <= 0.
- deliberately NOT ported from codex: ownerModule, enqueueNativeCompletion,
  executionBarrier, the byte-credit native-entry FIFO — completions are
  one-shot per wait token and stream volume is bounded at the E-6 transport
  credit window. Cross-refs logged for group M (M-2/M-6/M-8).

E-5 (re-implemented; codex shape kept, owner APIs replaced with the E-8
gate): js_ngspice_install_events binds the handler to the EXACT installing
module (handler.__pcbjamNgspiceOwnerModule stamp; presence is not identity),
re-installation replaces a foreign module's handler, a superseded handler
disarms itself, native entry goes through installingModule._malloc/
._pcbjam_ngspice_event (never lexical Module), each dispatch checks
canTouchNative() (loud drop on a dead/terminal module), and a trap on the
per-line entry latches the terminal gate.

Tests: scheduler-shim.test.ts +7 (gate happy/stale/dead/terminal/cross-realm/
js-bug/beginWait-refusal). e2e specs updated from the codex line: occ-export
decode-fault recovery (real onmessageerror transition via failDecode, J-4),
ngspice-probe direct-service coverage, eeschema-sim rewritten onto the E-7
applied-generation receipt (codex's executionBarrier await replaced with a
pendingWaits('ngspice') drain poll — the JSPI-line equivalent).

Also bumps the kicad submodule to the E-7/E-9 commit (dd5751038f7).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-31 18:18:21 +02:00
..
bindings collab: paste-collision sync-delete fix — lenient sibling restage, forced removals for deleted dirty roots, eeschema child-blob lifting 2026-08-31 12:50:12 +02:00
cli batched upload resave: --resave-batch CLI + one staging pass per bulk upload (tasks-runner 0004) 2026-08-24 14:46:43 +02:00
cmake eeschema simulator: lazy ngspice_service worker — static sharedspice (XSPICE registry + CIDER), init_dll ifdef, e2e both engines 2026-07-19 15:59:21 +02:00
editor cvpcb-wasm: link CvPcb as third kiface — eeschema Assign Footprints opens in WASM; serial-inline footprint list load fixes pool-task-vs-JS-bridge deadlock 2026-07-17 18:00:13 +02:00
gl1 fix(3d): blank viewer after raytracing round-trip — owner-context FFP routing + VAO isolation (gl1) 2026-08-25 11:25:34 +02:00
kiplatform fix(wasm): KiCad 10 kiplatform/libgit2 stubs, e2e fixtures, asyncify -g hook 2026-06-24 10:30:25 +02:00
ngspice-service jspi cleanup: remove the asyncify-era residue — dead code, conditionals, pipeline scaffolding, stale prose 2026-08-14 09:25:32 +02:00
occ-service jspi cleanup: remove the asyncify-era residue — dead code, conditionals, pipeline scaffolding, stale prose 2026-08-14 09:25:32 +02:00
shims jspi cleanup: remove the asyncify-era residue — dead code, conditionals, pipeline scaffolding, stale prose 2026-08-14 09:25:32 +02:00
stubs findings(E-5,E-8,E-9): module-identity ngspice events + runWaitCompletion admission gate 2026-08-31 18:18:21 +02:00
tools jspi cleanup: remove the asyncify-era residue — dead code, conditionals, pipeline scaffolding, stale prose 2026-08-14 09:25:32 +02:00
README.md refactor: 💡 remove orphaned files 2026-06-05 13:18:24 +02:00

WASM Compatibility Layer

This directory contains WASM-specific implementations that allow KiCad to run in a web browser while keeping our KiCad fork as close to upstream as possible.

Principle

Instead of patching KiCad source files, we:

  1. Provide alternative implementations for platform-specific code (kiplatform)
  2. Stub out libraries/features that can't work in the browser (libgit2, curl, nng, scripting, 3D viewer, ...)
  3. Expose KiCad to JavaScript via Embind bindings
  4. Override host package detection during cross-compilation (cmake find-modules)

The KiCad-side hooks for this are small if(EMSCRIPTEN) branches in KiCad's own CMakeLists that pull sources from this directory — see "How it's wired" below.

Directory Structure

wasm/
├── README.md               # This file
├── kiplatform/             # Platform abstraction implementations (compiled into KiCad)
│   ├── app.cpp             # App lifecycle (paths, startup)
│   ├── drivers.cpp         # GPU detection (returns "WebGL")
│   ├── environment.cpp     # Environment variables
│   ├── io.cpp              # File I/O (WASM virtual filesystem)
│   ├── policy.cpp          # Security policy (always permissive)
│   ├── secrets.cpp         # Credential storage
│   ├── sysinfo.cpp         # System information
│   ├── printing.cpp        # Print support (browser print())
│   └── ui.cpp              # UI helpers
├── bindings/               # Embind bindings exposing each app to JavaScript
│   ├── pcbnew_embind.cpp
│   ├── eeschema_embind.cpp
│   ├── pl_editor_embind.cpp
│   └── calculator_embind.cpp
├── stubs/                  # Stub implementations + header shims for unavailable deps
│   ├── *.c / *.cpp         # libgit2, curl, nng, scripting, 3D viewer, frame stubs, ...
│   ├── char_traits_uint16_workaround.h
│   └── GL/ nng/ ngspice/   # Header stubs found via include paths
└── cmake/                  # CMake find-module overrides for cross-compilation
    └── Find*.cmake / Use*.cmake

How it's wired

kiplatform — compiled into KiCad

The kiplatform/*.cpp files are added directly to KiCad's kiplatform library by an if(EMSCRIPTEN) branch in kicad/libs/kiplatform/CMakeLists.txt, which references them as ${PROJECT_SOURCE_DIR}/../wasm/kiplatform/*.cpp. There is no separate libkiplatform_wasm.a.

stubs — compiled by the build script and KiCad CMakeLists

scripts/kicad/build-kicad-target.sh compiles the C stubs (libgit2_stub.c, curl_stub.c, nng_stub.c) and force-includes char_traits_uint16_workaround.h. App-specific *_frame_stub.cpp / *_scripting_stub.cpp are picked up per app, and the remaining *_stub.cpp files are pulled in by if(EMSCRIPTEN) branches in the KiCad fork's own CMakeLists. Header stubs under GL/, nng/, ngspice/ are resolved via include paths.

bindings — per app

build-kicad-target.sh compiles wasm/bindings/<app>_embind.cpp for the app being built (apps without an embind file get an empty placeholder object).

cmake — module path

build-kicad-target.sh passes -DCMAKE_MODULE_PATH="${PROJECT_ROOT}/wasm/cmake" so the WASM find-module stubs override host package detection.

Coroutine/fiber support is not in this directory — it comes from the KiCad fork's kicad/thirdparty/libcontext/libcontext.cpp (LIBCONTEXT_PLATFORM_wasm32). The GLU tesselator comes from kicad/libs/kimath/glu_tess/glu_tess_impl.cpp.

Adding New Implementations

  1. Create the implementation file in the appropriate directory (kiplatform/, stubs/, bindings/).
  2. Wire it in: a stub C file goes in build-kicad-target.sh; a kiplatform/app source goes in the relevant if(EMSCRIPTEN) branch of the KiCad-side CMakeLists.
  3. Ensure the header interface matches KiCad's expected interface.
  4. Test with a minimal build before full integration.