@zenithbuild/core 0.6.5 → 0.6.7

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+export interface ZenithConfig {
+    router: boolean;
+    embeddedMarkupExpressions: boolean;
+    types: boolean;
+    typescriptDefault: boolean;
+    outDir: string;
+    pagesDir: string;
+    experimental: Record<string, never>;
+    strictDomLints: boolean;
+}
+type ConfigInput = Partial<ZenithConfig> | null | undefined;
+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

@@ -0,0 +1,78 @@
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const DEFAULTS = {
+    router: false,
+    embeddedMarkupExpressions: false,
+    types: true,
+    typescriptDefault: true,
+    outDir: 'dist',
+    pagesDir: 'pages',
+    experimental: {},
+    strictDomLints: false
+};
+const SCHEMA = {
+    router: 'boolean',
+    embeddedMarkupExpressions: 'boolean',
+    types: 'boolean',
+    typescriptDefault: 'boolean',
+    outDir: 'string',
+    pagesDir: 'string',
+    experimental: 'object',
+    strictDomLints: 'boolean'
+};
+export function validateConfig(config) {
+    if (config === null || config === undefined) {
+        return { ...DEFAULTS };
+    }
+    if (typeof config !== 'object' || Array.isArray(config)) {
+        throw new Error('[Zenith:Config] Config must be a plain object');
+    }
+    for (const key of Object.keys(config)) {
+        if (!(key in SCHEMA)) {
+            throw new Error(`[Zenith:Config] Unknown key: "${key}"`);
+        }
+    }
+    const result = { ...DEFAULTS };
+    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;
+            }
+            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 };
+        }
+        throw err;
+    }
+}
+export function getDefaults() {
+    return { ...DEFAULTS };
+}

package/dist/core-template.d.ts

@@ -0,0 +1 @@
+export declare function coreModuleSource(runtimeImport: string): string;

package/{src → dist}/core-template.js

@@ -1,17 +1,11 @@
-// ---------------------------------------------------------------------------
-// core-template.js — source template for emitted core asset
-// ---------------------------------------------------------------------------
-
 function assertRuntimeImport(runtimeImport) {
     if (typeof runtimeImport !== 'string' || runtimeImport.trim().length === 0) {
         throw new Error('[Zenith Core] coreModuleSource(runtimeImport) requires non-empty runtimeImport');
     }
 }
