zitejs 0.9.140 → 0.9.142

package/dist/esm/start/descriptions.js

@@ -0,0 +1,47 @@
+const stringValue = (node) => {
+    if (node?.type === "Literal" && typeof node.value === "string")
+        return node.value;
+    const quasis = node?.quasis;
+    if (node?.type === "TemplateLiteral" && node.expressions.length === 0)
+        return quasis?.[0]?.value.cooked;
+    return undefined;
+};
+const descriptionProperty = (node) => {
+    for (const property of node.properties) {
+        const key = property.key;
+        const named = key?.type === "Identifier" ? key.name : key?.type === "Literal" ? key.value : undefined;
+        if (property.type === "Property" && named === "description")
+            return stringValue(property.value);
+    }
+    return undefined;
+};
+// Walks a builder chain, `signedInFn({ description }).validator(…).handler(…)`, to an object option.
+const descriptionIn = (node) => {
+    if (node?.type === "CallExpression") {
+        for (const arg of node.arguments) {
+            const found = arg.type === "ObjectExpression" ? descriptionProperty(arg) : undefined;
+            if (found !== undefined)
+                return found;
+        }
+        return descriptionIn(node.callee);
+    }
+    if (node?.type === "MemberExpression")
+        return descriptionIn(node.object);
+    return undefined;
+};
+/** `name -> description` for each top-level const built with a description option. */
+export function factoryDescriptions(program) {
+    const found = new Map();
+    for (const statement of program.body) {
+        const declaration = (statement.type === "ExportNamedDeclaration" ? statement.declaration : statement);
+        if (declaration?.type !== "VariableDeclaration")
+            continue;
+        for (const declarator of declaration.declarations) {
+            const id = declarator.id;
+            const description = descriptionIn(declarator.init);
+            if (id.type === "Identifier" && description)
+                found.set(id.name, description);
+        }
+    }
+    return found;
+}

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

@@ -0,0 +1,20 @@
+import type { SourceDir } from "../sourceRoots.js";
+export declare const START_SERVER_ENTRY = ".zite/server.ts";
+export declare const START_INSTANCE_ENTRY = ".zite/start.ts";
+export type StartTarget = "cloudflare" | "node";
+/**
+ * The server entry every Start app builds with. Platform-owned: regenerated,
+ * never edited. On Workers it's an entrypoint the host can also call over RPC.
+ */
+export declare const renderStartServerEntry: (target?: StartTarget) => string;
+/** The start instance: the platform's middleware, then the app's own `src/start.ts` when it has one. */
+export declare const renderStartInstance: (hasAppStart: boolean) => string;
+export declare const hasAppStart: (appDir: string) => boolean;
+/** Writes `file` under `appDir` when its content differs. Returns whether it wrote. */
+export declare const writeIfChanged: (appDir: string, file: string, content: string) => boolean;
+export declare const isStartAppDir: (appPath: string) => boolean;
+export declare function regenerateStartEntries(app: SourceDir): void;
+/** App modules that mention createWorkflow: what the workflow registry imports. Describe decides what each one really exports. */
+export declare function workflowFiles(appDir: string): string[];
+/** The registry zite() builds in place of zitejs's empty one. */
+export declare const renderWorkflowModules: (appDir: string, files: string[]) => string;

package/dist/esm/start/entries.js

