zitejs 0.9.142 → 0.9.143

package/dist/esm/start/instance.d.ts

@@ -1,12 +0,0 @@
-import { type AnySerializationAdapter } from "@tanstack/react-router";
-import type { SSROption } from "@tanstack/router-core";
-import type { AnyFunctionMiddleware, AnyRequestMiddleware, StartInstance } from "@tanstack/start-client-core";
-import { ZiteError } from "./index.js";
-/**
- * The start instance every Start app builds with: the platform's middleware and
- * adapters first, then whatever the app's own `src/start.ts` sets.
- */
-export declare function createZiteStart<const TAdapters extends ReadonlyArray<AnySerializationAdapter> = [], TDefaultSsr extends SSROption = SSROption, const TRequest extends ReadonlyArray<AnyRequestMiddleware> = [], const TFunction extends ReadonlyArray<AnyFunctionMiddleware> = []>(app?: StartInstance<TAdapters, TDefaultSsr, TRequest, TFunction>): StartInstance<readonly [import("@tanstack/react-router").SerializationAdapter<ZiteError, {
-    code: "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "INVALID_INPUT";
-    message: string;
-}, never>, ...TAdapters], TDefaultSsr, readonly [import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>, ...TRequest], readonly [import("@tanstack/react-start").FunctionMiddlewareAfterClient<{}, unknown, undefined, undefined, undefined>, import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, undefined, undefined, undefined>, ...TFunction]>;

package/dist/esm/start/instance.js

@@ -1,73 +0,0 @@
-// For the generated `.zite/start.ts` only. Apps put their own options in
-// `src/start.ts`, which the generated instance composes after the platform's.
-import { createCsrfMiddleware, createMiddleware, createStart } from "@tanstack/react-start";
-import { createSerializationAdapter, redirect } from "@tanstack/react-router";
-import { isSignInRequired, loginHref, ZiteError } from "./index.js";
-import { errorOf, preview } from "./runLog.js";
-import { getHost, inScope } from "./scope.js";
-// TanStack drops its default CSRF check once an app has a start instance.
-const csrf = createCsrfMiddleware({ filter: (ctx) => ctx.handlerType === "serverFn" });
-// The host answers a signed-out call with a plain 401, the app with a ZiteError;
-// either way the browser goes to sign in rather than showing an error.
-const signInOn401 = createMiddleware({ type: "function" }).client(async ({ next }) => {
-    try {
-        return await next();
-    }
-    catch (error) {
-        if (!isSignInRequired(error))
-            throw error;
-        const href = loginHref();
-        if (typeof window !== "undefined")
-            window.location.assign(href);
-        throw redirect({ href, reloadDocument: true });
-    }
-});
-// Records each call for the run log. The host's own record of the request is the
-// floor; this adds what only the app sees: decoded input, output and errors.
-const runCapture = createMiddleware({ type: "function" }).server(async ({ next, data, serverFnMeta }) => {
-    const runs = getHost()?.runs;
-    const startedAt = Date.now();
-    const record = (outcome) => runs?.push({
-        fn: serverFnMeta.id,
-        name: serverFnMeta.name,
-        nested: inScope(),
-        startedAt,
-        durationMs: Date.now() - startedAt,
-        input: preview(data),
-        ...("error" in outcome ? { error: errorOf(outcome.error) } : { output: preview(outcome.output) }),
-    });
-    try {
-        const out = await next();
-        const failed = out.error;
-        record(failed === undefined ? { output: out.result } : { error: failed });
-        return out;
-    }
-    catch (error) {
-        record({ error });
-        throw error;
-    }
-});
-/** Carries a ZiteError to the browser as itself, so `instanceof ZiteError` and `.code` work there. */
-const ziteErrorAdapter = createSerializationAdapter({
-    key: "zite-error",
-    test: (value) => value instanceof ZiteError,
-    toSerializable: (error) => ({ code: error.code, message: error.message }),
-    fromSerializable: ({ code, message }) => new ZiteError(code, message),
-});
-/**
- * The start instance every Start app builds with: the platform's middleware and
- * adapters first, then whatever the app's own `src/start.ts` sets.
- */
-export function createZiteStart(app) {
-    return createStart(async () => {
-        const own = app ? await app.getOptions() : undefined;
-        // Spreading the app's optional arrays loses their tuple types, which the
-        // route tree registers for typed context and serialization.
-        return {
-            ...own,
-            requestMiddleware: [csrf, ...(own?.requestMiddleware ?? [])],
-            functionMiddleware: [signInOn401, runCapture, ...(own?.functionMiddleware ?? [])],
-            serializationAdapters: [ziteErrorAdapter, ...(own?.serializationAdapters ?? [])],
-        };
-    });
-}