-
 export function coreModuleSource(runtimeImport) {
     assertRuntimeImport(runtimeImport);
     const runtimeImportLiteral = JSON.stringify(runtimeImport);
-
     return [
         `import { signal, state, zeneffect, zenEffect as __zenithZenEffect, zenMount as __zenithZenMount } from ${runtimeImportLiteral};`,
         '',

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+export interface ZenithError extends Error {
+    zenithModule: string;
+}
+export declare function createError(module: string, message: string): ZenithError;
+export declare function formatError(module: string, message: string): string;
+export declare function isZenithError(err: Error | unknown): err is ZenithError;
+export declare const ErrorCodes: {
+    readonly CONFIG_UNKNOWN_KEY: "CONFIG_UNKNOWN_KEY";
+    readonly CONFIG_INVALID_TYPE: "CONFIG_INVALID_TYPE";
+    readonly CONFIG_EMPTY_VALUE: "CONFIG_EMPTY_VALUE";
+    readonly PATH_REPEATED_PARAM: "PATH_REPEATED_PARAM";
+    readonly VERSION_INCOMPATIBLE: "VERSION_INCOMPATIBLE";
+    readonly GUARD_VIOLATION: "GUARD_VIOLATION";
+};

package/dist/errors.js

@@ -0,0 +1,19 @@
+export function createError(module, message) {
+    const err = new Error(`[Zenith:${module}] ${message}`);
+    err.zenithModule = module;
+    return err;
+}
+export function formatError(module, message) {
+    return `[Zenith:${module}] ${message}`;
+}
+export function isZenithError(err) {
+    return err instanceof Error && typeof err.zenithModule === 'string';
+}
+export const ErrorCodes = {
+    CONFIG_UNKNOWN_KEY: 'CONFIG_UNKNOWN_KEY',
+    CONFIG_INVALID_TYPE: 'CONFIG_INVALID_TYPE',
+    CONFIG_EMPTY_VALUE: 'CONFIG_EMPTY_VALUE',
+    PATH_REPEATED_PARAM: 'PATH_REPEATED_PARAM',
+    VERSION_INCOMPATIBLE: 'VERSION_INCOMPATIBLE',
+    GUARD_VIOLATION: 'GUARD_VIOLATION'
+};

package/dist/guards.d.ts

@@ -0,0 +1,5 @@
+export declare function containsForbiddenPattern(source: string, patterns: string[]): string[];
+export { validateRouteParams } from './path.js';
+export { validateConfig as validateConfigSchema } from './config.js';
+export declare const FORBIDDEN_PATTERNS: string[];
+export declare const BROWSER_GLOBALS: string[];

package/dist/guards.js

@@ -0,0 +1,24 @@
+export function containsForbiddenPattern(source, patterns) {
+    const found = [];
+    for (const pattern of patterns) {
+        if (source.includes(pattern)) {
+            found.push(pattern);
+        }
+    }
+    return found;
+}
+export { validateRouteParams } from './path.js';
+export { validateConfig as validateConfigSchema } from './config.js';
+export const FORBIDDEN_PATTERNS = [
+    'eval(',
+    'new Function(',
+    'new Function (',
+    'document.write('
+];
+export const BROWSER_GLOBALS = [
+    'window',
+    'document',
+    'navigator',
+    'localStorage',
+    'sessionStorage'
+];

package/dist/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function hash(content: string): string;
+export declare function hashShort(content: string, length?: number): string;

package/dist/hash.js

@@ -0,0 +1,13 @@
+import { createHash } from 'node:crypto';
+export function hash(content) {
+    const normalized = normalizeInput(content);
+    return createHash('sha256').update(normalized).digest('hex');
+}
+export function hashShort(content, length = 8) {
+    return hash(content).slice(0, length);
+}
+function normalizeInput(content) {
+    let result = content.replace(/\\/g, '/');
+    result = result.replace(/\n+$/, '');
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { validateConfig, loadConfig, getDefaults } from './config.js';
+export { normalizeSeparators, fileToRoute, extractParams, isDynamic, validateRouteParams, canonicalize } from './path.js';
+export { sortRoutes, sortAlpha, isCorrectOrder } from './order.js';
+export { hash, hashShort } from './hash.js';
+export { createError, formatError, isZenithError, ErrorCodes } from './errors.js';
+export { parseSemver, formatVersion, validateCompatibility } from './version.js';
+export { IR_VERSION, IR_SCHEMA } from './schema.js';
+export { coreModuleSource } from './core-template.js';
+export { containsForbiddenPattern, FORBIDDEN_PATTERNS, BROWSER_GLOBALS } from './guards.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { validateConfig, loadConfig, getDefaults } from './config.js';
+export { normalizeSeparators, fileToRoute, extractParams, isDynamic, validateRouteParams, canonicalize } from './path.js';
+export { sortRoutes, sortAlpha, isCorrectOrder } from './order.js';
+export { hash, hashShort } from './hash.js';
+export { createError, formatError, isZenithError, ErrorCodes } from './errors.js';
+export { parseSemver, formatVersion, validateCompatibility } from './version.js';
+export { IR_VERSION, IR_SCHEMA } from './schema.js';
+export { coreModuleSource } from './core-template.js';
+export { containsForbiddenPattern, FORBIDDEN_PATTERNS, BROWSER_GLOBALS } from './guards.js';

package/dist/ir/index.js

@@ -0,0 +1 @@
+export { IR_VERSION, IR_SCHEMA } from '../schema.js';

package/dist/order.d.ts

@@ -0,0 +1,6 @@
+export interface RouteEntry {
+    path: string;
+}
+export declare function sortRoutes<T extends RouteEntry>(entries: T[]): T[];
+export declare function sortAlpha(items: string[]): string[];
+export declare function isCorrectOrder<T extends RouteEntry>(entries: T[]): boolean;

package/dist/order.js

@@ -0,0 +1,21 @@
+function isDynamicRoute(routePath) {
+    return routePath.includes(':');
+}
+export function sortRoutes(entries) {
+    return [...entries].sort((a, b) => {
+        const aDynamic = isDynamicRoute(a.path);
+        const bDynamic = isDynamicRoute(b.path);
+        if (!aDynamic && bDynamic)
+            return -1;
+        if (aDynamic && !bDynamic)
+            return 1;
+        return a.path.localeCompare(b.path);
+    });
+}
+export function sortAlpha(items) {
+    return [...items].sort((a, b) => a.localeCompare(b));
+}
+export function isCorrectOrder(entries) {
+    const sorted = sortRoutes(entries);
+    return entries.every((entry, i) => entry.path === sorted[i]?.path);
+}

package/dist/path.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeSeparators(filePath: string): string;
+export declare function fileToRoute(filePath: string, extension?: string): string;
+export declare function extractParams(routePath: string): string[];
+export declare function isDynamic(routePath: string): boolean;
+export declare function validateRouteParams(routePath: string): void;
+export declare function canonicalize(routePath: string): string;

package/dist/path.js

@@ -0,0 +1,53 @@
+export function normalizeSeparators(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+export function fileToRoute(filePath, extension = '.zen') {
+    let route = normalizeSeparators(filePath);
+    if (route.endsWith(extension)) {
+        route = route.slice(0, -extension.length);
+    }
+    route = route.replace(/\[([^\]]+)\]/g, ':$1');
+    if (route === 'index') {
+        return '/';
+    }
+    if (route.endsWith('/index')) {
+        route = route.slice(0, -'/index'.length);
+    }
+    if (!route.startsWith('/')) {
+        route = `/${route}`;
+    }
+    return route;
+}
+export function extractParams(routePath) {
+    const params = [];
+    const segments = routePath.split('/');
+    for (const segment of segments) {
+        if (segment.startsWith(':')) {
+            params.push(segment.slice(1));
+        }
+    }
+    return params;
+}
+export function isDynamic(routePath) {
+    return routePath.includes(':');
+}
+export function validateRouteParams(routePath) {
+    const params = extractParams(routePath);
+    const seen = new Set();
+    for (const param of params) {
+        if (seen.has(param)) {
+            throw new Error(`[Zenith:Path] Repeated parameter name ":${param}" in route "${routePath}"`);
+        }
+        seen.add(param);
+    }
+}
+export function canonicalize(routePath) {
+    let path = normalizeSeparators(routePath);
+    if (path.length > 1 && path.endsWith('/')) {
+        path = path.slice(0, -1);
+    }
+    if (!path.startsWith('/')) {
+        path = `/${path}`;
+    }
+    return path;
+}

package/dist/schema.d.ts

@@ -0,0 +1,5 @@
+export declare const IR_VERSION = 1;
+export declare const IR_SCHEMA: Readonly<{
+    version: 1;
+    requiredTopLevelKeys: readonly string[];
+}>;

package/{src → dist}/schema.js

@@ -1,9 +1,4 @@
-// ---------------------------------------------------------------------------
-// schema.js — Zenith Core IR authority
-// ---------------------------------------------------------------------------
-
 export const IR_VERSION = 1;
-
 export const IR_SCHEMA = Object.freeze({
     version: IR_VERSION,
     requiredTopLevelKeys: Object.freeze([

package/dist/version.d.ts

@@ -0,0 +1,8 @@
+export interface SemverVersion {
+    major: number;
+    minor: number;
+    patch: number;
+}
+export declare function parseSemver(version: string): SemverVersion;
+export declare function formatVersion(ver: SemverVersion): string;
+export declare function validateCompatibility(coreVersion: string, otherVersion: string): string | null;

package/dist/version.js

@@ -0,0 +1,27 @@
+export function parseSemver(version) {
+    const cleaned = version.replace(/^v/, '');
+    const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match) {
+        throw new Error(`[Zenith:Version] Invalid semver: "${version}"`);
+    }
+    return {
+        major: Number.parseInt(match[1], 10),
+        minor: Number.parseInt(match[2], 10),
+        patch: Number.parseInt(match[3], 10)
+    };
+}
+export function formatVersion(ver) {
+    return `${ver.major}.${ver.minor}.${ver.patch}`;
+}
+export function validateCompatibility(coreVersion, otherVersion) {
+    const core = parseSemver(coreVersion);
+    const other = parseSemver(otherVersion);
+    if (core.major !== other.major) {
+        throw new Error(`[Zenith:Version] Incompatible major versions: core=${formatVersion(core)}, other=${formatVersion(other)}`);
+    }
+    const minorDiff = Math.abs(core.minor - other.minor);
+    if (minorDiff > 1) {
+        return `[Zenith:Version] Minor version drift: core=${formatVersion(core)}, other=${formatVersion(other)} (diff=${minorDiff})`;
+    }
+    return null;
+}

package/package.json

@@ -1,55 +1,71 @@
 {
   "name": "@zenithbuild/core",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Deterministic utility substrate for the Zenith framework",
   "license": "MIT",
   "type": "module",
-  "main": "./src/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "bin": {
     "zenith": "bin/zenith.js"
   },
   "exports": {
-    ".": "./src/index.js",
-    "./config": "./src/config.js",
-    "./path": "./src/path.js",
-    "./order": "./src/order.js",
-    "./hash": "./src/hash.js",
-    "./errors": "./src/errors.js",
-    "./version": "./src/version.js",
-    "./guards": "./src/guards.js",
-    "./schema": "./src/schema.js",
-    "./core-template": "./src/core-template.js",
-    "./ir": "./src/ir/index.js"
+    ".": "./dist/index.js",
+    "./config": "./dist/config.js",
+    "./path": "./dist/path.js",
+    "./order": "./dist/order.js",
+    "./hash": "./dist/hash.js",
+    "./errors": "./dist/errors.js",
+    "./version": "./dist/version.js",
+    "./guards": "./dist/guards.js",
+    "./schema": "./dist/schema.js",
+    "./core-template": "./dist/core-template.js",
+    "./ir": "./dist/ir/index.js"
   },
   "files": [
-    "src",
+    "dist",
     "bin",
     "CORE_CONTRACT.md",
     "README.md",
-    "contracts"
+    "LICENSE",
+    "package.json"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zenithbuild/framework",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/zenithbuild/framework/issues"
+  },
+  "homepage": "https://github.com/zenithbuild/framework#readme",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@zenithbuild/cli": "^0.6.5",
-    "@zenithbuild/compiler": "^0.6.5",
-    "@zenithbuild/runtime": "^0.6.5",
-    "@zenithbuild/router": "^0.6.5",
-    "@zenithbuild/bundler": "^0.6.5"
+    "@zenithbuild/cli": "0.6.7",
+    "@zenithbuild/compiler": "0.6.7",
+    "@zenithbuild/runtime": "0.6.7",
+    "@zenithbuild/router": "0.6.7",
+    "@zenithbuild/bundler": "0.6.7"
   },
   "scripts": {
-    "test": "npm run contract:deps && npm run contract:scan && npm run contract:api && npm run contract:template && npm run contract:golden",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && npm run contract:deps && npm run contract:scan && npm run contract:api && npm run contract:template && npm run contract:golden && npm run test:legacy",
     "test:legacy": "NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.js",
     "contract:deps": "node dependency_contract.spec.js",
     "contract:scan": "node contract-scan.mjs",
     "contract:api": "node core_api_lock.spec.js",
     "contract:template": "node template-contract.spec.js",
-    "contract:golden": "node golden-contract.spec.js"
+    "contract:golden": "node golden-contract.spec.js",
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
+    "@types/node": "latest",
     "@jest/globals": "^30.2.0",
-    "jest": "^30.2.0"
+    "jest": "^30.2.0",
+    "typescript": "^5.7.3"
   },
   "private": false
 }

package/src/config.js

@@ -1,136 +0,0 @@
-// ---------------------------------------------------------------------------
-// config.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// Load and validate zenith.config.js. This is the ONLY module in core
-// that touches the filesystem (via dynamic import).
-//
-// V0 Schema: { router, outDir, pagesDir }
-// Unknown keys → throw.
-// ---------------------------------------------------------------------------
-
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-/** V0 config defaults */
-const DEFAULTS = {
-    router: false,
-    embeddedMarkupExpressions: false,
-    types: true,
-    typescriptDefault: true,
-    outDir: 'dist',
-    pagesDir: 'pages',
-    experimental: {},
-    strictDomLints: false
-};
-
-/** Allowed keys and their expected types */
-const SCHEMA = {
-    router: 'boolean',
-    embeddedMarkupExpressions: 'boolean',
-    types: 'boolean',
-    typescriptDefault: 'boolean',
-    outDir: 'string',
-    pagesDir: 'string',
-    experimental: 'object',
-    strictDomLints: 'boolean'
-};
-
-/**
- * Validate a config object against the V0 schema.
- * Throws on unknown keys or wrong types.
- *
- * @param {object} config
- * @returns {object} Normalized config with defaults applied
- */
-export function validateConfig(config) {
-    if (config === null || config === undefined) {
-        return { ...DEFAULTS };
-    }
-
-    if (typeof config !== 'object' || Array.isArray(config)) {
-        throw new Error('[Zenith:Config] Config must be a plain object');
-    }
-
-    // Check for unknown keys
-    for (const key of Object.keys(config)) {
-        if (!(key in SCHEMA)) {
-            throw new Error(`[Zenith:Config] Unknown key: "${key}"`);
-        }
-    }
-
-    // Validate types and apply defaults
-    const result = { ...DEFAULTS };
-
-    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' && 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`);
-                }
-                const expDefaults = { ...DEFAULTS.experimental };
-                for (const expKey of Object.keys(value)) {
-                    if (!(expKey in expDefaults)) {
-                        throw new Error(`[Zenith:Config] Unknown experimental key: "${expKey}"`);
-                    }
-                    if (typeof value[expKey] !== typeof expDefaults[expKey]) {
-                        throw new Error(`[Zenith:Config] Experimental key "${expKey}" must be ${typeof expDefaults[expKey]}`);
-                    }
-                    expDefaults[expKey] = value[expKey];
-                }
-                result[key] = expDefaults;
-                continue;
-            }
-            result[key] = value;
-        }
-    }
-
-    return result;
-}
-
-/**
- * Load zenith.config.js from a project root.
- * Returns validated config with defaults applied.
- *
- * @param {string} projectRoot
- * @returns {Promise<object>}
- */
-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) {
-        // File not found — return defaults
-        if (
-            err.code === 'ERR_MODULE_NOT_FOUND' ||
-            err.code === 'ENOENT' ||
-            err.message?.includes('Cannot find module') ||
-            err.message?.includes('ENOENT')
-        ) {
-            return { ...DEFAULTS };
-        }
-        throw err;
-    }
-}
-
-/**
- * Return the default config.
- * @returns {object}
- */
-export function getDefaults() {
-    return { ...DEFAULTS };
-}

