@zenithbuild/core 0.7.1 → 0.7.3

package/dist/config-types.d.ts

@@ -0,0 +1,38 @@
+export type ZenithTarget = 'static' | 'vercel-static' | 'netlify-static' | 'vercel' | 'netlify' | 'node';
+export type ZenithRenderMode = 'prerender' | 'server';
+export type ZenithPathKind = 'static' | 'dynamic';
+export interface RouteManifestEntry {
+    path: string;
+    file: string;
+    path_kind: ZenithPathKind;
+    render_mode: ZenithRenderMode;
+    params: string[];
+}
+export interface BuildManifestRoute extends RouteManifestEntry {
+    requires_hydration: boolean;
+    html: string;
+    assets: string[];
+}
+export interface BuildManifest {
+    schema_version: number;
+    zenith_version: string;
+    target: string;
+    base_path: string;
+    content_hash: string;
+    routes: BuildManifestRoute[];
+    assets: {
+        js: string[];
+        css: string[];
+        vendor: string | null;
+    };
+}
+export interface ZenithAdapter {
+    name: string;
+    validateRoutes(manifest: RouteManifestEntry[]): void;
+    adapt(options: {
+        coreOutput: string;
+        outDir: string;
+        manifest: BuildManifest;
+        config: Record<string, unknown>;
+    }): Promise<void>;
+}

package/dist/config-types.js

@@ -0,0 +1 @@
+export {};

package/dist/config.d.ts

@@ -1,14 +1,24 @@
+import type { ZenithAdapter, ZenithTarget } from './config-types.js';
+export type { BuildManifest, BuildManifestRoute, RouteManifestEntry, ZenithAdapter, ZenithPathKind, ZenithRenderMode, ZenithTarget } from './config-types.js';
 export interface ZenithConfig {
     router: boolean;
     embeddedMarkupExpressions: boolean;
-    types: boolean;
     typescriptDefault: boolean;
     outDir: string;
     pagesDir: string;
-    experimental: Record<string, never>;
+    basePath: string;
+    target: ZenithTarget;
+    adapter: ZenithAdapter | null;
     strictDomLints: boolean;
     images: ZenithImageConfig;
 }
