@zenithbuild/cli 0.7.4 → 0.7.7

package/dist/request-body.d.ts

@@ -1,2 +1 @@
 export function readRequestBodyBuffer(req: any): Promise<Buffer<ArrayBuffer>>;
-export function encodeRequestBodyBase64(bodyBuffer: any): string;

package/dist/request-body.js

@@ -5,9 +5,3 @@ export async function readRequestBodyBuffer(req) {
     }
     return Buffer.concat(chunks);
 }
-export function encodeRequestBodyBase64(bodyBuffer) {
-    if (!Buffer.isBuffer(bodyBuffer) || bodyBuffer.length === 0) {
-        return '';
-    }
-    return bodyBuffer.toString('base64');
-}

package/dist/resource-manifest.d.ts

@@ -0,0 +1,16 @@
+export function writeResourceRouteManifest(staticDir: any, routeManifest: any, basePath?: string): Promise<({
+    path: any;
+    file: any;
+    route_kind: string;
+    server_script: any;
+    server_script_path: any;
+    has_guard: boolean;
+    has_load: boolean;
+    has_action: boolean;
+    params: any;
+    route_id: any;
+} | null)[]>;
+export function loadResourceRouteManifest(distDir: any, fallbackBasePath?: string): Promise<{
+    basePath: any;
+    routes: any;
+}>;

package/dist/resource-manifest.js

@@ -0,0 +1,53 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { compareRouteSpecificity } from './server/resolve-request-route.js';
+function sanitizeResourceRoute(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+    if (typeof entry.path !== 'string' || typeof entry.server_script !== 'string') {
+        return null;
+    }
+    return {
+        path: entry.path,
+        file: typeof entry.file === 'string' ? entry.file : '',
+        route_kind: 'resource',
+        server_script: entry.server_script,
+        server_script_path: typeof entry.server_script_path === 'string' ? entry.server_script_path : '',
+        has_guard: entry.has_guard === true,
+        has_load: entry.has_load === true,
+        has_action: entry.has_action === true,
+        params: Array.isArray(entry.params) ? entry.params.filter((value) => typeof value === 'string') : [],
+        route_id: typeof entry.route_id === 'string' ? entry.route_id : null
+    };
+}
+export async function writeResourceRouteManifest(staticDir, routeManifest, basePath = '/') {
+    const routes = (Array.isArray(routeManifest) ? routeManifest : [])
+        .filter((entry) => entry?.route_kind === 'resource')
+        .map((entry) => sanitizeResourceRoute(entry))
+        .filter(Boolean)
+        .sort((left, right) => compareRouteSpecificity(left.path, right.path));
+    const manifestPath = join(staticDir, 'assets', 'resource-manifest.json');
+    await mkdir(join(staticDir, 'assets'), { recursive: true });
+    await writeFile(manifestPath, `${JSON.stringify({ base_path: basePath, routes }, null, 2)}\n`, 'utf8');
+    return routes;
+}
+export async function loadResourceRouteManifest(distDir, fallbackBasePath = '/') {
+    const manifestPath = join(distDir, 'assets', 'resource-manifest.json');
+    try {
+        const parsed = JSON.parse(await readFile(manifestPath, 'utf8'));
+        return {
+            basePath: typeof parsed?.base_path === 'string' ? parsed.base_path : fallbackBasePath,
+            routes: (Array.isArray(parsed?.routes) ? parsed.routes : [])
+                .map((entry) => sanitizeResourceRoute(entry))
+                .filter(Boolean)
+                .sort((left, right) => compareRouteSpecificity(left.path, right.path))
+        };
+    }
+    catch {
+        return {
+            basePath: fallbackBasePath,
+            routes: []
+        };
+    }
+}

package/dist/resource-response.d.ts

@@ -0,0 +1,49 @@
+export function buildResourceResponseDescriptor(result: any, basePath?: string, setCookies?: any[]): {
+    status: any;
+    headers: {
+        Location: string;
+        'Cache-Control': string;
+        'Content-Type'?: undefined;
+        'Content-Disposition'?: undefined;
+        'Content-Length'?: undefined;
+        Connection?: undefined;
+    };
+    body: string;
+    setCookies: any[];
+} | {
+    status: any;
+    headers: {
+        'Content-Type': string;
+        Location?: undefined;
+        'Cache-Control'?: undefined;
+        'Content-Disposition'?: undefined;
+        'Content-Length'?: undefined;
+        Connection?: undefined;
+    };
+    body: any;
+    setCookies: any[];
+} | {
+    status: number;
+    headers: {
+        'Content-Type': any;
+        'Content-Disposition': string;
+        'Content-Length': string;
+        Location?: undefined;
+        'Cache-Control'?: undefined;
+        Connection?: undefined;
+    };
+    body: Buffer<ArrayBuffer>;
+    setCookies: any[];
+} | {
+    status: any;
+    headers: {
+        'Content-Type': any;
+        'Cache-Control': string;
+        Connection: string;
+        Location?: undefined;
+        'Content-Disposition'?: undefined;
+        'Content-Length'?: undefined;
+    };
+    body: any;
+    setCookies: any[];
+};

