toiljs 0.0.66 → 0.0.68

package/src/devserver/stream/ws.ts

@@ -0,0 +1,76 @@
+/**
+ * Transport adapter that bridges ONE dev WebSocket connection to the {@link StreamDevHost} session
+ * driver. It is the per-socket glue the dev WS endpoint instantiates: socket-open -> `acceptUpgrade`
+ * (close on a `@connect`/gate reject), inbound frame -> `dispatch` (send reply frames back, or close
+ * on a reject/trap close code), socket-close -> `@close` + drop. It owns NO transport itself - the
+ * caller passes a {@link StreamWsTransport} of `send`/`close` callbacks - so it is unit-testable
+ * without a live socket and reusable across whatever WS/WebTransport the endpoint ends up speaking.
+ *
+ * The endpoint that wires hyper-express `app.ws` to this (the URL convention + coexistence with the
+ * Vite-HMR catch-all proxy + a `streamWasmFile` config) is the remaining live-server step; this is the
+ * transport-agnostic core it drives.
+ */
+
+import type { StreamDevHost } from './manager.js';
+
+/** The socket-side primitives this adapter needs: send one binary frame, and close with a code. */
+export interface StreamWsTransport {
+    /** Send one outbound binary frame to the client. */
+    send(frame: Buffer): void;
+    /** Close the connection with a `0x02xx` stream close code. */
+    close(code: number): void;
+}
+
+export class StreamWsSession {
+    private open = false;
+
+    constructor(
+        private readonly host: StreamDevHost,
+        private readonly connId: string,
+        private readonly authority: string,
+        private readonly path: string,
+        private readonly transport: StreamWsTransport,
+    ) {}
+
+    /** Whether the connection is accepted + live. */
+    get isOpen(): boolean {
+        return this.open;
+    }
+
+    /**
+     * Socket open: accept the upgrade (node gate is the endpoint's job; this drives the box). On a
+     * `@connect`/artifact reject the connection is closed with the code and no box is held. Returns
+     * whether the connection was accepted.
+     */
+    onOpen(): boolean {
+        const up = this.host.acceptUpgrade(this.connId, this.authority, this.path);
+        if (up.kind === 'rejected') {
+            this.transport.close(up.code);
+            return false;
+        }
+        this.open = true;
+        return true;
+    }
+
+    /** An inbound binary frame: dispatch it; send the reply frames, or close on a reject/trap code. */
+    onMessage(inbound: Buffer): void {
+        if (!this.open) return;
+        const r = this.host.dispatch(this.connId, inbound);
+        if (r.kind === 'reply') {
+            for (const frame of r.frames) this.transport.send(frame);
+        } else if (r.kind === 'close') {
+            // A guest reject or a TRAP close: close the socket; the socket-close event runs onClose,
+            // which fires @close + drops the box (a no-op if a trap already discarded it).
+            this.open = false;
+            this.transport.close(r.code);
+        }
+        // 'noConnection' cannot occur for a live, accepted session.
+    }
+
+    /** Socket close (client-initiated or after our own close): fire `@close` + drop the box. */
+    onClose(): void {
+        if (!this.open && !this.host.has(this.connId)) return;
+        this.open = false;
+        this.host.close(this.connId);
+    }
+}

package/src/devserver/wasm/surface.ts

@@ -18,9 +18,8 @@
  *   u32 data_coherence_hash
  *   u32 pair_coherence_hash    (exactly THREE u32 after build_id, not four)
  *
- * Fail-closed per Part 5's host rule: an ABSENT section is "legacy single
- * artifact, load as hot" (NOT a hard reject); a PRESENT-but-unparseable section is
- * a corrupt artifact -> do not start that artifact's emulator.
+ * Fail-closed per Part 5's host rule: an absent or unparseable section is a
+ * corrupt Toil artifact -> do not start that artifact's emulator.
  */
 
 import { DataReader } from 'toiljs/io';
@@ -47,16 +46,15 @@ export interface Surface {
     readonly pairCoherenceHash: number;
 }
 
