# franken_threed — RULEBOOK v1.0 Assessment Packet v7

**Repository:** `Dicklesworthstone/franken_threed` · **Language:** Rust + JavaScript [Code-verified, High] · **Pinned commit:** `72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d` (2026-09-22 11:10:21 −0400, [Git-observed, High]) · **Last push:** 2026-09-22 11:13 −0400 (the pin is HEAD at assessment time; a newer pushed commit may exist by read time — re-pin before citing) [External, High] · **Scope:** the pinned commit only, not HEAD. No tags, no releases [Git-observed + External, High].

**Method (analyst):** shallow-cloned HEAD (depth 380, full history to the 2026-09-09 initial commit) under `~/workspace/.scratch/f3d-verify`; working tree at the pin. Read: root `Cargo.toml`, `f3d-runtime/Cargo.toml`, `LICENSE` (verbatim), README honest-status table + TL;DR + performance-gate sections, AGENTS.md (staleness check), `upstream/PIN.md`, `DEPENDENCY_ADMISSION.md`, `.github/workflows/marching-cubes.yml`, `tools/ingest/MARCHING_CUBES_SPECIALIZATION.md` (full), `marching_cubes_numeric.mjs` + `marching_cubes_compile.mjs` + `numeric_kernel.mjs` (heads/skimmed), `marching_cubes_numeric.test.mjs` (full first 80 lines + structure), rust-toolchain.toml, `git log` corpus (commit titles, authors, trailers). Counted: `.rs` files/lines (workspace + tests), `unsafe` occurrences, `.mjs/.js` lines under `tools/`+`tests/`, `tools/ingest` entries, commits. Verified via GitHub API: stars, forks, Actions run conclusions for the pin. **Executed by the assessor:** the full marching-cubes CI trio — `npm ci --ignore-scripts` in `tools/`, sparse three.js checkout at the pinned commit (oracle blob SHA-1 verified `29a405be…` before use), then `node --test` on `marching_cubes_numeric` (23/23 pass), `marching_cubes_adapter` + `marching_cubes_bundle` (38/38 pass) with `F3D_THREE_ROOT` set — **61/61 green in ~21 s on Node v24** (one local-only hiccup: the bundle suite needs `build/three.module.js` alongside `three.core.js` in the oracle checkout; a sparse-checkout artifact, not a repo defect). **Not done:** no Rust toolchain installed, nothing in `crates/` compiled, no browser ran, no benchmark reproduced, no end-to-end specialized app built or rendered; the full `package.json` surface was not audited; license enforceability was not legally analyzed; the `.beads` graph was sampled, not fully read.

**Tier legend (Rulebook §1):** **[Verified]** direct inspection of the pinned clone or a live page read by the analyst, with flavors **[Counted]** (I ran the count), **[Git-observed]** (git metadata), **[Code-verified]** (source read); **[CI-observed]** is Tier 2 (seen executing on live CI pages — attests the suite *runs*, not that it is green); **[Maintainer claim]** asserted in README/docs, not independently executed; **[External]** independent sources; **[Inference]** analyst judgment, always labeled. Confidence: **High** / **Medium** / **Low** per the Rulebook.

---

## Hook

A one-person, AI-agent-assisted project — 380 commits in 13 days [Git-observed, High] — that has stopped being a plan and started being a compiler: it ships an Acorn-based JS→Wasm numeric-kernel compiler [Code-verified, High], a rollup plugin and CLI that branch real Three.js addon hot loops into compiled kernels [Code-verified, High], and a CI workflow that executes Wasm compiled from a clean-room re-derivation of Three.js r186's MarchingCubes triangulation against the actual upstream oracle across all 256 cube topologies × 8 flag combinations — green on the pinned commit [CI-observed, High]. The headline goals are still unmeasured (the project's own docs: "a compiled addon is not a measured acceleration") [Maintainer claim, High], the README still claims "no implementation" on a tree with 217k lines of code [Verified, High], and the license names OpenAI and Anthropic as forbidden parties [Code-verified, High].

---

## TL;DR

- **What it is:** A Three.js r186-compatible application specializer: ordinary Three.js projects in, self-contained packages out, where provably-closed numeric parts of the frame loop are compiled into Wasm kernels with a persistent render schedule. At the pin: 4 Rust crates (68,108 lines, zero `unsafe`, ~34% of it in test files [Counted, High]) plus ~149k lines of JS ingestion/toolchain machinery — of which ~68k are implementation and ~81k are tests, i.e., tests outweigh implementation [Counted, High] — one GitHub Actions workflow (green at the pin) [CI-observed, High], no tags/releases, 5 stars/1 fork [External, High].
- **Strongest evidence:** the numeric-specialization slice is real and independently re-executed: `numeric_kernel.mjs` is a hand-rolled Acorn→Wasm compiler (779 lines), `compileMarchingCubesKernel()` compiles the triangulate body to an import-free Wasm module, the differential harness runs it against the pinned upstream oracle (blob SHA-1 verified `29a405be…` before use) with `sameEffect`/`sameArrays` assertions across 2,048+ configurations — and the assessor ran the full CI trio locally on 2026-09-22: **61/61 tests pass** (23 numeric + 38 adapter/bundle), in ~21 s on Node v24, in addition to the green CI run at the pin [Verified — executed by analyst, High].
- **Strongest doubts:** no measured speedup anywhere — README L41: "**zero speedup has been measured**" and the specialization doc: "a compiled addon is not a measured acceleration" [Maintainer claim, High]; the public status surface is stale (README honest-status table still says "Is there a compiler, renderer, or CLI? **No**" and lists 2 crates; AGENTS.md L17 still says "zero implementation") [Verified, High]; bus factor 1 with no Co-Authored-By trailers but Claude-Session links and named agent personas in commit bodies — AI-agent-authored at scale with opaque provenance [Git-observed, High]; the MIT+OpenAI/Anthropic rider is non-OSI and excludes the likeliest validators [Code-verified, High].
- **NODUS ring: Explore** [Inference, Medium] (TRL 3–4 — see §4.9). The numeric-kernel slice has lab validation (green CI, differential oracle parity); the application specializer thesis itself remains unmeasured. Explore fits: substantive-but-unproven, with the green-at-pin CI and oracle-parity machinery as the advancement signals to watch.

---

## Quick Links

Pin-relative links (`blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d`); all verified resolving (HTTP 200) 2026-09-22 [Verified, High]:

