@zenithbuild/cli 0.7.10 → 0.7.12

package/dist/route-classification.js

@@ -0,0 +1,21 @@
+export function classifyPageRoute({ file, serverScript, hasScopedServerData = false }) {
+    const hasGuard = serverScript?.has_guard === true;
+    const hasLoad = serverScript?.has_load === true;
+    const hasAction = serverScript?.has_action === true;
+    const prerender = serverScript?.prerender === true;
+    if (prerender && (hasGuard || hasLoad || hasAction)) {
+        throw new Error(`[zenith] Build failed for ${file}: protected routes require SSR/runtime. ` +
+            'Cannot prerender a static route with a `guard`, `load`, or `action` function.');
+    }
+    if (prerender && hasScopedServerData) {
+        throw new Error(`[zenith] Build failed for ${file}: CSV012 scoped server data cannot be combined with prerender=true in v1.`);
+    }
+    const needsServerRender = !prerender && (Boolean(serverScript) || hasScopedServerData);
+    return {
+        prerender,
+        renderMode: needsServerRender ? 'server' : 'prerender',
+        hasGuard,
+        hasLoad,
+        hasAction
+    };
+}

package/dist/route-handler-export-analysis.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @param {string} source
+ * @param {'guard' | 'load' | 'action'} name
+ * @returns {{
+ *   fnMatch: RegExpMatchArray | null,
+ *   constParenMatch: RegExpMatchArray | null,
+ *   constSingleArgMatch: RegExpMatchArray | null,
+ *   constMiddlewareMatch: RegExpMatchArray | null,
+ *   hasExport: boolean,
+ *   matchCount: number,
+ *   arity: number | null
+ * }}
+ */
+export function readRouteHandlerExport(source: string, name: "guard" | "load" | "action"): {
+    fnMatch: RegExpMatchArray | null;
+    constParenMatch: RegExpMatchArray | null;
+    constSingleArgMatch: RegExpMatchArray | null;
+    constMiddlewareMatch: RegExpMatchArray | null;
+    hasExport: boolean;
+    matchCount: number;
+    arity: number | null;
+};

package/dist/route-handler-export-analysis.js

@@ -0,0 +1,41 @@
+function routeHandlerExportPattern(name, tail) {
+    return new RegExp(`\\bexport\\s+const\\s+${name}\\s*=\\s*${tail}`);
+}
+/**
+ * @param {string} source
+ * @param {'guard' | 'load' | 'action'} name
+ * @returns {{
+ *   fnMatch: RegExpMatchArray | null,
+ *   constParenMatch: RegExpMatchArray | null,
+ *   constSingleArgMatch: RegExpMatchArray | null,
+ *   constMiddlewareMatch: RegExpMatchArray | null,
+ *   hasExport: boolean,
+ *   matchCount: number,
+ *   arity: number | null
+ * }}
+ */
+export function readRouteHandlerExport(source, name) {
+    const fnMatch = source.match(new RegExp(`\\bexport\\s+(?:async\\s+)?function\\s+${name}\\s*\\(([^)]*)\\)`));
+    const constParenMatch = source.match(routeHandlerExportPattern(name, '(?:async\\s*)?\\(([^)]*)\\)\\s*=>'));
+    const constSingleArgMatch = source.match(routeHandlerExportPattern(name, '(?:async\\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=>'));
+    const constMiddlewareMatch = source.match(routeHandlerExportPattern(name, 'withMiddleware\\s*\\('));
+    const matchCount = Number(Boolean(fnMatch)) +
+        Number(Boolean(constParenMatch)) +
+        Number(Boolean(constSingleArgMatch)) +
+        Number(Boolean(constMiddlewareMatch));
+    let arity = null;
+    if (!constMiddlewareMatch) {
+        const singleArg = String(constSingleArgMatch?.[1] || '').trim();
+        const paramsText = String((fnMatch || constParenMatch)?.[1] || '').trim();
+        arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
+    }
+    return {
+        fnMatch,
+        constParenMatch,
+        constSingleArgMatch,
+        constMiddlewareMatch,
+        hasExport: matchCount > 0,
+        matchCount,
+        arity
+    };
+}

