zitejs 0.10.0-start.1 → 0.10.0-start.3

package/dist/cjs/check/index.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCheck = runCheck;
 const child_process_1 = require("child_process");
@@ -58,15 +91,60 @@ function bundleFailures(output) {
     }
     return failures;
 }
+const indent = (output) => output.trim().split('\n').map(l => `    ${l}`).join('\n');
+/**
+ * A Start app: `vite build` first, since it regenerates the route tree tsc
+ * reads, then tsc, then describe, which reports what the platform's build
+ * refuses, read the same way.
+ */
+async function checkStartApp(appPath) {
+    process.stdout.write('  vite build ... ');
+    const vite = run('npx', ['vite', 'build'], appPath);
+    console.log(vite.ok ? '✓' : '✗');
+    if (!vite.ok) {
+        console.log(indent(vite.output));
+        return false;
+    }
+    process.stdout.write('  tsc --noEmit ... ');
+    // --pretty for `file:line:col - error` lines, the shape the platform re-roots.
+    const tsc = run('npx', ['tsc', '--noEmit', '--pretty', '-p', 'tsconfig.app.json'], appPath);
+    console.log(tsc.ok ? '✓' : '✗');
+    if (!tsc.ok)
+        console.log(indent(tsc.output));
+    process.stdout.write('  describe ... ');
+    try {
+        const { describeBuiltApp } = await Promise.resolve().then(() => __importStar(require('../start/describeBuilt.js')));
+        const { descriptionProblems } = await Promise.resolve().then(() => __importStar(require('../start/problems.js')));
+        const problems = descriptionProblems((await describeBuiltApp(appPath)));
+        console.log(problems.length ? '✗' : '✓');
+        if (problems.length)
+            console.log(problems.map(p => `    ${p}`).join('\n'));
+        return tsc.ok && problems.length === 0;
+    }
+    catch (err) {
+        console.log('✗');
+        console.log(`    ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
 async function runCheck() {
-    const appDirs = (0, sourceRoots_js_1.listSourceDirs)();
-    if (appDirs.length === 0) {
+    const { isStartAppDir } = await Promise.resolve().then(() => __importStar(require('../start/entries.js')));
+    // Run inside a Start app, its own zitejs checks just that app: the workspace
+    // root's is a classic release that doesn't know Start.
+    const inStartApp = isStartAppDir('.');
+    const appDirs = inStartApp ? [] : (0, sourceRoots_js_1.listSourceDirs)();
+    if (!inStartApp && appDirs.length === 0) {
         console.error('No apps or automations found under apps/ or automations/.');
         process.exit(1);
     }
-    let allPassed = true;
+    let allPassed = inStartApp ? await checkStartApp('.') : true;
     for (const { root, dir: app, path: appPath } of appDirs) {
         console.log(`\n── ${appPath} ──`);
+        if (isStartAppDir(appPath)) {
+            if (!(await checkStartApp(appPath)))
+                allPassed = false;
+            continue;
+        }
         // Only tsconfig.app.json compiles anything. The app's tsconfig.json is a
         // solution-style config — `"files": []` plus a reference — so
         // `tsc --noEmit -p tsconfig.json` type-checks zero files and exits 0. It

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

@@ -8,4 +8,9 @@ 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/cjs/start/entries.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeIfChanged = exports.hasAppStart = exports.renderStartInstance = exports.renderStartServerEntry = exports.START_INSTANCE_ENTRY = exports.START_SERVER_ENTRY = void 0;
+exports.renderWorkflowModules = exports.isStartAppDir = exports.writeIfChanged = exports.hasAppStart = exports.renderStartInstance = exports.renderStartServerEntry = exports.START_INSTANCE_ENTRY = exports.START_SERVER_ENTRY = void 0;
 exports.regenerateStartEntries = regenerateStartEntries;
+exports.workflowFiles = workflowFiles;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 exports.START_SERVER_ENTRY = ".zite/server.ts";
@@ -42,14 +43,16 @@ const writeIfChanged = (appDir, file, content) => {
     return true;
 };
 exports.writeIfChanged = writeIfChanged;
-const isStartApp = (app) => {
+const isStartAppDir = (appPath) => {
     try {
-        return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(app.path, "zite.config.json"), "utf-8"))?.runtime === "start";
+        return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(appPath, "zite.config.json"), "utf-8"))?.runtime === "start";
     }
     catch {
         return false;
     }
 };
+exports.isStartAppDir = isStartAppDir;
+const isStartApp = (app) => (0, exports.isStartAppDir)(app.path);
 function regenerateStartEntries(app) {
     if (!isStartApp(app))
         return;
@@ -62,3 +65,29 @@ function regenerateStartEntries(app) {
             console.log(`Wrote ${(0, node_path_1.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. */
+function workflowFiles(appDir) {
+    const found = [];
+    const walk = (dir) => {
+        for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            const full = (0, node_path_1.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) && (0, node_fs_1.readFileSync)(full, "utf-8").includes("createWorkflow")) {
+                found.push((0, node_path_1.relative)(appDir, full).split("\\").join("/"));
+            }
+        }
+    };
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(appDir, "src")))
+        walk((0, node_path_1.join)(appDir, "src"));
+    return found.sort();
+}
+/** The registry zite() builds in place of zitejs's empty one. */
+const renderWorkflowModules = (appDir, files) => `export const workflowModules = {\n${files
+    .map((file) => `  ${JSON.stringify(file)}: () => import(${JSON.stringify((0, node_path_1.join)(appDir, file))}),`)
+    .join("\n")}\n};\n`;
+exports.renderWorkflowModules = renderWorkflowModules;

package/dist/cjs/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/cjs/start/problems.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.descriptionProblems = descriptionProblems;
+/** Every problem in a description, one line each, named by its rule. Any of them fails the build. */
+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/check/index.js

@@ -55,15 +55,60 @@ function bundleFailures(output) {
     }
     return failures;
 }
