toiljs 0.0.116 → 0.0.118

package/src/shared/index.ts

@@ -1,46 +0,0 @@
-/**
- * Shared primitives used across every toiljs target (client, compiler, cli, server tooling).
- * Placeholder, real shared types/utilities land here.
- */
-
-export const FRAMEWORK_NAME = 'toiljs';
-
-export interface ToilTarget {
-    readonly name: 'client' | 'compiler' | 'cli' | 'server';
-}
-
-/** SMTP connection config (non-secret) for the `smtp` / `gmail` providers. */
-export interface SmtpBackendConfig {
-    /** SMTP host. Empty + provider `gmail` defaults to `smtp.gmail.com`. */
-    readonly host?: string;
-    /** Submission port. `0`/unset defaults to 587 (STARTTLS); 465 = implicit TLS. */
-    readonly port?: number;
-    /** SMTP username. Defaults to `from`. */
-    readonly user?: string;
-}
-
-/**
- * The **non-secret** email backend config — the typed `email` section of
- * `toil.config.ts` (`server.email`), consumed by the dev server and the future
- * Node self-host. The provider API key / SMTP password is a SECRET and is NEVER
- * here: it comes from `.env.secrets` (`TOIL_EMAIL_API_KEY`). Any `TOIL_EMAIL_*`
- * env var overrides the matching field here.
- *
- * Mirrors the edge's `TOIL_EMAIL_*` keys (toil-backend `host/email.rs`
- * `EmailSection`). Lives in `toiljs/shared` so both the compiler (config schema)
- * and the dev server (resolver) can reference it regardless of build order.
- */
-export interface EmailBackendConfig {
-    /** `"resend"` (JSON API) | `"gmail"` | `"smtp"` (SMTP). Default `"resend"`. */
-    readonly provider?: 'resend' | 'gmail' | 'smtp';
-    /** The "from" address. Validated (single address, no CRLF). */
-    readonly from?: string;
-    /** Per-process send ceiling, sends/minute (rolling). `0` = unlimited. Default 60. */
-    readonly maxPerMin?: number;
-    /** Per-process send ceiling, sends/day (rolling). `0` = unlimited. Default 0. */
-    readonly maxPerDay?: number;
-    /** Per-recipient hourly cap (anti-abuse). Default 5. */
-    readonly maxPerRecipientPerHour?: number;
-    /** SMTP connection details (the `gmail` / `smtp` providers). */
-    readonly smtp?: SmtpBackendConfig;
-}

package/test/analytics-dev.test.ts

