toiljs 0.0.116 → 0.0.118

package/test/prerender.test.ts

@@ -1,116 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import ts from 'typescript';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import {
-    extractStaticMetadata,
-    loadTypeScript,
-    loadTypeScriptSync,
-} from '../src/compiler/prerender';
-
-const written: string[] = [];
-function tmp(source: string): string {
-    const file = path.join(
-        os.tmpdir(),
-        `toil-prerender-${String(written.length)}-${process.pid}.tsx`,
-    );
-    fs.writeFileSync(file, source);
-    written.push(file);
-    return file;
-}
-afterEach(() => {
-    for (const f of written.splice(0)) fs.rmSync(f, { force: true });
-});
-
-describe('extractStaticMetadata', () => {
-    it('extracts a static metadata object literal (nested objects/arrays)', () => {
-        const file = tmp(
-            `export const metadata = { title: 'X', keywords: ['a', 'b'], openGraph: { type: 'website' } };\n` +
-                `export default function P() { return null; }\n`,
-        );
-        expect(extractStaticMetadata(ts, file)).toEqual({
-            title: 'X',
-            keywords: ['a', 'b'],
-            openGraph: { type: 'website' },
-        });
-    });
-
-    it('returns null when there is no static metadata export', () => {
-        expect(
-            extractStaticMetadata(ts, tmp(`export default function P() { return null; }\n`)),
-        ).toBeNull();
-        // generateMetadata (a function) is not a static object literal → not extracted.
-        expect(
-            extractStaticMetadata(
-                ts,
-                tmp(`export const generateMetadata = () => ({ title: 'X' });\n`),
-            ),
-        ).toBeNull();
-    });
-
-    it('skips computed/non-literal properties but keeps the static ones', () => {
-        const file = tmp(`const x = foo();\nexport const metadata = { title: 'X', dyn: x };\n`);
-        expect(extractStaticMetadata(ts, file)).toEqual({ title: 'X' });
-    });
-});
-
-/**
- * Builds a throwaway project root whose resolvable `typescript` is `main`-ed at a module exporting
- * only `version` — the shape TypeScript 7 ships, having moved the compiler API to
- * `typescript/unstable/*`. Resolution succeeds, so a truthy check can't tell it apart from a usable
- * compiler; only probing the API can.
- */
-function rootWithApiLessTypeScript(): string {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), `toil-ts7-${process.pid}-`));
-    dirs.push(root);
-    const pkgDir = path.join(root, 'node_modules', 'typescript');
-    fs.mkdirSync(pkgDir, { recursive: true });
-    fs.writeFileSync(path.join(root, 'package.json'), '{"name":"fixture"}');
-    fs.writeFileSync(
-        path.join(pkgDir, 'package.json'),
-        '{"name":"typescript","version":"7.0.2","main":"./version.cjs"}',
-    );
-    fs.writeFileSync(
-        path.join(pkgDir, 'version.cjs'),
-        `module.exports = { version: '7.0.2', versionMajorMinor: '7.0' };\n`,
-    );
-    return root;
-}
-
-const dirs: string[] = [];
-afterEach(() => {
-    for (const d of dirs.splice(0)) fs.rmSync(d, { recursive: true, force: true });
-});
-
-describe('loadTypeScript', () => {
-    it('returns null (not a half-built module) when typescript exposes no compiler API', async () => {
-        const root = rootWithApiLessTypeScript();
-        const warn = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
-        try {
-            // Both must degrade rather than hand back `{ version }`, whose first `ts.ScriptTarget`
-            // read would throw `Cannot read properties of undefined (reading 'Latest')` mid-build.
-            expect(loadTypeScriptSync(root)).toBeNull();
-            await expect(loadTypeScript(root)).resolves.toBeNull();
-        } finally {
-            warn.mockRestore();
-        }
-    });
-
-    it('returns null when typescript is not installed at all', async () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), `toil-nots-${process.pid}-`));
-        dirs.push(root);
-        fs.writeFileSync(path.join(root, 'package.json'), '{"name":"fixture"}');
-        expect(loadTypeScriptSync(root)).toBeNull();
-        await expect(loadTypeScript(root)).resolves.toBeNull();
-    });
-
-    it('returns the compiler API when a usable typescript is installed', async () => {
-        // This repo's own root resolves its devDependency typescript, which has the classic API.
-        const root = path.resolve(__dirname, '..');
-        expect(loadTypeScriptSync(root)?.createSourceFile).toBeTypeOf('function');
-        expect((await loadTypeScript(root))?.ScriptTarget.Latest).toBeTypeOf('number');
-    });
-});