package/dist/esm/start/problems.d.ts

@@ -1,19 +0,0 @@
-type WithProblems = {
-    problems: string[];
-};
-type Described = {
-    functions: Array<WithProblems & {
-        id: string;
-        file?: string;
-    }>;
-    routes: Array<WithProblems & {
-        path: string;
-    }>;
-    workflows?: Array<WithProblems & {
-        id: string;
-        file: string;
-    }>;
-};
-/** Every problem in a description, one line each, named by its rule. Any of them fails the build. */
-export declare function descriptionProblems(description: Described): string[];
-export {};

package/dist/esm/start/problems.js

@@ -1,8 +0,0 @@
-/** Every problem in a description, one line each, named by its rule. Any of them fails the build. */
-export function descriptionProblems(description) {
-    return [
-        ...description.functions.flatMap((f) => f.problems.map((p) => `function ${f.id}${f.file ? ` (${f.file})` : ""}: ${p}`)),
-        ...description.routes.flatMap((r) => r.problems.map((p) => `route ${r.path}: ${p}`)),
-        ...(description.workflows ?? []).flatMap((w) => w.problems.map((p) => `workflow ${w.id} (${w.file}): ${p}`)),
-    ];
-}

package/dist/esm/start/registration.d.ts

@@ -1,13 +0,0 @@
-import type { LoadedWorkflow } from "./workflowRun.js";
-export type RegistrationResult = {
-    ok: true;
-    output: unknown;
-} | {
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-};
-/** Undefined when the workflow has no such function. */
-export declare function runRegistration(workflows: LoadedWorkflow[], name: string, op: unknown, input: unknown): Promise<RegistrationResult | undefined>;

package/dist/esm/start/registration.js

@@ -1,21 +0,0 @@
-// Server-only: a provider trigger's `subscribe` or `unsubscribe`, which the host
-// runs at publish. Not a run: nothing is logged, since what `subscribe` returns
-// carries the provider's signing secret.
-import { errorOf } from "./runLog.js";
-import { runInScope } from "./scope.js";
-/** Undefined when the workflow has no such function. */
-export async function runRegistration(workflows, name, op, input) {
-    const trigger = workflows.find((w) => w.id === name)?.workflow.config.trigger;
-    if (!trigger || !("subscribe" in trigger))
-        return undefined;
-    const fn = op === "subscribe" ? trigger.subscribe : op === "unsubscribe" ? trigger.unsubscribe : undefined;
-    if (typeof fn !== "function")
-        return undefined;
-    try {
-        const output = await runInScope({ kind: "workflow", user: null }, () => fn(input));
-        return { ok: true, output: output ?? null };
-    }
-    catch (error) {
-        return { ok: false, error: errorOf(error) };
-    }
-}

package/dist/esm/start/router.d.ts

@@ -1,17 +0,0 @@
-import { type AnyRoute, type RouterConstructorOptions, type RouterHistory } from "@tanstack/react-router";
-import type { User } from "./types.js";
-/** The router context every Zite app's root route declares: `createRootRouteWithContext<ZiteRouterContext>()`. */
-export type ZiteRouterContext = {
-    user: User | null;
-};
-type Dehydrated = {
-    user: User | null;
-};
-type ZiteRouterOptions<TRouteTree extends AnyRoute> = Omit<RouterConstructorOptions<TRouteTree, "never", false, RouterHistory, Dehydrated>, "context" | "dehydrate" | "hydrate">;
-/**
- * The router for `src/router.tsx`. The signed-in user is in `context.user`: on
- * the server from the platform, in the browser from the page it rendered, so
- * no request asks for it again.
- */
-export declare function createZiteRouter<TRouteTree extends AnyRoute>(options: ZiteRouterOptions<TRouteTree>): import("@tanstack/router-core").RouterCore<TRouteTree, "never", false, RouterHistory, Dehydrated>;
-export {};

package/dist/esm/start/router.js

