toiljs 0.0.116 → 0.0.118

package/test/email-preview.test.ts

@@ -1,73 +0,0 @@
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-
-import { createServer } from 'vite';
-import { describe, expect, it } from 'vitest';
-
-import { loadConfig } from '../src/compiler/config';
-import {
-    emailsVersion,
-    listEmails,
-    previewShellHtml,
-    renderEmailByName,
-} from '../src/compiler/email-preview';
-import { createViteConfig } from '../src/compiler/vite';
-
-const EXAMPLE = path.resolve(__dirname, '../examples/basic');
-
-// Drives a Vite server over examples/basic; skip where the example's deps are
-// not installed (e.g. CI without the example set up).
-describe.skipIf(!existsSync(path.join(EXAMPLE, 'node_modules')))(
-    'email preview end-to-end (examples/basic)',
-    () => {
-    it('lists Welcome and inlines its emails/styles/email.css; client/* alias resolves', async () => {
-        const cfg = await loadConfig({ root: EXAMPLE });
-        const items = listEmails(cfg);
-        expect(items.map((i) => i.name)).toContain('Welcome');
-
-        const server = await createServer({
-            ...(await createViteConfig(cfg)),
-            server: { middlewareMode: true, hmr: false },
-            appType: 'custom',
-            logLevel: 'silent',
-        });
-        try {
-            const r = await renderEmailByName(server, cfg, 'Welcome');
-            if (!r) throw new Error('Welcome did not render');
-            // tokens discovered from props
-            expect(r.tokens).toEqual(['code', 'name']);
-            // subject token template
-            expect(r.subject).toBe('Welcome to toiljs, {{name}}');
-            // .email-title { color: #f5f6fa } from emails/styles/email.css inlined onto the <h1>
-            expect(r.html).toMatch(/<h1[^>]*style="[^"]*color:\s*#f5f6fa/i);
-            // .email-card { background-color: #0e1520 } inlined onto the card <table>
-            expect(r.html).toMatch(/<table[^>]*style="[^"]*background-color:\s*#0e1520/i);
-
-            // The `client/*` reuse alias still resolves project CSS (the documented
-            // `import 'client/styles/…'` path), independent of where the demo keeps its styles.
-            const aliased = (await server.ssrLoadModule('client/styles/main.css?inline')) as {
-                default?: unknown;
-            };
-            expect(typeof aliased.default).toBe('string');
-        } finally {
-            await server.close();
-        }
-    }, 30000);
-
-    it('emailsVersion is a non-empty mtime:count fingerprint', async () => {
-        const cfg = await loadConfig({ root: EXAMPLE });
-        const v = emailsVersion(cfg);
-        expect(v).toMatch(/^\d+(\.\d+)?:\d+$/);
-        // at least Welcome.tsx + the client CSS files were counted
-        expect(Number(v.split(':')[1])).toBeGreaterThan(1);
-    });
-
-    it('the preview shell wires the dev endpoints', () => {
-        const html = previewShellHtml();
-        expect(html).toContain("var BASE = '/__toil/emails'");
-        for (const frag of ["BASE + '/list'", "BASE + '/render?name='", "BASE + '/version'"]) {
-            expect(html).toContain(frag);
-        }
-        expect(html).toContain('/__toil/open?file='); // open-in-editor
-    });
-});

package/test/emails.test.ts