@@ -1,113 +0,0 @@
-/**
- * Dev-server analytics stub parity: the `env.analytics_read` / `env.analytics_series` dev imports must
- * encode the v3 frames BYTE-FOR-BYTE like the edge (`analytics.rs`), so a guest's toilscript `Analytics`
- * decode is identical in dev and prod. We decode the stashed frame positionally, exactly as the guest.
- */
-import { describe, expect, it } from 'vitest';
-
-import { buildAnalyticsImports } from '../src/devserver/analytics/index.js';
-
-// Minimal fakes: domainLen 0 needs no memory; the stub stashes the frame into db.lastResult.
-function harness() {
-    const ref = { memory: null } as unknown as Parameters<typeof buildAnalyticsImports>[0];
-    const db = { lastResult: null as Buffer | null, lastResultVersion: 0 } as unknown as Parameters<
-        typeof buildAnalyticsImports
-    >[1];
-    return { imports: buildAnalyticsImports(ref, db), db };
-}
-
-describe('dev analytics stub v3 frame parity', () => {
-    it('analytics_read encodes the fixed-layout snapshot frame', () => {
-        const { imports, db } = harness();
-        const n = imports.analytics_read(0, 0);
-        const buf = db.lastResult as unknown as Buffer;
-        expect(n).toBe(buf.length);
-
-        let p = 0;
-        const u16 = () => { const v = buf.readUInt16LE(p); p += 2; return v; };
-        const u32 = () => { const v = buf.readUInt32LE(p); p += 4; return v; };
-        const u64 = () => { const v = buf.readBigUInt64LE(p); p += 8; return v; };
-        const f64 = () => { const v = buf.readDoubleLE(p); p += 8; return v; };
-
-        expect(u16()).toBe(3); // FRAME_VERSION
-        u64(); // now_ms
-        const count = u32();
-        expect(count).toBe(42); // METRIC_COUNTERS (edge N_COUNTERS; no WasmDispatches)
-        const life: bigint[] = [];
-        for (let i = 0; i < count; i++) life.push(u64()); // counters are u64 LE now
-        // Indices are the AUTHORITATIVE edge MetricId ids (metric_id.rs): a mislabel here means the dev
-        // dashboard shows the wrong metric for every id past StaticHits.
-        expect(life[0]).toBe(42n); // Requests (id 0)
-        expect(life[1]).toBe(12345n); // BytesOutL1 (id 1)
-        expect(life[11]).toBe(1_000_000n); // GasUsed (id 11, was 12 in the stale layout)
-        expect(life[40]).toBe(900n); // CacheHits (id 40, was 41)
-        expect(life[41]).toBe(100n); // CacheMisses (id 41, was 42)
-        expect(u64()).toBe(3n); // connectedStreams
-        expect(u64()).toBe(65536n); // committedMemory
-        expect(u64()).toBe(1_200n); // reqBurstUsed (current 3-min tumbling bucket)
-        expect(u64()).toBe(180_000n); // reqBurstCap (sustained 1000 rps * 180s window)
-        expect(u64()).toBe(250_000n); // req30dUsed (current 30-day bucket)
-        expect(u64()).toBe(10_000_000n); // req30dCap (30-day quota)
-        // 7 LIVE per-second rates (f64 LE), appended after the windows.
-        expect(f64()).toBeCloseTo(0.7); // rps
-        expect(f64()).toBeCloseTo(68.2); // bytesInPerSec
-        expect(f64()).toBeCloseTo(205.75); // bytesOutPerSec
-        expect(f64()).toBeCloseTo(34.1); // streamBytesInPerSec
-        expect(f64()).toBeCloseTo(136.5); // streamBytesOutPerSec
-        expect(f64()).toBeCloseTo(0.28); // dbOpsPerSec
-        expect(f64()).toBeCloseTo(16_666.67); // gasPerSec
-        expect(p).toBe(buf.length); // no trailing bytes
-    });
-
-    it('analytics_series encodes the series frame with the right shape per range', () => {
-        const { imports, db } = harness();
-        // metric 0 (Requests), range 3 (H24) -> hour ring, 24 buckets, bucketSecs 3600.
-        const n = imports.analytics_series(0, 0, 0, 3);
-        const buf = db.lastResult as unknown as Buffer;
-        expect(n).toBe(buf.length);
-        let p = 0;
-        expect(buf.readUInt16LE(p)).toBe(3); p += 2; // version
-        expect(buf.readUInt16LE(p)).toBe(0); p += 2; // metric id
-        expect(buf.readUInt32LE(p)).toBe(3600); p += 4; // bucketSecs
-        p += 8; // headMs
-        const count = buf.readUInt32LE(p); p += 4;
-        expect(count).toBe(24);
-        expect(buf.length).toBe(p + count * 8);
-
-        // range 0 (1h) -> minute ring: 60 buckets, bucketSecs 60.
-        imports.analytics_series(0, 0, 0, 0);
-        const b2 = db.lastResult as unknown as Buffer;
-        expect(b2.readUInt32LE(4)).toBe(60); // bucketSecs
-        expect(b2.readUInt32LE(16)).toBe(60); // count
-
-        // F1 guard: a minute-ring metric OTHER than Requests must ALSO get minute resolution on 1h.
-        // GasUsed(11) is in the edge minute ring; a stale dev set fell back to the hour ring here.
-        imports.analytics_series(0, 0, 11, 0); // GasUsed, 1h
-        const bGas = db.lastResult as unknown as Buffer;
-        expect(bGas.readUInt32LE(4)).toBe(60); // minute bucketSecs (was wrongly 3600 pre-fix)
-        expect(bGas.readUInt32LE(16)).toBe(60); // 60 minute buckets (was wrongly 1)
-        // A metric NOT in the minute ring (Status2xx=3) falls back to the hour ring on 1h.
-        imports.analytics_series(0, 0, 3, 0);
-        const bStat = db.lastResult as unknown as Buffer;
-        expect(bStat.readUInt32LE(4)).toBe(3600); // hour bucketSecs
-        expect(bStat.readUInt32LE(16)).toBe(1); // 1 hour bucket
-
-        // range 8 (D60) + 9 (D90) -> DAY ring: 60/90 buckets, bucketSecs 86400.
-        imports.analytics_series(0, 0, 0, 8);
-        const b60 = db.lastResult as unknown as Buffer;
-        expect(b60.readUInt32LE(4)).toBe(86_400); // bucketSecs
-        expect(b60.readUInt32LE(16)).toBe(60); // count
-        imports.analytics_series(0, 0, 0, 9);
-        const b90 = db.lastResult as unknown as Buffer;
-        expect(b90.readUInt32LE(4)).toBe(86_400); // bucketSecs
-        expect(b90.readUInt32LE(16)).toBe(90); // count
-
-        // A bad metric / range -> ABSENT (negative), no frame. Range 10 is past D90.
-        expect(imports.analytics_series(0, 0, 999, 3)).toBeLessThan(0);
-        expect(imports.analytics_series(0, 0, 0, 99)).toBeLessThan(0);
-        expect(imports.analytics_series(0, 0, 0, 10)).toBeLessThan(0);
-        // F2: valid ids are 0..=45 (gauges 42..=45); 46 is past the end and must be rejected like the edge.
-        expect(imports.analytics_series(0, 0, 46, 3)).toBeLessThan(0);
-        expect(imports.analytics_series(0, 0, 45, 3)).toBeGreaterThan(0); // gauge id 45 is valid
-    });
-});

package/test/assembly/aspect-shim.ts

@@ -1,33 +0,0 @@
-// A minimal in-AssemblyScript test shim for this directory's assembly specs.
-// `describe`/`it` run their bodies inline; `expect(x).toBe(y)` / `.toStrictEqual(y)` assert
-// `x == y` (value-equality, which covers the bool / i32 / string the specs compare). A failed
-// assertion aborts with the current test name; the vitest runner (../assembly.test.ts) compiles
-// each spec with toilscript, runs `_start`, and surfaces the abort as a test failure.
-
-let currentTest: string = '';
-
-export function describe(_name: string, fn: () => void): void {
-    fn();
-}
-
-export function it(name: string, fn: () => void): void {
-    currentTest = name;
-    fn();
-}
-
-export class Expectation<T> {
-    private actual: T;
-    constructor(actual: T) {
-        this.actual = actual;
-    }
-    toBe(expected: T): void {
-        assert(this.actual == expected, currentTest);
-    }
-    toStrictEqual(expected: T): void {
-        assert(this.actual == expected, currentTest);
-    }
-}
-
-export function expect<T>(actual: T): Expectation<T> {
-    return new Expectation<T>(actual);
-}

package/test/assembly/cookie.spec.ts

@@ -1,303 +0,0 @@
-// Pure cookie logic (builder, parser, codec, validation, Request/Response
-// integration). Imports the specific modules rather than the runtime index so
-// `securecookies.ts` is not pulled into the as-pect graph: it depends on the
-// toilscript crypto std (`crypto` / `data` / `bindings/webcrypto`), which the
-// as-pect compiler does not ship. `SecureCookies`
-// is exercised end-to-end against the real toilscript-compiled wasm in
-// `test/devserver.test.ts`.
-import { describe, it, expect } from './aspect-shim';
-import { Method, Request, Header } from '../../server/runtime/request';
-import { Response } from '../../server/runtime/response';
-import { Cookie, SameSite, CookieEncoding } from '../../server/runtime/http/cookie';
-import { Cookies } from '../../server/runtime/http/cookies';
-
-// --- helpers ----------------------------------------------------------------
-
-function headerValue(r: Response, name: string): string {
-    for (let i = 0; i < r.headers.length; i++) {
-        if (r.headers[i].name == name) return r.headers[i].value;
-    }
-    return '';
-}
-
-function headerCount(r: Response, name: string): i32 {
-    let n = 0;
-    for (let i = 0; i < r.headers.length; i++) {
-        if (r.headers[i].name == name) n++;
-    }
-    return n;
-}
-
-function reqWithCookie(value: string): Request {
-    const headers = new Array<Header>();
-    headers.push(new Header('Cookie', value));
-    return new Request(Method.GET, '/', headers, new Uint8Array(0));
-}
-
-// --- Cookie builder / serialize --------------------------------------------
-
-describe('Cookie.serialize', () => {
-    it('serializes a bare name=value', () => {
-        expect<string>(Cookie.create('a', 'b').serialize()).toStrictEqual('a=b');
-    });
-
-    it('percent-encodes the value by default', () => {
-        expect<string>(Cookie.create('x', 'hello world').serialize()).toStrictEqual('x=hello%20world');
-    });
-
-    it('leaves a Raw value untouched', () => {
-        expect<string>(
-            Cookie.create('x', 'abc').withEncoding(CookieEncoding.Raw).serialize(),
-        ).toStrictEqual('x=abc');
-    });
-
-    it('base64url-encodes when asked', () => {
-        expect<string>(
-            Cookie.create('x', 'hi').withEncoding(CookieEncoding.Base64Url).serialize(),
-        ).toStrictEqual('x=aGk');
-    });
-
-    it('emits attributes in a stable order', () => {
-        const s = Cookie.create('a', 'b')
-            .domain('example.com')
-            .path('/p')
-            .secure()
-            .httpOnly()
-            .sameSite(SameSite.Lax)
-            .maxAge(60)
-            .serialize();
-        expect<string>(s).toStrictEqual('a=b; Domain=example.com; Path=/p; Max-Age=60; SameSite=Lax; Secure; HttpOnly');
-    });
-
-    it('auto-adds Secure for SameSite=None', () => {
-        expect<string>(Cookie.create('a', 'b').sameSite(SameSite.None).serialize()).toStrictEqual(
-            'a=b; SameSite=None; Secure',
-        );
-    });
-
-    it('auto-adds Secure for Partitioned (CHIPS)', () => {
-        expect<string>(Cookie.create('a', 'b').partitioned().serialize()).toStrictEqual(
-            'a=b; Secure; Partitioned',
-        );
-    });
-
-    it('formats Expires from epoch seconds as an IMF-fixdate', () => {
-        expect<string>(Cookie.create('a', 'b').expires(784111777).serialize()).toStrictEqual(
-            'a=b; Expires=Sun, 06 Nov 1994 08:49:37 GMT',
-        );
-    });
-
-    it('formats the epoch as the IMF-fixdate zero point', () => {
-        expect<string>(Cookie.create('a', 'b').expires(0).serialize()).toStrictEqual(
-            'a=b; Expires=Thu, 01 Jan 1970 00:00:00 GMT',
-        );
-    });
-
-    it('clamps Max-Age to the 400-day cap', () => {
-        expect<string>(Cookie.create('a', 'b').maxAge(99999999).serialize()).toStrictEqual(
-            'a=b; Max-Age=34560000',
-        );
-    });
-
-    it('applies the __Host- prefix with its required attributes', () => {
-        expect<string>(Cookie.create('sid', 'x').asHostPrefixed().serialize()).toStrictEqual(
-            '__Host-sid=x; Path=/; Secure',
-        );
-    });
-
-    it('applies the __Secure- prefix', () => {
-        expect<string>(Cookie.create('sid', 'x').asSecurePrefixed().serialize()).toStrictEqual(
-            '__Secure-sid=x; Secure',
-        );
-    });
-
-    it('emits Priority and extension attributes', () => {
-        expect<string>(
-            Cookie.create('a', 'b').priority('High').extension('CustomFlag').serialize(),
-        ).toStrictEqual('a=b; Priority=High; CustomFlag');
-    });
-
-    it('percent-encodes CR/LF in a default-encoded value (no header injection)', () => {
-        expect<string>(Cookie.create('a', 'b\r\nc').serialize()).toStrictEqual('a=b%0D%0Ac');
-    });
-
-    it('strips control characters from a raw value', () => {
-        expect<string>(
-            Cookie.create('a', 'b\r\nInjected').withEncoding(CookieEncoding.Raw).serialize(),
-        ).toStrictEqual('a=bInjected');
-    });
-
-    it('strips control characters from the name', () => {
-        expect<string>(new Cookie('a\r\nb', 'v').serialize()).toStrictEqual('ab=v');
-    });
-
-    it('strips semicolons from a raw value (no attribute injection)', () => {
-        expect<string>(
-            Cookie.create('a', 'b; Secure').withEncoding(CookieEncoding.Raw).serialize(),
-        ).toStrictEqual('a=b Secure');
-    });
-
-    it('reduces the name to token chars (no attribute injection)', () => {
-        expect<string>(new Cookie('a;Domain=evil', 'v').serialize()).toStrictEqual('aDomainevil=v');
-    });
-});
-
-// --- validation -------------------------------------------------------------
-
-describe('Cookie.validate', () => {
-    it('accepts a well-formed cookie', () => {
-        expect<bool>(Cookie.create('ok', 'v').validate().valid).toBe(true);
-    });
-
-    it('rejects a name that is not a token', () => {
-        expect<bool>(Cookie.create('bad name', 'v').validate().valid).toBe(false);
-    });
-
-    it('rejects an empty name', () => {
-        expect<bool>(Cookie.create('', 'v').validate().valid).toBe(false);
-    });
-
-    it('rejects a Path that does not start with /', () => {
-        expect<bool>(Cookie.create('a', 'b').path('nope').validate().valid).toBe(false);
-    });
-
-    it('rejects name+value over 4096 bytes', () => {
-        expect<bool>(Cookie.create('a', 'x'.repeat(5000)).validate().valid).toBe(false);
-    });
-
-    it('rejects a __Host- name without its required attributes', () => {
-        const v = new Cookie('__Host-x', 'v').validate();
-        expect<bool>(v.valid).toBe(false);
-        expect<bool>(v.errors.length > 0).toBe(true);
-    });
-
-    it('accepts a correctly-formed __Host- cookie', () => {
-        expect<bool>(Cookie.create('x', 'v').asHostPrefixed().validate().valid).toBe(true);
-    });
-
-    it('flags a Max-Age beyond the 400-day cap', () => {
-        expect<bool>(Cookie.create('a', 'b').maxAge(99999999).validate().valid).toBe(false);
-    });
-});
-
-// --- Cookies.parse ----------------------------------------------------------
-
-describe('Cookies.parse', () => {
-    it('parses multiple cookies', () => {
-        const m = Cookies.parse('a=1; b=2');
-        expect<i32>(m.size).toBe(2);
-        expect<string>(m.get('a')!).toStrictEqual('1');
-        expect<string>(m.get('b')!).toStrictEqual('2');
-    });
-
-    it('returns null for a missing cookie', () => {
-        expect<bool>(Cookies.parse('a=1').get('x') == null).toBe(true);
-    });
-
-    it('keeps everything after the first = in the value', () => {
-        expect<string>(Cookies.parse('token=ab=cd').get('token')!).toStrictEqual('ab=cd');
-    });
-
-    it('trims surrounding whitespace around name and value', () => {
-        expect<string>(Cookies.parse('  a = 1 ; b=2').get('a')!).toStrictEqual('1');
-    });
-
-    it('strips one layer of surrounding quotes', () => {
-        expect<string>(Cookies.parse('a="hello"').get('a')!).toStrictEqual('hello');
-    });
-
-    it('percent-decodes values', () => {
-        expect<string>(Cookies.parse('x=hello%20world').get('x')!).toStrictEqual('hello world');
-    });
-
-    it('keeps the first occurrence of a duplicate name', () => {
-        expect<string>(Cookies.parse('a=1; a=2').get('a')!).toStrictEqual('1');
-    });
-
-    it('handles an empty header', () => {
-        expect<i32>(Cookies.parse('').size).toBe(0);
-    });
-
-    it('handles a valueless cookie', () => {
-        const m = Cookies.parse('flag');
-        expect<bool>(m.has('flag')).toBe(true);
-        expect<string>(m.get('flag')!).toStrictEqual('');
-    });
-});
-
-// --- value codec ------------------------------------------------------------
-
-describe('Cookies value codec', () => {
-    it('percent-encodes special characters', () => {
-        expect<string>(Cookies.encodeValue('a b&c')).toStrictEqual('a%20b%26c');
-    });
-
-    it('round-trips arbitrary UTF-8', () => {
-        const original = 'héllo, world! +/=';
-        expect<string>(Cookies.decodeValue(Cookies.encodeValue(original))).toStrictEqual(original);
-    });
-});
-
-// --- parseSetCookie ---------------------------------------------------------
-
-describe('Cookies.parseSetCookie', () => {
-    it('round-trips a serialized cookie', () => {
-        const wire = Cookie.create('a', 'hello world')
-            .domain('x.com')
-            .path('/')
-            .secure()
-            .httpOnly()
-            .sameSite(SameSite.Lax)
-            .maxAge(60)
-            .serialize();
-        expect<string>(Cookies.parseSetCookie(wire).serialize()).toStrictEqual(wire);
-    });
-
-    it('parses individual attributes', () => {
-        const c = Cookies.parseSetCookie('sid=abc; Path=/; HttpOnly; SameSite=Strict');
-        expect<string>(c.name).toStrictEqual('sid');
-        expect<string>(c.value).toStrictEqual('abc');
-    });
-});
-
-// --- Request / Response integration -----------------------------------------
-
-describe('Request cookies', () => {
-    it('reads a cookie by name', () => {
-        expect<string>(reqWithCookie('a=1; b=2').cookie('a')!).toStrictEqual('1');
-    });
-
-    it('returns null for a missing cookie', () => {
-        expect<bool>(reqWithCookie('a=1').cookie('missing') == null).toBe(true);
-    });
-
-    it('exposes the full jar', () => {
-        expect<i32>(reqWithCookie('a=1; b=2; c=3').cookies().size).toBe(3);
-    });
-});
-
-describe('Response cookies', () => {
-    it('adds a Set-Cookie header', () => {
-        const r = Response.text('x').setCookie(Cookie.create('a', 'b'));
-        expect<string>(headerValue(r, 'set-cookie')).toStrictEqual('a=b');
-    });
-
-    it('emits one Set-Cookie header per cookie (never folded)', () => {
-        const r = Response.empty(200)
-            .setCookie(Cookie.create('a', 'b'))
-            .setCookie(Cookie.create('c', 'd'));
-        expect<i32>(headerCount(r, 'set-cookie')).toBe(2);
-    });
-
-    it('setCookieKV is a shorthand', () => {
-        const r = Response.empty(200).setCookieKV('a', 'b');
-        expect<string>(headerValue(r, 'set-cookie')).toStrictEqual('a=b');
-    });
-
-    it('clearCookie emits an expired cookie', () => {
-        const r = Response.empty(200).clearCookie('a');
-        expect<string>(headerValue(r, 'set-cookie')).toStrictEqual(
-            'a=; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0',
-        );
-    });
-});