@@ -1,37 +0,0 @@
-import { createElement as h } from "react";
-import { createRouter, Link, useRouter, } from "@tanstack/react-router";
-import { currentHost } from "./host.js";
-const box = { maxWidth: 480, margin: "15vh auto", padding: 24, fontFamily: "system-ui, sans-serif", textAlign: "center" };
-function ZiteErrorComponent({ error }) {
-    const router = useRouter();
-    const message = error instanceof Error && error.name === "ZiteError" ? error.message : "Something went wrong.";
-    return h("div", { role: "alert", style: box }, h("p", { style: { fontWeight: 600 } }, message), h("button", { type: "button", onClick: () => router.invalidate() }, "Try again"));
-}
-function ZiteNotFound() {
-    return h("div", { style: box }, h("p", { style: { fontWeight: 600 } }, "Page not found"), h(Link, { to: "/" }, "Go home"));
-}
-/**
- * The router for `src/router.tsx`. The signed-in user is in `context.user`: on
- * the server from the platform, in the browser from the page it rendered, so
- * no request asks for it again.
- */
-export function createZiteRouter(options) {
-    const context = { user: currentHost()?.user ?? null };
-    const router = createRouter({
-        defaultPreload: "intent",
-        defaultPreloadStaleTime: 0,
-        scrollRestoration: true,
-        defaultErrorComponent: ZiteErrorComponent,
-        defaultNotFoundComponent: ZiteNotFound,
-        ...options,
-        context,
-        dehydrate: () => ({ user: context.user }),
-        hydrate: (dehydrated) => {
-            context.user = dehydrated.user;
-        },
-    });
-    const host = currentHost();
-    if (host)
-        host.router = router;
-    return router;
-}

package/dist/esm/start/runLog.d.ts

@@ -1,5 +0,0 @@
-export declare const preview: (value: unknown) => string | undefined;
-export declare const errorOf: (error: unknown) => {
-    code: string;
-    message: string;
-};

package/dist/esm/start/runLog.js

@@ -1,18 +0,0 @@
-import { ZiteError } from "./index.js";
-const PREVIEW_LIMIT = 8_000;
-export const preview = (value) => {
-    if (value === undefined)
-        return undefined;
-    if (typeof value === "object" && value !== null && Symbol.asyncIterator in value)
-        return "[stream]";
-    try {
-        const json = JSON.stringify(value);
-        return json && json.length > PREVIEW_LIMIT ? `${json.slice(0, PREVIEW_LIMIT)}…` : json;
-    }
-    catch {
-        return "[unserializable]";
-    }
-};
-export const errorOf = (error) => error instanceof ZiteError
-    ? { code: error.code, message: error.message }
-    : { code: "INTERNAL_ERROR", message: error instanceof Error ? error.message : String(error) };

package/dist/esm/start/scope.d.ts

@@ -1,15 +0,0 @@
-import type { AccessKind, User, ZiteRequestContext } from "./types.js";
-export type { AccessKind } from "./types.js";
-export type AccessScope = {
-    kind: AccessKind;
-    user: User | null;
-};
-export declare const runInScope: <T>(scope: AccessScope, fn: () => T) => T;
-/** True inside another server function's scope, i.e. a nested server-side call. */
-export declare const inScope: () => boolean;
-export declare class NoAccessDecisionError extends Error {
-    constructor(what: string);
-}
-export declare const requireScope: (what: string) => AccessScope;
-export declare const runWithHost: <T>(host: ZiteRequestContext, fn: () => T) => T;
-export declare const getHost: () => ZiteRequestContext | undefined;

package/dist/esm/start/scope.js

@@ -1,58 +0,0 @@
-// Server-only. Only zitejs's access middleware opens an access scope, and the
-// platform transport refuses calls outside one, so code with no access decision
-// can't reach data, integrations or email however it was written.
-import { AsyncLocalStorage } from "node:async_hooks";
-import { HOST_STORE_KEY } from "./host.js";
-// Keyed on globalThis so two copies of zitejs in one bundle share the stores.
-const stores = globalThis;
-const scopeStorage = (stores[Symbol.for("zitejs:access-scope")] ??=
-    new AsyncLocalStorage());
-const hostStorage = (stores[HOST_STORE_KEY] ??=
-    new AsyncLocalStorage());
-const isAsyncIterable = (value) => typeof value === "object" &&
-    value !== null &&
-    Symbol.asyncIterator in value &&
-    !(value instanceof ReadableStream);
-// TanStack resumes a streamed async generator from its serializer, outside the
-// middleware's async context, so each step re-enters the scope it started in.
-const rescope = (scope, source) => (async function* () {
-    const iterator = source[Symbol.asyncIterator]();
-    try {
-        while (true) {
-            const step = await scopeStorage.run(scope, () => iterator.next());
-            if (step.done)
-                return step.value;
-            yield step.value;
-        }
-    }
-    finally {
-        await scopeStorage.run(scope, async () => iterator.return?.());
-    }
-})();
-const rescopeResult = (scope, out) => {
-    const result = out?.result;
-    return isAsyncIterable(result) ? { ...out, result: rescope(scope, result) } : out;
-};
-export const runInScope = (scope, fn) => {
-    const out = scopeStorage.run(scope, fn);
-    return (out instanceof Promise
-        ? out.then((value) => rescopeResult(scope, value))
-        : rescopeResult(scope, out));
-};
-/** True inside another server function's scope, i.e. a nested server-side call. */
-export const inScope = () => scopeStorage.getStore() !== undefined;
-export class NoAccessDecisionError extends Error {
-    constructor(what) {
-        super(`${what} ran outside an access decision. Define server functions with signedInFn or publicFn, ` +
-            "and give server routes signedIn, anyone or webhook middleware. Loaders get data by calling a server function.");
-        this.name = "NoAccessDecisionError";
-    }
-}
-export const requireScope = (what) => {
-    const scope = scopeStorage.getStore();
-    if (!scope)
-        throw new NoAccessDecisionError(what);
-    return scope;
-};
-export const runWithHost = (host, fn) => hostStorage.run(host, fn);
-export const getHost = () => hostStorage.getStore();