package/test/prettier-plugin.test.ts

@@ -1,46 +0,0 @@
-import prettier from 'prettier';
-import { describe, expect, it } from 'vitest';
-
-import * as plugin from '../presets/prettier-plugin.js';
-
-function fmt(src: string): Promise<string> {
-    return prettier.format(src, {
-        parser: 'typescript',
-        plugins: [plugin],
-        tabWidth: 4,
-        singleQuote: true,
-        semi: true,
-    });
-}
-
-// The plugin lets prettier format toilscript server code, whose native decorators on free
-// functions (@main, @remote function) are not valid JS/TS grammar (so stock prettier throws).
-describe('toiljs prettier-plugin', () => {
-    it('formats a free @remote function and keeps the decorator', async () => {
-        const out = await fmt('@remote\nfunction ping(n:i32):i32{return n+1}\n');
-        expect(out).toContain('@remote');
-        expect(out).toContain('function ping(n: i32): i32 {');
-        expect(out).not.toContain('toil-decorator'); // marker fully restored
-    });
-
-    it('formats @main', async () => {
-        const out = await fmt('@main\nfunction run():i32{return 42}\n');
-        expect(out).toMatch(/@main\nfunction run\(\): i32 \{/);
-    });
-
-    it('handles @remote export function', async () => {
-        const out = await fmt('@remote\nexport function pong():void{}\n');
-        expect(out).toContain('@remote\nexport function pong(): void {}');
-    });
-
-    it('leaves class/method decorators untouched', async () => {
-        const out = await fmt('@data\nclass A{ x:i32=0 }\n');
-        expect(out).toContain('@data');
-        expect(out).toContain('class A {');
-    });
-
-    it('is idempotent', async () => {
-        const once = await fmt('@remote\nfunction f():void{}\n@main\nfunction g():void{}\n');
-        expect(await fmt(once)).toBe(once);
-    });
-});

package/test/routes.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { matchRoute } from '../src/client/routing/match';
-import { filePathToRoute, interceptTarget } from '../src/compiler/routes';
-
-describe('filePathToRoute', () => {
-    it('maps index, static, nested, and dynamic files to patterns', () => {
-        expect(filePathToRoute('index.tsx')).toBe('/');
-        expect(filePathToRoute('about.tsx')).toBe('/about');
-        expect(filePathToRoute('blog/index.tsx')).toBe('/blog');
-        expect(filePathToRoute('blog/[id].tsx')).toBe('/blog/:id');
-        expect(filePathToRoute('docs/guide/intro.jsx')).toBe('/docs/guide/intro');
-        expect(filePathToRoute('docs/[...slug].tsx')).toBe('/docs/*slug');
-    });
-
-    it('maps optional catch-all and strips route groups', () => {
-        expect(filePathToRoute('docs/[[...slug]].tsx')).toBe('/docs/**slug');
-        expect(filePathToRoute('[[...slug]].tsx')).toBe('/**slug');
-        expect(filePathToRoute('(marketing)/about.tsx')).toBe('/about');
-        expect(filePathToRoute('(shop)/index.tsx')).toBe('/');
-        expect(filePathToRoute('(a)/(b)/deep.tsx')).toBe('/deep');
-    });
-
-    it('strips parallel-slot (@slot) segments from the URL', () => {
-        expect(filePathToRoute('@modal/photo/[id].tsx')).toBe('/photo/:id');
-        expect(filePathToRoute('@sidebar/index.tsx')).toBe('/');
-        expect(filePathToRoute('dashboard/@chart/views.tsx')).toBe('/dashboard/views');
-    });
-});
-
-describe('interceptTarget', () => {
-    it('resolves (.)/(..)/(...) marker targets', () => {
-        expect(interceptTarget('@modal/(.)photo/[id].tsx')).toBe('/photo/:id');
-        expect(interceptTarget('feed/@modal/(..)photo/[id].tsx')).toBe('/photo/:id');
-        expect(interceptTarget('a/b/@m/(...)login.tsx')).toBe('/login');
-    });
-
-    it('returns null for routes with no interception marker', () => {
-        expect(interceptTarget('photo/[id].tsx')).toBeNull();
-        expect(interceptTarget('@modal/settings.tsx')).toBeNull();
-    });
-});
-
-describe('matchRoute', () => {
-    it('matches static routes', () => {
-        expect(matchRoute('/', '/')).toEqual({});
-        expect(matchRoute('/about', '/about')).toEqual({});
-    });
-
-    it('rejects non-matches', () => {
-        expect(matchRoute('/about', '/x')).toBeNull();
-        expect(matchRoute('/blog/:id', '/blog')).toBeNull();
-        expect(matchRoute('/', '/about')).toBeNull();
-    });
-
-    it('extracts dynamic params', () => {
-        expect(matchRoute('/blog/:id', '/blog/42')).toEqual({ id: '42' });
-        expect(matchRoute('/u/:user/p/:post', '/u/ann/p/7')).toEqual({ user: 'ann', post: '7' });
-        expect(matchRoute('/blog/:id', '/blog/a%20b')).toEqual({ id: 'a b' });
-    });
-
-    it('captures the tail with catch-all routes', () => {
-        expect(matchRoute('/docs/*slug', '/docs/a/b/c')).toEqual({ slug: 'a/b/c' });
-        expect(matchRoute('/docs/*slug', '/docs/intro')).toEqual({ slug: 'intro' });
-        expect(matchRoute('/files/*path', '/files/a%20b/c')).toEqual({ path: 'a b/c' });
-        // catch-all needs at least one trailing segment
-        expect(matchRoute('/docs/*slug', '/docs')).toBeNull();
-    });
-
-    it('matches optional catch-all with zero or more segments', () => {
-        expect(matchRoute('/docs/**slug', '/docs')).toEqual({ slug: '' });
-        expect(matchRoute('/docs/**slug', '/docs/a/b')).toEqual({ slug: 'a/b' });
-        expect(matchRoute('/**slug', '/')).toEqual({ slug: '' });
-        expect(matchRoute('/**slug', '/x/y')).toEqual({ slug: 'x/y' });
-    });
-});

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

@@ -1,164 +0,0 @@
-/**
- * Regression test for the bignum JSON wire format. 64-bit-and-up integers
- * (u64/i64/u128/i128/u256/i256) must cross JSON as DECIMAL STRINGS, not number tokens
- * or limb arrays: JSON numbers ride through a browser client's JSON.parse as IEEE
- * doubles, which silently corrupt any integer past 2^53.
- *
- * 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.
- */
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-import { beforeAll, describe, expect, it } from 'vitest';
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const spec = path.join(here, 'fixtures', 'bignum-wire', 'spec.ts');
-// The generated module imports DataWriter/DataReader from this specifier.
-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;
-    if (!binRel) throw new Error('toilscript declares no bin');
-    return path.join(path.dirname(pkgPath), binRel);
-}
-
-interface Wallet {
-    u: bigint;
-    i: bigint;
-    a: bigint;
-    b: bigint;
-    c: bigint;
-    d: bigint;
-    label: string;
-    toJSONValue(): Record<string, unknown>;
-}
-interface WalletStatic {
-    new (): Wallet;
-    fromJSONValue(v: unknown): Wallet;
-}
-interface AccountStatic {
-    new (): { main: Wallet; ids: bigint[]; toJSONValue(): Record<string, unknown> };
-    fromJSONValue(v: unknown): { main: Wallet; ids: bigint[] };
-}
-
-let Wallet: WalletStatic;
-let Account: AccountStatic;
-let tmp: string;
-
-beforeAll(async () => {
-    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'bignum-wire-'));
-    fs.writeFileSync(path.join(tmp, 'package.json'), '{ "type": "module" }\n');
-    // vitest transforms the imported .ts through Vite/oxc, which walks up for a tsconfig.
-    fs.writeFileSync(
-        path.join(tmp, 'tsconfig.json'),
-        JSON.stringify({ compilerOptions: { target: 'esnext', module: 'esnext' } }),
-    );
-    const mod = path.join(tmp, 'server.ts');
-    const wasm = path.join(tmp, 'spec.wasm');
-    const res = spawnSync(
-        process.execPath,
-        [
-            toilscriptBin(),
-            spec,
-            '-o',
-            wasm,
-            '--runtime',
-            'stub',
-            '--initialMemory',
-            '32',
-            '--rpcModule',
-            mod,
-            '--rpcRuntime',
-            codec,
-        ],
-        { 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;
-    };
-    Wallet = gen.Wallet;
-    Account = gen.Account;
-});
-
-// A few representative bignum types; `huge` is well past Number.MAX_SAFE_INTEGER.
-const huge = '123456789012345678901234567890';
-const u128Max = '340282366920938463463374607431768211455';
-const i64Min = '-9223372036854775808';
-
-describe('generated client bignum JSON wire format', () => {
-    it('serializes every 64-bit-and-up integer as a decimal string', () => {
-        const w = new Wallet();
-        w.u = BigInt(huge.slice(0, 19)); // fits u64
-        w.i = BigInt(i64Min);
-        w.a = BigInt(u128Max);
-        w.b = -123n;
-        w.c = BigInt(huge);
-        w.d = -1n;
-        w.label = 'x';
-        const json = w.toJSONValue();
-        // Each bignum field is a string, never a number or an array.
-        for (const k of ['u', 'i', 'a', 'b', 'c', 'd'] as const) {
-            expect(typeof json[k], `field ${k}`).toBe('string');
-        }
-        expect(json.a).toBe(u128Max);
-        expect(json.c).toBe(huge);
-        expect(json.i).toBe(i64Min);
-        expect(json.label).toBe('x');
-    });
-
-    it('revives a decimal string past 2^53 into an exact bigint', () => {
-        const w = Wallet.fromJSONValue({
-            u: '0',
-            i: i64Min,
-            a: u128Max,
-            b: '-123',
-            c: huge,
-            d: '-1',
-            label: 'y',
-        });
-        expect(w.c).toBe(BigInt(huge));
-        expect(w.a).toBe(BigInt(u128Max));
-        expect(w.i).toBe(BigInt(i64Min));
-        expect(w.d).toBe(-1n);
-    });
-
-    it('round-trips a value through send then revive without loss', () => {
-        const w = new Wallet();
-        w.c = BigInt(huge);
-        w.d = BigInt('-' + huge);
-        const back = Wallet.fromJSONValue(JSON.parse(JSON.stringify(w.toJSONValue())));
-        expect(back.c).toBe(BigInt(huge));
-        expect(back.d).toBe(BigInt('-' + huge));
-    });
-
-    it('recurses into nested @data and arrays of bignums', () => {
-        const a = new Account();
-        a.main.c = BigInt(huge);
-        a.ids = [1n, BigInt(huge)];
-        const json = a.toJSONValue();
-        const main = json.main as Record<string, unknown>;
-        expect(main.c).toBe(huge);
-        expect(json.ids).toEqual(['1', huge]);
-        const back = Account.fromJSONValue(JSON.parse(JSON.stringify(json)));
-        expect(back.main.c).toBe(BigInt(huge));
-        expect(back.ids).toEqual([1n, BigInt(huge)]);
-    });
-});