@@ -0,0 +1,93 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+export const START_SERVER_ENTRY = ".zite/server.ts";
+export const START_INSTANCE_ENTRY = ".zite/start.ts";
+const APP_START_FILES = ["src/start.ts", "src/start.tsx"];
+/**
+ * The server entry every Start app builds with. Platform-owned: regenerated,
+ * never edited. On Workers it's an entrypoint the host can also call over RPC.
+ */
+export const renderStartServerEntry = (target = "cloudflare") => target === "cloudflare"
+    ? `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+import handler from '@tanstack/react-start/server-entry';
+import { createZiteWorker } from 'zitejs/start/worker';
+import { getRouter } from '../src/router';
+
+export default createZiteWorker({ handler, getRouter });
+`
+    : `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+import handler, { createServerEntry } from '@tanstack/react-start/server-entry';
+import { createZiteFetch } from 'zitejs/start/server';
+import { getRouter } from '../src/router';
+
+export default createServerEntry({ fetch: createZiteFetch({ handler, getRouter }) });
+`;
+/** The start instance: the platform's middleware, then the app's own `src/start.ts` when it has one. */
+export const renderStartInstance = (hasAppStart) => hasAppStart
+    ? `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+import { createZiteStart } from 'zitejs/start/instance';
+import { startInstance as app } from '../src/start';
+
+export const startInstance = createZiteStart(app);
+`
+    : `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+import { createZiteStart } from 'zitejs/start/instance';
+
+export const startInstance = createZiteStart();
+`;
+export const hasAppStart = (appDir) => APP_START_FILES.some((file) => existsSync(join(appDir, file)));
+/** Writes `file` under `appDir` when its content differs. Returns whether it wrote. */
+export const writeIfChanged = (appDir, file, content) => {
+    const target = join(appDir, file);
+    if (existsSync(target) && readFileSync(target, "utf-8") === content)
+        return false;
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, content);
+    return true;
+};
+export const isStartAppDir = (appPath) => {
+    try {
+        return JSON.parse(readFileSync(join(appPath, "zite.config.json"), "utf-8"))?.runtime === "start";
+    }
+    catch {
+        return false;
+    }
+};
+const isStartApp = (app) => isStartAppDir(app.path);
+export function regenerateStartEntries(app) {
+    if (!isStartApp(app))
+        return;
+    const entries = [
+        [START_SERVER_ENTRY, renderStartServerEntry()],
+        [START_INSTANCE_ENTRY, renderStartInstance(hasAppStart(app.path))],
+    ];
+    for (const [file, content] of entries) {
+        if (writeIfChanged(app.path, file, content))
+            console.log(`Wrote ${join(app.path, file)}`);
+    }
+}
+const SOURCE_FILE = /\.[mc]?[jt]sx?$/;
+const NOT_APP_CODE = /(\.(test|spec)\.[^.]+|\.d\.ts|routeTree\.gen\.ts)$/;
+/** App modules that mention createWorkflow: what the workflow registry imports. Describe decides what each one really exports. */
+export function workflowFiles(appDir) {
+    const found = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name !== "node_modules")
+                    walk(full);
+            }
+            else if (SOURCE_FILE.test(entry.name) && !NOT_APP_CODE.test(entry.name) && readFileSync(full, "utf-8").includes("createWorkflow")) {
+                found.push(relative(appDir, full).split("\\").join("/"));
+            }
+        }
+    };
+    if (existsSync(join(appDir, "src")))
+        walk(join(appDir, "src"));
+    return found.sort();
+}
+/** The registry zite() builds in place of zitejs's empty one. */
+export const renderWorkflowModules = (appDir, files) => `export const workflowModules = {\n${files
+    .map((file) => `  ${JSON.stringify(file)}: () => import(${JSON.stringify(join(appDir, file))}),`)
+    .join("\n")}\n};\n`;

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

@@ -0,0 +1,3 @@
+import type { ZiteRequestContext } from "./types.js";
+export declare const HOST_STORE_KEY: unique symbol;
+export declare const currentHost: () => ZiteRequestContext | undefined;

package/dist/esm/start/host.js

@@ -0,0 +1,4 @@
+// Isomorphic, so it can't import the server-only store: it reads it through the
+// global key ./scope.ts registers it under. In the browser there is none.
+export const HOST_STORE_KEY = Symbol.for("zitejs:host-context");
+export const currentHost = () => globalThis[HOST_STORE_KEY]?.getStore();

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

