@zenithbuild/cli 0.7.3 → 0.7.4

package/dist/build/page-loop.js

@@ -5,14 +5,14 @@ import { applyOccurrenceRewritePlans } from '../component-instance-ir.js';
 import { collectExpandedComponentOccurrences } from '../component-occurrences.js';
 import { expandComponents } from '../resolve-components.js';
 import { composeServerScriptEnvelope, resolveAdjacentServerModules } from '../server-script-composition.js';
-import { createTimedCompilerRunner } from './compiler-runtime.js';
+import { createTimedCompilerRunner, mergePageImageMaterialization } from './compiler-runtime.js';
 import { buildComponentExpressionRewrite, mergeExpressionRewriteMaps, resolveRewrittenBindingMetadata } from './expression-rewrites.js';
 import { createPageIrMergeCache } from './merge-component-ir.js';
 import { buildPageOwnerContext, runPageComponentLoop } from './page-component-loop.js';
-import { applyExpressionRewrites, applyScopedIdentifierRewrites, normalizeExpressionBindingDependencies, normalizeExpressionPayload, normalizeHoistedSourcePayload, rewriteLegacyMarkupIdentifiers, rewriteRefBindingIdentifiers, synthesizeSignalBackedCompiledExpressions } from './page-ir-normalization.js';
+import { applyExpressionRewrites, normalizeExpressionPayload, normalizeHoistedSourcePayload, rewriteLegacyMarkupIdentifiers, rewriteRefBindingIdentifiers } from './page-ir-normalization.js';
+import { deferComponentRuntimeBlock } from './hoisted-code-transforms.js';
 import { addBreakdown, emitPageLoopSummary, recordPageProfile } from './page-loop-metrics.js';
 import { applyServerEnvelopeToPageIr, buildOccurrenceCountByPath, createPageBuildState, createPageLoopCaches, createPageLoopExecutionState } from './page-loop-state.js';
