@zenithbuild/cli 0.6.13 → 0.7.0

package/dist/component-instance-ir.d.ts

@@ -1,6 +1,6 @@
 export function cloneComponentIrForInstance(compIr: any, instanceId: any, extractDeclaredIdentifiers: any, resolveStateKeyFromBindings: any): {
     ir: any;
-    renameMap: Map<any, string>;
+    renameMap: Map<any, any>;
     refIdentifierPairs: any;
 };
-export function applyOccurrenceRewritePlans(pageIr: any, occurrencePlans: any, resolveBindingMetadata: any): void;
+export function applyOccurrenceRewritePlans(pageIr: any, occurrencePlans: any, resolveBindingMetadata: any, applyMetrics?: null): void;

package/dist/component-instance-ir.js

@@ -1,18 +1,85 @@
+import { loadTypeScriptApi } from './build/compiler-runtime.js';
 function deepClone(value) {
     return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
+const cloneMetadataCache = new WeakMap();
 function escapeIdentifier(identifier) {
     return identifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function replaceIdentifierRefs(input, renameMap) {
+function replaceIdentifierRefs(input, renamePlan) {
     let output = String(input || '');
-    const entries = [...renameMap.entries()].sort((a, b) => b[0].length - a[0].length);
-    for (const [from, to] of entries) {
-        const pattern = new RegExp(`\\b${escapeIdentifier(from)}\\b`, 'g');
-        output = output.replace(pattern, to);
+    for (const entry of renamePlan) {
+        output = output.replace(entry.pattern, entry.to);
     }
     return output;
 }
+function replaceIdentifierRefsInStatementSource(input, renameEntries, renamePlan) {
+    const source = String(input || '');
+    if (!source.trim()) {
+        return source;
+    }
+    const ts = loadTypeScriptApi();
+    if (!ts) {
+        return replaceIdentifierRefs(source, renamePlan);
+    }
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-instance-clone.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        return replaceIdentifierRefs(source, renamePlan);
+    }
+    const renameMap = new Map(renameEntries);
+    const shouldRenameIdentifier = (node) => {
+        const parent = node.parent;
+        if (!parent) {
+            return true;
+        }
+        if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+            return false;
+        }
+        if (ts.isPropertyAssignment(parent) && parent.name === node) {
+            return false;
+        }
+        if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
+            return false;
+        }
+        if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent)) {
+            return false;
+        }
+        return true;
+    };
+    const transformer = (context) => {
+        const visit = (node) => {
+            if (ts.isShorthandPropertyAssignment(node)) {
+                const rewritten = renameMap.get(node.name.text);
+                if (typeof rewritten === 'string' && rewritten.length > 0) {
+                    return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(node.name.text), ts.factory.createIdentifier(rewritten));
+                }
+            }
+            if (ts.isIdentifier(node) && shouldRenameIdentifier(node)) {
+                const rewritten = renameMap.get(node.text);
+                if (typeof rewritten === 'string' && rewritten.length > 0 && rewritten !== node.text) {
+                    return ts.factory.createIdentifier(rewritten);
+                }
+            }
+            return ts.visitEachChild(node, visit, context);
+        };
+        return (node) => ts.visitNode(node, visit);
+    };
+    const result = ts.transform(sourceFile, [transformer]);
+    try {
+        return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+            .printFile(result.transformed[0])
+            .trimEnd();
+    }
+    catch {
+        return replaceIdentifierRefs(source, renamePlan);
+    }
+    finally {
+        result.dispose();
+    }
+}
 function collectRenameTargets(compIr, extractDeclaredIdentifiers) {
     const targets = new Set();
     const stateBindings = Array.isArray(compIr?.hoisted?.state) ? compIr.hoisted.state : [];
@@ -44,26 +111,72 @@ function collectRenameTargets(compIr, extractDeclaredIdentifiers) {
     }
     return [...targets];
 }
