@zenithbuild/cli 0.6.17 → 0.7.1

package/dist/server-script-composition.js

@@ -0,0 +1,133 @@
+import { existsSync } from 'node:fs';
+import { basename, dirname, extname, join, relative } from 'node:path';
+const DATA_EXPORT_RE = /\bexport\s+const\s+data\b/;
+const LEGACY_EXPORT_RE = /\bexport\s+const\s+(?:ssr_data|props|ssr)\b/;
+/**
+ * @param {string} sourceFile
+ * @param {'guard' | 'load'} kind
+ * @returns {string[]}
+ */
+function adjacentModuleCandidates(sourceFile, kind) {
+    const dir = dirname(sourceFile);
+    const stem = basename(sourceFile, extname(sourceFile));
+    const baseName = sourceFile.slice(0, -extname(sourceFile).length);
+    const candidates = [];
+    if (stem === 'index') {
+        candidates.push(join(dir, `page.${kind}.ts`));
+        candidates.push(join(dir, `page.${kind}.js`));
+    }
+    candidates.push(`${baseName}.${kind}.ts`);
+    candidates.push(`${baseName}.${kind}.js`);
+    return candidates;
+}
+/**
+ * @param {string} sourceFile
+ * @param {'guard' | 'load'} kind
+ * @returns {string | null}
+ */
+function resolveAdjacentModule(sourceFile, kind) {
+    const matches = adjacentModuleCandidates(sourceFile, kind).filter((candidate) => existsSync(candidate));
+    if (matches.length === 0) {
+        return null;
+    }
+    if (matches.length > 1) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: multiple adjacent ${kind} modules detected\n` +
+            `  Matches: ${matches.join(', ')}\n` +
+            `  Example: keep exactly one adjacent ${kind} module for this route`);
+    }
+    return matches[0];
+}
+/**
+ * @param {string} fromFile
+ * @param {string} targetFile
+ * @returns {string}
+ */
+function renderRelativeSpecifier(fromFile, targetFile) {
+    let specifier = relative(dirname(fromFile), targetFile).replaceAll('\\', '/');
+    if (!specifier.startsWith('.')) {
+        specifier = `./${specifier}`;
+    }
+    return specifier;
+}
+/**
+ * @param {string} source
+ * @returns {{ hasData: boolean, hasLegacy: boolean }}
+ */
+function classifyInlineServerSource(source) {
+    const input = String(source || '');
+    return {
+        hasData: DATA_EXPORT_RE.test(input),
+        hasLegacy: LEGACY_EXPORT_RE.test(input)
+    };
+}
+/**
+ * @param {{
+ *   sourceFile: string,
+ *   inlineServerScript?: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null,
+ *   adjacentGuardPath?: string | null,
+ *   adjacentLoadPath?: string | null
+ * }} input
+ * @returns {{ serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null, guardPath: string | null, loadPath: string | null }}
+ */
+export function composeServerScriptEnvelope({ sourceFile, inlineServerScript = null, adjacentGuardPath = null, adjacentLoadPath = null }) {
+    const inlineSource = String(inlineServerScript?.source || '').trim();
+    const inlineHasGuard = inlineServerScript?.has_guard === true;
+    const inlineHasLoad = inlineServerScript?.has_load === true;
+    const { hasData, hasLegacy } = classifyInlineServerSource(inlineSource);
+    if (inlineHasGuard && adjacentGuardPath) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: guard is defined both inline and in an adjacent module\n` +
+            `  Example: keep guard in either <script server> or ${basename(adjacentGuardPath)}, not both`);
+    }
+    if (inlineHasLoad && adjacentLoadPath) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: load is defined both inline and in an adjacent module\n` +
+            `  Example: keep load in either <script server> or ${basename(adjacentLoadPath)}, not both`);
+    }
+    if (adjacentLoadPath && (hasData || hasLegacy)) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: an adjacent load module cannot be combined with inline data/legacy payload exports\n` +
+            `  Example: remove export const data/ssr_data/props/ssr or move payload logic into load(ctx)`);
+    }
+    const prologue = [];
+    if (adjacentGuardPath) {
+        prologue.push(`export { guard } from '${renderRelativeSpecifier(sourceFile, adjacentGuardPath)}';`);
+    }
+    if (adjacentLoadPath) {
+        prologue.push(`export { load } from '${renderRelativeSpecifier(sourceFile, adjacentLoadPath)}';`);
+    }
+    const mergedSource = [...prologue, inlineSource].filter(Boolean).join('\n');
+    if (!mergedSource.trim()) {
+        return {
+            serverScript: null,
+            guardPath: adjacentGuardPath,
+            loadPath: adjacentLoadPath
+        };
+    }
+    return {
+        serverScript: {
+            source: mergedSource,
+            prerender: inlineServerScript?.prerender === true,
+            has_guard: inlineHasGuard || Boolean(adjacentGuardPath),
+            has_load: inlineHasLoad || Boolean(adjacentLoadPath),
+            source_path: sourceFile
+        },
+        guardPath: adjacentGuardPath,
+        loadPath: adjacentLoadPath
+    };
+}
+/**
+ * @param {string} sourceFile
+ * @returns {{ guardPath: string | null, loadPath: string | null }}
+ */
+export function resolveAdjacentServerModules(sourceFile) {
+    return {
+        guardPath: resolveAdjacentModule(sourceFile, 'guard'),
+        loadPath: resolveAdjacentModule(sourceFile, 'load')
+    };
+}