package/dist/resource-response.js

@@ -0,0 +1,160 @@
+import { appLocalRedirectLocation } from './base-path.js';
+import { buildAttachmentContentDisposition, decodeDownloadResultBody } from './download-result.js';
+import { clientFacingRouteMessage, defaultRouteDenyMessage } from './server-error.js';
+function serializeJsonBody(payload) {
+    return JSON.stringify(payload);
+}
+function createReadableStreamFromAsyncIterable(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const { value, done } = await iterator.next();
+                if (done) {
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(typeof value === 'string' ? new TextEncoder().encode(value) : value);
+                }
+            }
+            catch (err) {
+                controller.error(err);
+            }
+        },
+        async cancel() {
+            if (typeof iterator.return === 'function') {
+                await iterator.return();
+            }
+        }
+    });
+}
+function createSseStream(events) {
+    const iterator = events[Symbol.asyncIterator]();
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const { value, done } = await iterator.next();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                let chunk = '';
+                if (value.event)
+                    chunk += `event: ${value.event}\n`;
+                if (value.id)
+                    chunk += `id: ${value.id}\n`;
+                if (value.retry)
+                    chunk += `retry: ${value.retry}\n`;
+                const data = typeof value.data === 'string' ? value.data : JSON.stringify(value.data);
+                const lines = data.split('\n');
+                for (const line of lines) {
+                    chunk += `data: ${line}\n`;
+                }
+                chunk += '\n';
+                controller.enqueue(encoder.encode(chunk));
+            }
+            catch (err) {
+                controller.error(err);
+            }
+        },
+        async cancel() {
+            if (typeof iterator.return === 'function') {
+                await iterator.return();
+            }
+        }
+    });
+}
+export function buildResourceResponseDescriptor(result, basePath = '/', setCookies = []) {
+    if (!result || typeof result !== 'object') {
+        return {
+            status: 500,
+            headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+            body: defaultRouteDenyMessage(500),
+            setCookies
+        };
+    }
+    if (result.kind === 'redirect') {
+        return {
+            status: Number.isInteger(result.status) ? result.status : 302,
+            headers: {
+                Location: appLocalRedirectLocation(result.location, basePath),
+                'Cache-Control': 'no-store'
+            },
+            body: '',
+            setCookies
+        };
+    }
+    if (result.kind === 'deny') {
+        const status = Number.isInteger(result.status) ? result.status : 403;
+        return {
+            status,
+            headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+            body: clientFacingRouteMessage(status, result.message),
+            setCookies
+        };
+    }
+    if (result.kind === 'json' || result.kind === 'invalid') {
+        const status = Number.isInteger(result.status) ? result.status : (result.kind === 'invalid' ? 400 : 200);
+        return {
+            status,
+            headers: { 'Content-Type': 'application/json; charset=utf-8' },
+            body: serializeJsonBody(result.data),
+            setCookies
+        };
+    }
+    if (result.kind === 'text') {
+        return {
+            status: Number.isInteger(result.status) ? result.status : 200,
+            headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+            body: result.body,
+            setCookies
+        };
+    }
+    if (result.kind === 'download') {
+        const body = decodeDownloadResultBody(result, 'resource download response');
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': result.contentType,
+                'Content-Disposition': buildAttachmentContentDisposition(result.filename),
+                'Content-Length': String(body.byteLength)
+            },
+            body,
+            setCookies
+        };
+    }
+    if (result.kind === 'stream') {
+        const body = typeof result.body?.getReader === 'function'
+            ? result.body
+            : createReadableStreamFromAsyncIterable(result.body);
+        return {
+            status: Number.isInteger(result.status) ? result.status : 200,
+            headers: {
+                'Content-Type': result.contentType || 'application/octet-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            },
+            body,
+            setCookies
+        };
+    }
+    if (result.kind === 'sse') {
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/event-stream; charset=utf-8',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            },
+            body: createSseStream(result.events),
+            setCookies
+        };
+    }
+    return {
+        status: 500,
+        headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+        body: defaultRouteDenyMessage(500),
+        setCookies
+    };
+}

