@zenithbuild/cli 0.7.3 → 0.7.5

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

@@ -1,116 +1,5 @@
-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]}`);
-}
+import { normalizeTypeScriptExpression, renderObjectKey } from './typescript-expression-utils.js';
+import { rewriteCompilerSignalMapReferences } from './compiler-signal-expression.js';
 /**
  * @param {string | null | undefined} compiledExpr
  * @param {{
@@ -126,22 +15,24 @@ export function resolveCompiledPropsExpression(compiledExpr, expressionRewrite =
     }
     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;
-        }
+    return rewriteCompilerSignalMapReferences(source, ({ ts, signalIndex, valueRead }) => {
         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 null;
+        }
+        if (valueRead) {
+            return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(stateKey), 'get'), undefined, []);
         }
-        return full.endsWith('.get()') ? `${stateKey}.get()` : stateKey;
+        return ts.factory.createIdentifier(stateKey);
     });
-    return normalizeTypeScriptExpression(resolved);
 }
 /**
+ * The only allowed downstream props rewrite boundary is compiler-owned exact lookup.
+ * If the compiler did not emit a mapping for the attr expression, CLI keeps the
+ * original expression text without attempting identifier reinterpretation.
+ *
  * @param {string} expr
  * @param {{
  *   expressionRewrite?: {
@@ -150,8 +41,7 @@ export function resolveCompiledPropsExpression(compiledExpr, expressionRewrite =
  *     ambiguous?: Set<string>,
  *     signals?: Array<{ state_index?: number }>,
  *     stateBindings?: Array<{ key?: string }>
- *   } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   } | null
  * } | null} rewriteContext
  * @returns {string}
  */
@@ -177,13 +67,18 @@ export function resolvePropsValueCode(expr, rewriteContext = null) {
             return normalizeTypeScriptExpression(exact);
         }
     }
-    return rewritePropsExpression(trimmed, rewriteContext);
+    return normalizeTypeScriptExpression(trimmed);
 }
 /**
  * @param {string} attrs
  * @param {{
- *   expressionRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null,
- *   scopeRewrite?: { map?: Map<string, string>, ambiguous?: Set<string> } | null
+ *   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
  * } | null} rewriteContext
  * @returns {string}
  */
@@ -225,8 +120,13 @@ export function renderPropsLiteralFromAttrs(attrs, rewriteContext = null) {
  * @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
+ *   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
  * } | null} rewriteContext
  * @returns {string}
  */

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

@@ -2,7 +2,7 @@
  * @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 }}
+ * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string, export_paths?: string[] } | null }}
  */
 export function extractServerScript(source: string, sourceFile: string, compilerOpts?: object): {
     source: string;
@@ -11,7 +11,9 @@ export function extractServerScript(source: string, sourceFile: string, compiler
         prerender: boolean;
         has_guard: boolean;
         has_load: boolean;
+        has_action: boolean;
         source_path: string;
+        export_paths?: string[];
     } | null;
 };
 /**

package/dist/build/server-script.js

@@ -1,15 +1,16 @@
 import { readFileSync } from 'node:fs';
 import { findNextKnownComponentTag } from '../component-tag-parser.js';
+import { extractStaticExportPaths } from '../static-export-paths.js';
 /**
  * @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 }}
+ * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string, export_paths?: string[] } | null }}
  */
 export function extractServerScript(source, sourceFile, compilerOpts = {}) {
     const scriptRe = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
     const serverMatches = [];
-    const reservedServerExportRe = /\bexport\s+const\s+(?:data|prerender|guard|load|ssr_data|props|ssr)\b|\bexport\s+(?:async\s+)?function\s+(?:load|guard)\s*\(|\bexport\s+const\s+(?:load|guard)\s*=/;
+    const reservedServerExportRe = /\bexport\s+const\s+(?:data|prerender|guard|load|action|ssr_data|props|ssr)\b|\bexport\s+(?:async\s+)?function\s+(?:load|guard|action)\s*\(|\bexport\s+const\s+(?:load|guard|action)\s*=/;
     for (const match of source.matchAll(scriptRe)) {
         const attrs = String(match[1] || '');
         const body = String(match[2] || '');
@@ -17,7 +18,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
         if (!isServer && reservedServerExportRe.test(body)) {
             throw new Error(`Zenith server script contract violation:\n` +
                 `  File: ${sourceFile}\n` +
-                `  Reason: guard/load/data exports are only allowed in <script server lang="ts"> or adjacent .guard.ts / .load.ts files\n` +
+                `  Reason: guard/load/action/data exports are only allowed in <script server lang="ts"> or adjacent .guard.ts / .load.ts / .action.ts files\n` +
                 `  Example: move the export into <script server lang="ts">`);
         }
         if (isServer) {
@@ -81,6 +82,19 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
             `  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) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: multiple action exports detected\n` +
+            `  Example: keep exactly one export const action = async (ctx) => ({ ... })`);
+    }
     const hasData = /\bexport\s+const\s+data\b/.test(serverSource);
     const hasSsrData = /\bexport\s+const\s+ssr_data\b/.test(serverSource);
     const hasSsr = /\bexport\s+const\s+ssr\b/.test(serverSource);
@@ -119,6 +133,17 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
                 `  Example: export const guard = async (ctx) => ({ ... })`);
         }
     }
+    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) {
+            throw new Error(`Zenith server script contract violation:\n` +
+                `  File: ${sourceFile}\n` +
+                `  Reason: action(ctx) must accept exactly one argument\n` +
+                `  Example: export const action = async (ctx) => ({ ... })`);
+        }
+    }
     const prerenderMatch = serverSource.match(/\bexport\s+const\s+prerender\s*=\s*([^\n;]+)/);
     let prerender = false;
     if (prerenderMatch) {
@@ -131,6 +156,7 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
         }
         prerender = rawValue.startsWith('true');
     }
+    const exportPaths = extractStaticExportPaths(serverSource, sourceFile) || [];
     const start = match.index ?? -1;
     if (start < 0) {
         return {
@@ -140,7 +166,9 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
                 prerender,
                 has_guard: hasGuard,
                 has_load: hasLoad,
-                source_path: sourceFile
+                has_action: hasAction,
+                source_path: sourceFile,
+                export_paths: exportPaths
             }
         };
     }
@@ -153,7 +181,9 @@ export function extractServerScript(source, sourceFile, compilerOpts = {}) {
             prerender,
             has_guard: hasGuard,
             has_load: hasLoad,
-            source_path: sourceFile
+            has_action: hasAction,
+            source_path: sourceFile,
+            export_paths: exportPaths
         }
     };
 }

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

@@ -11,14 +11,15 @@ export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, rou
     base_path: string;
     content_hash: any;
     routes: {
+        html: any;
+        assets: any[];
+        export_paths?: any[] | undefined;
         path: any;
         file: any;
         path_kind: any;
         render_mode: any;
         requires_hydration: boolean;
         params: any[];
-        html: any;
-        assets: any[];
     }[];
     assets: {
         js: any[];

package/dist/build-output-manifest.js

@@ -67,6 +67,9 @@ export async function writeBuildOutputManifest({ coreOutputDir, staticDir, targe
             render_mode: entry.render_mode,
             requires_hydration: /<script\b[^>]*type="module"/i.test(html),
             params: [...entry.params],
+            ...(Array.isArray(entry.export_paths) && entry.export_paths.length > 0
+                ? { export_paths: [...entry.export_paths] }
+                : {}),
             html: htmlPath,
             assets
         });

package/dist/build.js

@@ -1,24 +1,25 @@
-import { mkdir, rm } from 'node:fs/promises';
+import { cp, mkdir, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { resolveBuildAdapter } from './adapters/resolve-adapter.js';
 import { normalizeBasePath } from './base-path.js';
 import { rewriteSoftNavigationHrefBasePathInHtmlFiles } from './base-path-html.js';
 import { writeBuildOutputManifest } from './build-output-manifest.js';
 import { generateManifest } from './manifest.js';
+import { writeResourceRouteManifest } from './resource-manifest.js';
 import { buildComponentRegistry } from './resolve-components.js';
 import { collectAssets, createCompilerWarningEmitter, runBundler } from './build/compiler-runtime.js';
 import { buildPageEnvelopes } from './build/page-loop.js';
 import { deriveProjectRootFromPagesDir, ensureZenithTypeDeclarations } from './build/type-declarations.js';
-import { materializeImageMarkupInHtmlFiles } from './images/materialize.js';
 import { buildImageArtifacts } from './images/service.js';
+import { injectImageMaterializationIntoRouterManifest } from './images/router-manifest.js';
 import { createImageRuntimePayload, injectImageRuntimePayloadIntoHtmlFiles } from './images/payload.js';
+import { supportsTargetRouteCheck } from './route-check-support.js';
 import { createStartupProfiler } from './startup-profile.js';
 import { writeServerOutput } from './server-output.js';
 import { resolveBundlerBin } from './toolchain-paths.js';
 import { createBundlerToolchain, createCompilerToolchain, ensureToolchainCompatibility, getActiveToolchainCandidate } from './toolchain-runner.js';
 import { maybeWarnAboutZenithVersionMismatch } from './version-check.js';
 export { createCompilerWarningEmitter };
-const RUNTIME_MARKUP_BINDING = '__ZENITH_INTERNAL_ZENHTML';
 function createCompilerTotals() {
     return {
         pageMs: 0,
@@ -49,12 +50,14 @@ export async function build(options) {
     const projectRoot = deriveProjectRootFromPagesDir(pagesDir);
     const coreOutputDir = join(projectRoot, '.zenith-output');
     const staticOutputDir = join(coreOutputDir, 'static');
+    const imageStageDir = join(coreOutputDir, 'image-materialization-stage');
     const srcDir = resolve(pagesDir, '..');
     const compilerBin = createCompilerToolchain({ projectRoot, logger });
     const bundlerBin = createBundlerToolchain({ projectRoot, logger });
     const compilerTotals = createCompilerTotals();
     const { target, adapter, mode } = resolveBuildAdapter(config);
     const basePath = normalizeBasePath(config.basePath || '/');
+    const routeCheckEnabled = supportsTargetRouteCheck(target);
     const routerEnabled = config.router === true;
     const compilerOpts = {
         typescriptDefault: config.typescriptDefault === true,
@@ -72,13 +75,13 @@ export async function build(options) {
         }));
     }
     const registry = startupProfile.measureSync('build_component_registry', () => buildComponentRegistry(srcDir));
-    void RUNTIME_MARKUP_BINDING;
     const manifest = await startupProfile.measureAsync('generate_manifest', () => generateManifest(pagesDir, '.zen', { compilerOpts }));
+    const pageManifest = manifest.filter((entry) => entry?.route_kind !== 'resource');
     if (mode !== 'legacy') {
         adapter.validateRoutes(manifest);
     }
     await startupProfile.measureAsync('ensure_zenith_type_declarations', () => ensureZenithTypeDeclarations({
-        manifest,
+        manifest: pageManifest,
         pagesDir
     }));
     await startupProfile.measureAsync('reset_core_output', () => rm(coreOutputDir, { recursive: true, force: true }));
@@ -91,7 +94,7 @@ export async function build(options) {
         console.warn(line);
     });
     const { envelopes, expressionRewriteMetrics } = await buildPageEnvelopes({
-        manifest,
+        manifest: pageManifest,
         pagesDir,
         srcDir,
         registry,
@@ -102,26 +105,37 @@ export async function build(options) {
         compilerTotals,
         emitCompilerWarning
     });
-    if (envelopes.length > 0) {
-        await startupProfile.measureAsync('run_bundler', () => runBundler(envelopes, staticOutputDir, projectRoot, logger, showBundlerInfo, bundlerBin, { basePath }), { envelopes: envelopes.length });
-    }
-    await startupProfile.measureAsync('rewrite_soft_navigation_base_path', () => rewriteSoftNavigationHrefBasePathInHtmlFiles(staticOutputDir, basePath));
     const { manifest: imageManifest } = await startupProfile.measureAsync('build_image_artifacts', () => buildImageArtifacts({
         projectRoot,
-        outDir: staticOutputDir,
+        outDir: imageStageDir,
         config: config.images
     }));
     const imageRuntimePayload = createImageRuntimePayload(config.images, imageManifest, 'passthrough', basePath);
-    await startupProfile.measureAsync('materialize_image_markup', () => materializeImageMarkupInHtmlFiles({
-        distDir: staticOutputDir,
-        payload: imageRuntimePayload
-    }));
+    if (envelopes.length > 0) {
+        await startupProfile.measureAsync('run_bundler', () => runBundler(envelopes, staticOutputDir, projectRoot, logger, showBundlerInfo, bundlerBin, {
+            basePath,
+            routeCheck: routeCheckEnabled,
+            imageRuntimePayload
+        }), { envelopes: envelopes.length });
+        await startupProfile.measureAsync('inject_image_materialization_manifest', () => injectImageMaterializationIntoRouterManifest(staticOutputDir, envelopes), { envelopes: envelopes.length });
+    }
+    await startupProfile.measureAsync('write_resource_manifest', () => writeResourceRouteManifest(staticOutputDir, manifest, basePath));
+    await startupProfile.measureAsync('rewrite_soft_navigation_base_path', () => rewriteSoftNavigationHrefBasePathInHtmlFiles(staticOutputDir, basePath));
+    await startupProfile.measureAsync('stage_image_artifacts_into_static_output', async () => {
+        if (Object.keys(imageManifest).length === 0) {
+            return;
+        }
+        await cp(join(imageStageDir, '_zenith'), join(staticOutputDir, '_zenith'), {
+            recursive: true,
+            force: true
+        });
+    });
     await startupProfile.measureAsync('inject_image_runtime_payload', () => injectImageRuntimePayloadIntoHtmlFiles(staticOutputDir, imageRuntimePayload));
     const buildManifest = await startupProfile.measureAsync('write_core_manifest', () => writeBuildOutputManifest({
         coreOutputDir,
         staticDir: staticOutputDir,
         target,
-        routeManifest: manifest,
+        routeManifest: pageManifest,
         basePath
     }));
     await startupProfile.measureAsync('write_server_output', () => writeServerOutput({
@@ -134,11 +148,11 @@ export async function build(options) {
     await startupProfile.measureAsync('adapt_output', () => adapter.adapt({ coreOutput: coreOutputDir, outDir, manifest: buildManifest, config }));
     const assets = await startupProfile.measureAsync('collect_assets', () => collectAssets(outDir));
     startupProfile.emit('build_complete', {
-        pages: manifest.length,
+        pages: pageManifest.length,
         assets: assets.length,
         target,
         compilerTotals,
         expressionRewriteMetrics
     });
-    return { pages: manifest.length, assets };
+    return { pages: pageManifest.length, assets };
 }