-function buildRefIdentifierMap(baseIr, renameMap, resolveStateKeyFromBindings) {
-    const baseState = Array.isArray(baseIr?.hoisted?.state) ? baseIr.hoisted.state : [];
-    const baseRefs = Array.isArray(baseIr?.ref_bindings) ? baseIr.ref_bindings : [];
-    return baseRefs.map((binding) => {
-        const raw = typeof binding?.identifier === 'string' ? binding.identifier : null;
-        const resolvedBase = raw ? resolveStateKeyFromBindings(raw, baseState) : null;
-        const rewritten = resolvedBase ? (renameMap.get(resolvedBase) || null) : null;
+function getCloneMetadata(compIr, extractDeclaredIdentifiers, resolveStateKeyFromBindings) {
+    if (cloneMetadataCache.has(compIr)) {
+        return cloneMetadataCache.get(compIr);
+    }
+    const baseState = Array.isArray(compIr?.hoisted?.state) ? compIr.hoisted.state : [];
+    const baseRefs = Array.isArray(compIr?.ref_bindings) ? compIr.ref_bindings : [];
+    const metadata = {
+        renameTargets: collectRenameTargets(compIr, extractDeclaredIdentifiers),
+        refIdentifierEntries: baseRefs.map((binding) => {
+            const raw = typeof binding?.identifier === 'string' ? binding.identifier : null;
+            const resolvedBase = raw ? resolveStateKeyFromBindings(raw, baseState) : null;
+            return {
+                raw,
+                baseKey: resolvedBase || null
+            };
+        }).filter((entry) => typeof entry.raw === 'string' && typeof entry.baseKey === 'string')
+    };
+    cloneMetadataCache.set(compIr, metadata);
+    return metadata;
+}
+function buildRefIdentifierMap(refIdentifierEntries, renameMap) {
+    return refIdentifierEntries.map((entry) => {
+        const rewritten = renameMap.get(entry.baseKey) || null;
         return {
-            raw,
+            raw: entry.raw,
             rewritten: rewritten || null
         };
     }).filter((entry) => typeof entry.raw === 'string' && typeof entry.rewritten === 'string');
 }
+function addApplyMetric(applyMetrics, key, value) {
+    if (!applyMetrics || typeof applyMetrics !== 'object' || !Number.isFinite(value)) {
+        return;
+    }
+    applyMetrics[key] = (applyMetrics[key] || 0) + value;
+}
+function findNextExpressionIndex(expressions, raw, startIndex) {
+    for (let index = startIndex; index < expressions.length; index++) {
+        if (expressions[index] === raw) {
+            return index;
+        }
+    }
+    return -1;
+}
+function findNextRefIndex(refBindings, raw, startIndex) {
+    for (let index = startIndex; index < refBindings.length; index++) {
+        if (refBindings[index]?.identifier === raw) {
+            return index;
+        }
+    }
+    return -1;
+}
 export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredIdentifiers, resolveStateKeyFromBindings) {
     const suffix = `__inst${instanceId}`;
     const cloned = deepClone(compIr);
-    const renameTargets = collectRenameTargets(compIr, extractDeclaredIdentifiers);
-    const renameMap = new Map(renameTargets.map((name) => [name, `${name}${suffix}`]));
+    const cloneMetadata = getCloneMetadata(compIr, extractDeclaredIdentifiers, resolveStateKeyFromBindings);
+    const renameEntries = cloneMetadata.renameTargets.map((name) => [name, `${name}${suffix}`]);
+    const renameMap = new Map(renameEntries);
+    const renamePlan = renameEntries
+        .sort((left, right) => right[0].length - left[0].length)
+        .map(([from, to]) => ({
+        from,
+        pattern: new RegExp(`\\b${escapeIdentifier(from)}\\b`, 'g'),
+        to
+    }));
     if (Array.isArray(cloned?.expressions)) {
-        cloned.expressions = cloned.expressions.map((expr) => replaceIdentifierRefs(expr, renameMap));
+        cloned.expressions = cloned.expressions.map((expr) => replaceIdentifierRefs(expr, renamePlan));
     }
     if (Array.isArray(cloned?.expression_bindings)) {
         cloned.expression_bindings = cloned.expression_bindings.map((binding) => {
@@ -72,22 +185,22 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
             }
             return {
                 ...binding,
-                literal: typeof binding.literal === 'string' ? replaceIdentifierRefs(binding.literal, renameMap) : binding.literal,
+                literal: typeof binding.literal === 'string' ? replaceIdentifierRefs(binding.literal, renamePlan) : binding.literal,
                 compiled_expr: typeof binding.compiled_expr === 'string'
-                    ? replaceIdentifierRefs(binding.compiled_expr, renameMap)
+                    ? replaceIdentifierRefs(binding.compiled_expr, renamePlan)
                     : binding.compiled_expr,
                 component_instance: typeof binding.component_instance === 'string'
-                    ? replaceIdentifierRefs(binding.component_instance, renameMap)
+                    ? replaceIdentifierRefs(binding.component_instance, renamePlan)
                     : binding.component_instance,
                 component_binding: typeof binding.component_binding === 'string'
-                    ? replaceIdentifierRefs(binding.component_binding, renameMap)
+                    ? replaceIdentifierRefs(binding.component_binding, renamePlan)
                     : binding.component_binding
             };
         });
     }
     if (cloned?.hoisted) {
         if (Array.isArray(cloned.hoisted.declarations)) {
-            cloned.hoisted.declarations = cloned.hoisted.declarations.map((line) => replaceIdentifierRefs(line, renameMap));
+            cloned.hoisted.declarations = cloned.hoisted.declarations.map((line) => replaceIdentifierRefsInStatementSource(line, renameEntries, renamePlan));
         }
         if (Array.isArray(cloned.hoisted.functions)) {
             cloned.hoisted.functions = cloned.hoisted.functions.map((name) => renameMap.get(name) || name);
@@ -101,12 +214,12 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
                     return entry;
                 }
                 const key = typeof entry.key === 'string' ? (renameMap.get(entry.key) || entry.key) : entry.key;
-                const value = typeof entry.value === 'string' ? replaceIdentifierRefs(entry.value, renameMap) : entry.value;
+                const value = typeof entry.value === 'string' ? replaceIdentifierRefs(entry.value, renamePlan) : entry.value;
                 return { ...entry, key, value };
             });
         }
         if (Array.isArray(cloned.hoisted.code)) {
-            cloned.hoisted.code = cloned.hoisted.code.map((line) => replaceIdentifierRefs(line, renameMap));
+            cloned.hoisted.code = cloned.hoisted.code.map((line) => replaceIdentifierRefsInStatementSource(line, renameEntries, renamePlan));
         }
     }
     if (Array.isArray(cloned?.ref_bindings)) {
@@ -122,14 +235,14 @@ export function cloneComponentIrForInstance(compIr, instanceId, extractDeclaredI
             };
         });
     }
