tachyon-dom 0.1.0

package/dist/compiler/targets/server.js

@@ -0,0 +1,396 @@
+import { generatedEscapeHtmlHelperLines } from "../../html-escape.js";
+import { attrExpression, attrString, childPathEntries, escapeHtml, escapeMarker, expressionToScopeAccess, hydrationBoundaryFor, isHydrationAttribute, isVoidElement, jsOptionalPropertyAccess, jsString, itemNameFromKey, readExpressionAttribute, readPath, renderableChildren, serializeStaticAttr, textExpressionSegments, } from "../utils.js";
+const componentScope = (node, scope) => {
+    const next = { ...scope };
+    for (const attr of node.attrs) {
+        if (attr.name === "name") {
+            continue;
+        }
+        const expression = readExpressionAttribute(attr.value);
+        if (expression) {
+            next[attr.name] = readPath(next, expression);
+        }
+    }
+    const applyStores = (child) => {
+        if (child.type !== "element" || child.tagName !== "store") {
+            if (child.type === "element" && child.tagName !== "component") {
+                child.children.forEach(applyStores);
+            }
+            return;
+        }
+        for (const attr of child.attrs) {
+            const initial = readExpressionAttribute(attr.value);
+            if (initial) {
+                next[attr.name] = readPath(next, initial);
+            }
+        }
+    };
+    node.children.forEach(applyStores);
+    return next;
+};
+const renderText = (node, scope) => {
+    let output = "";
+    let lastEmittedWasText = false;
+    const separateTextNode = () => {
+        if (lastEmittedWasText) {
+            output += "<!---->";
+        }
+    };
+    for (const segment of textExpressionSegments(node.value)) {
+        if (segment.kind === "text") {
+            if (!segment.value) {
+                continue;
+            }
+            separateTextNode();
+            output += segment.value;
+            lastEmittedWasText = true;
+            continue;
+        }
+        separateTextNode();
+        output += escapeHtml(readPath(scope, segment.value));
+        lastEmittedWasText = true;
+    }
+    return output;
+};
+const renderFor = (node, scope, path) => {
+    const each = attrExpression(node, "each");
+    const key = attrExpression(node, "key") ?? "item";
+    const itemName = itemNameFromKey(key);
+    const items = each ? readPath(scope, each) : undefined;
+    if (!Array.isArray(items)) {
+        return "";
+    }
+    return items
+        .map((item) => {
+        const childScope = { ...scope, [itemName]: item };
+        return childPathEntries(node.children, path)
+            .map((entry) => renderNode(entry.child, childScope, entry.path))
+            .join("");
+    })
+        .join("");
+};
+const renderElement = (node, scope, path = []) => {
+    if (node.tagName === "outlet") {
+        return String(scope.outlet ?? "");
+    }
+    if (node.tagName === "slot") {
+        const slots = scope.slots;
+        const name = attrString(node, "name") ?? "default";
+        return slots && typeof slots === "object" ? String(slots[name] ?? "") : "";
+    }
+    if (node.tagName === "for") {
+        return renderFor(node, scope, path);
+    }
+    if (node.tagName === "if") {
+        return readPath(scope, attrExpression(node, "test") ?? "false")
+            ? node.children.map((child) => renderNode(child, scope)).join("")
+            : "";
+    }
+    if (node.tagName === "store") {
+        return "";
+    }
+    if (node.tagName === "component") {
+        const next = componentScope(node, scope);
+        const children = renderableChildren(node);
+        if (children.length === 1) {
+            return renderNode(children[0], next, path);
+        }
+        return children.map((child, index) => renderNode(child, next, [...path, index])).join("");
+    }
+    if (node.tagName === "await") {
+        const thenName = attrString(node, "then") ?? "value";
+        const value = readPath(scope, attrExpression(node, "value") ?? "undefined");
+        return node.children.map((child) => renderNode(child, { ...scope, [thenName]: value })).join("");
+    }
+    const attrs = [];
+    const classes = [];
+    const styles = [];
+    const hydrateBoundary = hydrationBoundaryFor(node, path);
+    for (const attr of node.attrs) {
+        if (attr.name.startsWith("on:") ||
+            attr.name.startsWith("bind:") ||
+            attr.name === "ref" ||
+            isHydrationAttribute(attr.name)) {
+            continue;
+        }
+        if (attr.name.startsWith("style:")) {
+            const expression = readExpressionAttribute(attr.value);
+            const value = expression ? readPath(scope, expression) : undefined;
+            if (value != null && value !== false) {
+                styles.push(`${attr.name.slice(6)}:${String(value)}`);
+            }
+            continue;
+        }
+        if (attr.name.startsWith("class:")) {
+            const expression = readExpressionAttribute(attr.value);
+            if (expression && readPath(scope, expression)) {
+                classes.push(attr.name.slice(6));
+            }
+            continue;
+        }
+        if (attr.name === "class" && attr.value !== true) {
+            classes.push(attr.value);
+            continue;
+        }
+        const expression = readExpressionAttribute(attr.value);
+        if (expression) {
+            const value = readPath(scope, expression);
+            if (value != null && value !== false) {
+                attrs.push(` ${attr.name}="${escapeHtml(value)}"`);
+            }
+            continue;
+        }
+        attrs.push(serializeStaticAttr(attr));
+    }
+    if (classes.length > 0) {
+        attrs.unshift(` class="${escapeHtml(classes.join(" "))}"`);
+    }
+    if (styles.length > 0) {
+        attrs.push(` style="${escapeHtml(styles.join(";"))}"`);
+    }
+    const html = isVoidElement(node)
+        ? `<${node.tagName}${attrs.join("")}>`
+        : `<${node.tagName}${attrs.join("")}>${childPathEntries(node.children, path)
+            .map((entry) => renderNode(entry.child, scope, entry.path))
+            .join("")}</${node.tagName}>`;
+    if (!hydrateBoundary) {
+        return html;
+    }
+    const marker = escapeMarker(hydrateBoundary.idKind === "static" ? hydrateBoundary.id : readPath(scope, hydrateBoundary.id));
+    return `<!--tachyon-hydrate:${marker}:start-->${html}<!--tachyon-hydrate:${marker}:end-->`;
+};
+const renderNode = (node, scope, path = []) => {
+    if (node.type === "text") {
+        return renderText(node, scope);
+    }
+    return renderElement(node, scope, path);
+};
+const renderTextExpression = (node, locals = new Set()) => {
+    const parts = [];
+    let lastEmittedWasText = false;
+    const separateTextNode = () => {
+        if (lastEmittedWasText) {
+            parts.push(jsString("<!---->"));
+        }
+    };
+    for (const segment of textExpressionSegments(node.value)) {
+        if (segment.kind === "text") {
+            if (segment.value) {
+                separateTextNode();
+                parts.push(jsString(segment.value));
+                lastEmittedWasText = true;
+            }
+            continue;
+        }
+        separateTextNode();
+        parts.push(`escapeHtml(${expressionToScopeAccess(segment.value, locals)})`);
+        lastEmittedWasText = true;
+    }
+    return parts.length > 0 ? parts.join(" + ") : `""`;
+};
+const foldStaticExpressionParts = (parts) => {
+    const folded = [];
+    let pending = "";
+    const flush = () => {
+        if (pending) {
+            folded.push(jsString(pending));
+            pending = "";
+        }
+    };
+    for (const part of parts) {
+        if (part.startsWith(`"`) && part.endsWith(`"`)) {
+            pending += JSON.parse(part);
+            continue;
+        }
+        flush();
+        folded.push(part);
+    }
+    flush();
+    return folded;
+};
+export const renderOpenTagExpression = (node, locals) => {
+    const parts = [jsString(`<${node.tagName}`)];
+    const staticClasses = [];
+    const dynamicClasses = [];
+    const dynamicStyles = [];
+    for (const attr of node.attrs) {
+        if (attr.name.startsWith("on:") ||
+            attr.name.startsWith("bind:") ||
+            attr.name === "ref" ||
+            isHydrationAttribute(attr.name)) {
+            continue;
+        }
+        if (attr.name.startsWith("style:")) {
+            const expression = readExpressionAttribute(attr.value);
+            if (expression) {
+                const value = expressionToScopeAccess(expression, locals);
+                dynamicStyles.push(`(${value} == null || ${value} === false ? "" : ${jsString(`${attr.name.slice(6)}:`)} + escapeHtml(${value}) + ${jsString(";")})`);
+            }
+            continue;
+        }
+        if (attr.name.startsWith("class:")) {
+            const expression = readExpressionAttribute(attr.value);
+            if (expression) {
+                dynamicClasses.push(`(${expressionToScopeAccess(expression, locals)} ? ${jsString(` ${attr.name.slice(6)}`)} : "")`);
+            }
+            continue;
+        }
+        if (attr.name === "class" && attr.value !== true) {
+            staticClasses.push(attr.value);
+            continue;
+        }
+        const expression = readExpressionAttribute(attr.value);
+        if (expression) {
+            const value = expressionToScopeAccess(expression, locals);
+            parts.push(`(${value} == null || ${value} === false ? "" : ${jsString(` ${attr.name}="`)} + escapeHtml(${value}) + ${jsString(`"`)} )`);
+            continue;
+        }
+        parts.push(jsString(serializeStaticAttr(attr)));
+    }
+    if (staticClasses.length > 0 || dynamicClasses.length > 0) {
+        const classExpression = `${jsString(staticClasses.join(" "))}${dynamicClasses.length > 0 ? ` + ${dynamicClasses.join(" + ")}` : ""}`;
+        parts.splice(1, 0, dynamicClasses.length === 0
+            ? jsString(` class="${staticClasses.join(" ")}"`)
+            : `(${classExpression} ? ${jsString(` class="`)} + (${classExpression}).trim() + ${jsString(`"`)} : "")`);
+    }
+    if (dynamicStyles.length > 0) {
+        const styleExpression = dynamicStyles.join(" + ");
+        parts.push(`(${styleExpression} ? ${jsString(` style="`)} + (${styleExpression}).replace(/;$/, "") + ${jsString(`"`)} : "")`);
+    }
+    parts.push(jsString(">"));
+    return foldStaticExpressionParts(parts).join(" + ");
+};
+export const renderNodeExpression = (node, locals = new Set(), path = []) => {
+    if (node.type === "text") {
+        return renderTextExpression(node, locals);
+    }
+    return renderElementExpression(node, locals, path);
+};
+const renderForExpression = (node, locals, path) => {
+    const each = attrExpression(node, "each") ?? "[]";
+    const key = attrExpression(node, "key") ?? "item";
+    const itemName = itemNameFromKey(key);
+    const eachAccess = expressionToScopeAccess(each, locals);
+    const childLocals = new Set(locals);
+    childLocals.add(itemName);
+    const childExpression = childPathEntries(node.children, path)
+        .map((entry) => renderNodeExpression(entry.child, childLocals, entry.path))
+        .join(" + ");
+    return `(Array.isArray(${eachAccess}) ? ${eachAccess}.map((${itemName}) => ${childExpression || `""`}).join("") : "")`;
+};
+const renderElementExpression = (node, locals = new Set(), path = []) => {
+    if (node.tagName === "outlet") {
+        return `String(scope.outlet ?? "")`;
+    }
+    if (node.tagName === "slot") {
+        const name = attrString(node, "name") ?? "default";
+        return `String(${jsOptionalPropertyAccess("scope.slots", name)} ?? "")`;
+    }
+    if (node.tagName === "for") {
+        return renderForExpression(node, locals, path);
+    }
+    if (node.tagName === "if") {
+        const test = expressionToScopeAccess(attrExpression(node, "test") ?? "false", locals);
+        const childExpression = childPathEntries(node.children, path)
+            .map((entry) => renderNodeExpression(entry.child, locals, entry.path))
+            .join(" + ");
+        return `(${test} ? ${childExpression || `""`} : "")`;
+    }
+    if (node.tagName === "store") {
+        return `""`;
+    }
+    if (node.tagName === "component") {
+        return renderComponentExpression(node, locals, path);
+    }
+    if (node.tagName === "await") {
+        const value = expressionToScopeAccess(attrExpression(node, "value") ?? "undefined", locals);
+        const thenName = attrString(node, "then") ?? "value";
+        const childLocals = new Set(locals);
+        childLocals.add(thenName);
+        const childExpression = childPathEntries(node.children, path)
+            .map((entry) => renderNodeExpression(entry.child, childLocals, entry.path))
+            .join(" + ");
+        return `(((${thenName}) => ${childExpression || `""`})(${value}))`;
+    }
+    const parts = [renderOpenTagExpression(node, locals)];
+    parts.push(...childPathEntries(node.children, path).map((entry) => renderNodeExpression(entry.child, locals, entry.path)));
+    if (!isVoidElement(node)) {
+        parts.push(jsString(`</${node.tagName}>`));
+    }
+    const expression = parts.join(" + ");
+    const hydrateBoundary = hydrationBoundaryFor(node, path);
+    if (!hydrateBoundary) {
+        return expression;
+    }
+    const marker = hydrateBoundary.idKind === "static"
+        ? jsString(hydrateBoundary.id)
+        : expressionToScopeAccess(hydrateBoundary.id, locals);
+    return `${jsString("<!--tachyon-hydrate:")} + escapeMarker(${marker}) + ${jsString(":start-->")} + ${expression} + ${jsString("<!--tachyon-hydrate:")} + escapeMarker(${marker}) + ${jsString(":end-->")}`;
+};
+const renderComponentExpression = (node, locals, path) => {
+    const localNames = new Set(locals);
+    const declarations = [];
+    for (const attr of node.attrs) {
+        if (attr.name === "name") {
+            continue;
+        }
+        const expression = readExpressionAttribute(attr.value);
+        if (expression) {
+            declarations.push(`const ${attr.name} = ${expressionToScopeAccess(expression, localNames)};`);
+            localNames.add(attr.name);
+        }
+    }
+    const applyStoreDeclarations = (child) => {
+        if (child.type !== "element" || child.tagName !== "store") {
+            if (child.type === "element" && child.tagName !== "component") {
+                child.children.forEach(applyStoreDeclarations);
+            }
+            return;
+        }
+        for (const attr of child.attrs) {
+            const initial = readExpressionAttribute(attr.value);
+            if (initial) {
+                declarations.push(`const ${attr.name} = ${expressionToScopeAccess(initial, localNames)};`);
+                localNames.add(attr.name);
+            }
+        }
+    };
+    node.children.forEach(applyStoreDeclarations);
+    const children = renderableChildren(node);
+    const expression = children.length === 1
+        ? renderNodeExpression(children[0], localNames, path)
+        : children.map((child, index) => renderNodeExpression(child, localNames, [...path, index])).join(" + ") || `""`;
+    return `(() => { ${declarations.join(" ")} return ${expression}; })()`;
+};
+const serverModuleCache = new WeakMap();
+export const generateServerModule = (template) => {
+    const cached = serverModuleCache.get(template);
+    if (cached) {
+        return cached;
+    }
+    const lines = [
+        ...generatedEscapeHtmlHelperLines,
+        `const escapeMarker = (value) => String(value ?? "").replaceAll("--", "- -").replaceAll(">", "&gt;");`,
+        `const escapeScriptJson = (value) => value.replaceAll("<", "\\\\u003c").replaceAll(">", "\\\\u003e");`,
+        `const ATTRIBUTE_ESCAPE = { "&": "&amp;", '"': "&quot;", "<": "&lt;" };`,
+        `const escapeAttribute = (value) => String(value).replace(/[&"<]/g, (char) => ATTRIBUTE_ESCAPE[char]);`,
+        `export const hydrationBoundaries = ${JSON.stringify(template.client.hydrationBoundaries)};`,
+        `export const renderHydrationState = (id, state) => '<script type="application/json" data-tachyon-state="' + escapeAttribute(id) + '">' + escapeScriptJson(JSON.stringify(state) ?? "null") + '</script>';`,
+        `export const render = (scope) => ${renderElementExpression(template.root)};`,
+    ];
+    const code = `${lines.join("\n")}\n`;
+    serverModuleCache.set(template, code);
+    return code;
+};
+const serverRendererCache = new WeakMap();
+export const compileServerTemplate = (template) => {
+    const cached = serverRendererCache.get(template);
+    if (cached) {
+        return cached;
+    }
+    const root = structuredClone(template.root);
+    const renderer = (scope) => renderNode(root, scope);
+    serverRendererCache.set(template, renderer);
+    return renderer;
+};
+export const renderServerTemplate = (template, scope) => compileServerTemplate(template)(scope);