package/dist/resource-route-module.d.ts

@@ -0,0 +1,15 @@
+export function isResourceRouteFile(fileName: any): boolean;
+export function resourceRouteFileToRoute(filePath: any, root: any): string;
+export function analyzeResourceRouteModule(fullPath: any, root: any): {
+    path: string;
+    file: string;
+    path_kind: string;
+    render_mode: string;
+    route_kind: string;
+    params: string[];
+    server_script: string;
+    server_script_path: any;
+    has_guard: boolean;
+    has_load: boolean;
+    has_action: boolean;
+};

package/dist/resource-route-module.js

@@ -0,0 +1,129 @@
+import { readFileSync } from 'node:fs';
+import { relative, sep } from 'node:path';
+const RESOURCE_EXTENSIONS = ['.resource.ts', '.resource.js', '.resource.mts', '.resource.cts', '.resource.mjs', '.resource.cjs'];
+const FORBIDDEN_RESOURCE_EXPORT_RE = /\bexport\s+const\s+(?:data|prerender|exportPaths|ssr_data|props|ssr)\b/;
+function readSingleExport(source, name) {
+    const fnMatch = source.match(new RegExp(`\\bexport\\s+(?:async\\s+)?function\\s+${name}\\s*\\(([^)]*)\\)`));
+    const constParenMatch = source.match(new RegExp(`\\bexport\\s+const\\s+${name}\\s*=\\s*(?:async\\s*)?\\(([^)]*)\\)\\s*=>`));
+    const constSingleArgMatch = source.match(new RegExp(`\\bexport\\s+const\\s+${name}\\s*=\\s*(?:async\\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=>`));
+    const matchCount = Number(Boolean(fnMatch)) +
+        Number(Boolean(constParenMatch)) +
+        Number(Boolean(constSingleArgMatch));
+    return {
+        fnMatch,
+        constParenMatch,
+        constSingleArgMatch,
+        hasExport: matchCount > 0,
+        matchCount
+    };
+}
+function assertSingleCtxArg(sourceFile, name, exportMatch) {
+    const singleArg = String(exportMatch.constSingleArgMatch?.[1] || '').trim();
+    const paramsText = String((exportMatch.fnMatch || exportMatch.constParenMatch)?.[1] || '').trim();
+    const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
+    if (arity !== 1) {
+        throw new Error(`Zenith resource route contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: ${name}(ctx) must accept exactly one argument\n` +
+            `  Example: export async function ${name}(ctx) { ... }`);
+    }
+}
+function segmentsToRoute(segments) {
+    const routeSegments = segments.map((seg) => {
+        const optionalCatchAllMatch = seg.match(/^\[\[\.\.\.([a-zA-Z_][a-zA-Z0-9_]*)\]\]$/);
+        if (optionalCatchAllMatch) {
+            return `*${optionalCatchAllMatch[1]}?`;
+        }
+        const catchAllMatch = seg.match(/^\[\.\.\.([a-zA-Z_][a-zA-Z0-9_]*)\]$/);
+        if (catchAllMatch) {
+            return `*${catchAllMatch[1]}`;
+        }
+        const paramMatch = seg.match(/^\[([a-zA-Z_][a-zA-Z0-9_]*)\]$/);
+        if (paramMatch) {
+            return `:${paramMatch[1]}`;
+        }
+        return seg;
+    });
+    if (routeSegments.length > 0) {
+        const last = routeSegments[routeSegments.length - 1];
+        if (last === 'index' || last === 'page') {
+            routeSegments.pop();
+        }
+    }
+    return `/${routeSegments.join('/')}`;
+}
+export function isResourceRouteFile(fileName) {
+    return RESOURCE_EXTENSIONS.some((extension) => fileName.endsWith(extension));
+}
+export function resourceRouteFileToRoute(filePath, root) {
+    const rel = relative(root, filePath);
+    const extension = RESOURCE_EXTENSIONS.find((candidate) => rel.endsWith(candidate));
+    if (!extension) {
+        throw new Error(`[Zenith CLI] Resource route "${filePath}" does not use a supported .resource.* extension.`);
+    }
+    const withoutExt = rel.slice(0, -extension.length);
+    const segments = withoutExt.split(sep).filter(Boolean);
+    const route = segmentsToRoute(segments);
+    return route === '/' ? '/' : route.replace(/\/+/g, '/');
+}
+export function analyzeResourceRouteModule(fullPath, root) {
+    const source = readFileSync(fullPath, 'utf8').trim();
+    if (!source) {
+        throw new Error(`Zenith resource route contract violation:\n` +
+            `  File: ${fullPath}\n` +
+            `  Reason: resource route module is empty\n` +
+            `  Example: export async function load(ctx) { return ctx.json({ ok: true }); }`);
+    }
+    if (FORBIDDEN_RESOURCE_EXPORT_RE.test(source)) {
+        throw new Error(`Zenith resource route contract violation:\n` +
+            `  File: ${fullPath}\n` +
+            `  Reason: resource routes may only export guard(ctx), load(ctx), and action(ctx)\n` +
+            `  Example: remove page-only exports such as data/prerender/exportPaths`);
+    }
+    const guardExport = readSingleExport(source, 'guard');
+    const loadExport = readSingleExport(source, 'load');
+    const actionExport = readSingleExport(source, 'action');
+    for (const [name, exportMatch] of [
+        ['guard', guardExport],
+        ['load', loadExport],
+        ['action', actionExport]
+    ]) {
+        if (exportMatch.matchCount > 1) {
+            throw new Error(`Zenith resource route contract violation:\n` +
+                `  File: ${fullPath}\n` +
+                `  Reason: multiple ${name} exports detected\n` +
+                `  Example: keep exactly one export for ${name}(ctx)`);
+        }
+        if (exportMatch.hasExport) {
+            assertSingleCtxArg(fullPath, name, exportMatch);
+        }
+    }
+    if (!loadExport.hasExport && !actionExport.hasExport) {
+        throw new Error(`Zenith resource route contract violation:\n` +
+            `  File: ${fullPath}\n` +
+            `  Reason: resource routes must export load(ctx), action(ctx), or both\n` +
+            `  Example: export async function load(ctx) { return ctx.text('ok'); }`);
+    }
+    return {
+        path: resourceRouteFileToRoute(fullPath, root),
+        file: relative(root, fullPath).replaceAll('\\', '/'),
+        path_kind: resourceRouteFileToRoute(fullPath, root).split('/').some((segment) => segment.startsWith(':') || segment.startsWith('*'))
+            ? 'dynamic'
+            : 'static',
+        render_mode: 'server',
+        route_kind: 'resource',
+        params: resourceRouteFileToRoute(fullPath, root)
+            .split('/')
+            .filter(Boolean)
+            .filter((segment) => segment.startsWith(':') || segment.startsWith('*'))
+            .map((segment) => {
+            const raw = segment.slice(1);
+            return raw.endsWith('?') ? raw.slice(0, -1) : raw;
+        }),
+        server_script: source,
+        server_script_path: fullPath,
+        has_guard: guardExport.hasExport,
+        has_load: loadExport.hasExport,
+        has_action: actionExport.hasExport
+    };
+}

