@zenithbuild/cli 0.7.3 → 0.7.5

package/dist/build/page-ir-normalization.js

@@ -1,4 +1,3 @@
-import { rewritePropsExpression } from './scoped-identifier-rewrite.js';
 import { resolveStateKeyFromBindings } from './expression-rewrites.js';
 import { expandScopedShorthandPropertiesInSource, normalizeTypeScriptExpression } from './typescript-expression-utils.js';
 /**
@@ -69,236 +68,6 @@ export function applyExpressionRewrites(pageIr, expressionMap, bindingMap, ambig
         }
     }
 }
-/**
- * @param {object} pageIr
- * @param {object} scopeRewrite
- * @param {Record<string, number> | null} [scopedMetrics]
- */
-export function applyScopedIdentifierRewrites(pageIr, scopeRewrite, scopedMetrics = null) {
-    if (!Array.isArray(pageIr?.expressions) || pageIr.expressions.length === 0) {
-        return;
-    }
-    const bindings = Array.isArray(pageIr.expression_bindings) ? pageIr.expression_bindings : [];
-    const scopeMap = scopeRewrite?.map instanceof Map ? scopeRewrite.map : null;
-    const scopeAmbiguous = scopeRewrite?.ambiguous instanceof Set ? scopeRewrite.ambiguous : null;
-    const scopeCandidates = scopeMap instanceof Map
-        ? new Set([...scopeMap.keys()].filter((identifier) => typeof identifier === 'string'
-            && identifier.length > 0
-            && !(scopeAmbiguous instanceof Set && scopeAmbiguous.has(identifier))))
-        : null;
-    const rewriteContext = { scopeRewrite };
-    const rewriteCache = new Map();
-    const shouldCheckIdentifierCandidate = (charCode, isStart) => {
-        if (charCode === 36 || charCode === 95)
-            return true;
-        if (charCode >= 65 && charCode <= 90)
-            return true;
-        if (charCode >= 97 && charCode <= 122)
-            return true;
-        if (!isStart && charCode >= 48 && charCode <= 57)
-            return true;
-        return false;
-    };
-    const canSkipScopedRewrite = (value) => {
-        if (!(scopeCandidates instanceof Set) || scopeCandidates.size === 0) {
-            return true;
-        }
-        let token = '';
-        for (let index = 0; index < value.length; index++) {
-            const charCode = value.charCodeAt(index);
-            if (shouldCheckIdentifierCandidate(charCode, token.length === 0)) {
-                token += value[index];
-                continue;
-            }
-            if (token.length > 0) {
-                if (scopeCandidates.has(token)) {
-                    return false;
-                }
-                token = '';
-            }
-        }
-        return token.length > 0 ? !scopeCandidates.has(token) : true;
-    };
-    const addScopedMetric = (key, value) => {
-        if (!scopedMetrics || typeof scopedMetrics !== 'object' || !Number.isFinite(value)) {
-            return;
-        }
-        scopedMetrics[key] = (scopedMetrics[key] || 0) + value;
-    };
-    const rewriteScoped = (value) => {
-        if (typeof value !== 'string') {
-            return value;
-        }
-        addScopedMetric('totalValues', 1);
-        const cached = rewriteCache.get(value);
-        if (typeof cached === 'string') {
-            addScopedMetric('cacheHitCount', 1);
-            return cached;
-        }
-        addScopedMetric('cacheMissCount', 1);
-        const missStartedAt = performance.now();
-        const identifierCheckStartedAt = performance.now();
-        const shouldSkip = canSkipScopedRewrite(value);
-        const identifierCheckMs = performance.now() - identifierCheckStartedAt;
-        addScopedMetric('identifierCheckMs', identifierCheckMs);
-        if (shouldSkip) {
-            addScopedMetric('fastSkipCount', 1);
-            addScopedMetric('fastSkipMs', identifierCheckMs);
-            rewriteCache.set(value, value);
-            addScopedMetric('unchangedMissCount', 1);
-            addScopedMetric('cacheMissMs', performance.now() - missStartedAt);
-            return value;
-        }
-        const rewriteCallStartedAt = performance.now();
-        const rewritten = rewritePropsExpression(value, rewriteContext);
-        addScopedMetric('rewriteCallMs', performance.now() - rewriteCallStartedAt);
-        addScopedMetric(rewritten === value ? 'unchangedMissCount' : 'changedMissCount', 1);
-        addScopedMetric('cacheMissMs', performance.now() - missStartedAt);
-        rewriteCache.set(value, rewritten);
-        return rewritten;
-    };
-    for (let index = 0; index < pageIr.expressions.length; index++) {
-        const current = pageIr.expressions[index];
-        if (typeof current === 'string') {
-            pageIr.expressions[index] = rewriteScoped(current);
-        }
-        if (!bindings[index] || typeof bindings[index] !== 'object') {
-            continue;
-        }
-        if (typeof bindings[index].literal === 'string') {
-            bindings[index].literal = rewriteScoped(bindings[index].literal);
-        }
-        if (typeof bindings[index].compiled_expr === 'string') {
-            bindings[index].compiled_expr = rewriteScoped(bindings[index].compiled_expr);
-        }
-    }
-}
-export function synthesizeSignalBackedCompiledExpressions(pageIr) {
-    if (!Array.isArray(pageIr?.expression_bindings) || pageIr.expression_bindings.length === 0) {
-        return;
-    }
-    const stateBindings = Array.isArray(pageIr?.hoisted?.state) ? pageIr.hoisted.state : [];
-    const signals = Array.isArray(pageIr?.signals) ? pageIr.signals : [];
-    if (stateBindings.length === 0 || signals.length === 0) {
-        return;
-    }
-    const signalBackedStateIndices = new Set(signals
-        .map((signal) => signal?.state_index)
-        .filter((value) => Number.isInteger(value)));
-    const signalIndexByStateKey = new Map();
-    for (let index = 0; index < signals.length; index++) {
-        const stateIndex = signals[index]?.state_index;
-        const stateKey = Number.isInteger(stateIndex) ? stateBindings[stateIndex]?.key : null;
-        if (typeof stateKey === 'string' && stateKey.length > 0) {
-            signalIndexByStateKey.set(stateKey, index);
-        }
-    }
-    if (signalIndexByStateKey.size === 0) {
-        return;
-    }
-    for (let index = 0; index < pageIr.expression_bindings.length; index++) {
-        const binding = pageIr.expression_bindings[index];
-        if (!binding || typeof binding !== 'object') {
-            continue;
-        }
-        if (typeof binding.compiled_expr === 'string' && binding.compiled_expr.includes('signalMap.get(')) {
-            continue;
-        }
-        const candidate = typeof binding.literal === 'string' && binding.literal.trim().length > 0
-            ? binding.literal
-            : typeof pageIr.expressions?.[index] === 'string'
-                ? pageIr.expressions[index]
-                : null;
-        if (typeof candidate !== 'string' || candidate.trim().length === 0) {
-            continue;
-        }
-        if (Number.isInteger(binding.state_index) &&
-            !signalBackedStateIndices.has(binding.state_index)) {
-            continue;
-        }
-        let rewritten = candidate;
-        const signalIndices = [];
-        for (const [stateKey, signalIndex] of signalIndexByStateKey.entries()) {
-            if (!rewritten.includes(stateKey)) {
-                continue;
-            }
-            const escaped = stateKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const pattern = new RegExp(`(?<!\\.)\\b${escaped}\\b`, 'g');
-            if (!pattern.test(rewritten)) {
-                continue;
-            }
-            rewritten = rewritten.replace(pattern, `signalMap.get(${signalIndex}).get()`);
-            signalIndices.push(signalIndex);
-        }
-        if (rewritten === candidate || signalIndices.length === 0) {
-            continue;
-        }
-        const uniqueSignalIndices = [...new Set(signalIndices)].sort((a, b) => a - b);
-        binding.compiled_expr = rewritten;
-        binding.signal_indices = uniqueSignalIndices;
-        if (uniqueSignalIndices.length === 1) {
-            binding.signal_index = uniqueSignalIndices[0];
-            const stateIndex = signals[uniqueSignalIndices[0]]?.state_index;
-            if (Number.isInteger(stateIndex)) {
-                binding.state_index = stateIndex;
-            }
-        }
-    }
-}
-export function normalizeExpressionBindingDependencies(pageIr) {
-    if (!Array.isArray(pageIr?.expression_bindings) || pageIr.expression_bindings.length === 0) {
-        return;
-    }
-    const signals = Array.isArray(pageIr.signals) ? pageIr.signals : [];
-    const dependencyRe = /signalMap\.get\((\d+)\)/g;
-    for (const binding of pageIr.expression_bindings) {
-        if (!binding || typeof binding !== 'object' || typeof binding.compiled_expr !== 'string') {
-            continue;
-        }
-        const indices = [];
-        dependencyRe.lastIndex = 0;
-        let match;
-        while ((match = dependencyRe.exec(binding.compiled_expr)) !== null) {
-            const index = Number.parseInt(match[1], 10);
-            if (Number.isInteger(index)) {
-                indices.push(index);
-            }
-        }
-        if (indices.length === 0) {
-            continue;
-        }
-        let signalIndices = [...new Set(indices)].sort((a, b) => a - b);
-        if (Number.isInteger(binding.state_index)) {
-            const owningSignalIndices = signals
-                .map((signal, index) => signal?.state_index === binding.state_index ? index : null)
-                .filter((value) => Number.isInteger(value));
-            const extractedMatchState = signalIndices.length > 0 &&
-                signalIndices.every((index) => signals[index]?.state_index === binding.state_index);
-            if (owningSignalIndices.length > 0 && !extractedMatchState) {
-                signalIndices = owningSignalIndices;
-            }
-        }
-        if (!Array.isArray(binding.signal_indices) ||
-            binding.signal_indices.length === 0 ||
-            binding.signal_indices.some((index) => signals[index]?.state_index !== binding.state_index)) {
-            binding.signal_indices = signalIndices;
-        }
-        if ((!Number.isInteger(binding.signal_index) ||
-            signals[binding.signal_index]?.state_index !== binding.state_index) &&
-            signalIndices.length === 1) {
-            binding.signal_index = signalIndices[0];
-        }
-        if (!Number.isInteger(binding.state_index) && Number.isInteger(binding.signal_index)) {
-            const stateIndex = signals[binding.signal_index]?.state_index;
-            if (Number.isInteger(stateIndex)) {
-                binding.state_index = stateIndex;
-            }
-        }
-        if (signalIndices.length === 1) {
-            binding.compiled_expr = binding.compiled_expr.replace(/signalMap\.get\(\d+\)/g, `signalMap.get(${signalIndices[0]})`);
-        }
-    }
-}
 export function normalizeExpressionPayload(pageIr) {
     if (!Array.isArray(pageIr?.expressions) || pageIr.expressions.length === 0) {
         return;
@@ -347,24 +116,34 @@ export function rewriteLegacyMarkupIdentifiers(pageIr) {
         return;
     }
     const bindings = Array.isArray(pageIr.expression_bindings) ? pageIr.expression_bindings : [];
+    function failLegacyMarkup(source) {
+        throw new Error(`[Zenith:Build] Legacy ${LEGACY_MARKUP_IDENT}\`...\` markup syntax is unsupported. ` +
+            'Use embedded markup expressions with embeddedMarkupExpressions: true, or unsafeHTML={value} for explicit raw HTML.');
+    }
     for (let i = 0; i < pageIr.expressions.length; i++) {
         if (typeof pageIr.expressions[i] === 'string' && pageIr.expressions[i].includes(LEGACY_MARKUP_IDENT)) {
             LEGACY_MARKUP_RE.lastIndex = 0;
-            pageIr.expressions[i] = pageIr.expressions[i].replace(LEGACY_MARKUP_RE, '__ZENITH_INTERNAL_ZENHTML');
+            if (LEGACY_MARKUP_RE.test(pageIr.expressions[i])) {
+                failLegacyMarkup(pageIr.expressions[i]);
+            }
         }
         if (bindings[i] &&
             typeof bindings[i] === 'object' &&
             typeof bindings[i].literal === 'string' &&
             bindings[i].literal.includes(LEGACY_MARKUP_IDENT)) {
             LEGACY_MARKUP_RE.lastIndex = 0;
-            bindings[i].literal = bindings[i].literal.replace(LEGACY_MARKUP_RE, '__ZENITH_INTERNAL_ZENHTML');
+            if (LEGACY_MARKUP_RE.test(bindings[i].literal)) {
+                failLegacyMarkup(bindings[i].literal);
+            }
         }
         if (bindings[i] &&
             typeof bindings[i] === 'object' &&
             typeof bindings[i].compiled_expr === 'string' &&
             bindings[i].compiled_expr.includes(LEGACY_MARKUP_IDENT)) {
             LEGACY_MARKUP_RE.lastIndex = 0;
-            bindings[i].compiled_expr = bindings[i].compiled_expr.replace(LEGACY_MARKUP_RE, '__ZENITH_INTERNAL_ZENHTML');
+            if (LEGACY_MARKUP_RE.test(bindings[i].compiled_expr)) {
+                failLegacyMarkup(bindings[i].compiled_expr);
+            }
         }
     }
 }

package/dist/build/page-loop-state.d.ts

@@ -1,9 +1,8 @@
 export function createPageLoopState(): {
     expressionRewriteMetrics: {
         calls: number;
-        cacheHits: number;
-        cacheMisses: number;
-        templateCompileMs: number;
+        compilerOwnedBindings: number;
+        ambiguousBindings: number;
     };
     pagePhaseTotals: {
         occurrenceCollectMs: number;
@@ -78,7 +77,6 @@ export function createPageLoopState(): {
     componentIrCache: Map<any, any>;
     componentDocumentModeCache: Map<any, any>;
     componentExpressionRewriteCache: Map<any, any>;
-    templateExpressionCache: Map<any, any>;
     hoistedCodeTransformCache: {
         transpileToJs: Map<any, any>;
         deferRuntime: Map<any, any>;
@@ -88,7 +86,6 @@ export function createPageLoopCaches(): {
     componentIrCache: Map<any, any>;
     componentDocumentModeCache: Map<any, any>;
     componentExpressionRewriteCache: Map<any, any>;
-    templateExpressionCache: Map<any, any>;
     hoistedCodeTransformCache: {
         transpileToJs: Map<any, any>;
         deferRuntime: Map<any, any>;
@@ -97,9 +94,8 @@ export function createPageLoopCaches(): {
 export function createPageLoopExecutionState(): {
     expressionRewriteMetrics: {
         calls: number;
-        cacheHits: number;
-        cacheMisses: number;
-        templateCompileMs: number;
+        compilerOwnedBindings: number;
+        ambiguousBindings: number;
     };
     pagePhaseTotals: {
         occurrenceCollectMs: number;
@@ -173,11 +169,12 @@ export function createPageLoopExecutionState(): {
     envelopes: never[];
 };
 export function preparePageIrForMerge(pageIr: any): void;
-export function applyServerEnvelopeToPageIr({ pageIr, composedServer, hasGuard, hasLoad, entry, srcDir, sourceFile }: {
+export function applyServerEnvelopeToPageIr({ pageIr, composedServer, hasGuard, hasLoad, hasAction, entry, srcDir, sourceFile }: {
     pageIr: any;
     composedServer: any;
     hasGuard: any;
     hasLoad: any;
+    hasAction: any;
     entry: any;
     srcDir: any;
     sourceFile: any;

package/dist/build/page-loop-state.js

@@ -11,7 +11,6 @@ export function createPageLoopCaches() {
         componentIrCache: new Map(),
         componentDocumentModeCache: new Map(),
         componentExpressionRewriteCache: new Map(),
-        templateExpressionCache: new Map(),
         hoistedCodeTransformCache: {
             transpileToJs: new Map(),
             deferRuntime: new Map()
@@ -22,9 +21,8 @@ export function createPageLoopExecutionState() {
     return {
         expressionRewriteMetrics: {
             calls: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            templateCompileMs: 0
+            compilerOwnedBindings: 0,
+            ambiguousBindings: 0
         },
         pagePhaseTotals: createPagePhaseTotals(),
         occurrenceApplyPhaseTotals: createOccurrenceApplyPhaseTotals(),
@@ -48,22 +46,25 @@ export function preparePageIrForMerge(pageIr) {
     pageIr.hoisted.state = pageIr.hoisted.state || [];
     pageIr.hoisted.code = pageIr.hoisted.code || [];
 }
-export function applyServerEnvelopeToPageIr({ pageIr, composedServer, hasGuard, hasLoad, entry, srcDir, sourceFile }) {
+export function applyServerEnvelopeToPageIr({ pageIr, composedServer, hasGuard, hasLoad, hasAction, entry, srcDir, sourceFile }) {
     if (composedServer.serverScript) {
-        pageIr.server_script = composedServer.serverScript;
+        const { has_action: _unusedHasAction, export_paths: _unusedExportPaths, ...serverScript } = composedServer.serverScript;
+        pageIr.server_script = serverScript;
         pageIr.prerender = composedServer.serverScript.prerender === true;
         if (pageIr.ssr_data === undefined) {
             pageIr.ssr_data = null;
         }
     }
-    if (pageIr.prerender === true && (hasGuard || hasLoad)) {
+    if (pageIr.prerender === true && (hasGuard || hasLoad || hasAction)) {
         throw new Error(`[zenith] Build failed for ${entry.file}: protected routes require SSR/runtime. ` +
-            'Cannot prerender a static route with a `guard` or `load` function.');
+            'Cannot prerender a static route with a `guard`, `load`, or `action` function.');
     }
     pageIr.has_guard = hasGuard;
     pageIr.has_load = hasLoad;
+    pageIr.has_action = hasAction;
     pageIr.guard_module_ref = composedServer.guardPath ? relative(srcDir, composedServer.guardPath).replaceAll('\\', '/') : null;
     pageIr.load_module_ref = composedServer.loadPath ? relative(srcDir, composedServer.loadPath).replaceAll('\\', '/') : null;
+    pageIr.action_module_ref = composedServer.actionPath ? relative(srcDir, composedServer.actionPath).replaceAll('\\', '/') : null;
     preparePageIrForMerge(pageIr);
 }
 export function buildOccurrenceCountByPath(componentOccurrences) {

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;