package/dist/compiler/targets/stream.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledTemplate } from "../types.js";
+export declare const generateServerStreamModule: (template: CompiledTemplate) => string;

package/dist/compiler/targets/stream.js

@@ -0,0 +1,204 @@
+import { generatedEscapeHtmlHelperLines } from "../../html-escape.js";
+import { attrExpression, attrString, childPathEntries, expressionToScopeAccess, hydrationBoundaryFor, isVoidElement, itemNameFromKey, jsOptionalPropertyAccess, jsString, readExpressionAttribute, renderableChildren, textExpressionSegments, } from "../utils.js";
+import { renderOpenTagExpression } from "./server.js";
+const renderTextYieldStatements = (node, locals, indent) => {
+    const statements = [];
+    let lastEmittedWasText = false;
+    const separateTextNode = () => {
+        if (lastEmittedWasText) {
+            statements.push(`${indent}yield "<!---->";`);
+        }
+    };
+    for (const segment of textExpressionSegments(node.value)) {
+        if (segment.kind === "text") {
+            if (segment.value) {
+                separateTextNode();
+                statements.push(`${indent}yield ${jsString(segment.value)};`);
+                lastEmittedWasText = true;
+            }
+            continue;
+        }
+        separateTextNode();
+        statements.push(`${indent}yield escapeHtml(${expressionToScopeAccess(segment.value, locals)});`);
+        lastEmittedWasText = true;
+    }
+    return statements;
+};
+const renderForYieldStatements = (node, locals, indent, path) => {
+    const each = attrExpression(node, "each") ?? "[]";
+    const key = attrExpression(node, "key") ?? "item";
+    const itemName = itemNameFromKey(key);
+    const eachAccess = expressionToScopeAccess(each, locals);
+    const childLocals = new Set(locals);
+    childLocals.add(itemName);
+    const statements = [
+        `${indent}if (Array.isArray(${eachAccess})) {`,
+        `${indent}  for (const ${itemName} of ${eachAccess}) {`,
+    ];
+    for (const entry of childPathEntries(node.children, path)) {
+        statements.push(...renderNodeYieldStatements(entry.child, childLocals, `${indent}    `, entry.path));
+    }
+    statements.push(`${indent}  }`, `${indent}}`);
+    return statements;
+};
+const renderElementYieldStatements = (node, locals, indent, path) => {
+    if (node.tagName === "outlet") {
+        return [`${indent}yield String(scope.outlet ?? "");`];
+    }
+    if (node.tagName === "slot") {
+        return [
+            `${indent}yield String(${jsOptionalPropertyAccess("scope.slots", attrString(node, "name") ?? "default")} ?? "");`,
+        ];
+    }
+    if (node.tagName === "for") {
+        return renderForYieldStatements(node, locals, indent, path);
+    }
+    if (node.tagName === "if") {
+        const statements = [`${indent}if (${expressionToScopeAccess(attrExpression(node, "test") ?? "false", locals)}) {`];
+        for (const entry of childPathEntries(node.children, path)) {
+            statements.push(...renderNodeYieldStatements(entry.child, locals, `${indent}  `, entry.path));
+        }
+        statements.push(`${indent}}`);
+        return statements;
+    }
+    if (node.tagName === "store") {
+        return [];
+    }
+    if (node.tagName === "component") {
+        return renderComponentYieldStatements(node, locals, indent, path);
+    }
+    if (node.tagName === "await") {
+        const thenName = attrString(node, "then") ?? "value";
+        const fallback = attrString(node, "fallback");
+        const errorText = attrString(node, "error");
+        const childLocals = new Set(locals);
+        childLocals.add(thenName);
+        const statements = [`${indent}{`];
+        if (fallback) {
+            statements.push(`${indent}  yield ${jsString(fallback)};`);
+        }
+        if (errorText) {
+            statements.push(`${indent}  try {`);
+            statements.push(`${indent}    const ${thenName} = await ${expressionToScopeAccess(attrExpression(node, "value") ?? "undefined", locals)};`);
+            for (const entry of childPathEntries(node.children, path)) {
+                statements.push(...renderNodeYieldStatements(entry.child, childLocals, `${indent}    `, entry.path));
+            }
+            statements.push(`${indent}  } catch {`);
+            statements.push(`${indent}    yield ${jsString(errorText)};`);
+            statements.push(`${indent}  }`);
+            statements.push(`${indent}}`);
+            return statements;
+        }
+        statements.push(`${indent}  const ${thenName} = await ${expressionToScopeAccess(attrExpression(node, "value") ?? "undefined", locals)};`);
+        for (const entry of childPathEntries(node.children, path)) {
+            statements.push(...renderNodeYieldStatements(entry.child, childLocals, `${indent}  `, entry.path));
+        }
+        statements.push(`${indent}}`);
+        return statements;
+    }
+    const hydrateBoundary = hydrationBoundaryFor(node, path);
+    const statements = [];
+    if (hydrateBoundary) {
+        const marker = hydrateBoundary.idKind === "static"
+            ? jsString(hydrateBoundary.id)
+            : expressionToScopeAccess(hydrateBoundary.id, locals);
+        statements.push(`${indent}yield ${jsString("<!--tachyon-hydrate:")} + escapeMarker(${marker}) + ${jsString(":start-->")};`);
+    }
+    statements.push(`${indent}yield ${renderOpenTagExpression(node, locals)};`);
+    for (const entry of childPathEntries(node.children, path)) {
+        statements.push(...renderNodeYieldStatements(entry.child, locals, indent, entry.path));
+    }
+    if (!isVoidElement(node)) {
+        statements.push(`${indent}yield ${jsString(`</${node.tagName}>`)};`);
+    }
+    if (hydrateBoundary) {
+        const marker = hydrateBoundary.idKind === "static"
+            ? jsString(hydrateBoundary.id)
+            : expressionToScopeAccess(hydrateBoundary.id, locals);
+        statements.push(`${indent}yield ${jsString("<!--tachyon-hydrate:")} + escapeMarker(${marker}) + ${jsString(":end-->")};`);
+    }
+    return statements;
+};
+const renderComponentYieldStatements = (node, locals, indent, path) => {
+    const localNames = new Set(locals);
+    const statements = [`${indent}{`];
+    for (const attr of node.attrs) {
+        if (attr.name === "name") {
+            continue;
+        }
+        const expression = readExpressionAttribute(attr.value);
+        if (expression) {
+            statements.push(`${indent}  const ${attr.name} = ${expressionToScopeAccess(expression, localNames)};`);
+            localNames.add(attr.name);
+        }
+    }
+    for (const child of node.children) {
+        if (child.type !== "element" || child.tagName !== "store") {
+            continue;
+        }
+        for (const attr of child.attrs) {
+            const initial = readExpressionAttribute(attr.value);
+            if (initial) {
+                statements.push(`${indent}  const ${attr.name} = ${expressionToScopeAccess(initial, localNames)};`);
+                localNames.add(attr.name);
+            }
+        }
+    }
+    const children = renderableChildren(node);
+    if (children.length === 1) {
+        statements.push(...renderNodeYieldStatements(children[0], localNames, `${indent}  `, path));
+    }
+    else {
+        for (const [index, child] of children.entries()) {
+            statements.push(...renderNodeYieldStatements(child, localNames, `${indent}  `, [...path, index]));
+        }
+    }
+    statements.push(`${indent}}`);
+    return statements;
+};
+const renderNodeYieldStatements = (node, locals, indent, path = []) => {
+    if (node.type === "text") {
+        return renderTextYieldStatements(node, locals, indent);
+    }
+    return renderElementYieldStatements(node, locals, indent, path);
+};
+const streamModuleCache = new WeakMap();
+export const generateServerStreamModule = (template) => {
+    const cached = streamModuleCache.get(template);
+    if (cached) {
+        return cached;
+    }
+    const coalescedStatements = renderNodeYieldStatements(template.root, new Set(), "  ").flatMap((line) => {
+        const yieldMatch = /^(\s*)yield (.*);$/.exec(line);
+        if (yieldMatch) {
+            return [
+                `${yieldMatch[1]}__tachyonPush(${yieldMatch[2]});`,
+                `${yieldMatch[1]}if (__tachyonBufferBytes >= __tachyonFlushBytes) { yield __tachyonBuffer; __tachyonBuffer = ""; __tachyonBufferBytes = 0; }`,
+            ];
+        }
+        if (line.includes(" await ")) {
+            const indent = line.match(/^\s*/)?.[0] ?? "";
+            return [
+                `${indent}if (__tachyonBuffer) { yield __tachyonBuffer; __tachyonBuffer = ""; __tachyonBufferBytes = 0; }`,
+                line,
+            ];
+        }
+        return [line];
+    });
+    const lines = [
+        ...generatedEscapeHtmlHelperLines,
+        `const escapeMarker = (value) => String(value ?? "").replaceAll("--", "- -").replaceAll(">", "&gt;");`,
+        `export const stream = async function* (scope) {`,
+        `  const __tachyonFlushBytes = 8192;`,
+        `  const __tachyonTextEncoder = new TextEncoder();`,
+        `  let __tachyonBuffer = "";`,
+        `  let __tachyonBufferBytes = 0;`,
+        `  const __tachyonPush = (chunk) => { const text = String(chunk ?? ""); __tachyonBuffer += text; __tachyonBufferBytes += __tachyonTextEncoder.encode(text).byteLength; };`,
+        ...coalescedStatements,
+        `  if (__tachyonBuffer) { yield __tachyonBuffer; }`,
+        `};`,
+    ];
+    const code = `${lines.join("\n")}\n`;
+    streamModuleCache.set(template, code);
+    return code;
+};