toiljs 0.0.62 → 0.0.63

package/build/compiler/index.js

@@ -90,15 +90,22 @@ export async function buildServer(root) {
     const binJs = resolveToilscriptBin(root);
     const files = serverEntryFiles(root);
     const split = splitSurfaceFiles(root, files);
-    if (split.hasDaemon) {
+    if (split.hasDaemon || split.hasStream) {
         const artifacts = serverArtifacts(root);
-        await runToilscriptPass(root, binJs, split.cold, {
-            mode: 'cold',
-            outFile: artifacts.cold,
-            withRpc: false,
-        });
-        if (split.hot.length > 0)
-            await runToilscriptPass(root, binJs, split.hot, {
+        if (split.hasDaemon)
+            await runToilscriptPass(root, binJs, split.cold, {
+                mode: 'cold',
+                outFile: artifacts.cold,
+                withRpc: false,
+            });
+        if (split.hasStream && split.stream.length > 0)
+            await runToilscriptPass(root, binJs, split.stream, {
+                mode: 'hot',
+                outFile: artifacts.stream,
+                withRpc: false,
+            });
+        if (split.request.length > 0)
+            await runToilscriptPass(root, binJs, split.request, {
                 mode: 'hot',
                 outFile: serverWasmFile(root),
                 withRpc: true,
@@ -123,11 +130,21 @@ function resolveToilscriptBin(root) {
     }
 }
 const COLD_DECORATOR = /^[ \t]*@(daemon|scheduled)\b/m;
-const HOT_DECORATOR = /^[ \t]*@(rest|route|stream|service|remote)\b/m;
+const STREAM_DECORATOR = /^[ \t]*@stream\b/m;
+const REQUEST_DECORATOR = /^[ \t]*@(rest|route|service|remote)\b/m;
+const RUNTIME_ENTRY = /from\s+['"]toiljs\/server\/runtime\/exports['"]/;
+function isStreamEntryFile(rel) {
+    return rel.endsWith('.stream.ts');
+}
+function isDaemonEntryFile(rel) {
+    return rel.endsWith('.daemon.ts');
+}
 export function splitSurfaceFiles(root, files) {
     let hasDaemon = false;
+    let hasStream = false;
     const cold = [];
-    const hot = [];
+    const stream = [];
+    const request = [];
     for (const rel of files) {
         let src = '';
         try {
@@ -135,19 +152,27 @@ export function splitSurfaceFiles(root, files) {
         }
         catch {
             cold.push(rel);
-            hot.push(rel);
+            stream.push(rel);
+            request.push(rel);
             continue;
         }
-        const isCold = COLD_DECORATOR.test(src);
-        const isHot = HOT_DECORATOR.test(src);
+        const isCold = COLD_DECORATOR.test(src) || isDaemonEntryFile(rel);
+        const isStream = STREAM_DECORATOR.test(src) || isStreamEntryFile(rel);
+        const isRequest = REQUEST_DECORATOR.test(src) ||
+            (RUNTIME_ENTRY.test(src) && !isStreamEntryFile(rel) && !isDaemonEntryFile(rel));
         if (isCold)
-            hasDaemon ||= /^[ \t]*@daemon\b/m.test(src);
-        if (!(isCold && !isHot))
-            hot.push(rel);
-        if (!(isHot && !isCold))
+            hasDaemon ||= /^[ \t]*@daemon\b/m.test(src) || isDaemonEntryFile(rel);
+        if (isStream)
+            hasStream = true;
+        const shared = !isCold && !isStream && !isRequest;
+        if (isCold || shared)
             cold.push(rel);
+        if (isStream || shared)
+            stream.push(rel);
+        if (isRequest || shared)
+            request.push(rel);
     }
-    return { hasDaemon, cold, hot };
+    return { hasDaemon, hasStream, cold, stream, request };
 }
 function runToilscriptPass(root, binJs, files, opts) {
     const args = [binJs, ...files, '--target', 'release'];
@@ -259,11 +284,13 @@ export function serverArtifacts(root) {
     let out = 'build/server/release.wasm';
     let hot;
     let cold;
+    let stream;
     try {
         const cfg = JSON.parse(fs.readFileSync(path.join(root, 'toilconfig.json'), 'utf8'));
         out = cfg.targets?.release?.outFile ?? out;
         hot = cfg.targets?.release?.hotFile;
         cold = cfg.targets?.release?.coldFile;
+        stream = cfg.targets?.release?.streamFile;
     }
     catch {
     }
@@ -274,6 +301,7 @@ export function serverArtifacts(root) {
     return {
         hot: path.resolve(root, hot ?? ins('hot')),
         cold: path.resolve(root, cold ?? ins('cold')),
+        stream: path.resolve(root, stream ?? ins('stream')),
     };
 }
 async function freeLoopbackPort() {

package/build/compiler/template-build.d.ts

@@ -1,4 +1,4 @@
-import { type ComponentType, type Context, createElement, type ReactNode } from 'react';
+import { type ComponentType, type Context, createElement, type ReactNode, Suspense } from 'react';
 import { renderToString } from 'react-dom/server';
 import { type ResolvedToilConfig } from './config.js';
 export interface RouteRenderInput {
@@ -13,6 +13,7 @@ export interface RouteRenderInput {
     shell: string;
     createElement?: typeof createElement;
     renderToString?: typeof renderToString;
+    Suspense?: typeof Suspense;
 }
 export interface TemplateArtifacts {
     name: string;
@@ -24,7 +25,7 @@ export interface TemplateArtifacts {
 }
 export declare function assembleRouteElement(Page: ComponentType, layouts: ComponentType<{
     children?: ReactNode;
-}>[], loaderData: unknown, loaderContext: Context<unknown> | null, h?: typeof createElement): ReactNode;
+}>[], loaderData: unknown, loaderContext: Context<unknown> | null, h?: typeof createElement, SuspenseComp?: typeof Suspense): ReactNode;
 export declare function injectIntoShell(shell: string, routeHtml: string): string;
 export declare function extractRouteTemplate(input: RouteRenderInput): TemplateArtifacts;
 export declare function writeTemplateArtifacts(ssrDir: string, art: TemplateArtifacts): void;

package/build/compiler/template-build.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { createElement } from 'react';
+import { createElement, Suspense } from 'react';
 import { renderToString } from 'react-dom/server';
 import { createServer } from 'vite';
 import { findLayout, findSpecialChain } from './generate.js';
@@ -11,13 +11,14 @@ import { assignSlotIds, coherenceHash, encodeSlots, extractFromHtml, } from './t
 import { createViteConfig } from './vite.js';
 const SSR_MARKER = '<template id="__toil_ssr"></template>';
 const ROOT_DIV = '<div id="root"></div>';
-export function assembleRouteElement(Page, layouts, loaderData, loaderContext, h = createElement) {
+export function assembleRouteElement(Page, layouts, loaderData, loaderContext, h = createElement, SuspenseComp = Suspense) {
     let node = h(Page);
     if (loaderContext) {
         node = h(loaderContext.Provider, { value: loaderData }, node);
     }
+    node = h(SuspenseComp, { fallback: null }, node);
     for (let i = layouts.length - 1; i >= 0; i--) {
-        node = h(layouts[i], null, node);
+        node = h(SuspenseComp, { fallback: null }, h(layouts[i], null, node));
     }
     return node;
 }
@@ -36,7 +37,8 @@ function stripHoistedResourceTags(html) {
 export function extractRouteTemplate(input) {
     const h = input.createElement ?? createElement;
     const render = input.renderToString ?? renderToString;
-    const element = assembleRouteElement(input.Page, input.layouts, input.loaderData, input.loaderContext, h);
+    const SuspenseComp = input.Suspense ?? Suspense;
+    const element = assembleRouteElement(input.Page, input.layouts, input.loaderData, input.loaderContext, h, SuspenseComp);
     input.setSsrBuild(true);
     let routeHtml;
     try {
@@ -139,8 +141,9 @@ async function renderSsrRoutes(cfg, shell) {
                 const loaderData = typeof mod.loader === 'function'
                     ? await mod.loader({ params, searchParams: new URLSearchParams() })
                     : undefined;
+                const rootLayout = findLayout(cfg);
                 const layoutFiles = [
-                    ...(findLayout(cfg) ? [findLayout(cfg)] : []),
+                    ...(rootLayout ? [rootLayout] : []),
                     ...findSpecialChain(cfg, r.file, 'layout', false),
                 ];
                 const layouts = [];
@@ -149,6 +152,7 @@ async function renderSsrRoutes(cfg, shell) {
                     layouts.push(lm.default);
                 }
                 const name = routeTemplateName(r.pattern);
+                client.__setSsrLocation(samplePath(r.pattern));
                 const art = extractRouteTemplate({
                     name,
                     Page: mod.default,
@@ -159,12 +163,16 @@ async function renderSsrRoutes(cfg, shell) {
                     shell,
                     createElement: react.createElement,
                     renderToString: reactDomServer.renderToString,
+                    Suspense: react.Suspense,
                 });
                 rendered.push({ pattern: r.pattern, art });
             }
             catch (err) {
                 warn(`skipped ${r.pattern} (render failed: ${err instanceof Error ? err.message : String(err)}) — falls back to client rendering`);
             }
+            finally {
+                client.__setSsrLocation(null);
+            }
         }
     }
     finally {
@@ -219,6 +227,9 @@ function sampleParams(pattern) {
     }
     return params;
 }
+function samplePath(pattern) {
+    return pattern.replace(/[:*]+([A-Za-z0-9_]+)/g, 'sample');
+}
 export async function extractTemplates(cfg, hostName = 'edge', priorServerSlots = new Map()) {
     const shell = resolveShell(cfg, true);
     if (shell === null)

package/examples/basic/server/services/Stats.ts

@@ -1,11 +1,10 @@
 import { store } from '../core/store';
 
 /** Typed RPC service (transport still a TODO): reached as `Server.stats.playerCount()` on the client. */
-@service
+/*@service
 class Stats {
-    /** Number of seeded players (the RPC transport is a TODO, so this throws on the client for now). */
     @remote
     public playerCount(): i32 {
         return store.size;
     }
-}
+}*/

package/examples/basic/server/services/remotes.ts

@@ -1,7 +1,7 @@
 /** Free `@remote` functions: callable as `Server.<name>()` on the client. */
 
 /** `Server.ping(n)` on the client. */
-@remote
+/*@remote
 function ping(n: i32): i32 {
     return n + 1;
-}
+}*/

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "toiljs",
     "type": "module",
-    "version": "0.0.62",
+    "version": "0.0.63",
     "author": "Dacely",
     "description": "The modern React framework: a file-based React frontend and a ToilScript-compiled WebAssembly backend.",
     "repository": {

package/src/client/index.ts

@@ -40,6 +40,7 @@ export {
     useSearchParams,
     useRouter,
     useNavigationPending,
+    __setSsrLocation,
 } from './routing/hooks.js';
 export type { RouterInstance } from './routing/hooks.js';
 export {

package/src/client/routing/hooks.ts

@@ -101,12 +101,25 @@ function useLocationSubscription(): void {
     );
 }
 
+/** Build-only override for the SSR pathname, set by the template extractor per route via
+ * {@link __setSsrLocation}. Lets location-dependent markup (a `NavLink`'s active class /
+ * `aria-current`) render as the route's own URL so it matches what the client computes on
+ * hydration, instead of the `/` default. Ignored in the browser (the live URL wins). */
+let ssrLocationOverride: string | null = null;
+
+/** Build-only: set the pathname the extractor is currently rendering (or `null` to clear).
+ * No effect in the browser. Exported through `toiljs/client` for the compiler. */
+export function __setSsrLocation(path: string | null): void {
+    ssrLocationOverride = path;
+}
+
 /** Subscribes to and returns the current `location.pathname`. SSR-safe: during a
- *  server render (build-time template extraction / edge SSR) there is no `window`,
- *  so it reports `/`; the client recomputes on hydration. */
+ *  server render there is no `window`, so it reports the extractor's override (the route
+ *  being rendered) or `/`; the client recomputes on hydration. */
 export function useLocation(): string {
     useLocationSubscription();
-    return typeof window === 'undefined' ? '/' : window.location.pathname;
+    if (typeof window === 'undefined') return ssrLocationOverride ?? '/';
+    return window.location.pathname;
 }
 
 /** Alias of {@link useLocation}: the current `location.pathname`. */

package/src/client/ssr/markers.tsx

@@ -145,7 +145,10 @@ export function Repeat<T>(props: RepeatProps<T>): ReactNode {
     return createElement(
         Fragment,
         null,
-        props.each.map((item, i) => props.children(item, i)),
+        // Each row is wrapped in a keyed Fragment so React has a stable list key (the
+        // row markup itself need not carry one). Index keys are fine here: an SSR'd
+        // region hydrates 1:1 against the host's pre-stamped rows and does not reorder.
+        props.each.map((item, i) => createElement(Fragment, { key: i }, props.children(item, i))),
     );
 }
 

package/src/compiler/index.ts

@@ -137,30 +137,42 @@ export async function buildServer(root: string): Promise<void> {
     // (optimization, features, runtime) still come from the toilconfig's `release` target.
     const files = serverEntryFiles(root);
 
-    // A project that declares a `@daemon` (cold surface) compiles the ONE source tree into TWO
-    // artifacts via two toilscript passes (one per --targetMode); a project with only the legacy
-    // request surface keeps the single-artifact path (byte-identical to before). The cold pass
-    // runs FIRST (cheap, no client surface); the hot pass runs LAST because it (re)writes
-    // shared/server.ts via --rpcModule, which the downstream client build imports.
+    // A project that declares a `@daemon` (L4 cold surface) and/or a `@stream` (L2/L3 stream
+    // surface) compiles the ONE source tree into SEPARATE artifacts, one per deployment tier, via
+    // one toilscript pass each; a project with only the legacy request surface keeps the
+    // single-artifact path (byte-identical to before). The three tiers:
+    //   - REQUEST (L1)   `server/main.ts`    + `@rest`/`@service`/`@remote` -> `release.wasm`
+    //   - STREAM  (L2/L3) `server/main.stream.ts` + `@stream`              -> `release-stream.wasm`
+    //   - DAEMON  (L4)   `@daemon`/`@scheduled`                            -> `release-cold.wasm`
+    // toilscript's gating matrix HARD-ERRORS a class compiled under the wrong --targetMode, so each
+    // pass is handed only the files eligible for its tier (`@data`/`@database`/plain helpers are
+    // SHARED into every pass). The request pass runs LAST because it (re)writes shared/server.ts via
+    // --rpcModule, which the downstream client build imports.
     const split = splitSurfaceFiles(root, files);
-    if (split.hasDaemon) {
+    if (split.hasDaemon || split.hasStream) {
         const artifacts = serverArtifacts(root);
-        // toilscript's gating matrix HARD-ERRORS a `@daemon`/`@scheduled` class compiled under
-        // `--targetMode hot` (and a `@rest`/`@stream`/`@service`/`@remote` class under cold). So
-        // each pass is handed only the files eligible for that mode: the cold pass drops hot-only
-        // files, the hot pass drops daemon-only files. `@data`/`@database`/plain files are shared.
-        await runToilscriptPass(root, binJs, split.cold, {
-            mode: 'cold',
-            outFile: artifacts.cold,
-            withRpc: false,
-        });
-        // The hot pass writes the legacy `outFile` (= hotFile alias, AN-1) so the request path
-        // and the dev server's `serverWasmFile` are unchanged; the request box loads it as today.
-        // A daemon-only project (no request/stream surface) has no hot files; skip the hot pass so
-        // toilscript is not handed an empty entry set. The request path then stays idle (no
-        // `handle` export), which is correct for a pure background worker.
-        if (split.hot.length > 0)
-            await runToilscriptPass(root, binJs, split.hot, {
+        // DAEMON (cold) pass: --targetMode cold, no client RPC surface.
+        if (split.hasDaemon)
+            await runToilscriptPass(root, binJs, split.cold, {
+                mode: 'cold',
+                outFile: artifacts.cold,
+                withRpc: false,
+            });
+        // STREAM pass: --targetMode hot into its OWN `release-stream.wasm`, no client RPC surface
+        // (a resident stream box exposes `stream_dispatch`, not the request client surface). Driven
+        // by `server/main.stream.ts` + the `@stream` classes; the request box never loads it.
+        if (split.hasStream && split.stream.length > 0)
+            await runToilscriptPass(root, binJs, split.stream, {
+                mode: 'hot',
+                outFile: artifacts.stream,
+                withRpc: false,
+            });
+        // REQUEST pass: the L1 artifact (= the legacy `outFile`, AN-1), WITH the client RPC surface.
+        // A pure daemon/stream project (no request files) skips it so toilscript is not handed an
+        // empty entry set; the request path then stays idle (no `handle` export), correct for a
+        // background-only worker.
+        if (split.request.length > 0)
+            await runToilscriptPass(root, binJs, split.request, {
                 mode: 'hot',
                 outFile: serverWasmFile(root),
                 withRpc: true,
@@ -168,7 +180,7 @@ export async function buildServer(root: string): Promise<void> {
         return;
     }
 
-    // Legacy single-artifact path (no daemon surface): exactly today's invocation.
+    // Legacy single-artifact path (no daemon/stream surface): exactly today's invocation.
     await runToilscriptPass(root, binJs, files, { mode: null, outFile: null, withRpc: true });
 }
 
@@ -191,54 +203,85 @@ function resolveToilscriptBin(root: string): string {
     }
 }
 
-/** Files classified per target mode for the two-pass build. */
+/** Files classified per deployment TIER for the multi-artifact build. */
 interface SurfaceSplit {
-    /** Whether any file declares a `@daemon` (so a cold pass is needed at all). */
+    /** Whether any file declares a `@daemon` (so a cold/daemon pass is needed at all). */
     readonly hasDaemon: boolean;
-    /** Files eligible for the COLD pass (everything except hot-only request files). */
+    /** Whether any file declares a `@stream` (or is a `*.stream.ts` entry), so a stream pass is needed. */
+    readonly hasStream: boolean;
+    /** Files for the DAEMON (cold) pass: `@daemon`/`@scheduled` surfaces + shared helpers. */
     readonly cold: string[];
-    /** Files eligible for the HOT pass (everything except daemon-only cold files). */
-    readonly hot: string[];
+    /** Files for the STREAM pass: `@stream` surfaces + the `*.stream.ts` entry + shared helpers. */
+    readonly stream: string[];
+    /** Files for the REQUEST pass: `@rest`/`@service`/`@remote` surfaces + the request entry + shared helpers. */
+    readonly request: string[];
 }
 
-/** A `@daemon`/`@scheduled` decorator at line start (a cold-only surface). */
+/** A `@daemon`/`@scheduled` decorator at line start (the L4 cold/daemon surface). */
 const COLD_DECORATOR = /^[ \t]*@(daemon|scheduled)\b/m;
-/** A request/stream-surface decorator at line start (a hot-only surface). */
-const HOT_DECORATOR = /^[ \t]*@(rest|route|stream|service|remote)\b/m;
+/** A `@stream` decorator at line start (the L2/L3 stream surface). */
+const STREAM_DECORATOR = /^[ \t]*@stream\b/m;
+/** A request-surface decorator at line start (`@rest`/`@route`/`@service`/`@remote`, the L1 tier). */
+const REQUEST_DECORATOR = /^[ \t]*@(rest|route|service|remote)\b/m;
+/** A server ENTRY re-exports the runtime WASM entry points; this marks `main.ts` / `main.stream.ts`
+ *  (vs a plain `@data`/helper), so each entry is routed to exactly ONE tier and two entries never
+ *  collide on a duplicate `export *` in the same pass. */
+const RUNTIME_ENTRY = /from\s+['"]toiljs\/server\/runtime\/exports['"]/;
+
+/** True for a STREAM-tier entry by the `*.stream.ts` naming convention (e.g. `main.stream.ts`). */
+function isStreamEntryFile(rel: string): boolean {
+    return rel.endsWith('.stream.ts');
+}
+
+/** True for a COLD/daemon-tier entry by the `*.daemon.ts` naming convention (e.g. `main.daemon.ts`). */
+function isDaemonEntryFile(rel: string): boolean {
+    return rel.endsWith('.daemon.ts');
+}
 
 /**
- * Classify each server source file by the surface decorators it declares, so each toilscript pass
- * is handed only the files valid for its `--targetMode` (toilscript HARD-ERRORS a cold class in
- * the hot artifact and vice versa). A file with a cold-only surface (`@daemon`/`@scheduled` and no
- * hot decorator) is dropped from the hot pass; a file with a hot-only surface is dropped from the
- * cold pass. Shared files (`@data`/`@database`/plain helpers, or a file mixing both surfaces) stay
- * in both passes, matching toilscript's class-level gating which admits `@data`/`@database`
- * everywhere.
+ * Classify each server source file by its deployment TIER, so each toilscript pass is handed only
+ * the files valid for its `--targetMode` (toilscript HARD-ERRORS a class compiled under the wrong
+ * mode). Three tiers:
+ *   - COLD/daemon: a file declaring `@daemon`/`@scheduled` -> `release-cold.wasm`.
+ *   - STREAM (L2/L3): a file declaring `@stream`, OR a `*.stream.ts` entry (`main.stream.ts`) ->
+ *     `release-stream.wasm`.
+ *   - REQUEST (L1): a file declaring `@rest`/`@service`/`@remote`, OR a non-`*.stream.ts` runtime
+ *     ENTRY (`main.ts`) -> `release.wasm`.
+ * A file with NONE of these (a plain `@data`/`@database`/helper) is SHARED into every pass, matching
+ * toilscript's class-level gating. Routing each entry to exactly one tier keeps `release.wasm` free
+ * of `stream_dispatch` and stops two entries re-exporting the runtime in the same pass.
  */
 export function splitSurfaceFiles(root: string, files: string[]): SurfaceSplit {
     let hasDaemon = false;
+    let hasStream = false;
     const cold: string[] = [];
-    const hot: string[] = [];
+    const stream: string[] = [];
+    const request: string[] = [];
     for (const rel of files) {
         let src = '';
         try {
             src = fs.readFileSync(path.join(root, rel), 'utf8');
         } catch {
-            // unreadable: keep it in both passes (let toilscript surface the error).
+            // unreadable: keep it in EVERY pass (let toilscript surface the error).
             cold.push(rel);
-            hot.push(rel);
+            stream.push(rel);
+            request.push(rel);
             continue;
         }
-        const isCold = COLD_DECORATOR.test(src);
-        const isHot = HOT_DECORATOR.test(src);
-        if (isCold) hasDaemon ||= /^[ \t]*@daemon\b/m.test(src);
-        // Drop a file from the hot pass only when it is cold-only (cold surface, no hot surface);
-        // a mixed file stays in both (toilscript gates per class, not per file).
-        if (!(isCold && !isHot)) hot.push(rel);
-        // Drop a file from the cold pass only when it is hot-only.
-        if (!(isHot && !isCold)) cold.push(rel);
+        const isCold = COLD_DECORATOR.test(src) || isDaemonEntryFile(rel);
+        const isStream = STREAM_DECORATOR.test(src) || isStreamEntryFile(rel);
+        const isRequest =
+            REQUEST_DECORATOR.test(src) ||
+            (RUNTIME_ENTRY.test(src) && !isStreamEntryFile(rel) && !isDaemonEntryFile(rel));
+        if (isCold) hasDaemon ||= /^[ \t]*@daemon\b/m.test(src) || isDaemonEntryFile(rel);
+        if (isStream) hasStream = true;
+        // A file with no tier-specific surface is a SHARED helper, compiled into every pass.
+        const shared = !isCold && !isStream && !isRequest;
+        if (isCold || shared) cold.push(rel);
+        if (isStream || shared) stream.push(rel);
+        if (isRequest || shared) request.push(rel);
     }
-    return { hasDaemon, cold, hot };
+    return { hasDaemon, hasStream, cold, stream, request };
 }
 
 interface PassOptions {
@@ -417,32 +460,40 @@ function serverWasmFile(root: string): string {
  *  present in the toilconfig `release` target; otherwise derived from `outFile` by inserting the
  *  mode before the extension (`release.wasm` -> `release-hot.wasm` / `release-cold.wasm`). */
 export interface ServerArtifacts {
-    /** Absolute path to the hot (request/stream) artifact. */
+    /** Absolute path to the hot (request) artifact. */
     readonly hot: string;
     /** Absolute path to the cold (daemon) artifact. */
     readonly cold: string;
+    /** Absolute path to the stream (L2/L3 `@stream`) artifact (`release-stream.wasm`). */
+    readonly stream: string;
 }
 export function serverArtifacts(root: string): ServerArtifacts {
     let out = 'build/server/release.wasm';
     let hot: string | undefined;
     let cold: string | undefined;
+    let stream: string | undefined;
     try {
         const cfg = JSON.parse(fs.readFileSync(path.join(root, 'toilconfig.json'), 'utf8')) as {
-            targets?: Record<string, { outFile?: string; hotFile?: string; coldFile?: string }>;
+            targets?: Record<
+                string,
+                { outFile?: string; hotFile?: string; coldFile?: string; streamFile?: string }
+            >;
         };
         out = cfg.targets?.release?.outFile ?? out;
         hot = cfg.targets?.release?.hotFile;
         cold = cfg.targets?.release?.coldFile;
+        stream = cfg.targets?.release?.streamFile;
     } catch {
         // No readable toilconfig: caller already gated on its existence; keep defaults.
     }
-    const ins = (mode: 'hot' | 'cold'): string => {
+    const ins = (mode: 'hot' | 'cold' | 'stream'): string => {
         const ext = path.extname(out);
         return out.slice(0, ext ? -ext.length : undefined) + '-' + mode + (ext || '.wasm');
     };
     return {
         hot: path.resolve(root, hot ?? ins('hot')),
         cold: path.resolve(root, cold ?? ins('cold')),
+        stream: path.resolve(root, stream ?? ins('stream')),
     };
 }