@zenithbuild/cli 0.7.5 → 0.7.7

package/dist/adapters/adapter-netlify.js

@@ -45,17 +45,9 @@ function createFunctionSource(route) {
         "  return new Response(message, { status: 501, headers: { 'Content-Type': 'text/plain; charset=utf-8' } });",
         '}',
         '',
-        'function isMultipartFormData(request) {',
-        "  const contentType = request.headers.get('content-type') || '';",
-        "  return /^multipart\\/form-data(?:\\s*;|$)/i.test(contentType.trim());",
-        '}',
-        '',
         'export default async function(request) {',
         '  const params = extractInternalParams(request.url, route);',
         "  if (route.route_kind === 'resource') {",
-        '    if (isMultipartFormData(request)) {',
-        "      return createHostedUnsupportedResponse('Hosted multipart resource routes are unsupported in this milestone');",
-        '    }',
         '    const response = await renderResourceRouteRequest({',
         '      request,',
         '      route,',

package/dist/adapters/adapter-vercel.js

@@ -66,23 +66,15 @@ function createFunctionSource(route) {
         "  return new Response(message, { status: 501, headers: { 'Content-Type': 'text/plain; charset=utf-8' } });",
         '}',
         '',
-        'function isMultipartFormData(request) {',
-        "  const contentType = request.headers.get('content-type') || '';",
-        "  return /^multipart\\/form-data(?:\\s*;|$)/i.test(contentType.trim());",
-        '}',
-        '',
         'export default {',
         '  async fetch(request) {',
         '    const params = extractInternalParams(request.url, route);',
         "    if (route.route_kind === 'resource') {",
-        '      if (isMultipartFormData(request)) {',
-        "        return createHostedUnsupportedResponse('Hosted multipart resource routes are unsupported in this milestone');",
-        '      }',
         '      const response = await renderResourceRouteRequest({',
         '        request,',
         '        route,',
         '        params,',
-        "        routeModulePath: join(__dirname, 'route', 'entry.js')",
+        `        routeModulePath: join(__dirname, 'routes', ${JSON.stringify(route.name)}, 'route', 'entry.js')`,
         '      });',
         "      if (response.headers.has('content-disposition')) {",
         "        return createHostedUnsupportedResponse('Hosted resource downloads are unsupported in this milestone');",
@@ -93,10 +85,10 @@ function createFunctionSource(route) {
         '      request,',
         '      route,',
         '      params,',
-        "      routeModulePath: join(__dirname, 'route', 'entry.js'),",
-        "      shellHtmlPath: join(__dirname, 'route', 'page.html'),",
-        `      pageAssetPath: ${route.page_asset_file ? "join(__dirname, 'route', " + JSON.stringify(route.page_asset_file) + ')' : 'null'},`,
-        `      imageManifestPath: ${route.image_manifest_file ? "join(__dirname, 'route', " + JSON.stringify(route.image_manifest_file) + ')' : 'null'},`,
+        `      routeModulePath: join(__dirname, 'routes', ${JSON.stringify(route.name)}, 'route', 'entry.js'),`,
+        `      shellHtmlPath: join(__dirname, 'routes', ${JSON.stringify(route.name)}, 'route', 'page.html'),`,
+        `      pageAssetPath: ${route.page_asset_file ? "join(__dirname, 'routes', " + JSON.stringify(route.name) + ", 'route', " + JSON.stringify(route.page_asset_file) + ')' : 'null'},`,
+        `      imageManifestPath: ${route.image_manifest_file ? "join(__dirname, 'routes', " + JSON.stringify(route.name) + ", 'route', " + JSON.stringify(route.image_manifest_file) + ')' : 'null'},`,
         `      imageConfig: ${JSON.stringify(route.image_config || {}, null, 2)}`,
         '    });',
         '  }',
@@ -146,7 +138,7 @@ export const vercelAdapter = {
             const functionDir = join(options.outDir, 'functions', '__zenith', `${route.name}.func`);
             await mkdir(functionDir, { recursive: true });
             await copyHostedPageRuntime(options.coreOutput, functionDir);
-            await cp(join(options.coreOutput, 'server', 'routes', route.name), functionDir, { recursive: true, force: true });
+            await cp(join(options.coreOutput, 'server', 'routes', route.name), join(functionDir, 'routes', route.name), { recursive: true, force: true });
             await writeFile(join(functionDir, 'package.json'), '{\n  "type": "module"\n}\n', 'utf8');
             await writeFile(join(functionDir, 'index.js'), createFunctionSource(route), 'utf8');
             await writeFile(join(functionDir, '.vc-config.json'), vercelFunctionConfig(), 'utf8');

package/dist/adapters/copy-hosted-page-runtime.js

@@ -3,10 +3,11 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 const PACKAGE_REQUIRE = createRequire(import.meta.url);
-const HOSTED_PAGE_RUNTIME_DIRS = ['runtime', 'images', 'auth'];
+const HOSTED_PAGE_RUNTIME_DIRS = ['runtime', 'images', 'auth', 'server-contract'];
 const HOSTED_PAGE_RUNTIME_FILES = [
     'base-path.js',
     'server-contract.js',
+    'server-middleware.js',
     'server-error.js',
     'resource-response.js',
     'download-result.js'

package/dist/build/hoisted-code-transforms.d.ts

@@ -21,9 +21,12 @@ export function rewriteStaticImportsInSource(source: string, fromFile: string, t
  * @param {string} sourceFile
  * @param {object | null} [transformCache]
  * @param {Record<string, number> | null} [mergeMetrics]
+ * @param {{ target?: 'es5' | 'esnext' }} [options]
  * @returns {string}
  */
-export function transpileTypeScriptToJs(source: string, sourceFile: string, transformCache?: object | null, mergeMetrics?: Record<string, number> | null): string;
+export function transpileTypeScriptToJs(source: string, sourceFile: string, transformCache?: object | null, mergeMetrics?: Record<string, number> | null, options?: {
+    target?: "es5" | "esnext";
+}): string;
 /**
  * @param {string} source
  * @param {Set<string>} seenStaticImports

package/dist/build/hoisted-code-transforms.js

@@ -76,11 +76,13 @@ export function rewriteStaticImportsInSource(source, fromFile, toFile) {
  * @param {string} sourceFile
  * @param {object | null} [transformCache]
  * @param {Record<string, number> | null} [mergeMetrics]
+ * @param {{ target?: 'es5' | 'esnext' }} [options]
  * @returns {string}
  */
-export function transpileTypeScriptToJs(source, sourceFile, transformCache = null, mergeMetrics = null) {
+export function transpileTypeScriptToJs(source, sourceFile, transformCache = null, mergeMetrics = null, options = {}) {
+    const target = options?.target === 'esnext' ? 'esnext' : 'es5';
     const cacheKey = transformCache?.transpileToJs instanceof Map
-        ? `${sourceFile}\u0000${source}`
+        ? `${sourceFile}\u0000${target}\u0000${source}`
         : null;
     if (cacheKey && transformCache.transpileToJs.has(cacheKey)) {
         if (mergeMetrics && typeof mergeMetrics === 'object') {
@@ -97,7 +99,7 @@ export function transpileTypeScriptToJs(source, sourceFile, transformCache = nul
             fileName: sourceFile,
             compilerOptions: {
                 module: ts.ModuleKind.ESNext,
-                target: ts.ScriptTarget.ES5,
+                target: target === 'esnext' ? ts.ScriptTarget.ESNext : ts.ScriptTarget.ES5,
                 importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Preserve,
                 verbatimModuleSyntax: true,
                 newLine: ts.NewLineKind.LineFeed,

package/dist/build/page-ir-normalization.d.ts

@@ -11,5 +11,5 @@ export function rewriteRefBindingIdentifiers(pageIr: object, preferredKeys?: Set
  */
 export function applyExpressionRewrites(pageIr: object, expressionMap: Map<string, string>, bindingMap: Map<string, object>, ambiguous: Set<string>): void;
 export function normalizeExpressionPayload(pageIr: any): void;
-export function normalizeHoistedSourcePayload(pageIr: any): void;
+export function normalizeHoistedSourcePayload(pageIr: any, sourceFile?: string, transformCache?: null, mergeMetrics?: null): void;
 export function rewriteLegacyMarkupIdentifiers(pageIr: any): void;

package/dist/build/page-ir-normalization.js

@@ -1,4 +1,5 @@
 import { resolveStateKeyFromBindings } from './expression-rewrites.js';
+import { transpileTypeScriptToJs } from './hoisted-code-transforms.js';
 import { expandScopedShorthandPropertiesInSource, normalizeTypeScriptExpression } from './typescript-expression-utils.js';
 /**
  * @param {object} pageIr
@@ -89,7 +90,7 @@ export function normalizeExpressionPayload(pageIr) {
         }
     }
 }
-export function normalizeHoistedSourcePayload(pageIr) {
+export function normalizeHoistedSourcePayload(pageIr, sourceFile = 'component.zen', transformCache = null, mergeMetrics = null) {
     const declarations = Array.isArray(pageIr?.hoisted?.declarations) ? pageIr.hoisted.declarations : null;
     if (declarations) {
         pageIr.hoisted.declarations = declarations.map((entry) => {
@@ -101,11 +102,40 @@ export function normalizeHoistedSourcePayload(pageIr) {
     }
     const codeBlocks = Array.isArray(pageIr?.hoisted?.code) ? pageIr.hoisted.code : null;
     if (codeBlocks) {
-        pageIr.hoisted.code = codeBlocks.map((entry) => {
+        pageIr.hoisted.code = codeBlocks.map((entry, index) => {
             if (typeof entry !== 'string') {
                 return entry;
             }
-            return expandScopedShorthandPropertiesInSource(entry);
+            const expanded = expandScopedShorthandPropertiesInSource(entry);
+            return transpileTypeScriptToJs(expanded, `${sourceFile}#hoisted-${index}.ts`, transformCache, mergeMetrics, { target: 'esnext' });
+        });
+    }
+    const componentScripts = pageIr?.components_scripts && typeof pageIr.components_scripts === 'object'
+        ? pageIr.components_scripts
+        : null;
+    if (componentScripts) {
+        for (const [hoistId, script] of Object.entries(componentScripts)) {
+            if (!script || typeof script !== 'object' || typeof script.code !== 'string') {
+                continue;
+            }
+            const expanded = expandScopedShorthandPropertiesInSource(script.code);
+            script.code = transpileTypeScriptToJs(expanded, `${sourceFile}#component-${hoistId}.ts`, transformCache, mergeMetrics, { target: 'esnext' });
+        }
+    }
+    const modules = Array.isArray(pageIr?.modules) ? pageIr.modules : null;
+    if (modules) {
+        pageIr.modules = modules.map((module, index) => {
+            if (!module || typeof module !== 'object' || typeof module.source !== 'string') {
+                return module;
+            }
+            const moduleId = typeof module.id === 'string' && module.id.length > 0
+                ? module.id
+                : `${sourceFile}#module-${index}.ts`;
+            const expanded = expandScopedShorthandPropertiesInSource(module.source);
+            return {
+                ...module,
+                source: transpileTypeScriptToJs(expanded, moduleId, transformCache, mergeMetrics, { target: 'esnext' })
+            };
         });
     }
 }

package/dist/build/page-loop.js

@@ -165,7 +165,7 @@ export async function buildPageEnvelopes(input) {
         pagePhase.expressionApplyMs = startupProfile.roundMs(performance.now() - expressionApplyStartedAt);
         const normalizeStartedAt = performance.now();
         normalizeExpressionPayload(pageIr);
-        normalizeHoistedSourcePayload(pageIr);
+        normalizeHoistedSourcePayload(pageIr, sourceFile, hoistedCodeTransformCache, expressionRewriteMetrics);
         if (Array.isArray(pageIr?.hoisted?.code) && pageIr.hoisted.code.length > 0) {
             pageIr.hoisted.code = pageIr.hoisted.code
                 .map((entry) => deferComponentRuntimeBlock(entry, hoistedCodeTransformCache, expressionRewriteMetrics))
@@ -174,6 +174,26 @@ export async function buildPageEnvelopes(input) {
         rewriteLegacyMarkupIdentifiers(pageIr);
         rewriteRefBindingIdentifiers(pageIr, knownRefKeys);
         pagePhase.normalizeMs = startupProfile.roundMs(performance.now() - normalizeStartedAt);
+        const requiresJs = detectRequiresJs(pageIr, routerEnabled);
+        if (!requiresJs) {
+            console.log(`[DEBUG] Route ${entry.path} is STATIC (no JS required)`);
+        }
+        else {
+            const reasons = [];
+            if (routerEnabled)
+                reasons.push('routerEnabled');
+            if (pageIr.signals.length > 0)
+                reasons.push('signals');
+            if (pageIr.event_bindings.length > 0)
+                reasons.push('event_bindings');
+            if (pageIr.marker_bindings.length > 0)
+                reasons.push('marker_bindings');
+            if (pageIr.component_instances.length > 0)
+                reasons.push('component_instances');
+            if (pageIr.hoisted?.code?.length > 0)
+                reasons.push('hoisted.code');
+            console.log(`[DEBUG] Route ${entry.path} is INTERACTIVE. Reasons: ${reasons.join(', ')}`);
+        }
         addBreakdown(pagePhaseTotals, pagePhase);
         addBreakdown(occurrenceApplyPhaseTotals, pageOccurrenceApplyBreakdown);
         addBreakdown(bindingResolutionTotals, pageBindingResolutionBreakdown);
@@ -187,7 +207,8 @@ export async function buildPageEnvelopes(input) {
             image_materialization: Array.isArray(pageIr.image_materialization)
                 ? pageIr.image_materialization
                 : [],
-            router: routerEnabled
+            router: routerEnabled,
+            requires_js: requiresJs
         });
         recordPageProfile({
             pageProfiles,
@@ -220,3 +241,26 @@ export async function buildPageEnvelopes(input) {
     });
     return { envelopes, expressionRewriteMetrics };
 }
+/**
+ * Detects if a page requires client-side JavaScript based on its IR.
+ * This is a conservative pass used for Static Route Omission.
+ *
+ * @param {object} pageIr
+ * @param {boolean} routerEnabled
+ * @returns {boolean}
+ */
+function detectRequiresJs(pageIr, routerEnabled) {
+    if (routerEnabled === true) {
+        return true;
+    }
+    const { signals = [], event_bindings = [], ref_bindings = [], marker_bindings = [], component_instances = [], hoisted = {} } = pageIr;
+    const requiresJs = (signals.length > 0 ||
+        event_bindings.length > 0 ||
+        ref_bindings.length > 0 ||
+        (Array.isArray(hoisted.signals) && hoisted.signals.length > 0) ||
+        (Array.isArray(hoisted.state) && hoisted.state.length > 0) ||
+        (Array.isArray(hoisted.code) && hoisted.code.filter(c => String(c).trim().length > 0).length > 0) ||
+        component_instances.some(instance => Array.isArray(instance.props) &&
+            instance.props.some(prop => prop.type === 'signal' || prop.type === 'binding' || prop.type === 'callback' || prop.type === 'reactive')));
+    return requiresJs;
+}

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

@@ -0,0 +1,29 @@
+export function createCompilerTotals(): {
+    pageMs: number;
+    ownerMs: number;
+    componentMs: number;
+    pageCalls: number;
+    ownerCalls: number;
+    componentCalls: number;
+    componentCacheHits: number;
+    componentCacheMisses: number;
+};
+export function createExpressionRewriteMetrics(): {
+    calls: number;
+    compilerOwnedBindings: number;
+    ambiguousBindings: number;
+};
+export function toManifestEntryMap(manifest: any, pagesDir: any): Map<any, any>;
+export function orderEnvelopes(manifest: any, pagesDir: any, envelopeByFile: any): any[] | null;
+export function isCssOnlyChange(changedFiles: any): any;
+export function buildPageOnlyFastPathSignature(envelope: any): any;
+export function buildGlobalGraphHash(envelopes: any): string;
+export function selectPageOnlyEntries(changedFiles: any, pagesDir: any, manifestEntryByPath: any): any[];
+export function maybeRunVersionCheck({ state, startupProfile, projectRoot, logger, bundlerBin }: {
+    state: any;
+    startupProfile: any;
+    projectRoot: any;
+    logger: any;
+    bundlerBin: any;
+}): Promise<void>;
+export function buildCompilerWarningEmitter(logger: any): (line: string) => void;

package/dist/dev-build-session/helpers.js

@@ -0,0 +1,223 @@
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { createCompilerWarningEmitter } from '../build/compiler-runtime.js';
+import { resolveBundlerBin } from '../toolchain-paths.js';
+import { getActiveToolchainCandidate } from '../toolchain-runner.js';
+import { maybeWarnAboutZenithVersionMismatch } from '../version-check.js';
+export function createCompilerTotals() {
+    return {
+        pageMs: 0,
+        ownerMs: 0,
+        componentMs: 0,
+        pageCalls: 0,
+        ownerCalls: 0,
+        componentCalls: 0,
+        componentCacheHits: 0,
+        componentCacheMisses: 0
+    };
+}
+export function createExpressionRewriteMetrics() {
+    return {
+        calls: 0,
+        compilerOwnedBindings: 0,
+        ambiguousBindings: 0
+    };
+}
+export function toManifestEntryMap(manifest, pagesDir) {
+    const map = new Map();
+    for (const entry of manifest) {
+        map.set(resolve(pagesDir, entry.file), entry);
+    }
+    return map;
+}
+export function orderEnvelopes(manifest, pagesDir, envelopeByFile) {
+    const ordered = [];
+    for (const entry of manifest) {
+        const envelope = envelopeByFile.get(resolve(pagesDir, entry.file));
+        if (!envelope) {
+            return null;
+        }
+        ordered.push(envelope);
+    }
+    return ordered;
+}
+export function isCssOnlyChange(changedFiles) {
+    return changedFiles.length > 0 && changedFiles.every((filePath) => filePath.endsWith('.css'));
+}
+function stableJson(value) {
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function collectJsImportSpecifiers(source) {
+    const values = [];
+    const patterns = [
+        /\bimport\s+(?:[^'"\n;]*?\s+from\s+)?['"]([^'"]+)['"]/g,
+        /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /\bexport\s+[^'"\n;]*?\s+from\s+['"]([^'"]+)['"]/g
+    ];
+    for (const pattern of patterns) {
+        pattern.lastIndex = 0;
+        for (const match of source.matchAll(pattern)) {
+            const value = String(match[1] || '').trim();
+            if (value.length > 0 && !values.includes(value)) {
+                values.push(value);
+            }
+        }
+    }
+    return values.sort();
+}
+function isExternalRuntimeSpecifier(specifier) {
+    return !specifier.startsWith('.')
+        && !specifier.startsWith('/')
+        && !specifier.startsWith('@/')
+        && !specifier.startsWith('\0zenith:')
+        && !specifier.includes('zenith:');
+}
+function collectEnvelopeAssetContract(envelope) {
+    const cssImportSpecifiers = new Set();
+    const externalImportSpecifiers = new Set();
+    for (const entry of envelope.ir.hoisted?.imports || []) {
+        for (const specifier of collectJsImportSpecifiers(String(entry || ''))) {
+            if (specifier.endsWith('.css')) {
+                cssImportSpecifiers.add(specifier);
+            }
+            if (isExternalRuntimeSpecifier(specifier)) {
+                externalImportSpecifiers.add(specifier);
+            }
+        }
+    }
+    for (const moduleEntry of envelope.ir.modules || []) {
+        for (const specifier of collectJsImportSpecifiers(String(moduleEntry?.source || ''))) {
+            if (specifier.endsWith('.css')) {
+                cssImportSpecifiers.add(specifier);
+            }
+            if (isExternalRuntimeSpecifier(specifier)) {
+                externalImportSpecifiers.add(specifier);
+            }
+        }
+    }
+    for (const importEntry of envelope.ir.imports || []) {
+        const specifier = String(importEntry?.spec || '').trim();
+        if (!specifier) {
+            continue;
+        }
+        if (specifier.endsWith('.css')) {
+            cssImportSpecifiers.add(specifier);
+        }
+        if (isExternalRuntimeSpecifier(specifier)) {
+            externalImportSpecifiers.add(specifier);
+        }
+    }
+    return {
+        componentHoistIds: Object.keys(envelope.ir.components_scripts || {}).sort(),
+        cssImportSpecifiers: [...cssImportSpecifiers].sort(),
+        externalImportSpecifiers: [...externalImportSpecifiers].sort()
+    };
+}
+function collectTemplateClassSignature(envelope) {
+    const html = typeof envelope?.ir?.html === 'string' ? envelope.ir.html : '';
+    if (!html) {
+        return [];
+    }
+    const classes = new Set();
+    const classAttrRe = /\bclass\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+    let match;
+    while ((match = classAttrRe.exec(html)) !== null) {
+        const rawValue = String(match[1] || match[2] || '');
+        for (const token of rawValue.split(/\s+/)) {
+            const value = token.trim();
+            if (value.length > 0) {
+                classes.add(value);
+            }
+        }
+    }
+    return [...classes].sort();
+}
+export function buildPageOnlyFastPathSignature(envelope) {
+    return stableJson({
+        route: envelope.route,
+        router: envelope.router === true,
+        assetContract: collectEnvelopeAssetContract(envelope),
+        templateClassSignature: collectTemplateClassSignature(envelope),
+        styleBlocks: envelope.ir.style_blocks || [],
+        serverScript: envelope.ir.server_script || null,
+        prerender: envelope.ir.prerender === true,
+        hasGuard: envelope.ir.has_guard === true,
+        hasLoad: envelope.ir.has_load === true,
+        guardModuleRef: envelope.ir.guard_module_ref || null,
+        loadModuleRef: envelope.ir.load_module_ref || null
+    });
+}
+export function buildGlobalGraphHash(envelopes) {
+    const nodesByHoistId = new Map();
+    const edgeSet = new Set();
+    for (const envelope of envelopes) {
+        for (const node of envelope.ir.graph_nodes || []) {
+            if (node && typeof node.hoist_id === 'string' && node.hoist_id.length > 0) {
+                nodesByHoistId.set(node.hoist_id, true);
+            }
+        }
+        for (const edge of envelope.ir.graph_edges || []) {
+            if (typeof edge === 'string' && edge.length > 0) {
+                edgeSet.add(edge);
+            }
+        }
+    }
+    let seed = '';
+    for (const hoistId of [...nodesByHoistId.keys()].sort()) {
+        seed += `node:${hoistId}\n`;
+    }
+    for (const edge of [...edgeSet].sort()) {
+        seed += `edge:${edge}\n`;
+    }
+    return createHash('sha256').update(seed).digest('hex');
+}
+export function selectPageOnlyEntries(changedFiles, pagesDir, manifestEntryByPath) {
+    if (changedFiles.length === 0) {
+        return [];
+    }
+    const selected = new Map();
+    for (const filePath of changedFiles) {
+        const resolvedPath = resolve(filePath);
+        if (!resolvedPath.startsWith(pagesDir) || !resolvedPath.endsWith('.zen') || !existsSync(resolvedPath)) {
+            return [];
+        }
+        const entry = manifestEntryByPath.get(resolvedPath);
+        if (!entry) {
+            return [];
+        }
+        selected.set(entry.file, entry);
+    }
+    return [...selected.values()];
+}
+export async function maybeRunVersionCheck({ state, startupProfile, projectRoot, logger, bundlerBin }) {
+    if (state.versionChecked) {
+        return;
+    }
+    const resolvedBundlerCandidate = getActiveToolchainCandidate(bundlerBin);
+    await startupProfile.measureAsync('version_mismatch_check', () => maybeWarnAboutZenithVersionMismatch({
+        projectRoot,
+        logger,
+        command: 'dev',
+        bundlerBinPath: resolvedBundlerCandidate?.path || resolveBundlerBin(projectRoot)
+    }));
+    state.versionChecked = true;
+}
+export function buildCompilerWarningEmitter(logger) {
+    return createCompilerWarningEmitter((line) => {
+        if (logger && typeof logger.warn === 'function') {
+            logger.warn(line, { onceKey: `compiler-warning:${line}` });
+            return;
+        }
+        console.warn(line);
+    });
+}

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

@@ -0,0 +1,24 @@
+export function createDevBuildSession(options: any): {
+    build(buildOptions?: {}): Promise<{
+        pages: number;
+        assets: any;
+        strategy: string;
+    }>;
+    getImageRuntimePayload(): {
+        mode: string;
+        basePath: 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;
+};