@zenithbuild/cli 0.7.5 → 0.7.7

package/dist/resource-response.d.ts

@@ -6,6 +6,7 @@ export function buildResourceResponseDescriptor(result: any, basePath?: string,
         'Content-Type'?: undefined;
         'Content-Disposition'?: undefined;
         'Content-Length'?: undefined;
+        Connection?: undefined;
     };
     body: string;
     setCookies: any[];
@@ -17,6 +18,7 @@ export function buildResourceResponseDescriptor(result: any, basePath?: string,
         'Cache-Control'?: undefined;
         'Content-Disposition'?: undefined;
         'Content-Length'?: undefined;
+        Connection?: undefined;
     };
     body: any;
     setCookies: any[];
@@ -28,7 +30,20 @@ export function buildResourceResponseDescriptor(result: any, basePath?: 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

@@ -4,6 +4,67 @@ import { clientFacingRouteMessage, defaultRouteDenyMessage } from './server-erro
 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 {
@@ -33,9 +94,10 @@ export function buildResourceResponseDescriptor(result, basePath = '/', setCooki
             setCookies
         };
     }
-    if (result.kind === 'json') {
+    if (result.kind === 'json' || result.kind === 'invalid') {
+        const status = Number.isInteger(result.status) ? result.status : (result.kind === 'invalid' ? 400 : 200);
         return {
-            status: Number.isInteger(result.status) ? result.status : 200,
+            status,
             headers: { 'Content-Type': 'application/json; charset=utf-8' },
             body: serializeJsonBody(result.data),
             setCookies
@@ -62,6 +124,33 @@ export function buildResourceResponseDescriptor(result, basePath = '/', setCooki
             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' },

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>;

package/dist/server-contract/resolve.js

@@ -0,0 +1,271 @@
+import { STAGED_SET_COOKIES_KEY } from './constants.js';
+import { validateServerExports } from './export-validation.js';
+import { assertJsonSerializable } from './json-serializable.js';
+import { assertValidRouteResultShape, isRouteResultLike } from './route-result-validation.js';
+import { allow, data, text } from './result-helpers.js';
+import { invokeRouteStage } from './stage.js';
+function buildActionState(result) {
+    if (!result || typeof result !== 'object') {
+        return null;
+    }
+    if (result.kind === 'data') {
+        return {
+            ok: true,
+            status: 200,
+            data: result.data
+        };
+    }
+    if (result.kind === 'invalid') {
+        return {
+            ok: false,
+            status: Number.isInteger(result.status) ? result.status : 400,
+            data: result.data
+        };
+    }
+    return null;
+}
+function buildResolvedEnvelope({ result, trace, status, ctx }) {
+    const envelope = { result, trace };
+    if (status !== undefined) {
+        envelope.status = status;
+    }
+    const setCookies = Array.isArray(ctx?.[STAGED_SET_COOKIES_KEY])
+        ? ctx[STAGED_SET_COOKIES_KEY].slice()
+        : [];
+    if (setCookies.length > 0) {
+        envelope.setCookies = setCookies;
+    }
+    return envelope;
+}
+export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = false, routeKind = 'page' }) {
+    validateServerExports({ exports, filePath, routeKind });
+    if (routeKind === 'resource') {
+        return resolveResourceRouteResult({ exports, ctx, filePath, guardOnly });
+    }
+    const trace = {
+        guard: 'none',
+        action: 'none',
+        load: 'none'
+    };
+    let responseStatus = 200;
+    const requestMethod = String(ctx?.method || ctx?.request?.method || 'GET').toUpperCase();
+    const isActionRequest = !guardOnly && requestMethod === 'POST';
+    if (ctx && typeof ctx === 'object') {
+        ctx.action = null;
+    }
+    if ('guard' in exports) {
+        const guardRaw = await invokeRouteStage({
+            fn: exports.guard,
+            ctx,
+            where: `${filePath}: guard(ctx)`,
+            allowedKinds: new Set(['allow', 'redirect', 'deny'])
+        });
+        const guardResult = guardRaw == null ? allow() : guardRaw;
+        if (guardResult.kind === 'data') {
+            throw new Error(`[Zenith] ${filePath}: guard(ctx) returned data(payload) which is a critical invariant violation. guard() can only return allow(), redirect(), or deny(). Use load(ctx) for data injection.`);
+        }
+        assertValidRouteResultShape(guardResult, `${filePath}: guard(ctx) return`, new Set(['allow', 'redirect', 'deny']));
+        trace.guard = guardResult.kind;
+        if (guardResult.kind === 'redirect' || guardResult.kind === 'deny') {
+            return buildResolvedEnvelope({ result: guardResult, trace, ctx });
+        }
+    }
+    if (guardOnly) {
+        return buildResolvedEnvelope({ result: allow(), trace, ctx });
+    }
+    if (isActionRequest && 'action' in exports) {
+        const actionRaw = await invokeRouteStage({
+            fn: exports.action,
+            ctx,
+            where: `${filePath}: action(ctx)`,
+            allowedKinds: new Set(['data', 'invalid', 'redirect', 'deny'])
+        });
+        let actionResult = null;
+        if (isRouteResultLike(actionRaw)) {
+            actionResult = actionRaw;
+            assertValidRouteResultShape(actionResult, `${filePath}: action(ctx) return`, new Set(['data', 'invalid', 'redirect', 'deny']));
+            if (actionResult.kind === 'data' || actionResult.kind === 'invalid') {
+                assertJsonSerializable(actionResult.data, `${filePath}: action(ctx) return`);
+            }
+        }
+        else {
+            assertJsonSerializable(actionRaw, `${filePath}: action(ctx) return`);
+            actionResult = data(actionRaw);
+        }
+        trace.action = actionResult.kind;
+        if (actionResult.kind === 'redirect' || actionResult.kind === 'deny') {
+            return buildResolvedEnvelope({ result: actionResult, trace, ctx });
+        }
+        const actionState = buildActionState(actionResult);
+        if (ctx && typeof ctx === 'object') {
+            ctx.action = actionState;
+        }
+        if (actionState && actionState.ok === false) {
+            responseStatus = actionState.status;
+        }
+    }
+    let payload;
+    if ('load' in exports) {
+        const loadRaw = await invokeRouteStage({
+            fn: exports.load,
+            ctx,
+            where: `${filePath}: load(ctx)`,
+            allowedKinds: new Set(['data', 'redirect', 'deny'])
+        });
+        let loadResult = null;
+        if (isRouteResultLike(loadRaw)) {
+            loadResult = loadRaw;
+            assertValidRouteResultShape(loadResult, `${filePath}: load(ctx) return`, new Set(['data', 'redirect', 'deny']));
+        }
+        else {
+            assertJsonSerializable(loadRaw, `${filePath}: load(ctx) return`);
+            loadResult = data(loadRaw);
+        }
+        trace.load = loadResult.kind;
+        return buildResolvedEnvelope({
+            result: loadResult,
+            trace,
+            status: loadResult.kind === 'data' ? responseStatus : undefined,
+            ctx
+        });
+    }
+    if ('data' in exports) {
+        payload = exports.data;
+        assertJsonSerializable(payload, `${filePath}: data export`);
+        trace.load = 'data';
+        return buildResolvedEnvelope({ result: data(payload), trace, status: responseStatus, ctx });
+    }
+    // legacy fallback
+    if ('ssr_data' in exports) {
+        payload = exports.ssr_data;
+        assertJsonSerializable(payload, `${filePath}: ssr_data export`);
+        trace.load = 'data';
+        return buildResolvedEnvelope({ result: data(payload), trace, status: responseStatus, ctx });
+    }
+    if ('props' in exports) {
+        payload = exports.props;
+        assertJsonSerializable(payload, `${filePath}: props export`);
+        trace.load = 'data';
+        return buildResolvedEnvelope({ result: data(payload), trace, status: responseStatus, ctx });
+    }
+    if ('ssr' in exports) {
+        payload = exports.ssr;
+        assertJsonSerializable(payload, `${filePath}: ssr export`);
+        trace.load = 'data';
+        return buildResolvedEnvelope({ result: data(payload), trace, status: responseStatus, ctx });
+    }
+    if (isActionRequest && ctx?.action) {
+        trace.load = 'data';
+        return buildResolvedEnvelope({
+            result: data({ action: ctx.action }),
+            trace,
+            status: responseStatus,
+            ctx
+        });
+    }
+    return buildResolvedEnvelope({ result: data({}), trace, status: responseStatus, ctx });
+}
+async function resolveResourceRouteResult({ exports, ctx, filePath, guardOnly = false }) {
+    const trace = {
+        guard: 'none',
+        action: 'none',
+        load: 'none'
+    };
+    const requestMethod = String(ctx?.method || ctx?.request?.method || 'GET').toUpperCase();
+    if (ctx && typeof ctx === 'object') {
+        ctx.action = null;
+    }
+    if ('guard' in exports) {
+        const guardRaw = await invokeRouteStage({
+            fn: exports.guard,
+            ctx,
+            where: `${filePath}: guard(ctx)`,
+            allowedKinds: new Set(['allow', 'redirect', 'deny'])
+        });
+        const guardResult = guardRaw == null ? allow() : guardRaw;
+        assertValidRouteResultShape(guardResult, `${filePath}: guard(ctx) return`, new Set(['allow', 'redirect', 'deny']));
+        trace.guard = guardResult.kind;
+        if (guardResult.kind === 'redirect' || guardResult.kind === 'deny') {
+            return buildResolvedEnvelope({ result: guardResult, trace, ctx });
+        }
+    }
+    if (guardOnly) {
+        return buildResolvedEnvelope({ result: allow(), trace, ctx });
+    }
+    if (requestMethod === 'GET' || requestMethod === 'HEAD') {
+        if (!('load' in exports)) {
+            trace.load = 'text';
+            return buildResolvedEnvelope({ result: text('Method Not Allowed', 405), trace, status: 405, ctx });
+        }
+        const loadResult = await resolveResourceStage({
+            exports,
+            exportName: 'load',
+            ctx,
+            filePath,
+            trace,
+            traceKey: 'load'
+        });
+        return buildResolvedEnvelope({
+            result: loadResult,
+            trace,
+            status: loadResult.status,
+            ctx
+        });
+    }
+    if (requestMethod === 'POST') {
+        if (!('action' in exports)) {
+            trace.action = 'text';
+            return buildResolvedEnvelope({ result: text('Method Not Allowed', 405), trace, status: 405, ctx });
+        }
+        const actionResult = await resolveResourceStage({
+            exports,
+            exportName: 'action',
+            ctx,
+            filePath,
+            trace,
+            traceKey: 'action'
+        });
+        return buildResolvedEnvelope({
+            result: actionResult,
+            trace,
+            status: actionResult.status,
+            ctx
+        });
+    }
+    return buildResolvedEnvelope({
+        result: text('Method Not Allowed', 405),
+        trace,
+        status: 405,
+        ctx
+    });
+}
+async function resolveResourceStage({ exports, exportName, ctx, filePath, trace, traceKey }) {
+    const raw = await invokeRouteStage({
+        fn: exports[exportName],
+        ctx,
+        where: `${filePath}: ${exportName}(ctx)`,
+        allowedKinds: new Set(['json', 'text', 'download', 'redirect', 'deny', 'invalid', 'stream', 'sse'])
+    });
+    if (!isRouteResultLike(raw)) {
+        throw new Error(`[Zenith] ${filePath}: ${exportName}(ctx) on a resource route must return json(...), text(...), download(...), redirect(...), deny(...), invalid(...), stream(...), or sse(...).`);
+    }
+    assertValidRouteResultShape(raw, `${filePath}: ${exportName}(ctx) return`, new Set(['json', 'text', 'download', 'redirect', 'deny', 'invalid', 'stream', 'sse']));
+    if (raw.kind === 'json' || raw.kind === 'invalid') {
+        assertJsonSerializable(raw.data, `${filePath}: ${exportName}(ctx) return`);
+    }
+    trace[traceKey] = raw.kind;
+    return raw;
+}
+export async function resolveServerPayload({ exports, ctx, filePath }) {
+    const resolved = await resolveRouteResult({ exports, ctx, filePath });
+    if (!resolved || !resolved.result || typeof resolved.result !== 'object') {
+        return {};
+    }
+    if (resolved.result.kind === 'data') {
+        return resolved.result.data;
+    }
+    if (resolved.result.kind === 'allow') {
+        return {};
+    }
+    throw new Error(`[Zenith] ${filePath}: resolveServerPayload() expected data but received ${resolved.result.kind}. Use resolveRouteResult() for guard/load flows.`);
+}

package/dist/server-contract/result-helpers.d.ts

@@ -0,0 +1,51 @@
+export function allow(): {
+    kind: string;
+};
+export function redirect(location: any, status?: number): {
+    kind: string;
+    location: string;
+    status: number;
+};
+export function deny(status?: number, message?: undefined): {
+    kind: string;
+    status: number;
+    message: undefined;
+};
+export function data(payload: any): {
+    kind: string;
+    data: any;
+};
+export function invalid(payload: any, status?: number): {
+    kind: string;
+    data: any;
+    status: number;
+};
+export function json(payload: any, status?: number): {
+    kind: string;
+    data: any;
+    status: number;
+};
+export function text(body: any, status?: number): {
+    kind: string;
+    body: string;
+    status: number;
+};
+export function download(body: any, options?: {}): {
+    kind: string;
+    body: any;
+    bodyEncoding: string;
+    bodySize: number;
+    filename: string;
+    contentType: string;
+    status: number;
+};
+export function stream(body: any, options?: {}): {
+    kind: string;
+    body: any;
+    status: any;
+    contentType: any;
+};
+export function sse(events: any): {
+    kind: string;
+    events: any;
+};

package/dist/server-contract/result-helpers.js

@@ -0,0 +1,59 @@
+import { createDownloadResult } from '../download-result.js';
+export function allow() {
+    return { kind: 'allow' };
+}
+export function redirect(location, status = 302) {
+    return {
+        kind: 'redirect',
+        location: String(location || ''),
+        status: Number.isInteger(status) ? status : 302
+    };
+}
+export function deny(status = 403, message = undefined) {
+    return {
+        kind: 'deny',
+        status: Number.isInteger(status) ? status : 403,
+        message: typeof message === 'string' ? message : undefined
+    };
+}
+export function data(payload) {
+    return { kind: 'data', data: payload };
+}
+export function invalid(payload, status = 400) {
+    return {
+        kind: 'invalid',
+        data: payload,
+        status: Number.isInteger(status) ? status : 400
+    };
+}
+export function json(payload, status = 200) {
+    return {
+        kind: 'json',
+        data: payload,
+        status: Number.isInteger(status) ? status : 200
+    };
+}
+export function text(body, status = 200) {
+    return {
+        kind: 'text',
+        body: typeof body === 'string' ? body : String(body ?? ''),
+        status: Number.isInteger(status) ? status : 200
+    };
+}
+export function download(body, options = {}) {
+    return createDownloadResult(body, options);
+}
+export function stream(body, options = {}) {
+    return {
+        kind: 'stream',
+        body,
+        status: options?.status,
+        contentType: options?.contentType
+    };
+}
+export function sse(events) {
+    return {
+        kind: 'sse',
+        events
+    };
+}