@zenithbuild/cli 0.6.6 → 0.6.9

package/dist/server/resolve-request-route.js

@@ -8,100 +8,89 @@
  * @returns {number}
  */
 export function compareRouteSpecificity(a, b) {
-  if (a === '/' && b !== '/') return -1;
-  if (b === '/' && a !== '/') return 1;
-
-  const aSegs = splitPath(a);
-  const bSegs = splitPath(b);
-  const aClass = routeClass(aSegs);
-  const bClass = routeClass(bSegs);
-  if (aClass !== bClass) {
-    return bClass - aClass;
-  }
-
-  const max = Math.min(aSegs.length, bSegs.length);
-  for (let i = 0; i < max; i++) {
-    const aWeight = segmentWeight(aSegs[i]);
-    const bWeight = segmentWeight(bSegs[i]);
-    if (aWeight !== bWeight) {
-      return bWeight - aWeight;
+    if (a === '/' && b !== '/')
+        return -1;
+    if (b === '/' && a !== '/')
+        return 1;
+    const aSegs = splitPath(a);
+    const bSegs = splitPath(b);
+    const aClass = routeClass(aSegs);
+    const bClass = routeClass(bSegs);
+    if (aClass !== bClass) {
+        return bClass - aClass;
     }
-  }
-
-  if (aSegs.length !== bSegs.length) {
-    return bSegs.length - aSegs.length;
-  }
-
-  return a.localeCompare(b);
+    const max = Math.min(aSegs.length, bSegs.length);
+    for (let i = 0; i < max; i++) {
+        const aWeight = segmentWeight(aSegs[i]);
+        const bWeight = segmentWeight(bSegs[i]);
+        if (aWeight !== bWeight) {
+            return bWeight - aWeight;
+        }
+    }
+    if (aSegs.length !== bSegs.length) {
+        return bSegs.length - aSegs.length;
+    }
+    return a.localeCompare(b);
 }
-
 /**
  * @param {string} pathname
  * @param {Array<{ path: string }>} routes
  * @returns {{ entry: { path: string }, params: Record<string, string> } | null}
  */
 export function matchRoute(pathname, routes) {
-  const target = splitPath(pathname);
-  const ordered = [...routes].sort((a, b) => compareRouteSpecificity(a.path, b.path));
-  for (const entry of ordered) {
-    const pattern = splitPath(entry.path);
-    const params = Object.create(null);
-    let patternIndex = 0;
-    let valueIndex = 0;
-    let matched = true;
-
-    while (patternIndex < pattern.length) {
-      const segment = pattern[patternIndex];
-      if (segment.startsWith('*')) {
-        const optionalCatchAll = segment.endsWith('?');
-        const key = optionalCatchAll ? segment.slice(1, -1) : segment.slice(1);
-        if (patternIndex !== pattern.length - 1) {
-          matched = false;
-          break;
+    const target = splitPath(pathname);
+    const ordered = [...routes].sort((a, b) => compareRouteSpecificity(a.path, b.path));
+    for (const entry of ordered) {
+        const pattern = splitPath(entry.path);
+        const params = Object.create(null);
+        let patternIndex = 0;
+        let valueIndex = 0;
+        let matched = true;
+        while (patternIndex < pattern.length) {
+            const segment = pattern[patternIndex];
+            if (segment.startsWith('*')) {
+                const optionalCatchAll = segment.endsWith('?');
+                const key = optionalCatchAll ? segment.slice(1, -1) : segment.slice(1);
+                if (patternIndex !== pattern.length - 1) {
+                    matched = false;
+                    break;
+                }
+                const rest = target.slice(valueIndex);
+                const rootRequiredCatchAll = !optionalCatchAll && pattern.length === 1;
+                if (rest.length === 0 && !optionalCatchAll && !rootRequiredCatchAll) {
+                    matched = false;
+                    break;
+                }
+                params[key] = normalizeCatchAll(rest);
+                valueIndex = target.length;
+                patternIndex = pattern.length;
+                break;
+            }
+            if (valueIndex >= target.length) {
+                matched = false;
+                break;
+            }
+            const value = target[valueIndex];
+            if (segment.startsWith(':')) {
+                params[segment.slice(1)] = value;
+            }
+            else if (segment !== value) {
+                matched = false;
+                break;
+            }
+            patternIndex += 1;
+            valueIndex += 1;
         }
-        const rest = target.slice(valueIndex);
-        const rootRequiredCatchAll = !optionalCatchAll && pattern.length === 1;
-        if (rest.length === 0 && !optionalCatchAll && !rootRequiredCatchAll) {
-          matched = false;
-          break;
+        if (!matched) {
+            continue;
         }
-        params[key] = normalizeCatchAll(rest);
-        valueIndex = target.length;
-        patternIndex = pattern.length;
-        break;
-      }
-
-      if (valueIndex >= target.length) {
-        matched = false;
-        break;
-      }
-
-      const value = target[valueIndex];
-      if (segment.startsWith(':')) {
-        params[segment.slice(1)] = value;
-      } else if (segment !== value) {
-        matched = false;
-        break;
-      }
-
-      patternIndex += 1;
-      valueIndex += 1;
-    }
-
-    if (!matched) {
-      continue;
-    }
-
-    if (valueIndex !== target.length || patternIndex !== pattern.length) {
-      continue;
+        if (valueIndex !== target.length || patternIndex !== pattern.length) {
+            continue;
+        }
+        return { entry, params: { ...params } };
     }
-
-    return { entry, params: { ...params } };
-  }
-
-  return null;
+    return null;
 }
-
 /**
  * Resolve an incoming request URL against a manifest route list.
  *
@@ -110,60 +99,62 @@ export function matchRoute(pathname, routes) {
  * @returns {{ matched: boolean, route: { path: string } | null, params: Record<string, string> }}
  */
 export function resolveRequestRoute(reqUrl, manifest) {
-  const url = reqUrl instanceof URL ? reqUrl : new URL(String(reqUrl), 'http://localhost');
-  const matched = matchRoute(url.pathname, manifest);
-  if (!matched) {
-    return { matched: false, route: null, params: {} };
-  }
-  return {
-    matched: true,
-    route: matched.entry,
-    params: matched.params
-  };
+    const url = reqUrl instanceof URL ? reqUrl : new URL(String(reqUrl), 'http://localhost');
+    const matched = matchRoute(url.pathname, manifest);
+    if (!matched) {
+        return { matched: false, route: null, params: {} };
+    }
+    return {
+        matched: true,
+        route: matched.entry,
+        params: matched.params
+    };
 }
-
 /**
  * @param {string[]} segments
  * @returns {number}
  */
 function routeClass(segments) {
-  let hasParam = false;
-  let hasCatchAll = false;
-  for (const segment of segments) {
-    if (segment.startsWith('*')) {
-      hasCatchAll = true;
-    } else if (segment.startsWith(':')) {
-      hasParam = true;
+    let hasParam = false;
+    let hasCatchAll = false;
+    for (const segment of segments) {
+        if (segment.startsWith('*')) {
+            hasCatchAll = true;
+        }
+        else if (segment.startsWith(':')) {
+            hasParam = true;
+        }
     }
-  }
-  if (!hasParam && !hasCatchAll) return 3;
-  if (hasCatchAll) return 1;
-  return 2;
+    if (!hasParam && !hasCatchAll)
+        return 3;
+    if (hasCatchAll)
+        return 1;
+    return 2;
 }
-
 /**
  * @param {string | undefined} segment
  * @returns {number}
  */
 function segmentWeight(segment) {
-  if (!segment) return 0;
-  if (segment.startsWith('*')) return 1;
-  if (segment.startsWith(':')) return 2;
-  return 3;
+    if (!segment)
+        return 0;
+    if (segment.startsWith('*'))
+        return 1;
+    if (segment.startsWith(':'))
+        return 2;
+    return 3;
 }
-
 /**
  * @param {string} pathname
  * @returns {string[]}
  */
 function splitPath(pathname) {
-  return pathname.split('/').filter(Boolean);
+    return pathname.split('/').filter(Boolean);
 }
-
 /**
  * @param {string[]} segments
  * @returns {string}
  */
 function normalizeCatchAll(segments) {
-  return segments.filter(Boolean).join('/');
+    return segments.filter(Boolean).join('/');
 }

package/dist/server-contract.d.ts

@@ -0,0 +1,39 @@
+export function allow(): {
+    kind: string;
+};
+export function redirect(location: any, status?: number): {
+    kind: string;
+    location: string;
+    status: number;
+};
+export function deny(status?: number, message?: undefined): {
+    kind: string;
+    status: number;
+    message: undefined;
+};
+export function data(payload: any): {
+    kind: string;
+    data: any;
+};
+export function validateServerExports({ exports, filePath }: {
+    exports: any;
+    filePath: any;
+}): void;
+export function assertJsonSerializable(value: any, where?: string): void;
+export function resolveRouteResult({ exports, ctx, filePath, guardOnly }: {
+    exports: any;
+    ctx: any;
+    filePath: any;
+    guardOnly?: boolean | undefined;
+}): Promise<{
+    result: any;
+    trace: {
+        guard: string;
+        load: string;
+    };
+}>;
+export function resolveServerPayload({ exports, ctx, filePath }: {
+    exports: any;
+    ctx: any;
+    filePath: any;
+}): Promise<any>;

package/dist/server-contract.js

@@ -1,17 +1,13 @@
 // server-contract.js — Zenith CLI V0
 // ---------------------------------------------------------------------------
 // Shared validation and payload resolution logic for <script server> blocks.
-
 const NEW_KEYS = new Set(['data', 'load', 'guard', 'prerender']);
 const LEGACY_KEYS = new Set(['ssr_data', 'props', 'ssr', 'prerender']);
 const ALLOWED_KEYS = new Set(['data', 'load', 'guard', 'prerender', 'ssr_data', 'props', 'ssr']);
-
 const ROUTE_RESULT_KINDS = new Set(['allow', 'redirect', 'deny', 'data']);
-
 export function allow() {
     return { kind: 'allow' };
 }
-
 export function redirect(location, status = 302) {
     return {
         kind: 'redirect',
@@ -19,7 +15,6 @@ export function redirect(location, status = 302) {
         status: Number.isInteger(status) ? status : 302
     };
 }
-
 export function deny(status = 403, message = undefined) {
     return {
         kind: 'deny',
@@ -27,11 +22,9 @@ export function deny(status = 403, message = undefined) {
         message: typeof message === 'string' ? message : undefined
     };
 }
-
 export function data(payload) {
     return { kind: 'data', data: payload };
 }
-
 function isRouteResultLike(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return false;
@@ -39,18 +32,14 @@ function isRouteResultLike(value) {
     const kind = value.kind;
     return typeof kind === 'string' && ROUTE_RESULT_KINDS.has(kind);
 }
-
 function assertValidRouteResultShape(value, where, allowedKinds) {
     if (!isRouteResultLike(value)) {
         throw new Error(`[Zenith] ${where}: invalid route result. Expected object with kind.`);
     }
     const kind = value.kind;
     if (!allowedKinds.has(kind)) {
-        throw new Error(
-            `[Zenith] ${where}: kind "${kind}" is not allowed here (allowed: ${Array.from(allowedKinds).join(', ')}).`
-        );
+        throw new Error(`[Zenith] ${where}: kind "${kind}" is not allowed here (allowed: ${Array.from(allowedKinds).join(', ')}).`);
     }
-
     if (kind === 'redirect') {
         if (typeof value.location !== 'string' || value.location.length === 0) {
             throw new Error(`[Zenith] ${where}: redirect requires non-empty string location.`);
@@ -59,7 +48,6 @@ function assertValidRouteResultShape(value, where, allowedKinds) {
             throw new Error(`[Zenith] ${where}: redirect status must be an integer 3xx.`);
         }
     }
-
     if (kind === 'deny') {
         if (!Number.isInteger(value.status) || (value.status !== 401 && value.status !== 403)) {
             throw new Error(`[Zenith] ${where}: deny status must be 401 or 403.`);
@@ -69,36 +57,26 @@ function assertValidRouteResultShape(value, where, allowedKinds) {
         }
     }
 }
-
 export function validateServerExports({ exports, filePath }) {
     const exportKeys = Object.keys(exports);
     const illegalKeys = exportKeys.filter(k => !ALLOWED_KEYS.has(k));
-
     if (illegalKeys.length > 0) {
         throw new Error(`[Zenith] ${filePath}: illegal export(s): ${illegalKeys.join(', ')}`);
     }
-
     const hasData = 'data' in exports;
     const hasLoad = 'load' in exports;
     const hasGuard = 'guard' in exports;
-
     const hasNew = hasData || hasLoad;
     const hasLegacy = ('ssr_data' in exports) || ('props' in exports) || ('ssr' in exports);
-
     if (hasData && hasLoad) {
         throw new Error(`[Zenith] ${filePath}: cannot export both "data" and "load". Choose one.`);
     }
-
     if (hasNew && hasLegacy) {
-        throw new Error(
-            `[Zenith] ${filePath}: cannot mix new ("data"/"load") with legacy ("ssr_data"/"props"/"ssr") exports.`
-        );
+        throw new Error(`[Zenith] ${filePath}: cannot mix new ("data"/"load") with legacy ("ssr_data"/"props"/"ssr") exports.`);
     }
-
     if ('prerender' in exports && typeof exports.prerender !== 'boolean') {
         throw new Error(`[Zenith] ${filePath}: "prerender" must be a boolean.`);
     }
-
     if (hasLoad && typeof exports.load !== 'function') {
         throw new Error(`[Zenith] ${filePath}: "load" must be a function.`);
     }
@@ -112,7 +90,6 @@ export function validateServerExports({ exports, filePath }) {
             throw new Error(`[Zenith] ${filePath}: "load(ctx)" must not contain rest parameters.`);
         }
     }
-
     if (hasGuard && typeof exports.guard !== 'function') {
         throw new Error(`[Zenith] ${filePath}: "guard" must be a function.`);
     }
@@ -127,53 +104,45 @@ export function validateServerExports({ exports, filePath }) {
         }
     }
 }
-
 export function assertJsonSerializable(value, where = 'payload') {
     const seen = new Set();
-
     function walk(v, path) {
         const t = typeof v;
-
-        if (v === null) return;
-        if (t === 'string' || t === 'number' || t === 'boolean') return;
-
+        if (v === null)
+            return;
+        if (t === 'string' || t === 'number' || t === 'boolean')
+            return;
         if (t === 'bigint' || t === 'function' || t === 'symbol') {
             throw new Error(`[Zenith] ${where}: non-serializable ${t} at ${path}`);
         }
-
         if (t === 'undefined') {
             throw new Error(`[Zenith] ${where}: undefined is not allowed at ${path}`);
         }
-
         if (v instanceof Date) {
             throw new Error(`[Zenith] ${where}: Date is not allowed at ${path} (convert to ISO string)`);
         }
-
         if (v instanceof Map || v instanceof Set) {
             throw new Error(`[Zenith] ${where}: Map/Set not allowed at ${path}`);
         }
-
         if (t === 'object') {
-            if (seen.has(v)) throw new Error(`[Zenith] ${where}: circular reference at ${path}`);
+            if (seen.has(v))
+                throw new Error(`[Zenith] ${where}: circular reference at ${path}`);
             seen.add(v);
-
             if (Array.isArray(v)) {
                 if (path === '$') {
                     throw new Error(`[Zenith] ${where}: top-level payload must be a plain object, not an array at ${path}`);
                 }
-                for (let i = 0; i < v.length; i++) walk(v[i], `${path}[${i}]`);
+                for (let i = 0; i < v.length; i++)
+                    walk(v[i], `${path}[${i}]`);
                 return;
             }
-
             const proto = Object.getPrototypeOf(v);
             const isPlainObject = proto === null ||
                 proto === Object.prototype ||
                 (proto && proto.constructor && proto.constructor.name === 'Object');
-
             if (!isPlainObject) {
                 throw new Error(`[Zenith] ${where}: non-plain object at ${path}`);
             }
-
             for (const k of Object.keys(v)) {
                 if (k === '__proto__' || k === 'constructor' || k === 'prototype') {
                     throw new Error(`[Zenith] ${where}: forbidden prototype pollution key "${k}" at ${path}.${k}`);
@@ -182,54 +151,40 @@ export function assertJsonSerializable(value, where = 'payload') {
             }
             return;
         }
-
         throw new Error(`[Zenith] ${where}: unsupported type at ${path}`);
     }
-
     walk(value, '$');
 }
-
 export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = false }) {
     validateServerExports({ exports, filePath });
-
     const trace = {
         guard: 'none',
         load: 'none'
     };
-
     if ('guard' in exports) {
         const guardRaw = await exports.guard(ctx);
         const guardResult = guardRaw == null ? allow() : guardRaw;
         if (guardResult.kind === 'data') {
             throw new Error(`[Zenith] ${filePath}: guard(ctx) returned data(payload) which is a critical invariant violation. guard() can only return allow(), redirect(), or deny(). Use load(ctx) for data injection.`);
         }
-        assertValidRouteResultShape(
-            guardResult,
-            `${filePath}: guard(ctx) return`,
-            new Set(['allow', 'redirect', 'deny'])
-        );
+        assertValidRouteResultShape(guardResult, `${filePath}: guard(ctx) return`, new Set(['allow', 'redirect', 'deny']));
         trace.guard = guardResult.kind;
         if (guardResult.kind === 'redirect' || guardResult.kind === 'deny') {
             return { result: guardResult, trace };
         }
     }
-
     if (guardOnly) {
         return { result: allow(), trace };
     }
-
     let payload;
     if ('load' in exports) {
         const loadRaw = await exports.load(ctx);
         let loadResult = null;
         if (isRouteResultLike(loadRaw)) {
             loadResult = loadRaw;
-            assertValidRouteResultShape(
-                loadResult,
-                `${filePath}: load(ctx) return`,
-                new Set(['data', 'redirect', 'deny'])
-            );
-        } else {
+            assertValidRouteResultShape(loadResult, `${filePath}: load(ctx) return`, new Set(['data', 'redirect', 'deny']));
+        }
+        else {
             assertJsonSerializable(loadRaw, `${filePath}: load(ctx) return`);
             loadResult = data(loadRaw);
         }
@@ -242,7 +197,6 @@ export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = f
         trace.load = 'data';
         return { result: data(payload), trace };
     }
-
     // legacy fallback
     if ('ssr_data' in exports) {
         payload = exports.ssr_data;
@@ -262,24 +216,18 @@ export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = f
         trace.load = 'data';
         return { result: data(payload), trace };
     }
-
     return { result: data({}), trace };
 }
-
 export async function resolveServerPayload({ exports, ctx, filePath }) {
     const resolved = await resolveRouteResult({ exports, ctx, filePath });
     if (!resolved || !resolved.result || typeof resolved.result !== 'object') {
         return {};
     }
-
     if (resolved.result.kind === 'data') {
         return resolved.result.data;
     }
     if (resolved.result.kind === 'allow') {
         return {};
     }
-
-    throw new Error(
-        `[Zenith] ${filePath}: resolveServerPayload() expected data but received ${resolved.result.kind}. Use resolveRouteResult() for guard/load flows.`
-    );
+    throw new Error(`[Zenith] ${filePath}: resolveServerPayload() expected data but received ${resolved.result.kind}. Use resolveRouteResult() for guard/load flows.`);
 }

package/dist/toolchain-paths.d.ts

@@ -0,0 +1,23 @@
+export type ToolchainTool = 'compiler' | 'bundler';
+export type ToolchainMode = 'binary' | 'node-bridge';
+export interface ToolchainCandidate {
+    tool: ToolchainTool;
+    mode: ToolchainMode;
+    source: string;
+    sourceKey: string;
+    label: string;
+    path: string;
+    command: string;
+    argsPrefix: string[];
+    explicit?: boolean;
+}
+export declare function resolveBinary(candidates: Array<string | ToolchainCandidate>): string;
+export declare function resolvePackageRoot(packageName: string, projectRoot?: string | null): string | null;
+export declare function readInstalledPackageVersion(packageName: string, projectRoot?: string | null): string | null;
+export declare function readCliPackageVersion(): string;
+export declare function compilerCommandCandidates(projectRoot?: string | null, env?: NodeJS.ProcessEnv): ToolchainCandidate[];
+export declare function compilerBinCandidates(projectRoot?: string | null, env?: NodeJS.ProcessEnv): string[];
+export declare function resolveCompilerBin(projectRoot?: string | null, env?: NodeJS.ProcessEnv): string;
+export declare function bundlerCommandCandidates(projectRoot?: string | null, env?: NodeJS.ProcessEnv): ToolchainCandidate[];
+export declare function resolveBundlerBin(projectRoot?: string | null, env?: NodeJS.ProcessEnv): string;
+export declare function bundlerBinCandidates(projectRoot?: string | null, env?: NodeJS.ProcessEnv): string[];