package/dist/startup-profile.d.ts

@@ -0,0 +1,10 @@
+export function createStartupProfiler(scope: any): {
+    enabled: boolean;
+    emit: (event: any, payload?: {}) => void;
+    measureSync: (label: any, fn: any, payload?: {}) => any;
+    measureAsync: (label: any, fn: any, payload?: {}) => Promise<any>;
+    nowMs(): number;
+    roundMs: typeof roundMs;
+};
+declare function roundMs(value: any): number;
+export {};

package/dist/startup-profile.js

@@ -0,0 +1,62 @@
+import { performance } from 'node:perf_hooks';
+const STARTUP_PROFILE_ENV = 'ZENITH_STARTUP_PROFILE';
+function roundMs(value) {
+    return Math.round(Number(value || 0) * 100) / 100;
+}
+export function createStartupProfiler(scope) {
+    const enabled = process.env[STARTUP_PROFILE_ENV] === '1';
+    const startedAt = performance.now();
+    function emit(event, payload = {}) {
+        if (!enabled) {
+            return;
+        }
+        const record = {
+            scope,
+            event,
+            atMs: roundMs(performance.now() - startedAt),
+            ...payload
+        };
+        try {
+            console.error(`[zenith-startup] ${JSON.stringify(record)}`);
+        }
+        catch {
+            // profiling must never break runtime behavior
+        }
+    }
+    function measureSync(label, fn, payload = {}) {
+        const stepStartedAt = performance.now();
+        try {
+            return fn();
+        }
+        finally {
+            emit('step', {
+                label,
+                durationMs: roundMs(performance.now() - stepStartedAt),
+                ...payload
+            });
+        }
+    }
+    async function measureAsync(label, fn, payload = {}) {
+        const stepStartedAt = performance.now();
+        try {
+            return await fn();
+        }
+        finally {
+            emit('step', {
+                label,
+                durationMs: roundMs(performance.now() - stepStartedAt),
+                ...payload
+            });
+        }
+    }
+    return {
+        enabled,
+        emit,
+        measureSync,
+        measureAsync,
+        nowMs() {
+            return roundMs(performance.now() - startedAt);
+        },
+        roundMs
+    };
+}

package/dist/toolchain-paths.d.ts

@@ -15,6 +15,7 @@ export declare function resolveBinary(candidates: Array<string | ToolchainCandid
 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 readWorkspacePackageVersion(packageName: string): string | null;
 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;

package/dist/toolchain-paths.js

@@ -151,6 +151,37 @@ export function readCliPackageVersion() {
         return '0.0.0';
     }
 }
