@zenithbuild/cli 0.6.17 → 0.7.0

package/dist/build/page-loop.js

@@ -0,0 +1,217 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { performance } from 'node:perf_hooks';
+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 { 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 { 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 {{
+ *   manifest: Array<{ path: string, file: string }>
+ *   pagesDir: string
+ *   srcDir: string
+ *   registry: Map<string, string>
+ *   compilerOpts: object
+ *   compilerBin: string|object
+ *   softNavigationEnabled: boolean
+ *   startupProfile: ReturnType<import('../startup-profile.js').createStartupProfiler>
+ *   compilerTotals: Record<string, number>
+ *   emitCompilerWarning: (line: string) => void
+ * }} input
+ * @returns {Promise<{ envelopes: object[], expressionRewriteMetrics: Record<string, number> }>}
+ */
+export async function buildPageEnvelopes(input) {
+    const { manifest, pagesDir, srcDir, registry, compilerOpts, compilerBin, softNavigationEnabled, startupProfile, compilerTotals, emitCompilerWarning } = input;
+    const cacheState = input.pageLoopCaches || createPageLoopCaches();
+    const executionState = createPageLoopExecutionState();
+    const { componentIrCache, componentDocumentModeCache, componentExpressionRewriteCache, templateExpressionCache, hoistedCodeTransformCache } = cacheState;
+    const { expressionRewriteMetrics, pagePhaseTotals, occurrenceApplyPhaseTotals, bindingResolutionTotals, scopedRewritePhaseTotals, mergePhaseTotals, componentLoopPhaseTotals, pageProfiles, envelopes } = executionState;
+    async function cooperativeYield() {
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    const timedRunCompiler = createTimedCompilerRunner(startupProfile, compilerTotals);
+    const pageLoopStartedAt = performance.now();
+    for (const entry of manifest) {
+        const pageStartedAt = performance.now();
+        let { pagePhase, pageOccurrenceApplyBreakdown, pageBindingResolutionBreakdown, pageScopedRewriteBreakdown, pageMergeBreakdown, pageComponentLoopBreakdown, pageExpandMs, pageCompileMs, pageOwnerCompileMs, pageComponentCompileMs, pageComponentCacheHits, pageComponentCacheMisses } = createPageBuildState();
+        await cooperativeYield();
+        const sourceFile = join(pagesDir, entry.file);
+        const rawSource = readFileSync(sourceFile, 'utf8');
+        const occurrenceCollectStartedAt = performance.now();
+        const componentOccurrences = collectExpandedComponentOccurrences(rawSource, registry, sourceFile);
+        pagePhase.occurrenceCollectMs = startupProfile.roundMs(performance.now() - occurrenceCollectStartedAt);
+        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 expandedStartedAt = performance.now();
+        const { expandedSource } = expandComponents(rawSource, registry, sourceFile);
+        pageExpandMs = startupProfile.roundMs(performance.now() - expandedStartedAt);
+        const expandedServerExtractStartedAt = performance.now();
+        const extractedServer = extractServerScript(expandedSource, sourceFile, compilerOpts);
+        pagePhase.serverExtractMs += startupProfile.roundMs(performance.now() - expandedServerExtractStartedAt);
+        const compileSource = extractedServer.source;
+        await cooperativeYield();
+        const pageCompileStartedAt = performance.now();
+        const 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
+        });
+        const hasGuard = composedServer.serverScript?.has_guard === true;
+        const hasLoad = composedServer.serverScript?.has_load === true;
+        applyServerEnvelopeToPageIr({
+            pageIr,
+            composedServer,
+            hasGuard,
+            hasLoad,
+            entry,
+            srcDir,
+            sourceFile
+        });
+        const pageIrMergeCache = createPageIrMergeCache(pageIr);
+        const seenStaticImports = new Set();
+        const occurrenceCountByPath = buildOccurrenceCountByPath(componentOccurrences);
+        const pageExpressionRewriteMap = new Map();
+        const pageExpressionBindingMap = new Map();
+        const pageAmbiguousExpressionMap = new Set();
+        const knownRefKeys = new Set();
+        const componentOccurrencePlans = [];
+        const { pageOwnerCompileMs: resolvedPageOwnerCompileMs, pageOwnerExpressionRewrite, pageOwnerScopeRewrite } = await buildPageOwnerContext({
+            componentOccurrences,
+            sourceFile,
+            pageOwnerSource,
+            compilerOpts,
+            compilerBin,
+            timedRunCompiler,
+            cooperativeYield,
+            templateExpressionCache,
+            expressionRewriteMetrics,
+            startupProfile
+        });
+        pageOwnerCompileMs = resolvedPageOwnerCompileMs;
+        const pageSelfRewriteStartedAt = performance.now();
+        const pageSelfExpressionRewrite = buildComponentExpressionRewrite(sourceFile, compileSource, pageIr, compilerOpts, compilerBin, templateExpressionCache, expressionRewriteMetrics);
+        pagePhase.selfRewriteMs = startupProfile.roundMs(performance.now() - pageSelfRewriteStartedAt);
+        mergeExpressionRewriteMaps(pageExpressionRewriteMap, pageExpressionBindingMap, pageAmbiguousExpressionMap, pageSelfExpressionRewrite, pageIrMergeCache, pageBindingResolutionBreakdown);
+        const componentLoopStartedAt = performance.now();
+        const pageStats = {
+            pageComponentCompileMs,
+            pageComponentCacheHits,
+            pageComponentCacheMisses
+        };
+        await 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
+        });
+        pageComponentCompileMs = pageStats.pageComponentCompileMs;
+        pageComponentCacheHits = pageStats.pageComponentCacheHits;
+        pageComponentCacheMisses = pageStats.pageComponentCacheMisses;
+        pagePhase.componentLoopMs = startupProfile.roundMs(performance.now() - componentLoopStartedAt);
+        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);
+        rewriteLegacyMarkupIdentifiers(pageIr);
+        rewriteRefBindingIdentifiers(pageIr, knownRefKeys);
+        pagePhase.normalizeMs = startupProfile.roundMs(performance.now() - normalizeStartedAt);
+        addBreakdown(pagePhaseTotals, pagePhase);
+        addBreakdown(occurrenceApplyPhaseTotals, pageOccurrenceApplyBreakdown);
+        addBreakdown(bindingResolutionTotals, pageBindingResolutionBreakdown);
+        addBreakdown(scopedRewritePhaseTotals, pageScopedRewriteBreakdown);
+        addBreakdown(mergePhaseTotals, pageMergeBreakdown);
+        addBreakdown(componentLoopPhaseTotals, pageComponentLoopBreakdown);
+        envelopes.push({
+            route: entry.path,
+            file: sourceFile,
+            ir: pageIr,
+            router: softNavigationEnabled
+        });
+        recordPageProfile({
+            pageProfiles,
+            entry,
+            componentOccurrences: componentOccurrences.length,
+            pageExpandMs,
+            pageCompileMs,
+            pageOwnerCompileMs,
+            pageComponentCompileMs,
+            pageComponentCacheHits,
+            pageComponentCacheMisses,
+            pagePhase,
+            startupProfile,
+            pageStartedAt
+        });
+    }
+    emitPageLoopSummary({
+        startupProfile,
+        manifest,
+        pageLoopStartedAt,
+        compilerTotals,
+        expressionRewriteMetrics,
+        pagePhaseTotals,
+        occurrenceApplyPhaseTotals,
+        bindingResolutionTotals,
+        scopedRewritePhaseTotals,
+        mergePhaseTotals,
+        componentLoopPhaseTotals,
+        pageProfiles
+    });
+    return { envelopes, expressionRewriteMetrics };
+}

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