@@ -1,58 +0,0 @@
-import { createElement, type ReactElement } from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-import { describe, expect, it } from 'vitest';
-
-import { __test } from '../src/compiler/emails';
-
-const render = (el: unknown): string => renderToStaticMarkup(el as ReactElement);
-
-describe('renderModule', () => {
-    it('discovers props as {{tokens}} and renders placeholders (alpha-sorted, deduped)', async () => {
-        const mod = {
-            default: (p: { name: string; code: string }) =>
-                createElement('p', null, `Hi ${p.name}, code ${p.code}`),
-        };
-        const r = await __test.renderModule('Welcome', mod, render);
-        if (!r) throw new Error('expected a rendered email');
-        expect(r.tokens).toEqual(['code', 'name']);
-        expect(r.html).toContain('{{name}}');
-        expect(r.html).toContain('{{code}}');
-    });
-
-    it('returns null when there is no default-exported component', async () => {
-        expect(await __test.renderModule('X', { default: 'nope' }, render)).toBeNull();
-    });
-
-    it('inlines imported CSS into element style="" (the reuse path)', async () => {
-        const mod = { default: () => createElement('h1', { className: 'email-title' }, 'Hello') };
-        const css = '.email-title { color: #111827; font-size: 22px; }';
-        const r = await __test.renderModule('Styled', mod, render, css);
-        if (!r) throw new Error('expected a rendered email');
-        // The class rule is moved onto the element as an inline style by the inliner.
-        expect(r.html).toMatch(/<h1[^>]*style="[^"]*color:\s*#111827/i);
-        expect(r.html).toMatch(/font-size:\s*22px/i);
-    });
-});
-
-describe('renderModuleSource', () => {
-    it('generates a typed Emails.<Name>.send with alpha-sorted token params', () => {
-        const src = __test.renderModuleSource([
-            {
-                name: 'Welcome',
-                subject: 'Welcome, {{name}}!',
-                html: '<p>{{code}}</p>',
-                text: 'code {{code}}',
-                tokens: ['code', 'name'],
-                purpose: 'welcome',
-            },
-        ]);
-        expect(src).toContain('export namespace Emails {');
-        expect(src).toContain('export namespace Welcome {');
-        expect(src).toContain(
-            'export function send(to: string, code: string, name: string, purpose: string = "welcome")',
-        );
-        expect(src).toContain(
-            'return new EmailTemplate(SUBJECT, TEXT, HTML).send(to, __v, purpose);',
-        );
-    });
-});

package/test/errors.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { parseError } from '../src/client/errors';
-
-describe('parseError', () => {
-    it('returns the message of an Error', () => {
-        expect(parseError(new Error('boom'))).toBe('boom');
-    });
-
-    it('stringifies non-Error values', () => {
-        expect(parseError('plain string')).toBe('plain string');
-        expect(parseError(42)).toBe('42');
-        expect(parseError(null)).toBe('null');
-        expect(parseError(undefined)).toBe('undefined');
-    });
-
-    it('reads the message of an Error subclass', () => {
-        class HttpError extends Error {}
-        expect(parseError(new HttpError('not found'))).toBe('not found');
-    });
-});

package/test/example-guestbook.test.ts

