@zenithbuild/cli 0.7.11 → 0.7.12

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

@@ -4,6 +4,7 @@ import { cloneComponentIrForInstance } from '../component-instance-ir.js';
 import { renderPropsLiteralFromAttrs } from './scoped-identifier-rewrite.js';
 import { extractTemplate, isDocumentMode } from '../resolve-components.js';
 import { buildComponentExpressionRewrite, mergeExpressionRewriteMaps, resolveStateKeyFromBindings } from './expression-rewrites.js';
+import { applyScopedDataContextToExpressionRewrite, resolveScopedExpressionContext } from './scoped-expression-context.js';
 import { mergeComponentIr } from './merge-component-ir.js';
 import { stripStyleBlocks } from './compiler-runtime.js';
 import { extractDeclaredIdentifiers } from './typescript-expression-utils.js';
@@ -17,6 +18,55 @@ function createEmptyExpressionRewrite() {
         sequence: []
     };
 }
+const SERVER_CONST_RE = /(?:^|\n)\s*const\s+([A-Za-z_$][\w$]*)\s*=/g;
+function stripOwnerServerBlocks(source) {
+    return String(source || '').replace(/<script\b([^>]*)>([\s\S]*?)<\/script>/gi, (full, attrs) => {
+        if (/\bserver\b/i.test(String(attrs || ''))) {
+            return '';
+        }
+        return full;
+    });
+}
+function collectServerConstNames(source) {
+    const names = [];
+    for (const match of String(source || '').matchAll(SERVER_CONST_RE)) {
+        const name = String(match[1] || '');
+        if (name && !names.includes(name)) {
+            names.push(name);
+        }
+    }
+    return names;
+}
+function createClientPlaceholderPrelude(source, strippedSource) {
+    const names = [];
+    String(source || '').replace(/<script\b([^>]*)>([\s\S]*?)<\/script>/gi, (full, attrs, body) => {
+        if (/\bserver\b/i.test(String(attrs || ''))) {
+            for (const name of collectServerConstNames(body)) {
+                const refRe = new RegExp(`\\b${escapeRegExp(name)}\\b`);
+                if (refRe.test(strippedSource) && !names.includes(name)) {
+                    names.push(name);
+                }
+            }
+        }
+        return full;
+    });
+    if (names.length === 0) {
+        return '';
+    }
+    return [
+        '<script lang="ts">',
+        ...names.map((name) => `const ${name} = undefined;`),
+        '</script>',
+        ''
+    ].join('\n');
+}
+function prepareOwnerClientCompileSource(source) {
+    const strippedSource = stripOwnerServerBlocks(source);
+    return stripStyleBlocks(`${createClientPlaceholderPrelude(source, strippedSource)}${strippedSource}`);
+}
+function escapeRegExp(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 async function resolveComponentIr({ compPath, componentSource, compilerOpts, compilerBin, timedRunCompiler, cooperativeYield, componentIrCache, compilerTotals, pageStats, startupProfile, emitCompilerWarning }) {
     let compIr;
     if (componentIrCache.has(compPath)) {
@@ -27,7 +77,7 @@ async function resolveComponentIr({ compPath, componentSource, compilerOpts, com
     else {
         await cooperativeYield();
         const componentCompileStartedAt = performance.now();
-        compIr = timedRunCompiler('component', compPath, stripStyleBlocks(componentSource), compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
+        compIr = timedRunCompiler('component', compPath, prepareOwnerClientCompileSource(componentSource), compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
         pageStats.pageComponentCompileMs += startupProfile.roundMs(performance.now() - componentCompileStartedAt);
         compilerTotals.componentCacheMisses += 1;
         pageStats.pageComponentCacheMisses += 1;
@@ -72,7 +122,7 @@ async function resolveOwnerRewriteContext({ occurrence, sourceFile, compilerOpts
         pageComponentLoopBreakdown.ownerSourceReadMs += startupProfile.roundMs(performance.now() - ownerSourceReadStartedAt);
         await cooperativeYield();
         const ownerCompileStartedAt = performance.now();
-        ownerIr = timedRunCompiler('component', ownerPath, stripStyleBlocks(ownerSource), compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
+        ownerIr = timedRunCompiler('component', ownerPath, prepareOwnerClientCompileSource(ownerSource), compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
         pageStats.pageComponentCompileMs += startupProfile.roundMs(performance.now() - ownerCompileStartedAt);
         compilerTotals.componentCacheMisses += 1;
         pageStats.pageComponentCacheMisses += 1;
@@ -136,6 +186,7 @@ export async function buildPageOwnerContext({ componentOccurrences, sourceFile,
 }
 export async 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 }) {
     let componentInstanceCounter = 0;
+    const scopedOccurrenceIndexByOwnerKey = new Map();
     for (const occurrence of componentOccurrences) {
         await cooperativeYield();
         const compName = occurrence.name;
@@ -146,7 +197,9 @@ export async function runPageComponentLoop({ componentOccurrences, occurrenceCou
         const componentSourceReadStartedAt = performance.now();
         const componentSource = readFileSync(compPath, 'utf8');
         pageComponentLoopBreakdown.componentSourceReadMs += startupProfile.roundMs(performance.now() - componentSourceReadStartedAt);
-        const occurrenceCount = occurrenceCountByPath.get(compPath) || 0;
+        const occurrenceCount = occurrenceCountByPath.get(compPath)
+            || occurrenceCountByPath.get(compName)
+            || 0;
         const compIr = await resolveComponentIr({
             compPath,
             componentSource,
@@ -175,6 +228,10 @@ export async function runPageComponentLoop({ componentOccurrences, occurrenceCou
             pageComponentLoopBreakdown,
             startupProfile
         });
+        const scopedContext = resolveScopedExpressionContext(pageIr, compPath, scopedOccurrenceIndexByOwnerKey);
+        const scopedExpressionRewrite = scopedContext
+            ? applyScopedDataContextToExpressionRewrite(expressionRewrite, scopedContext)
+            : expressionRewrite;
         const { attrExpressionRewrite } = await resolveOwnerRewriteContext({
             occurrence,
             sourceFile,
@@ -220,13 +277,16 @@ export async function runPageComponentLoop({ componentOccurrences, occurrenceCou
         }, seenStaticImports, knownRefKeys, pageIrMergeCache, pageMergeBreakdown, hoistedCodeTransformCache);
         pagePhase.mergeMs += startupProfile.roundMs(performance.now() - mergeStartedAt);
         if (useIsolatedInstance) {
+            const scopedInstanceRewrite = scopedContext
+                ? applyScopedDataContextToExpressionRewrite(instanceState.instanceRewrite, scopedContext)
+                : instanceState.instanceRewrite;
             componentOccurrencePlans.push({
-                rewrite: instanceState.instanceRewrite,
-                expressionSequence: instanceState.instanceRewrite.sequence,
+                rewrite: scopedInstanceRewrite,
+                expressionSequence: scopedInstanceRewrite.sequence,
                 refSequence: instanceState.refIdentifierPairs
             });
             continue;
         }
-        mergeExpressionRewriteMaps(pageExpressionRewriteMap, pageExpressionBindingMap, pageAmbiguousExpressionMap, expressionRewrite, pageIrMergeCache, pageBindingResolutionBreakdown);
+        mergeExpressionRewriteMaps(pageExpressionRewriteMap, pageExpressionBindingMap, pageAmbiguousExpressionMap, scopedExpressionRewrite, pageIrMergeCache, pageBindingResolutionBreakdown);
     }
 }

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

@@ -50,6 +50,12 @@ export function applyExpressionRewrites(pageIr, expressionMap, bindingMap, ambig
         if (rewritten && rewritten !== current && bindings[index].literal === current) {
             bindings[index].literal = rewritten;
         }
+        if (rewrittenBinding &&
+            typeof bindings[index].scoped_data_key === 'string' &&
+            bindings[index].scoped_data_key.length > 0 &&
+            !(typeof rewrittenBinding.scoped_data_key === 'string' && rewrittenBinding.scoped_data_key.length > 0)) {
+            continue;
+        }
         if (rewrittenBinding) {
             bindings[index].compiled_expr = rewrittenBinding.compiled_expr;
             bindings[index].signal_index = rewrittenBinding.signal_index;
@@ -57,6 +63,7 @@ export function applyExpressionRewrites(pageIr, expressionMap, bindingMap, ambig
             bindings[index].state_index = rewrittenBinding.state_index;
             bindings[index].component_instance = rewrittenBinding.component_instance;
             bindings[index].component_binding = rewrittenBinding.component_binding;
+            bindings[index].scoped_data_key = rewrittenBinding.scoped_data_key;
         }
         else if (rewritten && rewritten !== current && bindings[index].compiled_expr === current) {
             bindings[index].compiled_expr = rewritten;

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

@@ -169,12 +169,13 @@ export function createPageLoopExecutionState(): {
     envelopes: never[];
 };
 export function preparePageIrForMerge(pageIr: any): void;
-export function applyServerEnvelopeToPageIr({ pageIr, composedServer, entry, srcDir, sourceFile }: {
+export function applyServerEnvelopeToPageIr({ pageIr, composedServer, entry, srcDir, sourceFile, scopedMetadata }: {
     pageIr: any;
     composedServer: any;
     entry: any;
     srcDir: any;
     sourceFile: any;
+    scopedMetadata: any;
 }): void;
 export function buildOccurrenceCountByPath(componentOccurrences: any): Map<any, any>;
 export function createPageBuildState(): {

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

@@ -1,5 +1,6 @@
 import { relative } from 'node:path';
 import { classifyPageRoute } from '../route-classification.js';
+import { assertNoScopedServerBuildErrors } from '../manifest.js';
 import { createBindingResolutionTotals, createComponentLoopPhaseTotals, createMergePhaseTotals, createOccurrenceApplyPhaseTotals, createPagePhaseTotals, createScopedRewritePhaseTotals } from './page-loop-metrics.js';
 export function createPageLoopState() {
     return {
@@ -47,10 +48,12 @@ export function preparePageIrForMerge(pageIr) {
     pageIr.hoisted.state = pageIr.hoisted.state || [];
     pageIr.hoisted.code = pageIr.hoisted.code || [];
 }
-export function applyServerEnvelopeToPageIr({ pageIr, composedServer, entry, srcDir, sourceFile }) {
+export function applyServerEnvelopeToPageIr({ pageIr, composedServer, entry, srcDir, sourceFile, scopedMetadata }) {
+    assertNoScopedServerBuildErrors(scopedMetadata.diagnostics, entry.file);
     const classification = classifyPageRoute({
         file: entry.file,
-        serverScript: composedServer.serverScript
+        serverScript: composedServer.serverScript,
+        hasScopedServerData: scopedMetadata.hasScopedServerData
     });
     if (composedServer.serverScript) {
         const { has_action: _unusedHasAction, export_paths: _unusedExportPaths, ...serverScript } = composedServer.serverScript;
@@ -63,6 +66,10 @@ export function applyServerEnvelopeToPageIr({ pageIr, composedServer, entry, src
     pageIr.has_guard = classification.hasGuard;
     pageIr.has_load = classification.hasLoad;
     pageIr.has_action = classification.hasAction;
+    pageIr.has_scoped_server_data = scopedMetadata.hasScopedServerData;
+    pageIr.scoped_server_data = scopedMetadata.hasScopedServerData
+        ? scopedMetadata.scopedServerData
+        : [];
     pageIr.guard_module_ref = composedServer.guardPath ? relative(srcDir, composedServer.guardPath).replaceAll('\\', '/') : null;
     pageIr.load_module_ref = composedServer.loadPath ? relative(srcDir, composedServer.loadPath).replaceAll('\\', '/') : null;
     pageIr.action_module_ref = composedServer.actionPath ? relative(srcDir, composedServer.actionPath).replaceAll('\\', '/') : null;

package/dist/build/page-loop.js

@@ -14,6 +14,7 @@ import { deferComponentRuntimeBlock } from './hoisted-code-transforms.js';
 import { addBreakdown, emitPageLoopSummary, recordPageProfile } from './page-loop-metrics.js';
 import { applyServerEnvelopeToPageIr, buildOccurrenceCountByPath, createPageBuildState, createPageLoopCaches, createPageLoopExecutionState } from './page-loop-state.js';
 import { extractServerScript } from './server-script.js';
+import { analyzeRouteScopedServerMetadata } from '../manifest.js';
 /**
  * @param {{
  *   manifest: Array<{ path: string, file: string }>
@@ -78,12 +79,20 @@ export async function buildPageEnvelopes(input) {
             adjacentLoadPath: adjacentLoad,
             adjacentActionPath: adjacentAction
         });
+        const scopedMetadata = analyzeRouteScopedServerMetadata({
+            pageSource: rawSource,
+            pageFile: sourceFile,
+            registry,
+            srcDir,
+            compilerOpts
+        });
         applyServerEnvelopeToPageIr({
             pageIr,
             composedServer,
             entry,
             srcDir,
-            sourceFile
+            sourceFile,
+            scopedMetadata
         });
         const pageIrMergeCache = createPageIrMergeCache(pageIr);
         const seenStaticImports = new Set();

package/dist/build/scoped-expression-context.d.ts

@@ -0,0 +1,5 @@
+export function applyScopedDataContextToExpressionRewrite(componentRewrite: any, scopedContext: any): any;
+export function resolveScopedExpressionContext(pageIr: any, compPath: any, occurrenceIndexByOwnerKey: any): {
+    scopedDataKey: any;
+    serializedVariableNames: any;
+} | null;

package/dist/build/scoped-expression-context.js

@@ -0,0 +1,133 @@
+function escapeRegExp(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function scopedDataKey(scopedContext) {
+    return typeof scopedContext?.scopedDataKey === 'string' && scopedContext.scopedDataKey.length > 0
+        ? scopedContext.scopedDataKey
+        : null;
+}
+function scopedDataExpressionForSource(expression, scopedContext) {
+    const match = String(expression || '').trim().match(/^([A-Za-z_$][\w$]*)([\s\S]*)$/);
+    if (!match)
+        return null;
+    const root = match[1];
+    const rest = match[2] || '';
+    if (root === 'data' || root === 'ssr')
+        return `${root}${rest}`;
+    for (const name of Array.isArray(scopedContext?.serializedVariableNames) ? scopedContext.serializedVariableNames : []) {
+        if (typeof name === 'string' &&
+            name.length > 0 &&
+            (root === name || new RegExp(`(?:^|_)${escapeRegExp(name)}(?:__inst\\d+)?$`).test(root))) {
+            return `data.${name}${rest}`;
+        }
+    }
+    return null;
+}
+function scopedExpressionCandidate(raw, rewritten, binding, scopedContext) {
+    if (!scopedDataKey(scopedContext))
+        return null;
+    for (const candidate of [rewritten, binding?.compiled_expr, binding?.literal, raw]) {
+        const scopedExpression = scopedDataExpressionForSource(candidate, scopedContext);
+        if (scopedExpression)
+            return scopedExpression;
+    }
+    return null;
+}
+function createScopedBinding(scopedExpression, scopedContext, baseBinding = null) {
+    return scopedExpression
+        ? {
+            ...(baseBinding && typeof baseBinding === 'object' ? baseBinding : {}),
+            compiled_expr: scopedExpression,
+            literal: scopedExpression,
+            signal_index: null,
+            signal_indices: [],
+            state_index: null,
+            component_instance: null,
+            component_binding: null,
+            scoped_data_key: scopedDataKey(scopedContext)
+        }
+        : null;
+}
+function applyScopedContextToBinding(binding, scopedContext, fallbackExpression = null) {
+    if (!binding || typeof binding !== 'object' || !scopedDataKey(scopedContext))
+        return binding;
+    const scopedExpression = scopedDataExpressionForSource(binding.compiled_expr, scopedContext)
+        || scopedDataExpressionForSource(binding.literal, scopedContext)
+        || scopedDataExpressionForSource(fallbackExpression, scopedContext);
+    return scopedExpression ? createScopedBinding(scopedExpression, scopedContext, binding) : binding;
+}
+function hasScopedBinding(binding) {
+    return typeof binding?.scoped_data_key === 'string' && binding.scoped_data_key.length > 0;
+}
+export function applyScopedDataContextToExpressionRewrite(componentRewrite, scopedContext) {
+    if (!componentRewrite || !scopedDataKey(scopedContext))
+        return componentRewrite;
+    const next = {
+        map: new Map(),
+        bindings: new Map(),
+        signals: componentRewrite.signals,
+        stateBindings: componentRewrite.stateBindings,
+        ambiguous: new Set(componentRewrite.ambiguous),
+        sequence: []
+    };
+    for (const item of Array.isArray(componentRewrite.sequence) ? componentRewrite.sequence : []) {
+        const scopedBinding = applyScopedContextToBinding(item.binding, scopedContext, item.rewritten || item.raw);
+        const scopedExpression = scopedExpressionCandidate(item.raw, item.rewritten, scopedBinding, scopedContext);
+        next.sequence.push({
+            raw: item.raw,
+            rewritten: scopedExpression || item.rewritten,
+            binding: hasScopedBinding(scopedBinding)
+                ? scopedBinding
+                : createScopedBinding(scopedExpression, scopedContext)
+        });
+    }
+    for (const [raw, binding] of componentRewrite.bindings.entries()) {
+        next.bindings.set(raw, applyScopedContextToBinding(binding, scopedContext, raw));
+    }
+    for (const [raw, rewritten] of componentRewrite.map.entries()) {
+        const binding = next.bindings.get(raw);
+        next.map.set(raw, scopedExpressionCandidate(raw, rewritten, binding, scopedContext) || rewritten);
+    }
+    return next;
+}
+function normalizeSourcePath(value) {
+    return String(value || '').replaceAll('\\', '/');
+}
+function ownerKeyMatchesPath(ownerKey, filePath) {
+    const key = normalizeSourcePath(ownerKey);
+    const file = normalizeSourcePath(filePath);
+    return key.length > 0 && (file === key || file.endsWith(`/${key}`));
+}
+export function resolveScopedExpressionContext(pageIr, compPath, occurrenceIndexByOwnerKey) {
+    const entries = Array.isArray(pageIr?.scoped_server_data) ? pageIr.scoped_server_data : [];
+    const matches = entries.filter((entry) => entry &&
+        typeof entry === 'object' &&
+        (entry.ownerKind === 'layout' || entry.ownerKind === 'component') &&
+        ownerKeyMatchesPath(entry.ownerKey, compPath));
+    const entry = matches.length === 1 ? matches[0] : null;
+    if (!entry || typeof entry.ownerKey !== 'string')
+        return null;
+    let scopedDataKey = null;
+    if (entry.ownerKind === 'layout') {
+        scopedDataKey = `layout:${entry.ownerKey}`;
+    }
+    else if (entry.ownerKind === 'component' && entry.instanceStrategy === 'per-instance') {
+        const index = occurrenceIndexByOwnerKey.get(entry.ownerKey) || 0;
+        occurrenceIndexByOwnerKey.set(entry.ownerKey, index + 1);
+        const instance = Array.isArray(entry.instances) ? entry.instances[index] : null;
+        scopedDataKey = typeof instance?.key === 'string' && instance.key.length > 0
+            ? instance.key
+            : `component:${entry.ownerKey}:o${index}`;
+    }
+    else if (entry.ownerKind === 'component') {
+        scopedDataKey = `component:${entry.ownerKey}`;
+    }
+    return scopedDataKey
+        ? {
+            scopedDataKey,
+            serializedVariableNames: Array.isArray(entry.serializedVariableNames)
+                ? entry.serializedVariableNames
+                : []
+        }
+        : null;
+}

package/dist/build/type-declarations.d.ts

@@ -4,13 +4,14 @@
  */
 export function deriveProjectRootFromPagesDir(pagesDir: string): string;
 /**
- * @param {{ manifest: Array<{ path: string, file: string }>, pagesDir: string }} input
+ * @param {{ manifest: Array<{ path: string, file: string, scoped_server_data?: import('../scoped-server-data/types.js').ManifestScopedServerDataEntry[] }>, pagesDir: string }} input
  * @returns {Promise<void>}
  */
 export function ensureZenithTypeDeclarations(input: {
     manifest: Array<{
         path: string;
         file: string;
+        scoped_server_data?: import("../scoped-server-data/types.js").ManifestScopedServerDataEntry[];
     }>;
     pagesDir: string;
 }): Promise<void>;

package/dist/build/type-declarations.js

@@ -2,6 +2,8 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
 import { renderZenithEnvDts } from '../types/zenith-env-dts.js';
+const SCOPED_SERVER_TYPE_DECLARATIONS_HELPER_UNAVAILABLE = '[Zenith:ScopedServerData] Type declaration helper is unavailable. Run the CLI build step before generating scoped server data type declarations.';
+let scopedTypeDeclarationRendererPromise = null;
 /**
  * @param {string} targetPath
  * @param {string} next
@@ -61,6 +63,27 @@ function renderZenithRouteDts(manifest) {
     lines.push('');
     return `${lines.join('\n')}\n`;
 }
+/**
+ * @returns {Promise<(input: { manifest: Array<{ scoped_server_data?: import('../scoped-server-data/types.js').ManifestScopedServerDataEntry[] }>, srcDir: string }) => string>}
+ */
+async function getScopedServerDataTypeRenderer() {
+    if (!scopedTypeDeclarationRendererPromise) {
+        scopedTypeDeclarationRendererPromise = import('../scoped-server-data/type-declarations.js')
+            .then((helper) => {
+            if (typeof helper.renderScopedServerDataDts !== 'function') {
+                throw new Error(SCOPED_SERVER_TYPE_DECLARATIONS_HELPER_UNAVAILABLE);
+            }
+            return helper.renderScopedServerDataDts;
+        })
+            .catch((error) => {
+            if (error && error.message === SCOPED_SERVER_TYPE_DECLARATIONS_HELPER_UNAVAILABLE) {
+                throw error;
+            }
+            throw new Error(SCOPED_SERVER_TYPE_DECLARATIONS_HELPER_UNAVAILABLE);
+        });
+    }
+    return scopedTypeDeclarationRendererPromise;
+}
 /**
  * @param {string} pagesDir
  * @returns {string}
@@ -74,17 +97,24 @@ export function deriveProjectRootFromPagesDir(pagesDir) {
     return parent;
 }
 /**
- * @param {{ manifest: Array<{ path: string, file: string }>, pagesDir: string }} input
+ * @param {{ manifest: Array<{ path: string, file: string, scoped_server_data?: import('../scoped-server-data/types.js').ManifestScopedServerDataEntry[] }>, pagesDir: string }} input
  * @returns {Promise<void>}
  */
 export async function ensureZenithTypeDeclarations(input) {
     const projectRoot = deriveProjectRootFromPagesDir(input.pagesDir);
+    const srcDir = dirname(resolve(input.pagesDir));
     const zenithDir = resolve(projectRoot, '.zenith');
     await mkdir(zenithDir, { recursive: true });
     const envPath = join(zenithDir, 'zenith-env.d.ts');
     const routesPath = join(zenithDir, 'zenith-routes.d.ts');
+    const scopedPath = join(zenithDir, 'zenith-scoped-server-data.d.ts');
+    const renderScopedServerDataDts = await getScopedServerDataTypeRenderer();
     writeIfChanged(envPath, renderZenithEnvDts());
     writeIfChanged(routesPath, renderZenithRouteDts(input.manifest));
+    writeIfChanged(scopedPath, renderScopedServerDataDts({
+        manifest: input.manifest,
+        srcDir
+    }));
     const tsconfigPath = resolve(projectRoot, 'tsconfig.json');
     if (!existsSync(tsconfigPath)) {
         return;

package/dist/build-output-manifest.d.ts

@@ -1,15 +1,11 @@
-export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath }: {
+export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath, globalMiddleware }: {
     coreOutputDir: any;
     staticDir: any;
     target: any;
     routeManifest: any;
     basePath?: string | undefined;
+    globalMiddleware?: null | undefined;
 }): Promise<{
-    schema_version: number;
-    zenith_version: any;
-    target: any;
-    base_path: string;
-    content_hash: any;
     routes: {
         html: any;
         assets: any[];
@@ -26,4 +22,12 @@ export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, rou
         css: any[];
         vendor: any;
     };
+    global_middleware?: {
+        source_file: any;
+    } | undefined;
+    schema_version: number;
+    zenith_version: any;
+    target: any;
+    base_path: string;
+    content_hash: any;
 }>;

package/dist/build-output-manifest.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { normalizeGlobalMiddlewareMetadata } from './global-middleware.js';
 const CLI_VERSION = (() => {
     try {
         const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
@@ -39,7 +40,7 @@ async function readRouteHtml(staticDir, htmlPath) {
         return '';
     }
 }
-export async function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath = '/' }) {
+export async function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath = '/', globalMiddleware = null }) {
     const bundlerManifest = await readJson(join(staticDir, 'manifest.json'), {});
     const routerManifest = await readJson(join(staticDir, 'assets', 'router-manifest.json'), { routes: [] });
     const routeByPath = new Map((Array.isArray(routerManifest.routes) ? routerManifest.routes : []).map((entry) => [entry.path, entry]));
@@ -85,12 +86,14 @@ export async function writeBuildOutputManifest({ coreOutputDir, staticDir, targe
         bundlerManifest.css,
         ...routeAssetCss
     ].filter((value) => typeof value === 'string' && value.endsWith('.css')));
+    const globalMiddlewareMetadata = normalizeGlobalMiddlewareMetadata(globalMiddleware);
     const buildManifest = {
         schema_version: 1,
         zenith_version: CLI_VERSION,
         target,
         base_path: basePath,
         content_hash: typeof bundlerManifest.hash === 'string' ? bundlerManifest.hash : '',
+        ...(globalMiddlewareMetadata ? { global_middleware: globalMiddlewareMetadata } : {}),
         routes,
         assets: {
             js: [...jsAssets].sort(),

package/dist/build.js

@@ -16,6 +16,7 @@ import { createImageRuntimePayload, injectImageRuntimePayloadIntoHtmlFiles } fro
 import { supportsTargetRouteCheck } from './route-check-support.js';
 import { createStartupProfiler } from './startup-profile.js';
 import { writeServerOutput } from './server-output.js';
+import { resolveGlobalMiddleware } from './global-middleware.js';
 import { resolveBundlerBin } from './toolchain-paths.js';
 import { createBundlerToolchain, createCompilerToolchain, ensureToolchainCompatibility, getActiveToolchainCandidate } from './toolchain-runner.js';
 import { maybeWarnAboutZenithVersionMismatch } from './version-check.js';
@@ -75,6 +76,7 @@ export async function build(options) {
         }));
     }
     const registry = startupProfile.measureSync('build_component_registry', () => buildComponentRegistry(srcDir));
+    const globalMiddleware = await startupProfile.measureAsync('resolve_global_middleware', () => resolveGlobalMiddleware({ projectRoot, pagesDir, target }));
     const manifest = await startupProfile.measureAsync('generate_manifest', () => generateManifest(pagesDir, '.zen', { compilerOpts }));
     const pageManifest = manifest.filter((entry) => entry?.route_kind !== 'resource');
     if (mode !== 'legacy') {
@@ -136,14 +138,21 @@ export async function build(options) {
         staticDir: staticOutputDir,
         target,
         routeManifest: pageManifest,
-        basePath
+        basePath,
+        globalMiddleware: globalMiddleware?.metadata || null
     }));
     await startupProfile.measureAsync('write_server_output', () => writeServerOutput({
         coreOutputDir,
         staticDir: staticOutputDir,
         projectRoot,
         config,
-        basePath
+        basePath,
+        globalMiddleware: globalMiddleware?.metadata || null,
+        pageManifest,
+        pagesDir,
+        srcDir,
+        registry,
+        compilerOpts
     }));
     await startupProfile.measureAsync('adapt_output', () => adapter.adapt({ coreOutput: coreOutputDir, outDir, manifest: buildManifest, config }));
     const assets = await startupProfile.measureAsync('collect_assets', () => collectAssets(outDir));

package/dist/component-instance-ir.js

@@ -388,6 +388,7 @@ export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBind
                     binding.state_index = resolved.state_index;
                     binding.component_instance = resolved.component_instance;
                     binding.component_binding = resolved.component_binding;
+                    binding.scoped_data_key = resolved.scoped_data_key;
                 }
             }
             exprCursor = found + 1;

package/dist/component-occurrences.d.ts

@@ -4,3 +4,12 @@ export function collectExpandedComponentOccurrences(source: any, registry: any,
     ownerPath: string;
     componentPath: string;
 }[];
+/**
+ * Unique layout/component `.zen` paths reachable from a page dependency graph.
+ *
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string} sourceFile
+ * @returns {string[]}
+ */
+export function collectReachableOwnerPaths(source: string, registry: Map<string, string>, sourceFile: string): string[];

package/dist/component-occurrences.js

@@ -10,6 +10,24 @@ export function collectExpandedComponentOccurrences(source, registry, sourceFile
     }, [], occurrences);
     return occurrences;
 }
+/**
+ * Unique layout/component `.zen` paths reachable from a page dependency graph.
+ *
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string} sourceFile
+ * @returns {string[]}
+ */
+export function collectReachableOwnerPaths(source, registry, sourceFile) {
+    const occurrences = collectExpandedComponentOccurrences(source, registry, sourceFile);
+    const paths = new Set();
+    for (const occurrence of occurrences) {
+        if (occurrence.componentPath) {
+            paths.add(occurrence.componentPath);
+        }
+    }
+    return [...paths];
+}
 function walkSource(source, registry, context, chain, occurrences) {
     let cursor = 0;
     while (cursor < source.length) {

package/dist/config-plugins.d.ts

@@ -0,0 +1,12 @@
+export function normalizePlugins(value: any): ({
+    name: any;
+    config: any;
+} | {
+    name: any;
+    config?: undefined;
+})[];
+export function assertPluginConfigPatch(value: any): void;
+export function cloneConfigValue(value: any, seen?: Map<any, any>): any;
+export function deepFreeze(value: any, seen?: Set<any>): any;
+export function pluginHookError(pluginName: any, hookName: any, error: any): Error;
+export const PLUGIN_CONFIG_PATCH_KEYS: Set<string>;