-import { buildScopedIdentifierRewrite } from './scoped-identifier-rewrite.js';
 import { extractServerScript } from './server-script.js';
 /**
  * @param {{
@@ -33,7 +33,7 @@ export async function buildPageEnvelopes(input) {
     const { manifest, pagesDir, srcDir, registry, compilerOpts, compilerBin, routerEnabled, startupProfile, compilerTotals, emitCompilerWarning } = input;
     const cacheState = input.pageLoopCaches || createPageLoopCaches();
     const executionState = createPageLoopExecutionState();
-    const { componentIrCache, componentDocumentModeCache, componentExpressionRewriteCache, templateExpressionCache, hoistedCodeTransformCache } = cacheState;
+    const { componentIrCache, componentDocumentModeCache, componentExpressionRewriteCache, hoistedCodeTransformCache } = cacheState;
     const { expressionRewriteMetrics, pagePhaseTotals, occurrenceApplyPhaseTotals, bindingResolutionTotals, scopedRewritePhaseTotals, mergePhaseTotals, componentLoopPhaseTotals, pageProfiles, envelopes } = executionState;
     async function cooperativeYield() {
         await new Promise((resolve) => setImmediate(resolve));
@@ -52,7 +52,7 @@ export async function buildPageEnvelopes(input) {
         const pageOwnerExtractStartedAt = performance.now();
         const pageOwnerSource = extractServerScript(rawSource, sourceFile, compilerOpts).source;
         pagePhase.serverExtractMs += startupProfile.roundMs(performance.now() - pageOwnerExtractStartedAt);
-        const { guardPath: adjacentGuard, loadPath: adjacentLoad } = resolveAdjacentServerModules(sourceFile);
+        const { guardPath: adjacentGuard, loadPath: adjacentLoad, actionPath: adjacentAction } = resolveAdjacentServerModules(sourceFile);
         const expandedStartedAt = performance.now();
         const { expandedSource } = expandComponents(rawSource, registry, sourceFile);
         pageExpandMs = startupProfile.roundMs(performance.now() - expandedStartedAt);
@@ -62,21 +62,24 @@ export async function buildPageEnvelopes(input) {
         const compileSource = extractedServer.source;
         await cooperativeYield();
         const pageCompileStartedAt = performance.now();
-        const pageIr = timedRunCompiler('page', sourceFile, compileSource, compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
+        let pageIr = timedRunCompiler('page', sourceFile, compileSource, compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
         pageCompileMs = startupProfile.roundMs(performance.now() - pageCompileStartedAt);
         const composedServer = composeServerScriptEnvelope({
             sourceFile,
             inlineServerScript: extractedServer.serverScript,
             adjacentGuardPath: adjacentGuard,
-            adjacentLoadPath: adjacentLoad
+            adjacentLoadPath: adjacentLoad,
+            adjacentActionPath: adjacentAction
         });
         const hasGuard = composedServer.serverScript?.has_guard === true;
         const hasLoad = composedServer.serverScript?.has_load === true;
+        const hasAction = composedServer.serverScript?.has_action === true;
         applyServerEnvelopeToPageIr({
             pageIr,
             composedServer,
             hasGuard,
             hasLoad,
+            hasAction,
             entry,
             srcDir,
             sourceFile
@@ -89,7 +92,8 @@ export async function buildPageEnvelopes(input) {
         const pageAmbiguousExpressionMap = new Set();
         const knownRefKeys = new Set();
         const componentOccurrencePlans = [];
-        const { pageOwnerCompileMs: resolvedPageOwnerCompileMs, pageOwnerExpressionRewrite, pageOwnerScopeRewrite } = await buildPageOwnerContext({
+        const imagePropsLiterals = [];
+        const { pageOwnerCompileMs: resolvedPageOwnerCompileMs, pageOwnerExpressionRewrite } = await buildPageOwnerContext({
             componentOccurrences,
             sourceFile,
             pageOwnerSource,
@@ -97,13 +101,12 @@ export async function buildPageEnvelopes(input) {
             compilerBin,
             timedRunCompiler,
             cooperativeYield,
-            templateExpressionCache,
             expressionRewriteMetrics,
             startupProfile
         });
         pageOwnerCompileMs = resolvedPageOwnerCompileMs;
         const pageSelfRewriteStartedAt = performance.now();
-        const pageSelfExpressionRewrite = buildComponentExpressionRewrite(sourceFile, compileSource, pageIr, compilerOpts, compilerBin, templateExpressionCache, expressionRewriteMetrics);
+        const pageSelfExpressionRewrite = buildComponentExpressionRewrite(pageIr, expressionRewriteMetrics);
         pagePhase.selfRewriteMs = startupProfile.roundMs(performance.now() - pageSelfRewriteStartedAt);
         mergeExpressionRewriteMaps(pageExpressionRewriteMap, pageExpressionBindingMap, pageAmbiguousExpressionMap, pageSelfExpressionRewrite, pageIrMergeCache, pageBindingResolutionBreakdown);
         const componentLoopStartedAt = performance.now();
@@ -127,10 +130,8 @@ export async function buildPageEnvelopes(input) {
             componentIrCache,
             componentDocumentModeCache,
             componentExpressionRewriteCache,
-            templateExpressionCache,
             expressionRewriteMetrics,
             pageOwnerExpressionRewrite,
-            pageOwnerScopeRewrite,
             pageIr,
             pageIrMergeCache,
             seenStaticImports,
@@ -139,6 +140,7 @@ export async function buildPageEnvelopes(input) {
             pageAmbiguousExpressionMap,
             knownRefKeys,
             componentOccurrencePlans,
+            imagePropsLiterals,
             pagePhase,
             pageBindingResolutionBreakdown,
             pageMergeBreakdown,
@@ -150,25 +152,25 @@ export async function buildPageEnvelopes(input) {
         pageComponentCacheHits = pageStats.pageComponentCacheHits;
         pageComponentCacheMisses = pageStats.pageComponentCacheMisses;
         pagePhase.componentLoopMs = startupProfile.roundMs(performance.now() - componentLoopStartedAt);
+        if (imagePropsLiterals.length > 0) {
+            pageIr = mergePageImageMaterialization(pageIr, imagePropsLiterals, {
+                compilerToolchain: compilerBin
+            });
+        }
         const occurrencePlanApplyStartedAt = performance.now();
         applyOccurrenceRewritePlans(pageIr, componentOccurrencePlans, (rewrite, binding) => resolveRewrittenBindingMetadata(pageIrMergeCache, rewrite, binding, pageBindingResolutionBreakdown), pageOccurrenceApplyBreakdown);
         pagePhase.occurrencePlanApplyMs = startupProfile.roundMs(performance.now() - occurrencePlanApplyStartedAt);
         const expressionApplyStartedAt = performance.now();
         applyExpressionRewrites(pageIr, pageExpressionRewriteMap, pageExpressionBindingMap, pageAmbiguousExpressionMap);
         pagePhase.expressionApplyMs = startupProfile.roundMs(performance.now() - expressionApplyStartedAt);
-        const scopedRewriteStartedAt = performance.now();
-        const scopedRewritePlanStartedAt = performance.now();
-        const scopedRewritePlan = buildScopedIdentifierRewrite(pageIr);
-        pagePhase.scopedRewritePlanMs = startupProfile.roundMs(performance.now() - scopedRewritePlanStartedAt);
-        const scopedRewriteApplyStartedAt = performance.now();
-        applyScopedIdentifierRewrites(pageIr, scopedRewritePlan, pageScopedRewriteBreakdown);
-        pagePhase.scopedRewriteApplyMs = startupProfile.roundMs(performance.now() - scopedRewriteApplyStartedAt);
-        pagePhase.scopedRewriteMs = startupProfile.roundMs(performance.now() - scopedRewriteStartedAt);
         const normalizeStartedAt = performance.now();
-        synthesizeSignalBackedCompiledExpressions(pageIr);
         normalizeExpressionPayload(pageIr);
         normalizeHoistedSourcePayload(pageIr);
-        normalizeExpressionBindingDependencies(pageIr);
+        if (Array.isArray(pageIr?.hoisted?.code) && pageIr.hoisted.code.length > 0) {
+            pageIr.hoisted.code = pageIr.hoisted.code
+                .map((entry) => deferComponentRuntimeBlock(entry, hoistedCodeTransformCache, expressionRewriteMetrics))
+                .filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+        }
         rewriteLegacyMarkupIdentifiers(pageIr);
         rewriteRefBindingIdentifiers(pageIr, knownRefKeys);
         pagePhase.normalizeMs = startupProfile.roundMs(performance.now() - normalizeStartedAt);
@@ -182,6 +184,9 @@ export async function buildPageEnvelopes(input) {
             route: entry.path,
             file: sourceFile,
             ir: pageIr,
+            image_materialization: Array.isArray(pageIr.image_materialization)
+                ? pageIr.image_materialization
+                : [],
             router: routerEnabled
         });
         recordPageProfile({

package/dist/build/scoped-identifier-rewrite.d.ts

@@ -1,29 +1,3 @@
-/**
- * @param {object | null | undefined} ir
- * @returns {{ map: Map<string, string>, ambiguous: Set<string> }}
- */
-export function buildScopedIdentifierRewrite(ir: object | null | undefined): {
-    map: Map<string, string>;
-    ambiguous: Set<string>;
-};
-/**
- * @param {string} expr
- * @param {{
- *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
- * } | null} rewriteContext
- * @returns {string}
- */
-export function rewritePropsExpression(expr: string, rewriteContext?: {
-    expressionRewrite?: {
-        map?: Map<string, string>;
-        ambiguous?: Set<string>;
-    } | null;
-    scopeRewrite?: {
-        map?: Map<string, string>;
-        ambiguous?: Set<string>;
-    } | null;
-} | null): string;
 /**
  * @param {string | null | undefined} compiledExpr
  * @param {{
@@ -41,6 +15,10 @@ export function resolveCompiledPropsExpression(compiledExpr: string | null | und
     }>;
 } | null | undefined): string | null;
 /**
+ * The only allowed downstream props rewrite boundary is compiler-owned exact lookup.
+ * If the compiler did not emit a mapping for the attr expression, CLI keeps the
+ * original expression text without attempting identifier reinterpretation.
+ *
  * @param {string} expr
  * @param {{
  *   expressionRewrite?: {
@@ -49,8 +27,7 @@ export function resolveCompiledPropsExpression(compiledExpr: string | null | und
  *     ambiguous?: Set<string>,
  *     signals?: Array<{ state_index?: number }>,
  *     stateBindings?: Array<{ key?: string }>
- *   } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   } | null
  * } | null} rewriteContext
  * @returns {string}
  */
