Upstream ports/, exams/, and ct-runner to the polymorph repos

The consumer-facing pieces were developed in-repo as reference implementations and are pending upstreaming to their proper homes (cross-repo, operator-driven):

ports/websocket → polymorph-websocket (their conformance suite runs 55/55 incl. TLS under this port; README notes the one platform delta — Deno abnormal-close code 0)
ports/webcrypto → polymorph-webcrypto (11 families today; webcrypto port: complete the remaining algorithm families #3 tracks completion)
ports/webrtc → polymorph-webrtc-datachannels (echo-demo green over real data channels; note the npm-backend import-map requirement for foreign entry projects, and werift fallback is unverified)
exams/iroh-endpoint → polymorph-iroh (the endpoint exam, 5/5)
ct-runner → polymorph-test (an L3 runner for their L1 contract, emitting schema-exact L4 JSONL; upstream would add CLI/L6 integration, tag scheduling, lockfile folds, sharding)

Migration story per repo: delete the jco fork pins, transpile steps, generated trees, and flag-verification scripts; replace the Node 24+JSPI lane with a flagless Deno lane; browser legs via the deltic lanes.

Prerequisite: #16 (versioned releases) — consumer repos should pin a published deltic version, not a git checkout.

ct-runner: --translator/DELTIC_TRANSLATOR for consumers outside a che…

polymorph-test migration started (Phase 1 landed as polymorph-test#75, side-by-side with the jco legs).

Mechanics proven for the interim pin scheme (#16): consumer runs deltic straight from the release tag — raw.githubusercontent import-map URLs + committed deno.lock (--frozen) for the module graph, release-asset translator wasm sha256-pinned by their fetch-translator.ts, cross-checked at run time. Equivalence gates: deltic's human output and fold output byte-match the goldens shared with their composed-cli/jco legs; ct-runner's --translator flag (#23) was the enabling change.

Remaining phases, in order:

Phase 2 — fixture/tag-scheduling parity in our ct-runner: --missing + tags custom-section inventory (their embed leg schedules tag-gated cases to not-applicable; the deltic leg currently runs feature-blind, scheduling: "none", with lane-specific goldens). Also: emit diagnostics-complete: true on returned cases (we already emit false correctly on the trap path; upstream emits it always). Optional DX: a --wasi flag on the ct-runner CLI (baseline wasiShims()) — polymorph-test ended up with repo-owned glue so it doesn't need it, but our own ports/websocket runner hand-rolls exactly this.
Phase 3 — browser legs + Pages viewer off jco (their runPageHarness/worker plumbing; the viewer-aggregate transpile is sync jco, needs the P1 generated-JS story or a runtime-linked page path).
Phase 4 — cutover PR: delete jco pins, transpile scripts, flag-verification, the Node 24+JSPI lane; Node stays a distribution target only.

Findings for the migration record: at a pinned tag, wasi-shims/src/io.ts imports @deltic/runtime/embedder by bare specifier — resolved by our workspace config, so URL consumers must add one extra import-map entry (documented in their js/runner-deltic/README.md); JSR publishing (#16) obviates this.

js: deltic runner leg (Path 3b) — runtime-linked suites on stock Deno

Phase 2 (deltic side) complete — #30 merged: ct-runner reads the suites' own component-test:tags@0.1 inventory (survives wac composition — verified on the tls artifacts), schedules per-target inapplicable cases to not-applicable in the embed runner's exact wire shape, --missing on the CLI, diagnostics-complete: true parity on returned rows. #25 closed; the tls smoke now runs zero-failure/zero-xfail on all three compositions.

polymorph-test side, deferred to the next deliberate pin bump of their verify-deltic lane: fixture leg gains hsm N/A rows + scheduling: "tags" envelopes, their runner.ts needs a not-applicable render branch, lane goldens regenerate. Remaining phases unchanged: Phase 3 (browser legs + Pages viewer — packaging story, interpreter already at browser parity; per the #8 rescope, no eval anywhere), Phase 4 (jco deletion, ideally behind #16's registry story).

Prerequisite relaxed per #16 decision (2026-08-09): registry publishing is deferred, so upstreaming does not wait on a published package. Consumer repos pin a git reference and/or prerelease artifact (pre-<shorthash> releases) instead.

Phase 3 complete — the browser execution leg, both sides:

deltic #34: deltic-embedder.mjs release asset (one platform-neutral ES module: embedder API + Translator + ct-runner glue + wasi-shims; deno bundle --platform browser, no runtime codegen per the P1: emitted specialized-JS host-boundary executor (AOT-shaped, no eval) #8 invariant), gated by tools/release-bundle/bundle_test.ts in the core matrix.
polymorph-test #76: js/runner-deltic/browser-worker.mjs — drop-in for their page-runner.mjs via workerUrl, sharing harness.mjs's case loop (one-line-ish await-tolerance patch, jco legs pinned unchanged by verify-viewer); selftest.mjs gates the engine path under plain node with no JSPI flag; pin bumped to pre-83fff30, bringing ct-runner: no tag/missing feature-gating (cases N/A per target run and fail) #25 tag scheduling into the CLI legs (--missing hsm fixture parity with their embed leg). Verified end to end in real chromium through their unmodified Playwright driver.

Remaining = Phase 4 (cutover): move the Pages viewer's own engines off jco (viewer-aggregate sync transpile → runtime-linked; demo suites → the deltic worker), then delete the jco pins, transpile scripts, verify-node, and the Node/JSPI lane. After that, consumer repos (websocket/webcrypto/webrtc/tls driver-ct matrices) can adopt the deltic worker for their browser legs via the same workerUrl injection.

jco cutover: delete the toolchain — deps, transpiles, wrapper bin, th…

Phase 4 complete — polymorph-test is jco-free (polymorph-test#77, merged; the post-merge Pages deploy went green with the runtime-linked viewer).

Viewer engines runtime-linked: the viewer-aggregate component instantiates in-page via deltic; live runs use the shared deltic worker pool over component wasm. Verified in real chromium through the page's own demo walkthrough.
Deleted: js/runner-node/ + verify-node, the jco-transpile bin, all jco/preview2-shim deps and transpile scripts, every --experimental-wasm-jspi. No npm install remains in the verify matrix or Pages build.
Kept as consumer-facing glue: js/viewer/browser-worker.mjs + js/node-runner.mjs (zero jco deps in-repo; downstream driver-ct jco legs pin them until they port — the deltic worker is exported as ./deltic-worker/./deltic-engine for exactly that).

The migration story from this issue's description is fully realized for polymorph-test: no transpile step, no generated trees, no fork pins, no flag-verification, the Node/JSPI lane replaced by flagless legs (Deno CLI + plain-node selftests + the browser worker). Remaining scope on this issue is the OTHER consumer repos (websocket/webcrypto/webrtc/tls/iroh ports + exams upstreaming), which can now adopt the same worker/pin pattern.

polymorph-tls migrated (polymorph-tls#36 + CI fix #38, main fully green): standing targets deltic-deno + deltic-deno-delegated run the composed artifacts runtime-linked on stock Deno, side by side with the jco targets per the websocket pattern. Matrix now 9 targets / 56 results / 0 failing, deltic rows identical to the wasmtime and jco rows case for case. Notables: tag scheduling read from the artifacts' own embedded inventory (#25); envelope provenance re-pointed at the un-composed suite mirroring the wasmtime legs' --suite-artifact, keeping the aggregate's mixed-hash warning silent. No SUT host module on this leg — the import surface is wasiShims() + runner-supplied test-context.

Family status: polymorph-test cut over (jco-free), websocket + tls side-by-side deltic legs green. Next per the readiness order: webcrypto (behind #3), webrtc (behind #19, minding #21), iroh (behind #4), mosh (behind #2).

polymorph-webrtc-datachannels migrated (polymorph-webrtc-datachannels#149, merged; their Conformance CI green including the new leg): standing target deltic-deno runs their full driver-ct loopback matrix (solo+pair, 37/37) runtime-linked on stock Deno, side by side with the jco targets per the websocket/tls pattern. Matrix now 5 loopback targets, deltic rows identical to wasmtime/composed/jco case for case; interop/Shadow/netns rows untouched (their #19-scope loopback ruling).

Notables vs the earlier legs: the SUT host module is npm-native-addon-backed (node-datachannel under Deno — the import maps carry node-datachannel/werift npm mappings next to the deltic URLs, the leg's deno install --allow-scripts is a justfile dep, and the addon needs a post-cleanup() settle under deno test); and the child runs under THEIR Rust orchestrator (a new Deno peer kind in rtc-ct-driver) rather than standalone, so the leg inherits their solo/pair fold and signaling provisioning. Pin pre-10cc776.

Findings: #36 (pc.close() wrapper latch — their suite caught it), #37 (unit-test candidate race + teardown SIGSEGV — their runner caught it; = the #21 root cause, now closed), and the same latent close-race noted for their jco-impl in the PR.

Family status: polymorph-test cut over (jco-free), websocket + tls + webrtc side-by-side deltic legs green. Next per the readiness order: webcrypto (behind #3), iroh (behind #4), mosh (behind #2).

Guest constructors complete synchronously in jspi mode; iroh exam ont…

polymorph-iroh: deltic leg built and green end to end; draft PR up, one deliberate residue (polymorph-iroh#36, their full CI green in 15 m — the exam runs on GitHub runners, not just the dev box).

host-deltic/ runs the ENDPOINT surface — the workload their issue #10 (= lann/jco#11/#13) blocks under jco — runtime-linked on stock Deno: the five-scenario exam (bind+identity, relay echo ~100 ms handshake, WebRTC upgrade ~0.9 s, the #10 concurrency rows as passing assertions, teardown) is just exam-deltic, wired into their gha::checks. Import sources follow the family convention: the websocket and webrtc deltic modules come from the sibling checkouts (.deps/websocket/js/deltic, .deps/webrtc/deltic-impl — their setup.sh pins bumped; co-dependent Wasi-prefix renames in their host-wasmtime absorbed, full pairing matrix green with the bumps).

Yield this round (the exam found a deltic runtime gap, not a consumer defect): their new WIT constructs endpoint-options around a borrowed identity — the first guest-resource constructor any consumer has exercised from JS — and jspi-mode promising-wrapped entries made every guest constructor structurally unusable. Fixed in #41 (CONSTRUCTOR_SYNC_ENTRY: plain-entered constructor variant; regression pinned on the resources fixture under forced jspi); exams/iroh-endpoint refreshed onto the identity/options surface in the same PR (5/5 against their main).

The residue = the webcrypto boundary: @polymorph/webcrypto-deltic is a documented TEMPORARY URL pin on deltic's ports/webcrypto at pre-58b2404; when polymorph-webcrypto's in-flight migration lands its deltic module, the mapping moves to .deps/webcrypto like the other two rows (one import-map line + pin note) and the PR un-drafts. Everything else is done.

Family status: polymorph-test cut over (jco-free), websocket + tls + webrtc side-by-side legs green, iroh green in draft behind the webcrypto swap. Remaining: webcrypto (in flight), mosh (behind #2).

polymorph-webcrypto migrated — the deltic execution legs are live in their conformance matrix (polymorph-webcrypto#352, merged; post-merge main run green including the matrix publish).

Port completion (webcrypto port: complete the remaining algorithm families #3, closed): #40 — the full polymorph:webcrypto@0.1.0 surface in ports/webcrypto, built from their own jco host module as reference, driven by their REAL suites (19,090 + 772 cases).
Consumer side: js/deltic/ host module (pinned pre-58b2404, frozen locks, module-identity guard) + deltic-deno targets for BOTH suites, wired through justfile/CI/publish.
The five Deno platform gaps (imported-8192-bit RSA verify, AES-GCM IV window, AES-CTR counter widths, OAEP odd-modulus, OAEP Constructed+label) ride as a 416-entry expected-fail ledger tracking polymorph-webcrypto#351 — capability-feature tags are blocked by their frozen census; the maintainer proposal to amend it is in streams: drop() on a handle whose readable end was transferred to a guest still drops the guest-owned shared object #351. Staleness detection proved itself on the first CI run: one undeclared failure (a case-timeout on CI hardware, not a gap) was refused by the aggregate and fixed as a timeout bump, not a ledger entry.
Enabler that landed with it: #39 — fresh-case runs lost their quadratic re-enumeration + per-instantiate recompile (their shared suite: 17.3 min → 7.5 local, ~27 min on a 2-core Actions runner).

Remaining scope on this issue: iroh (#4) and mosh (#2). webrtc landed earlier today (#41).

polymorph-iroh migrated (polymorph-iroh#36, merged; their full CI green — the exam runs on GitHub runners): host-deltic/ runs the endpoint surface (the workload their #10 / lann/jco#11 blocks) runtime-linked on stock Deno, just exam-deltic in their gha::checks. All host modules now come from the sibling checkouts per the family convention — websocket js/deltic, webrtc deltic-impl, and polymorph-webcrypto's own js/deltic module (their #352; the temporary pin on deltic's ports/webcrypto is gone).

Family status: polymorph-test cut over (jco-free), websocket + tls + webrtc + webcrypto + iroh deltic legs green and merged. Remaining on this issue: experiment-mosh (behind #2) and the ports/exams reference copies' long-term disposition.

deltic-browser rows: the composed artifacts runtime-linked in Chromiu…

Scope decision (operator): jco support/coverage is retained in polymorph-webcrypto only.

Everywhere else the jco legs come out — per repo, as soon as its deltic coverage twin exists. Sequencing as of now:

webcrypto — keeps js/jco and the jco-node/jco-browser lanes indefinitely (with them: the Chromium side of the Deno platform-gap ledger, and the standing venue for Perf baseline vs the jco legs (and consumer case-budget fit) #17's head-to-head). No deltic-browser port needed there.
tls — deltic-deno + deltic-browser both merged (their ports/webrtc: latch owned channels on peer-connection close #36, fresh-case runs: same-index re-pick + compiled-module cache #39) -> removal in flight.
iroh — host-deltic supersedes host-jco (their ports/webrtc: latch owned channels on peer-connection close #36) -> removal in flight; polymorph-iroh#10 closes as superseded when it lands. Follow-up for retiring the 5 ms polling workaround once inter-task wakeup is verified on both remaining hosts: endpoint: retire the bounded-polling wake path once jco leaves the host set polymorph-iroh#37
websocket — deltic-browser open (their Guest constructors complete synchronously in jspi mode; iroh exam onto the identity/options surface #41) -> removal queued behind it.
webrtc-datachannels — browser twin needs a page-context runner (no RTCPeerConnection in workers); removal blocked until it exists.

Consequences: polymorph-test keeps publishing the jco-era compat surface webcrypto's retained lanes pin, and #17's cross-suite half becomes unmeasurable as removals land — webcrypto stays measurable indefinitely; run-or-rescope there is the operator's call.

Remove the jco conformance legs; the deltic rows carry both postures

Correction — removals are operator-scheduled; the "in flight" framing above overstated the mandate (the ruling was for the record, not a go signal). Actual state:

tls: their #40 landed before the pause reached the session (auto-merge on green CI); operator ruled to keep it. tls's jco legs are gone; its Perf baseline vs the jco legs (and consumer case-budget fit) #17 head-to-head stays reproducible at the pre-removal SHA.
iroh: removal prepared and parked as draft (#39; closes their Policy: FinalizationRegistry-triggered dtors vs instance teardown ordering #10 when it lands). Follow-ups stand: their ports/webrtc tests: buffer trickled candidates; settle after addon cleanup (#21 root cause) #37 (polling retirement), CI: test-webrtc becomes a required core step (#21 closed) #38 (bench call-count reinstatement).
websocket / webrtc: untouched. Sequencing as above, on operator signal only.
Docs: the disposition + per-repo cutover state is recorded in docs/consumers.md (docs: consumers.md — the jco disposition (webcrypto retains; per-repo cutover state) #48).

tls update: #40 reverted (polymorph-tls#41, auto-merge on green) — operator ordering rule: the #17 perf comparison runs before a repo's jco legs are deleted. The revert is a pure git revert -m 1 plus re-application of the #39 wiring completions that rode #40 (publish-action deltic-browser rows, deltic js-lock, README table rows). The disposition ruling itself is unchanged: jco ultimately remains only in polymorph-webcrypto; removals re-land on operator signal after the measurements (iroh's stays parked as draft polymorph-iroh#39). docs/consumers.md updated (#49).

Revert "Remove the jco conformance legs; the deltic rows carry both p…

deltic-browser row: the suite runtime-linked in Chromium; component-t…

Browser lanes complete — every jco-browser row now has a deltic-browser twin. The last coverage prerequisite for jco removal is discharged; first-order perf from leg wall times came out uniformly in deltic's favor.

repo	corpus	jco-browser	deltic-browser	ratio
polymorph-tls (#39)	7 cases × 2 compositions	2.4 s	2.7 s	~parity (fetch-dominated)
polymorph-websocket (#41)	55 cases incl. TLS	32.8 s	16.5 s	~2.0×
polymorph-webcrypto (#355)	19,862 cases (Wycheproof)	155 s	51 s	~3.0×
polymorph-webrtc-datachannels (#150)	37 cases, real ICE/DTLS	38.2 s	27.2 s	~1.4×

(Same box, same Chromium, sequential; handshake-bound suites compress the gap, instantiation-bound ones widen it.)

The dedup architecture (per the directive): one upstream mechanism serves everyone. polymorph-test grew workerMain({ deltic, suiteImports }) (#79) + a freshCases run-message knob (#80); each consumer bundles ONE worker/page module (deltic engine surface from the release-bundle entry + its own deltic host module + the upstream message loop through a single import map — one embedder instance, no import-map-in-worker gamble). tls needed zero new host code (stock worker); websocket/webcrypto are worker-based; webrtc is page-based (RTCPeerConnection is Window-only) and confirms the polymorph-test-artifacts dedup: the page reuses the upstream runPageHarness/proxy frame and deltic's own runSuite from the bundle — the only new upstream Rust was a 6-line deltic-browser spawn kind.

Notables for the record: the webcrypto browser rows recover the Deno-platform coverage (OAEP-with-label, the parameter windows, 8192-bit verify — all pass on Chromium, no xfails); the 19k corpus needed freshCases: false (renderer wasm-reservation ceiling; declared per row) and a 300 s stall bound (runner headroom); the jco trees keep working under the bumped polymorph-test pins via one vendored jco-transpile.mjs wrapper per repo (dies with the jco trees). Watch item: solo/channel-drop-implies-close failed once on a runner under deltic-browser (drop-side close vs in-flight delivery race; did not recur on rerun — their per-push conformance now exercises it continuously).

Removal readiness: with browser parity green everywhere and deltic#17's first-order answer recorded above, nothing structural remains before the per-repo jco cutover PRs (delete driver-ct/jco + js/jco trees, fork pins, transpile wrappers, JSPI lanes) plus the iroh host-jco retirement and its inter-task-wakeup payoff.

jco cutover: delivered across the family.

Repo	PR	Scope
polymorph-tls	#42 (merged)	jco legs retired; matrix = wasmtime + deltic-deno + deltic-browser per posture
polymorph-websocket	#42 (auto-merge armed)	jco legs, `js/jco` host, demo, transpile wrapper retired; WPT parity carrier ported to deltic (loss sets stayed empty — the deltic carrier loses nothing against either engine baseline); demo runs runtime-linked (`just demo::deltic`)
polymorph-webrtc-datachannels	#151 (auto-merge armed)	jco legs + `jco-impl` retired; interop directions preserved on deltic children — deltic-deno/deltic-browser vs Google's libwebrtc reference both orders + vs wasmtime both ways, 13 directions × 12 pair cases all green
polymorph-iroh	#40 (merged)	host-jco, fork pin, jco spike pairings, udp-wake rig retired; deltic is the JS leg. #10 (the jco scheduler defect) closed as superseded; the 5 ms polling-workaround reversal is filed as iroh#42 (~5× handshake-latency win available)
polymorph-webcrypto	#358 (docs-only, auto-merge armed)	keeps both JS hosts by design; docs now present deltic as the primary JS path

Provenance discipline everywhere: the deltic modules' port-provenance headers now cite the retired jco reference hosts at their last revisions (git show <sha>:<path>), so the line-level citations stay resolvable.

With this, every consumer's standing matrix runs deltic as its JS host (webcrypto additionally retains jco rows), all on pre-58b2404. Remaining threads from this arc: #54 (u8-lift bulk copy — bench/boundary's recv rows are the sentinel) and iroh#42 downstream.

Triage: p2 → p3. The thread records delivery of the consumer migrations, and current docs/consumers.md describes the established external-provider arrangement. Remaining work is reconciling any residual upstreaming/disposition scope, not a demonstrated behavior blocker. Keep open pending that scope check rather than treating the historical migration list as unfinished implementation.

Navigation Menu

Repository navigation

Upstream ports/, exams/, and ct-runner to the polymorph repos #14

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Upstream ports/, exams/, and ct-runner to the polymorph repos #14

Description

Activity

lann commented on Aug 9, 2026

lann commented on Aug 9, 2026

lann commented on Aug 9, 2026

lann commented on Aug 9, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lann commented on Aug 10, 2026

lannbot commented on Sep 12, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions