npm - toiljs - Versions diffs - 0.0.74 → 0.0.76 - Mend

toiljs 0.0.74 → 0.0.76

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/CHANGELOG.md +19 -0
package/TYPESCRIPT_LAW.md +1 -3
package/build/client/.tsbuildinfo +1 -1
package/build/client/components/Image.js +11 -14
package/build/compiler/.tsbuildinfo +1 -1
package/build/compiler/generate.js +9 -0
package/build/compiler/template-build.d.ts +4 -0
package/build/compiler/template-build.js +11 -1
package/build/devserver/.tsbuildinfo +1 -1
package/build/devserver/runtime/module.js +2 -0
package/build/devserver/stream/index.d.ts +2 -1
package/build/devserver/stream/index.js +3 -11
package/build/devserver/stream/manager.d.ts +2 -0
package/build/devserver/stream/manager.js +7 -6
package/build/devserver/stream/ws.js +4 -0
package/package.json +2 -9
package/src/client/components/Image.tsx +18 -13
package/src/compiler/generate.ts +16 -0
package/src/compiler/template-build.ts +32 -1
package/src/devserver/runtime/module.ts +3 -0
package/src/devserver/stream/index.ts +8 -19
package/src/devserver/stream/manager.ts +15 -11
package/src/devserver/stream/ws.ts +2 -0
package/test/assembly/aspect-shim.ts +33 -0
package/test/assembly/cookie.spec.ts +1 -0
package/test/assembly/example.spec.ts +1 -0
package/test/assembly/ssr.spec.ts +1 -0
package/test/assembly.test.ts +59 -0
package/test/dom/Image.test.tsx +25 -2
package/test/fixtures/stream-gate.ts +19 -15
package/test/ssr-template.test.tsx +54 -0
package/test/stream-emulation.test.ts +56 -10
package/vitest.config.ts +2 -1
package/as-pect.asconfig.json +0 -34
package/as-pect.config.js +0 -71

package/src/compiler/generate.ts CHANGED Viewed

@@ -404,6 +404,15 @@ const DEFAULT_HTML =
 /** The module entry that boots the app, injected into the HTML (resolved relative to `.toil`). */
 const ENTRY_SCRIPT = `<script type="module" src="./entry.tsx"></script>`;
+/** Toil's component base CSS, baked into the shell `<head>` so built-in components (the `Image`
+ * `fill`/blur layout) style via overridable classes instead of forced-inline styles, and stay
+ * SSR-safe (present before JS). The app can restyle `.toil-img-*` freely. */
+const TOIL_BASE_STYLE =
+    `<style id="toil-base">` +
+    `.toil-img-fill{position:absolute;inset:0;width:100%;height:100%}` +
+    `.toil-img-blur{background-size:cover;background-position:center;filter:blur(20px)}` +
+    `</style>`;
 /**
  * Produces the `.toil/index.html` Vite entry from the project's `public/index.html` template (or
  * the built-in default if absent), ensuring the generated module entry script is present. Users
@@ -419,6 +428,13 @@ function buildHtml(cfg: ResolvedToilConfig): string {
             ? html.replace('</body>', `    ${ENTRY_SCRIPT}\n  </body>`)
             : `${html}\n${ENTRY_SCRIPT}\n`;
     }
+    // Ship toil's component base CSS once, so `Image` `fill`/blur lay out via overridable classes
+    // instead of inline styles. Idempotent (keyed on the `toil-base` id).
+    if (!html.includes('id="toil-base"')) {
+        html = html.includes('</head>')
+            ? html.replace('</head>', `    ${TOIL_BASE_STYLE}\n  </head>`)
+            : `${TOIL_BASE_STYLE}\n${html}`;
+    }
     return html;
 }

package/src/compiler/template-build.ts CHANGED Viewed

@@ -45,6 +45,8 @@ import {
     extractFromHtml,
 } from './template.js';
 import { createViteConfig } from './vite.js';
+import { extractStaticMetadata, loadTypeScript } from './prerender.js';
+import { injectSeoHtml, routeSeo, type SeoConfig } from './seo.js';
 /** Marker element the client `mount` looks for to switch to `hydrateRoot`. */
 const SSR_MARKER = '<template id="__toil_ssr"></template>';
@@ -78,6 +80,14 @@ export interface RouteRenderInput {
     /** React's `Suspense` from the SAME instance as {@link createElement}, so the
      * Suspense dehydration markers (`<!--$-->`) emitted match the client's. */
     Suspense?: typeof Suspense;
+    /** Site SEO config. When set, this route's resolved SEO (site defaults overlaid with the
+     * route's static `metadata`) is baked into the template `<head>`, so an SSR route serves the
+     * same per-page title/description/og (incl og:image) a crawler gets from `<route>/index.html`. */
+    seo?: SeoConfig | null;
+    /** The route's static `export const metadata` (extracted at build), overlaid on the site SEO. */
+    metadata?: Record<string, unknown> | null;
+    /** The route pattern, used for the canonical / `og:url`. */
+    pattern?: string;
 }
 export interface TemplateArtifacts {
@@ -162,7 +172,16 @@ export function extractRouteTemplate(input: RouteRenderInput): TemplateArtifacts
     } finally {
         input.setSsrBuild(false);
     }
-    const full = injectIntoShell(input.shell, stripHoistedResourceTags(routeHtml));
+    let full = injectIntoShell(input.shell, stripHoistedResourceTags(routeHtml));
+    // Bake the route's resolved SEO into the template <head>, mirroring the static prerender
+    // (prerender.ts / ssg.ts) so an `ssr=true` route serves the SAME per-page metadata (title,
+    // description, canonical, og:* incl og:image, twitter, jsonLd) a crawler gets from the static
+    // <route>/index.html — which the dynamic SSR template otherwise shadows at request time. Runs on
+    // the FULL spliced document (injectSeoHtml's <title>/</head> regexes need the shell head, not the
+    // stripped fragment) and BEFORE extractFromHtml so the coherence hash covers the baked head.
+    if (input.seo) {
+        full = injectSeoHtml(full, routeSeo(input.seo, input.metadata ?? null, input.pattern ?? '/'));
+    }
     const extracted: Extracted = extractFromHtml(full);
     const ids = assignSlotIds(extracted.slots);
     const hash = coherenceHash(extracted.tmpl, extracted.slots);
@@ -259,6 +278,10 @@ async function renderSsrRoutes(cfg: ResolvedToilConfig, shell: string): Promise<
     const routes = scanRoutes(cfg.routesAbsDir).filter((r) => r.slot === undefined && !r.intercept);
     if (routes.length === 0) return [];
+    // Load TypeScript once (same as prerender.ts) to read each route's static `metadata` for the
+    // SSR <head>. Only needed when the project configures SEO.
+    const ts = cfg.seo ? await loadTypeScript(cfg.root) : null;
     const warn = (msg: string): void => {
         process.stderr.write(`  toil: SSR ${msg}\n`);
     };
@@ -332,6 +355,11 @@ async function renderSsrRoutes(cfg: ResolvedToilConfig, shell: string): Promise<
                     layouts.push(lm.default);
                 }
+                // The route's static `metadata` export (same static-AST read prerender.ts uses, so
+                // the SSR head matches the static <route>/index.html exactly). generateMetadata is
+                // dynamic and skipped here, as in prerender/ssg.
+                const metadata = ts ? extractStaticMetadata(ts, r.file) : null;
                 const name = routeTemplateName(r.pattern);
                 // Tell location hooks which URL this template is for, so a NavLink's active
                 // class / aria-current render as they will on the client at this route (else
@@ -348,6 +376,9 @@ async function renderSsrRoutes(cfg: ResolvedToilConfig, shell: string): Promise<
                     createElement: react.createElement,
                     renderToString: reactDomServer.renderToString,
                     Suspense: react.Suspense,
+                    seo: cfg.seo,
+                    metadata,
+                    pattern: r.pattern,
                 });
                 rendered.push({ pattern: r.pattern, art });
             } catch (err) {

package/src/devserver/runtime/module.ts CHANGED Viewed

@@ -110,6 +110,9 @@ const PROVIDED_IMPORTS = new Set([
     'email_send',
     'env_get',
     'env_get_secure',
+    // Per-domain analytics (see ./analytics/index.ts).
+    'analytics_read',
+    'analytics_list_sites',
     // Web Crypto host functions (see ./crypto.ts).
     'crypto.fill_random',
     'crypto.random_uuid',

package/src/devserver/stream/index.ts CHANGED Viewed

@@ -81,10 +81,10 @@ export type StreamMessageOutcome =
     | { readonly kind: 'reply'; readonly frames: Buffer[] }
     | { readonly kind: 'reject'; readonly code: number };
-/** A `@connect` outcome: the guest accepted (the box is usable) or rejected with a `0x02xx` code. */
+/** A `@connect` outcome: accepted/rejected plus any immediate frames staged during the hook. */
 export type StreamConnectOutcome =
-    | { readonly kind: 'accept' }
-    | { readonly kind: 'reject'; readonly code: number };
+    | { readonly kind: 'accept'; readonly initialEgress: Buffer[] }
+    | { readonly kind: 'reject'; readonly code: number; readonly initialEgress: Buffer[] };
 export class DevStreamBox {
     private constructor(
@@ -132,17 +132,16 @@ export class DevStreamBox {
     /**
      * Fire `@connect`: write the connect-info block (stream id + transport + authority + path) into the
-     * guest's info region, dispatch `EVENT_CONNECT`, and decode the `StreamOutbound` accept/reject. On
-     * accept, clear any `@connect`-staged egress (initial-egress is deferred, like the edge) so it does
-     * not contaminate the first `@message` reply. A box without the bridge runs `@connect` context-free
+     * guest's info region, dispatch `EVENT_CONNECT`, decode the `StreamOutbound` accept/reject, and
+     * drain any staged egress as initial frames. A box without the bridge runs `@connect` context-free
      * (the write is a no-op) and always accepts unless it returns a negative code.
      */
     onConnect(streamId: bigint, authority: string, path: string): StreamConnectOutcome {
         this.writeConnectInfo(streamId, authority, path);
         const rc = this.dispatch(EVENT_CONNECT, streamId);
-        if (rc < 0n) return { kind: 'reject', code: decodeRejectCode(rc) };
-        this.resetEgressRing();
-        return { kind: 'accept' };
+        const initialEgress = this.egressDrain();
+        if (rc < 0n) return { kind: 'reject', code: decodeRejectCode(rc), initialEgress };
+        return { kind: 'accept', initialEgress };
     }
     /** Fire `@close` (graceful close). */
@@ -241,16 +240,6 @@ export class DevStreamBox {
         if (pathLen > 0) memU8.set(pathBytes.subarray(0, pathLen), base + SI_BODY + authLen);
     }
-    /** Zero the egress ring cursors, discarding any staged frames. Safe between dispatches (the guest,
-     *  the sole egress producer, is idle). */
-    private resetEgressRing(): void {
-        const rings = this.rings;
-        if (!rings) return;
-        const dv = new DataView(this.exports.memory.buffer);
-        dv.setUint32(rings.egressOff + RC_WRITE, 0, true);
-        dv.setUint32(rings.egressOff + RC_READ, 0, true);
-    }
     /** Host (producer) writes ONE inbound RingFrame into the ingress ring with the drained-reset
      *  (host owns write_cursor; reset read_cursor only when the guest has drained). */
     private ingressWrite(inbound: Buffer): void {

package/src/devserver/stream/manager.ts CHANGED Viewed

@@ -32,8 +32,8 @@ export const STREAM_HOOK_TRAPPED = 0x0200;
 /** The outcome of an upgrade accept attempt (mirrors the edge `StreamUpgradeOutcome`). */
 export type StreamUpgradeOutcome =
-    | { readonly kind: 'accepted'; readonly streamId: bigint }
-    | { readonly kind: 'rejected'; readonly code: number };
+    | { readonly kind: 'accepted'; readonly streamId: bigint; readonly initialEgress: Buffer[] }
+    | { readonly kind: 'rejected'; readonly code: number; readonly initialEgress: Buffer[] };
 /** The outcome of driving one inbound frame (mirrors the edge `StreamDatagramOutcome`). */
 export type StreamDispatchResult =
@@ -69,30 +69,34 @@ export class StreamDevHost {
      * Accept (or reject) an upgrade for `authority` + `path`, mirroring `StreamWorker::accept_upgrade`:
      * (re)load the artifact on mtime change, instantiate a resident box, fire `@connect` WITH the
      * connect context, and HONOR the guest's accept/reject. Returns the host-assigned stream id on
-     * accept, or a `0x02xx` reject code. Fails closed (no connection registered, box dropped) on a
-     * missing/unreadable artifact (`0x0208`), a `@connect` reject (the guest's code), or a load/connect
-     * trap (`0x0200`). Throws only on a duplicate `connId`.
+     * accept, plus any initial egress staged by `@connect`, or a `0x02xx` reject code. Fails closed
+     * (no connection registered, box dropped) on a missing/unreadable artifact (`0x0208`), a
+     * `@connect` reject (the guest's code), or a load/connect trap (`0x0200`). Throws only on a
+     * duplicate `connId`.
      */
     acceptUpgrade(connId: string, authority: string, path: string): StreamUpgradeOutcome {
-        if (this.conns.has(connId)) throw new Error(`stream connection '${connId}' is already open`);
+        if (this.conns.has(connId))
+            throw new Error(`stream connection '${connId}' is already open`);
         this.refresh();
-        if (!this.bytes) return { kind: 'rejected', code: STREAM_REJECTED };
+        if (!this.bytes) return { kind: 'rejected', code: STREAM_REJECTED, initialEgress: [] };
         let box: DevStreamBox;
         try {
             box = DevStreamBox.load(this.bytes);
         } catch {
-            return { kind: 'rejected', code: STREAM_REJECTED };
+            return { kind: 'rejected', code: STREAM_REJECTED, initialEgress: [] };
         }
         const streamId = this.allocStreamId();
         let outcome;
         try {
             outcome = box.onConnect(streamId, authority, path);
         } catch {
-            return { kind: 'rejected', code: STREAM_HOOK_TRAPPED }; // @connect trapped
+            return { kind: 'rejected', code: STREAM_HOOK_TRAPPED, initialEgress: [] }; // @connect trapped
+        }
+        if (outcome.kind === 'reject') {
+            return { kind: 'rejected', code: outcome.code, initialEgress: outcome.initialEgress };
         }
-        if (outcome.kind === 'reject') return { kind: 'rejected', code: outcome.code };
         this.conns.set(connId, { box, streamId });
-        return { kind: 'accepted', streamId };
+        return { kind: 'accepted', streamId, initialEgress: outcome.initialEgress };
     }
     /**

package/src/devserver/stream/ws.ts CHANGED Viewed

@@ -45,10 +45,12 @@ export class StreamWsSession {
     onOpen(): boolean {
         const up = this.host.acceptUpgrade(this.connId, this.authority, this.path);
         if (up.kind === 'rejected') {
+            for (const frame of up.initialEgress) this.transport.send(frame);
             this.transport.close(up.code);
             return false;
         }
         this.open = true;
+        for (const frame of up.initialEgress) this.transport.send(frame);
         return true;
     }

package/test/assembly/aspect-shim.ts ADDED Viewed

@@ -0,0 +1,33 @@
+// 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 CHANGED Viewed

@@ -5,6 +5,7 @@
 // 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';

package/test/assembly/example.spec.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 // 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';

package/test/assembly/ssr.spec.ts CHANGED Viewed

@@ -3,6 +3,7 @@
 // (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';

package/test/assembly.test.ts ADDED Viewed

@@ -0,0 +1,59 @@
+// 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 });
+            }
+        });
+    }
+});

package/test/dom/Image.test.tsx CHANGED Viewed

@@ -23,6 +23,9 @@ describe('Image', () => {
         expect(img.getAttribute('width')).toBe('200');
         expect(img.getAttribute('height')).toBe('100');
         expect(img.getAttribute('fetchpriority')).toBe('auto');
+        // A plain image adds no inline style and no toil class (nothing to lay out).
+        expect(img.getAttribute('style')).toBe(null);
+        expect(img.className).toBe('');
     });
     it('priority images load eagerly with high fetch priority', () => {
@@ -38,7 +41,7 @@ describe('Image', () => {
         expect(img.getAttribute('fetchpriority')).toBe('high');
     });
-    it('fill drops width/height and absolutely positions the image', () => {
+    it('fill drops width/height and lays out via the toil-img-fill class, not inline styles', () => {
         const { getByAltText } = render(
             <Image
                 src="/bg.png"
@@ -50,10 +53,28 @@ describe('Image', () => {
         const img = getByAltText('bg') as HTMLImageElement;
         expect(img.hasAttribute('width')).toBe(false);
         expect(img.hasAttribute('height')).toBe(false);
-        expect(img.style.position).toBe('absolute');
+        // The fill layout comes from a shipped, overridable CSS class, NOT inline positioning.
+        expect(img.classList.contains('toil-img-fill')).toBe(true);
+        expect(img.style.position).toBe('');
+        // objectFit is genuinely per-instance, so it stays inline.
         expect(img.style.objectFit).toBe('cover');
     });
+    it('preserves the caller className alongside the fill class', () => {
+        const { getByAltText } = render(
+            <Image
+                src="/bg.png"
+                alt="bg2"
+                fill
+                className="hero"
+            />,
+        );
+        const img = getByAltText('bg2') as HTMLImageElement;
+        expect(img.classList.contains('hero')).toBe(true);
+        expect(img.classList.contains('toil-img-fill')).toBe(true);
+        expect(img.getAttribute('style')).toBe(null);
+    });
     it('shows a blur placeholder until the image loads', () => {
         const { getByAltText } = render(
             <Image
@@ -66,8 +87,10 @@ describe('Image', () => {
             />,
         );
         const img = getByAltText('p') as HTMLImageElement;
+        expect(img.classList.contains('toil-img-blur')).toBe(true);
         expect(img.style.backgroundImage).toContain('data:image/x');
         fireEvent.load(img);
         expect(img.style.backgroundImage).toBe('');
+        expect(img.classList.contains('toil-img-blur')).toBe(false);
     });
 });

package/test/fixtures/stream-gate.ts CHANGED Viewed

@@ -1,24 +1,28 @@
 // Dev @connect-bridge fixture: a `@stream('gate')` whose `@connect(c: StreamInbound): StreamOutbound`
 // reads the host-written connect context (the path) and REJECTS "/blocked" with 0x0211, ACCEPTING any
-// other path; a "/greet" path stages an egress frame DURING @connect (the host must clear it so it does
-// not contaminate the first @message reply). A @message echoes. Mirrors toil-backend's connect_src.ts;
+// 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();
+    @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());
     }
-    return StreamOutbound.accept();
-  }
-  @message reply(p: StreamPacket): StreamOutbound {
-    return StreamOutbound.reply(p.bytes());
-  }
 }
-export function probe(): i32 { return 1; }
+export function probe(): i32 {
+    return 1;
+}

package/test/ssr-template.test.tsx CHANGED Viewed

@@ -392,4 +392,58 @@ describe('ssr build orchestration', () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
+    it('bakes the route SEO (title/description/og incl og:image) into the template <head>', () => {
+        const art = extractRouteTemplate({
+            name: 'profile',
+            Page: ProfilePage,
+            layouts: [Layout],
+            loaderData: sample,
+            loaderContext: LoaderDataContext,
+            setSsrBuild: __setSsrBuild,
+            shell: SHELL,
+            seo: {
+                url: 'https://ex.com',
+                title: 'Site',
+                openGraph: { siteName: 'Site', image: 'https://ex.com/og.png' },
+            },
+            metadata: {
+                title: 'Profile',
+                description: 'A user profile',
+                openGraph: { title: 'Profile OG' },
+            },
+            pattern: '/u/ada',
+        });
+        const tmpl = art.tmpl.toString('utf8');
+        // The route's own title replaces the shell's, and its metadata + the site SEO are in <head>,
+        // so an SSR route serves the same per-page tags a crawler would get from <route>/index.html.
+        expect(tmpl).toContain('<title>Profile</title>');
+        expect(tmpl).not.toContain('<title>t</title>');
+        expect(tmpl).toContain('<meta name="description" content="A user profile" />');
+        expect(tmpl).toContain('<meta property="og:title" content="Profile OG" />');
+        expect(tmpl).toContain('<meta property="og:image" content="https://ex.com/og.png" />');
+        // Per-route canonical / og:url point at THIS route, not the site root.
+        expect(tmpl).toContain('<link rel="canonical" href="https://ex.com/u/ada" />');
+        expect(tmpl).toContain('<meta property="og:url" content="https://ex.com/u/ada" />');
+        // The baked head is inside art.tmpl, so it is covered by the coherence hash.
+        expect(art.hash).toHaveLength(32);
+        // Holes are unaffected (still body-only).
+        expect(art.slotCount).toBe(3);
+    });
+    it('skips SEO injection when no seo config is passed (head unchanged)', () => {
+        const art = extractRouteTemplate({
+            name: 'p',
+            Page: ProfilePage,
+            layouts: [Layout],
+            loaderData: sample,
+            loaderContext: LoaderDataContext,
+            setSsrBuild: __setSsrBuild,
+            shell: SHELL,
+        });
+        const tmpl = art.tmpl.toString('utf8');
+        expect(tmpl).toContain('<title>t</title>'); // shell title untouched
+        expect(tmpl).not.toContain('og:image');
+        expect(tmpl).not.toContain('rel="canonical"');
+    });
 });

package/test/stream-emulation.test.ts CHANGED Viewed

@@ -30,8 +30,10 @@ import {
 import { StreamWsSession, type StreamWsTransport } from '../src/devserver/stream/ws.js';
 const here = dirname(fileURLToPath(import.meta.url));
-// The LOCAL toilscript build (the @message + @connect bridge codegen); the published dep predates it.
-const LOCAL_TOILSCRIPT_BIN = join(here, '..', '..', 'toilscript', 'bin', 'toilscript.js');
+// The toilscript build with the @message + @connect bridge codegen (it ships in the dep now).
+// Resolved from node_modules so this works both locally (the symlinked repo) and in CI (the npm
+// dep), not from a sibling checkout that CI does not have.
+const LOCAL_TOILSCRIPT_BIN = join(here, '..', 'node_modules', 'toilscript', 'bin', 'toilscript.js');
 let tmp: string;
 let ECHO_PATH: string;
@@ -50,7 +52,9 @@ function compile(srcName: string): { path: string; wasm: Buffer } {
         { encoding: 'utf8' },
     );
     if (r.status !== 0) {
-        throw new Error(`toilscript compile ${srcName} failed (${String(r.status)}):\n${r.stderr}${r.stdout}`);
+        throw new Error(
+            `toilscript compile ${srcName} failed (${String(r.status)}):\n${r.stderr}${r.stdout}`,
+        );
     }
     return { path: out, wasm: readFileSync(out) };
 }
@@ -140,10 +144,17 @@ describe('dev stream box: the @connect info-block bridge', () => {
     it('reads the connect path and rejects /blocked while accepting others', () => {
         const box = DevStreamBox.load(GATE);
         expect(box.hasConnectBridge).toBe(true);
-        expect(box.onConnect(id, 'acme.toil', '/blocked')).toEqual({ kind: 'reject', code: 0x0211 });
+        expect(box.onConnect(id, 'acme.toil', '/blocked')).toEqual({
+            kind: 'reject',
+            code: 0x0211,
+            initialEgress: [],
+        });
         const ok = DevStreamBox.load(GATE);
-        expect(ok.onConnect(id, 'acme.toil', '/room/42')).toEqual({ kind: 'accept' });
+        expect(ok.onConnect(id, 'acme.toil', '/room/42')).toEqual({
+            kind: 'accept',
+            initialEgress: [],
+        });
         // An accepted connection is usable: its @message echoes.
         expect(ok.onMessage(id, Buffer.from('hi'))).toEqual({
             kind: 'reply',
@@ -151,11 +162,14 @@ describe('dev stream box: the @connect info-block bridge', () => {
         });
     });
-    it('clears @connect-staged egress so the first @message reply is clean', () => {
+    it('returns @connect-staged egress and keeps the first @message reply clean', () => {
         const box = DevStreamBox.load(GATE);
-        // /greet stages "GHI" during @connect; the host clears it on accept.
-        expect(box.onConnect(id, 'acme.toil', '/greet')).toEqual({ kind: 'accept' });
-        // The first @message must see ONLY its own reply, never the stale "GHI".
+        // /greet stages "GHI" during @connect; the host returns it as initial egress.
+        expect(box.onConnect(id, 'acme.toil', '/greet')).toEqual({
+            kind: 'accept',
+            initialEgress: [Buffer.from('GHI')],
+        });
+        // The first @message must see ONLY its own reply, never the drained initial "GHI".
         expect(box.onMessage(id, Buffer.from('hi'))).toEqual({
             kind: 'reply',
             frames: [Buffer.from('hi')],
@@ -185,6 +199,7 @@ describe('dev stream session driver (StreamDevHost)', () => {
         expect(host.acceptUpgrade('c1', 'acme.toil', '/blocked')).toEqual({
             kind: 'rejected',
             code: 0x0211,
+            initialEgress: [],
         });
         expect(host.activeConnections).toBe(0);
         expect(host.acceptUpgrade('c2', 'acme.toil', '/ok').kind).toBe('accepted');
@@ -211,6 +226,18 @@ describe('dev stream session driver (StreamDevHost)', () => {
         host.acceptUpgrade('c1', 'acme.toil', '/');
         expect(() => host.acceptUpgrade('c1', 'acme.toil', '/')).toThrow();
     });
+    it('returns initial egress from @connect while keeping dispatch clean', () => {
+        const host = new StreamDevHost(GATE_PATH);
+        expect(host.acceptUpgrade('c1', 'acme.toil', '/greet')).toMatchObject({
+            kind: 'accepted',
+            initialEgress: [Buffer.from('GHI')],
+        });
+        expect(host.dispatch('c1', Buffer.from('hi'))).toEqual({
+            kind: 'reply',
+            frames: [Buffer.from('hi')],
+        });
+    });
 });
 describe('dev stream WS session adapter (StreamWsSession)', () => {
@@ -237,6 +264,20 @@ describe('dev stream WS session adapter (StreamWsSession)', () => {
         expect(host.activeConnections).toBe(0);
     });
+    it('sends @connect initial egress on open', () => {
+        const host = new StreamDevHost(GATE_PATH);
+        const { sent, closed, t } = makeTransport();
+        const s = new StreamWsSession(host, 'ws1', 'acme.toil', '/greet', t);
+        expect(s.onOpen()).toBe(true);
+        expect(s.isOpen).toBe(true);
+        expect(sent).toEqual([Buffer.from('GHI')]);
+        expect(closed).toEqual([]);
+        s.onMessage(Buffer.from('hi'));
+        expect(sent).toEqual([Buffer.from('GHI'), Buffer.from('hi')]);
+        s.onClose();
+        expect(host.activeConnections).toBe(0);
+    });
     it('closes the socket with the code on a guest reject, then fires @close on socket close', () => {
         const host = new StreamDevHost(ECHO_PATH);
         const { closed, t } = makeTransport();
@@ -310,7 +351,12 @@ describe('dev stream router (doc 08 4.1/4.2)', () => {
         expect(router.matchRoute('/not-a-stream')).toBeNull(); // -> proxied to Vite
         const ws = new MockWs();
-        const ctx: StreamUpgradeContext = { kind: 'stream', route, url: route, authority: 'acme.toil' };
+        const ctx: StreamUpgradeContext = {
+            kind: 'stream',
+            route,
+            url: route,
+            authority: 'acme.toil',
+        };
         router.onUpgrade(ws, ctx);
         expect(router.activeConnections).toBe(1);
         ws.emitMessage(Buffer.from('hi'));