@zenithbuild/cli 0.7.3 → 0.7.4

package/README.md

@@ -2,26 +2,30 @@
 
 > **⚠️ Internal API:** This package is an internal implementation detail of the Zenith framework. It is not intended for public use and its API may break without warning. Please use `@zenithbuild/core` instead.
 
-
 The command-line interface for developing and building Zenith applications.
 
 ## Canonical Docs
 
-- CLI contract: `../zenith-docs/documentation/cli-contract.md`
-- Deployment targets guide: `/Users/judahsullivan/Personal/zenithbuild-monorepo/docs/documentation/guides/deployment-targets.md`
-- Script server/data contract: `../zenith-docs/documentation/contracts/server-data.md`
+- CLI contract: `../../docs/documentation/cli-contract.md`
+- Deployment targets guide: `../../docs/documentation/guides/deployment-targets.md`
+- Route protection: `../../docs/documentation/routing/route-protection.md`
 - Server output contract: `./SERVER_OUTPUT_CONTRACT.md`
 
 ## Overview
 
-`@zenithbuild/cli` provides the toolchain needed to manage Zenith projects. While `create-zenith` is for scaffolding, this CLI is for the daily development loop: serving apps, building for production, and managing plugins.
+`@zenithbuild/cli` is Zenith's deterministic project orchestrator. It owns the daily development loop:
+
+- `zenith dev`
+- `zenith build`
+- `zenith preview`
+
+It does not ship a public plugin-management surface.
 
 ## Features
 
 - **Dev Server**: Instant HMR (Hot Module Replacement) powered by Bun.
-- **Build System**: optimized production bundling.
-- **Plugin Management**: Easily add and remove Zenith plugins.
-- **Preview**: Test your production builds locally.
+- **Build System**: deterministic build output and adapter packaging.
+- **Preview**: target-aware verification of built output.
 
 ## Config Baseline
 
@@ -78,6 +82,8 @@ Current limitations:
 
 - There is no separate `assetPrefix` knob. Assets intentionally follow `basePath`.
 - `vercel` and `netlify` do not yet emit a deployed `/_zenith/image` endpoint. The `node` target does.
+- Image materialization is route-artifact-driven. Build, preview, and server render consume structured `image_materialization` metadata instead of executing page assets, and dynamic image props are currently unsupported until the compiler emits a dedicated image-props artifact.
+- There is no shipped plugin install/remove command surface in this CLI.
 
 ## Commands
 
@@ -90,9 +96,6 @@ Compiles and bundles your application for production.
 ### `zenith preview`
 Previews the locally built target contract for verification. Static targets serve built files; `target: 'node'` boots the built Node artifact.
 
-### `zenith add <plugin>`
-Installs and configures a Zenith plugin.
-
 ## Installation
 
 Typically installed as a dev dependency in your Zenith project:

package/dist/adapters/adapter-netlify.js