@@ -68,45 +45,61 @@ export function resolvePropsValueCode(expr: string, rewriteContext?: {
             key?: string;
         }>;
     } | null;
-    scopeRewrite?: {
-        map?: Map<string, string>;
-        ambiguous?: Set<string>;
-    } | null;
 } | null): string;
 /**
  * @param {string} attrs
  * @param {{
- *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   expressionRewrite?: {
+ *     map?: Map<string, string>,
+ *     bindings?: Map<string, { compiled_expr?: string | null }>,
+ *     ambiguous?: Set<string>,
+ *     signals?: Array<{ state_index?: number }>,
+ *     stateBindings?: Array<{ key?: string }>
+ *   } | null
  * } | null} rewriteContext
  * @returns {string}
  */
 export function renderPropsLiteralFromAttrs(attrs: string, rewriteContext?: {
     expressionRewrite?: {
         map?: Map<string, string>;
+        bindings?: Map<string, {
+            compiled_expr?: string | null;
+        }>;
         ambiguous?: Set<string>;
-    } | null;
-    scopeRewrite?: {
-        map?: Map<string, string>;
-        ambiguous?: Set<string>;
+        signals?: Array<{
+            state_index?: number;
+        }>;
+        stateBindings?: Array<{
+            key?: string;
+        }>;
     } | null;
 } | null): string;
 /**
  * @param {string} source
  * @param {string} attrs
  * @param {{
- *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   expressionRewrite?: {
+ *     map?: Map<string, string>,
+ *     bindings?: Map<string, { compiled_expr?: string | null }>,
+ *     ambiguous?: Set<string>,
+ *     signals?: Array<{ state_index?: number }>,
+ *     stateBindings?: Array<{ key?: string }>
+ *   } | null
  * } | null} rewriteContext
  * @returns {string}
  */
 export function injectPropsPrelude(source: string, attrs: string, rewriteContext?: {
     expressionRewrite?: {
         map?: Map<string, string>;
+        bindings?: Map<string, {
+            compiled_expr?: string | null;
+        }>;
         ambiguous?: Set<string>;
-    } | null;
-    scopeRewrite?: {
-        map?: Map<string, string>;
-        ambiguous?: Set<string>;
+        signals?: Array<{
+            state_index?: number;
+        }>;
+        stateBindings?: Array<{
+            key?: string;
+        }>;
     } | null;
 } | null): string;