package/test/assembly/example.spec.ts

@@ -1,22 +0,0 @@
-// Imports the specific modules rather than the runtime index: the index
-// re-exports `SecureCookies`, which depends on the toilscript crypto std the
-// as-pect compiler does not ship (see test/assembly/cookie.spec.ts).
-import { describe, it, expect } from './aspect-shim';
-import { Method } from '../../server/runtime/request';
-import { Response } from '../../server/runtime/response';
-
-describe('server runtime', () => {
-    it('numbers the HTTP methods per the wire contract', () => {
-        expect<i32>(<i32>Method.GET).toBe(0);
-        expect<i32>(<i32>Method.POST).toBe(1);
-        expect<i32>(<i32>Method.HEAD).toBe(5);
-    });
-
-    it('builds a 200 text response by default', () => {
-        expect<i32>(<i32>Response.text('hi').status).toBe(200);
-    });
-
-    it('defaults notFound() to 404', () => {
-        expect<i32>(<i32>Response.notFound().status).toBe(404);
-    });
-});

package/test/assembly/ssr.spec.ts

@@ -1,95 +0,0 @@
-// Imports specific SSR modules (not the runtime index, which pulls in the
-// crypto std the as-pect compiler does not ship). These modules are pure
-// (escaping + buffer building + linear-memory encode), so they run under
-// as-pect; the full `render` export is exercised via the example wasm in
-// test/devserver.test.ts.
-import { describe, it, expect } from './aspect-shim';
-import { escapeHtml, escapeJsonForScript } from '../../server/runtime/ssr/escape';
-import { HASH_LEN, HtmlBuilder, SlotKind, SlotValues } from '../../server/runtime/ssr/slots';
-import { encodeValues } from '../../server/runtime/ssr/encode';
-
-function bytesToStr(b: Uint8Array): string {
-    return String.UTF8.decodeUnsafe(changetype<usize>(b.dataStart), b.length);
-}
-
-describe('ssr escape (react-dom byte-identity)', () => {
-    it('passes clean text through unchanged', () => {
-        expect<string>(escapeHtml('hello world')).toStrictEqual('hello world');
-    });
-
-    it('escapes the five React characters with React entities', () => {
-        // React uses &#x27; for the apostrophe and &quot; for the quote.
-        expect<string>(escapeHtml('<a href="x">A&B\'s</a>')).toStrictEqual(
-            '&lt;a href=&quot;x&quot;&gt;A&amp;B&#x27;s&lt;/a&gt;',
-        );
-    });
-
-    it('escapes ampersand first-class (not double-encoding)', () => {
-        expect<string>(escapeHtml('a & b')).toStrictEqual('a &amp; b');
-        expect<string>(escapeHtml('&amp;')).toStrictEqual('&amp;amp;');
-    });
-
-    it('escapes script-context json delimiters', () => {
-        expect<string>(escapeJsonForScript('{"x":"</script>"}')).toStrictEqual(
-            '{"x":"\\u003c/script\\u003e"}',
-        );
-        expect<string>(escapeJsonForScript('{"a":1}')).toStrictEqual('{"a":1}');
-    });
-});
-
-describe('ssr SlotValues', () => {
-    it('escapes text holes and leaves raw holes verbatim', () => {
-        const v = new SlotValues(new StaticArray<u8>(HASH_LEN));
-        v.setText(0, '<b>');
-        v.setRaw(1, '<b>ok</b>');
-        expect<i32>(v.slots.length).toBe(2);
-        expect<i32>(<i32>v.slots[0].kind).toBe(<i32>SlotKind.TEXT);
-        expect<string>(bytesToStr(v.slots[0].bytes)).toStrictEqual('&lt;b&gt;');
-        expect<i32>(<i32>v.slots[1].kind).toBe(<i32>SlotKind.RAW);
-        expect<string>(bytesToStr(v.slots[1].bytes)).toStrictEqual('<b>ok</b>');
-    });
-
-    it('stamps repeat rows by interleaving raw chunks and escaped values', () => {
-        const v = new SlotValues(new StaticArray<u8>(HASH_LEN));
-        const rows = new HtmlBuilder();
-        const items = ['a&b', 'c'];
-        for (let i = 0; i < items.length; i++) {
-            rows.raw('<li>').text(items[i]).raw('</li>');
-        }
-        v.setRepeat(2, rows);
-        expect<i32>(<i32>v.slots[0].kind).toBe(<i32>SlotKind.REPEAT);
-        expect<string>(bytesToStr(v.slots[0].bytes)).toStrictEqual(
-            '<li>a&amp;b</li><li>c</li>',
-        );
-    });
-});
-
-describe('ssr encodeValues wire format', () => {
-    it('round-trips status, hash, and one text slot', () => {
-        const hash = new StaticArray<u8>(HASH_LEN);
-        hash[0] = 0xaa;
-        hash[31] = 0xbb;
-        const v = new SlotValues(hash);
-        v.setStatus(200);
-        v.setText(7, 'hi');
-
-        const buf = new Uint8Array(128);
-        const base = changetype<usize>(buf.dataStart);
-        const n = encodeValues(v, base);
-        // status(2) + hash(32) + n_headers(2) + n_slots(2) + slot[id(2)+kind(1)+len(4)+"hi"(2)]
-        expect<i32>(<i32>n).toBe(2 + 32 + 2 + 2 + 2 + 1 + 4 + 2);
-
-        expect<i32>(<i32>load<u16>(base)).toBe(200); // status
-        expect<i32>(<i32>load<u8>(base + 2)).toBe(0xaa); // hash[0]
-        expect<i32>(<i32>load<u8>(base + 2 + 31)).toBe(0xbb); // hash[31]
-        const afterHash = base + 2 + 32;
-        expect<i32>(<i32>load<u16>(afterHash)).toBe(0); // n_headers
-        expect<i32>(<i32>load<u16>(afterHash + 2)).toBe(1); // n_slots
-        const slot = afterHash + 4;
-        expect<i32>(<i32>load<u16>(slot)).toBe(7); // slot_id
-        expect<i32>(<i32>load<u8>(slot + 2)).toBe(<i32>SlotKind.TEXT); // kind
-        expect<i32>(<i32>load<u32>(slot + 3)).toBe(2); // value_len
-        expect<i32>(<i32>load<u8>(slot + 7)).toBe(0x68); // 'h'
-        expect<i32>(<i32>load<u8>(slot + 8)).toBe(0x69); // 'i'
-    });
-});