+const indent = (output) => output.trim().split('\n').map(l => `    ${l}`).join('\n');
+/**
+ * A Start app: `vite build` first, since it regenerates the route tree tsc
+ * reads, then tsc, then describe, which reports what the platform's build
+ * refuses, read the same way.
+ */
+async function checkStartApp(appPath) {
+    process.stdout.write('  vite build ... ');
+    const vite = run('npx', ['vite', 'build'], appPath);
+    console.log(vite.ok ? '✓' : '✗');
+    if (!vite.ok) {
+        console.log(indent(vite.output));
+        return false;
+    }
+    process.stdout.write('  tsc --noEmit ... ');
+    // --pretty for `file:line:col - error` lines, the shape the platform re-roots.
+    const tsc = run('npx', ['tsc', '--noEmit', '--pretty', '-p', 'tsconfig.app.json'], appPath);
+    console.log(tsc.ok ? '✓' : '✗');
+    if (!tsc.ok)
+        console.log(indent(tsc.output));
+    process.stdout.write('  describe ... ');
+    try {
+        const { describeBuiltApp } = await import('../start/describeBuilt.js');
+        const { descriptionProblems } = await import('../start/problems.js');
+        const problems = descriptionProblems((await describeBuiltApp(appPath)));
+        console.log(problems.length ? '✗' : '✓');
+        if (problems.length)
+            console.log(problems.map(p => `    ${p}`).join('\n'));
+        return tsc.ok && problems.length === 0;
+    }
+    catch (err) {
+        console.log('✗');
+        console.log(`    ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
 export async function runCheck() {
-    const appDirs = listSourceDirs();
-    if (appDirs.length === 0) {
+    const { isStartAppDir } = await import('../start/entries.js');
+    // Run inside a Start app, its own zitejs checks just that app: the workspace
+    // root's is a classic release that doesn't know Start.
+    const inStartApp = isStartAppDir('.');
+    const appDirs = inStartApp ? [] : listSourceDirs();
+    if (!inStartApp && appDirs.length === 0) {
         console.error('No apps or automations found under apps/ or automations/.');
         process.exit(1);
     }
-    let allPassed = true;
+    let allPassed = inStartApp ? await checkStartApp('.') : true;
     for (const { root, dir: app, path: appPath } of appDirs) {
         console.log(`\n── ${appPath} ──`);
+        if (isStartAppDir(appPath)) {
+            if (!(await checkStartApp(appPath)))
+                allPassed = false;
+            continue;
+        }
         // Only tsconfig.app.json compiles anything. The app's tsconfig.json is a
         // solution-style config — `"files": []` plus a reference — so
         // `tsc --noEmit -p tsconfig.json` type-checks zero files and exits 0. It

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

@@ -1,3 +1,5 @@
+import type { LoadedWorkflow } from "./workflowRun.js";
+import type { WorkflowConfig } from "./workflow.js";
 export type Access = {
     kind: "signedIn" | "anyone" | "webhook" | "none";
     roles: string[];
@@ -7,6 +9,8 @@ export type DescribedFunction = {
     name?: string;
     file?: string;
     method?: string;
+    /** From the factory's `description` option; display-only. */
+    description?: string;
     access: Access;
     input?: unknown;
     problems: string[];
@@ -16,9 +20,18 @@ export type DescribedRoute = {
     methods: Record<string, Access>;
     problems: string[];
 };
+export type DescribedWorkflow = {
+    id: string;
+    file: string;
+    description?: string;
+    schedule?: WorkflowConfig["schedule"];
+    trigger?: WorkflowConfig["trigger"];
+    problems: string[];
+};
 export type Description = {
     functions: DescribedFunction[];
     routes: DescribedRoute[];
+    workflows: DescribedWorkflow[];
 };
 export declare function describeFunction(id: string, request: Request): Promise<DescribedFunction>;
 type RouteLike = {
@@ -32,9 +45,12 @@ type RouteLike = {
     };
 };
 export declare function describeRoutes(routesById: Record<string, RouteLike>): DescribedRoute[];
+export declare function describeWorkflows(workflows: LoadedWorkflow[]): DescribedWorkflow[];
 export declare function describeApp(opts: {
     fnIds: string[];
+    descriptions?: Record<string, string>;
     getRouter: () => unknown;
     request: Request;
+    workflows?: LoadedWorkflow[];
 }): Promise<Description>;
 export {};

package/dist/esm/start/describe.js

@@ -38,6 +38,8 @@ const describeProbe = createMiddleware({ type: "function" }).server(({ serverFnM
         Object.assign(probe, { meta: serverFnMeta, method, reached: true });
     return "zite:describe";
 });
+const SERVER_ONLY = "server-only: nothing in the browser calls it, and a server function that only other server functions call can't run. " +
+    "Move the shared logic into a *.server.ts helper and call that.";
 export async function describeFunction(id, request) {
     const problems = [];
     const seen = [];
@@ -64,7 +66,14 @@ export async function describeFunction(id, request) {
         await runWithStartContext(startContext, () => createSsrRpc(id)({ data: undefined, context: {} }));
     }
     catch (error) {
-        problems.push(`probe-failed: ${error instanceof Error ? error.message : String(error)}`);
+        const message = error instanceof Error ? error.message : String(error);
+        // TanStack registers only functions something can call through it. One that
+        // only other server functions call isn't registered, and calling it fails.
+        if (message === `Server function info not found for ${id}`) {
+            probe = null;
+            return { id, access: { kind: "none", roles: [] }, problems: [SERVER_ONLY] };
+        }
+        problems.push(`probe-failed: ${message}`);
     }
     const state = probe;
     probe = null;
@@ -113,10 +122,26 @@ export function describeRoutes(routesById) {
     }
     return out;
 }
+// A workflow's id is its export name: what the host invokes it by and the editor shows.
+export function describeWorkflows(workflows) {
+    return workflows.map(({ id, file, workflow }) => {
+        const problems = [];
+        if (id === "default")
+            problems.push("workflow-default-export: export it by name, which becomes its id");
+        const elsewhere = workflows.find((other) => other.id === id && other.file !== file);
+        if (elsewhere)
+            problems.push(`duplicate-workflow: ${id} is also exported from ${elsewhere.file}`);
+        const { description, schedule, trigger } = workflow.config;
+        return { id, file, description, ...(schedule ? { schedule } : { trigger }), problems };
+    });
+}
 export async function describeApp(opts) {
     const functions = [];
-    for (const id of opts.fnIds)
-        functions.push(await describeFunction(id, opts.request));
+    for (const id of opts.fnIds) {
+        const described = await describeFunction(id, opts.request);
+        const description = opts.descriptions?.[id];
+        functions.push(description ? { ...described, description } : described);
+    }
     const router = (await opts.getRouter());
-    return { functions, routes: describeRoutes(router.routesById) };
+    return { functions, routes: describeRoutes(router.routesById), workflows: describeWorkflows(opts.workflows ?? []) };
 }

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

@@ -0,0 +1,4 @@
+/** `name -> description` for each top-level const built with a description option. */
+export declare function factoryDescriptions(program: {
+    body: unknown[];
+}): Map<string, string>;

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

@@ -8,4 +8,9 @@ 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

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+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"];
@@ -34,14 +34,15 @@ export const writeIfChanged = (appDir, file, content) => {
     writeFileSync(target, content);
     return true;
 };
-const isStartApp = (app) => {
+export const isStartAppDir = (appPath) => {
     try {
-        return JSON.parse(readFileSync(join(app.path, "zite.config.json"), "utf-8"))?.runtime === "start";
+        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;
@@ -54,3 +55,28 @@ export function regenerateStartEntries(app) {
             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/index.d.ts

@@ -1,6 +1,9 @@
 import type { User } from "./types.js";
 export type { User, ZiteRequestContext } from "./types.js";
 export { createZiteRouter, type ZiteRouterContext } from "./router.js";
+export { createWorkflow, type Workflow, type WorkflowArgs, type WorkflowConfig } from "./workflow.js";
+export type { ZiteSchedule } from "../schedules/index.js";
+export type { ZiteTrigger } from "../backend/index.js";
 declare module "@tanstack/start-client-core" {
     interface ServerFnOptions {
         /** What this function does, in a sentence. Shown in the editor. */
@@ -9,6 +12,7 @@ declare module "@tanstack/start-client-core" {
 }
 declare const STATUS: {
     readonly BAD_REQUEST: 400;
+    readonly INVALID_INPUT: 400;
     readonly UNAUTHORIZED: 401;
     readonly FORBIDDEN: 403;
     readonly NOT_FOUND: 404;
@@ -17,6 +21,8 @@ declare const STATUS: {
     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;

package/dist/esm/start/index.js

@@ -4,8 +4,10 @@ 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,
@@ -13,6 +15,8 @@ const STATUS = {
     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;
@@ -62,6 +66,29 @@ const host = () => {
         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) => {
@@ -69,7 +96,9 @@ const withStatus = async (isServerFn, fn) => {
     try {
         return await fn();
     }
-    catch (error) {
+    catch (caught) {
+        const issues = validationIssues(caught);
+        const error = issues ? invalidInput(issues) : caught;
         if (!(error instanceof ZiteError))
             throw error;
         if (!isServerFn)
@@ -87,10 +116,10 @@ export const signedIn = tag(createMiddleware().server(({ next, serverFnMeta }) =
     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 }) => {
+export const anyone = tag(createMiddleware().server(({ next, serverFnMeta }) => withStatus(!!serverFnMeta, async () => {
     const { user } = host();
     return runInScope({ kind: "anyone", user }, () => next({ context: { user } }));
-}), { kind: "anyone" });
+})), { kind: "anyone" });
 /** Webhooks delivered by the platform, which already checked the URL token. */
 export const webhook = tag(createMiddleware().server(({ next }) => {
     if (host().invoke?.kind !== "webhook")

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

@@ -7,6 +7,6 @@ import { ZiteError } from "./index.js";
  * 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";
+    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

@@ -3,6 +3,7 @@
 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" });
@@ -21,23 +22,6 @@ const signInOn401 = createMiddleware({ type: "function" }).client(async ({ next
         throw redirect({ href, reloadDocument: true });
     }
 });
-const PREVIEW_LIMIT = 8_000;
-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]";
-    }
-};
-const errorOf = (error) => error instanceof ZiteError
-    ? { code: error.code, message: error.message }
-    : { code: "INTERNAL_ERROR", message: error instanceof Error ? error.message : String(error) };
 // 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 }) => {

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