package/dist/esm/start/server.d.ts

@@ -1,51 +0,0 @@
-import type { HostProps, PlatformBinding, RenderWatch, ZiteRequestContext } from "./types.js";
-export { runWithHost } from "./scope.js";
-export { describeApp } from "./describe.js";
-export type { HostProps, PlatformBinding, PlatformCallInput, PlatformCallResult, PlatformSession, RenderWatch, RunRecord } from "./types.js";
-/**
- * Routes every zitejs data, integration and email call to this request's
- * platform, on one session, and only inside an access scope. The access kind
- * travels with the call so the platform can record what a page read and narrow
- * anonymous reads.
- */
-export declare function installPlatformTransport(): void;
-/** What the host dispatched this request with. Headers are ignored: props are the only thing it alone can set. */
-export declare function hostContextFromProps(request: Request, props: HostProps): ZiteRequestContext;
-/**
- * A request the host didn't dispatch: `zitejs describe` under `vite preview`,
- * and tests, which pass their own platform. Deployed builds have no public URL,
- * so in production every request carries props.
- */
-export declare function hostContextFromRequest(request: Request, platform?: PlatformBinding): ZiteRequestContext;
-/** Every server function TanStack compiled, written in by `zite()` at build. Empty in dev, where TanStack doesn't call its id hook. */
-export declare const builtFunctionIds: () => string[];
-/** Each server function's `description` option, written in by `zite()` at build. */
-export declare const builtFunctionDescriptions: () => Record<string, string>;
-type Fetch = (request: Request, ...rest: unknown[]) => Promise<Response> | Response;
-type WorkerContext = {
-    waitUntil(promise: Promise<unknown>): void;
-};
-export type ZiteServerOptions = {
-    handler: {
-        fetch: Fetch;
-    };
-    getRouter: () => unknown;
-    platform?: PlatformBinding;
-};
-type HostedContext = WorkerContext & {
-    props?: Partial<HostProps>;
-};
-export type ZiteHandlers = {
-    fetch: Fetch;
-    /** A page the host may cache: as `fetch`, with every read and outbound fetch reported to `watch`. */
-    render(request: Request, ctx: HostedContext, watch: RenderWatch): Promise<Response>;
-};
-/**
- * The handlers of a Start app's server entry. A request the host dispatched
- * carries its identity and platform in props; anything else (describe under
- * `vite preview`, tests) reads `x-zite-*` headers and uses `platform` if one
- * is given.
- */
-export declare function createZiteHandlers(options: ZiteServerOptions): ZiteHandlers;
-/** The fetch handler alone, for entries that take no RPC. */
-export declare function createZiteFetch(options: ZiteServerOptions): Fetch;

package/dist/esm/start/server.js