package/src/errors.js

@@ -1,54 +0,0 @@
-// ---------------------------------------------------------------------------
-// errors.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// Shared error formatting. All Zenith errors use the format:
-//   [Zenith:MODULE] message
-//
-// Pure factory functions. No side effects.
-// ---------------------------------------------------------------------------
-
-/**
- * Create a Zenith error with standard formatting.
- *
- * @param {string} module  Module name (e.g. 'Config', 'Path', 'Build')
- * @param {string} message  Error message
- * @returns {Error}
- */
-export function createError(module, message) {
-    const err = new Error(`[Zenith:${module}] ${message}`);
-    err.zenithModule = module;
-    return err;
-}
-
-/**
- * Format an error message with the Zenith prefix.
- *
- * @param {string} module
- * @param {string} message
- * @returns {string}
- */
-export function formatError(module, message) {
-    return `[Zenith:${module}] ${message}`;
-}
-
-/**
- * Check if an error is a Zenith error.
- *
- * @param {Error} err
- * @returns {boolean}
- */
-export function isZenithError(err) {
-    return err instanceof Error && typeof err.zenithModule === 'string';
-}
-
-/**
- * Predefined error codes for common situations.
- */
-export const ErrorCodes = {
-    CONFIG_UNKNOWN_KEY: 'CONFIG_UNKNOWN_KEY',
-    CONFIG_INVALID_TYPE: 'CONFIG_INVALID_TYPE',
-    CONFIG_EMPTY_VALUE: 'CONFIG_EMPTY_VALUE',
-    PATH_REPEATED_PARAM: 'PATH_REPEATED_PARAM',
-    VERSION_INCOMPATIBLE: 'VERSION_INCOMPATIBLE',
-    GUARD_VIOLATION: 'GUARD_VIOLATION'
-};