@@ -0,0 +1,112 @@
+/**
+ * @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 {{
+ *   signals?: Array<{ state_index?: number }>,
+ *   stateBindings?: Array<{ key?: string }>
+ * } | null | undefined} expressionRewrite
+ * @returns {string | null}
+ */
+export function resolveCompiledPropsExpression(compiledExpr: string | null | undefined, expressionRewrite?: {
+    signals?: Array<{
+        state_index?: number;
+    }>;
+    stateBindings?: Array<{
+        key?: string;
+    }>;
+} | null | undefined): string | null;
+/**
+ * @param {string} expr
+ * @param {{
+ *   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,
+ *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ * } | null} rewriteContext
+ * @returns {string}
+ */
+export function resolvePropsValueCode(expr: string, rewriteContext?: {
+    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;
+    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
+ * } | null} rewriteContext
+ * @returns {string}
+ */
+export function renderPropsLiteralFromAttrs(attrs: string, rewriteContext?: {
+    expressionRewrite?: {
+        map?: Map<string, string>;
+        ambiguous?: Set<string>;
+    } | null;
+    scopeRewrite?: {
+        map?: Map<string, string>;
+        ambiguous?: Set<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
+ * } | null} rewriteContext
+ * @returns {string}
+ */
+export function injectPropsPrelude(source: string, attrs: string, rewriteContext?: {
+    expressionRewrite?: {
+        map?: Map<string, string>;
+        ambiguous?: Set<string>;
+    } | null;
+    scopeRewrite?: {
+        map?: Map<string, string>;
+        ambiguous?: Set<string>;
+    } | null;
+} | null): string;

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

@@ -0,0 +1,245 @@
+import { extractDeclaredIdentifiers, normalizeTypeScriptExpression, renderObjectKey, rewriteIdentifiersWithinExpression } from './typescript-expression-utils.js';
+/**
+ * @param {string} value
+ * @returns {string | null}
+ */
+function deriveScopedIdentifierAlias(value) {
+    const ident = String(value || '').trim();
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(ident)) {
+        return null;
+    }
+    const parts = ident.split('_').filter(Boolean);
+    const candidate = parts.length > 1 ? parts[parts.length - 1] : ident;
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(candidate) ? candidate : ident;
+}
+/**
+ * @param {Map<string, string>} map
+ * @param {Set<string>} ambiguous
+ * @param {string | null} raw
+ * @param {string | null} rewritten
+ */
+function recordScopedIdentifierRewrite(map, ambiguous, raw, rewritten) {
+    if (typeof raw !== 'string' || raw.length === 0 || typeof rewritten !== 'string' || rewritten.length === 0) {
+        return;
+    }
+    const existing = map.get(raw);
+    if (existing && existing !== rewritten) {
+        map.delete(raw);
+        ambiguous.add(raw);
+        return;
+    }
+    if (!ambiguous.has(raw)) {
+        map.set(raw, rewritten);
+    }
+}
+/**
+ * @param {object | null | undefined} ir
+ * @returns {{ map: Map<string, string>, ambiguous: Set<string> }}
+ */
+export function buildScopedIdentifierRewrite(ir) {
+    const out = { map: new Map(), ambiguous: new Set() };
+    if (!ir || typeof ir !== 'object') {
+        return out;
+    }
+    const stateBindings = Array.isArray(ir?.hoisted?.state) ? ir.hoisted.state : [];
+    for (const stateEntry of stateBindings) {
+        const key = typeof stateEntry?.key === 'string' ? stateEntry.key : null;
+        recordScopedIdentifierRewrite(out.map, out.ambiguous, deriveScopedIdentifierAlias(key), key);
+    }
+    const functionBindings = Array.isArray(ir?.hoisted?.functions) ? ir.hoisted.functions : [];
+    for (const fnName of functionBindings) {
+        if (typeof fnName !== 'string') {
+            continue;
+        }
+        recordScopedIdentifierRewrite(out.map, out.ambiguous, deriveScopedIdentifierAlias(fnName), fnName);
+    }
+    const declarations = Array.isArray(ir?.hoisted?.declarations) ? ir.hoisted.declarations : [];
+    for (const declaration of declarations) {
+        if (typeof declaration !== 'string') {
+            continue;
+        }
+        for (const identifier of extractDeclaredIdentifiers(declaration)) {
+            recordScopedIdentifierRewrite(out.map, out.ambiguous, deriveScopedIdentifierAlias(identifier), identifier);
+        }
+    }
+    return out;
+}
+/**
+ * @param {string} expr
+ * @param {{
+ *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
+ *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ * } | null} rewriteContext
+ * @returns {string}
+ */
+export function rewritePropsExpression(expr, rewriteContext = null) {
+    const trimmed = String(expr || '').trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    const expressionMap = rewriteContext?.expressionRewrite?.map;
+    const expressionAmbiguous = rewriteContext?.expressionRewrite?.ambiguous;
+    if (expressionMap instanceof Map &&
+        !(expressionAmbiguous instanceof Set && expressionAmbiguous.has(trimmed))) {
+        const exact = expressionMap.get(trimmed);
+        if (typeof exact === 'string' && exact.length > 0) {
+            return normalizeTypeScriptExpression(exact);
+        }
+    }
+    const scopeMap = rewriteContext?.scopeRewrite?.map;
+    const scopeAmbiguous = rewriteContext?.scopeRewrite?.ambiguous;
+    const rootMatch = trimmed.match(/^([A-Za-z_$][A-Za-z0-9_$]*)([\s\S]*)$/);
+    if (!(scopeMap instanceof Map)) {
+        return normalizeTypeScriptExpression(trimmed);
+    }
+    if (!rootMatch) {
+        return rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
+    }
+    const root = rootMatch[1];
+    if (scopeAmbiguous instanceof Set && scopeAmbiguous.has(root)) {
+        return rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
+    }
+    const rewrittenRoot = scopeMap.get(root);
+    if (typeof rewrittenRoot !== 'string' || rewrittenRoot.length === 0 || rewrittenRoot === root) {
+        return rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
+    }
+    if (rootMatch[2].trim().length === 0) {
+        return normalizeTypeScriptExpression(rewrittenRoot);
+    }
+    const rewrittenExpr = rewriteIdentifiersWithinExpression(trimmed, scopeMap, scopeAmbiguous);
+    return typeof rewrittenExpr === 'string' && rewrittenExpr.length > 0
+        ? rewrittenExpr
+        : normalizeTypeScriptExpression(`${rewrittenRoot}${rootMatch[2]}`);
+}
+/**
+ * @param {string | null | undefined} compiledExpr
+ * @param {{
+ *   signals?: Array<{ state_index?: number }>,
+ *   stateBindings?: Array<{ key?: string }>
+ * } | null | undefined} expressionRewrite
+ * @returns {string | null}
+ */
+export function resolveCompiledPropsExpression(compiledExpr, expressionRewrite = null) {
+    const source = typeof compiledExpr === 'string' ? compiledExpr.trim() : '';
+    if (!source) {
+        return null;
+    }
+    const signals = Array.isArray(expressionRewrite?.signals) ? expressionRewrite.signals : [];
+    const stateBindings = Array.isArray(expressionRewrite?.stateBindings) ? expressionRewrite.stateBindings : [];
+    const resolved = source.replace(/signalMap\.get\((\d+)\)(?:\.get\(\))?/g, (full, rawIndex) => {
+        const signalIndex = Number.parseInt(rawIndex, 10);
+        if (!Number.isInteger(signalIndex)) {
+            return full;
+        }
+        const signal = signals[signalIndex];
+        const stateIndex = signal?.state_index;
+        const stateKey = Number.isInteger(stateIndex) ? stateBindings[stateIndex]?.key : null;
+        if (typeof stateKey !== 'string' || stateKey.length === 0) {
+            return full;
+        }
+        return full.endsWith('.get()') ? `${stateKey}.get()` : stateKey;
+    });
+    return normalizeTypeScriptExpression(resolved);
+}
+/**
+ * @param {string} expr
+ * @param {{
+ *   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,
+ *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ * } | null} rewriteContext
+ * @returns {string}
+ */
+export function resolvePropsValueCode(expr, rewriteContext = null) {
+    const trimmed = String(expr || '').trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    const expressionRewrite = rewriteContext?.expressionRewrite;
+    const expressionAmbiguous = expressionRewrite?.ambiguous;
+    if (!(expressionAmbiguous instanceof Set && expressionAmbiguous.has(trimmed))) {
+        const binding = expressionRewrite?.bindings instanceof Map
+            ? expressionRewrite.bindings.get(trimmed)
+            : null;
+        const compiled = resolveCompiledPropsExpression(binding?.compiled_expr, expressionRewrite);
+        if (typeof compiled === 'string' && compiled.length > 0) {
+            return compiled;
+        }
+        const exact = expressionRewrite?.map instanceof Map
+            ? expressionRewrite.map.get(trimmed)
+            : null;
+        if (typeof exact === 'string' && exact.length > 0) {
+            return normalizeTypeScriptExpression(exact);
+        }
+    }
+    return rewritePropsExpression(trimmed, rewriteContext);
+}
+/**
+ * @param {string} attrs
+ * @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 renderPropsLiteralFromAttrs(attrs, rewriteContext = null) {
+    const src = String(attrs || '').trim();
+    if (!src) {
+        return '{}';
+    }
+    const entries = [];
+    const attrRe = /([A-Za-z_$][A-Za-z0-9_$-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|\{([\s\S]*?)\}))?/g;
+    let match;
+    while ((match = attrRe.exec(src)) !== null) {
+        const rawName = match[1];
+        if (!rawName || rawName.startsWith('on:')) {
+            continue;
+        }
+        const doubleQuoted = match[2];
+        const singleQuoted = match[3];
+        const expressionValue = match[4];
+        let valueCode = 'true';
+        if (doubleQuoted !== undefined) {
+            valueCode = JSON.stringify(doubleQuoted);
+        }
+        else if (singleQuoted !== undefined) {
+            valueCode = JSON.stringify(singleQuoted);
+        }
+        else if (expressionValue !== undefined) {
+            const trimmed = String(expressionValue).trim();
+            valueCode = trimmed.length > 0 ? resolvePropsValueCode(trimmed, rewriteContext) : 'undefined';
+        }
+        entries.push(`${renderObjectKey(rawName)}: ${valueCode}`);
+    }
+    if (entries.length === 0) {
+        return '{}';
+    }
+    return `{ ${entries.join(', ')} }`;
+}
+/**
+ * @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
+ * } | null} rewriteContext
+ * @returns {string}
+ */
+export function injectPropsPrelude(source, attrs, rewriteContext = null) {
+    if (typeof source !== 'string' || source.trim().length === 0) {
+        return source;
+    }
+    if (!/\bprops\b/.test(source)) {
+        return source;
+    }
+    if (/\b(?:const|let|var)\s+props\b/.test(source)) {
+        return source;
+    }
+    const propsLiteral = renderPropsLiteralFromAttrs(attrs, rewriteContext);
+    return `var props = ${propsLiteral};\n${source}`;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * @param {string} source
+ * @param {string} sourceFile
+ * @param {object} [compilerOpts]
+ * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null }}
+ */
+export function extractServerScript(source: string, sourceFile: string, compilerOpts?: object): {
+    source: string;
+    serverScript: {
+        source: string;
+        prerender: boolean;
+        has_guard: boolean;
+        has_load: boolean;
+        source_path: string;
+    } | null;
+};
+/**
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string | null} [ownerPath]
+ * @returns {Map<string, Array<{ attrs: string, ownerPath: string | null }>>}
+ */
+export function collectComponentUsageAttrs(source: string, registry: Map<string, string>, ownerPath?: string | null): Map<string, Array<{
+    attrs: string;
+    ownerPath: string | null;
+}>>;
+/**
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string | null} [ownerPath]
+ * @param {Set<string>} [visitedFiles]
+ * @param {Map<string, Array<{ attrs: string, ownerPath: string | null }>>} [out]
+ * @returns {Map<string, Array<{ attrs: string, ownerPath: string | null }>>}
+ */
+export function collectRecursiveComponentUsageAttrs(source: string, registry: Map<string, string>, ownerPath?: string | null, visitedFiles?: Set<string>, out?: Map<string, Array<{
+    attrs: string;
+    ownerPath: string | null;
+}>>): Map<string, Array<{
+    attrs: string;
+    ownerPath: string | null;
+}>>;