package/dist/scoped-server-data/analyze-owner-file.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerOptsLike, OwnerFileAnalysisResult } from './types.js';
+export declare const RESERVED_LEVEL1_BINDING_NAMES: readonly ["data", "props", "params", "ssr", "ssr_data", "ctx"];
+export declare function analyzeOwnerServerFile(ownerSource: string, ownerPath: string, compilerOpts?: CompilerOptsLike): OwnerFileAnalysisResult;

package/dist/scoped-server-data/analyze-owner-file.js

@@ -0,0 +1,149 @@
+import { readRouteHandlerExport } from '../route-handler-export-analysis.js';
+import { extractTemplate } from '../resolve-components.js';
+import { createScopedServerDiagnostic, SCOPED_SERVER_DIAGNOSTIC } from './diagnostics.js';
+import { partitionScriptBlocks, serverBlockRequiresLangTs } from './parse-owner-server-block.js';
+import { computeSerializationSet } from './serialization-set.js';
+export const RESERVED_LEVEL1_BINDING_NAMES = [
+    'data',
+    'props',
+    'params',
+    'ssr',
+    'ssr_data',
+    'ctx'
+];
+const TOP_LEVEL_CONST_RE = /(?:^|\n)\s*const\s+([A-Za-z_$][\w$]*)\s*=/g;
+const TOP_LEVEL_LET_RE = /(?:^|\n)\s*let\s+([A-Za-z_$][\w$]*)\s*=/g;
+const EXPLICIT_DATA_EXPORT_RE = /\bexport\s+const\s+data\s*=\s*/;
+export function analyzeOwnerServerFile(ownerSource, ownerPath, compilerOpts = {}) {
+    const diagnostics = [];
+    const { serverBlocks, clientBlocks } = partitionScriptBlocks(ownerSource);
+    if (serverBlocks.length === 0) {
+        return { owner: null, diagnostics };
+    }
+    if (serverBlocks.length > 1) {
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.MULTIPLE_SERVER_BLOCKS, 'error', 'Multiple <script server> blocks are not supported in layout/component owners.', ownerPath));
+        return { owner: null, diagnostics };
+    }
+    const serverBlock = serverBlocks[0];
+    const serverBody = String(serverBlock.body || '').trim();
+    if (serverBlockRequiresLangTs(serverBlock.attrs, compilerOpts)) {
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.MISSING_LANG_TS, 'error', 'Layout/component server blocks require lang="ts" (or typescriptDefault).', ownerPath));
+    }
+    diagnostics.push(...collectRouteControlMisuseDiagnostics(serverBody, ownerPath));
+    diagnostics.push(...collectLetDiagnostics(serverBody, ownerPath));
+    const hasExplicitData = EXPLICIT_DATA_EXPORT_RE.test(serverBody);
+    const level1Names = collectTopLevelConstNames(serverBody);
+    if (hasExplicitData && level1Names.length > 0) {
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.MIXED_LEVEL1_AND_DATA, 'error', 'Use either top-level server const values or export const data, not both.', ownerPath));
+    }
+    diagnostics.push(...collectReservedBindingDiagnostics(level1Names, ownerPath));
+    diagnostics.push(...collectClientLeakDiagnostics(level1Names, clientBlocks, ownerPath));
+    if (diagnostics.some((item) => item.severity === 'error')) {
+        return { owner: null, diagnostics };
+    }
+    const template = extractTemplate(ownerSource);
+    const ownerKind = inferOwnerKind(ownerPath);
+    if (hasExplicitData) {
+        const owner = {
+            ownerKind,
+            ownerPath,
+            syntax: 'explicit-data',
+            serializedVariableNames: collectExplicitDataTemplateRefs(template),
+            exportName: 'data'
+        };
+        return { owner, diagnostics };
+    }
+    if (level1Names.length === 0) {
+        return { owner: null, diagnostics };
+    }
+    const serializedVariableNames = computeSerializationSet(level1Names, template);
+    for (const name of level1Names) {
+        if (!serializedVariableNames.includes(name)) {
+            diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.UNREFERENCED_SERVER_VAR, 'warning', `Server variable "${name}" is not referenced by this owner's template and will not serialize.`, ownerPath));
+        }
+    }
+    const owner = {
+        ownerKind,
+        ownerPath,
+        syntax: 'variables',
+        serializedVariableNames,
+        level1VariableNames: level1Names,
+        exportName: 'data'
+    };
+    return { owner, diagnostics };
+}
+function collectRouteControlMisuseDiagnostics(serverBody, ownerPath) {
+    const diagnostics = [];
+    const load = readRouteHandlerExport(serverBody, 'load');
+    if (load.hasExport) {
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.OWNER_LOAD_MISUSE, 'error', '`load()` is route-only in Zenith. Use server variables or scoped data() inside layouts/components.', ownerPath));
+    }
+    const guard = readRouteHandlerExport(serverBody, 'guard');
+    if (guard.hasExport) {
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.OWNER_GUARD_MISUSE, 'error', '`guard()` is route-only in Zenith and cannot be declared in layout/component owners.', ownerPath));
+    }
+    const action = readRouteHandlerExport(serverBody, 'action');
+    if (action.hasExport) {
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.OWNER_ACTION_MISUSE, 'error', '`action()` is route-only in Zenith and cannot be declared in layout/component owners.', ownerPath));
+    }
+    return diagnostics;
+}
+function collectLetDiagnostics(serverBody, ownerPath) {
+    const diagnostics = [];
+    for (const match of serverBody.matchAll(TOP_LEVEL_LET_RE)) {
+        const name = String(match[1] || '');
+        diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.LEVEL1_LET_REJECTED, 'error', `Level 1 server variable "${name}" must use const, not let.`, ownerPath));
+    }
+    return diagnostics;
+}
+function collectTopLevelConstNames(serverBody) {
+    const names = [];
+    for (const match of serverBody.matchAll(TOP_LEVEL_CONST_RE)) {
+        const name = String(match[1] || '');
+        if (name && !names.includes(name)) {
+            names.push(name);
+        }
+    }
+    return names;
+}
+function collectReservedBindingDiagnostics(level1Names, ownerPath) {
+    const diagnostics = [];
+    const reserved = new Set(RESERVED_LEVEL1_BINDING_NAMES);
+    for (const name of level1Names) {
+        if (reserved.has(name)) {
+            diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.RESERVED_BINDING, 'error', `Server variable "${name}" uses a reserved binding name.`, ownerPath));
+        }
+    }
+    return diagnostics;
+}
+function collectClientLeakDiagnostics(level1Names, clientBlocks, ownerPath) {
+    const diagnostics = [];
+    if (level1Names.length === 0 || clientBlocks.length === 0) {
+        return diagnostics;
+    }
+    const clientSource = clientBlocks.map((block) => block.body).join('\n');
+    for (const name of level1Names) {
+        const refRe = new RegExp(`\\b${escapeRegExp(name)}\\b`);
+        if (refRe.test(clientSource)) {
+            diagnostics.push(createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.CLIENT_SCRIPT_LEAK, 'error', `Server variable "${name}" is referenced from a client script block.`, ownerPath));
+        }
+    }
+    return diagnostics;
+}
+function collectExplicitDataTemplateRefs(template) {
+    const refs = [];
+    for (const match of String(template || '').matchAll(/\{data\.([A-Za-z_$][\w$]*)/g)) {
+        const name = String(match[1] || '');
+        if (name && !refs.includes(name)) {
+            refs.push(name);
+        }
+    }
+    return refs.sort();
+}
+function inferOwnerKind(ownerPath) {
+    const normalized = String(ownerPath || '').replace(/\\/g, '/');
+    return normalized.includes('/layouts/') ? 'layout' : 'component';
+}
+function escapeRegExp(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/scoped-server-data/diagnostics.d.ts

@@ -0,0 +1,18 @@
+import type { ScopedServerDiagnostic, ScopedServerDiagnosticSeverity } from './types.js';
+export declare const SCOPED_SERVER_DIAGNOSTIC: {
+    readonly OWNER_LOAD_MISUSE: "CSV001";
+    readonly OWNER_GUARD_MISUSE: "CSV002";
+    readonly OWNER_ACTION_MISUSE: "CSV003";
+    readonly RESERVED_BINDING: "CSV004";
+    readonly LEVEL1_LET_REJECTED: "CSV005";
+    readonly MULTIPLE_SERVER_BLOCKS: "CSV006";
+    readonly CLIENT_SCRIPT_LEAK: "CSV007";
+    readonly COMPETING_DOCUMENT_ROOTS: "CSV008";
+    readonly MIXED_LEVEL1_AND_DATA: "CSV009";
+    readonly MISSING_LANG_TS: "CSV010";
+    readonly UNREFERENCED_SERVER_VAR: "CSV011";
+    readonly PRERENDER_WITH_SCOPED_DATA: "CSV012";
+    readonly UNSUPPORTED_COMPONENT_PROP: "CSV013";
+};
+export declare function createScopedServerDiagnostic(code: string, severity: ScopedServerDiagnosticSeverity, message: string, filePath: string): ScopedServerDiagnostic;
+export declare function sortScopedServerDiagnostics(diagnostics: ScopedServerDiagnostic[]): ScopedServerDiagnostic[];

package/dist/scoped-server-data/diagnostics.js

@@ -0,0 +1,32 @@
+export const SCOPED_SERVER_DIAGNOSTIC = {
+    OWNER_LOAD_MISUSE: 'CSV001',
+    OWNER_GUARD_MISUSE: 'CSV002',
+    OWNER_ACTION_MISUSE: 'CSV003',
+    RESERVED_BINDING: 'CSV004',
+    LEVEL1_LET_REJECTED: 'CSV005',
+    MULTIPLE_SERVER_BLOCKS: 'CSV006',
+    CLIENT_SCRIPT_LEAK: 'CSV007',
+    COMPETING_DOCUMENT_ROOTS: 'CSV008',
+    MIXED_LEVEL1_AND_DATA: 'CSV009',
+    MISSING_LANG_TS: 'CSV010',
+    UNREFERENCED_SERVER_VAR: 'CSV011',
+    PRERENDER_WITH_SCOPED_DATA: 'CSV012',
+    UNSUPPORTED_COMPONENT_PROP: 'CSV013'
+};
+export function createScopedServerDiagnostic(code, severity, message, filePath) {
+    return {
+        code,
+        severity,
+        message,
+        filePath
+    };
+}
+export function sortScopedServerDiagnostics(diagnostics) {
+    return [...diagnostics].sort((left, right) => {
+        const fileCmp = left.filePath.localeCompare(right.filePath);
+        if (fileCmp !== 0) {
+            return fileCmp;
+        }
+        return left.code.localeCompare(right.code);
+    });
+}

package/dist/scoped-server-data/lowering.d.ts

@@ -0,0 +1,27 @@
+import type { CompilerOptsLike, ManifestScopedServerDataEntry } from './types.js';
+export interface LowerRouteScopedServerDataOptions {
+    pageSource: string;
+    pageFile: string;
+    registry: Map<string, string>;
+    srcDir: string;
+    projectRoot?: string;
+    compilerOpts?: CompilerOptsLike;
+    scopedServerData?: ManifestScopedServerDataEntry[];
+}
+export interface LoweredScopedServerDataEntry extends ManifestScopedServerDataEntry {
+    module: string;
+}
+export interface LoweredScopedServerDataModule {
+    ownerKey: string;
+    ownerPath: string;
+    module: string;
+    source: string;
+    sourcePath: string;
+}
+export interface LoweredScopedServerDataRoute {
+    scopedServerData: LoweredScopedServerDataEntry[];
+    modules: LoweredScopedServerDataModule[];
+}
+export declare function lowerRouteScopedServerData(options: LowerRouteScopedServerDataOptions): LoweredScopedServerDataRoute;
+export declare function scopedServerModulePathForOwnerKey(ownerKey: string): string;
+export declare function resolveScopedServerModuleOutputPath(serverDir: string, modulePath: string): string;

package/dist/scoped-server-data/lowering.js

@@ -0,0 +1,242 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { isAbsolute, join, resolve, sep } from 'node:path';
+import { collectExpandedComponentOccurrences } from '../component-occurrences.js';
+import { scanRouteScopedServerOwners, toOwnerKey } from './owner-scanner.js';
+import { partitionScriptBlocks } from './parse-owner-server-block.js';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+const INVALID_OWNER_KEY_ERROR = '[Zenith:ScopedServerData] Invalid scoped server data owner key.';
+const INVALID_MODULE_PATH_ERROR = '[Zenith:ScopedServerData] Invalid scoped server data module path.';
+export function lowerRouteScopedServerData(options) {
+    const pageSource = String(options.pageSource || '');
+    const pageFile = resolve(String(options.pageFile || ''));
+    const srcDir = resolve(String(options.srcDir || ''));
+    const registry = options.registry;
+    const compilerOpts = options.compilerOpts || {};
+    const metadata = Array.isArray(options.scopedServerData) ? options.scopedServerData : [];
+    const scanResult = scanRouteScopedServerOwners({
+        pageSource,
+        pageFile,
+        registry,
+        srcDir,
+        compilerOpts
+    });
+    assertNoLoweringDiagnostics(scanResult.diagnostics, pageFile);
+    const ownerByKey = new Map();
+    for (const owner of scanResult.owners) {
+        ownerByKey.set(owner.ownerKey, owner);
+    }
+    const metadataByKey = new Map();
+    for (const entry of metadata) {
+        if (entry && typeof entry.ownerKey === 'string') {
+            metadataByKey.set(entry.ownerKey, entry);
+        }
+    }
+    const orderedKeys = buildEncounterOrderedOwnerKeys({
+        pageSource,
+        pageFile,
+        registry,
+        srcDir,
+        ownerByKey,
+        metadata
+    });
+    const ts = resolveTypeScriptApi(options.projectRoot);
+    const scopedServerData = [];
+    const modules = [];
+    for (const ownerKey of orderedKeys) {
+        const owner = ownerByKey.get(ownerKey);
+        if (!owner) {
+            throw new Error(`[Zenith:ScopedServerData] Cannot lower missing scoped server data owner "${ownerKey}" for "${pageFile}".`);
+        }
+        const modulePath = scopedServerModulePathForOwnerKey(ownerKey);
+        const source = lowerOwnerSource(owner, ts);
+        const entry = {
+            ...(metadataByKey.get(ownerKey) || toFallbackManifestEntry(owner)),
+            module: modulePath
+        };
+        if (owner.syntax === 'variables' &&
+            owner.serializedVariableNames.length > 0 &&
+            !Array.isArray(entry.serializedVariableNames)) {
+            entry.serializedVariableNames = [...owner.serializedVariableNames];
+        }
+        scopedServerData.push(entry);
+        modules.push({
+            ownerKey,
+            ownerPath: owner.ownerPath,
+            module: modulePath,
+            source,
+            sourcePath: owner.ownerPath
+        });
+    }
+    return { scopedServerData, modules };
+}
+export function scopedServerModulePathForOwnerKey(ownerKey) {
+    const raw = String(ownerKey || '');
+    if (!raw || isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw)) {
+        throw new Error(INVALID_OWNER_KEY_ERROR);
+    }
+    const normalized = raw.replace(/\\/g, '/');
+    const parts = normalized.split('/');
+    if (parts.some((part) => part.length === 0 || part === '.' || part === '..')) {
+        throw new Error(INVALID_OWNER_KEY_ERROR);
+    }
+    return `scoped/${parts.join('/')}.mjs`;
+}
+export function resolveScopedServerModuleOutputPath(serverDir, modulePath) {
+    const raw = String(modulePath || '');
+    if (!raw || isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw)) {
+        throw new Error(INVALID_MODULE_PATH_ERROR);
+    }
+    const normalized = raw.replace(/\\/g, '/');
+    if (!normalized.startsWith('scoped/') || normalized.split('/').some((part) => part === '..' || part === '.')) {
+        throw new Error(INVALID_MODULE_PATH_ERROR);
+    }
+    const scopedRoot = resolve(serverDir, 'scoped');
+    const outputPath = resolve(serverDir, normalized);
+    if (outputPath !== scopedRoot && !outputPath.startsWith(`${scopedRoot}${sep}`)) {
+        throw new Error(INVALID_MODULE_PATH_ERROR);
+    }
+    return outputPath;
+}
+function buildEncounterOrderedOwnerKeys({ pageSource, pageFile, registry, srcDir, ownerByKey, metadata }) {
+    const seen = new Set();
+    const keys = [];
+    for (const occurrence of collectExpandedComponentOccurrences(pageSource, registry, pageFile)) {
+        if (typeof occurrence.componentPath !== 'string' || occurrence.componentPath.length === 0) {
+            continue;
+        }
+        const ownerKey = toOwnerKey(occurrence.componentPath, srcDir);
+        if (!ownerByKey.has(ownerKey) || seen.has(ownerKey)) {
+            continue;
+        }
+        seen.add(ownerKey);
+        keys.push(ownerKey);
+    }
+    for (const entry of metadata) {
+        const ownerKey = String(entry?.ownerKey || '');
+        if (ownerKey && ownerByKey.has(ownerKey) && !seen.has(ownerKey)) {
+            seen.add(ownerKey);
+            keys.push(ownerKey);
+        }
+    }
+    for (const ownerKey of ownerByKey.keys()) {
+        if (!seen.has(ownerKey)) {
+            keys.push(ownerKey);
+        }
+    }
+    return keys;
+}
+function lowerOwnerSource(owner, ts) {
+    const ownerSource = readFileSync(owner.ownerPath, 'utf8');
+    const serverBody = readSingleServerBody(ownerSource, owner.ownerPath);
+    assertNoRouteResultMisuse(serverBody, owner.ownerPath);
+    if (owner.syntax === 'explicit-data') {
+        return ensureTrailingNewline(serverBody);
+    }
+    const { imports, body } = partitionTopLevelImports(ts, serverBody, owner.ownerPath);
+    const lines = [
+        imports,
+        'export async function data(ctx, props) {',
+        indentBlock(body),
+        '  return {',
+        ...owner.serializedVariableNames.map((name) => `    ${name},`),
+        '  };',
+        '}',
+        ''
+    ].filter((line) => line !== null && line !== undefined);
+    return lines.join('\n');
+}
+function readSingleServerBody(ownerSource, ownerPath) {
+    const { serverBlocks } = partitionScriptBlocks(ownerSource);
+    if (serverBlocks.length !== 1) {
+        throw new Error(`[Zenith:ScopedServerData] Cannot lower scoped server data owner "${ownerPath}" because it must contain exactly one server block.`);
+    }
+    return String(serverBlocks[0]?.body || '').trim();
+}
+function partitionTopLevelImports(ts, source, filePath) {
+    const parsed = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const importRanges = [];
+    for (const statement of parsed.statements) {
+        if (ts.isImportDeclaration(statement) || ts.isImportEqualsDeclaration(statement)) {
+            importRanges.push([statement.getFullStart(), statement.end]);
+        }
+    }
+    if (importRanges.length === 0) {
+        return { imports: '', body: source.trim() };
+    }
+    const imports = importRanges
+        .map(([start, end]) => source.slice(start, end).trim())
+        .filter(Boolean)
+        .join('\n');
+    let cursor = 0;
+    const bodyParts = [];
+    for (const [start, end] of importRanges) {
+        bodyParts.push(source.slice(cursor, start));
+        cursor = end;
+    }
+    bodyParts.push(source.slice(cursor));
+    return {
+        imports,
+        body: bodyParts.join('').trim()
+    };
+}
+function assertNoRouteResultMisuse(serverBody, ownerPath) {
+    const ctxMisuse = serverBody.match(/\bctx\s*\.\s*(redirect|deny|data)\s*\(/);
+    if (ctxMisuse) {
+        throw new Error(`[Zenith:ScopedServerData] Scoped server data owner "${ownerPath}" cannot use route-only result API ctx.${ctxMisuse[1]}().`);
+    }
+    if (/\bexport\s+(?:async\s+)?function\s+action\b|\bexport\s+const\s+action\s*=/.test(serverBody)) {
+        throw new Error(`[Zenith:ScopedServerData] Scoped server data owner "${ownerPath}" cannot declare route-only action().`);
+    }
+}
+function assertNoLoweringDiagnostics(diagnostics, pageFile) {
+    const errors = diagnostics.filter((item) => item.severity === 'error');
+    if (errors.length === 0) {
+        return;
+    }
+    const first = errors[0];
+    throw new Error(`[Zenith:ScopedServerData] Cannot lower scoped server data for ${pageFile}: ${first.code} ${first.message} (${first.filePath})`);
+}
+function resolveTypeScriptApi(projectRoot) {
+    if (projectRoot) {
+        try {
+            const projectRequire = createRequire(join(projectRoot, '__zenith_scoped_server_data_lowering__.js'));
+            return projectRequire('typescript');
+        }
+        catch {
+            // Fall through to the CLI workspace/package dependency.
+        }
+    }
+    try {
+        return PACKAGE_REQUIRE('typescript');
+    }
+    catch {
+        throw new Error('[Zenith:ScopedServerData] Scoped server data lowering requires the `typescript` package.');
+    }
+}
+function toFallbackManifestEntry(owner) {
+    const entry = {
+        ownerKind: owner.ownerKind,
+        ownerKey: owner.ownerKey,
+        syntax: owner.syntax,
+        exportName: owner.exportName,
+        instanceStrategy: owner.ownerKind === 'layout' ? 'singleton' : 'singleton'
+    };
+    if (owner.syntax === 'variables' && owner.serializedVariableNames.length > 0) {
+        entry.serializedVariableNames = [...owner.serializedVariableNames];
+    }
+    return entry;
+}
+function indentBlock(source) {
+    const trimmed = String(source || '').trim();
+    if (!trimmed) {
+        return '';
+    }
+    return trimmed
+        .split('\n')
+        .map((line) => `  ${line}`)
+        .join('\n');
+}
+function ensureTrailingNewline(source) {
+    return source.endsWith('\n') ? source : `${source}\n`;
+}

package/dist/scoped-server-data/manifest-integration.d.ts

@@ -0,0 +1,4 @@
+import type { AnalyzeRouteScopedServerMetadataOptions, AnalyzeRouteScopedServerMetadataResult, ScopedServerDiagnostic } from './types.js';
+export type { AnalyzeRouteScopedServerMetadataOptions, AnalyzeRouteScopedServerMetadataResult, ManifestScopedServerDataEntry } from './types.js';
+export declare function analyzeRouteScopedServerMetadata(options: AnalyzeRouteScopedServerMetadataOptions): AnalyzeRouteScopedServerMetadataResult;
+export declare function assertNoScopedServerBuildErrors(diagnostics: ScopedServerDiagnostic[], contextFile: string): void;