The external core compile driver now enforces the same host/target
pairing matrix as the service compile lane: same-triple compiles keep
the native lane, Linux and Windows GNU targets cross-compile from any
macOS/Linux/Windows build host over the compiler's zig-cc lane, macOS
targets need a macOS build host, and every refused pairing teaches
before compiler work starts. The co-emitted contract sidecar is
target-independent: a macOS-native, x86_64-windows-gnu, and
x86_64-linux-musl compile of one staged tree emit byte-identical
documents with identical integer-class decisions, and the COFF and ELF
archives declare the same nsc_core_* symbol surface as the Mach-O one.
The SDK's fixture graph compiles corewire for the build host, so the
battery lanes configure under a cross -Dtarget, and a new
stage-cross-e2e step installs the host-fixture, markup, and in-process
service pool batteries under <prefix>/e2e for execution on the target
machine. scripts/cross-e2e.sh drives the lane end to end: it
cross-builds the batteries, the kanban example, and the service fixture
app (in-process carrier — the core and service archives linked into one
executable, with no defined-symbol overlap between the localized
service archive and the core's contract surface) for x86_64-windows-gnu
and x86_64-linux-musl, then executes the batteries on the Windows box
over ssh and in an amd64 Alpine container. gate.sh runs the lane in
either tier when NATIVE_SDK_CROSS=1 is set and skips it otherwise.
All three batteries pass on both targets: 29 host-fixture, 10 markup,
and 19 in-process pool tests on Windows (the three posix-spawn tests
skip there), and 32/10/19 in the musl container. The TypeScript chapter
and ts-core skill state the supported build matrix, including the Linux
glibc spelling and the unchanged desktop-only scope for mobile.
* feat(services): add the in-process TypeScript service carrier
Compile src/services into a thread-instanced, runtime-localized library
archive (scriptc 0.0.27 library mode) linked into the app binary, and run
it on a small worker-thread pool: one archive instance per pool thread,
same-key requests strictly FIFO, distinct keys in parallel across
instances. The carrier preserves the child-process seam exactly — the
same HostCallBinding, poll-based completion delivery, journaled results,
lazy start, and replay that never initializes the archive.
Cancellation and deadlines ride the same cooperative marker-file token
the child publishes, with the same grace; an operation that ignores its
token is abandoned (thread detached, timeout routed, pool refilled), and
a detected trap routes kind service_trap through the per-instance panic
sink while other instances keep answering. Streaming chunks relay live
through a per-request framed file the pool's supervisor thread tails, so
chunks keep preceding the typed terminal mid-operation.
In-process is the default carrier on host-native macOS/Linux builds;
app.zon .service_carrier (and -Dservice-carrier) select explicitly, with
.service_pool_size (-Dservice-pool-size) setting the pool width (default
min(4, cores)). Windows and cross builds keep the child carrier.
corewire grows the two in-process projections (library facade entry and
compiler profile), the service compile script grows an --out-archive
lane, and bench-service-host now measures both carriers. The new pool
e2e suite covers success/throw routing, duplicate and unkeyed keys,
live streaming with cancellation, queued deadlines, parallelism,
per-key FIFO, trap isolation, the registry/archive pairing fence, and
journal replay against the pool.
* test(services): absorb runner load in the pool parallelism proof
One retry of the parallel batch keeps the timing assertion meaningful
on saturated runners; a pool that serialized distinct keys fails both
attempts deterministically.
* fix(services): harden in-process carrier supervision
* fix(services): harden pool queue scheduling
Wake the supervisor when newly admitted work can move the next deadline earlier, and scan the full queue so large busy-key bursts cannot hide runnable independent work.
* fix(services): drain streams after grace race
Let completion-owned requests remain in the supervisor stream polling path when the grace poison CAS loses, and cover the boundary with a deterministic regression.
* feat(tooling): gate capability claims on the compiler surface manifest
- Add surface_manifest_diff.mjs: mechanical diff of two scriptc surface
manifests keyed by stable entry ids — flips to static (with the
staging-transform/caveat retirements each flip makes due), tier
regressions, easings, added/removed entries, SC-code and semantic
note changes; human-readable and --json output.
- Add gen_service_surface.mjs: generate the author-facing service
compile-surface reference (skill-data/ts-services/references/
service-surface.md) byte-derived from the pinned compiler's manifest,
plus a --check mode that fails on a stale or hand-edited reference,
a manifest/pin version mismatch, any hand-written SC-code claim in
docs/skills/skill-data prose, or a compiler version literal that does
not match the pin.
- Wire the check into scripts/gate.sh as the surface-claims step:
fast tier when docs/, skills/, skill-data/, or packages/core/ change;
always in full.
- Point skill-data/ts-services/SKILL.md at the generated reference and
cover the tooling in packages/core/test/surface_tools.test.ts.
* fix(tooling): harden service surface checks
* fix(tooling): close service surface audit gaps
* fix(tooling): close manifest review gaps
* fix(tooling): harden surface claim auditing
* fix(tooling): keep surface audits layer-aware
* Implement the TypeScript service seam
- Classify src/services as ordinary static-tier TypeScript and generate a checked service contract.
- Compile, package, and supervise a pinned out-of-process service host behind Cmd.request.
- Cover service authority, failures, restart, timeout, replay, docs, skills, and showcase fixtures.
* fix service boundary validation and staging
* fix TypeScript service packaging and validation
* fix TypeScript service review findings
* Improve retained desktop frame performance
1. Fix retained animation pumping and Windows frame wake scheduling.
2. Make latency and frame profiling monotonic, observable, and regression-tested.
3. Add physical-display-aware macOS and Windows performance gates.
* Fix PR performance and package checks
- Align NativeSdkViewInfo declarations with runtime GPU telemetry.
- Calibrate hosted macOS animation budgets without weakening physical-device defaults.
* Harden Windows performance sampling and shutdown
- Correlate physical hover samples with their responding visual frames.
- Stop due-frame callbacks immediately when the Windows host exits.
zero-native becomes the Native SDK. Apps are authored as native markup plus Zig on a deterministic runtime and rendered by the toolkit's own engine into real OS windows — no browser, no WebView, no interpreter in the binary.
- Desktop is complete on macOS, Windows, and Linux: native rendering with per-platform titlebar fidelity, audio playback with streaming, a verified track cache, and real spectrum analysis, native context menus, packaging with sealed code signing, and a deterministic automation and record-replay story.
- Experimental iOS and Android host tiers ship behind the same app manifest: simulator and emulator dev loops, archive-ready packaging, real platform tab bars and push navigation, with embedding over the C ABI underneath.
- The docs site, component catalog, theme packs, showcase apps, and CHANGELOG carry the full account.
Chris Tate