package/dist/build/scoped-identifier-rewrite.js

@@ -1,116 +1,5 @@
-import { extractDeclaredIdentifiers, normalizeTypeScriptExpression, renderObjectKey, rewriteIdentifiersWithinExpression } from './typescript-expression-utils.js';
-/**
- * @param {string} value
- * @returns {string | null}
- */
-function deriveScopedIdentifierAlias(value) {
-    const ident = String(value || '').trim();
-    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(ident)) {
-        return null;
-    }
-    const parts = ident.split('_').filter(Boolean);
-    const candidate = parts.length > 1 ? parts[parts.length - 1] : ident;
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(candidate) ? candidate : ident;
-}
-/**
- * @param {Map<string, string>} map
- * @param {Set<string>} ambiguous
- * @param {string | null} raw
- * @param {string | null} rewritten
- */
-function recordScopedIdentifierRewrite(map, ambiguous, raw, rewritten) {
-    if (typeof raw !== 'string' || raw.length === 0 || typeof rewritten !== 'string' || rewritten.length === 0) {
-        return;
-    }
-    const existing = map.get(raw);
-    if (existing && existing !== rewritten) {
-        map.delete(raw);
-        ambiguous.add(raw);
-        return;
-    }
-    if (!ambiguous.has(raw)) {
-        map.set(raw, rewritten);
-    }
-}
-/**
- * @param {object | null | undefined} ir
- * @returns {{ map: Map<string, string>, ambiguous: Set<string> }}
- */
-export function buildScopedIdentifierRewrite(ir) {
-    const out = { map: new Map(), ambiguous: new Set() };
-    if (!ir || typeof ir !== 'object') {
-        return out;
-    }
-    const stateBindings = Array.isArray(ir?.hoisted?.state) ? ir.hoisted.state : [];
-    for (const stateEntry of stateBindings) {
-        const key = typeof stateEntry?.key === 'string' ? stateEntry.key : null;
-        recordScopedIdentifierRewrite(out.map, out.ambiguous, deriveScopedIdentifierAlias(key), key);
-    }
-    const functionBindings = Array.isArray(ir?.hoisted?.functions) ? ir.hoisted.functions : [];
-    for (const fnName of functionBindings) {
-        if (typeof fnName !== 'string') {
-            continue;
-        }
-        recordScopedIdentifierRewrite(out.map, out.ambiguous, deriveScopedIdentifierAlias(fnName), fnName);
-    }
-    const declarations = Array.isArray(ir?.hoisted?.declarations) ? ir.hoisted.declarations : [];
-    for (const declaration of declarations) {
-        if (typeof declaration !== 'string') {
-            continue;
-        }
-        for (const identifier of extractDeclaredIdentifiers(declaration)) {
-            recordScopedIdentifierRewrite(out.map, out.ambiguous, deriveScopedIdentifierAlias(identifier), identifier);
-        }
-    }
-    return out;
-}
-/**
- * @param {string} expr
- * @param {{
- *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
- * } | null} rewriteContext
- * @returns {string}
- */
-export function rewritePropsExpression(expr, rewriteContext = null) {
-    const trimmed = String(expr || '').trim();
-    if (!trimmed) {
-        return trimmed;
-    }
-    const expressionMap = rewriteContext?.expressionRewrite?.map;
-    const expressionAmbiguous = rewriteContext?.expressionRewrite?.ambiguous;
-    if (expressionMap instanceof Map &&
-        !(expressionAmbiguous instanceof Set && expressionAmbiguous.has(trimmed))) {
-        const exact = expressionMap.get(trimmed);
-        if (typeof exact === 'string' && exact.length > 0) {
-            return normalizeTypeScriptExpression(exact);
-        }
-    }
-    const scopeMap = rewriteContext?.scopeRewrite?.map;
-    const scopeAmbiguous = rewriteContext?.scopeRewrite?.ambiguous;
-    const rootMatch = trimmed.match(/^([A-Za-z_$][A-Za-z0-9_$]*)([\s\S]*)$/);
-    if (!(scopeMap instanceof Map)) {
-        return normalizeTypeScriptExpression(trimmed);
-    }
-    if (!rootMatch) {
-        return rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
-    }
-    const root = rootMatch[1];
-    if (scopeAmbiguous instanceof Set && scopeAmbiguous.has(root)) {
-        return rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
-    }
-    const rewrittenRoot = scopeMap.get(root);
-    if (typeof rewrittenRoot !== 'string' || rewrittenRoot.length === 0 || rewrittenRoot === root) {
-        return rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
-    }
-    if (rootMatch[2].trim().length === 0) {
-        return normalizeTypeScriptExpression(rewrittenRoot);
-    }
-    const rewrittenExpr = rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
-    return typeof rewrittenExpr === 'string' && rewrittenExpr.length > 0
-        ? rewrittenExpr
-        : normalizeTypeScriptExpression(`${rewrittenRoot}${rootMatch[2]}`);
-}
+import { normalizeTypeScriptExpression, renderObjectKey } from './typescript-expression-utils.js';
+import { rewriteCompilerSignalMapReferences } from './compiler-signal-expression.js';
 /**
  * @param {string | null | undefined} compiledExpr
  * @param {{
@@ -126,22 +15,24 @@ export function resolveCompiledPropsExpression(compiledExpr, expressionRewrite =
     }
     const signals = Array.isArray(expressionRewrite?.signals) ? expressionRewrite.signals : [];
     const stateBindings = Array.isArray(expressionRewrite?.stateBindings) ? expressionRewrite.stateBindings : [];
-    const resolved = source.replace(/signalMap\.get\((\d+)\)(?:\.get\(\))?/g, (full, rawIndex) => {
-        const signalIndex = Number.parseInt(rawIndex, 10);
-        if (!Number.isInteger(signalIndex)) {
-            return full;
-        }
+    return rewriteCompilerSignalMapReferences(source, ({ ts, signalIndex, valueRead }) => {
         const signal = signals[signalIndex];
         const stateIndex = signal?.state_index;
         const stateKey = Number.isInteger(stateIndex) ? stateBindings[stateIndex]?.key : null;
         if (typeof stateKey !== 'string' || stateKey.length === 0) {
-            return full;
+            return null;
+        }
+        if (valueRead) {
+            return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(stateKey), 'get'), undefined, []);
         }
-        return full.endsWith('.get()') ? `${stateKey}.get()` : stateKey;
+        return ts.factory.createIdentifier(stateKey);
     });
-    return normalizeTypeScriptExpression(resolved);
 }
 /**
+ * The only allowed downstream props rewrite boundary is compiler-owned exact lookup.
+ * If the compiler did not emit a mapping for the attr expression, CLI keeps the
+ * original expression text without attempting identifier reinterpretation.
+ *
  * @param {string} expr
  * @param {{
  *   expressionRewrite?: {
@@ -150,8 +41,7 @@ export function resolveCompiledPropsExpression(compiledExpr, expressionRewrite =
  *     ambiguous?: Set<string>,
  *     signals?: Array<{ state_index?: number }>,
  *     stateBindings?: Array<{ key?: string }>
- *   } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   } | null
  * } | null} rewriteContext
  * @returns {string}
  */
