@zenithbuild/cli 0.7.10 → 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,15 +169,13 @@ export function createPageLoopExecutionState(): {
     envelopes: never[];
 };
 export function preparePageIrForMerge(pageIr: any): void;
-export function applyServerEnvelopeToPageIr({ pageIr, composedServer, hasGuard, hasLoad, hasAction, entry, srcDir, sourceFile }: {
+export function applyServerEnvelopeToPageIr({ pageIr, composedServer, entry, srcDir, sourceFile, scopedMetadata }: {
     pageIr: any;
     composedServer: any;
-    hasGuard: any;
-    hasLoad: any;
-    hasAction: 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,4 +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 {
@@ -46,22 +48,28 @@ export function preparePageIrForMerge(pageIr) {
     pageIr.hoisted.state = pageIr.hoisted.state || [];
     pageIr.hoisted.code = pageIr.hoisted.code || [];
 }
-export function applyServerEnvelopeToPageIr({ pageIr, composedServer, hasGuard, hasLoad, hasAction, 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,
+        hasScopedServerData: scopedMetadata.hasScopedServerData
+    });
     if (composedServer.serverScript) {
         const { has_action: _unusedHasAction, export_paths: _unusedExportPaths, ...serverScript } = composedServer.serverScript;
         pageIr.server_script = serverScript;
-        pageIr.prerender = composedServer.serverScript.prerender === true;
+        pageIr.prerender = classification.prerender;
         if (pageIr.ssr_data === undefined) {
             pageIr.ssr_data = null;
         }
     }
-    if (pageIr.prerender === true && (hasGuard || hasLoad || hasAction)) {
-        throw new Error(`[zenith] Build failed for ${entry.file}: protected routes require SSR/runtime. ` +
-            'Cannot prerender a static route with a `guard`, `load`, or `action` function.');
-    }
-    pageIr.has_guard = hasGuard;
-    pageIr.has_load = hasLoad;
-    pageIr.has_action = hasAction;
+    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 }>
@@ -56,13 +57,20 @@ export async function buildPageEnvelopes(input) {
         const expandedStartedAt = performance.now();
         const { expandedSource } = expandComponents(rawSource, registry, sourceFile);
         pageExpandMs = startupProfile.roundMs(performance.now() - expandedStartedAt);
+        const usesInternalExpandedSource = expandedSource !== rawSource;
+        if (usesInternalExpandedSource) {
+            const rawServerExtracted = extractServerScript(rawSource, sourceFile, compilerOpts);
+            timedRunCompiler('page', sourceFile, rawServerExtracted.source, compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
+        }
         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();
-        let pageIr = timedRunCompiler('page', sourceFile, compileSource, compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
+        let pageIr = timedRunCompiler('page', sourceFile, compileSource, usesInternalExpandedSource
+            ? { ...compilerOpts, internalAllowUnboundMarkup: true }
+            : compilerOpts, { compilerToolchain: compilerBin, onWarning: emitCompilerWarning });
         pageCompileMs = startupProfile.roundMs(performance.now() - pageCompileStartedAt);
         const composedServer = composeServerScriptEnvelope({
             sourceFile,
@@ -71,18 +79,20 @@ export async function buildPageEnvelopes(input) {
             adjacentLoadPath: adjacentLoad,
             adjacentActionPath: adjacentAction
         });
-        const hasGuard = composedServer.serverScript?.has_guard === true;
-        const hasLoad = composedServer.serverScript?.has_load === true;
-        const hasAction = composedServer.serverScript?.has_action === true;
+        const scopedMetadata = analyzeRouteScopedServerMetadata({
+            pageSource: rawSource,
+            pageFile: sourceFile,
+            registry,
+            srcDir,
+            compilerOpts
+        });
         applyServerEnvelopeToPageIr({
             pageIr,
             composedServer,
-            hasGuard,
-            hasLoad,
-            hasAction,
             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/server-script.js

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { findNextKnownComponentTag } from '../component-tag-parser.js';
+import { readRouteHandlerExport } from '../route-handler-export-analysis.js';
 import { extractStaticExportPaths } from '../static-export-paths.js';
 /**
  * @param {string} source
@@ -56,40 +57,25 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
             `  Reason: <script server> block is empty\n` +
             `  Example: export const data = { ... }`);
     }
-    const loadFnMatch = serverSource.match(/\bexport\s+(?:async\s+)?function\s+load\s*\(([^)]*)\)/);
-    const loadConstParenMatch = serverSource.match(/\bexport\s+const\s+load\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>/);
-    const loadConstSingleArgMatch = serverSource.match(/\bexport\s+const\s+load\s*=\s*(?:async\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
-    const hasLoad = Boolean(loadFnMatch || loadConstParenMatch || loadConstSingleArgMatch);
-    const loadMatchCount = Number(Boolean(loadFnMatch)) +
-        Number(Boolean(loadConstParenMatch)) +
-        Number(Boolean(loadConstSingleArgMatch));
-    if (loadMatchCount > 1) {
+    const loadExport = readRouteHandlerExport(serverSource, 'load');
+    const hasLoad = loadExport.hasExport;
+    if (loadExport.matchCount > 1) {
         throw new Error(`Zenith server script contract violation:\n` +
             `  File: ${sourceFile}\n` +
             `  Reason: multiple load exports detected\n` +
             `  Example: keep exactly one export const load = async (ctx) => ({ ... })`);
     }
-    const guardFnMatch = serverSource.match(/\bexport\s+(?:async\s+)?function\s+guard\s*\(([^)]*)\)/);
-    const guardConstParenMatch = serverSource.match(/\bexport\s+const\s+guard\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>/);
-    const guardConstSingleArgMatch = serverSource.match(/\bexport\s+const\s+guard\s*=\s*(?:async\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
-    const hasGuard = Boolean(guardFnMatch || guardConstParenMatch || guardConstSingleArgMatch);
-    const guardMatchCount = Number(Boolean(guardFnMatch)) +
-        Number(Boolean(guardConstParenMatch)) +
-        Number(Boolean(guardConstSingleArgMatch));
-    if (guardMatchCount > 1) {
+    const guardExport = readRouteHandlerExport(serverSource, 'guard');
+    const hasGuard = guardExport.hasExport;
+    if (guardExport.matchCount > 1) {
         throw new Error(`Zenith server script contract violation:\n` +
             `  File: ${sourceFile}\n` +
             `  Reason: multiple guard exports detected\n` +
             `  Example: keep exactly one export const guard = async (ctx) => ({ ... })`);
     }
-    const actionFnMatch = serverSource.match(/\bexport\s+(?:async\s+)?function\s+action\s*\(([^)]*)\)/);
-    const actionConstParenMatch = serverSource.match(/\bexport\s+const\s+action\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>/);
-    const actionConstSingleArgMatch = serverSource.match(/\bexport\s+const\s+action\s*=\s*(?:async\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
-    const hasAction = Boolean(actionFnMatch || actionConstParenMatch || actionConstSingleArgMatch);
-    const actionMatchCount = Number(Boolean(actionFnMatch)) +
-        Number(Boolean(actionConstParenMatch)) +
-        Number(Boolean(actionConstSingleArgMatch));
-    if (actionMatchCount > 1) {
+    const actionExport = readRouteHandlerExport(serverSource, 'action');
+    const hasAction = actionExport.hasExport;
+    if (actionExport.matchCount > 1) {
         throw new Error(`Zenith server script contract violation:\n` +
             `  File: ${sourceFile}\n` +
             `  Reason: multiple action exports detected\n` +
@@ -112,10 +98,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
             `  Example: use only export const data or export const load`);
     }
     if (hasLoad) {
-        const singleArg = String(loadConstSingleArgMatch?.[1] || '').trim();
-        const paramsText = String((loadFnMatch || loadConstParenMatch)?.[1] || '').trim();
-        const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
-        if (arity !== 1) {
+        if (loadExport.arity !== null && loadExport.arity !== 1) {
             throw new Error(`Zenith server script contract violation:\n` +
                 `  File: ${sourceFile}\n` +
                 `  Reason: load(ctx) must accept exactly one argument\n` +
@@ -123,10 +106,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
         }
     }
     if (hasGuard) {
-        const singleArg = String(guardConstSingleArgMatch?.[1] || '').trim();
-        const paramsText = String((guardFnMatch || guardConstParenMatch)?.[1] || '').trim();
-        const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
-        if (arity !== 1) {
+        if (guardExport.arity !== null && guardExport.arity !== 1) {
             throw new Error(`Zenith server script contract violation:\n` +
                 `  File: ${sourceFile}\n` +
                 `  Reason: guard(ctx) must accept exactly one argument\n` +
@@ -134,10 +114,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
         }
     }
     if (hasAction) {
-        const singleArg = String(actionConstSingleArgMatch?.[1] || '').trim();
-        const paramsText = String((actionFnMatch || actionConstParenMatch)?.[1] || '').trim();
-        const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
-        if (arity !== 1) {
+        if (actionExport.arity !== null && actionExport.arity !== 1) {
             throw new Error(`Zenith server script contract violation:\n` +
                 `  File: ${sourceFile}\n` +
                 `  Reason: action(ctx) must accept exactly one argument\n` +

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

@@ -1,6 +1,9 @@
 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,58 +64,25 @@ function renderZenithRouteDts(manifest) {
     return `${lines.join('\n')}\n`;
 }
 /**
- * @returns {string}
+ * @returns {Promise<(input: { manifest: Array<{ scoped_server_data?: import('../scoped-server-data/types.js').ManifestScopedServerDataEntry[] }>, srcDir: string }) => string>}
  */
-function renderZenithEnvDts() {
-    return [
-        '// Auto-generated by Zenith CLI. Do not edit manually.',
-        'export {};',
-        '',
-        'declare global {',
-        '  namespace Zenith {',
-        '    type Params = Record<string, string>;',
-        '',
-        '    interface ErrorState {',
-        '      status?: number;',
-        '      code?: string;',
-        '      message: string;',
-        '    }',
-        '',
-        '    type PageData = Record<string, unknown> & { __zenith_error?: ErrorState };',
-        '',
-        '    interface RouteMeta {',
-        '      id: string;',
-        '      file: string;',
-        '      pattern: string;',
-        '    }',
-        '',
-        '    interface LoadContext {',
-        '      params: Params;',
-        '      url: URL;',
-        '      request: Request;',
-        '      route: RouteMeta;',
-        '    }',
-        '',
-        '    type Load<T extends PageData = PageData> = (ctx: LoadContext) => Promise<T> | T;',
-        '',
-        '    interface Fragment {',
-        '      __zenith_fragment: true;',
-        '      mount: (anchor: Node | null) => void;',
-        '      unmount: () => void;',
-        '    }',
-        '',
-        '    type Renderable =',
-        '      | string',
-        '      | number',
-        '      | boolean',
-        '      | null',
-        '      | undefined',
-        '      | Renderable[]',
-        '      | Fragment;',
-        '  }',
-        '}',
-        ''
-    ].join('\n');
+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
@@ -127,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;