| Filename | Latest commit message | Latest commit date |
|---|---|---|
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>
|
||
| .. | ||
| bindings | ||
| cli | ||
| cmake | ||
| editor | ||
| gl1 | ||
| kiplatform | ||
| ngspice-service | ||
| occ-service | ||
| shims | ||
| stubs | ||
| tools | ||
| README.md | ||
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:
- Provide alternative implementations for platform-specific code (kiplatform)
- Stub out libraries/features that can't work in the browser (libgit2, curl, nng, scripting, 3D viewer, ...)
- Expose KiCad to JavaScript via Embind bindings
- 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 fromkicad/libs/kimath/glu_tess/glu_tess_impl.cpp.
Adding New Implementations
- Create the implementation file in the appropriate directory (
kiplatform/,stubs/,bindings/). - Wire it in: a stub C file goes in
build-kicad-target.sh; a kiplatform/app source goes in the relevantif(EMSCRIPTEN)branch of the KiCad-side CMakeLists. - Ensure the header interface matches KiCad's expected interface.
- Test with a minimal build before full integration.