package/src/guards.js

@@ -1,61 +0,0 @@
-// ---------------------------------------------------------------------------
-// guards.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// Small pure validation helpers. These provide primitives —
-// they do NOT scan repos, enforce architecture, or police other layers.
-// ---------------------------------------------------------------------------
-
-/**
- * Check if source contains any of the given forbidden patterns.
- *
- * @param {string} source  Source code text
- * @param {string[]} patterns  Patterns to check for
- * @returns {string[]}  Array of matched patterns (empty if none)
- */
-export function containsForbiddenPattern(source, patterns) {
-    const found = [];
-    for (const pattern of patterns) {
-        if (source.includes(pattern)) {
-            found.push(pattern);
-        }
-    }
-    return found;
-}
-
-/**
- * Validate that a route path has no repeated parameter names.
- * Re-exported from path.js for convenience.
- *
- * @param {string} routePath
- */
-export { validateRouteParams } from './path.js';
-
-/**
- * Validate a config object against the V0 schema.
- * Re-exported from config.js for convenience.
- *
- * @param {object} config
- * @returns {object}
- */
-export { validateConfig as validateConfigSchema } from './config.js';
-
-/**
- * Default forbidden patterns for Zenith source code.
- */
-export const FORBIDDEN_PATTERNS = [
-    'eval(',
-    'new Function(',
-    'new Function (',
-    'document.write('
-];
-
-/**
- * Default browser globals that should not appear in Node-only code.
- */
-export const BROWSER_GLOBALS = [
-    'window',
-    'document',
-    'navigator',
-    'localStorage',
-    'sessionStorage'
-];

