toiljs 0.0.65 → 0.0.67

package/src/devserver/server.ts

@@ -362,7 +362,14 @@ export async function startDevServer(options: DevServerOptions): Promise<Running
                 const route = ssrRoutes.find((r) => r.test(pathnameOf(request.url)));
                 if (route) {
                     try {
-                        const out = assembleSsr(route, module.dispatchRender(envelopeReq));
+                        // A static route (its template has no holes -> no slots) needs no guest
+                        // render: serve the prerendered template directly so it paints instantly
+                        // instead of falling through to a (blank-until-JS) client render. Dynamic
+                        // routes run the guest `render` and splice its values in.
+                        const out: SsrResult | null =
+                            route.entries.length === 0
+                                ? { status: 200, headers: [], html: route.tmpl }
+                                : assembleSsr(route, module.dispatchRender(envelopeReq));
                         if (out !== null) {
                             sendSsr(response, out, request.method === 'HEAD');
                             return;

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/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/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);