package/dist/route-check-support.js

@@ -1,4 +1,4 @@
-const ROUTE_CHECK_UNSUPPORTED_TARGETS = new Set(['vercel', 'netlify']);
+const ROUTE_CHECK_UNSUPPORTED_TARGETS = new Set(['vercel', 'netlify', 'static-export']);
 export function supportsTargetRouteCheck(target) {
     return !ROUTE_CHECK_UNSUPPORTED_TARGETS.has(String(target || '').trim());
 }

package/dist/server-contract/constants.d.ts

@@ -0,0 +1,5 @@
+export const ALLOWED_KEYS: Set<string>;
+export const RESOURCE_ALLOWED_KEYS: Set<string>;
+export const ROUTE_RESULT_KINDS: Set<string>;
+export const AUTH_CONTROL_FLOW_FLAG: "__zenith_auth_control_flow";
+export const STAGED_SET_COOKIES_KEY: "__zenith_staged_set_cookies";

package/dist/server-contract/constants.js

@@ -0,0 +1,5 @@
+export const ALLOWED_KEYS = new Set(['data', 'load', 'guard', 'action', 'prerender', 'exportPaths', 'ssr_data', 'props', 'ssr']);
+export const RESOURCE_ALLOWED_KEYS = new Set(['load', 'guard', 'action']);
+export const ROUTE_RESULT_KINDS = new Set(['allow', 'redirect', 'deny', 'data', 'invalid', 'json', 'text', 'download', 'stream', 'sse']);
+export const AUTH_CONTROL_FLOW_FLAG = '__zenith_auth_control_flow';
+export const STAGED_SET_COOKIES_KEY = '__zenith_staged_set_cookies';

package/dist/server-contract/export-validation.d.ts

@@ -0,0 +1,5 @@
+export function validateServerExports({ exports, filePath, routeKind }: {
+    exports: any;
+    filePath: any;
+    routeKind?: string | undefined;
+}): void;

