@zenithbuild/cli 0.7.4 → 0.7.5

package/README.md

@@ -53,8 +53,8 @@ There is no separate `assetPrefix` config. Public framework asset URLs follow `b
 
 - `basePath` defaults to `/`.
 - Canonical route paths stay base-path free in manifests and route classification.
-- Public app URLs, bundled asset URLs, router URLs, `/_zenith/image`, and `/__zenith/route-check` are prefixed with `basePath`.
-- Static emitted files stay adapter-neutral; adapters map the public base path to those canonical outputs.
+- Public app URLs, bundled asset URLs, router URLs, and any framework endpoints exposed by the selected target are prefixed with `basePath`.
+- Canonical `.zenith-output` files stay adapter-neutral; final adapter output may still nest public files under `basePath` when direct-file serving requires it.
 
 `router` behavior:
 
@@ -66,6 +66,7 @@ There is no separate `assetPrefix` config. Public framework asset URLs follow `b
 
 - `target` is the shorthand deployment target. Phase 1 defaults loaded config to `target: 'static'`.
 - `adapter` is the explicit adapter object form and is mutually exclusive with `target`.
+- `static-export` emits rewrite-free concrete public files rooted at `outDir` and requires `exportPaths` for dynamic prerender routes.
 - `vercel-static` emits a Vercel Build Output API layout rooted at `outDir`.
 - `netlify-static` emits a Netlify publish directory rooted at `outDir`, including generated `_redirects` rewrites for dynamic prerendered routes.
 - `vercel` emits a Vercel Build Output API layout with packaged route functions for server-classified routes and static rewrites for prerendered dynamic routes.
@@ -81,8 +82,9 @@ Server-capable target contract:
 Current limitations:
 
 - There is no separate `assetPrefix` knob. Assets intentionally follow `basePath`.
+- `static-export` does not expose deployed `/_zenith/image` or `/__zenith/route-check` endpoints. A plain static file server is the contract.
 - `vercel` and `netlify` do not yet emit a deployed `/_zenith/image` endpoint. The `node` target does.
-- Image materialization is route-artifact-driven. Build, preview, and server render consume structured `image_materialization` metadata instead of executing page assets, and dynamic image props are currently unsupported until the compiler emits a dedicated image-props artifact.
+- Image materialization is route-artifact-driven. Bundler owns final build/static HTML image materialization, while preview and server render still materialize at runtime from structured `image_materialization` metadata. No path executes page assets, and dynamic image props are currently unsupported until the compiler emits a dedicated image-props artifact.
 - There is no shipped plugin install/remove command surface in this CLI.
 
 ## Commands

package/dist/adapters/adapter-netlify.d.ts

@@ -1,5 +1,5 @@
 export namespace netlifyAdapter {
     let name: string;
-    function validateRoutes(): void;
+    function validateRoutes(manifest: any): void;
     function adapt(options: any): Promise<void>;
 }

package/dist/adapters/adapter-netlify.js

@@ -2,7 +2,9 @@ import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { prependBasePath } from '../base-path.js';
 import { compareRouteSpecificity } from '../server/resolve-request-route.js';