@@ -177,13 +67,18 @@ export function resolvePropsValueCode(expr, rewriteContext = null) {
             return normalizeTypeScriptExpression(exact);
         }
     }
-    return rewritePropsExpression(trimmed, rewriteContext);
+    return normalizeTypeScriptExpression(trimmed);
 }
 /**
  * @param {string} attrs
  * @param {{
- *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   expressionRewrite?: {
+ *     map?: Map<string, string>,
+ *     bindings?: Map<string, { compiled_expr?: string | null }>,
+ *     ambiguous?: Set<string>,
+ *     signals?: Array<{ state_index?: number }>,
+ *     stateBindings?: Array<{ key?: string }>
+ *   } | null
  * } | null} rewriteContext
  * @returns {string}
  */
@@ -225,8 +120,13 @@ export function renderPropsLiteralFromAttrs(attrs, rewriteContext = null) {
  * @param {string} source
  * @param {string} attrs
  * @param {{
- *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   expressionRewrite?: {
+ *     map?: Map<string, string>,
+ *     bindings?: Map<string, { compiled_expr?: string | null }>,
+ *     ambiguous?: Set<string>,
+ *     signals?: Array<{ state_index?: number }>,
+ *     stateBindings?: Array<{ key?: string }>
+ *   } | null
  * } | null} rewriteContext
  * @returns {string}
  */

package/dist/build/server-script.d.ts

@@ -2,7 +2,7 @@
  * @param {string} source
  * @param {string} sourceFile
  * @param {object} [compilerOpts]
- * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null }}
+ * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string } | null }}
  */
 export function extractServerScript(source: string, sourceFile: string, compilerOpts?: object): {
     source: string;
@@ -11,6 +11,7 @@ export function extractServerScript(source: string, sourceFile: string, compiler
         prerender: boolean;
         has_guard: boolean;
         has_load: boolean;
+        has_action: boolean;
         source_path: string;
     } | null;
 };