package/src/hash.js

@@ -1,52 +0,0 @@
-// ---------------------------------------------------------------------------
-// hash.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// Deterministic content hashing. SHA-256, hex output.
-//
-// CRITICAL: This algorithm must match the bundler's hashing exactly.
-// If bundler changes hash algorithm, core must change in lockstep.
-//
-// Input normalization:
-//   - Path separators → /
-//   - Trailing newlines stripped
-// ---------------------------------------------------------------------------
-
-import { createHash } from 'node:crypto';
-
-/**
- * Hash a string using SHA-256. Returns hex digest.
- *
- * @param {string} content
- * @returns {string}
- */
-export function hash(content) {
-    const normalized = _normalizeInput(content);
-    return createHash('sha256').update(normalized).digest('hex');
-}
-
-/**
- * Hash a string and return a truncated hash (first N characters).
- * Useful for content-hashed filenames.
- *
- * @param {string} content
- * @param {number} [length=8]
- * @returns {string}
- */
-export function hashShort(content, length = 8) {
-    return hash(content).slice(0, length);
-}
-
-/**
- * Normalize input for deterministic hashing.
- * - Replaces backslashes with forward slashes
- * - Strips trailing newlines
- *
- * @param {string} content
- * @returns {string}
- */
-function _normalizeInput(content) {
-    let result = content.replace(/\\/g, '/');
-    // Strip trailing newlines
-    result = result.replace(/\n+$/, '');
-    return result;
-}