package/test/rpc-dispatch.test.ts

@@ -1,132 +0,0 @@
-/**
- * @service / @remote RPC: a real round trip into the example project's toilscript-compiled server
- * wasm. A `POST /__toil_rpc` carrying the FNV method id in the `dacely-rpc` header is dispatched by the
- * runtime `Rpc` registry (compiler-injected `__rpcDispatch` + `Rpc.register`) to the @remote method,
- * and the @data/scalar result comes back encoded with the same DataWriter codec the client decodes.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { describe, expect, it } from 'vitest';
-
-import { WasmServerModule } from '../src/devserver/index.js';
-
-const EXAMPLE_WASM = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    '../examples/basic/build/server/release.wasm',
-);
-
-/** FNV-1a (the toilscript `dataTypeId`); the client + the parser injection must agree on this. */
-function fnv1a(s: string): number {
-    let h = 0x811c9dc5;
-    for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 0x01000193) >>> 0;
-    return h >>> 0;
-}
-
-describe.skipIf(!fs.existsSync(EXAMPLE_WASM))('@service RPC dispatch', () => {
-    const load = (): WasmServerModule => {
-        const m = new WasmServerModule(EXAMPLE_WASM);
-        m.refresh();
-        return m;
-    };
-
-    it('dispatches Server.stats.playerCount() over /__toil_rpc', () => {
-        const id = fnv1a('Stats.playerCount');
-        expect(id).toBe(118912982); // matches the generated __toilRpc client
-        const r = load().dispatch({
-            method: 'POST',
-            path: '/__toil_rpc',
-            headers: [['dacely-rpc', String(id)]],
-            body: new Uint8Array(0),
-        });
-        expect(r.unhandled).toBe(false);
-        expect(r.status).toBe(200);
-        // The result is a DataWriter-encoded i32 (the seeded player count = 3).
-        expect(r.body.length).toBe(4);
-        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
-        expect(dv.getInt32(0, true)).toBe(3);
-    });
-
-    it('dispatches a free Server.ping(n) over /__toil_rpc', () => {
-        const id = fnv1a('ping');
-        const body = new Uint8Array(4);
-        new DataView(body.buffer).setInt32(0, 41, true); // arg n = 41 (DataWriter writeI32, LE)
-        const r = load().dispatch({
-            method: 'POST',
-            path: '/__toil_rpc',
-            headers: [['dacely-rpc', String(id)]],
-            body,
-        });
-        expect(r.status).toBe(200);
-        expect(r.body.length).toBe(4);
-        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
-        expect(dv.getInt32(0, true)).toBe(42); // ping(41) = 42
-    });
-
-    it('round-trips a Uint8Array[] arg + result (writeBytes/readBytes loop, the #5 fix)', () => {
-        const id = fnv1a('echoParts');
-        const parts = [Uint8Array.from([1, 2]), Uint8Array.from([3, 4, 5])];
-        const buf: number[] = [];
-        const pushU32 = (v: number) => buf.push(v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >>> 24) & 255);
-        pushU32(parts.length); // u32 count, then per part: u32 len + bytes (DataWriter.writeBytes)
-        for (const p of parts) {
-            pushU32(p.length);
-            for (const b of p) buf.push(b);
-        }
-        const r = load().dispatch({
-            method: 'POST',
-            path: '/__toil_rpc',
-            headers: [['dacely-rpc', String(id)]],
-            body: Uint8Array.from(buf),
-        });
-        expect(r.status).toBe(200);
-        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
-        let off = 0;
-        const count = dv.getUint32(off, true);
-        off += 4;
-        const out: number[][] = [];
-        for (let i = 0; i < count; i++) {
-            const len = dv.getUint32(off, true);
-            off += 4;
-            out.push([...r.body.subarray(off, off + len)]);
-            off += len;
-        }
-        expect(out).toEqual([
-            [1, 2],
-            [3, 4, 5],
-        ]);
-    });
-
-    it('rejects an @auth @remote with 401 when there is no session', () => {
-        const id = fnv1a('Stats.secretCount');
-        const r = load().dispatch({
-            method: 'POST',
-            path: '/__toil_rpc',
-            headers: [['dacely-rpc', String(id)]],
-            body: new Uint8Array(0),
-        });
-        expect(r.status).toBe(401);
-    });
-
-    it('returns 400 for an unknown method id', () => {
-        const r = load().dispatch({
-            method: 'POST',
-            path: '/__toil_rpc',
-            headers: [['dacely-rpc', '999999']],
-            body: new Uint8Array(0),
-        });
-        expect(r.status).toBe(400);
-    });
-
-    it('does not intercept a non-RPC request (no dacely-rpc header)', () => {
-        const r = load().dispatch({
-            method: 'GET',
-            path: '/json',
-            headers: [['host', 'localhost:3000']],
-            body: new Uint8Array(0),
-        });
-        expect(r.status).toBe(200);
-        expect(Buffer.from(r.body).toString()).toBe('{"hello":"toiljs"}\n');
-    });
-});