package/dist/build/server-script.js

@@ -4,12 +4,12 @@ import { findNextKnownComponentTag } from '../component-tag-parser.js';
  * @param {string} source
  * @param {string} sourceFile
  * @param {object} [compilerOpts]
- * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null }}
+ * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string } | null }}
  */
 export function extractServerScript(source, sourceFile, compilerOpts = {}) {
     const scriptRe = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
     const serverMatches = [];
-    const reservedServerExportRe = /\bexport\s+const\s+(?:data|prerender|guard|load|ssr_data|props|ssr)\b|\bexport\s+(?:async\s+)?function\s+(?:load|guard)\s*\(|\bexport\s+const\s+(?:load|guard)\s*=/;
+    const reservedServerExportRe = /\bexport\s+const\s+(?:data|prerender|guard|load|action|ssr_data|props|ssr)\b|\bexport\s+(?:async\s+)?function\s+(?:load|guard|action)\s*\(|\bexport\s+const\s+(?:load|guard|action)\s*=/;
     for (const match of source.matchAll(scriptRe)) {
         const attrs = String(match[1] || '');
         const body = String(match[2] || '');
@@ -17,7 +17,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
         if (!isServer && reservedServerExportRe.test(body)) {
             throw new Error(`Zenith server script contract violation:\n` +
                 `  File: ${sourceFile}\n` +
-                `  Reason: guard/load/data exports are only allowed in <script server lang="ts"> or adjacent .guard.ts / .load.ts files\n` +
+                `  Reason: guard/load/action/data exports are only allowed in <script server lang="ts"> or adjacent .guard.ts / .load.ts / .action.ts files\n` +
                 `  Example: move the export into <script server lang="ts">`);
         }
         if (isServer) {
@@ -81,6 +81,19 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
             `  Reason: multiple guard exports detected\n` +
             `  Example: keep exactly one export const guard = async (ctx) => ({ ... })`);
     }
+    const actionFnMatch = serverSource.match(/\bexport\s+(?:async\s+)?function\s+action\s*\(([^)]*)\)/);
+    const actionConstParenMatch = serverSource.match(/\bexport\s+const\s+action\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>/);
+    const actionConstSingleArgMatch = serverSource.match(/\bexport\s+const\s+action\s*=\s*(?:async\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
+    const hasAction = Boolean(actionFnMatch || actionConstParenMatch || actionConstSingleArgMatch);
+    const actionMatchCount = Number(Boolean(actionFnMatch)) +
+        Number(Boolean(actionConstParenMatch)) +
+        Number(Boolean(actionConstSingleArgMatch));
+    if (actionMatchCount > 1) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: multiple action exports detected\n` +
+            `  Example: keep exactly one export const action = async (ctx) => ({ ... })`);
+    }
     const hasData = /\bexport\s+const\s+data\b/.test(serverSource);
     const hasSsrData = /\bexport\s+const\s+ssr_data\b/.test(serverSource);
     const hasSsr = /\bexport\s+const\s+ssr\b/.test(serverSource);
@@ -119,6 +132,17 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
                 `  Example: export const guard = async (ctx) => ({ ... })`);
         }
     }
+    if (hasAction) {
+        const singleArg = String(actionConstSingleArgMatch?.[1] || '').trim();
+        const paramsText = String((actionFnMatch || actionConstParenMatch)?.[1] || '').trim();
+        const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
+        if (arity !== 1) {
+            throw new Error(`Zenith server script contract violation:\n` +
+                `  File: ${sourceFile}\n` +
+                `  Reason: action(ctx) must accept exactly one argument\n` +
+                `  Example: export const action = async (ctx) => ({ ... })`);
+        }
+    }
     const prerenderMatch = serverSource.match(/\bexport\s+const\s+prerender\s*=\s*([^\n;]+)/);
     let prerender = false;
     if (prerenderMatch) {
@@ -140,6 +164,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
                 prerender,
                 has_guard: hasGuard,
                 has_load: hasLoad,
+                has_action: hasAction,
                 source_path: sourceFile
             }
         };
@@ -153,6 +178,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
             prerender,
             has_guard: hasGuard,
             has_load: hasLoad,
+            has_action: hasAction,
             source_path: sourceFile
         }
     };

package/dist/build.js

@@ -11,14 +11,15 @@ import { buildPageEnvelopes } from './build/page-loop.js';
 import { deriveProjectRootFromPagesDir, ensureZenithTypeDeclarations } from './build/type-declarations.js';
 import { materializeImageMarkupInHtmlFiles } from './images/materialize.js';
 import { buildImageArtifacts } from './images/service.js';
+import { injectImageMaterializationIntoRouterManifest } from './images/router-manifest.js';
 import { createImageRuntimePayload, injectImageRuntimePayloadIntoHtmlFiles } from './images/payload.js';
+import { supportsTargetRouteCheck } from './route-check-support.js';
 import { createStartupProfiler } from './startup-profile.js';
 import { writeServerOutput } from './server-output.js';
 import { resolveBundlerBin } from './toolchain-paths.js';
 import { createBundlerToolchain, createCompilerToolchain, ensureToolchainCompatibility, getActiveToolchainCandidate } from './toolchain-runner.js';
 import { maybeWarnAboutZenithVersionMismatch } from './version-check.js';
 export { createCompilerWarningEmitter };
-const RUNTIME_MARKUP_BINDING = '__ZENITH_INTERNAL_ZENHTML';
 function createCompilerTotals() {
     return {
         pageMs: 0,
@@ -55,6 +56,7 @@ export async function build(options) {
     const compilerTotals = createCompilerTotals();
     const { target, adapter, mode } = resolveBuildAdapter(config);
     const basePath = normalizeBasePath(config.basePath || '/');
+    const routeCheckEnabled = supportsTargetRouteCheck(target);
     const routerEnabled = config.router === true;
     const compilerOpts = {
         typescriptDefault: config.typescriptDefault === true,
@@ -72,7 +74,6 @@ export async function build(options) {
         }));
     }
     const registry = startupProfile.measureSync('build_component_registry', () => buildComponentRegistry(srcDir));
-    void RUNTIME_MARKUP_BINDING;
     const manifest = await startupProfile.measureAsync('generate_manifest', () => generateManifest(pagesDir, '.zen', { compilerOpts }));
     if (mode !== 'legacy') {
         adapter.validateRoutes(manifest);
@@ -103,7 +104,8 @@ export async function build(options) {
         emitCompilerWarning
     });
     if (envelopes.length > 0) {
-        await startupProfile.measureAsync('run_bundler', () => runBundler(envelopes, staticOutputDir, projectRoot, logger, showBundlerInfo, bundlerBin, { basePath }), { envelopes: envelopes.length });
+        await startupProfile.measureAsync('run_bundler', () => runBundler(envelopes, staticOutputDir, projectRoot, logger, showBundlerInfo, bundlerBin, { basePath, routeCheck: routeCheckEnabled }), { envelopes: envelopes.length });
+        await startupProfile.measureAsync('inject_image_materialization_manifest', () => injectImageMaterializationIntoRouterManifest(staticOutputDir, envelopes), { envelopes: envelopes.length });
     }
     await startupProfile.measureAsync('rewrite_soft_navigation_base_path', () => rewriteSoftNavigationHrefBasePathInHtmlFiles(staticOutputDir, basePath));
     const { manifest: imageManifest } = await startupProfile.measureAsync('build_image_artifacts', () => buildImageArtifacts({