package/src/index.js

@@ -1,26 +0,0 @@
-// ---------------------------------------------------------------------------
-// index.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// Public API. Re-exports frozen module namespaces only.
-// ---------------------------------------------------------------------------
-
-export { validateConfig, loadConfig, getDefaults } from './config.js';
-export {
-    normalizeSeparators,
-    fileToRoute,
-    extractParams,
-    isDynamic,
-    validateRouteParams,
-    canonicalize
-} from './path.js';
-export { sortRoutes, sortAlpha, isCorrectOrder } from './order.js';
-export { hash, hashShort } from './hash.js';
-export { createError, formatError, isZenithError, ErrorCodes } from './errors.js';
-export { parseSemver, formatVersion, validateCompatibility } from './version.js';
-export { IR_VERSION, IR_SCHEMA } from './schema.js';
-export { coreModuleSource } from './core-template.js';
-export {
-    containsForbiddenPattern,
-    FORBIDDEN_PATTERNS,
-    BROWSER_GLOBALS
-} from './guards.js';

package/src/order.js

@@ -1,69 +0,0 @@
-// ---------------------------------------------------------------------------
-// order.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// Deterministic ordering utilities. Pure transforms.
-//
-// Sorting contract:
-// 1. Static routes first, dynamic routes second
-// 2. Alphabetical tiebreak within each group
-// 3. Stable across runs
-// ---------------------------------------------------------------------------
-
-/**
- * Check if a route path contains dynamic segments (starts with :).
- *
- * @param {string} routePath
- * @returns {boolean}
- */
-function _isDynamic(routePath) {
-    return routePath.includes(':');
-}
-
-/**
- * Sort route entries deterministically.
- *
- * Rules:
- * 1. Static routes before dynamic routes
- * 2. Alphabetical (lexicographic) within each group
- *
- * Entries must have a `path` property.
- *
- * @param {{ path: string }[]} entries
- * @returns {{ path: string }[]}
- */
-export function sortRoutes(entries) {
-    return [...entries].sort((a, b) => {
-        const aDynamic = _isDynamic(a.path);
-        const bDynamic = _isDynamic(b.path);
-
-        // Static before dynamic
-        if (!aDynamic && bDynamic) return -1;
-        if (aDynamic && !bDynamic) return 1;
-
-        // Alphabetical tiebreak
-        return a.path.localeCompare(b.path);
-    });
-}
-
-/**
- * Sort an array of strings deterministically.
- * Simple alphabetical sort with stable ordering.
- *
- * @param {string[]} items
- * @returns {string[]}
- */
-export function sortAlpha(items) {
-    return [...items].sort((a, b) => a.localeCompare(b));
-}
-
-/**
- * Check if an array of route entries is in correct deterministic order.
- * Does not throw — returns boolean.
- *
- * @param {{ path: string }[]} entries
- * @returns {boolean}
- */
-export function isCorrectOrder(entries) {
-    const sorted = sortRoutes(entries);
-    return entries.every((entry, i) => entry.path === sorted[i].path);
-}