-/** `'absent'` => legacy single artifact (load as hot, no emulators).
- *  `'invalid'` => present but corrupt (fail closed). Otherwise the parsed surface. */
-export function parseSurface(wasm: Buffer): Surface | 'absent' | 'invalid' {
+/** `'invalid'` => absent or corrupt (fail closed). Otherwise the parsed surface. */
+export function parseSurface(wasm: Buffer): Surface | 'invalid' {
     let sec: Buffer | null;
     try {
         sec = customSection(wasm, 'toil.surface');
     } catch {
         return 'invalid'; // garbage section table
     }
-    if (sec === null) return 'absent';
+    if (sec === null) return 'invalid';
 
     const r = new DataReader(sec);
     r.readU16(); // format_version

package/test/built-ssr.test.ts

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { describe, expect, it } from 'vitest';
+
+import { loadBuiltSsrTemplates } from '../src/devserver/production';
+import { assembleSsr, type SsrRoute } from '../src/devserver/ssr';
+
+function slotsManifest(tmplLen: number, hash: Buffer): Buffer {
+    const buf = Buffer.alloc(46 + 8);
+    let o = 0;
+    buf.write('TSLT', o, 'ascii');
+    o += 4;
+    buf.writeUInt16LE(1, o);
+    o += 2;
+    buf.writeUInt16LE(0, o);
+    o += 2;
+    buf.writeUInt32LE(tmplLen, o);
+    o += 4;
+    hash.copy(buf, o);
+    o += 32;
+    buf.writeUInt16LE(1, o);
+    o += 2;
+    buf.writeUInt32LE(1, o); // insert after the first byte
+    o += 4;
+    buf.writeUInt16LE(0, o);
+    o += 2;
+    buf.writeUInt8(0, o); // text
+    o += 1;
+    buf.writeUInt8(0, o);
+    return buf;
+}
+
+function valuesEnvelope(hash: Buffer, value: string): Buffer {
+    const valueBytes = Buffer.from(value);
+    const buf = Buffer.alloc(2 + 32 + 2 + 2 + 2 + 1 + 4 + valueBytes.length);
+    let o = 0;
+    buf.writeUInt16LE(200, o);
+    o += 2;
+    hash.copy(buf, o);
+    o += 32;
+    buf.writeUInt16LE(0, o); // headers
+    o += 2;
+    buf.writeUInt16LE(1, o); // slots
+    o += 2;
+    buf.writeUInt16LE(0, o);
+    o += 2;
+    buf.writeUInt8(0, o);
+    o += 1;
+    buf.writeUInt32LE(valueBytes.length, o);
+    o += 4;
+    valueBytes.copy(buf, o);
+    return buf;
+}
+
+describe('built SSR templates', () => {
+    it('loads the built shell, including production CSS links, from _ssr artifacts', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-built-ssr-'));
+        try {
+            const dir = path.join(root, '_ssr');
+            fs.mkdirSync(dir, { recursive: true });
+            const tmpl = Buffer.from(
+                '<!doctype html><html><head><link rel="stylesheet" href="/css/style.css"></head><body>A</body></html>',
+            );
+            const hash = Buffer.alloc(32, 7);
+            fs.writeFileSync(
+                path.join(dir, 'templates.json'),
+                JSON.stringify([{ route: '/x', name: 'x', hash: hash.toString('hex') }]),
+            );
+            fs.writeFileSync(path.join(dir, 'x.tmpl'), tmpl);
+            fs.writeFileSync(path.join(dir, 'x.slots'), slotsManifest(tmpl.length, hash));
+
+            const templates = loadBuiltSsrTemplates(root);
+            expect(templates).toHaveLength(1);
+            expect(Buffer.from(templates[0]!.tmpl).toString('utf8')).toContain('/css/style.css');
+            expect(Buffer.from(templates[0]!.hash!).equals(hash)).toBe(true);
+            expect(templates[0]!.entries).toEqual([{ id: 0, offset: 1 }]);
+        } finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+
+    it('checks the deployed template hash before splicing production SSR values', () => {
+        const hash = Buffer.alloc(32, 1);
+        const route: SsrRoute = {
+            test: () => true,
+            tmpl: Buffer.from('ab'),
+            entries: [{ id: 0, offset: 1 }],
+            hash,
+        };
+
+        expect(Buffer.from(assembleSsr(route, valuesEnvelope(hash, 'X'))!.html).toString()).toBe(
+            'aXb',
+        );
+        expect(assembleSsr(route, valuesEnvelope(Buffer.alloc(32, 2), 'X'))).toBeNull();
+    });
+});

package/test/daemon-build.test.ts

@@ -9,7 +9,7 @@
  *     passes (one `--targetMode cold`, one `--targetMode hot`) and produces BOTH
  *     `release-hot.wasm` and `release-cold.wasm`; the cold artifact decodes to a
  *     daemon catalog and its `toil.surface` is target_mode = cold.
- *   - a project with only the legacy request surface keeps the single-artifact
+ *   - a project with only the default request surface keeps the single-artifact
  *     path (no cold pass, no cold artifact).
  *
  * The build invokes the LOCAL toilscript (branch feat/streams-phase0-compiler),
@@ -17,7 +17,15 @@
  * `node_modules` the same way the dev build resolves it (`require.resolve`).
  */
 
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import {
+    existsSync,
+    mkdirSync,
+    mkdtempSync,
+    readFileSync,
+    rmSync,
+    symlinkSync,
+    writeFileSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -190,8 +198,8 @@ describe.skipIf(!existsSync(LOCAL_TOILSCRIPT))('buildServer two-pass (daemon pro
         // The cold artifact carries the daemon surface + catalog (decoded byte-for-byte).
         const coldBytes = readFileSync(cold);
         const surface = parseSurface(coldBytes);
-        expect(surface !== 'absent' && surface !== 'invalid' && surface.targetMode).toBe('cold');
-        expect(surface !== 'absent' && surface !== 'invalid' && surface.flags.daemon).toBe(true);
+        expect(surface !== 'invalid' && surface.targetMode).toBe('cold');
+        expect(surface !== 'invalid' && surface.flags.daemon).toBe(true);
 
         const catalog = parseDaemonCatalog(coldBytes);
         expect(catalog).not.toBeNull();
@@ -201,12 +209,12 @@ describe.skipIf(!existsSync(LOCAL_TOILSCRIPT))('buildServer two-pass (daemon pro
         expect(catalog!.tasks[1].schedule.kind).toBe('cron');
 
         // A daemon-only project (no request/stream surface) has no hot files, so the hot pass is
-        // skipped (toilscript would HARD-ERROR a @daemon class under --targetMode hot). The legacy
-        // single-artifact `release.wasm` is therefore not produced for a pure background worker.
+        // skipped (toilscript would HARD-ERROR a @daemon class under --targetMode hot). The default
+        // request artifact `release.wasm` is therefore not produced for a pure background worker.
         expect(existsSync(join(tmp, 'build/server/release.wasm'))).toBe(false);
     }, 60_000);
 
-    it('keeps the single-artifact path for a legacy (no-daemon) project', async () => {
+    it('keeps the single-artifact path for a request-only project', async () => {
         scaffold(LEGACY_SRC, BASE_TOILCONFIG);
         await buildServer(tmp);
 

package/test/daemon-catalog.test.ts

@@ -117,7 +117,13 @@ describe('parseDaemonCatalog (Part 5)', () => {
                 name: 'lateMinute',
                 taskIndex: 0,
                 kind: 1,
-                cron: { minute: minuteMask, hour: 0xffffff, dom: 0xfffffffe, month: 0x1ffe, dow: 0x7f },
+                cron: {
+                    minute: minuteMask,
+                    hour: 0xffffff,
+                    dom: 0xfffffffe,
+                    month: 0x1ffe,
+                    dow: 0x7f,
+                },
             },
         ]);
         const cat = parseDaemonCatalog(wasmWithSection('toildaemon.catalog', payload));
@@ -173,10 +179,11 @@ function buildSurfaceBytes(opts: {
 describe('parseSurface (Part 5)', () => {
     it('decodes a cold daemon surface with exactly three trailing u32 hashes', () => {
         const flags = 0b000100 | 0b001000; // daemon (bit2) + scheduled (bit3)
-        const s = parseSurface(wasmWithSection('toil.surface', buildSurfaceBytes({ mode: 1, flags })));
-        expect(s).not.toBe('absent');
+        const s = parseSurface(
+            wasmWithSection('toil.surface', buildSurfaceBytes({ mode: 1, flags })),
+        );
         expect(s).not.toBe('invalid');
-        if (s !== 'absent' && s !== 'invalid') {
+        if (s !== 'invalid') {
             expect(s.targetMode).toBe('cold');
             expect(s.flags.daemon).toBe(true);
             expect(s.flags.scheduled).toBe(true);
@@ -188,13 +195,15 @@ describe('parseSurface (Part 5)', () => {
     });
 
     it('decodes a hot surface (target_mode 0)', () => {
-        const s = parseSurface(wasmWithSection('toil.surface', buildSurfaceBytes({ mode: 0, flags: 1 })));
-        expect(s !== 'absent' && s !== 'invalid' && s.targetMode).toBe('hot');
+        const s = parseSurface(
+            wasmWithSection('toil.surface', buildSurfaceBytes({ mode: 0, flags: 1 })),
+        );
+        expect(s !== 'invalid' && s.targetMode).toBe('hot');
     });
 
-    it("treats an ABSENT section as 'absent' (legacy single artifact, load as hot)", () => {
+    it('fails closed when toil.surface is absent', () => {
         const wasm = wasmWithSection('toildb.catalog', Buffer.from([0x01, 0x00]));
-        expect(parseSurface(wasm)).toBe('absent');
+        expect(parseSurface(wasm)).toBe('invalid');
     });
 
     it("fails closed: a PRESENT but truncated section is 'invalid'", () => {

package/test/devserver-database.test.ts

@@ -92,7 +92,7 @@ function routeKindsSection(routes: readonly (readonly [number, number, string])[
     return Buffer.concat(chunks);
 }
 
-function catalogSectionV2(fillMaxWaitMs: number, fillAllowStale: number, replication = 5): Buffer {
+function catalogSectionV1(fillMaxWaitMs: number, fillAllowStale: number, replication = 5): Buffer {
     const chunks: Buffer[] = [];
     const u8 = (v: number) => chunks.push(Buffer.from([v & 0xff]));
     const u16 = (v: number) => {
@@ -111,7 +111,7 @@ function catalogSectionV2(fillMaxWaitMs: number, fillAllowStale: number, replica
         chunks.push(b);
     };
 
-    u16(2); // catalog version
+    u16(1); // catalog version
     u16(1); // databases
     str('App');
     u16(1); // collections
@@ -215,8 +215,8 @@ describe('toildb dev emulator (record family)', () => {
         expect(imports['data.resolve_collection'](p, l, 16)).toBe(-1070);
     });
 
-    it('parses catalog v2 fill policy and backend replication bytes', () => {
-        setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV2(7, 0)));
+    it('parses catalog v1 fill policy and backend replication bytes', () => {
+        setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV1(7, 0)));
         const { imports, buf, db } = setupRaw();
         const h = resolve(imports, buf, 'App/users');
 
@@ -231,9 +231,9 @@ describe('toildb dev emulator (record family)', () => {
         });
     });
 
-    it('rejects replication policies that require catalog v3 metadata', () => {
+    it('rejects replication policies that require explicit policy metadata', () => {
         for (const replication of [3, 4]) {
-            setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV2(7, 0, replication)));
+            setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV1(7, 0, replication)));
             const { imports, buf } = setupRaw();
             const [p, l] = put(buf, 0, 'App/users');
 
@@ -241,8 +241,8 @@ describe('toildb dev emulator (record family)', () => {
         }
     });
 
-    it('rejects malformed catalog v2 fill policy', () => {
-        setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV2(7, 2)));
+    it('rejects malformed catalog v1 fill policy', () => {
+        setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV1(7, 2)));
         const { imports, buf } = setupRaw();
         const [p, l] = put(buf, 0, 'App/users');
 

package/test/devserver.test.ts

@@ -4,6 +4,7 @@
  * into the example project's ToilScript-compiled server wasm.
  */
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -15,6 +16,7 @@ import {
     unpackHandleResult,
     WasmServerModule,
 } from '../src/devserver/index.js';
+import { resolveStaticFile } from '../src/devserver/http/runtime.js';
 
 const EXAMPLE_WASM = path.resolve(
     path.dirname(fileURLToPath(import.meta.url)),
@@ -121,10 +123,7 @@ describe('response envelope decoding', () => {
             /status 0/,
         );
         // Claim a huge header name with too few bytes behind it.
-        const bad = Buffer.concat([
-            Buffer.from([200, 0, 1, 0, 255, 255, 0, 0]),
-            Buffer.from('hi'),
-        ]);
+        const bad = Buffer.concat([Buffer.from([200, 0, 1, 0, 255, 255, 0, 0]), Buffer.from('hi')]);
         expect(() => decodeResponseEnvelope(bad)).toThrow(/truncated/);
     });
 });
@@ -140,6 +139,23 @@ describe('handle() result unpacking', () => {
     });
 });
 
+describe('static file resolver', () => {
+    it('resolves absolute request paths inside the static root', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-static-'));
+        const file = path.join(root, 'assets', 'app.css');
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, 'body{}');
+
+            expect(resolveStaticFile(root, '/assets/app.css')).toBe(file);
+            expect(resolveStaticFile(root, '/missing.css')).toBeNull();
+            expect(resolveStaticFile(root, '/../app.css')).toBeNull();
+        } finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+
 describe.skipIf(!fs.existsSync(EXAMPLE_WASM))('dispatch into the example server wasm', () => {
     const load = (): WasmServerModule => {
         const m = new WasmServerModule(EXAMPLE_WASM);

package/test/example-guestbook.test.ts

@@ -64,17 +64,20 @@ describe.skipIf(!haveWasm)('guestbook demo: ToilDB events + counter persist acro
         expect(json(r).total).toBe('1');
 
         // A brand-new wasm instance - its memory is empty - still sees the prior
-        // signature, because it lives in ToilDB, not module state.
+        // signature, because it lives in ToilDB, not module state. The action
+        // acks with the running total; the entries list is served by the GET.
         r = sign(load(), 'Linus', 'second');
-        const v = json(r);
+        expect(json(r).total).toBe('2');
+
+        // The newest entries are served by GET /guestbook from the materialized
+        // view that the @derive republishes after each signature (events.latest
+        // is a scan, barred in the request handlers, so it runs in the derive).
+        const v = json(list(load()));
         expect(v.total).toBe('2');
         expect(v.entries.length).toBe(2);
         expect(v.entries[0].author).toBe('Linus'); // events.latest is newest-first
         expect(v.entries[1].author).toBe('Ada');
         expect(v.entries[1].message).toBe('first!');
-
-        // A read-only GET on yet another instance sees the same persisted state.
-        expect(json(list(load())).total).toBe('2');
     });
 
     // End-to-end proof that the `server/migrations/GuestEntry.migration.ts` demo

package/test/fixtures/stream-echo.ts

@@ -0,0 +1,26 @@
+// Dev-stream emulation fixture: a `@stream('echo')` whose raw `@message` bridge echoes the inbound
+// bytes back through the egress ring, rejects an 'X'-prefixed frame (0x0210), and `empty()`s a
+// zero-length frame. Compiled by the dev test with the LOCAL toilscript (`--targetMode hot`), then
+// driven through `DevStreamBox`. Mirrors toil-backend's `tests/fixtures/stream/echo_src.ts`.
+
+let __count: i32 = 0;
+
+// Observable so the @message hook's residency can be asserted across events.
+export function messageCount(): i32 {
+  return __count;
+}
+
+@stream('echo')
+class Echo {
+  @message reply(p: StreamPacket): StreamOutbound {
+    __count = __count + 1;
+    const n = p.length;
+    if (n == 0) return StreamOutbound.empty();
+    if (p.at(0) == 0x58) return StreamOutbound.reject(0x0210); // 'X' -> reject
+    return StreamOutbound.reply(p.bytes());
+  }
+}
+
+export function probe(): i32 {
+  return 1;
+}

package/test/fixtures/stream-gate.ts

@@ -0,0 +1,24 @@
+// Dev @connect-bridge fixture: a `@stream('gate')` whose `@connect(c: StreamInbound): StreamOutbound`
+// reads the host-written connect context (the path) and REJECTS "/blocked" with 0x0211, ACCEPTING any
+// other path; a "/greet" path stages an egress frame DURING @connect (the host must clear it so it does
+// not contaminate the first @message reply). A @message echoes. Mirrors toil-backend's connect_src.ts;
+// exercises the whole @connect bridge (stream_info block -> StreamInbound.path() -> accept/reject).
+
+@stream('gate')
+class Gate {
+  @connect onConnect(c: StreamInbound): StreamOutbound {
+    if (c.path() == "/blocked") return StreamOutbound.reject(0x0211);
+    if (c.path() == "/greet") {
+      const g = new Uint8Array(3);
+      g[0] = 0x47; g[1] = 0x48; g[2] = 0x49; // "GHI"
+      StreamOutbound.reply(g);
+      return StreamOutbound.accept();
+    }
+    return StreamOutbound.accept();
+  }
+  @message reply(p: StreamPacket): StreamOutbound {
+    return StreamOutbound.reply(p.bytes());
+  }
+}
+
+export function probe(): i32 { return 1; }

package/test/fixtures/stream-trap.ts

@@ -0,0 +1,18 @@
+// Dev trap fixture: a `@stream('trap')` whose `@message` deliberately TRAPS (the wasm `unreachable`
+// instruction). The dev has no gas-metering middleware, so this stands in for the edge's gas-kill: a
+// real trap makes the dispatch throw, which StreamDevHost turns into a STREAM_HOOK_TRAPPED close that
+// discards the poisoned box (mirrors toil-backend's poisoned-box containment, 05 7.4).
+//
+// The trap sits behind an always-true guard so the `return` stays reachable to the type checker.
+
+@stream('trap')
+class Trap {
+  @message boom(p: StreamPacket): StreamOutbound {
+    if (p.length >= 0) {
+      unreachable();
+    }
+    return StreamOutbound.empty();
+  }
+}
+
+export function probe(): i32 { return 1; }

package/test/rpc-bignum-wire.test.ts

@@ -7,7 +7,7 @@
  * Compiles test/fixtures/bignum-wire/spec.ts with the installed toilscript (so it
  * exercises the published compiler + generated client, not a hand-written stub), then
  * imports the generated TS client and asserts the wire shape both directions, including
- * values far above 2^53 and the legacy limb-array shape older servers emitted.
+ * values far above 2^53.
  */
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
@@ -24,6 +24,9 @@ const codec = path.join(here, '..', 'src', 'io', 'codec.ts');
 
 /** Resolves the installed toilscript CLI entry (no PATH / .bin assumptions). */
 function toilscriptBin(): string {
+    if (process.env.TOILSCRIPT_BIN) return process.env.TOILSCRIPT_BIN;
+    const sibling = path.resolve(here, '..', '..', 'toilscript', 'bin', 'toilscript.js');
+    if (fs.existsSync(sibling)) return sibling;
     const pkgPath = require.resolve('toilscript/package.json');
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8')) as { bin?: Record<string, string> };
     const binRel = pkg.bin?.toilscript;
@@ -83,6 +86,10 @@ beforeAll(async () => {
         { encoding: 'utf8' },
     );
     if (res.status !== 0) throw new Error('toilscript compile failed:\n' + res.stderr);
+    const generatedSource = fs.readFileSync(mod, 'utf8');
+    const removedHelper = ['__toil', 'Unlimb'].join('');
+    expect(generatedSource).toContain('__toilBigInt');
+    expect(generatedSource).not.toContain(removedHelper);
     const gen = (await import(pathToFileURL(mod).href)) as {
         Wallet: WalletStatic;
         Account: AccountStatic;
@@ -142,13 +149,6 @@ describe('generated client bignum JSON wire format', () => {
         expect(back.d).toBe(BigInt('-' + huge));
     });
 
-    it('still revives the legacy little-endian limb-array shape (back-compat)', () => {
-        // u256 [5,0,4,0] little-endian = 5 + 4*2^128.
-        const w = Wallet.fromJSONValue({ c: [5, 0, 4, 0], a: [9, 1] });
-        expect(w.c).toBe(2n ** 130n + 5n);
-        expect(w.a).toBe(2n ** 64n + 9n);
-    });
-
     it('recurses into nested @data and arrays of bignums', () => {
         const a = new Account();
         a.main.c = BigInt(huge);