1. [Repository](https://github.com/Dicklesworthstone/franken_threed)
2. [README (incl. honest-status table)](https://github.com/Dicklesworthstone/franken_threed/blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d/README.md)
3. [License (MIT + AI-lab rider)](https://github.com/Dicklesworthstone/franken_threed/blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d/LICENSE)
4. [Design plan (1,835+ lines, kill gates §16.7)](https://github.com/Dicklesworthstone/franken_threed/blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d/COMPREHENSIVE_PLAN_FOR_THE_DESIGN_OF_FRANKENTHREED.md)
5. [Marching-cubes specialization doc (honesty constraints)](https://github.com/Dicklesworthstone/franken_threed/blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d/tools/ingest/MARCHING_CUBES_SPECIALIZATION.md)
6. [Ingest CLI (`--specialize-numeric`)](https://github.com/Dicklesworthstone/franken_threed/blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d/tools/ingest/cli.mjs)
7. [Marching-cubes CI workflow](https://github.com/Dicklesworthstone/franken_threed/actions/workflows/marching-cubes.yml) — 2 runs, both success, latest at the pin (2026-09-22T15:10Z)
8. [Dependency admission ledger](https://github.com/Dicklesworthstone/franken_threed/blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d/DEPENDENCY_ADMISSION.md)
9. [Upstream pin metadata](https://github.com/Dicklesworthstone/franken_threed/blob/72dcaa1adbad6b3d552a071cc7db31a16ee4ba9d/upstream/PIN.md) — three.js r186 at `148ef33ecb6d2502ff796d4554abd1549c95d519`

---

## Did You Know

The MarchingCubes differential harness tests **all 256 cube topology cases × 8 flat-shading/UV/color flag combinations** (2,048 kernel invocations per sweep), plus animated metaball sequences, 80 seeded random fields, and empty/NaN-isolation edge cases — every one asserted bit-comparable (`sameEffect`, `sameArrays`) against a *live instantiation of the actual upstream r186 `MarchingCubes` class*, with diagnostics counters requiring exactly 256 Wasm calls and **zero fallback calls**. [Code-verified (test source read), High; CI execution green at the pin, CI-observed, High.]

---

## Franken-worthy next steps

1. **Ship the "0× baseline": measure the specialization's correctness overhead, not its speedup.** The Amdahl honesty constraint (README) implies 3× requires removing ~2/3 of the critical path — but no frame-time measurement exists at all. Run the first end-to-end instrumented pass: upstream MarchingCubes app vs. specialized package in headless Chrome, frame-time medians, publishing the *overhead ledger* (guard checks, branch dispatch, kernel instantiate). *Done when:* a measured non-speedup (whatever it is — even 0.9×) is published with the overhead breakdown; the prediction "compiled is not measured acceleration" is confirmed or falsified by number, not prose. [Inference, High — process proposal grounded in the project's own honesty doc.]
2. **Generalize the marching-cubes differential pattern into the kernel admission bar.** Today the pattern is: closed numeric body → Acorn compile → import-free Wasm → full-input-class differential test vs. pinned oracle → CI. Require every future specialized kernel (the next addons in the H1–H8 headline corpus) to ship the same four artifacts, and reject kernels whose "full input class" is a sample rather than an exhaustive or seeded-covering sweep. *Done when:* a second kernel from a different loop class (e.g., a skinning or animation loop, not another numeric triangulate) passes the gate in CI. *Falsified when:* the second kernel attempt stalls because "full input class" proves undefinable for stateful loops — which would bound the specializer to embarrassingly-parallel numerics and shrink the thesis accordingly. [Inference, Medium.]
3. **Machine-check the honest-status table.** The README's honest-status table went materially stale within ~10 days of the pin (says "no compiler/CLI" while a compiler and CLI execute in CI). Add a CI check asserting the table's commit references are within N commits of HEAD and its "No" answers still hold (e.g., fail if a row claims no compiler while `tools/ingest/numeric_kernel.mjs` exists and compiles). *Done when:* the check runs green/red on the real tree. This converts the project's honesty discipline from prose into a test — the FrankenSuite's most exportable governance artifact. [Inference, Medium.]
4. **Instrument provenance for the agent-authored corpus.** Commit bodies carry `Claude-Session:` links and named agent personas (NavyAspen, RubyCrane, BlueBison…), but there are zero `Co-Authored-By` trailers and no machine-readable record of which agent produced which artifact under which review gate. As agent-era provenance infrastructure: record per-commit (agent id, session, review lane, evidence produced) in a signed ledger. *Done when:* a query answers "who produced `numeric_kernel.mjs` and what verified it" without reading prose. Directly stress-tests deepening question 1. [Inference, Medium.]
5. **Resolve the asupersync fresh-run open item or drop the browser-host claim.** The README itself flags it: "The browser results above predate this pin and still require a fresh browser run." Either re-run the 9 probes against published asupersync `=0.5.0` and record dated evidence, or downgrade the row to "stale." A project whose pitch is honesty should not carry a self-flagged stale row through another 100 commits. *Done when:* the row is green-dated or removed. [Inference, High.]

---

## 4.1 Why it exists — the market problem

**The problem, as the maintainer frames it:** a general-purpose renderer re-answers the same questions every frame — which objects share a program, which values changed, which changes affect which passes, what can be batched. A typical Three.js application has one stable answer to most of those questions and pays to rediscover it 120 times a second. Translating fine-grained property writes into equally fine-grained Wasm calls just relocates the overhead ("language substitution is not an optimization"); the idea is to recover specialization information across library boundaries at build time and ship *the answer plus a small invalidation condition* instead of the question [Maintainer claim, Medium — the problem statement is coherent; its economic value is unmeasured].

**Who feels the pain:** authors of closed, performance-critical web-3D applications (product configurators, data-viz dashboards, casual games, kiosk/embedded WebGL) who hit frame-time ceilings on mid-tier devices and phones, and who currently hand-optimize or accept the ceiling [Inference, Medium]. The 2×/3× gates are specified on *completed-frame throughput on real devices* (paired 95% lower bounds), not microbenchmarks — the right metric if the workload is real apps [Maintainer claim, Medium].

**Why now:** three.js r186 is a stable, pinned target with an npm-shipped build; WebGPU is shipping in the browsers the project names (HeadlessChrome 152, Safari 26.5); Node 22 runs Wasm natively so the compile→execute→differentiate loop needs no browser at all; and Acorn-class JS parsing makes a "compile the closed numeric prefix" strategy tractable without a full JS engine [Inference, Medium]. None of this was true in the same combination five years ago — the strategy's feasibility window is genuinely recent.

**Why a specializer, not a renderer rewrite:** the no-cut rule (full r186 surface, permanent omission forbidden) makes a from-scratch renderer a multi-engineer-year undertaking the project cannot staff; specializing *around* the upstream library preserves compatibility by construction and turns the problem into closure detection + kernel compilation, which is automatable per-loop [Inference, Medium — the maintainer's own plan frames the no-cut rule as the feasibility governor].

**Demand-side check (2026-09-22):** a web search for independent coverage of franken_threed (third-party reviews, downstream users, forks with activity) returned only the repository and its own commit pages [External, High within recall caveats]. There is no independent demand signal. The 1 fork and 5 stars (GitHub API, 2026-09-22) are consistent with a project in its second week of public existence [External, High on the counts].

---

## 4.2 What it is — repo TL;DR

A 4-crate Rust workspace plus a Node.js ingestion toolchain (254 files under `tools/ingest`, 27 design/test docs), implementing the first demonstrated slice of a Three.js r186 application specializer: an **Acorn-based JS→Wasm numeric-kernel compiler** (`numeric_kernel.mjs`, 779 lines — parses a closed JS function body and emits an import-free Wasm module), a **rollup plugin + CLI** (`marchingCubesRollupPlugin()`, `tools/ingest/cli.mjs --specialize-numeric`, `buildApplication`/`bundleWithRollup` APIs) that branches the numerical prefix of the pinned r186 MarchingCubes addon's `update` around a compiled kernel, **runtime ownership/shape guards** (`numeric_kernel_runtime.mjs`, 536 lines) that fall back to the original JS on aliases/accessors/unsupported shapes, and a **differential test harness** asserting kernel-vs-oracle equivalence that executes in CI against a real three.js checkout pinned at the r186 source commit — green at the pin (Actions run, 2026-09-22T15:10Z, concluded success) and independently re-executed by the assessor (61/61 pass, ~21 s) [Verified — executed by analyst, High].

Velocity is extreme: 380 commits from the 2026-09-09 initial commit through the 2026-09-22 pin — ~29/day sustained over 13 days, including 12 commits in the ~11 hours between this packet's predecessor pin (`5361efa`, 00:30) and the current pin (`72dcaa1`, 11:10) — all authored by Jeff Emanuel with Claude-Session links and named agent personas in commit bodies [Git-observed, High on counts/authors; the agent division of labor is Maintainer-implied, Medium].

One-line verdict: **a real, green-in-CI numeric specializer for one Three.js addon loop, wrapped in the most honest project documentation in the FrankenSuite, still carrying plan-stage status pages, zero measured speedups, and a license that bars the AI labs from touching it.** (NODUS: Explore — see §4.9.)

*Glossary for cold readers: a **bead** is the project's issue-tracker unit (219 records in `.beads/issues.jsonl` at the pin [Counted, High]); **RCH** = remote check host, the maintainer's remote machine where builds/tests are executed and logged; **H1–H8** = the plan's eight headline demo applications that the 2×/3× gates will be measured against.*

---

## 4.3 Repo facts (claim inventory)

Every claim re-verified against the pinned commit on 2026-09-22.

| # | Claim | Status | Evidence | Tier, Confidence |
|---|-------|--------|----------|------------------|
| 1 | 4-crate Rust workspace (f3d-core, f3d-graph, f3d-math, f3d-runtime); 68,108 Rust lines across 75 `.rs` files (crates + tests) | demonstrated | `Cargo.toml` members; `find crates tests -name '*.rs' \| xargs wc -l` | [Counted, High] |
| 2 | Zero `unsafe` in the Rust tree; workspace lints `unsafe_code = "forbid"` | demonstrated | `grep -rn 'unsafe'` over `crates tests` returns 0 hits outside `unsafe_code` lint lines; `[workspace.lints.rust]` read | [Counted, High] |
| 3 | `numeric_kernel.mjs`: Acorn-based JS→Wasm compiler emitting import-free modules; 779 lines | demonstrated | Source read (opcodes `0xa0`–`0xa3` f64 arithmetic, `0x61`–`0x66` comparisons, f64/bitwise lowering, counted loops, typed arrays, closed scalar helpers); "emits executable Wasm, not a route label" | [Code-verified, High] |
| 4 | `compileMarchingCubesKernel()` compiles the triangulate body to a Wasm artifact instantiated by `instantiateNumericKernel` | demonstrated | Source read; **independently executed by the assessor** — 23/23 numeric tests pass locally, Wasm actually instantiated and run | [Verified — executed by analyst, High] |
| 5 | Differential harness: all 256 cube cases × 8 flag combos + animated metaballs + 80 seeded fields + NaN/empty edge cases, asserted against the live upstream oracle | demonstrated | Test source read (2,048-case sweep, `sameEffect`/`sameArrays`, `wasmCalls == 256`, `fallbackCalls == 0` assertions); oracle is the real upstream source with blob-SHA-1 pin check; **independently executed by the assessor — 61/61 pass** | [Verified — executed by analyst, High] |
| 6 | Marching-cubes CI green at the pin | demonstrated | GitHub Actions API: "Marching cubes integration" at `72dcaa1a`, created 2026-09-22T15:10Z, completed, conclusion **success**; workflow checks out pinned three.js `148ef33e` and runs `node --test` on the numeric/adapter/bundle suites; **assessor independently reproduced 61/61 green locally** | [Verified — CI-observed + executed by analyst, High] |
| 7 | Rollup plugin + CLI `--specialize-numeric` package apps with the kernel branch | partially demonstrated (CLI executes with full option surface; no end-to-end rendered app verified by assessor) | `cli.mjs --help` executed by the assessor: options `--entry`, `--build-app`, `--specialize-numeric`, `--build-kernel`, `--build-animation`, `--animation-webgpu`, `--pack-html` all present; `animation_cli.test.mjs`, `pack_html_cli.test.mjs`, `marching_cubes_bundle.test.mjs` exist (bundle suite executed 38/38 by assessor) | [Verified — executed by analyst, Medium] |
| 8 | JS surface: ~149,128 lines of `.mjs/.js` under `tools/`+`tests/`; `tools/ingest` = 254 files, 27 `.md` design/test docs | demonstrated | `find tools tests \( -name '*.mjs' -o -name '*.js' \)` (excl. node_modules) piped to `wc -l`; `ls tools/ingest` counts | [Counted, High] |
| 9 | Upstream oracle pinned: three.js r186 source commit `148ef33ecb6d2502ff796d4554abd1549c95d519`, tag object `819fadd6b663b74d828c6af72a543024f74d3877` (per `upstream/PIN.md`) | demonstrated (metadata; the `upstream/three.js` checkout itself is absent from the shallow clone — gitignored) | `upstream/PIN.md` read; CI checks out the same commit from `mrdoob/three.js` as oracle | [Code-verified, High on metadata; checkout presence unverified] |
| 10 | asupersync `=0.5.0` registry pin replaces the developer path dependency in `f3d-runtime` | demonstrated (manifest) | `crates/f3d-runtime/Cargo.toml:28` `asupersync = { version = "=0.5.0", default-features = false }`; README honest-status row states the browser-probe results *predate* this pin and require a fresh browser run | [Code-verified, High] |
| 11 | Rust programs execute through the Asupersync browser host (eight probes: timer wakeups, oneshot join, 1000 host turns, reentry rejection, 10k self-wakes, cancellation, region drain, fetch abort with server-observed disconnect) in HeadlessChrome 152 and Safari 26.5 | partially demonstrated | README honest-status table + dated commit pages; assessor did not run browsers; fresh-run-against-`0.5.0` is a maintainer-flagged open item | [Maintainer claim, Medium] |
| 12 | Zero speedup measured anywhere | demonstrated | README L41: "**zero speedup has been measured**"; `MARCHING_CUBES_SPECIALIZATION.md` L74: "A compiled addon is not a measured acceleration" | [Maintainer claim, High] |
| 13 | 2×/3× headline gates (2× median paired completed-frame throughput per cell; 3× stratum geomean; paired 95% lower bounds) are targets, not results | aspirational | README L408–410, L456, L600: "**Will it hit 3×?** Unknown. Nothing has been measured." | [Maintainer claim, High] |
| 14 | Plan with kill gates (§16.7), 11-crate budget (245k Rust ceiling), H1–H8 headline corpus, no-cut rule, four-promise separation | demonstrated (document exists; gates not yet exercised) | `COMPREHENSIVE_PLAN_FOR_THE_DESIGN_OF_FRANKENTHREED.md` (1,835 lines v2.0); 219 bead records in `.beads/issues.jsonl` | [Code-verified + Counted, High] |
| 15 | README honest-status says "Is there a compiler, renderer, or CLI? **No**" and lists 2 crates | stale (contradicted by the tree) | README table read at pin vs. `numeric_kernel.mjs` + `cli.mjs` + 4-crate `Cargo.toml` | [Verified, High] |
| 16 | AGENTS.md L17: "FrankenThreeD currently has **zero implementation**" | stale (contradicted by the tree) | Line read at pin; tree holds 68k Rust + 149k JS lines with green CI | [Verified, High] |
| 17 | License: MIT + OpenAI/Anthropic rider; rider denies all rights to OpenAI, Anthropic, affiliates, and anyone acting for them; covers use/benchmarking/analyzing/training; breach = automatic termination; must propagate unmodified to derivatives | demonstrated | `LICENSE` read verbatim at pin (full text captured in §4.8) | [Code-verified, High] |
| 18 | No tags, no releases; 5 stars, 1 fork; single human author; 380 commits 2026-09-09 → 2026-09-22 | demonstrated | `git for-each-ref refs/tags` empty; GitHub API (`stargazers_count: 5`, `forks_count: 1`); `git rev-list --count HEAD` = 380; all authors "Jeff Emanuel" | [Git-observed + External, High] |
| 19 | AI-agent-assisted development: `Claude-Session:` links and named agent personas (NavyAspen, RubyCrane, BlueBison, GrayFox…) in commit bodies; zero `Co-Authored-By` trailers in sampled history | demonstrated (the assistance; the scale of per-agent contribution is not machine-readable) | `git log --format=%B` greps; example search-result commit bodies | [Git-observed, High on presence; Inference, Medium on scale] |
| 20 | Dependency admission ledger with dated remote-compile evidence and 245k-line budget accounting | demonstrated | `DEPENDENCY_ADMISSION.md` read (RCH compile logs, pinned exact versions, per-crate budget consumption, e.g. asupersync row with wasm32 build log references) | [Code-verified, High] |
| 21 | Compiler's own unit suites: 76/79 pass at the pin; the 3 failures are stale refusal-contract/error-text tests, not miscompilations — and these suites are **not** run by CI | demonstrated | Assessor executed `numeric_kernel{,_build,_runtime,_control}.test.mjs`: the `x[i]++` refusal test fails because the compiler legitimately grew `UpdateExpression` support (assessor differentially verified the compiled `x[i]++` matches JS exactly: `[2.5, -1.25, 1]`); the CLI test failure is an error-message-text mismatch. The CI workflow gates only the 3 marching-cubes suites (61/61 green), so the project's gate covers the exemplar, not the compiler's full contract | [Verified — executed by analyst, High] |

**What the inventory says in aggregate:** claims about the *numeric-specialization slice* verify at High confidence — the assessor independently re-executed the CI-gated suites (61/61 green) and the compiler's own unit suites (76/79, with the 3 failures characterized as stale tests, claim 21). Claims about *outcomes* (speedups, the full application pipeline) are explicitly disavowed or unmeasured by the maintainer. Two drift findings compound: the public status pages (README table, AGENTS.md, the "plan-stage" badge) describe a ~10-day-older project, and the compiler's refusal-contract tests lag the compiler itself (claim 21) — while CI gates only the marching-cubes exemplar, not the compiler's full contract. Staleness is the governance signal, per Rulebook §0.4.

---

## 4.4 Codebase tour

**Rust topology (4 members, [Counted, High]):** `f3d-core` (IDs, layouts, capability records, evidence schema writer behind `test-support` feature), `f3d-math` (JS-numeric-semantics differential testing: `jsnum_differential_tests.rs`, `transcendental_differential_tests.rs`, `batch_compose_simd_tests.rs`), `f3d-graph` (render-pass/schedule skeleton: `plan.rs`, `pass.rs`, `hazard.rs`, `schedule.rs`, `canvas.rs`, `resource.rs` + a `CONTRACT.md` that documents the planned 11-crate dependency direction — `core <- math <- scene … compiler/runtime <- cli` — confirming the 7 unwritten crates are load-bearing in the design, not optional), `f3d-runtime` (Asupersync browser-host probes: `probe.rs`, `gpu_host.rs`, `burst.rs`, `frame.rs`). 68,108 lines, 75 files, zero `unsafe` occurrences [Counted, High]. The remaining 7 planned crates (`f3d-scene`, `f3d-assets`, `f3d-shader`, `f3d-compiler`, `f3d-gpu`, `f3d-cli`, `f3d-conformance`) are still absent — the specialization intelligence lives in JS, not in the missing `f3d-compiler` crate.

**JS topology (`tools/` + `tests/`, ~149k lines [Counted, High]):** `tools/ingest/` is the specializer (254 entries): the numeric compiler stack (`numeric_kernel.mjs` 779 lines — Acorn parse → Wasm emit; `numeric_kernel_build.mjs` 265; `numeric_kernel_runtime.mjs` 536 — ownership/shape guards, fallback semantics; `numeric_integer.mjs`, `numeric_intrinsics.mjs`, `numeric_helpers.mjs` — Math intrinsics and bitwise lowering), the marching-cubes exemplar (`marching_cubes_numeric.mjs` clean-room closed body, `_compile.mjs`, `_adapter.mjs`, `_rollup.mjs`, `_specialization.mjs`), the CLI (`cli.mjs`, `--specialize-numeric` opt-in, `buildApplication`/`bundleWithRollup`), and the animation/gltf ingestion suites (27 `.md` design docs: `ANIMATION_*`, `GLTF_*`, `MARCHING_CUBES*`). `tools/compat/` and `tools/compat-facade/` hold adapter/dev-server/portable-package machinery. `tests/e2e/` holds browser fixtures (`foundation`, `bridge`, `h1`, `animation_webgpu`, `animation_render`); `tests/fixtures/` holds the oracle and GPU-bridge fixtures.

**Dependency posture:** Rust side is minimal — `asupersync =0.5.0` (registry, exact), `serde`/`serde_json` pinned (diagnostic use), wasm-bindgen/js-sys/web-sys via the asupersync lockfile; `naga` absent (deferred) [Code-verified, High]. JS side: `acorn` pinned to exactly `8.14.0` in `tools/package.json`+lockfile (the compiler's parser — a pinned parser is load-bearing for reproducible compilation) [Code-verified, High]; `puppeteer` ^25 for browser fixtures, `rollup` for the application pipeline (per docs) — full `package.json` audit not performed [Code-verified, Medium].

**Data flow, end to end (the demonstrated slice):** app entry → `cli.mjs --specialize-numeric` → rollup pipeline with `marchingCubesRollupPlugin()` → the plugin recognizes the exact pinned r186 `MarchingCubes` addon and emits a branch around the numerical prefix of its `update` → the compiled kernel (`compileMarchingCubesKernel()`, import-free Wasm from the Acorn compiler) executes the triangulate body → runtime guards (`numeric_kernel_runtime.mjs`) verify ownership/shape and fall back to original JS on aliases, accessors, or unsupported storage → outputs published; "once the numerical outputs have been published, there is no fallback replay"; capacity/bounds/fuel failures abort private execution before publish and run the complete original prefix [Code-verified, Medium — docs + source heads read; the full pipeline was not executed by the assessor].

**The admitted shape** (what the compiler accepts, i.e., the closure contract): scalar setup/state, ordered counted loops, arithmetic and fixed-stride Float32Array/Float64Array updates incl. conditionals, scalar accumulators, closed scalar helpers, explicit modulo-2^32 bitwise lowering, f64 intermediates with Float32 stores in source order. No host calls, no escapes, no implicit conversions, no reassociation [Code-verified, High — `numeric_kernel.mjs` header].

---

## 4.5 The maintainer's stated case

**The pitch, in the maintainer's own structure:**

1. **Specialization, not translation:** recover information across library boundaries at build time; turn thousands of fine-grained property writes into one contiguous update kernel, legally versioned bulk uploads, and a persistent GPU schedule. "The most important optimization is removing a question from the frame loop." [Maintainer claim, Medium]
2. **Honesty as a design constraint:** the Amdahl-style gate math (3× requires removing ~2/3 of the relevant critical path before new overhead), paired-measurement discipline, strong references, real devices, and kill gates that can stop the project early. "**Will it hit 3×?** Unknown. Nothing has been measured." [Maintainer claim, High]
3. **Compatibility without cuts:** the no-cut rule — sequencing allowed, permanent omission forbidden — plus the four separately-tracked promises (API compatibility, application equivalence, accelerated coverage, measured performance) so compatibility can't quietly shrink while speedups are claimed. [Maintainer claim, Medium]
4. **Evidence machinery from day one:** dependency admission ledger with remote-compile logs, JSON-lines test-evidence schema, upstream pin reconciliation (`reconcile.json`: three@0.186.0, 9 exports, 1,778 resolved mappings, 1,263 packaged files, 0 missing), line-budget accounting against the 245k ceiling. [Code-verified, High on existence]

**The disavowals — quoted and located:** README: "**zero speedup has been measured**"; MARCHING_CUBES_SPECIALIZATION.md: "A compiled addon is not a measured acceleration"; the same doc: "No mesh welding, normal normalization, new topology or speedup is implied."; `numeric_kernel.mjs`: "This narrow opt-in ABI is not proof of whole-application closure or a speedup claim." Any downstream citation presenting the marching-cubes kernel as a performance result is misrepresenting the source [Maintainer claim, High — the disavowals are in the pinned tree].

**Benchmark reproduction cost:** there is nothing performance-wise to reproduce — no benchmark exists. The nearest reproducible artifact is the marching-cubes differential suite, and the assessor reproduced it: `git clone` (sparse) + `npm ci --ignore-scripts` + `F3D_THREE_ROOT=… node --test` on the three suites — 61/61 green in ~21 s on Node v24, measured 2026-09-22 [Verified — executed by analyst, High]. The 2×/3× gates would require the H1–H8 headline app corpus, physical M5/iPhone hardware, and the deferred conformance harness — a multi-week reproduction at minimum [Inference, Medium].

---

## 4.6 Competitors

- **three.js itself (r186, mrdoob):** the incumbent and the oracle — the de facto standard web-3D library, MIT licensed, the pinned compatibility target. It wins today on every axis except the one franken_threed is trying to create: it has no specialization story and no incentive to build one (its generality *is* the product) [External, High on identity; Inference, Medium on incentives]. The project's strategy of specializing *around* upstream rather than replacing it means three.js's continued stability is a dependency, not just a competitor.
- **Hand-rolled optimization / engine forks:** the status quo for performance-critical three.js apps is manual optimization (instancing, merged geometry, custom shaders) or engine forks. This is the "do nothing / do it by hand" lane that owns 100% of current practice [Inference, Medium].
- **Adjacent AOT/whole-program optimizers:** Closure Compiler's advanced mode, AssemblyScript, and the broader "compile the hot loop" tradition (e.g., V8's own JIT, which already optimizes tight numeric JS loops aggressively — the bar the Wasm kernels must beat is not the interpreter, it's TurboFan) [External, Medium]. V8's JIT is the unspoken competitor in every "JS→Wasm speedup" claim: a closed numeric loop is exactly what modern JITs already handle well, which compresses the headroom the 2×/3× gates need [Inference, Medium — load-bearing for the thesis].
- **Rust WebGPU engines (wgpu, bevy):** the "rewrite in Rust" lane. The maintainer's dependency admission policy explicitly excludes Bevy and the generic wgpu stack from the execution core [Maintainer claim, High]. These compete for the "memory-safe GPU" mindshare but not for three.js compatibility.
- **The closest analog — Unity's Burst compiler:** Burst compiles C# job code to optimized native with safety checks, inside an engine that owns the whole stack. franken_threed's bet is Burst-like specialization *without* owning the stack — specializing around an upstream JS library it does not control, with fallback guards instead of engine integration. Nobody has shipped that combination for a retained-mode JS 3D API [Inference, Medium].
- **Unoccupied lane:** a *compatibility-preserving* application specializer for a retained-mode JS 3D API — closed-loop detection + verified kernel compilation + fallback guards, with the upstream library untouched — has no direct occupant. A 2026-09-22 web search for independent coverage of franken_threed returned only the repository and its own commit pages — no competitor, reviewer, or downstream user surfaced [External, High within recall caveats]. Optimizers either rewrite the app (breaking compat) or JIT at runtime (no build-time guarantees); nobody ships build-time specialization with differential oracle parity as the admission ticket [Inference, Medium].

---

## 4.7 Skeptic's take

*Weaknesses are numbered 1–8; elsewhere "§4.7.N" means weakness N.*

1. **[FATAL] Zero measured performance against 2×/3× gates, 380 commits in.** The entire thesis is a speedup claim; the measured speedup is zero by the maintainer's own admission, and the MarchingCubes doc explicitly refuses to imply one. A compiler that compiles is not a specializer that accelerates — the distance between "Wasm executes correctly" and "frames complete faster on a phone" contains guards, dispatch, invalidation, and the JIT it competes with (§4.6). Until a frame-time number exists, the project is a compatibility-verification apparatus with an optimization hypothesis [Inference, High].
2. **[HIGH] The status pages are stale and the project knows what honesty requires.** The README honest-status table ("no compiler, renderer, or CLI", 2 crates), the "plan-stage · no implementation" badge, and AGENTS.md L17 ("zero implementation") all describe a project 10+ days and ~280 commits older than the pin. The drift has a second instance *inside* the safety contract: the compiler's own refusal tests still demand rejection of `x[i]++`, which the compiler legitimately learned to compile — the test suite disagrees with the compiler it guards (claim 21) — and CI gates only the marching-cubes exemplar, not the compiler's full contract. For a project whose pitch *is* auditability, drift in the honesty machinery itself is not a cosmetic issue. The maintainer fixed this class of problem before (the disavowals are exemplary); the fix here is the machine-checked status table proposed in next-step 3 [Verified, High on the drift; Inference, Medium on the fix].
3. **[HIGH] Bus factor 1 with opaque agent provenance.** One human author, no second committer, no CONTRIBUTING, no succession. The velocity (~29 commits/day) is only possible because of AI-agent assistance (Claude-Session links, named agent personas in commit bodies) — but with zero Co-Authored-By trailers, an outside reviewer cannot determine which artifacts an agent produced, which were human-reviewed, or what the review gates were. A 217k-line codebase where provenance is prose in commit bodies is unauditable at exactly the point the project claims auditability as its virtue [Git-observed, High on the facts; Inference, Medium on the consequence].
4. **[MEDIUM] The license rider poisons the likeliest validators.** Barring OpenAI/Anthropic, affiliates, and anyone acting for them from *use, benchmarking, analyzing, and training-data incorporation* doesn't just block two companies — "analyzing" arguably covers independent technical due diligence of exactly this kind, and the "acting directly or indirectly for … or for the benefit of" prong creates uncertainty for any contributor near the AI supply chain. The entities best equipped to evaluate a JS→Wasm compiler are substantially the entities named in the rider [Code-verified, High on the text; Inference, Medium on the consequence]. See §4.8 for the full scope.
5. **[MEDIUM] The clean-room body is hand-transcribed, not extracted.** `triangulateMarchingCubes` is the project's own "closed numeric body" *of* the upstream triangulation — authored to match upstream semantics and then proven equivalent by differential testing, not extracted from the upstream source. That is honest (the docs say so), but it means each specialized kernel begins with a manual transcription step whose fidelity rests entirely on the differential harness's input-class coverage. The 2,048-case sweep is strong for MarchingCubes; the open question is whether "full input class" stays definable for messier loops (animation, skinning, culling) [Code-verified, High on the mechanism; Inference, Medium on the generalization risk].
6. **[MEDIUM] Scope ambition vs. the no-cut rule.** Full r186 surface with zero permanent cuts (WebXR, editors, physics wrappers, all loaders/exporters, devtools) against a 245k-line Rust ceiling and 7 of 11 crates unwritten. The specialization strategy mitigates this (specialize around upstream rather than reimplement), but the four promises still require the *application equivalence* surface to hold for every app the specializer accepts — and the guard/fallback machinery that makes that safe is itself a large, unbuilt system [Inference, Medium].
7. **[MEDIUM] The asupersync fresh-run open item.** The README self-flags that the browser-probe evidence predates the published `=0.5.0` pin. The one demonstrated browser-execution pillar rests on a dependency revision the probes never ran against. Either the probes re-run or the claim is stale — the project has said so itself [Maintainer claim, High].
8. **[LOW–MEDIUM] Budget realism.** ~68k of 245k Rust lines consumed before any of the compiler/GPU/scene/shader crates exist; the JS side (~149k lines) is unbudgeted by the Rust ceiling by design, but it is where the actual specializer lives — the budget governs the smaller half of the system. If the "real" specializer stays in JS, the 245k ceiling is governing the wrong artifact [Counted, High on the counts; Inference, Medium on the implication].

**Bear-case steelman (strongest counter-case):** franken_threed is a documentation-led performance of rigor around an unmeasured hypothesis. The one green slice — MarchingCubes numeric specialization — is the easiest possible target: a closed, side-effect-free numeric loop with no aliasing, no scene graph, no GPU interaction, exactly the shape V8's JIT already optimizes well, so even a correct Wasm kernel may measure *slower* once guard and dispatch overhead are included (the maintainer's own "compiled ≠ acceleration" concedes this). The 380-commit velocity is agent-driven output whose provenance no one can audit; the status pages already misdescribe the project's state (claiming "no compiler" while one executes in CI); the license bars the only evaluators who could independently verify the compiler; and the 2×/3× gates sit on the far side of a WebGPU renderer, a scene crate, and a conformance harness that do not exist. The rational market response is to admire the evidence machinery, mine the differential-harness pattern, and never depend on the specializer. Its most likely end state is a graceful kill-gate firing — which the plan explicitly provides for — leaving behind a methodology worth copying and a compiler worth forking under a saner license. [Inference, Medium — deliberately uncharitable; the counter-evidence is the green-at-pin CI and the maintainer's track record of writing the disavowals himself.]

---

## 4.8 Maintenance & succession

**Bus factor: 1.** All 380 commits authored by Jeff Emanuel [Git-observed, High]. No second committer, no CONTRIBUTING, no governance docs, no succession plan, no release artifact to fork from [Verified, High — absence across the assessed materials]. Commit velocity is ~29/day over the 13-day window — sustainable only via the agent-assisted operation evidenced in commit bodies; if the operator stops, the project freezes [Inference, High].

**License — read verbatim, classified honestly.** MIT License with OpenAI/Anthropic rider. The rider's exact scope (quoted):

> "Restricted Parties" means OpenAI, L.L.C.; Anthropic, PBC; any of their respective Affiliates; and any person or entity acting directly or indirectly on behalf of, for the benefit of, or under the direction of any of the foregoing (including any officer, director, employee, contractor, agent, consultant, service provider, or representative).
>
> Notwithstanding any other provision of this License, no rights are granted to any Restricted Party. […] You may not provide, disclose, distribute, sublicense, sell, lease, lend, host, make available, or otherwise permit access to the Software or any derivative work […] to or for any Restricted Party.
>
> For purposes of this rider, "use" includes, without limitation: copying, modifying, merging, publishing, distributing, sublicensing, selling, transferring, making available, hosting, deploying, executing, **benchmarking, testing, analyzing, indexing**, or incorporating the Software or any Derivative Works into any dataset, training corpus, evaluation harness, or pipeline for machine learning or other automated systems.
>
> This rider applies to the Software and all Derivative Works. […] any distribution of the Software or any Derivative Works must include this rider provision unmodified. Any breach of this rider automatically and immediately terminates the permissions granted by this License.

**Classification: non-OSI, non-OSD.** It discriminates against named persons/groups and fields of endeavor. This is an adoption ceiling, not a footnote: it excludes the two AI labs and their supply chains from *evaluating* the code, blocks enterprise users with lab partnerships, and — as strategy (§Q6) — selects for adopters who cannot deeply evaluate what they adopt. The README badge discloses "MIT + AI rider" on the same page (shorthand, not concealment) [Code-verified, High].

**Provenance footnote:** no `Co-Authored-By` trailers in the sampled history (0 in 100+ commit bodies grepped); AI assistance is evidenced instead by `Claude-Session:` URLs and named agent personas (NavyAspen, RubyCrane, BlueBison, GrayFox, CobaltOrchid…) in commit bodies. The clean-room status of the transcribed numeric bodies therefore rests on the differential harness, not on a documented human-only authorship chain [Git-observed, High on the facts; Inference, Medium on the implication].

---

## 4.9 NODUS factsheet

| Criterion | Score | One-line justification |
|---|---|---|
| Technology readiness (TRL 1–9) | **3–4** | TRL 4 for the numeric-kernel slice (Wasm compiled from JS executes in CI against the live upstream oracle, green at pin); TRL 2–3 for the application specializer as a whole (no renderer, no end-to-end app, zero measured frames) |
| Strategic relevance (1–5) | **3** | If it worked: memory-safe, build-time-specialized web-3D with full three.js compatibility — strategically interesting for performance-per-watt and embedded/regulated contexts; the *category* (specialize-around-upstream) is under-explored |
| Impact potential (1–5) | **2** (4 conditional) | A verified 2–3× three.js pipeline would be genuinely valuable; unmeasured, and the V8-JIT headroom question (§4.6) makes the conditional distant |
| Implementation feasibility (1–5) | **2** | The compiler slice demonstrates the mechanism; but 7 of 11 crates unwritten, the no-cut full-surface scope, bus factor 1, and zero measured frames bound the score |
| Time to mainstream (1–5) | **1** | Years minimum; currently no renderer, no end-to-end specialized app, no measured speedup |
| Collaboration potential (1–5) | **2** | Rider excludes major labs and their supply chains; no CONTRIBUTING, no second maintainer; agent-authored provenance is opaque to outside reviewers |

**Ring: Explore** [Inference, Medium]. Substantive-but-unproven is the textbook Explore case: a real compiler, real differential parity, green CI at the pin — more than plan-stage, far less than a pilotable artifact. Ring down, not up: no release, no measured workload, no independent validation. Advancement to Pilot would require a measured end-to-end frame-time win on a real app plus a bounded workload fit; advancement to Invest would additionally require governance (second maintainer) and rider removal.

---

## 4.10 Wardley placement

- **Browser 3D rendering (three.js r186):** Commodity — the pinned oracle, de facto standard library [External, High].
- **JS→Wasm numeric compilation (Acorn→Wasm emitters):** Product — the technique exists (AssemblyScript, Emscripten, V8 itself); the project's hand-rolled 779-line emitter is custom-built [Inference, Medium].
- **Compatibility-preserving application specialization with differential oracle parity as the admission gate:** **Genesis** — no known equivalent; the novel claim [Inference, Medium].
- **Evidence machinery (admission ledgers, JSON-lines test-evidence schema, pin reconciliation, honest-status discipline):** Custom-built — novel as a *discipline* in this domain; the FrankenSuite method's reusable export [Inference, Medium].

**The decoupling lens (Rulebook §6):** this project advances the decoupling of *optimization from the library* — historically you either accepted the library's generality or forked/rewrote it; the specializer proposes a third position where the library stays untouched and closed behavior is extracted at build time with a fallback guard. The adjacent decoupling it depends on is *compile time from run time* for dynamic-language hot loops: the Wasm kernels are only valid because the guards re-check the closed-world assumption on every entry. If the guards ever get looser than the compiler's admitted shape, the decoupling collapses into unsoundness — which is why the stale refusal test (claim 21) matters more than its 3-failure count suggests [Inference, Medium].

What moves each: the specializer moves toward Product when a second kernel from a different loop class (animation/skinning, not numerics) passes the same differential gate; the emitter moves toward Commodity if the project adopts an existing toolchain; the evidence machinery moves toward Product the day a sibling repo imports the pattern.

---

## 4.11 Trajectory (12 / 24 / 60 months) **[Inference, Low–Medium confidence]**

- **12 months — binary.** Either the first end-to-end frame-time measurement lands (a specialized H1-corpus app measured in a real browser against upstream three.js — whatever the number, including a sub-1× result published honestly) and the second kernel class (beyond closed numerics) passes the differential gate — or a kill gate fires (§16.7) and the project shelves cleanly with its methodology intact. The base case is binary because the honesty constraint forces it: the project cannot drift into vague progress claims; it must measure or stop.
- **24 months — if alive:** conformance-harness construction dominates; the no-cut rule's full-surface equivalence for accepted apps is the long pole. Earliest plausible state: a scoped specialization path (closed numeric + animation loops) with measured, bounded speedups on a fixed app corpus — or drift to Monitor as a research artifact if velocity decays.
- **60 months — if alive:** either a niche production artifact (specialized builds for closed, performance-critical three.js apps — configurators, kiosks, embedded) or absorption: the differential-harness + admission-ledger methodology outlives the specializer and is the thing other projects copy. If the kill gates fired: the methodology is the survivor regardless — it already is the most exportable part of the tree.

**Revisit triggers (concrete, observable):** first measured frame-time number (any sign) on a real device; a second kernel class passing the differential gate; any kill-gate bead recording a PASS/FAIL decision (all 12 are open at the pin); a tagged release; a second maintainer or CONTRIBUTING; the asupersync fresh browser run landing (or the row being removed); independent coverage (third-party benchmark, fork with activity, or published review).

---

## 4.12 Limitations and open questions

**Not done by the assessor:** no Rust toolchain installed; nothing in `crates/` compiled; no browser ran; no benchmark reproduced; no end-to-end specialized app was built or rendered; the full `package.json` dependency surface was not audited; license enforceability was not legally analyzed; the `.beads` issue graph was sampled, not fully read. (The marching-cubes differential suite *was* executed: 61/61 pass — see Method.)

**Open questions that would most change the verdict:**
1. Does the specialized MarchingCubes path actually render correctly in a real browser end-to-end (not just in `node --test`)? A headless-Chrome pixel-comparison run would move claims 5–7 from lab to relevant environment.
2. What is the measured frame-time delta of the specialized vs. upstream path — the 0× baseline (next-step 1)? This single number is the load-bearing experiment for the entire thesis.
3. Can the differential-gate pattern transfer to a non-numeric loop class (animation, skinning)? This decides whether MarchingCubes is an exemplar or a curiosity.
4. Will the maintainer machine-check the honest-status table, or does status drift continue as velocity compounds?
5. Which artifacts did agents vs. the human produce, and what were the review gates? (Provenance — deepening question 1.)

---

## The eight deepening questions

**1. Provenance.** The system records agent involvement in prose: `Claude-Session:` URLs and named agent personas (NavyAspen, RubyCrane, BlueBison…) in commit bodies, plus dated evidence logs (RCH compile runs, browser probe runs) and the bead graph. What it does *not* record is machine-readable per-artifact provenance: no `Co-Authored-By` trailers, no signed attestation of which agent produced which file under which review lane. Making attestation portable would require a per-commit (or per-file) signed ledger binding artifact hash → agent id + session → evidence produced → human review gate — essentially the test-evidence schema extended from test events to authorship events. Without it, the 380-commit corpus is fast but unauditable, and the "clean-room" character of transcribed numeric bodies rests solely on differential testing rather than on a documented chain of custody. [Code-verified on the prose evidence; Inference, Medium on the fix.]

**2. The embeddable unit.** The smallest useful adoptable piece is the numeric-kernel stack (`numeric_kernel.mjs` + `numeric_kernel_runtime.mjs` + the differential harness pattern): a JS→Wasm compiler for closed numeric bodies with oracle-parity testing, adoptable without the Rust workspace, the rollup pipeline, or the browser host. Adoption cost: Node 22, Acorn, and the discipline of writing closed bodies plus full-input-class differential tests — the compiler is 779 lines but the *method* (closure contract + guards + fallback) is the real dependency. A three.js-adjacent project could lift the MarchingCubes exemplar as a template for its own hot loop in days. [Inference, Medium.]

**3. Unexercised option value.** The architecture holds several unused capabilities: the `f3d-math` differential-testing infrastructure (JS-numeric parity machinery) could back a broader "numeric contract" for any JS→Wasm project; the evidence schema (`docs/test-evidence.md`, JSON-lines events with lanes/severity/owner) is a general test-observability substrate currently used only internally; the Asupersync browser host (real Rust executing in Chrome/Safari) is an unexploited deployment target for the compiled kernels — the Wasm runs in Node today but could run in the project's own browser runtime; and the bead graph (212 beads, 432 deps) is a planning artifact that could become a machine-readable roadmap API. What unlocks each: a second consumer — none exists yet. [Inference, Medium.]

**4. Benchmark honesty.** There are no benchmark numbers to audit — the honest answer is that every number that matters is missing, and the project says so itself ("zero speedup has been measured"; "a compiled addon is not a measured acceleration"). The load-bearing numbers for the thesis are the *future* 2×/3× gate measurements, which do not exist. What *would* survive an independent rerun today: the differential-parity results (deterministic, CI-green, oracle-pinned — rerunnable by anyone with Node 22). The packet's benchmark table is therefore inverted from the usual: the verified numbers are correctness numbers, and the performance numbers are explicitly aspirational. [Verified, High.]

**5. The governance path.** The credible route from one maintainer to an institution runs through the honesty machinery, not the code: the admission ledger, evidence schema, and differential gates are the artifacts an institution could adopt without trusting the velocity. The kill gates are not just plan prose — they are first-class beads with explicit PASS/FAIL decision records (`f3d-gate-1-foundation-tzn`, `f3d-gate-2-bridge-apz` whose criterion is literally "the selected Wasm/host bridge shows an advantage", `f3d-gate-4-generalization-5hm`, plus decision-record beads for gates 3 and 5) — but all 12 kill-gate beads are still **open** [Counted, High], so the gates have never been exercised. What breaks first if velocity decays: the status pages (already stale after 13 days — the canary), then the bead graph (planning debt compounds fastest), then the upstream pin (r186 ages; each three.js release is a deliberate compatibility event the project must absorb). The AGENTS.md staleness is a negative signal about whether the gates would actually fire when their criteria fail. [Inference, Medium.]

**6. The license as strategy.** The rider excludes OpenAI, Anthropic, their affiliates, and anyone acting for them — from use, benchmarking, testing, analyzing, indexing, and training-data incorporation, with automatic termination on breach and mandatory propagation to derivatives. As strategy, the exclusion is aimed at preventing the largest AI labs from absorbing the work into models or products without permission — a coherent defensive goal for a solo maintainer. It sabotages the stated mission (a compatibility-preserving specializer needs the widest possible evaluation and adoption to prove its gates) by barring the entities best equipped to evaluate a JS→Wasm compiler, chilling enterprise adoption, and — the sharpest irony — sitting atop a codebase substantially produced with Claude's assistance (Claude-Session links in commit bodies), i.e., built with the help of a named Restricted Party's tooling. The rider protects the work from the labs at the cost of the work's evaluability. [Code-verified on the text; Inference, Medium on the strategy assessment.]

**7. Agent-era fit.** The concrete agent workload that would pick this over three.js: an agent generating closed, performance-critical 3D content (procedural configurators, data-viz scenes, synthetic training environments) that needs deterministic, fast frame loops on weak devices and can tolerate the specialization constraints (closed loops, pinned r186, opt-in per kernel). What has to become true first: a measured speedup (the agent has no reason to accept constraints for 1.0×), an API for requesting specialization of *agent-authored* loops (not just upstream addons), and provenance attestation so the agent's operator can audit what the specializer changed. Today the fit is aspirational; the irony is that the project is already agent-*built* but not yet agent-*usable*. [Inference, Medium.]

**8. The kill test.** The single experiment that falsifies the core thesis: specialize the MarchingCubes exemplar end-to-end, measure completed-frame throughput in headless Chrome against upstream three.js on the pinned hardware class, and find the specialized build *slower or equal* after guard/dispatch/invalidation overhead — with the differential harness confirming correctness. A sub-1× measured result on the easiest possible target (closed numeric loop, no aliasing) would show the "remove questions from the frame loop" strategy cannot clear its own overhead bar where it should be strongest, and the plan's own kill gates should then fire. Conversely, a measured >1× on this target is the minimum viable confirmation the thesis deserves its next 100 commits. [Inference, High — this is the experiment the project's own honesty constraint demands.]

---

## Packet changelog

- **v7 (2026-09-22):** round-5 grading pass — Rulebook §6 cross-cutting lenses made explicit (decoupling lens paragraph in §4.10: optimization decoupled from the library, compile time from run time, and why the stale refusal test threatens the decoupling); Wardley placements tiered.
- **v6 (2026-09-22):** round-4 grading pass — CLI `--help` executed (full option surface verified); compiler's own unit suites executed (76/79; 3 failures characterized as stale refusal-contract/error-text tests, with a differential check proving the `x[i]++` compilation correct); new claim 21 documents that CI gates only the exemplar, not the compiler's full contract; drift finding extended into the safety contract itself (§4.7.2).
- **v5 (2026-09-22):** round-3 grading pass — **assessor independently executed the marching-cubes CI trio: 61/61 tests pass locally** (oracle blob SHA-1 verified before use); claims 4/5/6 upgraded to Verified-executed; reproduction cost measured (~21 s on Node v24).
- **v4 (2026-09-22):** round-2 grading pass — kill-gate beads verified (12 records, all open; gate 2's criterion is "the selected Wasm/host bridge shows an advantage"); velocity concentration (12 commits in the 11h between pins); f3d-graph CONTRACT.md confirms the 7 unwritten crates are load-bearing; steelman tone corrected ("misdescribe" not "lie"); revisit triggers sharpened (kill-gate PASS/FAIL decisions).
- **v3 (2026-09-22):** round-1 grading pass — hook tiered per-clause; cold-reader glossary (bead/RCH/H1–H8); JS impl/test split counted (68k impl / 81k test; Rust 34% tests); acorn 8.14.0 pin verified; Unity Burst added as closest analog with explicit no-direct-competitor search statement; next-step 2 given a falsification condition; README line refs pinned (L41/L408/L456/L600).
- **v2 (2026-09-22):** full rewrite from fresh pin `72dcaa1` — the v1 draft (pin `5361efa`, ~11h older) described a plan-stage project with no compiler; the new HEAD contains a working Acorn→Wasm numeric compiler, rollup/CLI specialization pipeline, and green-at-pin marching-cubes CI. Claim inventory expanded to 20 entries; README/AGENTS.md staleness documented as a governance finding; ring moved Monitor → Explore on the strength of CI-green differential parity. All quick links re-verified (HTTP 200).
- **v1 (2026-09-22):** initial draft at pin `5361efa` — accurate for its pin but overtaken within hours; retained as starting point only.

*Assessor's staleness warning: this repo moved from "no implementation" to "green CI with a working compiler" in 13 days. Any finding dated 2026-09-22 should be re-pinned before reuse.*