-    const refIdentifierPairs = buildRefIdentifierMap(compIr, renameMap, resolveStateKeyFromBindings);
+    const refIdentifierPairs = buildRefIdentifierMap(cloneMetadata.refIdentifierEntries, renameMap);
     return {
         ir: cloned,
         renameMap,
         refIdentifierPairs
     };
 }
-export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBindingMetadata) {
+export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBindingMetadata, applyMetrics = null) {
     const expressions = Array.isArray(pageIr?.expressions) ? pageIr.expressions : [];
     const bindings = Array.isArray(pageIr?.expression_bindings) ? pageIr.expression_bindings : [];
     const refBindings = Array.isArray(pageIr?.ref_bindings) ? pageIr.ref_bindings : [];
@@ -141,13 +254,9 @@ export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBind
             if (typeof item?.raw !== 'string') {
                 continue;
             }
-            let found = -1;
-            for (let index = exprCursor; index < expressions.length; index++) {
-                if (expressions[index] === item.raw) {
-                    found = index;
-                    break;
-                }
-            }
+            const expressionLookupStartedAt = performance.now();
+            const found = findNextExpressionIndex(expressions, item.raw, exprCursor);
+            addApplyMetric(applyMetrics, 'expressionLookupMs', performance.now() - expressionLookupStartedAt);
             if (found === -1) {
                 continue;
             }
@@ -163,7 +272,9 @@ export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBind
                 if (binding.compiled_expr === item.raw) {
                     binding.compiled_expr = rewritten;
                 }
+                const bindingResolutionStartedAt = performance.now();
                 const resolved = resolveBindingMetadata(plan.rewrite, item.binding);
+                addApplyMetric(applyMetrics, 'bindingResolutionMs', performance.now() - bindingResolutionStartedAt);
                 if (resolved) {
                     binding.compiled_expr = resolved.compiled_expr;
                     binding.signal_index = resolved.signal_index;
@@ -180,13 +291,9 @@ export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBind
             if (typeof refItem?.raw !== 'string' || typeof refItem?.rewritten !== 'string') {
                 continue;
             }
-            let found = -1;
-            for (let index = refCursor; index < refBindings.length; index++) {
-                if (refBindings[index]?.identifier === refItem.raw) {
-                    found = index;
-                    break;
-                }
-            }
+            const refLookupStartedAt = performance.now();
+            const found = findNextRefIndex(refBindings, refItem.raw, refCursor);
+            addApplyMetric(applyMetrics, 'refLookupMs', performance.now() - refLookupStartedAt);
             if (found === -1) {
                 continue;
             }

package/dist/component-occurrences.js

@@ -4,10 +4,13 @@ import { extractTemplate, isDocumentMode } from './resolve-components.js';
 export function collectExpandedComponentOccurrences(source, registry, sourceFile) {
     /** @type {Array<{ name: string, attrs: string, ownerPath: string, componentPath: string }>} */
     const occurrences = [];
-    walkSource(String(source || ''), registry, sourceFile, [], occurrences);
+    walkSource(String(source || ''), registry, {
+        parseFilePath: sourceFile,
+        ownerPath: sourceFile
+    }, [], occurrences);
     return occurrences;
 }
-function walkSource(source, registry, sourceFile, chain, occurrences) {
+function walkSource(source, registry, context, chain, occurrences) {
     let cursor = 0;
     while (cursor < source.length) {
         const tag = findNextKnownComponentTag(source, registry, cursor);
@@ -19,52 +22,97 @@ function walkSource(source, registry, sourceFile, chain, occurrences) {
         if (!tag.selfClosing) {
             const close = findMatchingComponentClose(source, tag.name, tag.end);
             if (!close) {
-                throw new Error(`Unclosed component tag <${tag.name}> in ${sourceFile} at offset ${tag.start}`);
+                throw new Error(`Unclosed component tag <${tag.name}> in ${context.parseFilePath} at offset ${tag.start}`);
             }
             children = source.slice(tag.end, close.contentEnd);
             replaceEnd = close.tagEnd;
         }
         const compPath = registry.get(tag.name);
         if (!compPath) {
-            throw new Error(`Unknown component "${tag.name}" referenced in ${sourceFile}`);
+            throw new Error(`Unknown component "${tag.name}" referenced in ${context.parseFilePath}`);
         }
         if (chain.includes(tag.name)) {
             const cycle = [...chain, tag.name].join(' -> ');
-            throw new Error(`Circular component dependency detected: ${cycle}\nFile: ${sourceFile}`);
+            throw new Error(`Circular component dependency detected: ${cycle}\nFile: ${context.parseFilePath}`);
         }
         occurrences.push({
             name: tag.name,
             attrs: String(tag.attrs || '').trim(),
-            ownerPath: sourceFile,
+            ownerPath: context.ownerPath,
             componentPath: compPath
         });
         const compSource = readFileSync(compPath, 'utf8');
-        const nextTemplate = materializeTemplate(compSource, tag.name, children, compPath);
-        walkSource(nextTemplate, registry, compPath, [...chain, tag.name], occurrences);
+        const fragments = materializeFragments(compSource, tag.name, children, compPath, context);
+        for (const fragment of fragments) {
+            if (!fragment.source) {
+                continue;
+            }
+            walkSource(fragment.source, registry, fragment, [...chain, tag.name], occurrences);
+        }
         cursor = replaceEnd;
     }
 }
-function materializeTemplate(componentSource, name, children, componentPath) {
+function materializeFragments(componentSource, name, children, componentPath, slotContext) {
     let template = extractTemplate(componentSource);
     const slotCount = countSlots(template);
+    const slotMatch = findFirstSlot(template);
     if (isDocumentMode(template)) {
         if (slotCount !== 1) {
             throw new Error(`Document Mode component "${name}" must contain exactly one <slot />, found ${slotCount}.\nFile: ${componentPath}`);
         }
-        return replaceSlot(template, children);
+        return splitFragmentsAtFirstSlot(template, slotMatch, children, componentPath, slotContext);
     }
     if (children.trim().length > 0 && slotCount === 0) {
         throw new Error(`Component "${name}" has children but its template has no <slot />.\nEither add <slot /> to ${componentPath} or make the tag self-closing.`);
     }
-    if (slotCount > 0) {
-        template = replaceSlot(template, children || '');
+    if (slotCount === 0) {
+        return [{
+                source: template,
+                parseFilePath: componentPath,
+                ownerPath: componentPath
+            }];
     }
-    return template;
+    return splitFragmentsAtFirstSlot(template, slotMatch, children || '', componentPath, slotContext);
 }
 function countSlots(template) {
     const matches = template.match(/<slot\s*>\s*<\/slot>|<slot\s*\/>|<slot\s*>/gi);
     return matches ? matches.length : 0;
 }
-function replaceSlot(template, content) {
-    return template.replace(/<slot\s*>\s*<\/slot>|<slot\s*\/>|<slot\s*>/i, content);
+function findFirstSlot(template) {
+    const match = /<slot\s*>\s*<\/slot>|<slot\s*\/>|<slot\s*>/i.exec(template);
+    if (!match || typeof match.index !== 'number') {
+        return null;
+    }
+    return {
+        index: match.index,
+        length: match[0].length
+    };
+}
+function splitFragmentsAtFirstSlot(template, slotMatch, content, componentPath, slotContext) {
+    if (!slotMatch) {
+        return [{
+                source: template,
+                parseFilePath: componentPath,
+                ownerPath: componentPath
+            }];
+    }
+    const before = template.slice(0, slotMatch.index);
+    const after = template.slice(slotMatch.index + slotMatch.length);
+    return [
+        {
+            source: before,
+            parseFilePath: componentPath,
+            ownerPath: componentPath
+        },
+        {
+            source: content,
+            parseFilePath: slotContext.parseFilePath,
+            ownerPath: slotContext.ownerPath
+        },
+        {
+            source: after,
+            parseFilePath: componentPath,
+            ownerPath: componentPath
+        }
+    ];
 }

package/dist/config.d.ts

@@ -0,0 +1,66 @@
+export function validateConfig(config: any): {
+    images: {
+        formats: string[];
+        deviceSizes: number[];
+        imageSizes: number[];
+        remotePatterns: any[];
+        quality: number;
+        allowSvg: boolean;
+        maxRemoteBytes: number;
+        maxPixels: number;
+        minimumCacheTTL: number;
+        dangerouslyAllowLocalNetwork: boolean;
+    };
+    router: boolean;
+    embeddedMarkupExpressions: boolean;
+    types: boolean;
+    typescriptDefault: boolean;
+    outDir: string;
+    pagesDir: string;
+    experimental: {};
+    strictDomLints: boolean;
+};
+export function loadConfig(projectRoot: any): Promise<{
+    images: {
+        formats: string[];
+        deviceSizes: number[];
+        imageSizes: number[];
+        remotePatterns: any[];
+        quality: number;
+        allowSvg: boolean;
+        maxRemoteBytes: number;
+        maxPixels: number;
+        minimumCacheTTL: number;
+        dangerouslyAllowLocalNetwork: boolean;
+    };
+    router: boolean;
+    embeddedMarkupExpressions: boolean;
+    types: boolean;
+    typescriptDefault: boolean;
+    outDir: string;
+    pagesDir: string;
+    experimental: {};
+    strictDomLints: boolean;
+}>;
+export namespace DEFAULT_CONFIG {
+    let router: boolean;
+    let embeddedMarkupExpressions: boolean;
+    let types: boolean;
+    let typescriptDefault: boolean;
+    let outDir: string;
+    let pagesDir: string;
+    let experimental: {};
+    let strictDomLints: boolean;
+    let images: {
+        formats: string[];
+        deviceSizes: number[];
+        imageSizes: number[];
+        remotePatterns: any[];
+        quality: number;
+        allowSvg: boolean;
+        maxRemoteBytes: number;
+        maxPixels: number;
+        minimumCacheTTL: number;
+        dangerouslyAllowLocalNetwork: boolean;
+    };
+}

package/dist/config.js

@@ -0,0 +1,86 @@
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { normalizeImageConfig } from './images/shared.js';
+export const DEFAULT_CONFIG = {
+    router: false,
+    embeddedMarkupExpressions: false,
+    types: true,
+    typescriptDefault: true,
+    outDir: 'dist',
+    pagesDir: 'pages',
+    experimental: {},
+    strictDomLints: false,
+    images: normalizeImageConfig()
+};
+const TOP_LEVEL_SCHEMA = {
+    router: 'boolean',
+    embeddedMarkupExpressions: 'boolean',
+    types: 'boolean',
+    typescriptDefault: 'boolean',
+    outDir: 'string',
+    pagesDir: 'string',
+    experimental: 'object',
+    strictDomLints: 'boolean',
+    images: 'object'
+};
+export function validateConfig(config) {
+    if (config === null || config === undefined) {
+        return { ...DEFAULT_CONFIG, images: normalizeImageConfig() };
+    }
+    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 TOP_LEVEL_SCHEMA)) {
+            throw new Error(`[Zenith:Config] Unknown key: "${key}"`);
+        }
+    }
+    const result = {
+        ...DEFAULT_CONFIG,
+        images: normalizeImageConfig(DEFAULT_CONFIG.images)
+    };
+    for (const [key, expectedType] of Object.entries(TOP_LEVEL_SCHEMA)) {
+        if (!(key in config)) {
+            continue;
+        }
+        const value = config[key];
+        if (key === 'images') {
+            result.images = normalizeImageConfig(value);
+            continue;
+        }
+        if (expectedType === 'object') {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                throw new Error(`[Zenith:Config] Key "${key}" must be a plain object`);
+            }
+            result[key] = { ...value };
+            continue;
+        }
+        if (typeof value !== expectedType) {
+            throw new Error(`[Zenith:Config] Key "${key}" must be ${expectedType}, got ${typeof value}`);
+        }
+        if (expectedType === 'string' && value.trim().length === 0) {
+            throw new Error(`[Zenith:Config] Key "${key}" must be a non-empty string`);
+        }
+        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);
+        return validateConfig(mod.default || mod);
+    }
+    catch (error) {
+        const code = typeof error?.code === 'string' ? error.code : '';
+        const message = typeof error?.message === 'string' ? error.message : '';
+        if (code === 'ERR_MODULE_NOT_FOUND'
+            || code === 'ENOENT'
+            || message.includes('Cannot find module')
+            || message.includes('ENOENT')) {
+            return validateConfig(null);
+        }
+        throw error;
+    }
+}

package/dist/debug-script.d.ts

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

package/dist/debug-script.js

@@ -0,0 +1,8 @@
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+// Load the compiled payload for the home page from dist output
+// actually I'll use the bundler's output JSON or just raw compile
+// Let's run the CLI compiler
+import { execSync } from 'child_process';
+const out = execSync('~/.bun/bin/bun run build', { cwd: resolve(process.cwd(), 'packages/runtime') });
+// never mind, the site uses zenith compiler.

package/dist/dev-build-session.d.ts

@@ -0,0 +1,23 @@
+export function createDevBuildSession(options: any): {
+    build(buildOptions?: {}): Promise<{
+        pages: number;
+        assets: any;
+        strategy: string;
+    }>;
+    getImageRuntimePayload(): {
+        mode: string;
+        config: {
+            formats: string[];
+            deviceSizes: number[];
+            imageSizes: number[];
+            remotePatterns: any[];
+            quality: number;
+            allowSvg: boolean;
+            maxRemoteBytes: number;
+            maxPixels: number;
+            minimumCacheTTL: number;
+            dangerouslyAllowLocalNetwork: boolean;
+        };
+        localImages: any;
+    } | null;
+};