package/src/path.js

@@ -1,131 +0,0 @@
-// ---------------------------------------------------------------------------
-// path.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// Path normalization utilities. Pure transforms — no filesystem access.
-//
-// - Normalizes separators (\ → /)
-// - Converts [param] → :param
-// - Extracts params from route strings
-// - Validates no repeated param names
-// - Strips file extensions
-// ---------------------------------------------------------------------------
-
-/**
- * Normalize path separators to forward slashes.
- *
- * @param {string} filePath
- * @returns {string}
- */
-export function normalizeSeparators(filePath) {
-    return filePath.replace(/\\/g, '/');
-}
-
-/**
- * Convert a file-system path to a route path.
- *
- * Rules:
- * - Normalize separators
- * - Strip the extension
- * - Convert [param] → :param
- * - index files → parent path
- * - Ensure leading /
- *
- * @param {string} filePath  Relative path from pages dir (e.g. "users/[id].zen")
- * @param {string} [extension='.zen']
- * @returns {string}
- */
-export function fileToRoute(filePath, extension = '.zen') {
-    let route = normalizeSeparators(filePath);
-
-    // Strip extension
-    if (route.endsWith(extension)) {
-        route = route.slice(0, -extension.length);
-    }
-
-    // Convert [param] → :param
-    route = route.replace(/\[([^\]]+)\]/g, ':$1');
-
-    // Handle index → parent
-    if (route === 'index') {
-        return '/';
-    }
-    if (route.endsWith('/index')) {
-        route = route.slice(0, -'/index'.length);
-    }
-
-    // Ensure leading /
-    if (!route.startsWith('/')) {
-        route = '/' + route;
-    }
-
-    return route;
-}
-
-/**
- * Extract parameter names from a route path.
- *
- * @param {string} routePath  e.g. "/users/:id/posts/:postId"
- * @returns {string[]}  e.g. ["id", "postId"]
- */
-export function extractParams(routePath) {
-    const params = [];
-    const segments = routePath.split('/');
-    for (const segment of segments) {
-        if (segment.startsWith(':')) {
-            params.push(segment.slice(1));
-        }
-    }
-    return params;
-}
-
-/**
- * Check if a route path contains dynamic segments.
- *
- * @param {string} routePath
- * @returns {boolean}
- */
-export function isDynamic(routePath) {
-    return routePath.includes(':');
-}
-
-/**
- * Validate that a route path has no repeated parameter names.
- * Throws on violation.
- *
- * @param {string} routePath
- */
-export function validateRouteParams(routePath) {
-    const params = extractParams(routePath);
-    const seen = new Set();
-    for (const param of params) {
-        if (seen.has(param)) {
-            throw new Error(
-                `[Zenith:Path] Repeated parameter name ":${param}" in route "${routePath}"`
-            );
-        }
-        seen.add(param);
-    }
-}
-
-/**
- * Canonicalize a route path.
- * Strips trailing slashes (except root), normalizes separators.
- *
- * @param {string} routePath
- * @returns {string}
- */
-export function canonicalize(routePath) {
-    let path = normalizeSeparators(routePath);
-
-    // Remove trailing slash (unless root)
-    if (path.length > 1 && path.endsWith('/')) {
-        path = path.slice(0, -1);
-    }
-
-    // Ensure leading slash
-    if (!path.startsWith('/')) {
-        path = '/' + path;
-    }
-
-    return path;
-}

