@zenithbuild/cli 0.7.2 → 0.7.4

package/dist/component-instance-ir.js

@@ -3,83 +3,189 @@ function deepClone(value) {
     return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 const cloneMetadataCache = new WeakMap();
-function escapeIdentifier(identifier) {
-    return identifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function replaceIdentifierRefs(input, renamePlan) {
-    let output = String(input || '');
-    for (const entry of renamePlan) {
-        output = output.replace(entry.pattern, entry.to);
-    }
-    return output;
-}
-function replaceIdentifierRefsInStatementSource(input, renameEntries, renamePlan) {
-    const source = String(input || '');
-    if (!source.trim()) {
-        return source;
-    }
+function loadCloneTypeScriptApi() {
     const ts = loadTypeScriptApi();
     if (!ts) {
-        return replaceIdentifierRefs(source, renamePlan);
+        throw new Error('[Zenith:Build] Deterministic component instance cloning requires the TypeScript parser.');
     }
-    let sourceFile;
-    try {
-        sourceFile = ts.createSourceFile('zenith-instance-clone.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    return ts;
+}
+function collectBindingNames(ts, name, target) {
+    if (ts.isIdentifier(name)) {
+        target.add(name.text);
+        return;
     }
-    catch {
-        return replaceIdentifierRefs(source, renamePlan);
+    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 buildScopedIdentifierTransformer(ts, renameEntries, sourceLabel) {
     const renameMap = new Map(renameEntries);
-    const shouldRenameIdentifier = (node) => {
+    const shouldSkipIdentifier = (node, localBindings) => {
+        if (localBindings.has(node.text)) {
+            return true;
+        }
         const parent = node.parent;
         if (!parent) {
-            return true;
+            return false;
         }
         if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
-            return false;
+            return true;
         }
         if (ts.isPropertyAssignment(parent) && parent.name === node) {
-            return false;
+            return true;
         }
         if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
-            return false;
+            return true;
         }
         if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent)) {
-            return false;
+            return true;
+        }
+        if (ts.isBindingElement(parent) && parent.propertyName === node) {
+            return true;
         }
-        return true;
+        if (ts.isLabeledStatement(parent) && parent.label === node) {
+            return true;
+        }
+        if ((ts.isBreakStatement(parent) || ts.isContinueStatement(parent)) && parent.label === node) {
+            return true;
+        }
+        return false;
     };
-    const transformer = (context) => {
-        const visit = (node) => {
+    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;
+    };
+    return (context) => {
+        const visit = (node, localBindings) => {
+            const scopeBindings = nextScopeBindings(node, localBindings);
             if (ts.isShorthandPropertyAssignment(node)) {
                 const rewritten = renameMap.get(node.name.text);
-                if (typeof rewritten === 'string' && rewritten.length > 0) {
+                if (typeof rewritten === 'string' &&
+                    rewritten.length > 0 &&
+                    rewritten !== node.name.text &&
+                    !scopeBindings.has(node.name.text)) {
                     return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(node.name.text), ts.factory.createIdentifier(rewritten));
                 }
             }
-            if (ts.isIdentifier(node) && shouldRenameIdentifier(node)) {
+            if (ts.isIdentifier(node) && !shouldSkipIdentifier(node, scopeBindings)) {
                 const rewritten = renameMap.get(node.text);
                 if (typeof rewritten === 'string' && rewritten.length > 0 && rewritten !== node.text) {
                     return ts.factory.createIdentifier(rewritten);
                 }
             }
-            return ts.visitEachChild(node, visit, context);
+            return ts.visitEachChild(node, (child) => visit(child, scopeBindings), context);
         };
-        return (node) => ts.visitNode(node, visit);
+        return (node) => ts.visitNode(node, (child) => visit(child, new Set()));
     };
+}
+function rewriteSourceFileWithIdentifiers(sourceFile, renameEntries, sourceLabel) {
+    const ts = loadCloneTypeScriptApi();
+    const transformer = buildScopedIdentifierTransformer(ts, renameEntries, sourceLabel);
     const result = ts.transform(sourceFile, [transformer]);
     try {
         return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
             .printFile(result.transformed[0])
             .trimEnd();
     }
-    catch {
-        return replaceIdentifierRefs(source, renamePlan);
-    }
     finally {
         result.dispose();
     }
 }
+function rewriteIdentifierRefsInExpressionSource(input, renameEntries, sourceLabel) {
+    const source = String(input || '');
+    if (!source.trim()) {
+        return source;
+    }
+    const ts = loadCloneTypeScriptApi();
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-instance-clone-expression.ts', `const __zenith_expr__ = (${source});`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        throw new Error(`[Zenith:Build] Failed to parse component instance expression for deterministic rewriting in ${sourceLabel}.`);
+    }
+    const rewritten = rewriteSourceFileWithIdentifiers(sourceFile, renameEntries, sourceLabel);
+    const parsed = ts.createSourceFile('zenith-instance-clone-expression.js', rewritten, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const statement = parsed.statements.find(ts.isVariableStatement);
+    const declaration = statement?.declarationList?.declarations?.[0];
+    const initializer = declaration?.initializer;
+    if (!initializer) {
+        throw new Error(`[Zenith:Build] Failed to extract rewritten component instance expression in ${sourceLabel}.`);
+    }
+    const root = ts.isParenthesizedExpression(initializer) ? initializer.expression : initializer;
+    return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+        .printNode(ts.EmitHint.Unspecified, root, parsed)
+        .trim();
+}
+function rewriteIdentifierRefsInStatementSource(input, renameEntries, sourceLabel) {
+    const source = String(input || '');
+    if (!source.trim()) {
+        return source;
+    }
+    const ts = loadCloneTypeScriptApi();
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-instance-clone.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        throw new Error(`[Zenith:Build] Failed to parse component instance statement source for deterministic rewriting in ${sourceLabel}.`);
+    }
+    ;
+    return rewriteSourceFileWithIdentifiers(sourceFile, renameEntries, sourceLabel);
+}
 function collectRenameTargets(compIr, extractDeclaredIdentifiers) {
     const targets = new Set();
     const stateBindings = Array.isArray(compIr?.hoisted?.state) ? compIr.hoisted.state : [];
@@ -163,20 +269,16 @@ function findNextRefIndex(refBindings, raw, startIndex) {
     return -1;
 }
 export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredIdentifiers, resolveStateKeyFromBindings) {
+    // The only permitted downstream clone rewrite is structural instance isolation of
+    // component-local symbols. No string-based semantic reinterpretation is allowed.
     const suffix = `__inst${instanceId}`;
+    const sourceLabel = `component instance ${instanceId}`;
     const cloned = deepClone(compIr);
     const cloneMetadata = getCloneMetadata(compIr, extractDeclaredIdentifiers, resolveStateKeyFromBindings);
     const renameEntries = cloneMetadata.renameTargets.map((name) => [name, `${name}${suffix}`]);
     const renameMap = new Map(renameEntries);
-    const renamePlan = renameEntries
-        .sort((left, right) => right[0].length - left[0].length)
-        .map(([from, to]) => ({
-        from,
-        pattern: new RegExp(`\\b${escapeIdentifier(from)}\\b`, 'g'),
-        to
-    }));
     if (Array.isArray(cloned?.expressions)) {
-        cloned.expressions = cloned.expressions.map((expr) => replaceIdentifierRefs(expr, renamePlan));
+        cloned.expressions = cloned.expressions.map((expr) => rewriteIdentifierRefsInExpressionSource(expr, renameEntries, sourceLabel));
     }
     if (Array.isArray(cloned?.expression_bindings)) {
         cloned.expression_bindings = cloned.expression_bindings.map((binding) => {
@@ -185,22 +287,24 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
             }
             return {
                 ...binding,
-                literal: typeof binding.literal === 'string' ? replaceIdentifierRefs(binding.literal, renamePlan) : binding.literal,
+                literal: typeof binding.literal === 'string'
+                    ? rewriteIdentifierRefsInExpressionSource(binding.literal, renameEntries, sourceLabel)
+                    : binding.literal,
                 compiled_expr: typeof binding.compiled_expr === 'string'
-                    ? replaceIdentifierRefs(binding.compiled_expr, renamePlan)
+                    ? rewriteIdentifierRefsInExpressionSource(binding.compiled_expr, renameEntries, sourceLabel)
                     : binding.compiled_expr,
                 component_instance: typeof binding.component_instance === 'string'
-                    ? replaceIdentifierRefs(binding.component_instance, renamePlan)
+                    ? rewriteIdentifierRefsInExpressionSource(binding.component_instance, renameEntries, sourceLabel)
                     : binding.component_instance,
                 component_binding: typeof binding.component_binding === 'string'
-                    ? replaceIdentifierRefs(binding.component_binding, renamePlan)
+                    ? rewriteIdentifierRefsInExpressionSource(binding.component_binding, renameEntries, sourceLabel)
                     : binding.component_binding
             };
         });
     }
     if (cloned?.hoisted) {
         if (Array.isArray(cloned.hoisted.declarations)) {
-            cloned.hoisted.declarations = cloned.hoisted.declarations.map((line) => replaceIdentifierRefsInStatementSource(line, renameEntries, renamePlan));
+            cloned.hoisted.declarations = cloned.hoisted.declarations.map((line) => rewriteIdentifierRefsInStatementSource(line, renameEntries, sourceLabel));
         }
         if (Array.isArray(cloned.hoisted.functions)) {
             cloned.hoisted.functions = cloned.hoisted.functions.map((name) => renameMap.get(name) || name);
@@ -214,12 +318,14 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
                     return entry;
                 }
                 const key = typeof entry.key === 'string' ? (renameMap.get(entry.key) || entry.key) : entry.key;
-                const value = typeof entry.value === 'string' ? replaceIdentifierRefs(entry.value, renamePlan) : entry.value;
+                const value = typeof entry.value === 'string'
+                    ? rewriteIdentifierRefsInExpressionSource(entry.value, renameEntries, sourceLabel)
+                    : entry.value;
                 return { ...entry, key, value };
             });
         }
         if (Array.isArray(cloned.hoisted.code)) {
-            cloned.hoisted.code = cloned.hoisted.code.map((line) => replaceIdentifierRefsInStatementSource(line, renameEntries, renamePlan));
+            cloned.hoisted.code = cloned.hoisted.code.map((line) => rewriteIdentifierRefsInStatementSource(line, renameEntries, sourceLabel));
         }
     }
     if (Array.isArray(cloned?.ref_bindings)) {

package/dist/dev-build-session.js

@@ -2,14 +2,19 @@ import { existsSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { resolve } from 'node:path';
 import { buildComponentRegistry } from './resolve-components.js';
+import { normalizeBasePath } from './base-path.js';
 import { collectAssets, createCompilerWarningEmitter, runBundler } from './build/compiler-runtime.js';
 import { buildPageEnvelopes } from './build/page-loop.js';
 import { createPageLoopCaches } from './build/page-loop-state.js';
 import { deriveProjectRootFromPagesDir, ensureZenithTypeDeclarations } from './build/type-declarations.js';
+import { injectImageMaterializationIntoRouterManifest } from './images/router-manifest.js';
 import { buildImageArtifacts } from './images/service.js';
-import { createImageRuntimePayload } from './images/payload.js';
+import { materializeImageMarkupInHtmlFiles } from './images/materialize.js';
+import { createImageRuntimePayload, injectImageRuntimePayloadIntoHtmlFiles } from './images/payload.js';
 import { createStartupProfiler } from './startup-profile.js';
 import { resolveBundlerBin } from './toolchain-paths.js';
+import { resolveBuildAdapter } from './adapters/resolve-adapter.js';
+import { supportsTargetRouteCheck } from './route-check-support.js';
 import { createBundlerToolchain, createCompilerToolchain, ensureToolchainCompatibility, getActiveToolchainCandidate } from './toolchain-runner.js';
 import { maybeWarnAboutZenithVersionMismatch } from './version-check.js';
 import { generateManifest } from './manifest.js';
@@ -28,9 +33,8 @@ function createCompilerTotals() {
 function createExpressionRewriteMetrics() {
     return {
         calls: 0,
-        cacheHits: 0,
-        cacheMisses: 0,
-        templateCompileMs: 0
+        compilerOwnedBindings: 0,
+        ambiguousBindings: 0
     };
 }
 function toManifestEntryMap(manifest, pagesDir) {
@@ -238,6 +242,9 @@ export function createDevBuildSession(options) {
     const compilerBin = createCompilerToolchain({ projectRoot, logger });
     const bundlerBin = createBundlerToolchain({ projectRoot, logger });
     const routerEnabled = config.router === true;
+    const { target } = resolveBuildAdapter(config);
+    const basePath = normalizeBasePath(config.basePath || '/');
+    const routeCheckEnabled = supportsTargetRouteCheck(target);
     const compilerOpts = {
         typescriptDefault: config.typescriptDefault === true,
         experimentalEmbeddedMarkup: config.embeddedMarkupExpressions === true,
@@ -255,7 +262,7 @@ export function createDevBuildSession(options) {
         pageLoopCaches: createPageLoopCaches(),
         hasSuccessfulBuild: false,
         imageManifest: {},
-        imageRuntimePayload: createImageRuntimePayload(config.images, {}, 'endpoint')
+        imageRuntimePayload: createImageRuntimePayload(config.images, {}, 'passthrough', basePath)
     };
     async function syncImageState(startupProfile) {
         const { manifest } = await startupProfile.measureAsync('build_image_artifacts', () => buildImageArtifacts({
@@ -264,7 +271,12 @@ export function createDevBuildSession(options) {
             config: config.images
         }));
         state.imageManifest = manifest;
-        state.imageRuntimePayload = createImageRuntimePayload(config.images, manifest, 'endpoint');
+        state.imageRuntimePayload = createImageRuntimePayload(config.images, manifest, 'passthrough', basePath);
+        await startupProfile.measureAsync('materialize_image_markup', () => materializeImageMarkupInHtmlFiles({
+            distDir: outDir,
+            payload: state.imageRuntimePayload
+        }));
+        await startupProfile.measureAsync('inject_image_runtime_payload', () => injectImageRuntimePayloadIntoHtmlFiles(outDir, state.imageRuntimePayload));
     }
     async function runBundlerWithCachedEnvelopes(startupProfile, activeLogger, showBundlerInfo, bundlerOptions = {}) {
         const orderedEnvelopes = bundlerOptions.envelopesOverride
@@ -273,12 +285,14 @@ export function createDevBuildSession(options) {
             throw new Error('Dev rebuild cache is incomplete; full rebuild required.');
         }
         await startupProfile.measureAsync('run_bundler', () => runBundler(orderedEnvelopes, outDir, projectRoot, activeLogger, showBundlerInfo, bundlerBin, {
+            routeCheck: routeCheckEnabled,
             devStableAssets: true,
             rebuildStrategy: bundlerOptions.rebuildStrategy || 'full',
             changedRoutes: bundlerOptions.changedRoutes || [],
             fastPath: bundlerOptions.fastPath === true,
             globalGraphHash: bundlerOptions.globalGraphHash || ''
         }), { envelopes: orderedEnvelopes.length });
+        await startupProfile.measureAsync('inject_image_materialization_manifest', () => injectImageMaterializationIntoRouterManifest(outDir, orderedEnvelopes), { envelopes: orderedEnvelopes.length });
         const assets = await startupProfile.measureAsync('collect_assets', () => collectAssets(outDir));
         return { assets, envelopeCount: orderedEnvelopes.length };
     }