+export type ZenithConfigInput = Partial<Omit<ZenithConfig, 'target' | 'adapter'>> & ({
+    target?: ZenithTarget;
+    adapter?: never;
+} | {
+    target?: never;
+    adapter: ZenithAdapter;
+});
 export interface ZenithImageRemotePattern {
     protocol: string;
     hostname: string;
@@ -28,8 +38,8 @@ export interface ZenithImageConfig {
     minimumCacheTTL: number;
     dangerouslyAllowLocalNetwork: boolean;
 }
-type ConfigInput = Partial<ZenithConfig> | null | undefined;
+type ConfigInput = ZenithConfigInput | null | undefined;
+export declare function defineConfig<T extends ZenithConfigInput>(config: T): T;
 export declare function validateConfig(config: ConfigInput): ZenithConfig;
 export declare function loadConfig(projectRoot: string): Promise<ZenithConfig>;
 export declare function getDefaults(): ZenithConfig;
-export {};

package/dist/config.js

@@ -1,5 +1,18 @@
-import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+const CONFIG_FILES = ['zenith.config.ts', 'zenith.config.js'];
+const KNOWN_TARGETS = [
+    'static',
+    'vercel-static',
+    'netlify-static',
+    'vercel',
+    'netlify',
+    'node'
+];
 const DEFAULT_IMAGE_CONFIG = {
     formats: ['webp', 'avif'],
     quality: 75,
@@ -15,22 +28,24 @@ const DEFAULT_IMAGE_CONFIG = {
 const DEFAULTS = {
     router: false,
     embeddedMarkupExpressions: false,
-    types: true,
     typescriptDefault: true,
     outDir: 'dist',
     pagesDir: 'pages',
-    experimental: {},
+    basePath: '/',
+    target: 'static',
+    adapter: null,
     strictDomLints: false,
     images: DEFAULT_IMAGE_CONFIG
 };
 const SCHEMA = {
     router: 'boolean',
     embeddedMarkupExpressions: 'boolean',
-    types: 'boolean',
     typescriptDefault: 'boolean',
     outDir: 'string',
     pagesDir: 'string',
-    experimental: 'object',
+    basePath: 'string',
+    target: 'string',
+    adapter: 'object',
     strictDomLints: 'boolean',
     images: 'object'
 };
@@ -162,6 +177,100 @@ function normalizeImageConfig(input) {
     }
     return config;
 }
+function normalizeBasePath(value) {
+    const raw = String(value ?? '/').trim();
+    if (!raw || raw === '/') {
+        return '/';
+    }
+    if (raw.includes('?') || raw.includes('#')) {
+        throw new Error('[Zenith:Config] Key "basePath" must not include query or hash fragments');
+    }
+    if (!raw.startsWith('/')) {
+        throw new Error('[Zenith:Config] Key "basePath" must start with "/"');
+    }
+    const normalized = raw.replace(/\/{2,}/g, '/').replace(/\/+$/g, '');
+    return normalized || '/';
+}
+function validateAdapterValue(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('[Zenith:Config] Key "adapter" must be a plain object');
+    }
+    if (typeof value.name !== 'string' || value.name.trim().length === 0) {
+        throw new Error('[Zenith:Config] Key "adapter.name" must be a non-empty string');
+    }
+    if (typeof value.validateRoutes !== 'function') {
+        throw new Error('[Zenith:Config] Key "adapter.validateRoutes" must be a function');
+    }
+    if (typeof value.adapt !== 'function') {
+        throw new Error('[Zenith:Config] Key "adapter.adapt" must be a function');
+    }
+    return value;
+}
+function resolveConfigFile(projectRoot) {
+    const matches = CONFIG_FILES
+        .map((name) => join(projectRoot, name))
+        .filter((candidate) => existsSync(candidate));
+    if (matches.length > 1) {
+        throw new Error(`[Zenith:Config] Multiple config files found. Keep exactly one of: ${CONFIG_FILES.join(', ')}`);
+    }
+    return matches[0] || null;
+}
+function resolveTypeScriptApi(projectRoot) {
+    try {
+        const projectRequire = createRequire(join(projectRoot, '__zenith_config_loader__.js'));
+        return projectRequire('typescript');
+    }
+    catch {
+        try {
+            return PACKAGE_REQUIRE('typescript');
+        }
+        catch {
+            throw new Error('[Zenith:Config] zenith.config.ts requires the `typescript` package to be installed.');
+        }
+    }
+}
+function importTypescriptConfig(configPath, projectRoot) {
+    return readFile(configPath, 'utf8').then((source) => {
+        const ts = resolveTypeScriptApi(projectRoot);
+        const transpiled = ts.transpileModule(source, {
+            compilerOptions: {
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.ES2022,
+                moduleResolution: ts.ModuleResolutionKind.NodeNext,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true
+            },
+            fileName: configPath
+        }).outputText;
+        const tempConfigPath = join(projectRoot, `.zenith.config.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.mjs`);
+        return writeFile(tempConfigPath, transpiled, 'utf8')
+            .then(() => import(`${pathToFileURL(tempConfigPath).href}?t=${Date.now()}`))
+            .finally(() => rm(tempConfigPath, { force: true }));
+    });
+}
+function importJavascriptConfig(configPath, projectRoot) {
+    return readFile(configPath, 'utf8').then((source) => {
+        const isCommonJs = /\bmodule\.exports\b|\bexports\./.test(source);
+        const tempConfigPath = join(projectRoot, `.zenith.config.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.${isCommonJs ? 'cjs' : 'mjs'}`);
+        return writeFile(tempConfigPath, source, 'utf8')
+            .then(() => {
+            if (isCommonJs) {
+                const projectRequire = createRequire(join(projectRoot, '__zenith_config_loader__.js'));
+                const resolvedPath = projectRequire.resolve(tempConfigPath);
+                const requireCache = projectRequire.cache || PACKAGE_REQUIRE.cache;
+                if (requireCache && resolvedPath in requireCache) {
+                    delete requireCache[resolvedPath];
+                }
+                return projectRequire(tempConfigPath);
+            }
+            return import(`${pathToFileURL(tempConfigPath).href}?t=${Date.now()}`);
+        })
+            .finally(() => rm(tempConfigPath, { force: true }));
+    });
+}
+export function defineConfig(config) {
+    return config;
+}
 export function validateConfig(config) {
     if (config === null || config === undefined) {
         return { ...DEFAULTS, images: cloneImageConfig() };
@@ -174,50 +283,50 @@ export function validateConfig(config) {
             throw new Error(`[Zenith:Config] Unknown key: "${key}"`);
         }
     }
+    if ('target' in config && 'adapter' in config) {
+        throw new Error('[Zenith:Config] Keys "target" and "adapter" are mutually exclusive');
+    }
     const result = { ...DEFAULTS, images: cloneImageConfig() };
     for (const [key, expectedType] of Object.entries(SCHEMA)) {
-        if (key in config) {
-            const value = config[key];
-            if (typeof value !== expectedType) {
-                throw new Error(`[Zenith:Config] Key "${key}" must be ${expectedType}, got ${typeof value}`);
-            }
-            if (expectedType === 'string' && typeof value === 'string' && value.trim() === '') {
-                throw new Error(`[Zenith:Config] Key "${key}" must be a non-empty string`);
-            }
-            if (key === 'experimental' && value) {
-                if (typeof value !== 'object' || Array.isArray(value)) {
-                    throw new Error('[Zenith:Config] Key "experimental" must be a plain object');
-                }
-                result[key] = { ...DEFAULTS.experimental };
-                continue;
-            }
-            if (key === 'images') {
-                result.images = normalizeImageConfig(value);
-                continue;
-            }
-            result[key] = value;
+        if (!(key in config)) {
+            continue;
         }
+        const value = config[key];
+        if (key === 'images') {
+            result.images = normalizeImageConfig(value);
+            continue;
+        }
+        if (key === 'adapter') {
+            result.adapter = validateAdapterValue(value);
+            continue;
+        }
+        if (typeof value !== expectedType) {
+            throw new Error(`[Zenith:Config] Key "${key}" must be ${expectedType}, got ${typeof value}`);
+        }
+        if (expectedType === 'string' && typeof value === 'string' && value.trim() === '') {
+            throw new Error(`[Zenith:Config] Key "${key}" must be a non-empty string`);
+        }
+        if (key === 'target' && !KNOWN_TARGETS.includes(value)) {
+            throw new Error(`[Zenith:Config] Unsupported target: "${value}"`);
+        }
+        if (key === 'basePath') {
+            result.basePath = normalizeBasePath(value);
+            continue;
+        }
+        result[key] = value;
     }
     return result;
 }
 export async function loadConfig(projectRoot) {
-    const configPath = join(projectRoot, 'zenith.config.js');
-    try {
-        const url = pathToFileURL(configPath).href;
-        const mod = await import(url);
-        const raw = mod.default || mod;
-        return validateConfig(raw);
-    }
-    catch (err) {
-        const error = err;
-        if (error.code === 'ERR_MODULE_NOT_FOUND' ||
-            error.code === 'ENOENT' ||
-            error.message?.includes('Cannot find module') ||
-            error.message?.includes('ENOENT')) {
-            return { ...DEFAULTS, images: cloneImageConfig() };
-        }
-        throw err;
+    const resolvedProjectRoot = resolve(projectRoot);
+    const configPath = resolveConfigFile(resolvedProjectRoot);
+    if (!configPath) {
+        return { ...DEFAULTS, images: cloneImageConfig() };
     }
+    const mod = configPath.endsWith('.ts')
+        ? await importTypescriptConfig(configPath, resolvedProjectRoot)
+        : await importJavascriptConfig(configPath, resolvedProjectRoot);
+    return validateConfig(mod.default || mod);
 }
 export function getDefaults() {
     return { ...DEFAULTS, images: cloneImageConfig() };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/core",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Deterministic utility substrate for the Zenith framework",
   "license": "MIT",
   "type": "module",
@@ -43,11 +43,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@zenithbuild/cli": "0.7.1",
-    "@zenithbuild/compiler": "0.7.1",
-    "@zenithbuild/runtime": "0.7.1",
-    "@zenithbuild/router": "0.7.1",
-    "@zenithbuild/bundler": "0.7.1"
+    "@zenithbuild/cli": "0.7.3",
+    "@zenithbuild/compiler": "0.7.3",
+    "@zenithbuild/runtime": "0.7.3",
+    "@zenithbuild/router": "0.7.3",
+    "@zenithbuild/bundler": "0.7.3"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",