@@ -0,0 +1,79 @@
+import type { User } from "./types.js";
+export type { User, ZiteRequestContext } from "./types.js";
+export { createZiteRouter, type ZiteRouterContext } from "./router.js";
+export { createWorkflow, type StartProviderTrigger, type StartTrigger, type Workflow, type WorkflowArgs, type WorkflowConfig, } from "./workflow.js";
+export type { ZiteSchedule } from "../schedules/index.js";
+export type { ZiteTrigger, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput, } from "../backend/index.js";
+declare module "@tanstack/start-client-core" {
+    interface ServerFnOptions {
+        /** What this function does, in a sentence. Shown in the editor. */
+        description?: string;
+    }
+}
+declare const STATUS: {
+    readonly BAD_REQUEST: 400;
+    readonly INVALID_INPUT: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly CONFLICT: 409;
+    readonly RATE_LIMITED: 429;
+    readonly INTERNAL_ERROR: 500;
+};
+export type ZiteErrorCode = keyof typeof STATUS;
+/** @internal The HTTP status each code answers with. */
+export declare const ZITE_ERROR_STATUS: Readonly<Record<ZiteErrorCode, number>>;
+/** Fail with a status: `throw new ZiteError('FORBIDDEN', 'Only the owner can edit this')`. */
+export declare class ZiteError extends Error {
+    readonly code: ZiteErrorCode;
+    constructor(code: ZiteErrorCode, message?: string);
+}
+export declare const hasRole: (user: User, role: string) => boolean;
+/** The message a server function fails with when it needs a session; the platform's client middleware sends the user to sign in. */
+export declare const SIGN_IN_REQUIRED = "ZITE_SIGN_IN_REQUIRED";
+export declare const isSignInRequired: (error: unknown) => boolean;
+/**
+ * The platform's sign-in page, returning to `redirectTo` (default: the current
+ * page). For guards: `throw redirect({ href: loginHref(), reloadDocument: true })`.
+ */
+export declare function loginHref(redirectTo?: string): string;
+/** What a zitejs middleware means, for describe. Keyed by identity, so composing or re-exporting keeps it. */
+export type ZiteMiddlewareKind = {
+    kind: "signedIn" | "anyone" | "factory";
+} | {
+    kind: "webhook";
+    paused?: true;
+} | {
+    kind: "role";
+    role: string;
+};
+/** @internal */
+export declare const ziteMiddlewareKind: (middleware: unknown) => ZiteMiddlewareKind | undefined;
+/** Only signed-in users. Handlers get `context.user: User`. */
+export declare const signedIn: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, {
+    user: User;
+}>;
+/** Anyone, signed in or not. Handlers get `context.user: User | null`. */
+export declare const anyone: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, {
+    user: User | null;
+}>;
+/**
+ * Webhooks delivered by the platform, which already checked the URL token.
+ * `webhook.paused` keeps the URL but runs nothing: the platform answers the
+ * provider 200 and drops the delivery until it's switched back.
+ */
+export declare const webhook: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined> & {
+    paused: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>;
+};
+/** Signed-in users with this role. */
+export declare const role: (name: string) => import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, readonly [import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, {
+    user: User;
+}>], undefined>;
+declare const compiled: import("@tanstack/react-start").FunctionMiddlewareAfterClient<{}, unknown, undefined, undefined, undefined>;
+declare const builder: import("@tanstack/react-start").ServerFnBuilder<import("@tanstack/react-start").Register, import("@tanstack/react-start").Method, true>;
+type SignedInFn = ReturnType<typeof builder.middleware<readonly [typeof compiled, typeof signedIn]>>;
+type PublicFn = ReturnType<typeof builder.middleware<readonly [typeof compiled, typeof anyone]>>;
+/** A server function only signed-in users can call. */
+export declare const signedInFn: SignedInFn;
+/** A server function anyone can call (external apps only). */
+export declare const publicFn: PublicFn;

package/dist/esm/start/index.js