package/dist/server-contract/export-validation.js

@@ -0,0 +1,59 @@
+import { ALLOWED_KEYS, RESOURCE_ALLOWED_KEYS } from './constants.js';
+function assertOneArgRouteFunction({ filePath, exportName, value }) {
+    if (typeof value !== 'function') {
+        throw new Error(`[Zenith] ${filePath}: "${exportName}" must be a function.`);
+    }
+    if (value.length !== 1) {
+        throw new Error(`[Zenith] ${filePath}: "${exportName}(ctx)" must take exactly 1 argument.`);
+    }
+    const fnStr = value.toString();
+    const paramsMatch = fnStr.match(/^[^{=]+\(([^)]*)\)/);
+    if (paramsMatch && paramsMatch[1].includes('...')) {
+        throw new Error(`[Zenith] ${filePath}: "${exportName}(ctx)" must not contain rest parameters.`);
+    }
+}
+export function validateServerExports({ exports, filePath, routeKind = 'page' }) {
+    const exportKeys = Object.keys(exports);
+    const allowedKeys = routeKind === 'resource' ? RESOURCE_ALLOWED_KEYS : ALLOWED_KEYS;
+    const illegalKeys = exportKeys.filter((key) => !allowedKeys.has(key));
+    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 hasAction = 'action' in exports;
+    const hasNew = hasData || hasLoad || hasAction;
+    const hasLegacy = ('ssr_data' in exports) || ('props' in exports) || ('ssr' in exports);
+    if (routeKind === 'resource') {
+        if (hasData) {
+            throw new Error(`[Zenith] ${filePath}: resource routes may not export "data". Use load(ctx) or action(ctx) with ctx.json()/ctx.text().`);
+        }
+        if (!hasLoad && !hasAction) {
+            throw new Error(`[Zenith] ${filePath}: resource routes must export load(ctx), action(ctx), or both.`);
+        }
+    }
+    if (hasData && hasLoad) {
+        throw new Error(`[Zenith] ${filePath}: cannot export both "data" and "load". Choose one.`);
+    }
+    if (routeKind === 'page' && hasNew && hasLegacy) {
+        throw new Error(`[Zenith] ${filePath}: cannot mix new ("data"/"load") with legacy ("ssr_data"/"props"/"ssr") exports.`);
+    }
+    if (routeKind === 'page' && 'prerender' in exports && typeof exports.prerender !== 'boolean') {
+        throw new Error(`[Zenith] ${filePath}: "prerender" must be a boolean.`);
+    }
+    if (routeKind === 'page' && 'exportPaths' in exports) {
+        if (!Array.isArray(exports.exportPaths) || exports.exportPaths.some((value) => typeof value !== 'string')) {
+            throw new Error(`[Zenith] ${filePath}: "exportPaths" must be an array of string pathnames.`);
+        }
+    }
+    if (hasLoad) {
+        assertOneArgRouteFunction({ filePath, exportName: 'load', value: exports.load });
+    }
+    if (hasGuard) {
+        assertOneArgRouteFunction({ filePath, exportName: 'guard', value: exports.guard });
+    }
+    if (hasAction) {
+        assertOneArgRouteFunction({ filePath, exportName: 'action', value: exports.action });
+    }
+}

package/dist/server-contract/json-serializable.d.ts

@@ -0,0 +1 @@
+export function assertJsonSerializable(value: any, where?: string): void;

package/dist/server-contract/json-serializable.js

@@ -0,0 +1,52 @@
+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 (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}`);
+            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 += 1) {
+                    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 key of Object.keys(v)) {
+                if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                    throw new Error(`[Zenith] ${where}: forbidden prototype pollution key "${key}" at ${path}.${key}`);
+                }
+                walk(v[key], `${path}.${key}`);
+            }
+            return;
+        }
+        throw new Error(`[Zenith] ${where}: unsupported type at ${path}`);
+    }
+    walk(value, '$');
+}

package/dist/server-contract/resolve.d.ts

@@ -0,0 +1,15 @@
+export function resolveRouteResult({ exports, ctx, filePath, guardOnly, routeKind }: {
+    exports: any;
+    ctx: any;
+    filePath: any;
+    guardOnly?: boolean | undefined;
+    routeKind?: string | undefined;
+}): Promise<{
+    result: any;
+    trace: any;
+}>;
+export function resolveServerPayload({ exports, ctx, filePath }: {
+    exports: any;
+    ctx: any;
+    filePath: any;
+}): Promise<any>;