-import { createNetlifyBasePathAssetRules, createNetlifyRewriteRules } from './route-rules.js';
+import { copyHostedPageRuntime } from './copy-hosted-page-runtime.js';
+import { createNetlifyBasePathAssetRules, createNetlifyImageEndpointRule, createNetlifyRewriteRules } from './route-rules.js';
+import { validateHostedResourceRoutes } from './validate-hosted-resource-routes.js';
 function buildNetlifyServerRules(route, basePath = '/') {
     const destination = `/.netlify/functions/__zenith_${route.name}`;
     if (!Array.isArray(route.params) || route.params.length === 0) {
@@ -34,13 +36,37 @@ function createFunctionSource(route) {
     return [
         "import { fileURLToPath } from 'node:url';",
         "import { dirname, join } from 'node:path';",
-        "import { renderRouteRequest, extractInternalParams } from './_zenith/runtime/route-render.js';",
+        "import { renderResourceRouteRequest, renderRouteRequest, extractInternalParams } from './_zenith/runtime/route-render.js';",
         '',
         'const __dirname = dirname(fileURLToPath(import.meta.url));',
         `const route = ${JSON.stringify(route, null, 2)};`,
         '',
+        'function createHostedUnsupportedResponse(message) {',
+        "  return new Response(message, { status: 501, headers: { 'Content-Type': 'text/plain; charset=utf-8' } });",
+        '}',
+        '',
+        'function isMultipartFormData(request) {',
+        "  const contentType = request.headers.get('content-type') || '';",
+        "  return /^multipart\\/form-data(?:\\s*;|$)/i.test(contentType.trim());",
+        '}',
+        '',
         'export default async function(request) {',
         '  const params = extractInternalParams(request.url, route);',
+        "  if (route.route_kind === 'resource') {",
+        '    if (isMultipartFormData(request)) {',
+        "      return createHostedUnsupportedResponse('Hosted multipart resource routes are unsupported in this milestone');",
+        '    }',
+        '    const response = await renderResourceRouteRequest({',
+        '      request,',
+        '      route,',
+        '      params,',
+        `      routeModulePath: join(__dirname, '_zenith', 'routes', ${JSON.stringify(route.name)}, 'route', 'entry.js')`,
+        '    });',
+        "    if (response.headers.has('content-disposition')) {",
+        "      return createHostedUnsupportedResponse('Hosted resource downloads are unsupported in this milestone');",
+        '    }',
+        '    return response;',
+        '  }',
         '  return renderRouteRequest({',
         '    request,',
         '    route,',
@@ -55,6 +81,24 @@ function createFunctionSource(route) {
         ''
     ].join('\n');
 }
+function createImageFunctionSource(imagesConfig) {
+    return [
+        "import { fileURLToPath } from 'node:url';",
+        "import { dirname } from 'node:path';",
+        "import { handleImageFetchRequest } from './_zenith/images/service.js';",
+        '',
+        'const __dirname = dirname(fileURLToPath(import.meta.url));',
+        `const imageConfig = ${JSON.stringify(imagesConfig || {}, null, 2)};`,
+        '',
+        'export default async function(request) {',
+        '  return handleImageFetchRequest(request, {',
+        '    projectRoot: __dirname,',
+        '    config: imageConfig',
+        '  });',
+        '}',
+        ''
+    ].join('\n');
+}
 async function loadServerManifest(coreOutput) {
     try {
         const parsed = JSON.parse(await readFile(join(coreOutput, 'server', 'manifest.json'), 'utf8'));
@@ -67,7 +111,8 @@ async function loadServerManifest(coreOutput) {
 function buildRedirectsFile(buildManifest, serverRoutes) {
     const lines = [
         '# Generated by Zenith netlify adapter',
-        ...createNetlifyBasePathAssetRules(buildManifest.base_path)
+        ...createNetlifyBasePathAssetRules(buildManifest.base_path),
+        createNetlifyImageEndpointRule(buildManifest.base_path)
     ];
     const seen = new Set();
     for (const route of [...serverRoutes].sort((left, right) => compareRouteSpecificity(left.path, right.path))) {
@@ -92,7 +137,9 @@ function buildRedirectsFile(buildManifest, serverRoutes) {
 }
 export const netlifyAdapter = {
     name: 'netlify',
-    validateRoutes() { },
+    validateRoutes(manifest) {
+        validateHostedResourceRoutes(manifest, 'netlify');
+    },
     async adapt(options) {
         const publishDir = join(options.outDir, 'publish');
         const functionsDir = join(options.outDir, 'functions');
@@ -105,16 +152,11 @@ export const netlifyAdapter = {
         await mkdir(functionsDir, { recursive: true });
         await cp(staticDir, publishDir, { recursive: true, force: true });
         await writeFile(join(functionsDir, 'package.json'), '{\n  "type": "module"\n}\n', 'utf8');
-        if (serverRoutes.length > 0) {
-            await cp(join(options.coreOutput, 'server', 'runtime'), join(functionsDir, '_zenith', 'runtime'), { recursive: true, force: true });
-            await cp(join(options.coreOutput, 'server', 'images'), join(functionsDir, '_zenith', 'images'), { recursive: true, force: true });
-            await cp(join(options.coreOutput, 'server', 'base-path.js'), join(functionsDir, '_zenith', 'base-path.js'), { force: true });
-            await cp(join(options.coreOutput, 'server', 'server-contract.js'), join(functionsDir, '_zenith', 'server-contract.js'), { force: true });
-            await cp(join(options.coreOutput, 'server', 'server-error.js'), join(functionsDir, '_zenith', 'server-error.js'), { force: true });
-            for (const route of serverRoutes) {
-                await cp(join(options.coreOutput, 'server', 'routes', route.name), join(functionsDir, '_zenith', 'routes', route.name), { recursive: true, force: true });
-                await writeFile(join(functionsDir, `__zenith_${route.name}.mjs`), createFunctionSource(route), 'utf8');
-            }
+        await copyHostedPageRuntime(options.coreOutput, join(functionsDir, '_zenith'));
+        await writeFile(join(functionsDir, '__zenith_image.mjs'), createImageFunctionSource(options.config?.images || {}), 'utf8');
+        for (const route of serverRoutes) {
+            await cp(join(options.coreOutput, 'server', 'routes', route.name), join(functionsDir, '_zenith', 'routes', route.name), { recursive: true, force: true });
+            await writeFile(join(functionsDir, `__zenith_${route.name}.mjs`), createFunctionSource(route), 'utf8');
         }
         await writeFile(join(publishDir, '_redirects'), buildRedirectsFile(options.manifest, serverRoutes), 'utf8');
         await writeFile(join(options.outDir, 'netlify.toml'), [

package/dist/adapters/adapter-static-export.d.ts

@@ -0,0 +1,5 @@
+export namespace staticExportAdapter {
+    let name: string;
+    function validateRoutes(manifest: any): void;
+    function adapt(options: any): Promise<void>;
+}

package/dist/adapters/adapter-static-export.js

@@ -0,0 +1,115 @@
+import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { prependBasePath } from '../base-path.js';
+import { toStaticHtmlFilePath } from '../static-export-paths.js';
+function stripLeadingSlash(value) {
+    return String(value || '').replace(/^\/+/, '');
+}
+function collectConcretePaths(route) {
+    if (route.path_kind === 'dynamic') {
+        return Array.isArray(route.export_paths) ? route.export_paths : [];
+    }
+    return [route.path];
+}
+async function copySupportFiles({ staticDir, outDir, publicRoot, skippedFiles }) {
+    async function walk(currentDir) {
+        let entries = [];
+        try {
+            entries = await readdir(currentDir);
+        }
+        catch {
+            return;
+        }
+        entries.sort((left, right) => left.localeCompare(right));
+        for (const name of entries) {
+            const sourcePath = join(currentDir, name);
+            const info = await stat(sourcePath);
+            if (info.isDirectory()) {
+                await walk(sourcePath);
+                continue;
+            }
+            const relativePath = relative(staticDir, sourcePath).replaceAll('\\', '/');
+            if (relativePath === 'manifest.json') {
+                await cp(sourcePath, join(outDir, 'manifest.json'), { force: true });
+                continue;
+            }
+            if (skippedFiles.has(relativePath)) {
+                continue;
+            }
+            const targetPath = join(publicRoot, relativePath);
+            await mkdir(dirname(targetPath), { recursive: true });
+            await cp(sourcePath, targetPath, { force: true });
+        }
+    }
+    await walk(staticDir);
+}
+async function writeConcreteHtmlFiles({ staticDir, outDir, routes, basePath }) {
+    for (const route of routes) {
+        const sourceHtmlPath = join(staticDir, stripLeadingSlash(route.html));
+        const sourceHtml = await readFile(sourceHtmlPath, 'utf8');
+        for (const concretePath of collectConcretePaths(route)) {
+            const publicPath = prependBasePath(basePath, concretePath);
+            const outputPath = join(outDir, toStaticHtmlFilePath(publicPath));
+            await mkdir(dirname(outputPath), { recursive: true });
+            await writeFile(outputPath, sourceHtml, 'utf8');
+        }
+    }
+}
+export const staticExportAdapter = {
+    name: 'static-export',
+    validateRoutes(manifest) {
+        const concretePathOwners = new Map();
+        for (const route of manifest) {
+            if (route.render_mode === 'server') {
+                throw new Error(`[Zenith:Build] target "static-export" cannot emit server-rendered routes. ` +
+                    `Route "${route.path}" (${route.file}) requires render_mode="server".`);
+            }
+            if (route.path_kind === 'static') {
+                if (Array.isArray(route.export_paths) && route.export_paths.length > 0) {
+                    throw new Error(`[Zenith:Build] target "static-export" only accepts exportPaths on dynamic prerender routes. ` +
+                        `Route "${route.path}" (${route.file}) is already concrete.`);
+                }
+            }
+            else {
+                if (!Array.isArray(route.export_paths) || route.export_paths.length === 0) {
+                    throw new Error(`[Zenith:Build] target "static-export" requires explicit exportPaths for dynamic prerender routes. ` +
+                        `Route "${route.path}" (${route.file}) has no concrete export-path contract.`);
+                }
+            }
+            for (const concretePath of collectConcretePaths(route)) {
+                const existing = concretePathOwners.get(concretePath);
+                if (existing) {
+                    throw new Error(`[Zenith:Build] target "static-export" produced a duplicate concrete path "${concretePath}" ` +
+                        `from "${existing.file}" and "${route.file}".`);
+                }
+                concretePathOwners.set(concretePath, route);
+            }
+        }
+    },
+    async adapt(options) {
+        const staticDir = join(options.coreOutput, 'static');
+        const routes = Array.isArray(options.manifest?.routes) ? options.manifest.routes : [];
+        const skippedFiles = new Set(routes
+            .map((route) => stripLeadingSlash(route.html))
+            .filter((value) => value.length > 0));
+        const basePath = options.manifest?.base_path || '/';
+        const publicRoot = basePath === '/'
+            ? options.outDir
+            : join(options.outDir, stripLeadingSlash(basePath));
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(options.outDir, { recursive: true });
+        await mkdir(publicRoot, { recursive: true });
+        await copySupportFiles({
+            staticDir,
+            outDir: options.outDir,
+            publicRoot,
+            skippedFiles
+        });
+        await writeConcreteHtmlFiles({
+            staticDir,
+            outDir: options.outDir,
+            routes,
+            basePath
+        });
+    }
+};

package/dist/adapters/adapter-types.d.ts

@@ -1,5 +1,5 @@
 export const KNOWN_TARGETS: string[];
-export type ZenithTarget = "static" | "vercel-static" | "netlify-static" | "vercel" | "netlify" | "node";
+export type ZenithTarget = "static" | "static-export" | "vercel-static" | "netlify-static" | "vercel" | "netlify" | "node";
 export type ZenithRenderMode = "prerender" | "server";
 export type ZenithPathKind = "static" | "dynamic";
 export type RouteManifestEntry = {
@@ -8,6 +8,7 @@ export type RouteManifestEntry = {
     path_kind: ZenithPathKind;
     render_mode: ZenithRenderMode;
     params: string[];
+    export_paths?: string[];
 };
 export type BuildManifest = {
     schema_version: number;
@@ -22,6 +23,7 @@ export type BuildManifest = {
         render_mode: ZenithRenderMode;
         requires_hydration: boolean;
         params: string[];
+        export_paths?: string[];
         html: string;
         assets: string[];
     }>;

package/dist/adapters/adapter-types.js

@@ -1,5 +1,6 @@
 export const KNOWN_TARGETS = [
     'static',
+    'static-export',
     'vercel-static',
     'netlify-static',
     'vercel',
@@ -7,7 +8,7 @@ export const KNOWN_TARGETS = [
     'node'
 ];
 /**
- * @typedef {'static' | 'vercel-static' | 'netlify-static' | 'vercel' | 'netlify' | 'node'} ZenithTarget
+ * @typedef {'static' | 'static-export' | 'vercel-static' | 'netlify-static' | 'vercel' | 'netlify' | 'node'} ZenithTarget
  */
 /**
  * @typedef {'prerender' | 'server'} ZenithRenderMode
@@ -21,7 +22,8 @@ export const KNOWN_TARGETS = [
  *   file: string,
  *   path_kind: ZenithPathKind,
  *   render_mode: ZenithRenderMode,
- *   params: string[]
+ *   params: string[],
+ *   export_paths?: string[]
  * }} RouteManifestEntry
  */
 /**
@@ -38,6 +40,7 @@ export const KNOWN_TARGETS = [
  *     render_mode: ZenithRenderMode,
  *     requires_hydration: boolean,
  *     params: string[],
+ *     export_paths?: string[],
  *     html: string,
  *     assets: string[]
  *   }>,

package/dist/adapters/adapter-vercel.d.ts

@@ -1,5 +1,5 @@
 export namespace vercelAdapter {
     let name: string;
-    function validateRoutes(): void;
+    function validateRoutes(manifest: any): void;
     function adapt(options: any): Promise<void>;
 }

package/dist/adapters/adapter-vercel.js

@@ -1,7 +1,9 @@
 import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { compareRouteSpecificity } from '../server/resolve-request-route.js';
-import { createVercelBasePathAssetRoutes, createVercelRouteSource } from './route-rules.js';
+import { copyHostedPageRuntime } from './copy-hosted-page-runtime.js';
+import { createVercelBasePathAssetRoutes, createVercelImageEndpointRoute, createVercelRouteSource } from './route-rules.js';
+import { validateHostedResourceRoutes } from './validate-hosted-resource-routes.js';
 function buildVercelServerDest(route) {
     const base = `/__zenith/${route.name}`;
     if (!Array.isArray(route.params) || route.params.length === 0) {
@@ -18,6 +20,7 @@ function buildVercelConfig(buildManifest, serverRoutes) {
             dest: buildVercelServerDest(route)
         });
     }
+    routes.push(createVercelImageEndpointRoute(buildManifest.base_path));
     routes.push({ handle: 'filesystem' });
     for (const route of buildManifest.routes.filter((entry) => entry.render_mode === 'prerender' && entry.path_kind === 'dynamic')) {
         routes.push({
@@ -30,18 +33,62 @@ function buildVercelConfig(buildManifest, serverRoutes) {
         routes
     };
 }
+function createImageFunctionSource(imagesConfig) {
+    return [
+        "import { fileURLToPath } from 'node:url';",
+        "import { dirname } from 'node:path';",
+        "import { handleImageFetchRequest } from './images/service.js';",
+        '',
+        'const __dirname = dirname(fileURLToPath(import.meta.url));',
+        `const imageConfig = ${JSON.stringify(imagesConfig || {}, null, 2)};`,
+        '',
+        'export default {',
+        '  async fetch(request) {',
+        '    return handleImageFetchRequest(request, {',
+        '      projectRoot: __dirname,',
+        '      config: imageConfig',
+        '    });',
+        '  }',
+        '};',
+        ''
+    ].join('\n');
+}
 function createFunctionSource(route) {
     return [
         "import { fileURLToPath } from 'node:url';",
         "import { dirname, join } from 'node:path';",
-        "import { renderRouteRequest, extractInternalParams } from './runtime/route-render.js';",
+        "import { renderResourceRouteRequest, renderRouteRequest, extractInternalParams } from './runtime/route-render.js';",
         '',
         'const __dirname = dirname(fileURLToPath(import.meta.url));',
         `const route = ${JSON.stringify(route, null, 2)};`,
         '',
+        'function createHostedUnsupportedResponse(message) {',
+        "  return new Response(message, { status: 501, headers: { 'Content-Type': 'text/plain; charset=utf-8' } });",
+        '}',
+        '',
+        'function isMultipartFormData(request) {',
+        "  const contentType = request.headers.get('content-type') || '';",
+        "  return /^multipart\\/form-data(?:\\s*;|$)/i.test(contentType.trim());",
+        '}',
+        '',
         'export default {',
         '  async fetch(request) {',
         '    const params = extractInternalParams(request.url, route);',
+        "    if (route.route_kind === 'resource') {",
+        '      if (isMultipartFormData(request)) {',
+        "        return createHostedUnsupportedResponse('Hosted multipart resource routes are unsupported in this milestone');",
+        '      }',
+        '      const response = await renderResourceRouteRequest({',
+        '        request,',
+        '        route,',
+        '        params,',
+        "        routeModulePath: join(__dirname, 'route', 'entry.js')",
+        '      });',
+        "      if (response.headers.has('content-disposition')) {",
+        "        return createHostedUnsupportedResponse('Hosted resource downloads are unsupported in this milestone');",
+        '      }',
+        '      return response;',
+        '    }',
         '    return renderRouteRequest({',
         '      request,',
         '      route,',
@@ -66,9 +113,26 @@ async function loadServerManifest(coreOutput) {
         return [];
     }
 }
+function vercelFunctionConfig() {
+    return `${JSON.stringify({
+        runtime: 'nodejs22.x',
+        handler: 'index.js',
+        launcherType: 'Nodejs',
+        shouldAddHelpers: true
+    }, null, 2)}\n`;
+}
+async function writeHostedFunctionBundle(functionDir, coreOutput, source) {
+    await mkdir(functionDir, { recursive: true });
+    await copyHostedPageRuntime(coreOutput, functionDir);
+    await writeFile(join(functionDir, 'package.json'), '{\n  "type": "module"\n}\n', 'utf8');
+    await writeFile(join(functionDir, 'index.js'), source, 'utf8');
+    await writeFile(join(functionDir, '.vc-config.json'), vercelFunctionConfig(), 'utf8');
+}
 export const vercelAdapter = {
     name: 'vercel',
-    validateRoutes() { },
+    validateRoutes(manifest) {
+        validateHostedResourceRoutes(manifest, 'vercel');
+    },
     async adapt(options) {
         const staticDir = join(options.coreOutput, 'static');
         // Route meaning is fixed upstream in the manifest/server package.
@@ -77,23 +141,15 @@ export const vercelAdapter = {
         await rm(options.outDir, { recursive: true, force: true });
         await mkdir(join(options.outDir, 'static'), { recursive: true });
         await cp(staticDir, join(options.outDir, 'static'), { recursive: true, force: true });
+        await writeHostedFunctionBundle(join(options.outDir, 'functions', '__zenith', 'image.func'), options.coreOutput, createImageFunctionSource(options.config?.images || {}));
         for (const route of serverRoutes) {
             const functionDir = join(options.outDir, 'functions', '__zenith', `${route.name}.func`);
             await mkdir(functionDir, { recursive: true });
-            await cp(join(options.coreOutput, 'server', 'runtime'), join(functionDir, 'runtime'), { recursive: true, force: true });
-            await cp(join(options.coreOutput, 'server', 'images'), join(functionDir, 'images'), { recursive: true, force: true });
-            await cp(join(options.coreOutput, 'server', 'base-path.js'), join(functionDir, 'base-path.js'), { force: true });
-            await cp(join(options.coreOutput, 'server', 'server-contract.js'), join(functionDir, 'server-contract.js'), { force: true });
-            await cp(join(options.coreOutput, 'server', 'server-error.js'), join(functionDir, 'server-error.js'), { force: true });
+            await copyHostedPageRuntime(options.coreOutput, functionDir);
             await cp(join(options.coreOutput, 'server', 'routes', route.name), functionDir, { recursive: true, force: true });
             await writeFile(join(functionDir, 'package.json'), '{\n  "type": "module"\n}\n', 'utf8');
             await writeFile(join(functionDir, 'index.js'), createFunctionSource(route), 'utf8');
-            await writeFile(join(functionDir, '.vc-config.json'), `${JSON.stringify({
-                runtime: 'nodejs22.x',
-                handler: 'index.js',
-                launcherType: 'Nodejs',
-                shouldAddHelpers: true
-            }, null, 2)}\n`, 'utf8');
+            await writeFile(join(functionDir, '.vc-config.json'), vercelFunctionConfig(), 'utf8');
         }
         await writeFile(join(options.outDir, 'config.json'), `${JSON.stringify(buildVercelConfig(options.manifest, serverRoutes), null, 2)}\n`, 'utf8');
     }

package/dist/adapters/copy-hosted-page-runtime.d.ts

@@ -0,0 +1 @@
+export function copyHostedPageRuntime(coreOutput: any, targetDir: any): Promise<void>;

package/dist/adapters/copy-hosted-page-runtime.js

@@ -0,0 +1,49 @@
+import { cp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+const HOSTED_PAGE_RUNTIME_DIRS = ['runtime', 'images', 'auth'];
+const HOSTED_PAGE_RUNTIME_FILES = [
+    'base-path.js',
+    'server-contract.js',
+    'server-error.js',
+    'resource-response.js',
+    'download-result.js'
+];
+function createSharpRuntimeSource() {
+    const sharpPath = PACKAGE_REQUIRE.resolve('sharp');
+    const fallbackUrl = pathToFileURL(sharpPath).href;
+    return [
+        'async function loadSharp() {',
+        '  try {',
+        "    const mod = await import('sharp');",
+        '    return mod.default || mod;',
+        '  } catch {',
+        `    const mod = await import(${JSON.stringify(fallbackUrl)});`,
+        '    return mod.default || mod;',
+        '  }',
+        '}',
+        '',
+        'const sharp = await loadSharp();',
+        'export default sharp;',
+        ''
+    ].join('\n');
+}
+export async function copyHostedPageRuntime(coreOutput, targetDir) {
+    const serverDir = join(coreOutput, 'server');
+    await mkdir(targetDir, { recursive: true });
+    for (const name of HOSTED_PAGE_RUNTIME_DIRS) {
+        await cp(join(serverDir, name), join(targetDir, name), {
+            recursive: true,
+            force: true
+        });
+    }
+    for (const name of HOSTED_PAGE_RUNTIME_FILES) {
+        await cp(join(serverDir, name), join(targetDir, name), { force: true });
+    }
+    const imageServicePath = join(targetDir, 'images', 'service.js');
+    const imageServiceSource = await readFile(imageServicePath, 'utf8');
+    await writeFile(imageServicePath, imageServiceSource.replace("import sharp from 'sharp';", "import sharp from './sharp-runtime.js';"), 'utf8');
+    await writeFile(join(targetDir, 'images', 'sharp-runtime.js'), createSharpRuntimeSource(), 'utf8');
+}

package/dist/adapters/resolve-adapter.js

@@ -2,6 +2,7 @@ import { isConfigKeyExplicit, isLoadedConfig } from '../config.js';
 import { netlifyAdapter } from './adapter-netlify.js';
 import { nodeAdapter } from './adapter-node.js';
 import { netlifyStaticAdapter } from './adapter-netlify-static.js';
+import { staticExportAdapter } from './adapter-static-export.js';
 import { staticAdapter } from './adapter-static.js';
 import { KNOWN_TARGETS } from './adapter-types.js';
 import { vercelAdapter } from './adapter-vercel.js';
@@ -32,6 +33,9 @@ function resolveTargetAdapter(target) {
     if (target === 'static') {
         return staticAdapter;
     }
+    if (target === 'static-export') {
+        return staticExportAdapter;
+    }
     if (target === 'vercel-static') {
         return vercelStaticAdapter;
     }

package/dist/adapters/route-rules.d.ts

@@ -1,7 +1,12 @@
 export function createNetlifyBasePathAssetRules(basePath: any): string[];
+export function createNetlifyImageEndpointRule(basePath: any): string;
 export function createNetlifyRewriteRules(route: any, basePath?: string): string[];
 export function createVercelBasePathAssetRoutes(basePath: any): {
     src: string;
     dest: string;
 }[];
+export function createVercelImageEndpointRoute(basePath: any): {
+    src: string;
+    dest: string;
+};
 export function createVercelRouteSource(routePath: any, basePath?: string): string;

package/dist/adapters/route-rules.js

@@ -21,6 +21,9 @@ export function createNetlifyBasePathAssetRules(basePath) {
         `${prependBasePath(normalizedBasePath, '/_zenith/image/local/*')} /_zenith/image/local/:splat 200`
     ];
 }
+export function createNetlifyImageEndpointRule(basePath) {
+    return `${prependBasePath(basePath, '/_zenith/image')} /.netlify/functions/__zenith_image 200!`;
+}
 export function createNetlifyRewriteRules(route, basePath = '/') {
     const segments = splitRouteSegments(route.path);
     if (segments.length === 0) {
@@ -61,6 +64,12 @@ export function createVercelBasePathAssetRoutes(basePath) {
         }
     ];
 }
+export function createVercelImageEndpointRoute(basePath) {
+    return {
+        src: createVercelRouteSource('/_zenith/image', basePath),
+        dest: '/__zenith/image'
+    };
+}
 export function createVercelRouteSource(routePath, basePath = '/') {
     const segments = splitRouteSegments(routePath);
     if (segments.length === 0) {

package/dist/adapters/validate-hosted-resource-routes.d.ts

@@ -0,0 +1 @@
+export function validateHostedResourceRoutes(manifest: any, targetName: any): void;

package/dist/adapters/validate-hosted-resource-routes.js

@@ -0,0 +1,13 @@
+const HOSTED_RESOURCE_DOWNLOAD_RE = /\b(?:ctx\.)?download\s*\(/;
+export function validateHostedResourceRoutes(manifest, targetName) {
+    for (const route of Array.isArray(manifest) ? manifest : []) {
+        if (route?.route_kind !== 'resource') {
+            continue;
+        }
+        const source = typeof route.server_script === 'string' ? route.server_script : '';
+        if (HOSTED_RESOURCE_DOWNLOAD_RE.test(source)) {
+            throw new Error(`[Zenith:Build] target "${targetName}" does not support resource downloads in this milestone. ` +
+                `Route "${route.path}" (${route.file}) must run on dev, preview, or target "node".`);
+        }
+    }
+}

package/dist/auth/route-auth.d.ts

@@ -0,0 +1,6 @@
+export function consumeStagedSetCookies(ctx: any): any[];
+export function attachRouteAuth(ctx: any, options?: {}): any;
+export const SESSION_COOKIE_NAME: "zenith_session";
+export const SESSION_SECRET_ENV: "ZENITH_SESSION_SECRET";
+export const STAGED_SET_COOKIES_KEY: "__zenith_staged_set_cookies";
+export const AUTH_CONTROL_FLOW_FLAG: "__zenith_auth_control_flow";