@@ -0,0 +1,157 @@
+import { createMiddleware, createServerFn } from "@tanstack/react-start";
+import { setResponseStatus } from "@tanstack/react-start/server";
+import { USAGE_TOKEN_QUERY_PARAM } from "../auth/constants.js";
+import { currentHost } from "./host.js";
+import { getHost, inScope, runInScope } from "./scope.js";
+export { createZiteRouter } from "./router.js";
+export { createWorkflow, } from "./workflow.js";
+const STATUS = {
+    BAD_REQUEST: 400,
+    INVALID_INPUT: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    CONFLICT: 409,
+    RATE_LIMITED: 429,
+    INTERNAL_ERROR: 500,
+};
+/** @internal The HTTP status each code answers with. */
+export const ZITE_ERROR_STATUS = STATUS;
+/** Fail with a status: `throw new ZiteError('FORBIDDEN', 'Only the owner can edit this')`. */
+export class ZiteError extends Error {
+    code;
+    constructor(code, message) {
+        super(message ?? code);
+        this.name = "ZiteError";
+        this.code = code;
+    }
+}
+export const hasRole = (user, role) => user.roles.includes(role);
+/** The message a server function fails with when it needs a session; the platform's client middleware sends the user to sign in. */
+export const SIGN_IN_REQUIRED = "ZITE_SIGN_IN_REQUIRED";
+export const isSignInRequired = (error) => error instanceof Error && error.message === SIGN_IN_REQUIRED;
+/**
+ * The platform's sign-in page, returning to `redirectTo` (default: the current
+ * page). For guards: `throw redirect({ href: loginHref(), reloadDocument: true })`.
+ */
+export function loginHref(redirectTo) {
+    const current = typeof window !== "undefined" ? window.location.href : currentHost()?.url;
+    // Absolute on purpose: better-auth drops a relative callback with an encoded
+    // space, fragment or non-ASCII path, and never checks an absolute one.
+    const target = current ? new URL(redirectTo ?? current, current) : undefined;
+    const params = new URLSearchParams();
+    if (target && !(target.pathname === "/" && !target.search && !target.hash))
+        params.set("redirectUrl", target.toString());
+    else if (!target && redirectTo)
+        params.set("redirectUrl", redirectTo);
+    // The editor preview's sign-in page needs the preview's token.
+    const usageToken = current ? new URL(current).searchParams.get(USAGE_TOKEN_QUERY_PARAM) : null;
+    if (usageToken)
+        params.set(USAGE_TOKEN_QUERY_PARAM, usageToken);
+    const query = params.toString();
+    return query ? `/auth/login?${query}` : "/auth/login";
+}
+const kinds = new WeakMap();
+const tag = (middleware, kind) => {
+    kinds.set(middleware, kind);
+    return middleware;
+};
+/** @internal */
+export const ziteMiddlewareKind = (middleware) => typeof middleware === "object" && middleware !== null ? kinds.get(middleware) : undefined;
+// Identity comes from server-only storage, never TanStack's context, which
+// merges whatever context the browser sends.
+const host = () => {
+    const current = getHost();
+    if (!current)
+        throw new ZiteError("UNAUTHORIZED", "Missing platform context");
+    return current;
+};
+// TanStack fails a validator with a plain Error whose message is the issues as JSON.
+const validationIssues = (error) => {
+    if (!(error instanceof Error) || error.constructor !== Error)
+        return undefined;
+    try {
+        const issues = JSON.parse(error.message);
+        return Array.isArray(issues) && issues.length > 0 && issues.every((issue) => typeof issue?.message === "string")
+            ? issues
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const invalidInput = (issues) => {
+    if (getHost()?.mode === "live")
+        return new ZiteError("INVALID_INPUT", "Invalid input");
+    const describe = ({ message, path = [] }) => {
+        const at = path.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+        return at ? `${at}: ${message}` : message;
+    };
+    return new ZiteError("INVALID_INPUT", issues.map(describe).join("; "));
+};
+// Server functions report a status through TanStack's error envelope; server
+// routes need a Response. A nested call's failure is the caller's to handle.
+const withStatus = async (isServerFn, fn) => {
+    const nested = inScope();
+    try {
+        return await fn();
+    }
+    catch (caught) {
+        const issues = validationIssues(caught);
+        const error = issues ? invalidInput(issues) : caught;
+        if (!(error instanceof ZiteError))
+            throw error;
+        if (!isServerFn)
+            return new Response(error.message, { status: STATUS[error.code] });
+        if (!nested)
+            setResponseStatus(STATUS[error.code]);
+        throw error;
+    }
+};
+/** Only signed-in users. Handlers get `context.user: User`. */
+export const signedIn = tag(createMiddleware().server(({ next, serverFnMeta }) => withStatus(!!serverFnMeta, async () => {
+    const { user } = host();
+    if (!user)
+        throw new ZiteError("UNAUTHORIZED", SIGN_IN_REQUIRED);
+    return runInScope({ kind: "signedIn", user }, () => next({ context: { user } }));
+})), { kind: "signedIn" });
+/** Anyone, signed in or not. Handlers get `context.user: User | null`. */
+export const anyone = tag(createMiddleware().server(({ next, serverFnMeta }) => withStatus(!!serverFnMeta, async () => {
+    const { user } = host();
+    return runInScope({ kind: "anyone", user }, () => next({ context: { user } }));
+})), { kind: "anyone" });
+const webhookMiddleware = (paused) => tag(createMiddleware().server(({ next }) => {
+    if (host().invoke?.kind !== "webhook")
+        return new Response("Not found", { status: 404 });
+    return runInScope({ kind: "webhook", user: null }, () => next());
+}), paused ? { kind: "webhook", paused: true } : { kind: "webhook" });
+/**
+ * Webhooks delivered by the platform, which already checked the URL token.
+ * `webhook.paused` keeps the URL but runs nothing: the platform answers the
+ * provider 200 and drops the delivery until it's switched back.
+ */
+export const webhook = Object.assign(webhookMiddleware(false), { paused: webhookMiddleware(true) });
+/** Signed-in users with this role. */
+export const role = (name) => tag(createMiddleware()
+    .middleware([signedIn])
+    .server(({ next, context, serverFnMeta }) => withStatus(!!serverFnMeta, async () => {
+    if (!hasRole(context.user, name))
+        throw new ZiteError("FORBIDDEN", `Requires the ${name} role`);
+    return next();
+})), { kind: "role", role: name });
+// TanStack's compiler tags every server function it compiles with an id. A
+// builder it didn't compile (an object property, one returned from a helper)
+// has none and would run its handler wherever it was called, so it fails here.
+const compiled = tag(createMiddleware({ type: "function" }).client(({ next, serverFnMeta }) => {
+    if (!serverFnMeta?.id) {
+        throw new Error("This server function was not compiled by TanStack Start. Assign signedInFn(...)/publicFn(...)" +
+            ".handler(...) directly to its own top-level const, not an object property or a helper's return value.");
+    }
+    return next();
+}), { kind: "factory" });
+// TanStack doesn't export its builder-after-middleware type, so name it through the public builder.
+const builder = createServerFn();
+/** A server function only signed-in users can call. */
+export const signedInFn = createServerFn().middleware([compiled, signedIn]);
+/** A server function anyone can call (external apps only). */
+export const publicFn = createServerFn().middleware([compiled, anyone]);

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,73 @@
+// 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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,8 @@
+/** 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,21 @@
+// 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,37 @@
+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

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

package/dist/esm/start/runLog.js

@@ -0,0 +1,18 @@
+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) };