@@ -110,6 +110,7 @@ export const netlifyAdapter = {
             await cp(join(options.coreOutput, 'server', 'images'), join(functionsDir, '_zenith', 'images'), { recursive: true, force: true });
             await cp(join(options.coreOutput, 'server', 'base-path.js'), join(functionsDir, '_zenith', 'base-path.js'), { force: true });
             await cp(join(options.coreOutput, 'server', 'server-contract.js'), join(functionsDir, '_zenith', 'server-contract.js'), { force: true });
+            await cp(join(options.coreOutput, 'server', 'server-error.js'), join(functionsDir, '_zenith', 'server-error.js'), { force: true });
             for (const route of serverRoutes) {
                 await cp(join(options.coreOutput, 'server', 'routes', route.name), join(functionsDir, '_zenith', 'routes', route.name), { recursive: true, force: true });
                 await writeFile(join(functionsDir, `__zenith_${route.name}.mjs`), createFunctionSource(route), 'utf8');

package/dist/adapters/adapter-node.js

@@ -12,6 +12,14 @@ const NODE_RUNTIME_FILES = [
         from: new URL('../server/resolve-request-route.js', import.meta.url),
         to: 'runtime/resolve-request-route.js'
     },
+    {
+        from: new URL('../request-origin.js', import.meta.url),
+        to: 'request-origin.js'
+    },
+    {
+        from: new URL('../server-error.js', import.meta.url),
+        to: 'server-error.js'
+    },
     {
         from: new URL('../images/service.js', import.meta.url),
         to: 'images/service.js'

package/dist/adapters/adapter-vercel.js

@@ -84,6 +84,7 @@ export const vercelAdapter = {
             await cp(join(options.coreOutput, 'server', 'images'), join(functionDir, 'images'), { recursive: true, force: true });
             await cp(join(options.coreOutput, 'server', 'base-path.js'), join(functionDir, 'base-path.js'), { force: true });
             await cp(join(options.coreOutput, 'server', 'server-contract.js'), join(functionDir, 'server-contract.js'), { force: true });
+            await cp(join(options.coreOutput, 'server', 'server-error.js'), join(functionDir, 'server-error.js'), { force: true });
             await cp(join(options.coreOutput, 'server', 'routes', route.name), functionDir, { recursive: true, force: true });
             await writeFile(join(functionDir, 'package.json'), '{\n  "type": "module"\n}\n', 'utf8');
             await writeFile(join(functionDir, 'index.js'), createFunctionSource(route), 'utf8');

package/dist/build/compiler-runtime.d.ts

@@ -42,17 +42,18 @@ export function createTimedCompilerRunner(startupProfile: ReturnType<typeof impo
  * @param {object | null} [logger]
  * @param {boolean} [showInfo]
  * @param {string|object} [bundlerBin]
- * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string, basePath?: string }} [bundlerOptions]
+ * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string, basePath?: string, routeCheck?: boolean }} [bundlerOptions]
  * @returns {Promise<void>}
  */
-export function runBundler(envelope: object | object[], outDir: string, projectRoot: string, logger?: object | null, showInfo?: boolean, bundlerBin?: string | object, bundlerOptions?: {
-    devStableAssets?: boolean;
-    rebuildStrategy?: "full" | "bundle-only" | "page-only";
-    changedRoutes?: string[];
-    fastPath?: boolean;
-    globalGraphHash?: string;
-    basePath?: string;
-}): Promise<void>;
+/**
+ * Merge compiler-owned static image materialization rows from marker bindings + rewritten props literals.
+ * @param {object} pageIr
+ * @param {string[]} literals
+ * @param {object} [compilerRunOptions]
+ * @returns {object}
+ */
+export function mergePageImageMaterialization(pageIr: object, literals: string[], compilerRunOptions?: object): object;
+export function runBundler(envelope: any, outDir: any, projectRoot: any, logger?: null, showInfo?: boolean, bundlerBin?: string, bundlerOptions?: {}): Promise<any>;
 /**
  * @param {string} rootDir
  * @returns {Promise<string[]>}

package/dist/build/compiler-runtime.js

@@ -171,9 +171,56 @@ export function createTimedCompilerRunner(startupProfile, compilerTotals) {
  * @param {object | null} [logger]
  * @param {boolean} [showInfo]
  * @param {string|object} [bundlerBin]
- * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string, basePath?: string }} [bundlerOptions]
+ * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string, basePath?: string, routeCheck?: boolean }} [bundlerOptions]
  * @returns {Promise<void>}
  */
+/**
+ * Merge compiler-owned static image materialization rows from marker bindings + rewritten props literals.
+ * @param {object} pageIr
+ * @param {string[]} literals
+ * @param {object} [compilerRunOptions]
+ * @returns {object}
+ */
+export function mergePageImageMaterialization(pageIr, literals, compilerRunOptions = {}) {
+    if (!Array.isArray(literals) || literals.length === 0) {
+        return pageIr;
+    }
+    const compilerToolchain = compilerRunOptions.compilerToolchain
+        || (compilerRunOptions.compilerBin && typeof compilerRunOptions.compilerBin === 'object'
+            ? compilerRunOptions.compilerBin
+            : null);
+    const compilerBin = !compilerToolchain && typeof compilerRunOptions.compilerBin === 'string'
+        ? compilerRunOptions.compilerBin
+        : null;
+    const payload = JSON.stringify({
+        marker_bindings: pageIr.marker_bindings,
+        literals
+    });
+    const args = ['--merge-image-materialization'];
+    const opts = {
+        encoding: 'utf8',
+        maxBuffer: COMPILER_SPAWN_MAX_BUFFER,
+        input: payload
+    };
+    const result = compilerToolchain
+        ? runToolchainSync(compilerToolchain, args, opts).result
+        : (compilerBin
+            ? spawnSync(compilerBin, args, opts)
+            : runToolchainSync(createCompilerToolchain({
+                logger: compilerRunOptions.logger || null
+            }), args, opts).result);
+    if (result.error) {
+        throw new Error(`merge image materialization spawn failed: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`merge image materialization failed with exit code ${result.status}\n${result.stderr || ''}`);
+    }
+    const parsed = JSON.parse(result.stdout);
+    return {
+        ...pageIr,
+        image_materialization: parsed.image_materialization
+    };
+}
 export function runBundler(envelope, outDir, projectRoot, logger = null, showInfo = true, bundlerBin = resolveBundlerBin(projectRoot), bundlerOptions = {}) {
     return new Promise((resolvePromise, rejectPromise) => {
         const useStructuredLogger = Boolean(logger && typeof logger.childLine === 'function');
@@ -192,6 +239,9 @@ export function runBundler(envelope, outDir, projectRoot, logger = null, showInf
         if (typeof bundlerOptions.basePath === 'string' && bundlerOptions.basePath.length > 0) {
             bundlerArgs.push('--base-path', bundlerOptions.basePath);
         }
+        if (bundlerOptions.routeCheck === true) {
+            bundlerArgs.push('--route-check');
+        }
         if (bundlerOptions.devStableAssets === true) {
             bundlerArgs.push('--dev-stable-assets');
         }

package/dist/build/compiler-signal-expression.d.ts

@@ -0,0 +1 @@
+export function rewriteCompilerSignalMapReferences(compiledExpr: any, buildReplacement: any): string | null;

package/dist/build/compiler-signal-expression.js

@@ -0,0 +1,155 @@
+import { loadTypeScriptApi } from './compiler-runtime.js';
+import { normalizeTypeScriptExpression } from './typescript-expression-utils.js';
+function collectBindingNames(ts, name, target) {
+    if (ts.isIdentifier(name)) {
+        target.add(name.text);
+        return;
+    }
+    if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+        for (const element of name.elements) {
+            if (ts.isBindingElement(element)) {
+                collectBindingNames(ts, element.name, target);
+            }
+        }
+    }
+}
+function collectDirectBlockBindings(ts, block, target) {
+    const statements = Array.isArray(block?.statements) ? block.statements : [];
+    for (const statement of statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                collectBindingNames(ts, declaration.name, target);
+            }
+            continue;
+        }
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+            target.add(statement.name.text);
+        }
+    }
+}
+function isNestedBlockScope(ts, node) {
+    return (ts.isBlock(node) || ts.isModuleBlock(node)) && !ts.isSourceFile(node.parent);
+}
+function resolveCompilerSignalIndex(ts, node, localBindings) {
+    if (!ts.isCallExpression(node)) {
+        return null;
+    }
+    if (node.arguments.length !== 1) {
+        return null;
+    }
+    const expression = node.expression;
+    if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== 'get') {
+        return null;
+    }
+    if (!ts.isIdentifier(expression.expression) || expression.expression.text !== 'signalMap') {
+        return null;
+    }
+    if (localBindings.has('signalMap')) {
+        return null;
+    }
+    const [indexArg] = node.arguments;
+    if (!ts.isNumericLiteral(indexArg)) {
+        return null;
+    }
+    const signalIndex = Number.parseInt(indexArg.text, 10);
+    return Number.isInteger(signalIndex) ? signalIndex : null;
+}
+export function rewriteCompilerSignalMapReferences(compiledExpr, buildReplacement) {
+    const source = typeof compiledExpr === 'string' ? compiledExpr.trim() : '';
+    if (!source) {
+        return null;
+    }
+    if (!source.includes('signalMap.get(') || typeof buildReplacement !== 'function') {
+        return normalizeTypeScriptExpression(source);
+    }
+    const ts = loadTypeScriptApi();
+    if (!ts) {
+        return normalizeTypeScriptExpression(source);
+    }
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-compiled-expression.ts', `const __zenith_expr__ = (${source});`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        return normalizeTypeScriptExpression(source);
+    }
+    const nextScopeBindings = (node, localBindings) => {
+        if (ts.isSourceFile(node)) {
+            return localBindings;
+        }
+        if (ts.isFunctionLike(node)) {
+            const next = new Set(localBindings);
+            if (node.name && ts.isIdentifier(node.name) && !ts.isSourceFile(node.parent)) {
+                next.add(node.name.text);
+            }
+            for (const param of node.parameters) {
+                collectBindingNames(ts, param.name, next);
+            }
+            return next;
+        }
+        if (isNestedBlockScope(ts, node)) {
+            const next = new Set(localBindings);
+            collectDirectBlockBindings(ts, node, next);
+            return next;
+        }
+        if (ts.isCatchClause(node) && node.variableDeclaration) {
+            const next = new Set(localBindings);
+            collectBindingNames(ts, node.variableDeclaration.name, next);
+            return next;
+        }
+        if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node))
+            && node.initializer
+            && ts.isVariableDeclarationList(node.initializer)) {
+            const next = new Set(localBindings);
+            for (const declaration of node.initializer.declarations) {
+                collectBindingNames(ts, declaration.name, next);
+            }
+            return next;
+        }
+        return localBindings;
+    };
+    const transformer = (context) => {
+        const visit = (node, localBindings) => {
+            const scopeBindings = nextScopeBindings(node, localBindings);
+            if (ts.isCallExpression(node) && node.arguments.length === 0) {
+                const expression = node.expression;
+                if (ts.isPropertyAccessExpression(expression) && expression.name.text === 'get') {
+                    const signalIndex = resolveCompilerSignalIndex(ts, expression.expression, scopeBindings);
+                    if (Number.isInteger(signalIndex)) {
+                        const replacement = buildReplacement({ ts, signalIndex, valueRead: true });
+                        if (replacement) {
+                            return replacement;
+                        }
+                    }
+                }
+            }
+            const signalIndex = resolveCompilerSignalIndex(ts, node, scopeBindings);
+            if (Number.isInteger(signalIndex)) {
+                const replacement = buildReplacement({ ts, signalIndex, valueRead: false });
+                if (replacement) {
+                    return replacement;
+                }
+            }
+            return ts.visitEachChild(node, (child) => visit(child, scopeBindings), context);
+        };
+        return (node) => ts.visitNode(node, (child) => visit(child, new Set()));
+    };
+    const result = ts.transform(sourceFile, [transformer]);
+    try {
+        const printed = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+            .printFile(result.transformed[0])
+            .trimEnd();
+        const prefix = 'const __zenith_expr__ = (';
+        const suffix = ');';
+        if (!printed.startsWith(prefix) || !printed.endsWith(suffix)) {
+            return normalizeTypeScriptExpression(source);
+        }
+        return normalizeTypeScriptExpression(printed.slice(prefix.length, printed.length - suffix.length));
+    }
+    catch {
+        return normalizeTypeScriptExpression(source);
+    }
+    finally {
+        result.dispose();
+    }
+}

package/dist/build/expression-rewrites.d.ts

@@ -1,10 +1,5 @@
 /**
- * @param {string} compPath
- * @param {string} componentSource
  * @param {object} compIr
- * @param {object} compilerOpts
- * @param {string|object} compilerBin
- * @param {Map<string, string[]> | null} [templateExpressionCache]
  * @param {Record<string, number> | null} [rewriteMetrics]
  * @returns {{
  *   map: Map<string, string>,
@@ -22,7 +17,7 @@
  *   sequence: Array<{ raw: string, rewritten: string, binding: object | null }>
  * }}
  */
-export function buildComponentExpressionRewrite(compPath: string, componentSource: string, compIr: object, compilerOpts: object, compilerBin: string | object, templateExpressionCache?: Map<string, string[]> | null, rewriteMetrics?: Record<string, number> | null): {
+export function buildComponentExpressionRewrite(compIr: object, rewriteMetrics?: Record<string, number> | null): {
     map: Map<string, string>;
     bindings: Map<string, {
         compiled_expr: string | null;

package/dist/build/expression-rewrites.js

@@ -1,13 +1,7 @@
 import { performance } from 'node:perf_hooks';
-import { extractTemplate } from '../resolve-components.js';
-import { runCompiler } from './compiler-runtime.js';
+import { rewriteCompilerSignalMapReferences } from './compiler-signal-expression.js';
 /**
- * @param {string} compPath
- * @param {string} componentSource
  * @param {object} compIr
- * @param {object} compilerOpts
- * @param {string|object} compilerBin
- * @param {Map<string, string[]> | null} [templateExpressionCache]
  * @param {Record<string, number> | null} [rewriteMetrics]
  * @returns {{
  *   map: Map<string, string>,
@@ -25,7 +19,9 @@ import { runCompiler } from './compiler-runtime.js';
  *   sequence: Array<{ raw: string, rewritten: string, binding: object | null }>
  * }}
  */
-export function buildComponentExpressionRewrite(compPath, componentSource, compIr, compilerOpts, compilerBin, templateExpressionCache = null, rewriteMetrics = null) {
+export function buildComponentExpressionRewrite(compIr, rewriteMetrics = null) {
+    // Downstream is only allowed to read compiler-owned raw->rewritten pairs here.
+    // It must not synthesize new identifier meaning beyond this mapping.
     const out = {
         map: new Map(),
         bindings: new Map(),
@@ -39,60 +35,19 @@ export function buildComponentExpressionRewrite(compPath, componentSource, compI
     if (rewrittenExpressions.length === 0) {
         return out;
     }
-    const hoistedState = Array.isArray(compIr?.hoisted?.state) ? compIr.hoisted.state : [];
-    const hoistedFunctions = Array.isArray(compIr?.hoisted?.functions) ? compIr.hoisted.functions : [];
-    const hoistedDeclarations = Array.isArray(compIr?.hoisted?.declarations) ? compIr.hoisted.declarations : [];
-    const signals = Array.isArray(compIr?.signals) ? compIr.signals : [];
-    if (hoistedState.length === 0 &&
-        hoistedFunctions.length === 0 &&
-        hoistedDeclarations.length === 0 &&
-        signals.length === 0) {
-        return out;
-    }
     if (rewriteMetrics && typeof rewriteMetrics === 'object') {
         rewriteMetrics.calls += 1;
     }
-    const templateOnly = extractTemplate(componentSource);
-    if (!templateOnly.trim()) {
-        return out;
-    }
-    const cacheKey = `${compPath}\u0000${templateOnly}`;
-    let rawExpressions = null;
-    if (templateExpressionCache instanceof Map && templateExpressionCache.has(cacheKey)) {
-        rawExpressions = templateExpressionCache.get(cacheKey);
-        if (rewriteMetrics && typeof rewriteMetrics === 'object') {
-            rewriteMetrics.cacheHits += 1;
-        }
-    }
-    else {
-        let templateIr;
-        const templateCompileStartedAt = performance.now();
-        try {
-            templateIr = runCompiler(compPath, templateOnly, compilerOpts, {
-                suppressWarnings: true,
-                compilerToolchain: compilerBin
-            });
-        }
-        catch {
-            return out;
-        }
-        rawExpressions = Array.isArray(templateIr?.expressions) ? templateIr.expressions : [];
-        if (templateExpressionCache instanceof Map) {
-            templateExpressionCache.set(cacheKey, rawExpressions);
-        }
-        if (rewriteMetrics && typeof rewriteMetrics === 'object') {
-            rewriteMetrics.cacheMisses += 1;
-            rewriteMetrics.templateCompileMs += Math.round((performance.now() - templateCompileStartedAt) * 100) / 100;
-        }
-    }
-    const count = Math.min(rawExpressions.length, rewrittenExpressions.length);
-    for (let i = 0; i < count; i++) {
-        const raw = rawExpressions[i];
+    for (let i = 0; i < rewrittenExpressions.length; i++) {
         const rewritten = rewrittenExpressions[i];
-        if (typeof raw !== 'string' || typeof rewritten !== 'string') {
+        if (typeof rewritten !== 'string') {
             continue;
         }
         const binding = rewrittenBindings[i];
+        // Compiler emits the raw source literal for exact lookup; CLI only transports it.
+        const raw = typeof binding?.literal === 'string' && binding.literal.length > 0
+            ? binding.literal
+            : rewritten;
         const normalizedBinding = binding && typeof binding === 'object'
             ? {
                 compiled_expr: typeof binding.compiled_expr === 'string' ? binding.compiled_expr : null,
@@ -133,6 +88,10 @@ export function buildComponentExpressionRewrite(compPath, componentSource, compI
             }
         }
     }
+    if (rewriteMetrics && typeof rewriteMetrics === 'object') {
+        rewriteMetrics.compilerOwnedBindings += out.sequence.length;
+        rewriteMetrics.ambiguousBindings += out.ambiguous.size;
+    }
     return out;
 }
 /**
@@ -143,27 +102,28 @@ export function buildComponentExpressionRewrite(compPath, componentSource, compI
  * @returns {string | null}
  */
 export function remapCompiledExpressionSignals(compiledExpr, componentSignals, componentStateBindings, pageSignalIndexByStateKey) {
+    // This is a mechanical index remap across page merge boundaries, not a second compiler pass.
     if (typeof compiledExpr !== 'string' || compiledExpr.length === 0) {
         return null;
     }
-    return compiledExpr.replace(/signalMap\.get\((\d+)\)/g, (full, rawIndex) => {
-        const localIndex = Number.parseInt(rawIndex, 10);
-        if (!Number.isInteger(localIndex)) {
-            return full;
-        }
-        const signal = componentSignals[localIndex];
+    return rewriteCompilerSignalMapReferences(compiledExpr, ({ ts, signalIndex, valueRead }) => {
+        const signal = componentSignals[signalIndex];
         if (!signal || !Number.isInteger(signal.state_index)) {
-            return full;
+            return null;
         }
         const stateKey = componentStateBindings[signal.state_index]?.key;
         if (typeof stateKey !== 'string' || stateKey.length === 0) {
-            return full;
+            return null;
         }
         const pageIndex = pageSignalIndexByStateKey.get(stateKey);
         if (!Number.isInteger(pageIndex)) {
-            return full;
+            return null;
         }
-        return `signalMap.get(${pageIndex})`;
+        const signalMapRead = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('signalMap'), 'get'), undefined, [ts.factory.createNumericLiteral(String(pageIndex))]);
+        if (valueRead) {
+            return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(signalMapRead, 'get'), undefined, []);
+        }
+        return signalMapRead;
     });
 }
 /**
@@ -319,6 +279,15 @@ export function mergeExpressionRewriteMaps(pageMap, pageBindingMap, pageAmbiguou
         const resolved = resolveRewrittenBindingMetadata(pageBindingContext, componentRewrite, binding, bindingResolutionMetrics);
         const existing = pageBindingMap.get(raw);
         if (existing && JSON.stringify(existing) !== JSON.stringify(resolved)) {
+            const existingWeight = measureBindingSpecificity(existing, raw);
+            const resolvedWeight = measureBindingSpecificity(resolved, raw);
+            if (resolvedWeight > existingWeight && existingWeight === 0) {
+                pageBindingMap.set(raw, resolved);
+                continue;
+            }
+            if (existingWeight > resolvedWeight && resolvedWeight === 0) {
+                continue;
+            }
             pageAmbiguous.add(raw);
             pageMap.delete(raw);
             pageBindingMap.delete(raw);
@@ -340,6 +309,33 @@ export function mergeExpressionRewriteMaps(pageMap, pageBindingMap, pageAmbiguou
         pageMap.set(raw, rewritten);
     }
 }
+function measureBindingSpecificity(binding, raw) {
+    if (!binding || typeof binding !== 'object') {
+        return 0;
+    }
+    let score = 0;
+    if (typeof binding.compiled_expr === 'string' &&
+        binding.compiled_expr.length > 0 &&
+        binding.compiled_expr !== raw) {
+        score += 4;
+    }
+    if (Number.isInteger(binding.signal_index)) {
+        score += 2;
+    }
+    if (Array.isArray(binding.signal_indices) && binding.signal_indices.length > 0) {
+        score += 2;
+    }
+    if (Number.isInteger(binding.state_index)) {
+        score += 1;
+    }
+    if (typeof binding.component_instance === 'string' && binding.component_instance.length > 0) {
+        score += 1;
+    }
+    if (typeof binding.component_binding === 'string' && binding.component_binding.length > 0) {
+        score += 1;
+    }
+    return score;
+}
 /**
  * @param {string} identifier
  * @param {Array<{ key?: string }>} stateBindings

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

@@ -1,4 +1,4 @@
-export function buildPageOwnerContext({ componentOccurrences, sourceFile, pageOwnerSource, compilerOpts, compilerBin, timedRunCompiler, cooperativeYield, templateExpressionCache, expressionRewriteMetrics, startupProfile }: {
+export function buildPageOwnerContext({ componentOccurrences, sourceFile, pageOwnerSource, compilerOpts, compilerBin, timedRunCompiler, cooperativeYield, expressionRewriteMetrics, startupProfile }: {
     componentOccurrences: any;
     sourceFile: any;
     pageOwnerSource: any;
@@ -6,7 +6,6 @@ export function buildPageOwnerContext({ componentOccurrences, sourceFile, pageOw
     compilerBin: any;
     timedRunCompiler: any;
     cooperativeYield: any;
-    templateExpressionCache: any;
     expressionRewriteMetrics: any;
     startupProfile: any;
 }): Promise<{
@@ -19,10 +18,6 @@ export function buildPageOwnerContext({ componentOccurrences, sourceFile, pageOw
         ambiguous: Set<any>;
         sequence: never[];
     };
-    pageOwnerScopeRewrite: {
-        map: Map<any, any>;
-        ambiguous: Set<any>;
-    };
 } | {
     pageOwnerCompileMs: any;
     pageOwnerExpressionRewrite: {
@@ -51,12 +46,8 @@ export function buildPageOwnerContext({ componentOccurrences, sourceFile, pageOw
             binding: object | null;
         }>;
     };
-    pageOwnerScopeRewrite: {
-        map: Map<string, string>;
-        ambiguous: Set<string>;
-    };
 }>;
-export function runPageComponentLoop({ componentOccurrences, occurrenceCountByPath, sourceFile, registry, compilerOpts, compilerBin, timedRunCompiler, cooperativeYield, startupProfile, compilerTotals, emitCompilerWarning, componentIrCache, componentDocumentModeCache, componentExpressionRewriteCache, templateExpressionCache, expressionRewriteMetrics, pageOwnerExpressionRewrite, pageOwnerScopeRewrite, pageIr, pageIrMergeCache, seenStaticImports, pageExpressionRewriteMap, pageExpressionBindingMap, pageAmbiguousExpressionMap, knownRefKeys, componentOccurrencePlans, pagePhase, pageBindingResolutionBreakdown, pageMergeBreakdown, pageComponentLoopBreakdown, hoistedCodeTransformCache, pageStats }: {
+export function runPageComponentLoop({ componentOccurrences, occurrenceCountByPath, sourceFile, registry, compilerOpts, compilerBin, timedRunCompiler, cooperativeYield, startupProfile, compilerTotals, emitCompilerWarning, componentIrCache, componentDocumentModeCache, componentExpressionRewriteCache, expressionRewriteMetrics, pageOwnerExpressionRewrite, pageIr, pageIrMergeCache, seenStaticImports, pageExpressionRewriteMap, pageExpressionBindingMap, pageAmbiguousExpressionMap, knownRefKeys, componentOccurrencePlans, imagePropsLiterals, pagePhase, pageBindingResolutionBreakdown, pageMergeBreakdown, pageComponentLoopBreakdown, hoistedCodeTransformCache, pageStats }: {
     componentOccurrences: any;
     occurrenceCountByPath: any;
     sourceFile: any;
@@ -71,10 +62,8 @@ export function runPageComponentLoop({ componentOccurrences, occurrenceCountByPa
     componentIrCache: any;
     componentDocumentModeCache: any;
     componentExpressionRewriteCache: any;
-    templateExpressionCache: any;
     expressionRewriteMetrics: any;
     pageOwnerExpressionRewrite: any;
-    pageOwnerScopeRewrite: any;
     pageIr: any;
     pageIrMergeCache: any;
     seenStaticImports: any;
@@ -83,6 +72,7 @@ export function runPageComponentLoop({ componentOccurrences, occurrenceCountByPa
     pageAmbiguousExpressionMap: any;
     knownRefKeys: any;
     componentOccurrencePlans: any;
+    imagePropsLiterals: any;
     pagePhase: any;
     pageBindingResolutionBreakdown: any;
     pageMergeBreakdown: any;