package/test/rpc-kinds.test.ts

@@ -1,18 +0,0 @@
-/**
- * The dev-server RPC DB-kind resolution (audit #2): an `@action` @remote may write; a plain/read-only
- * @remote (absent from `toildb.rpc_kinds`) defaults to read-only Query, matching the edge host gate.
- */
-import { describe, expect, it } from 'vitest';
-
-import { rpcKindForId, type RpcKindEntry } from '../src/devserver/db/routeKinds.js';
-import { DbFunctionKind } from '../src/devserver/db/types.js';
-
-describe('rpcKindForId', () => {
-    it('returns the @action kind for a listed id, and read-only Query for an absent one', () => {
-        const methods: RpcKindEntry[] = [{ methodId: 42, kind: DbFunctionKind.Action }];
-        expect(rpcKindForId(methods, 42)).toBe(DbFunctionKind.Action);
-        // An id NOT in rpc_kinds (a plain/read-only @remote) defaults to Query - the safe default.
-        expect(rpcKindForId(methods, 999)).toBe(DbFunctionKind.Query);
-        expect(rpcKindForId([], 42)).toBe(DbFunctionKind.Query);
-    });
-});

package/test/rpc.test.ts

@@ -1,66 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { Server } from '../src/client/rpc';
-
-// `Server` is the runtime behind the generated typed surface. The RPC branch surfaces
-// `globalThis.__toilRpc` (attached by the generated `shared/server.ts`); when that client has
-// not loaded, the proxy throws a helpful "client has not loaded" error naming the path.
-describe('Server RPC stub (client not loaded)', () => {
-    afterEach(() => {
-        delete (globalThis as { __toilRpc?: unknown }).__toilRpc;
-    });
-
-    it('throws on a direct call, naming the path', () => {
-        const s = Server as { ping: () => unknown };
-        expect(() => s.ping()).toThrow(/Server\.ping\(\)/);
-    });
-
-    it('throws on a nested service.method call', () => {
-        const s = Server as { accounts: { getUser: () => unknown } };
-        expect(() => s.accounts.getUser()).toThrow(/Server\.accounts\.getUser\(\)/);
-        expect(() => s.accounts.getUser()).toThrow(/has not loaded/);
-    });
-
-    it('surfaces the attached RPC client (service method + free remote) once loaded', async () => {
-        const fake = { stats: { playerCount: async () => 3 }, ping: async (n: number) => n + 1 };
-        (globalThis as { __toilRpc?: unknown }).__toilRpc = fake;
-        const s = Server as {
-            stats: { playerCount: () => Promise<number> };
-            ping: (n: number) => Promise<number>;
-        };
-        expect(await s.stats.playerCount()).toBe(3);
-        expect(await s.ping(41)).toBe(42);
-    });
-
-    it('is not thenable (so it is not mistaken for a promise)', () => {
-        const s = Server as Record<string, unknown>;
-        expect(s.then).toBeUndefined();
-    });
-
-    it('ignores symbol probes without throwing', () => {
-        const s = Server as Record<PropertyKey, unknown>;
-        expect(s[Symbol.iterator]).toBeUndefined();
-    });
-});
-
-// `Server.REST` surfaces the working fetch client that the generated `shared/server.ts`
-// attaches to `globalThis.__toilRest` on import.
-describe('Server.REST surface', () => {
-    afterEach(() => {
-        delete (globalThis as { __toilRest?: unknown }).__toilRest;
-    });
-
-    it('returns the attached REST client when shared/server has loaded', () => {
-        const fake = { todos: { getTodo: async () => 'ok' } };
-        (globalThis as { __toilRest?: unknown }).__toilRest = fake;
-        const s = Server as { REST: typeof fake };
-        expect(s.REST).toBe(fake);
-        expect(s.REST.todos.getTodo).toBeTypeOf('function');
-    });
-
-    it('throws a helpful "not loaded" error when the REST client is absent', () => {
-        const s = Server as { REST: { todos: { getTodo: () => unknown } } };
-        expect(() => s.REST.todos.getTodo()).toThrow(/Server\.REST\.todos\.getTodo\(\)/);
-        expect(() => s.REST.todos.getTodo()).toThrow(/has not loaded/);
-    });
-});