package/test/assembly.test.ts

@@ -1,59 +0,0 @@
-// Runs the AssemblyScript specs in test/assembly/*.spec.ts by compiling each with toilscript and
-// executing its `_start` (which runs the describe/it bodies + the shim's asserts). A failed assert
-// aborts; this runner surfaces it as a vitest failure. Runs them via toilscript, no external runner.
-import { describe, it } from 'vitest';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const TOILSCRIPT_BIN = join(here, '..', 'node_modules', 'toilscript', 'bin', 'toilscript.js');
-const SPECS = ['example', 'cookie', 'ssr'] as const;
-
-function liftString(ptr: number, mem: WebAssembly.Memory): string {
-    if (!ptr) return '(no message)';
-    const u32 = new Uint32Array(mem.buffer);
-    const len = (u32[(ptr - 4) >>> 2] >>> 1) >>> 0;
-    const u16 = new Uint16Array(mem.buffer);
-    let s = '';
-    const start = ptr >>> 1;
-    for (let i = 0; i < len; i++) s += String.fromCharCode(u16[start + i]);
-    return s;
-}
-
-describe('assembly specs (toilscript-compiled)', () => {
-    for (const spec of SPECS) {
-        it(`${spec}.spec.ts passes`, async () => {
-            const tmp = mkdtempSync(join(tmpdir(), 'toiljs-asm-'));
-            try {
-                const src = join(here, 'assembly', `${spec}.spec.ts`);
-                const out = join(tmp, `${spec}.wasm`);
-                const r = spawnSync(
-                    'node',
-                    [TOILSCRIPT_BIN, src, '-o', out, '--exportStart', '_start', '--runtime', 'stub'],
-                    { encoding: 'utf8' },
-                );
-                if (r.status !== 0) {
-                    throw new Error(`toilscript compile ${spec}.spec.ts failed:\n${r.stderr}${r.stdout}`);
-                }
-                const wasm = readFileSync(out);
-                const holder: { mem: WebAssembly.Memory | null } = { mem: null };
-                const { instance } = await WebAssembly.instantiate(wasm, {
-                    env: {
-                        abort(msg: number, _file: number, line: number): void {
-                            const m = holder.mem ? liftString(msg >>> 0, holder.mem) : '';
-                            throw new Error(`${spec}.spec.ts assertion failed: "${m}" (line ${line})`);
-                        },
-                        seed: () => 0,
-                    },
-                });
-                holder.mem = instance.exports.memory as WebAssembly.Memory;
-                (instance.exports._start as () => void)();
-            } finally {
-                rmSync(tmp, { recursive: true, force: true });
-            }
-        });
-    }
-});