@kuratchi/js 0.0.14 → 0.0.16

package/dist/compiler/wrangler-sync.js

@@ -0,0 +1,185 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function stripJsonComments(content) {
+    let result = '';
+    let i = 0;
+    let inString = false;
+    let stringChar = '';
+    while (i < content.length) {
+        const ch = content[i];
+        const next = content[i + 1];
+        if (inString) {
+            result += ch;
+            if (ch === '\\' && i + 1 < content.length) {
+                result += next;
+                i += 2;
+                continue;
+            }
+            if (ch === stringChar) {
+                inString = false;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            stringChar = ch;
+            result += ch;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            while (i < content.length && content[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i += 2;
+            while (i < content.length - 1 && !(content[i] === '*' && content[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}
+export function syncWranglerConfig(opts) {
+    const jsoncPath = path.join(opts.projectDir, 'wrangler.jsonc');
+    const jsonPath = path.join(opts.projectDir, 'wrangler.json');
+    const tomlPath = path.join(opts.projectDir, 'wrangler.toml');
+    let configPath;
+    let isJsonc = false;
+    if (fs.existsSync(jsoncPath)) {
+        configPath = jsoncPath;
+        isJsonc = true;
+    }
+    else if (fs.existsSync(jsonPath)) {
+        configPath = jsonPath;
+    }
+    else if (fs.existsSync(tomlPath)) {
+        console.log('[kuratchi] wrangler.toml detected. Auto-sync requires wrangler.jsonc. Skipping wrangler sync.');
+        return;
+    }
+    else {
+        console.log('[kuratchi] Creating wrangler.jsonc with workflow config...');
+        configPath = jsoncPath;
+        isJsonc = true;
+    }
+    let rawContent = '';
+    let wranglerConfig = {};
+    if (fs.existsSync(configPath)) {
+        rawContent = fs.readFileSync(configPath, 'utf-8');
+        try {
+            const jsonContent = stripJsonComments(rawContent);
+            wranglerConfig = JSON.parse(jsonContent);
+        }
+        catch (err) {
+            console.error(`[kuratchi] Failed to parse ${path.basename(configPath)}: ${err.message}`);
+            console.error('[kuratchi] Skipping wrangler sync. Please fix the JSON syntax.');
+            return;
+        }
+    }
+    let changed = false;
+    if (opts.config.workflows.length > 0) {
+        const existingWorkflows = wranglerConfig.workflows || [];
+        const existingByBinding = new Map(existingWorkflows.map((workflow) => [workflow.binding, workflow]));
+        for (const workflow of opts.config.workflows) {
+            const name = workflow.binding.toLowerCase().replace(/_/g, '-');
+            const entry = {
+                name,
+                binding: workflow.binding,
+                class_name: workflow.className,
+            };
+            const existing = existingByBinding.get(workflow.binding);
+            if (!existing) {
+                existingWorkflows.push(entry);
+                changed = true;
+                console.log(`[kuratchi] Added workflow "${workflow.binding}" to wrangler config`);
+            }
+            else if (existing.class_name !== workflow.className) {
+                existing.class_name = workflow.className;
+                changed = true;
+                console.log(`[kuratchi] Updated workflow "${workflow.binding}" class_name to "${workflow.className}"`);
+            }
+        }
+        const configBindings = new Set(opts.config.workflows.map((workflow) => workflow.binding));
+        const filtered = existingWorkflows.filter((workflow) => {
+            if (!configBindings.has(workflow.binding)) {
+                const expectedName = workflow.binding.toLowerCase().replace(/_/g, '-');
+                if (workflow.name === expectedName) {
+                    console.log(`[kuratchi] Removed workflow "${workflow.binding}" from wrangler config`);
+                    changed = true;
+                    return false;
+                }
+            }
+            return true;
+        });
+        if (filtered.length !== existingWorkflows.length) {
+            wranglerConfig.workflows = filtered;
+        }
+        else {
+            wranglerConfig.workflows = existingWorkflows;
+        }
+        if (wranglerConfig.workflows.length === 0) {
+            delete wranglerConfig.workflows;
+        }
+    }
+    if (opts.config.containers.length > 0) {
+        const existingContainers = wranglerConfig.containers || [];
+        const existingByBinding = new Map(existingContainers.map((container) => [container.binding, container]));
+        for (const container of opts.config.containers) {
+            const name = container.binding.toLowerCase().replace(/_/g, '-');
+            const entry = {
+                name,
+                binding: container.binding,
+                class_name: container.className,
+            };
+            const existing = existingByBinding.get(container.binding);
+            if (!existing) {
+                existingContainers.push(entry);
+                changed = true;
+                console.log(`[kuratchi] Added container "${container.binding}" to wrangler config`);
+            }
+            else if (existing.class_name !== container.className) {
+                existing.class_name = container.className;
+                changed = true;
+                console.log(`[kuratchi] Updated container "${container.binding}" class_name to "${container.className}"`);
+            }
+        }
+        wranglerConfig.containers = existingContainers;
+        if (wranglerConfig.containers.length === 0) {
+            delete wranglerConfig.containers;
+        }
+    }
+    if (opts.config.durableObjects.length > 0) {
+        if (!wranglerConfig.durable_objects) {
+            wranglerConfig.durable_objects = { bindings: [] };
+        }
+        const existingBindings = wranglerConfig.durable_objects.bindings || [];
+        const existingByName = new Map(existingBindings.map((binding) => [binding.name, binding]));
+        for (const durableObject of opts.config.durableObjects) {
+            const entry = {
+                name: durableObject.binding,
+                class_name: durableObject.className,
+            };
+            const existing = existingByName.get(durableObject.binding);
+            if (!existing) {
+                existingBindings.push(entry);
+                changed = true;
+                console.log(`[kuratchi] Added durable_object "${durableObject.binding}" to wrangler config`);
+            }
+            else if (existing.class_name !== durableObject.className) {
+                existing.class_name = durableObject.className;
+                changed = true;
+                console.log(`[kuratchi] Updated durable_object "${durableObject.binding}" class_name to "${durableObject.className}"`);
+            }
+        }
+        wranglerConfig.durable_objects.bindings = existingBindings;
+    }
+    if (!changed)
+        return;
+    const newContent = JSON.stringify(wranglerConfig, null, isJsonc ? '\t' : '\t');
+    opts.writeFile(configPath, newContent + '\n');
+}

package/dist/runtime/app.js

@@ -133,13 +133,25 @@ export function createApp(config) {
 }
 /** Render a page through its layout */
 function renderPage(route, data, layouts) {
-    const content = route.render(data);
+    const rendered = normalizeRenderOutput(route.render(data));
     const layoutName = route.layout ?? 'default';
     const layout = layouts[layoutName];
     const html = layout
-        ? layout.render({ content, data })
-        : content;
+        ? layout.render({ content: rendered.html, data, head: rendered.head })
+        : rendered.html;
     return new Response(html, {
         headers: { 'content-type': 'text/html; charset=utf-8' },
     });
 }
+function normalizeRenderOutput(output) {
+    if (typeof output === 'string') {
+        return { html: output, head: '' };
+    }
+    return {
+        html: typeof output?.html === 'string' ? output.html : '',
+        head: typeof output?.head === 'string' ? output.head : '',
+        fragments: output && typeof output === 'object' && !Array.isArray(output) && typeof output.fragments === 'object'
+            ? (output.fragments ?? {})
+            : {},
+    };
+}

package/dist/runtime/generated-worker.d.ts

@@ -0,0 +1,33 @@
+import type { PageRenderOutput, RuntimeContext, RuntimeDefinition } from './types.js';
+export interface GeneratedAssetEntry {
+    content: string;
+    mime: string;
+    etag: string;
+}
+export interface GeneratedApiRoute {
+    pattern: string;
+    __api: true;
+    [method: string]: unknown;
+}
+export interface GeneratedPageRoute {
+    pattern: string;
+    load?: (params: Record<string, string>) => Promise<unknown> | unknown;
+    actions?: Record<string, (...args: any[]) => Promise<unknown> | unknown>;
+    rpc?: Record<string, (...args: any[]) => Promise<unknown> | unknown>;
+    render: (data: Record<string, any>) => PageRenderOutput;
+}
+export interface GeneratedWorkerOptions {
+    routes: Array<GeneratedPageRoute | GeneratedApiRoute>;
+    layout: (content: string, head?: string) => Promise<string> | string;
+    layoutActions: Record<string, (...args: any[]) => Promise<unknown> | unknown>;
+    assetsPrefix: string;
+    assets: Record<string, GeneratedAssetEntry>;
+    errorPages: Record<number, (detail?: string) => string>;
+    runtimeDefinition?: RuntimeDefinition;
+    workflowStatusRpc?: Record<string, (instanceId: string) => Promise<unknown>>;
+    initializeRequest?: (ctx: RuntimeContext) => Promise<void> | void;
+    preRouteChecks?: (ctx: RuntimeContext) => Promise<Response | null | undefined> | Response | null | undefined;
+}
+export declare function createGeneratedWorker(opts: GeneratedWorkerOptions): {
+    fetch(request: Request, env: Record<string, any>, ctx: ExecutionContext): Promise<Response>;
+};

package/dist/runtime/generated-worker.js

@@ -0,0 +1,412 @@
+import { __esc, __getLocals, __setLocal, __setRequestContext, buildDefaultBreadcrumbs } from './context.js';
+import { Router } from './router.js';
+export function createGeneratedWorker(opts) {
+    const router = new Router();
+    const runtimeEntries = __getRuntimeEntries(opts.runtimeDefinition);
+    for (let i = 0; i < opts.routes.length; i++) {
+        router.add(opts.routes[i].pattern, i);
+    }
+    return {
+        async fetch(request, env, ctx) {
+            __setRequestContext(ctx, request, env);
+            const runtimeCtx = {
+                request,
+                env,
+                ctx,
+                url: new URL(request.url),
+                params: {},
+                locals: __getLocals(),
+            };
+            if (opts.initializeRequest) {
+                await opts.initializeRequest(runtimeCtx);
+            }
+            const coreFetch = async () => {
+                const { url } = runtimeCtx;
+                const fragmentId = request.headers.get('x-kuratchi-fragment');
+                const preRoute = opts.preRouteChecks ? await opts.preRouteChecks(runtimeCtx) : null;
+                if (preRoute instanceof Response) {
+                    return __secHeaders(preRoute);
+                }
+                if (url.pathname.startsWith(opts.assetsPrefix)) {
+                    const name = url.pathname.slice(opts.assetsPrefix.length);
+                    const asset = opts.assets[name];
+                    if (asset) {
+                        if (request.headers.get('if-none-match') === asset.etag) {
+                            return new Response(null, { status: 304 });
+                        }
+                        return new Response(asset.content, {
+                            headers: {
+                                'content-type': asset.mime,
+                                'cache-control': 'public, max-age=31536000, immutable',
+                                'etag': asset.etag,
+                            },
+                        });
+                    }
+                    return __secHeaders(new Response('Not Found', { status: 404 }));
+                }
+                const match = router.match(url.pathname);
+                if (!match) {
+                    return __secHeaders(new Response(await opts.layout(__renderError(opts.errorPages, 404)), {
+                        status: 404,
+                        headers: { 'content-type': 'text/html; charset=utf-8' },
+                    }));
+                }
+                runtimeCtx.params = match.params;
+                __setLocal('params', match.params);
+                const route = opts.routes[match.index];
+                if ('__api' in route && route.__api) {
+                    return __dispatchApiRoute(route, runtimeCtx);
+                }
+                const pageRoute = route;
+                const queryFn = request.headers.get('x-kuratchi-query-fn') || '';
+                const queryArgsRaw = request.headers.get('x-kuratchi-query-args') || '[]';
+                let queryArgs = [];
+                try {
+                    const parsed = JSON.parse(queryArgsRaw);
+                    queryArgs = Array.isArray(parsed) ? parsed : [];
+                }
+                catch { }
+                __setLocal('__queryOverride', queryFn ? { fn: queryFn, args: queryArgs } : null);
+                if (!__getLocals().__breadcrumbs) {
+                    __setLocal('breadcrumbs', buildDefaultBreadcrumbs(url.pathname, match.params));
+                }
+                const rpcResponse = await __handleRpc(pageRoute, opts.workflowStatusRpc ?? {}, runtimeCtx);
+                if (rpcResponse)
+                    return rpcResponse;
+                if (request.method === 'POST') {
+                    const actionResponse = await __handleAction(pageRoute, opts.layoutActions, opts.layout, runtimeCtx, fragmentId);
+                    if (actionResponse)
+                        return actionResponse;
+                }
+                try {
+                    const loaded = pageRoute.load ? await pageRoute.load(match.params) : {};
+                    const data = (__isObject(loaded) ? loaded : { value: loaded });
+                    data.params = match.params;
+                    data.breadcrumbs = __getLocals().__breadcrumbs ?? [];
+                    const allActions = Object.assign({}, pageRoute.actions, opts.layoutActions || {});
+                    Object.keys(allActions).forEach((key) => {
+                        if (!(key in data))
+                            data[key] = { error: undefined, loading: false, success: false };
+                    });
+                    return await __renderPage(opts.layout, pageRoute, data, fragmentId);
+                }
+                catch (err) {
+                    if (err?.isRedirectError) {
+                        const redirectTo = err.location || url.pathname;
+                        const redirectStatus = Number(err.status) || 303;
+                        return __attachCookies(new Response(null, { status: redirectStatus, headers: { location: redirectTo } }));
+                    }
+                    const handled = await __runRuntimeError(runtimeEntries, runtimeCtx, err);
+                    if (handled)
+                        return __secHeaders(handled);
+                    console.error('[kuratchi] Route load/render error:', err);
+                    const pageErrStatus = err?.isPageError && err.status ? err.status : 500;
+                    const errDetail = err?.isPageError ? err.message : (__isDevMode() && err?.message) ? err.message : undefined;
+                    return __secHeaders(new Response(await opts.layout(__renderError(opts.errorPages, pageErrStatus, errDetail)), {
+                        status: pageErrStatus,
+                        headers: { 'content-type': 'text/html; charset=utf-8' },
+                    }));
+                }
+            };
+            try {
+                const requestResponse = await __runRuntimeRequest(runtimeEntries, runtimeCtx, async () => {
+                    return __runRuntimeRoute(runtimeEntries, runtimeCtx, coreFetch);
+                });
+                return await __runRuntimeResponse(runtimeEntries, runtimeCtx, requestResponse);
+            }
+            catch (err) {
+                const handled = await __runRuntimeError(runtimeEntries, runtimeCtx, err);
+                if (handled)
+                    return __secHeaders(handled);
+                throw err;
+            }
+        },
+    };
+}
+async function __dispatchApiRoute(route, runtimeCtx) {
+    const { request } = runtimeCtx;
+    const method = request.method;
+    if (method === 'OPTIONS') {
+        const handler = route.OPTIONS;
+        if (typeof handler === 'function')
+            return __secHeaders(await handler(runtimeCtx));
+        const allowed = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']
+            .filter((name) => typeof route[name] === 'function')
+            .join(', ');
+        return __secHeaders(new Response(null, { status: 204, headers: { Allow: allowed, 'Access-Control-Allow-Methods': allowed } }));
+    }
+    const handler = route[method];
+    if (typeof handler !== 'function') {
+        const allowed = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']
+            .filter((name) => typeof route[name] === 'function')
+            .join(', ');
+        return __secHeaders(new Response(JSON.stringify({ error: 'Method Not Allowed' }), {
+            status: 405,
+            headers: { 'content-type': 'application/json', Allow: allowed },
+        }));
+    }
+    return __secHeaders(await handler(runtimeCtx));
+}
+async function __handleRpc(route, workflowStatusRpc, runtimeCtx) {
+    const { request, url } = runtimeCtx;
+    const rpcName = url.searchParams.get('_rpc');
+    const hasRouteRpc = rpcName && route.rpc && Object.hasOwn(route.rpc, rpcName);
+    const hasWorkflowRpc = rpcName && Object.hasOwn(workflowStatusRpc, rpcName);
+    if (!(request.method === 'GET' && rpcName && (hasRouteRpc || hasWorkflowRpc))) {
+        return null;
+    }
+    if (request.headers.get('x-kuratchi-rpc') !== '1') {
+        return __secHeaders(new Response(JSON.stringify({ ok: false, error: 'Forbidden' }), {
+            status: 403,
+            headers: { 'content-type': 'application/json', 'cache-control': 'no-store' },
+        }));
+    }
+    try {
+        const rpcArgsStr = url.searchParams.get('_args');
+        let rpcArgs = [];
+        if (rpcArgsStr) {
+            const parsed = JSON.parse(rpcArgsStr);
+            rpcArgs = Array.isArray(parsed) ? parsed : [];
+        }
+        const rpcFn = hasRouteRpc ? route.rpc[rpcName] : workflowStatusRpc[rpcName];
+        const rpcResult = await rpcFn(...rpcArgs);
+        return __secHeaders(new Response(JSON.stringify({ ok: true, data: rpcResult }), {
+            headers: { 'content-type': 'application/json', 'cache-control': 'no-store' },
+        }));
+    }
+    catch (err) {
+        console.error('[kuratchi] RPC error:', err);
+        const errMsg = __isDevMode() ? err?.message : 'Internal Server Error';
+        return __secHeaders(new Response(JSON.stringify({ ok: false, error: errMsg }), {
+            status: 500,
+            headers: { 'content-type': 'application/json', 'cache-control': 'no-store' },
+        }));
+    }
+}
+async function __handleAction(route, layoutActions, layout, runtimeCtx, fragmentId) {
+    const { request, url, params } = runtimeCtx;
+    if (request.method !== 'POST')
+        return null;
+    if (!__isSameOrigin(request, url)) {
+        return __secHeaders(new Response('Forbidden', { status: 403 }));
+    }
+    const formData = await request.formData();
+    const actionName = formData.get('_action');
+    const actionKey = typeof actionName === 'string' ? actionName : null;
+    const actionFn = (actionKey && route.actions && Object.hasOwn(route.actions, actionKey) ? route.actions[actionKey] : null)
+        || (actionKey && layoutActions && Object.hasOwn(layoutActions, actionKey) ? layoutActions[actionKey] : null);
+    if (!(actionKey && actionFn)) {
+        return null;
+    }
+    const argsStr = formData.get('_args');
+    const isFetchAction = argsStr !== null;
+    try {
+        if (isFetchAction) {
+            const parsed = JSON.parse(String(argsStr));
+            const args = Array.isArray(parsed) ? parsed : [];
+            await actionFn(...args);
+        }
+        else {
+            await actionFn(formData);
+        }
+    }
+    catch (err) {
+        if (err?.isRedirectError) {
+            const redirectTo = err.location || url.pathname;
+            const redirectStatus = Number(err.status) || 303;
+            if (isFetchAction) {
+                return __attachCookies(__secHeaders(new Response(JSON.stringify({ ok: true, redirectTo, redirectStatus }), {
+                    headers: { 'content-type': 'application/json' },
+                })));
+            }
+            return __attachCookies(new Response(null, { status: redirectStatus, headers: { location: redirectTo } }));
+        }
+        console.error('[kuratchi] Action error:', err);
+        if (isFetchAction) {
+            const errMsg = __isDevMode() && err?.message ? err.message : 'Internal Server Error';
+            return __secHeaders(new Response(JSON.stringify({ ok: false, error: errMsg }), {
+                status: 500,
+                headers: { 'content-type': 'application/json' },
+            }));
+        }
+        const loaded = route.load ? await route.load(params) : {};
+        const data = (__isObject(loaded) ? loaded : { value: loaded });
+        data.params = params;
+        data.breadcrumbs = __getLocals().__breadcrumbs ?? [];
+        const allActions = Object.assign({}, route.actions, layoutActions || {});
+        Object.keys(allActions).forEach((key) => {
+            if (!(key in data))
+                data[key] = { error: undefined, loading: false, success: false };
+        });
+        const errMsg = err?.isActionError ? err.message : (__isDevMode() && err?.message) ? err.message : 'Action failed';
+        data[actionKey] = { error: errMsg, loading: false, success: false };
+        return await __renderPage(layout, route, data, fragmentId);
+    }
+    if (isFetchAction) {
+        return __attachCookies(new Response(JSON.stringify({ ok: true }), {
+            headers: { 'content-type': 'application/json' },
+        }));
+    }
+    const locals = __getLocals();
+    const redirectTo = locals.__redirectTo || url.pathname;
+    const redirectStatus = Number(locals.__redirectStatus) || 303;
+    return __attachCookies(new Response(null, { status: redirectStatus, headers: { location: redirectTo } }));
+}
+async function __renderPage(layout, route, data, fragmentId) {
+    const rendered = __normalizeRenderOutput(route.render(data));
+    if (fragmentId) {
+        const fragment = rendered.fragments?.[fragmentId];
+        if (typeof fragment !== 'string') {
+            return __secHeaders(new Response('Fragment not found', { status: 404 }));
+        }
+        return __attachCookies(new Response(fragment, {
+            headers: { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' },
+        }));
+    }
+    return __attachCookies(new Response(await layout(rendered.html, rendered.head || ''), {
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+    }));
+}
+function __renderError(errorPages, status, detail) {
+    const custom = errorPages[status];
+    if (custom)
+        return custom(detail);
+    const title = __errorMessages[status] || 'Error';
+    const detailHtml = detail
+        ? '<p style="font-family:ui-monospace,monospace;font-size:0.8rem;color:#555;background:#111;padding:0.5rem 1rem;border-radius:6px;max-width:480px;margin:1rem auto 0;word-break:break-word">' + __esc(detail) + '</p>'
+        : '';
+    return '<div style="display:flex;align-items:center;justify-content:center;min-height:60vh;text-align:center;padding:2rem">'
+        + '<div>'
+        + '<p style="font-size:5rem;font-weight:700;margin:0;color:#333;line-height:1">' + status + '</p>'
+        + '<p style="font-size:1rem;color:#555;margin:0.5rem 0 0;letter-spacing:0.05em">' + __esc(title) + '</p>'
+        + detailHtml
+        + '</div>'
+        + '</div>';
+}
+function __isSameOrigin(request, url) {
+    const fetchSite = request.headers.get('sec-fetch-site');
+    if (fetchSite && fetchSite !== 'same-origin' && fetchSite !== 'same-site' && fetchSite !== 'none') {
+        return false;
+    }
+    const origin = request.headers.get('origin');
+    if (!origin)
+        return true;
+    try {
+        return new URL(origin).origin === url.origin;
+    }
+    catch {
+        return false;
+    }
+}
+function __secHeaders(response) {
+    for (const [key, value] of Object.entries(__defaultSecHeaders)) {
+        if (!response.headers.has(key))
+            response.headers.set(key, value);
+    }
+    return response;
+}
+function __attachCookies(response) {
+    const cookies = __getLocals().__setCookieHeaders;
+    if (cookies && cookies.length > 0) {
+        const newResponse = new Response(response.body, response);
+        for (const header of cookies)
+            newResponse.headers.append('Set-Cookie', header);
+        return __secHeaders(newResponse);
+    }
+    return __secHeaders(response);
+}
+async function __runRuntimeRequest(runtimeEntries, ctx, next) {
+    let idx = -1;
+    async function dispatch(i) {
+        if (i <= idx)
+            throw new Error('[kuratchi runtime] next() called multiple times in request phase');
+        idx = i;
+        const entry = runtimeEntries[i];
+        if (!entry)
+            return next();
+        const [, step] = entry;
+        if (typeof step.request !== 'function')
+            return dispatch(i + 1);
+        return await step.request(ctx, () => dispatch(i + 1));
+    }
+    return dispatch(0);
+}
+async function __runRuntimeRoute(runtimeEntries, ctx, next) {
+    let idx = -1;
+    async function dispatch(i) {
+        if (i <= idx)
+            throw new Error('[kuratchi runtime] next() called multiple times in route phase');
+        idx = i;
+        const entry = runtimeEntries[i];
+        if (!entry)
+            return next();
+        const [, step] = entry;
+        if (typeof step.route !== 'function')
+            return dispatch(i + 1);
+        return await step.route(ctx, () => dispatch(i + 1));
+    }
+    return dispatch(0);
+}
+async function __runRuntimeResponse(runtimeEntries, ctx, response) {
+    let out = response;
+    for (const [, step] of runtimeEntries) {
+        if (typeof step.response !== 'function')
+            continue;
+        out = await step.response(ctx, out);
+        if (!(out instanceof Response)) {
+            throw new Error('[kuratchi runtime] response handlers must return a Response');
+        }
+    }
+    return out;
+}
+async function __runRuntimeError(runtimeEntries, ctx, error) {
+    for (const [name, step] of runtimeEntries) {
+        if (typeof step.error !== 'function')
+            continue;
+        try {
+            const handled = await step.error(ctx, error);
+            if (handled instanceof Response)
+                return handled;
+        }
+        catch (hookErr) {
+            console.error('[kuratchi runtime] error handler failed in step', name, hookErr);
+        }
+    }
+    return null;
+}
+function __isObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function __normalizeRenderOutput(output) {
+    if (typeof output === 'string') {
+        return { html: output, head: '' };
+    }
+    return {
+        html: typeof output?.html === 'string' ? output.html : '',
+        head: typeof output?.head === 'string' ? output.head : '',
+        fragments: __isObject(output?.fragments) ? output.fragments : {},
+    };
+}
+function __getRuntimeEntries(runtimeDefinition) {
+    return Object.entries(runtimeDefinition ?? {}).filter((entry) => !!entry[1] && typeof entry[1] === 'object');
+}
+function __isDevMode() {
+    return !!globalThis.__kuratchi_DEV__;
+}
+const __defaultSecHeaders = {
+    'X-Content-Type-Options': 'nosniff',
+    'X-Frame-Options': 'DENY',
+    'Referrer-Policy': 'strict-origin-when-cross-origin',
+};
+const __errorMessages = {
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    408: 'Request Timeout',
+    429: 'Too Many Requests',
+    500: 'Internal Server Error',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+};

package/dist/runtime/index.d.ts

@@ -1,10 +1,11 @@
 export { createApp } from './app.js';
+export { createGeneratedWorker } from './generated-worker.js';
 export { defineConfig } from './config.js';
 export { defineRuntime } from './runtime.js';
 export { Router, filePathToPattern } from './router.js';
 export { getCtx, getRequest, getLocals, getParams, getParam, RedirectError, redirect, goto, setBreadcrumbs, getBreadcrumbs, breadcrumbsHome, breadcrumbsPrev, breadcrumbsNext, breadcrumbsCurrent, buildDefaultBreadcrumbs, } from './context.js';
 export { kuratchiDO, doRpc } from './do.js';
 export { extractSubdomainSlug, extractSlugFromPrefix, matchContainerViewPath, rewriteProxyLocationHeader, buildContainerRequest, createContainerEnvVars, startContainer, proxyToContainer, handleContainerRouting, forwardJsonPostToContainerDO, matchSiteViewPath, buildSiteContainerRequest, createWpContainerEnvVars, startSiteContainer, proxyToSiteContainer, } from './containers.js';
-export type { AppConfig, Env, AuthConfig, RouteContext, RouteModule, ApiRouteModule, HttpMethod, LayoutModule, RuntimeContext, RuntimeDefinition, RuntimeStep, RuntimeNext, RuntimeErrorResult, } from './types.js';
+export type { AppConfig, Env, AuthConfig, RouteContext, RouteModule, ApiRouteModule, HttpMethod, LayoutModule, PageRenderOutput, PageRenderResult, RuntimeContext, RuntimeDefinition, RuntimeStep, RuntimeNext, RuntimeErrorResult, } from './types.js';
 export type { RpcOf } from './do.js';
 export { url, pathname, searchParams, headers, method, params, slug } from './request.js';

package/dist/runtime/index.js

@@ -1,4 +1,5 @@
 export { createApp } from './app.js';
+export { createGeneratedWorker } from './generated-worker.js';
 export { defineConfig } from './config.js';
 export { defineRuntime } from './runtime.js';
 export { Router, filePathToPattern } from './router.js';