@@ -1,123 +0,0 @@
-/**
- * The `examples/basic` Guestbook demo: a @rest controller backed by ToilDB
- * (`events` + `counter`). Each dispatch runs a FRESH wasm instance (linear
- * memory resets between requests), so the only thing that can carry a signature
- * from one request to the next is ToilDB - which is exactly what the demo shows.
- * Contrast the `Players` route, whose own comment notes "memory resets next
- * request". Skips until the example server wasm is built (`npm run build:server`).
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { describe, expect, it, beforeEach } from 'vitest';
-
-import { WasmServerModule } from '../src/devserver/index.js';
-import { __resetDbForTests, configureDbPersistence } from '../src/devserver/db/index.js';
-
-const EXAMPLE_WASM = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    '../examples/basic/build/server/release.wasm',
-);
-const haveWasm = fs.existsSync(EXAMPLE_WASM);
-
-function load(): WasmServerModule {
-    const m = new WasmServerModule(EXAMPLE_WASM);
-    m.refresh();
-    return m;
-}
-function sign(m: WasmServerModule, author: string, message: string) {
-    return m.dispatch({
-        method: 'POST',
-        path: '/guestbook',
-        headers: [
-            ['host', 'localhost:3000'],
-            ['content-type', 'application/json'],
-        ],
-        body: new TextEncoder().encode(JSON.stringify({ author, message })),
-    });
-}
-function list(m: WasmServerModule) {
-    return m.dispatch({
-        method: 'GET',
-        path: '/guestbook',
-        headers: [['host', 'localhost:3000']],
-        body: new Uint8Array(0),
-    });
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const json = (r: { body: Uint8Array }): any => JSON.parse(Buffer.from(r.body).toString());
-
-describe.skipIf(!haveWasm)('guestbook demo: ToilDB events + counter persist across requests', () => {
-    beforeEach(() => __resetDbForTests());
-
-    it('starts empty after a reset', () => {
-        const v = json(list(load()));
-        expect(v.total).toBe('0'); // i64 rides JSON as a decimal string
-        expect(v.entries.length).toBe(0);
-    });
-
-    it('signatures persist across separate requests (a fresh instance each time)', () => {
-        let r = sign(load(), 'Ada', 'first!');
-        expect(r.status).toBe(200);
-        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. The action
-        // acks with the running total; the entries list is served by the GET.
-        r = sign(load(), 'Linus', 'second');
-        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!');
-    });
-
-    // End-to-end proof that the `server/migrations/GuestEntry.migration.ts` demo
-    // actually RUNS: write an entry under the current shape, downgrade it on disk to
-    // the original pre-`at` `GuestEntryV1` layout (drop the trailing u64 + re-stamp
-    // with v1's schema_version), then `list()` and confirm the woven decoder ran the
-    // `@migrate` - the entry comes back with the new `at` field defaulted to 0.
-    it('migrates an on-disk pre-`at` entry on read (the GuestEntry.migration demo fires)', () => {
-        const GUEST_ENTRY_V1_VERSION = 631968986; // layoutHash({author:string, message:string})
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gb-mig-'));
-        const file = path.join(dir, 'devdata.json');
-        try {
-            // 1. sign under the CURRENT shape (author, message, at); persistence flushes it.
-            configureDbPersistence(file);
-            expect(sign(load(), 'Ada', 'from the old days').status).toBe(200);
-
-            // 2. downgrade that event on disk to the v1 shape: GuestEntry encodes
-            //    author + message + at(u64), so dropping the trailing 8 bytes yields a
-            //    valid GuestEntryV1; re-stamp it with v1's schema_version.
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const snap: any = JSON.parse(fs.readFileSync(file, 'utf8'));
-            const evKey = Object.keys(snap.events)[0];
-            const buf = Buffer.from(snap.events[evKey][0].v, 'base64');
-            snap.events[evKey][0] = {
-                v: buf.subarray(0, buf.length - 8).toString('base64'),
-                sv: GUEST_ENTRY_V1_VERSION,
-            };
-            fs.writeFileSync(file, JSON.stringify(snap));
-
-            // 3. reload + list: the read surfaces v1's version, so the guest's woven
-            //    decoder runs the @migrate, copying author/message and defaulting at=0.
-            __resetDbForTests();
-            configureDbPersistence(file);
-            const v = json(list(load()));
-            expect(v.entries.length).toBe(1);
-            expect(v.entries[0].author).toBe('Ada');
-            expect(v.entries[0].message).toBe('from the old days');
-            expect(String(v.entries[0].at)).toBe('0'); // the migrated-in field
-        } finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});

package/test/features.test.ts

@@ -1,149 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-    defaultConfigSource,
-    detectPreprocessor,
-    detectTailwind,
-    packageDiff,
-    preprocessorForExt,
-    requiredPackages,
-    setConfigImages,
-    setStyleImports,
-    styleEntry,
-    type StyleFeatures,
-    styleImportLines,
-} from '../src/cli/features';
-
-const CSS: StyleFeatures = { preprocessor: 'css', tailwind: false };
-const SASS_TW: StyleFeatures = { preprocessor: 'sass', tailwind: true };
-
-describe('styleEntry / preprocessorForExt', () => {
-    it('maps preprocessors to stylesheet paths', () => {
-        expect(styleEntry('css')).toBe('styles/main.css');
-        expect(styleEntry('sass')).toBe('styles/main.scss');
-        expect(styleEntry('less')).toBe('styles/main.less');
-        expect(styleEntry('stylus')).toBe('styles/main.styl');
-    });
-
-    it('reverses extensions back to preprocessors', () => {
-        expect(preprocessorForExt('scss')).toBe('sass');
-        expect(preprocessorForExt('.sass')).toBe('sass');
-        expect(preprocessorForExt('less')).toBe('less');
-        expect(preprocessorForExt('styl')).toBe('stylus');
-        expect(preprocessorForExt('css')).toBe('css');
-        expect(preprocessorForExt('txt')).toBeNull();
-    });
-});
-
-describe('requiredPackages / packageDiff', () => {
-    it('lists packages for a feature set', () => {
-        expect(requiredPackages(CSS)).toEqual([]);
-        expect(requiredPackages({ preprocessor: 'sass', tailwind: false })).toEqual(['sass']);
-        expect(requiredPackages({ preprocessor: 'css', tailwind: true })).toEqual([
-            'tailwindcss',
-            '@tailwindcss/vite',
-        ]);
-    });
-
-    it('diffs add/remove between two setups', () => {
-        expect(packageDiff(CSS, SASS_TW)).toEqual({
-            add: ['sass', 'tailwindcss', '@tailwindcss/vite'],
-            remove: [],
-        });
-        expect(packageDiff(SASS_TW, CSS)).toEqual({
-            add: [],
-            remove: ['sass', 'tailwindcss', '@tailwindcss/vite'],
-        });
-        expect(
-            packageDiff(
-                { preprocessor: 'sass', tailwind: false },
-                { preprocessor: 'less', tailwind: false },
-            ),
-        ).toEqual({ add: ['less'], remove: ['sass'] });
-    });
-});
-
-describe('styleImportLines / setStyleImports', () => {
-    it('orders Tailwind before the main stylesheet', () => {
-        expect(styleImportLines(CSS)).toEqual(["import './styles/main.css';"]);
-        expect(styleImportLines(SASS_TW)).toEqual([
-            "import './styles/tailwind.css';",
-            "import './styles/main.scss';",
-        ]);
-    });
-
-    it('rewrites the app entry imports, preserving the rest', () => {
-        const src = [
-            "import { routes, layout, notFound } from 'toiljs/routes';",
-            '',
-            "import './styles/main.css';",
-            '',
-            'Toil.mount(routes, layout, notFound);',
-            '',
-        ].join('\n');
-
-        const out = setStyleImports(src, SASS_TW);
-        expect(out).toContain("import './styles/tailwind.css';");
-        expect(out).toContain("import './styles/main.scss';");
-        expect(out).not.toContain("import './styles/main.css';");
-        expect(out).toContain("from 'toiljs/routes'");
-        expect(out).toContain('Toil.mount(routes, layout, notFound);');
-    });
-
-    it('round-trips back to plain CSS (drops Tailwind import)', () => {
-        const src = [
-            "import { routes, layout, notFound } from 'toiljs/routes';",
-            "import './styles/tailwind.css';",
-            "import './styles/main.scss';",
-            'Toil.mount(routes, layout, notFound);',
-        ].join('\n');
-
-        const out = setStyleImports(src, CSS);
-        expect(out).toContain("import './styles/main.css';");
-        expect(out).not.toContain('tailwind.css');
-        expect(out).not.toContain('main.scss');
-    });
-});
-
-describe('detect from dependencies', () => {
-    it('finds the active preprocessor and Tailwind', () => {
-        expect(detectPreprocessor({ sass: '^1' })).toBe('sass');
-        expect(detectPreprocessor({ less: '^4' })).toBe('less');
-        expect(detectPreprocessor({})).toBe('css');
-        expect(detectTailwind({ '@tailwindcss/vite': '^4' })).toBe(true);
-        expect(detectTailwind({ react: '^19' })).toBe(false);
-    });
-});
-
-describe('setConfigImages / defaultConfigSource', () => {
-    it('flips an existing images flag', () => {
-        const src =
-            'export default defineConfig({\n    client: {\n        images: true,\n    },\n});\n';
-        expect(setConfigImages(src, false)).toContain('images: false');
-        expect(setConfigImages(src, false)).not.toContain('images: true');
-    });
-
-    it('adds images to an existing client block', () => {
-        const out = setConfigImages(
-            'export default defineConfig({ client: { base: "/" } });',
-            false,
-        );
-        expect(out).toContain('images: false');
-        expect(out).toContain('base: "/"');
-    });
-
-    it('adds a client block to a bare config', () => {
-        const out = setConfigImages('export default defineConfig({});', false);
-        expect(out).toContain('client: { images: false }');
-    });
-
-    it('returns null when the shape is unrecognized', () => {
-        expect(setConfigImages('const x = 1;', false)).toBeNull();
-    });
-
-    it('round-trips through defaultConfigSource', () => {
-        const src = defaultConfigSource(false);
-        expect(src).toContain('images: false');
-        expect(setConfigImages(src, true)).toContain('images: true');
-    });
-});

package/test/fixtures/bignum-wire/spec.ts

@@ -1,25 +0,0 @@
-// Fixture for the generated-client JSON wire-format test (test/rpc-bignum-wire.test.ts).
-// Compiled by the installed toilscript with --rpcModule, then the generated TS client is
-// imported and exercised. Covers every JSON bignum width plus a nested @data so the
-// recursive toJSONValue path is hit.
-
-@data
-class Wallet {
-    u: u64 = 0;
-    i: i64 = 0;
-    a: u128 = u128.Zero;
-    b: i128 = i128.Zero;
-    c: u256 = u256.Zero;
-    d: i256 = i256.Zero;
-    label: string = '';
-}
-
-@data
-class Account {
-    main: Wallet = new Wallet();
-    ids: u256[] = [];
-}
-
-// The two @data classes above ARE the surface: buildServerModule emits their codec + the bignum
-// helpers for any @data. (No @remote here - a @remote injects a server-side Rpc registration that
-// needs the full server runtime, which this `--runtime stub` fixture deliberately does not link.)

package/test/fixtures/daemon-app.ts

@@ -1,65 +0,0 @@
-// A minimal @daemon fixture for the dev daemon-emulation test. It declares the
-// daemon host imports directly (so it needs no toiljs globals lib) and records
-// its activity into resident daemon wasm memory. Compiled with `--targetMode cold`
-// by the test.
-//
-//   onStart()          -> increments `started` and stamps the lease epoch
-//   tick()  @scheduled -> increments `tickFast`   (1s interval)
-//   sixHourly() cron   -> increments `tickCron`   (0 */6 * * *)
-//
-// The imports live in the `daemon` wasm module with BARE names, as the edge
-// registers them; they are not dotted names under `env`. toilscript's stdlib
-// exposes the same surface as the ambient `Daemon` class (`~lib/daemon`), which
-// real daemons should use instead of hand-declaring these.
-
-// @ts-nocheck — this is AssemblyScript source compiled by toilscript, not TS.
-
-@external("daemon", "is_leader")
-declare function daemonIsLeader(): i32;
-
-@external("daemon", "current_epoch")
-declare function daemonCurrentEpoch(): i64;
-
-@external("daemon", "task_count")
-declare function daemonTaskCount(): i32;
-
-let started: i32 = 0;
-let leaderSeen: i32 = 0;
-let epochNonneg: i32 = 0;
-let taskcount2: i32 = 0;
-let tickFast: i32 = 0;
-let tickCron: i32 = 0;
-
-@daemon
-class Jobs {
-    onStart(): void {
-        // Prove leader=true and that the epoch import is callable; record both so
-        // the test can assert the stubs from outside.
-        started += 1;
-        if (daemonIsLeader() == 1) leaderSeen += 1;
-        let epoch = daemonCurrentEpoch();
-        if (epoch >= 0) epochNonneg += 1;
-        if (daemonTaskCount() == 2) taskcount2 += 1;
-    }
-
-    @scheduled("1s")
-    tick(): void {
-        tickFast += 1;
-    }
-
-    @scheduled("0 */6 * * *")
-    sixHourly(): void {
-        tickCron += 1;
-    }
-}
-
-export function startedCount(): i32 { return started; }
-export function leaderCount(): i32 { return leaderSeen; }
-export function epochNonnegCount(): i32 { return epochNonneg; }
-export function taskcount2Count(): i32 { return taskcount2; }
-export function tickFastCount(): i32 { return tickFast; }
-export function tickCronCount(): i32 { return tickCron; }
-
-export function probe(): i32 {
-    return 1;
-}