package/src/version.js

@@ -1,67 +0,0 @@
-// ---------------------------------------------------------------------------
-// version.js — Zenith Core V0
-// ---------------------------------------------------------------------------
-// SemVer parsing and compatibility validation.
-//
-// Direction of control: Other layers call core's version utility.
-// Core never imports other packages to auto-check.
-// ---------------------------------------------------------------------------
-
-/**
- * Parse a SemVer string into components.
- *
- * @param {string} version  e.g. "1.2.3"
- * @returns {{ major: number, minor: number, patch: number }}
- */
-export function parseSemver(version) {
-    const cleaned = version.replace(/^v/, '');
-    const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)/);
-    if (!match) {
-        throw new Error(`[Zenith:Version] Invalid semver: "${version}"`);
-    }
-    return {
-        major: parseInt(match[1], 10),
-        minor: parseInt(match[2], 10),
-        patch: parseInt(match[3], 10)
-    };
-}
-
-/**
- * Format a version object back to a string.
- *
- * @param {{ major: number, minor: number, patch: number }} ver
- * @returns {string}
- */
-export function formatVersion(ver) {
-    return `${ver.major}.${ver.minor}.${ver.patch}`;
-}
-
-/**
- * Validate compatibility between two versions.
- *
- * Rules:
- * - Major versions must match (throws if different)
- * - Minor version difference > 1 produces a warning (returns warning string)
- * - Otherwise returns null (compatible)
- *
- * @param {string} coreVersion
- * @param {string} otherVersion
- * @returns {string|null}  Warning message or null if fully compatible
- */
-export function validateCompatibility(coreVersion, otherVersion) {
-    const core = parseSemver(coreVersion);
-    const other = parseSemver(otherVersion);
-
-    if (core.major !== other.major) {
-        throw new Error(
-            `[Zenith:Version] Incompatible major versions: core=${formatVersion(core)}, other=${formatVersion(other)}`
-        );
-    }
-
-    const minorDiff = Math.abs(core.minor - other.minor);
-    if (minorDiff > 1) {
-        return `[Zenith:Version] Minor version drift: core=${formatVersion(core)}, other=${formatVersion(other)} (diff=${minorDiff})`;
-    }
-
-    return null;
-}