@zenithbuild/cli 0.6.17 → 0.7.0

package/dist/build/hoisted-code-transforms.js

@@ -0,0 +1,316 @@
+import { dirname, relative, resolve } from 'node:path';
+import { loadTypeScriptApi } from './compiler-runtime.js';
+/**
+ * @param {string} spec
+ * @returns {boolean}
+ */
+function isRelativeSpecifier(spec) {
+    return spec.startsWith('./') || spec.startsWith('../');
+}
+function rebaseRelativeSpecifier(spec, fromFile, toFile) {
+    if (!isRelativeSpecifier(spec)) {
+        return spec;
+    }
+    const absoluteTarget = resolve(dirname(fromFile), spec);
+    let rebased = relative(dirname(toFile), absoluteTarget).replaceAll('\\', '/');
+    if (!rebased.startsWith('.')) {
+        rebased = `./${rebased}`;
+    }
+    return rebased;
+}
+/**
+ * @param {string} line
+ * @param {string} oldSpec
+ * @param {string} newSpec
+ * @returns {string}
+ */
+function replaceImportSpecifierLiteral(line, oldSpec, newSpec) {
+    const single = `'${oldSpec}'`;
+    if (line.includes(single)) {
+        return line.replace(single, `'${newSpec}'`);
+    }
+    const dbl = `"${oldSpec}"`;
+    if (line.includes(dbl)) {
+        return line.replace(dbl, `"${newSpec}"`);
+    }
+    return line;
+}
+export function rewriteStaticImportLine(line, fromFile, toFile) {
+    const match = line.match(/^\s*import(?:\s+[^'"]+?\s+from)?\s*['"]([^'"]+)['"]\s*;?\s*$/);
+    if (!match) {
+        return line;
+    }
+    const spec = match[1];
+    if (!isRelativeSpecifier(spec)) {
+        return line;
+    }
+    const rebased = rebaseRelativeSpecifier(spec, fromFile, toFile);
+    return replaceImportSpecifierLiteral(line, spec, rebased);
+}
+/**
+ * @param {string} line
+ * @returns {string | null}
+ */
+export function extractStaticImportSpecifier(line) {
+    const match = line.match(/^\s*import(?:\s+[^'"]+?\s+from)?\s*['"]([^'"]+)['"]\s*;?\s*$/);
+    return match ? match[1] : null;
+}
+/**
+ * @param {string} spec
+ * @returns {boolean}
+ */
+export function isCssSpecifier(spec) {
+    return /\.css(?:[?#].*)?$/i.test(spec);
+}
+/**
+ * @param {string} source
+ * @param {string} fromFile
+ * @param {string} toFile
+ * @returns {string}
+ */
+export function rewriteStaticImportsInSource(source, fromFile, toFile) {
+    return source.replace(/(^\s*import(?:\s+[^'"]+?\s+from)?\s*['"])([^'"]+)(['"]\s*;?\s*$)/gm, (_full, prefix, spec, suffix) => `${prefix}${rebaseRelativeSpecifier(spec, fromFile, toFile)}${suffix}`);
+}
+/**
+ * @param {string} source
+ * @param {string} sourceFile
+ * @param {object | null} [transformCache]
+ * @param {Record<string, number> | null} [mergeMetrics]
+ * @returns {string}
+ */
+export function transpileTypeScriptToJs(source, sourceFile, transformCache = null, mergeMetrics = null) {
+    const cacheKey = transformCache?.transpileToJs instanceof Map
+        ? `${sourceFile}\u0000${source}`
+        : null;
+    if (cacheKey && transformCache.transpileToJs.has(cacheKey)) {
+        if (mergeMetrics && typeof mergeMetrics === 'object') {
+            mergeMetrics.codeTranspileCacheHits = (mergeMetrics.codeTranspileCacheHits || 0) + 1;
+        }
+        return transformCache.transpileToJs.get(cacheKey);
+    }
+    const ts = loadTypeScriptApi();
+    if (!ts) {
+        return source;
+    }
+    try {
+        const output = ts.transpileModule(source, {
+            fileName: sourceFile,
+            compilerOptions: {
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.ES5,
+                importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Preserve,
+                verbatimModuleSyntax: true,
+                newLine: ts.NewLineKind.LineFeed,
+            },
+            reportDiagnostics: false,
+        });
+        const transpiled = output.outputText;
+        if (mergeMetrics && typeof mergeMetrics === 'object') {
+            if (transpiled === source) {
+                mergeMetrics.codeTranspileExactNoopCount = (mergeMetrics.codeTranspileExactNoopCount || 0) + 1;
+            }
+            else if (transpiled.trim() === String(source).trim()) {
+                mergeMetrics.codeTranspileTrimmedNoopCount = (mergeMetrics.codeTranspileTrimmedNoopCount || 0) + 1;
+            }
+            else {
+                mergeMetrics.codeTranspileChangedOutputCount = (mergeMetrics.codeTranspileChangedOutputCount || 0) + 1;
+            }
+        }
+        if (cacheKey) {
+            transformCache.transpileToJs.set(cacheKey, transpiled);
+            if (mergeMetrics && typeof mergeMetrics === 'object') {
+                mergeMetrics.codeTranspileCacheMisses = (mergeMetrics.codeTranspileCacheMisses || 0) + 1;
+            }
+        }
+        return transpiled;
+    }
+    catch {
+        return source;
+    }
+}
+const DEFERRED_RUNTIME_CALLS = new Set(['zenMount', 'zenEffect', 'zeneffect']);
+/**
+ * @param {string} body
+ * @returns {{ hoisted: string, deferred: string }}
+ */
+function splitDeferredRuntimeCalls(body) {
+    const ts = loadTypeScriptApi();
+    if (!ts || typeof body !== 'string' || body.trim().length === 0) {
+        return { hoisted: body, deferred: '' };
+    }
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-component-runtime.ts', body, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        return { hoisted: body, deferred: '' };
+    }
+    if (!sourceFile || !Array.isArray(sourceFile.statements) || sourceFile.statements.length === 0) {
+        return { hoisted: body, deferred: '' };
+    }
+    const ranges = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression)) {
+            continue;
+        }
+        let callee = statement.expression.expression;
+        while (ts.isParenthesizedExpression(callee)) {
+            callee = callee.expression;
+        }
+        if (!ts.isIdentifier(callee) || !DEFERRED_RUNTIME_CALLS.has(callee.text)) {
+            continue;
+        }
+        const start = typeof statement.getFullStart === 'function' ? statement.getFullStart() : statement.pos;
+        const end = statement.end;
+        if (!Number.isInteger(start) || !Number.isInteger(end) || end <= start) {
+            continue;
+        }
+        ranges.push({ start, end });
+    }
+    if (ranges.length === 0) {
+        return { hoisted: body, deferred: '' };
+    }
+    ranges.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const range of ranges) {
+        const last = merged[merged.length - 1];
+        if (!last || range.start > last.end) {
+            merged.push({ start: range.start, end: range.end });
+            continue;
+        }
+        if (range.end > last.end) {
+            last.end = range.end;
+        }
+    }
+    let cursor = 0;
+    let hoisted = '';
+    let deferred = '';
+    for (const range of merged) {
+        if (range.start > cursor) {
+            hoisted += body.slice(cursor, range.start);
+        }
+        deferred += body.slice(range.start, range.end);
+        if (!deferred.endsWith('\n')) {
+            deferred += '\n';
+        }
+        cursor = range.end;
+    }
+    if (cursor < body.length) {
+        hoisted += body.slice(cursor);
+    }
+    return { hoisted, deferred };
+}
+/**
+ * @param {string} source
+ * @param {Set<string>} seenStaticImports
+ * @returns {string}
+ */
+export function dedupeStaticImportsInSource(source, seenStaticImports) {
+    const lines = source.split('\n');
+    const kept = [];
+    for (const line of lines) {
+        const spec = extractStaticImportSpecifier(line);
+        if (!spec) {
+            kept.push(line);
+            continue;
+        }
+        const key = line.trim();
+        if (seenStaticImports.has(key)) {
+            continue;
+        }
+        seenStaticImports.add(key);
+        kept.push(line);
+    }
+    return kept.join('\n');
+}
+/**
+ * @param {string} source
+ * @returns {string}
+ */
+export function stripNonCssStaticImportsInSource(source) {
+    const lines = source.split('\n');
+    const kept = [];
+    for (const line of lines) {
+        const spec = extractStaticImportSpecifier(line);
+        if (!spec) {
+            kept.push(line);
+            continue;
+        }
+        if (isCssSpecifier(spec)) {
+            kept.push(line);
+        }
+    }
+    return kept.join('\n');
+}
+/**
+ * @param {string} source
+ * @param {object | null} [transformCache]
+ * @param {Record<string, number> | null} [mergeMetrics]
+ * @returns {string}
+ */
+export function deferComponentRuntimeBlock(source, transformCache = null, mergeMetrics = null) {
+    const cacheKey = transformCache?.deferRuntime instanceof Map ? source : null;
+    if (cacheKey && transformCache.deferRuntime.has(cacheKey)) {
+        if (mergeMetrics && typeof mergeMetrics === 'object') {
+            mergeMetrics.codeDeferRuntimeCacheHits = (mergeMetrics.codeDeferRuntimeCacheHits || 0) + 1;
+        }
+        return transformCache.deferRuntime.get(cacheKey);
+    }
+    const lines = source.split('\n');
+    const importLines = [];
+    const bodyLines = [];
+    let inImportPrefix = true;
+    for (const line of lines) {
+        if (inImportPrefix && extractStaticImportSpecifier(line)) {
+            importLines.push(line);
+            continue;
+        }
+        inImportPrefix = false;
+        bodyLines.push(line);
+    }
+    const body = bodyLines.join('\n');
+    if (body.trim().length === 0) {
+        const output = importLines.join('\n');
+        if (cacheKey) {
+            transformCache.deferRuntime.set(cacheKey, output);
+            if (mergeMetrics && typeof mergeMetrics === 'object') {
+                mergeMetrics.codeDeferRuntimeCacheMisses = (mergeMetrics.codeDeferRuntimeCacheMisses || 0) + 1;
+            }
+        }
+        return output;
+    }
+    const { hoisted, deferred } = splitDeferredRuntimeCalls(body);
+    if (deferred.trim().length === 0) {
+        const output = [importLines.join('\n').trim(), hoisted.trim()]
+            .filter((segment) => segment.length > 0)
+            .join('\n');
+        if (cacheKey) {
+            transformCache.deferRuntime.set(cacheKey, output);
+            if (mergeMetrics && typeof mergeMetrics === 'object') {
+                mergeMetrics.codeDeferRuntimeCacheMisses = (mergeMetrics.codeDeferRuntimeCacheMisses || 0) + 1;
+            }
+        }
+        return output;
+    }
+    const indentedBody = deferred
+        .trim()
+        .split('\n')
+        .map((line) => `    ${line}`)
+        .join('\n');
+    const wrapped = [
+        importLines.join('\n').trim(),
+        hoisted.trim(),
+        "__zenith_component_bootstraps.push(() => {",
+        indentedBody,
+        "});"
+    ]
+        .filter((segment) => segment.length > 0)
+        .join('\n');
+    if (cacheKey) {
+        transformCache.deferRuntime.set(cacheKey, wrapped);
+        if (mergeMetrics && typeof mergeMetrics === 'object') {
+            mergeMetrics.codeDeferRuntimeCacheMisses = (mergeMetrics.codeDeferRuntimeCacheMisses || 0) + 1;
+        }
+    }
+    return wrapped;
+}

package/dist/build/merge-component-ir.d.ts

@@ -0,0 +1,16 @@
+export function createPageIrMergeCache(pageIr: any): {
+    stateEntries: any;
+    signals: any;
+    importSet: Set<any>;
+    declarationSet: Set<any>;
+    functionSet: Set<any>;
+    hoistedSignalSet: Set<any>;
+    stateKeySet: Set<any>;
+    stateIndexByKey: Map<any, any>;
+    runtimeSignalStateKeySet: Set<any>;
+    signalIndexByStateKey: Map<any, any>;
+    signalIndicesByStateIndex: Map<any, any>;
+    codeSet: Set<any>;
+};
+export function addMergeMetric(mergeMetrics: any, key: any, value: any): void;
+export function mergeComponentIr(pageIr: any, compIr: any, compPath: any, pageFile: any, options: any, seenStaticImports: any, knownRefKeys?: null, mergeCache?: null, mergeMetrics?: null, transformCache?: null): void;

package/dist/build/merge-component-ir.js

@@ -0,0 +1,257 @@
+import { performance } from 'node:perf_hooks';
+import { resolveStateKeyFromBindings } from './expression-rewrites.js';
+import { injectPropsPrelude } from './scoped-identifier-rewrite.js';
+import { dedupeStaticImportsInSource, deferComponentRuntimeBlock, extractStaticImportSpecifier, isCssSpecifier, rewriteStaticImportLine, rewriteStaticImportsInSource, stripNonCssStaticImportsInSource, transpileTypeScriptToJs } from './hoisted-code-transforms.js';
+export function createPageIrMergeCache(pageIr) {
+    const hoisted = pageIr?.hoisted || {};
+    const stateEntries = Array.isArray(hoisted.state) ? hoisted.state : [];
+    const signals = Array.isArray(pageIr?.signals) ? pageIr.signals : [];
+    const signalIndexByStateKey = new Map();
+    const signalIndicesByStateIndex = new Map();
+    for (let index = 0; index < signals.length; index++) {
+        const stateIndex = signals[index]?.state_index;
+        if (!Number.isInteger(stateIndex) || stateIndex < 0) {
+            continue;
+        }
+        const stateKey = stateEntries[stateIndex]?.key;
+        if (typeof stateKey === 'string' && stateKey.length > 0 && !signalIndexByStateKey.has(stateKey)) {
+            signalIndexByStateKey.set(stateKey, index);
+        }
+        const existingIndices = signalIndicesByStateIndex.get(stateIndex);
+        if (existingIndices) {
+            existingIndices.push(index);
+        }
+        else {
+            signalIndicesByStateIndex.set(stateIndex, [index]);
+        }
+    }
+    return {
+        stateEntries,
+        signals,
+        importSet: new Set(Array.isArray(hoisted.imports) ? hoisted.imports : []),
+        declarationSet: new Set(Array.isArray(hoisted.declarations) ? hoisted.declarations : []),
+        functionSet: new Set(Array.isArray(hoisted.functions) ? hoisted.functions : []),
+        hoistedSignalSet: new Set(Array.isArray(hoisted.signals) ? hoisted.signals : []),
+        stateKeySet: new Set(stateEntries.map((entry) => entry?.key).filter(Boolean)),
+        stateIndexByKey: new Map(stateEntries
+            .map((entry, index) => [entry?.key, index])
+            .filter(([key]) => typeof key === 'string' && key.length > 0)),
+        runtimeSignalStateKeySet: new Set(signals
+            .map((signal) => {
+            const stateIndex = signal?.state_index;
+            return Number.isInteger(stateIndex) ? stateEntries[stateIndex]?.key : null;
+        })
+            .filter(Boolean)),
+        signalIndexByStateKey,
+        signalIndicesByStateIndex,
+        codeSet: new Set(Array.isArray(hoisted.code) ? hoisted.code : [])
+    };
+}
+export function addMergeMetric(mergeMetrics, key, value) {
+    if (!mergeMetrics || typeof mergeMetrics !== 'object' || !Number.isFinite(value)) {
+        return;
+    }
+    mergeMetrics[key] = (mergeMetrics[key] || 0) + value;
+}
+export function mergeComponentIr(pageIr, compIr, compPath, pageFile, options, seenStaticImports, knownRefKeys = null, mergeCache = null, mergeMetrics = null, transformCache = null) {
+    const componentScriptsStartedAt = performance.now();
+    if (compIr.components_scripts) {
+        for (const [hoistId, script] of Object.entries(compIr.components_scripts)) {
+            if (!pageIr.components_scripts[hoistId]) {
+                pageIr.components_scripts[hoistId] = script;
+            }
+        }
+    }
+    addMergeMetric(mergeMetrics, 'componentScriptsMs', performance.now() - componentScriptsStartedAt);
+    const componentInstancesStartedAt = performance.now();
+    if (compIr.component_instances?.length) {
+        pageIr.component_instances.push(...compIr.component_instances);
+    }
+    addMergeMetric(mergeMetrics, 'componentInstancesMs', performance.now() - componentInstancesStartedAt);
+    const refBindingsStartedAt = performance.now();
+    if (knownRefKeys instanceof Set && Array.isArray(compIr.ref_bindings)) {
+        const componentStateBindings = Array.isArray(compIr?.hoisted?.state) ? compIr.hoisted.state : [];
+        for (const binding of compIr.ref_bindings) {
+            if (!binding || typeof binding.identifier !== 'string' || binding.identifier.length === 0) {
+                continue;
+            }
+            const resolved = resolveStateKeyFromBindings(binding.identifier, componentStateBindings);
+            knownRefKeys.add(resolved || binding.identifier);
+        }
+    }
+    addMergeMetric(mergeMetrics, 'refBindingsMs', performance.now() - refBindingsStartedAt);
+    const importsStartedAt = performance.now();
+    if (compIr.hoisted?.imports?.length) {
+        for (const imp of compIr.hoisted.imports) {
+            const rebased = rewriteStaticImportLine(imp, compPath, pageFile);
+            if (options.cssImportsOnly) {
+                const spec = extractStaticImportSpecifier(rebased);
+                if (!spec || !isCssSpecifier(spec)) {
+                    continue;
+                }
+            }
+            if (mergeCache?.importSet instanceof Set) {
+                if (mergeCache.importSet.has(rebased)) {
+                    continue;
+                }
+                mergeCache.importSet.add(rebased);
+            }
+            else if (pageIr.hoisted.imports.includes(rebased)) {
+                continue;
+            }
+            if (!mergeCache?.importSet || mergeCache.importSet.has(rebased)) {
+                pageIr.hoisted.imports.push(rebased);
+            }
+        }
+    }
+    addMergeMetric(mergeMetrics, 'importsMs', performance.now() - importsStartedAt);
+    const hoistedSymbolsStartedAt = performance.now();
+    if (options.includeCode && compIr.hoisted) {
+        if (Array.isArray(compIr.hoisted.declarations)) {
+            for (const decl of compIr.hoisted.declarations) {
+                if (mergeCache?.declarationSet instanceof Set) {
+                    if (mergeCache.declarationSet.has(decl)) {
+                        continue;
+                    }
+                    mergeCache.declarationSet.add(decl);
+                }
+                else if (pageIr.hoisted.declarations.includes(decl)) {
+                    continue;
+                }
+                pageIr.hoisted.declarations.push(decl);
+            }
+        }
+        if (Array.isArray(compIr.hoisted.functions)) {
+            for (const fnName of compIr.hoisted.functions) {
+                if (mergeCache?.functionSet instanceof Set) {
+                    if (mergeCache.functionSet.has(fnName)) {
+                        continue;
+                    }
+                    mergeCache.functionSet.add(fnName);
+                }
+                else if (pageIr.hoisted.functions.includes(fnName)) {
+                    continue;
+                }
+                pageIr.hoisted.functions.push(fnName);
+            }
+        }
+        if (Array.isArray(compIr.hoisted.signals)) {
+            for (const signalName of compIr.hoisted.signals) {
+                if (mergeCache?.hoistedSignalSet instanceof Set) {
+                    if (mergeCache.hoistedSignalSet.has(signalName)) {
+                        continue;
+                    }
+                    mergeCache.hoistedSignalSet.add(signalName);
+                }
+                else if (pageIr.hoisted.signals.includes(signalName)) {
+                    continue;
+                }
+                pageIr.hoisted.signals.push(signalName);
+            }
+        }
+        if (Array.isArray(compIr.hoisted.state)) {
+            const existingKeys = mergeCache?.stateKeySet instanceof Set
+                ? mergeCache.stateKeySet
+                : new Set((pageIr.hoisted.state || [])
+                    .map((entry) => entry && typeof entry === 'object' ? entry.key : null)
+                    .filter(Boolean));
+            for (const stateEntry of compIr.hoisted.state) {
+                if (!stateEntry || typeof stateEntry !== 'object') {
+                    continue;
+                }
+                if (typeof stateEntry.key !== 'string' || stateEntry.key.length === 0 || existingKeys.has(stateEntry.key)) {
+                    continue;
+                }
+                existingKeys.add(stateEntry.key);
+                pageIr.hoisted.state.push(stateEntry);
+                if (mergeCache?.stateIndexByKey instanceof Map) {
+                    mergeCache.stateIndexByKey.set(stateEntry.key, pageIr.hoisted.state.length - 1);
+                }
+            }
+        }
+    }
+    addMergeMetric(mergeMetrics, 'hoistedSymbolsMs', performance.now() - hoistedSymbolsStartedAt);
+    const runtimeSignalsStartedAt = performance.now();
+    if (options.includeCode && Array.isArray(compIr.signals)) {
+        pageIr.signals = Array.isArray(pageIr.signals) ? pageIr.signals : [];
+        const existingSignalStateKeys = mergeCache?.runtimeSignalStateKeySet instanceof Set
+            ? mergeCache.runtimeSignalStateKeySet
+            : new Set(pageIr.signals
+                .map((signal) => {
+                const stateIndex = signal?.state_index;
+                return Number.isInteger(stateIndex) ? pageIr.hoisted.state?.[stateIndex]?.key : null;
+            })
+                .filter(Boolean));
+        for (const signal of compIr.signals) {
+            if (!signal || !Number.isInteger(signal.state_index)) {
+                continue;
+            }
+            const stateKey = compIr.hoisted?.state?.[signal.state_index]?.key;
+            if (typeof stateKey !== 'string' || stateKey.length === 0) {
+                continue;
+            }
+            const pageStateIndex = mergeCache?.stateIndexByKey instanceof Map
+                ? mergeCache.stateIndexByKey.get(stateKey)
+                : pageIr.hoisted.state.findIndex((entry) => entry?.key === stateKey);
+            if (!Number.isInteger(pageStateIndex) || pageStateIndex < 0 || existingSignalStateKeys.has(stateKey)) {
+                continue;
+            }
+            existingSignalStateKeys.add(stateKey);
+            const nextSignalIndex = pageIr.signals.length;
+            pageIr.signals.push({
+                id: nextSignalIndex,
+                kind: typeof signal.kind === 'string' && signal.kind.length > 0 ? signal.kind : 'signal',
+                state_index: pageStateIndex
+            });
+            if (mergeCache?.signalIndexByStateKey instanceof Map && !mergeCache.signalIndexByStateKey.has(stateKey)) {
+                mergeCache.signalIndexByStateKey.set(stateKey, nextSignalIndex);
+            }
+            if (mergeCache?.signalIndicesByStateIndex instanceof Map) {
+                const existingIndices = mergeCache.signalIndicesByStateIndex.get(pageStateIndex);
+                if (existingIndices) {
+                    existingIndices.push(nextSignalIndex);
+                }
+                else {
+                    mergeCache.signalIndicesByStateIndex.set(pageStateIndex, [nextSignalIndex]);
+                }
+            }
+        }
+    }
+    addMergeMetric(mergeMetrics, 'runtimeSignalsMs', performance.now() - runtimeSignalsStartedAt);
+    const hoistedCodeStartedAt = performance.now();
+    if (options.includeCode && compIr.hoisted?.code?.length) {
+        for (const block of compIr.hoisted.code) {
+            const rebaseStartedAt = performance.now();
+            const rebased = rewriteStaticImportsInSource(block, compPath, pageFile);
+            addMergeMetric(mergeMetrics, 'codeRebaseImportsMs', performance.now() - rebaseStartedAt);
+            const filterImportsStartedAt = performance.now();
+            const filteredImports = options.cssImportsOnly ? stripNonCssStaticImportsInSource(rebased) : rebased;
+            addMergeMetric(mergeMetrics, 'codeFilterImportsMs', performance.now() - filterImportsStartedAt);
+            const transpileStartedAt = performance.now();
+            const transpiled = transpileTypeScriptToJs(filteredImports, compPath, transformCache, mergeMetrics);
+            addMergeMetric(mergeMetrics, 'codeTranspileMs', performance.now() - transpileStartedAt);
+            const propsPreludeStartedAt = performance.now();
+            const withPropsPrelude = injectPropsPrelude(transpiled, options.componentAttrs || '', options.componentAttrsRewrite || null);
+            addMergeMetric(mergeMetrics, 'codePropsPreludeMs', performance.now() - propsPreludeStartedAt);
+            const dedupeImportsStartedAt = performance.now();
+            const deduped = dedupeStaticImportsInSource(withPropsPrelude, seenStaticImports);
+            addMergeMetric(mergeMetrics, 'codeDedupeImportsMs', performance.now() - dedupeImportsStartedAt);
+            const deferRuntimeStartedAt = performance.now();
+            const deferred = deferComponentRuntimeBlock(deduped, transformCache, mergeMetrics);
+            addMergeMetric(mergeMetrics, 'codeDeferRuntimeMs', performance.now() - deferRuntimeStartedAt);
+            if (deferred.trim().length > 0) {
+                if (mergeCache?.codeSet instanceof Set) {
+                    if (mergeCache.codeSet.has(deferred)) {
+                        continue;
+                    }
+                    mergeCache.codeSet.add(deferred);
+                }
+                else if (pageIr.hoisted.code.includes(deferred)) {
+                    continue;
+                }
+                pageIr.hoisted.code.push(deferred);
+            }
+        }
+    }
+    addMergeMetric(mergeMetrics, 'hoistedCodeMs', performance.now() - hoistedCodeStartedAt);
+}

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

@@ -0,0 +1,92 @@
+export function buildPageOwnerContext({ componentOccurrences, sourceFile, pageOwnerSource, compilerOpts, compilerBin, timedRunCompiler, cooperativeYield, templateExpressionCache, expressionRewriteMetrics, startupProfile }: {
+    componentOccurrences: any;
+    sourceFile: any;
+    pageOwnerSource: any;
+    compilerOpts: any;
+    compilerBin: any;
+    timedRunCompiler: any;
+    cooperativeYield: any;
+    templateExpressionCache: any;
+    expressionRewriteMetrics: any;
+    startupProfile: any;
+}): Promise<{
+    pageOwnerCompileMs: number;
+    pageOwnerExpressionRewrite: {
+        map: Map<any, any>;
+        bindings: Map<any, any>;
+        signals: never[];
+        stateBindings: never[];
+        ambiguous: Set<any>;
+        sequence: never[];
+    };
+    pageOwnerScopeRewrite: {
+        map: Map<any, any>;
+        ambiguous: Set<any>;
+    };
+} | {
+    pageOwnerCompileMs: any;
+    pageOwnerExpressionRewrite: {
+        map: Map<string, string>;
+        bindings: Map<string, {
+            compiled_expr: string | null;
+            signal_index: number | null;
+            signal_indices: number[];
+            state_index: number | null;
+            component_instance: string | null;
+            component_binding: string | null;
+        }>;
+        signals: Array<{
+            id?: number;
+            kind?: string;
+            state_index?: number;
+        }>;
+        stateBindings: Array<{
+            key?: string;
+            value?: string;
+        }>;
+        ambiguous: Set<string>;
+        sequence: Array<{
+            raw: string;
+            rewritten: string;
+            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 }: {
+    componentOccurrences: any;
+    occurrenceCountByPath: any;
+    sourceFile: any;
+    registry: any;
+    compilerOpts: any;
+    compilerBin: any;
+    timedRunCompiler: any;
+    cooperativeYield: any;
+    startupProfile: any;
+    compilerTotals: any;
+    emitCompilerWarning: any;
+    componentIrCache: any;
+    componentDocumentModeCache: any;
+    componentExpressionRewriteCache: any;
+    templateExpressionCache: any;
+    expressionRewriteMetrics: any;
+    pageOwnerExpressionRewrite: any;
+    pageOwnerScopeRewrite: any;
+    pageIr: any;
+    pageIrMergeCache: any;
+    seenStaticImports: any;
+    pageExpressionRewriteMap: any;
+    pageExpressionBindingMap: any;
+    pageAmbiguousExpressionMap: any;
+    knownRefKeys: any;
+    componentOccurrencePlans: any;
+    pagePhase: any;
+    pageBindingResolutionBreakdown: any;
+    pageMergeBreakdown: any;
+    pageComponentLoopBreakdown: any;
+    hoistedCodeTransformCache: any;
+    pageStats: any;
+}): Promise<void>;