package/test/fixtures/stream-echo.ts

@@ -1,26 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-// 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 returns it as initial
-// egress and drains the ring 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

@@ -1,18 +0,0 @@
-// 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/fixtures/stream-typed.ts

@@ -1,41 +0,0 @@
-// A TYPED @stream fixture: @stream({ message: ChatMsg }) makes @message receive the DECODED @data
-// (doc 03 2.5), not raw bytes. The hook replies with the decoded text's length, so a host round-trip
-// proves the @data decode ran at runtime (not just compiled). The seed* exports hand the host a real
-// ChatMsg.encode() payload so the test never hand-crafts the @data wire format.
-
-@data
-class ChatMsg {
-  text: string = '';
-}
-
-@stream({ message: ChatMsg })
-class TypedChat {
-  @message
-  onMsg(m: ChatMsg): StreamOutbound {
-    // Reply with the DECODED text length (one byte): "hi" -> 2 proves the decode produced the string.
-    const r = new Uint8Array(1);
-    r[0] = <u8>m.text.length;
-    return StreamOutbound.reply(r);
-  }
-}
-
-// Seed buffer: the guest encodes a ChatMsg the host feeds back, so the host never hand-crafts @data
-// bytes (the encode/decode pair is the wire contract). A StaticArray<u8>'s pointer IS its data start.
-let seedBuf = new StaticArray<u8>(64);
-let seedLen: i32 = 0;
-
-export function seedHi(): void {
-  const m = new ChatMsg();
-  m.text = 'hi';
-  const b = m.encode();
-  seedLen = b.length;
-  for (let i = 0, n = b.length; i < n; i++) seedBuf[i] = b[i];
-}
-
-export function seedOffset(): i32 {
-  return changetype<i32>(seedBuf);
-}
-
-export function seedLength(): i32 {
-  return seedLen;
-}

package/test/fonts.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { fontPreloadTags } from '../src/compiler/fonts';
-
-describe('fontPreloadTags', () => {
-    it('builds a crossorigin preload link per font, skipping non-fonts', () => {
-        const tags = fontPreloadTags(['fonts/a-abc.woff2', 'assets/x-1.js', 'fonts/b.ttf'], '/');
-        expect(tags).toHaveLength(2);
-        expect(tags[0]).toEqual({
-            tag: 'link',
-            attrs: {
-                rel: 'preload',
-                as: 'font',
-                type: 'font/woff2',
-                href: '/fonts/a-abc.woff2',
-                crossorigin: '',
-            },
-            injectTo: 'head',
-        });
-        expect(tags[1].attrs?.type).toBe('font/ttf');
-    });
-
-    it('respects a non-root base path', () => {
-        expect(fontPreloadTags(['fonts/a.woff2'], '/app/')[0].attrs?.href).toBe(
-            '/app/fonts/a.woff2',
-        );
-    });
-});