+function workspacePackageManifestPath(packageName) {
+    switch (packageName) {
+        case '@zenithbuild/cli':
+            return resolve(CLI_ROOT, 'package.json');
+        case '@zenithbuild/core':
+            return resolve(CLI_ROOT, '../core/package.json');
+        case '@zenithbuild/compiler':
+            return resolve(CLI_ROOT, '../compiler/package.json');
+        case '@zenithbuild/runtime':
+            return resolve(CLI_ROOT, '../runtime/package.json');
+        case '@zenithbuild/router':
+            return resolve(CLI_ROOT, '../router/package.json');
+        case '@zenithbuild/bundler':
+            return resolve(CLI_ROOT, '../bundler/package.json');
+        default:
+            return '';
+    }
+}
+export function readWorkspacePackageVersion(packageName) {
+    const manifestPath = workspacePackageManifestPath(packageName);
+    if (!manifestPath || !existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        const pkg = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
 function createInstalledPlatformPackageCandidate(tool, packages, projectRoot) {
     const platformPackage = currentPlatformPackage(packages);
     if (!platformPackage) {

package/dist/version-check.d.ts

@@ -40,9 +40,10 @@ interface VersionCheckLogger {
 }
 export declare function compareVersions(leftVersion: string | null | undefined, rightVersion: string | null | undefined): number;
 export declare function getBundlerVersion(bundlerBinPath: string | null | undefined): BundlerVersionResult;
-export declare function getLocalZenithVersions({ projectRoot, bundlerBinPath }?: {
+export declare function getLocalZenithVersions({ projectRoot, bundlerBinPath, preferWorkspacePackageVersions }?: {
     projectRoot?: string | null;
     bundlerBinPath?: string | null;
+    preferWorkspacePackageVersions?: boolean;
 }): ZenithVersions;
 export declare function checkCompatibility(versions: Partial<ZenithVersions>): CompatibilityResult;
 export declare function maybeWarnAboutZenithVersionMismatch({ projectRoot, logger, command, bundlerBinPath }?: {

package/dist/version-check.js

@@ -1,7 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { readCliPackageVersion, readInstalledPackageVersion, resolveBundlerBin } from './toolchain-paths.js';
+import { readCliPackageVersion, readInstalledPackageVersion, readWorkspacePackageVersion, resolveBundlerBin } from './toolchain-paths.js';
 const PACKAGE_KEYS = [
     ['core', '@zenithbuild/core'],
     ['compiler', '@zenithbuild/compiler'],
@@ -220,12 +220,18 @@ export function getBundlerVersion(bundlerBinPath) {
         ok: result.status === 0 && Boolean(versionMatch)
     };
 }
-export function getLocalZenithVersions({ projectRoot, bundlerBinPath } = {}) {
+export function getLocalZenithVersions({ projectRoot, bundlerBinPath, preferWorkspacePackageVersions = false } = {}) {
     const resolvedBundlerBin = bundlerBinPath || resolveBundlerBin(projectRoot ?? null);
     const bundlerVersion = getBundlerVersion(resolvedBundlerBin);
+    const readPackageVersion = (packageName) => {
+        if (preferWorkspacePackageVersions) {
+            return readWorkspacePackageVersion(packageName) || readInstalledPackageVersion(packageName, projectRoot ?? null);
+        }
+        return readInstalledPackageVersion(packageName, projectRoot ?? null);
+    };
     const versions = {
         cli: readCliPackageVersion(),
-        projectCli: readInstalledPackageVersion('@zenithbuild/cli', projectRoot ?? null),
+        projectCli: readPackageVersion('@zenithbuild/cli'),
         core: null,
         compiler: null,
         runtime: null,
@@ -237,7 +243,7 @@ export function getLocalZenithVersions({ projectRoot, bundlerBinPath } = {}) {
         targetVersion: null
     };
     for (const [key, packageName] of PACKAGE_KEYS) {
-        versions[key] = readInstalledPackageVersion(packageName, projectRoot ?? null);
+        versions[key] = readPackageVersion(packageName);
     }
     versions.targetVersion = determineTargetVersion(versions);
     return versions;
@@ -299,7 +305,8 @@ export async function maybeWarnAboutZenithVersionMismatch({ projectRoot, logger,
     if (!logger || process.env.ZENITH_SKIP_VERSION_CHECK === '1') {
         return { status: 'ok', issues: [], details: { targetVersion: '0.0.0', versions: {}, summary: '' } };
     }
-    const versions = getLocalZenithVersions({ projectRoot, bundlerBinPath });
+    const preferWorkspacePackageVersions = process.env.ZENITH_PREFER_WORKSPACE_PACKAGES === '1';
+    const versions = getLocalZenithVersions({ projectRoot, bundlerBinPath, preferWorkspacePackageVersions });
     versions.projectRoot = projectRoot ?? null;
     const result = checkCompatibility(versions);
     const onceKey = `zenith-version-check:${describeVersions(versions)}:${result.status}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.6.17",
+  "version": "0.7.1",
   "description": "Deterministic project orchestrator for Zenith framework",
   "license": "MIT",
   "type": "module",
@@ -28,14 +28,15 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && node -e \"const fs=require('fs');if(fs.existsSync('dist/index.js')) fs.chmodSync('dist/index.js',0o755)\"",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node ./scripts/copy-framework-components.mjs && node -e \"const fs=require('fs');if(fs.existsSync('dist/index.js')) fs.chmodSync('dist/index.js',0o755)\"",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "bun run build && node --experimental-vm-modules $(node -e \"const path=require('node:path');const pkg=require.resolve('jest/package.json');process.stdout.write(path.join(path.dirname(pkg),'bin/jest.js'))\") --config jest.config.js --forceExit --runInBand",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@zenithbuild/compiler": "0.6.17",
-    "picocolors": "^1.1.1"
+    "@zenithbuild/compiler": "0.7.1",
+    "picocolors": "^1.1.1",
+    "sharp": "^0.34.4"
   },
   "devDependencies": {
     "@types/node": "latest",