@@ -1,215 +0,0 @@
-import { ZiteError, ZITE_ERROR_STATUS } from "./index.js";
-import { describeApp } from "./describe.js";
-import { runRegistration } from "./registration.js";
-import { preview } from "./runLog.js";
-import { getHost, requireScope, runWithHost } from "./scope.js";
-import { loadWorkflows, loggedInput, runWorkflow } from "./workflowRun.js";
-export { runWithHost } from "./scope.js";
-export { describeApp } from "./describe.js";
-/**
- * Routes every zitejs data, integration and email call to this request's
- * platform, on one session, and only inside an access scope. The access kind
- * travels with the call so the platform can record what a page read and narrow
- * anonymous reads.
- */
-export function installPlatformTransport() {
-    const sdkCall = async (integrationId, className, methodName, params) => {
-        const scope = requireScope(`${className}.${methodName}`);
-        const host = getHost();
-        // Fails closed: no platform means no platform access, never a fallback.
-        if (!host?.platform)
-            throw new Error("The Zite platform binding is missing");
-        host.session ??= Promise.resolve(host.watch ? host.platform.session(host.watch) : host.platform.session());
-        const result = await (await host.session).call({ integrationId, className, methodName, params, access: scope.kind });
-        if ("value" in result)
-            return result.value;
-        const { code, message } = result.error;
-        throw new ZiteError(code in ZITE_ERROR_STATUS ? code : "INTERNAL_ERROR", message);
-    };
-    globalThis.__wrapSdkCall = sdkCall;
-    watchOutboundFetches();
-}
-let fetchesWatched = false;
-const fetchedHost = (input) => {
-    try {
-        return new URL(input instanceof Request ? input.url : input).host;
-    }
-    catch {
-        return "?";
-    }
-};
-// A page that fetched depends on more than the reads the host saw, so the host
-// must hear of it before the fetch goes out. Next patches fetch for the same reason.
-const watchOutboundFetches = () => {
-    if (fetchesWatched)
-        return;
-    fetchesWatched = true;
-    const nativeFetch = globalThis.fetch.bind(globalThis);
-    globalThis.fetch = async (input, init) => {
-        const watch = getHost()?.watch;
-        if (watch)
-            await watch.uncacheable(`fetch ${fetchedHost(input)}`);
-        return nativeFetch(input, init);
-    };
-};
-const decodeUser = (value) => JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
-const INVOKE_KINDS = new Set(["webhook", "describe", "workflow", "register", "warm"]);
-/** What the host dispatched this request with. Headers are ignored: props are the only thing it alone can set. */
-export function hostContextFromProps(request, props) {
-    return {
-        requestId: props.requestId,
-        url: request.url,
-        user: props.user,
-        mode: props.mode,
-        invoke: props.invoke,
-        runs: [],
-        platform: props.platform,
-    };
-}
-/**
- * A request the host didn't dispatch: `zitejs describe` under `vite preview`,
- * and tests, which pass their own platform. Deployed builds have no public URL,
- * so in production every request carries props.
- */
-export function hostContextFromRequest(request, platform) {
-    const { headers } = request;
-    const user = headers.get("x-zite-user");
-    const [kind, name = ""] = headers.get("x-zite-invoke")?.split(":") ?? [];
-    return {
-        requestId: headers.get("x-zite-request-id") ?? crypto.randomUUID(),
-        url: request.url,
-        user: user ? decodeUser(user) : null,
-        mode: "live",
-        invoke: INVOKE_KINDS.has(kind) ? { kind: kind, name } : null,
-        runs: [],
-        platform,
-    };
-}
-/** Every server function TanStack compiled, written in by `zite()` at build. Empty in dev, where TanStack doesn't call its id hook. */
-export const builtFunctionIds = () => "__ZITE_FN_IDS__".split(",").filter((id) => id && !id.startsWith("__ZITE"));
-const parseDescriptions = (json) => {
-    try {
-        return JSON.parse(json);
-    }
-    catch {
-        return {};
-    }
-};
-/** Each server function's `description` option, written in by `zite()` at build. */
-export const builtFunctionDescriptions = () => parseDescriptions("__ZITE_FN_DESCRIPTIONS__");
-// Server functions also run while a streamed page renders, so the run log is
-// complete only once the body has been read to the end.
-const onBodyEnd = (response, done) => {
-    if (!response.body) {
-        done();
-        return response;
-    }
-    return new Response(response.body.pipeThrough(new TransformStream({ flush: done })), response);
-};
-const INVOKE_PATH = "/_zite/invoke";
-// The host sends `{ input }`; a platform-fired run's input carries the runner's
-// `__cron`, `__poll` or `__webhook` state, exactly as for classic endpoints.
-async function invokeWorkflow(request, host, workflows) {
-    if (request.method !== "POST" || new URL(request.url).pathname !== INVOKE_PATH)
-        return new Response("Not found", { status: 404 });
-    const name = host.invoke?.name;
-    const found = workflows.find((w) => w.id === name);
-    if (!found)
-        return Response.json({ ok: false, error: { code: "NOT_FOUND", message: `No workflow named ${name}` } }, { status: 404 });
-    const input = (await request.json().catch(() => ({})))?.input;
-    const startedAt = Date.now();
-    const result = await runWorkflow(found.workflow, input);
-    host.runs.push({
-        fn: `workflow:${found.id}`,
-        name: found.id,
-        nested: false,
-        startedAt,
-        durationMs: Date.now() - startedAt,
-        input: preview(loggedInput(input)),
-        ...(result.ok ? { output: preview(result.output) } : { error: result.error }),
-    });
-    return Response.json(result, { status: result.ok ? 200 : 500 });
-}
-// The host sends `{ op, input }`: `subscribe` with the platform's notification
-// URL and secret, or `unsubscribe` with what `subscribe` returned.
-async function invokeRegistration(request, host, workflows) {
-    if (request.method !== "POST" || new URL(request.url).pathname !== INVOKE_PATH)
-        return new Response("Not found", { status: 404 });
-    const name = host.invoke?.name ?? "";
-    const body = (await request.json().catch(() => null));
-    const result = await runRegistration(workflows, name, body?.op, body?.input);
-    if (!result) {
-        return Response.json({ ok: false, error: { code: "NOT_FOUND", message: `${name} has no ${String(body?.op)}` } }, { status: 404 });
-    }
-    return Response.json(result, { status: result.ok ? 200 : 500 });
-}
-const isZiteError = (error) => error instanceof Error && error.name === "ZiteError" && error.code in ZITE_ERROR_STATUS;
-// TanStack renders any loader error as a 500. A page refused with a ZiteError
-// (a missing role, a record that isn't there) answers with that error's status.
-const pageStatus = (host) => {
-    const matches = host.router?.state?.matches;
-    const failed = matches?.find((match) => match.status === "error")?.error;
-    return isZiteError(failed) ? ZITE_ERROR_STATUS[failed.code] : undefined;
-};
-/**
- * The handlers of a Start app's server entry. A request the host dispatched
- * carries its identity and platform in props; anything else (describe under
- * `vite preview`, tests) reads `x-zite-*` headers and uses `platform` if one
- * is given.
- */
-export function createZiteHandlers(options) {
-    installPlatformTransport();
-    // Loaded on first use, so a page request never pays for importing workflow modules.
-    let workflows;
-    const loadedWorkflows = () => (workflows ??= loadWorkflows());
-    const serve = async (request, ctx, watch) => {
-        const host = ctx?.props?.platform
-            ? hostContextFromProps(request, ctx.props)
-            : hostContextFromRequest(request, options.platform);
-        if (watch)
-            host.watch = watch;
-        // Starting this isolate was the point: the platform warms a build before its
-        // first visitors, and no app code runs.
-        if (host.invoke?.kind === "warm")
-            return new Response(null, { status: 204 });
-        if (host.invoke?.kind === "describe") {
-            return Response.json(await describeApp({
-                fnIds: builtFunctionIds(),
-                descriptions: builtFunctionDescriptions(),
-                getRouter: options.getRouter,
-                request,
-                workflows: await loadedWorkflows(),
-            }));
-        }
-        let response = await runWithHost(host, async () => host.invoke?.kind === "workflow"
-            ? invokeWorkflow(request, host, await loadedWorkflows())
-            : host.invoke?.kind === "register"
-                ? invokeRegistration(request, host, await loadedWorkflows())
-                : options.handler.fetch(request));
-        const status = response.status === 500 ? pageStatus(host) : undefined;
-        if (status)
-            response = new Response(response.body, { status, headers: response.headers });
-        return onBodyEnd(response, () => {
-            const { platform } = host;
-            if (!host.runs.length || !platform)
-                return;
-            const batch = { runs: host.runs };
-            // On the request's session when it has one: one call, not another binding round trip.
-            const flushed = (async () => {
-                const session = host.session ? await host.session : undefined;
-                await (session?.runs ? session.runs(batch) : platform.runs(batch));
-            })().catch((error) => {
-                console.error("[zite] couldn't record runs", error);
-            });
-            ctx?.waitUntil(flushed);
-        });
-    };
-    return {
-        fetch: (request, ...rest) => serve(request, rest[1]),
-        render: (request, ctx, watch) => serve(request, ctx, watch),
-    };
-}
-/** The fetch handler alone, for entries that take no RPC. */
-export function createZiteFetch(options) {
-    return createZiteHandlers(options).fetch;
-}