zitejs 0.9.95 → 0.9.96

package/dist/cjs/backend/index.d.ts

@@ -27,13 +27,22 @@ export type ZiteErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_
  * through a fixed table (BAD_REQUEST -> 400, and so on); it reads `code` and
  * nothing else, so an error carrying only a numeric `statusCode` fell through
  * to a generic 500.
+ *
+ * Both call shapes, mirroring the worker's own class (`zite-runtime.ts`): the
+ * object form is preferred, and the positional form is what pre-monorepo app
+ * code was written against. Typing only the object form would have failed the
+ * typecheck of every migrated app that throws one.
  */
 export declare class ZiteError extends Error {
     code: ZiteErrorCode;
+    /** Short, non-technical message suitable for showing to an end user. */
+    userFacingMessage?: string;
     constructor(options: {
         code: ZiteErrorCode;
         message: string;
+        userFacingMessage?: string;
     });
+    constructor(message: string, code?: ZiteErrorCode);
 }
 /**
  * Structurally matches a zod schema. `TIn` is the schema's *input* type, which
@@ -49,7 +58,7 @@ export type ZiteStreamInterface = {
     write: (data: unknown) => Promise<void>;
     forward: (asyncIterable: AsyncIterable<string>) => Promise<string>;
 };
-export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput> {
+export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {
     description?: string;
     inputSchema?: SchemaLike<TInput, TRawInput>;
     outputSchema?: SchemaLike<TOutput>;
@@ -61,12 +70,17 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      * Declaring one widens `context` so `context.user` must be null-checked.
      */
     schedule?: TSchedule;
-    webhook?: ZiteWebhook;
+    /**
+     * When set, the endpoint can also be triggered by an inbound webhook. Like
+     * `schedule`, this widens `context` — the workflow-runner sends
+     * `{ user: null }` for a webhook fire exactly as it does for a cron one.
+     */
+    webhook?: TWebhook;
     execute: (params: {
         input: TInput;
-        context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
+        context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
     } : {})) => Promise<TOutput> | TOutput;
 }
-export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput>(config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>): EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>;
+export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput>(config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>;

package/dist/cjs/backend/index.js

@@ -7,13 +7,27 @@ exports.createEndpoint = createEndpoint;
  * through a fixed table (BAD_REQUEST -> 400, and so on); it reads `code` and
  * nothing else, so an error carrying only a numeric `statusCode` fell through
  * to a generic 500.
+ *
+ * Both call shapes, mirroring the worker's own class (`zite-runtime.ts`): the
+ * object form is preferred, and the positional form is what pre-monorepo app
+ * code was written against. Typing only the object form would have failed the
+ * typecheck of every migrated app that throws one.
  */
 class ZiteError extends Error {
     code;
-    constructor(options) {
-        super(options.message);
+    /** Short, non-technical message suitable for showing to an end user. */
+    userFacingMessage;
+    constructor(optionsOrMessage, legacyCode) {
+        if (typeof optionsOrMessage === "string") {
+            super(optionsOrMessage);
+            this.code = legacyCode ?? "INTERNAL_ERROR";
+        }
+        else {
+            super(optionsOrMessage.message);
+            this.code = optionsOrMessage.code;
+            this.userFacingMessage = optionsOrMessage.userFacingMessage;
+        }
         this.name = "ZiteError";
-        this.code = options.code;
     }
 }
 exports.ZiteError = ZiteError;

package/dist/cjs/bundle/index.js

@@ -599,8 +599,13 @@ async function runBundle() {
     if (appFlag !== -1 && args[appFlag + 1]) {
         baseDir = path.resolve(baseDir, 'apps', args[appFlag + 1]);
     }
-    // If explicit endpoint names passed, use those; otherwise find all
-    const explicitNames = args.filter(a => !a.startsWith('--'));
+    // If explicit endpoint names passed, use those; otherwise find all.
+    // Skipping `--app`'s VALUE as well as the flag: it is a positional arg, so
+    // filtering on the `--` prefix alone treated the app directory name as an
+    // endpoint name — `zitejs bundle --app myapp` tried to bundle
+    // `src/api/myapp.ts`, found nothing else, and reported every real endpoint
+    // as missing.
+    const explicitNames = args.filter((a, i) => !a.startsWith('--') && !(appFlag !== -1 && i === appFlag + 1));
     let endpointNames;
     if (explicitNames.length > 0) {
         endpointNames = explicitNames;

package/dist/cjs/runtime/index.d.ts

@@ -2,21 +2,30 @@ import type { NotificationsCreateParams, NotificationsCreateResult } from "../no
 /**
  * A comparison against one field. Mirrors base-runner's operator set
  * (`LegacyWhereConditionOperators`); anything else in the object is ignored.
+ *
+ * The operand types deliberately match the pre-monorepo `FilterOperators`
+ * rather than tightening to the field's own type. The value of typing filters
+ * is in the KEY — an unknown key silently returns every row — and tightening
+ * the operands buys little while breaking real migrated code: dates are ISO
+ * strings here but 1.0 accepted `number | Date` on every comparison, and
+ * `contains` was `any`.
  */
 export type FilterCondition<V> = {
     /** Substring match (text fields) or "has any of these" (linked records). */
-    contains?: V extends Array<infer E> ? E | E[] : V;
+    contains?: any;
     /** Not equal, or — against `null` — "is set". */
     not?: V | null;
     /** Empty array means "no filter", not "match nothing". */
     in?: V extends Array<infer E> ? E[] : V[];
     /** Empty array means "no filter", not "match everything". */
     notIn?: V extends Array<infer E> ? E[] : V[];
-    lt?: V;
-    lte?: V;
-    gt?: V;
-    gte?: V;
+    lt?: V | number | Date;
+    lte?: V | number | Date;
+    gt?: V | number | Date;
+    gte?: V | number | Date;
 };
+/** Pre-monorepo name for {@link FilterCondition}. Kept so migrated app code that spells the type out still compiles. */
+export type FilterOperators<V> = FilterCondition<V> | V;
 /**
  * Filters keyed by the record's own field names. Typed rather than `unknown`
  * because an unrecognized key is not an error at runtime — it passes through
@@ -24,8 +33,16 @@ export type FilterCondition<V> = {
  * comes back **unfiltered**. A typo silently returns every row.
  */
 export type RecordFilters<T> = {
-    [K in keyof T]?: T[K] | FilterCondition<T[K]>;
+    [K in keyof T]?: T[K] | (T[K] extends Array<infer E> ? E : never) | FilterCondition<T[K]>;
 };
+/**
+ * Resolves a zod schema to the type it produces. `createEndpoint` infers this
+ * for you, so it is rarely needed — it exists because the pre-monorepo SDK
+ * exposed it and migrated app code may still name it.
+ */
+export type InferSchemaType<T> = T extends {
+    _output: infer U;
+} ? U : T;
 export interface TableFindAllOptions<T = Record<string, unknown>> {
     limit?: number;
     offset?: number;

package/dist/cjs/sync/lib.js

@@ -52,10 +52,15 @@ const FIELD_INPUT_TYPE_MAP = {
     user: "string | string[] | null",
 };
 /**
- * Computed and system-managed fields. base-runner rejects a write to any of
- * these outright (`createRecordDataSchema` in `trpc/schemas/records.ts`), so
- * they are omitted from the generated input type rather than typed and then
- * refused at runtime.
+ * Computed and system-managed fields, omitted from the generated input type
+ * rather than typed and then refused at runtime.
+ *
+ * Mirrors `COMPUTED_FIELD_TYPES` in the product's own `shared/bases/fields`.
+ * The first six are rejected by `createRecordDataSchema` — each has a
+ * `refine(val => val == null)`, so a non-null write errors (null is a no-op
+ * clear). `created_at` / `updated_at` are refused differently: they have no
+ * column at all, so a write is silently dropped, which is the worse outcome to
+ * leave typed as writable.
  */
 const READ_ONLY_FIELD_TYPES = new Set([
     "lookup",
@@ -64,6 +69,8 @@ const READ_ONLY_FIELD_TYPES = new Set([
     "formula",
     "autonumber",
     "updated_by",
+    "created_at",
+    "updated_at",
 ]);
 /**
  * Emitted once per `db.ts`. The old inline `{ url: string; name?: string }` was
@@ -110,6 +117,19 @@ const DURATION_FORMAT_EXAMPLES = {
     "h:mm:ss.ss": "1:23:03.00",
     "h:mm:ss.sss": "1:23:03.000",
 };
+// Naming the format alone ("display as `european` format") doesn't say what to
+// render — these mirror the pickers in the database UI, which is what the user
+// chose from. `local` is the viewer's system locale, so it has no fixed example.
+const DATE_FORMAT_EXAMPLES = {
+    long: "January 15, 2024",
+    us: "1/15/2024",
+    european: "15/01/2024",
+    iso: "2024-01-15",
+};
+const withDateFormatExample = (format) => {
+    const example = DATE_FORMAT_EXAMPLES[format];
+    return example ? `"${format}" format (e.g. ${example})` : `"${format}" format`;
+};
 function toPascalCase(name) {
     const pascal = name
         .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
@@ -188,13 +208,13 @@ function fieldJsdoc(schemaField, table, schema) {
     if (def.type === "date") {
         const tpl = def.template;
         if (tpl.dateFormat)
-            parts.push(`Date-only field (YYYY-MM-DD string), null when unset, display as "${tpl.dateFormat}" format`);
+            parts.push(`Date-only field (YYYY-MM-DD string), null when unset, display as ${withDateFormatExample(tpl.dateFormat)}`);
     }
     if (def.type === "datetime") {
         const tpl = def.template;
         const timeParts = ["Date+time field (ISO 8601 timestamp), null when unset"];
         if (tpl.dateFormat)
-            timeParts.push(`date: ${tpl.dateFormat}`);
+            timeParts.push(`date: ${withDateFormatExample(tpl.dateFormat)}`);
         if (tpl.timeFormat)
             timeParts.push(`time: ${tpl.timeFormat}`);
         if (tpl.timezone)
@@ -393,13 +413,13 @@ function generateDbTs(schema) {
     lines.push("//     operators: contains, not, in, notIn, lt, lte, gt, gte");
     lines.push('//       `not: null` means "is set"; `in`/`notIn` with an empty array apply NO filter');
     lines.push("//     sort: [{ field: 'fieldName', direction: 'asc' | 'desc' }]");
-    lines.push("//     limit defaults to 500, max 5000; offset is a row count (a number)");
+    lines.push("//     limit defaults to 500, max 2000; offset is a row count (a number)");
     lines.push("//   .findOne({ id?, filters?, fields? }) → T | undefined");
     lines.push("//   .create({ record }) → T");
     lines.push("//   .update({ id, record }) → { id: string, fields: Partial<T> }");
     lines.push("//   .delete({ id }) → { success: true, id: string }");
     lines.push("//   .bulkCreate({ records, matchOn? }) → { success: boolean, records: T[] }");
-    lines.push("//     up to 500 records per call; matchOn upserts on those fields");
+    lines.push("//     up to 100 records per call; matchOn upserts on those fields");
     lines.push("//");
     lines.push("// Reading these types:");
     lines.push("//   SDK names are stable identifiers — they do NOT change when a table or field is");
@@ -410,8 +430,9 @@ function generateDbTs(schema) {
     lines.push("//   display yourself, following the display config in each field's comment.");
     lines.push("//   PERCENT fields are stored as decimals — 0.5 is 50%, 1.0 is 100%.");
     lines.push("//   LINKED RECORD fields hold UUID record ids from findOne/findAll — never invent one.");
-    lines.push("//   Computed fields (formula, rollup, lookup, autonumber) are absent from the *Input");
-    lines.push("//   types — writing to one is rejected.");
+    lines.push("//   Computed and system-managed fields (formula, rollup, lookup, autonumber,");
+    lines.push("//   created/updated timestamps and more) are absent from the *Input types —");
+    lines.push("//   a write to one is rejected or silently dropped.");
     lines.push("//");
     lines.push("// Zite auth users:");
     lines.push("//   zite.auth.findAllUsers({ appIds?, filter?, filters?, sort?, limit?, offset? })");
@@ -425,7 +446,7 @@ function generateDbTs(schema) {
     lines.push("//     → { rows: Record<string, unknown>[], columns, rowCount, truncated }");
     lines.push("//     Capped at 2000 rows — `truncated: true` means there were more, so paginate in");
     lines.push("//     SQL rather than assuming you got everything. Queries time out after 10s.");
-    lines.push("//     columns[].name is the SDK name; columns[].originalName is the user-facing one.");
+    lines.push("//     columns[].name is the SDK name; columns[].originalName is the underlying", "//     database column (or your own SQL alias).");
     lines.push("//");
     lines.push("// SQL guidelines:");
     lines.push("//   - Use SDK names for tables (PascalCase) and fields (camelCase)");
@@ -483,38 +504,74 @@ function generateDbTs(schema) {
     lines.push("");
     return lines.join("\n");
 }
+const NOT_AN_ENDPOINT = {
+    isEndpoint: false,
+    hasDefaultExport: false,
+    stream: false,
+};
+/** `createEndpoint(...)` anywhere in the expression, through wrappers. */
+function callsCreateEndpoint(node) {
+    if (!node || typeof node !== "object")
+        return false;
+    const n = node;
+    if (n.type === "CallExpression" &&
+        n.callee?.name ===
+            "createEndpoint") {
+        return true;
+    }
+    return Object.values(n).some((v) => Array.isArray(v) ? v.some(callsCreateEndpoint) : callsCreateEndpoint(v));
+}
+/** Unwrap `x satisfies T` / `x as const` to the expression underneath. */
+function unwrapExpression(node) {
+    let current = node;
+    while ((current?.type === "TSAsExpression" ||
+        current?.type === "TSSatisfiesExpression" ||
+        current?.type === "TSNonNullExpression" ||
+        current?.type === "ParenthesizedExpression") &&
+        current.expression) {
+        current = current.expression;
+    }
+    return current;
+}
 function inspectEndpointFile(source) {
+    let ast;
     try {
-        const ast = (0, parser_1.parse)(source, {
-            sourceType: "module",
-            plugins: ["typescript"],
-        });
-        const defaultExport = ast.program.body.find((n) => n.type === "ExportDefaultDeclaration" &&
-            n.declaration.type === "CallExpression");
-        if (!defaultExport || defaultExport.type !== "ExportDefaultDeclaration")
-            return { isEndpoint: false, stream: false };
-        const call = defaultExport.declaration;
-        if (call.type !== "CallExpression" || call.arguments.length === 0)
-            return { isEndpoint: false, stream: false };
-        const arg = call.arguments[0];
-        // `createEndpoint(config)` — anything else defaulting out of src/api/ is
-        // not an endpoint we can type a caller for.
-        if (arg.type !== "ObjectExpression")
-            return { isEndpoint: false, stream: false };
-        const streamProp = arg.properties.find((p) => p.type === "ObjectProperty" &&
-            ((p.key.type === "Identifier" && p.key.name === "stream") ||
-                (p.key.type === "StringLiteral" && p.key.value === "stream")));
-        const stream = !!streamProp &&
-            streamProp.type === "ObjectProperty" &&
-            streamProp.value.type === "BooleanLiteral" &&
-            streamProp.value.value === true;
-        return { isEndpoint: true, stream };
+        ast = (0, parser_1.parse)(source, { sourceType: "module", plugins: ["typescript"] });
     }
     catch {
-        // A file that doesn't parse can't be typed either. Leaving it out keeps
-        // one broken file from taking the whole generated module down with it.
-        return { isEndpoint: false, stream: false };
+        // Unparseable with a TS-only plugin set — most likely TSX, which is still
+        // a real endpoint file. Assume yes and let the app's own typecheck judge
+        // it, rather than dropping a route the bundler will deploy regardless.
+        return { isEndpoint: true, hasDefaultExport: true, stream: false };
     }
+    const body = ast.program.body;
+    const hasDefaultExport = body.some((n) => n.type === "ExportDefaultDeclaration" ||
+        (n.type === "ExportNamedDeclaration" &&
+            n.specifiers?.some((spec) => spec.type === "ExportSpecifier" &&
+                (spec.exported.type === "Identifier"
+                    ? spec.exported.name
+                    : spec.exported.value) === "default")));
+    const isEndpoint = hasDefaultExport || body.some(callsCreateEndpoint);
+    if (!isEndpoint)
+        return NOT_AN_ENDPOINT;
+    // Stream detection is best-effort on the literal config: it is the only
+    // shape we can read `stream: true` out of statically.
+    const defaultExport = body.find((n) => n.type === "ExportDefaultDeclaration");
+    const call = defaultExport
+        ? unwrapExpression(defaultExport.declaration)
+        : undefined;
+    const arg = call?.type === "CallExpression"
+        ? unwrapExpression(call.arguments?.[0] ?? {})
+        : undefined;
+    if (arg?.type !== "ObjectExpression") {
+        return { isEndpoint, hasDefaultExport, stream: false };
+    }
+    const streamProp = arg.properties.find((prop) => prop.type === "ObjectProperty" &&
+        ((prop.key?.type === "Identifier" && prop.key.name === "stream") ||
+            (prop.key?.type === "StringLiteral" && prop.key.value === "stream")));
+    const stream = streamProp?.value?.type === "BooleanLiteral" &&
+        streamProp.value.value === true;
+    return { isEndpoint, hasDefaultExport, stream };
 }
 /**
  * Reserved words can't be `const` names. The route is the filename either way,
@@ -556,8 +613,9 @@ function generateApiTs(endpointFiles) {
         const ident = toSafeIdentifier(key);
         // Distinct files can collide on one identifier (`send-email.ts` and
         // `send_email.ts` both camelCase to `sendEmail`), which used to emit the
-        // same `export const` twice. Input is sorted by every caller, so first-wins
-        // is stable across runs.
+        // same `export const` twice. First-wins, which is stable because every
+        // caller sorts its input before calling — the two in this package and
+        // `generateApiClient` in the backend's migration assembler.
         if (seenIdents.has(ident)) {
             skipped.push(`${fileName} (name collides with '${ident}')`);
             continue;
@@ -569,6 +627,9 @@ function generateApiTs(endpointFiles) {
             ident,
             pascal: toPascalCase(key),
             stream: shape?.stream ?? false,
+            // No content to inspect means a bare-filename caller, which historically
+            // assumed a default export — keep that assumption.
+            typed: shape ? shape.hasDefaultExport : true,
         });
     }
     if (endpoints.length === 0)
@@ -588,11 +649,24 @@ function generateApiTs(endpointFiles) {
             lines.push(`//   ${name}`);
         lines.push("");
     }
-    for (const { pascal, baseName } of endpoints) {
+    for (const { pascal, baseName, typed } of endpoints) {
+        if (!typed)
+            continue;
         lines.push(`import type { default as _${pascal}Ep } from '../src/api/${baseName}';`);
     }
     lines.push("");
-    for (const { baseName, ident, pascal, stream } of endpoints) {
+    for (const { baseName, ident, pascal, stream, typed } of endpoints) {
+        if (!typed) {
+            // Declared with `export const x = createEndpoint(...)` — the 1.0 shape.
+            // The route is real and the bundler deploys it, so the caller has to
+            // exist; there is just no default export to read its types from.
+            lines.push(`// '${baseName}' has no default export, so its input/output are untyped.`);
+            lines.push(`export type ${pascal}InputType = unknown;`);
+            lines.push(`export type ${pascal}OutputType = unknown;`);
+            lines.push(`export const ${ident} = ${stream ? "createStreamingCaller" : "createCaller"}<${pascal}InputType, ${pascal}OutputType>('${baseName}');`);
+            lines.push("");
+            continue;
+        }
         lines.push(`type _${pascal}Cfg = typeof _${pascal}Ep;`);
         // A caller sends the schema's INPUT type, not its output: a field with a
         // `.default()` or a transform is optional to send and guaranteed on the
@@ -839,12 +913,14 @@ function generateAirtableTs(lock) {
         "//   Fields marked \"Links to X\" hold Airtable record ids (rec...) from",
         "//   findOne/findAll — never invent one.",
         "//   Read-only fields are absent from the *RecordInput types: Airtable rejects a",
-        "//   write to a formula, rollup, lookup or autonumber with a 422.",
+        "//   write to a computed one (formula, rollup, lookup, autonumber, the created/",
+        "//   modified metadata, button, aiText) with a 422.",
         "//",
         "// Usage tips:",
         "//   - Airtable has a strict rate limit of 5 requests/second per base",
-        "//   - Use bulkCreate() instead of calling create() in a loop. Pass any number of",
-        "//     records — it chunks into Airtable's 10-per-request batches for you",
+        "//   - Use bulkCreate() instead of calling create() in a loop, but chunk it",
+        "//     yourself: Airtable rejects more than 10 records in one create request",
+        "//     with a 422, and not every runtime path batches for you",
         "//   - findAll() offsets are opaque cursor strings from a previous call, NOT row",
         "//     counts (unlike zite.<table>.findAll, whose offset IS a number)",
         "//   - Always destructure record properties individually in create/update calls",
@@ -906,13 +982,31 @@ function generateBackendWrapperTs(envVarNames = []) {
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteWebhook };",
+        // The pre-monorepo SDK put this in scope for every endpoint, so migrated
+        // code can name it. `createEndpoint` infers the same thing without it.
+        "export type InferSchemaType<T> = T extends { _output: infer U } ? U : T;",
         "",
         "export class ZiteError extends Error {",
         "  code: ZiteErrorCode;",
-        "  constructor(options: { code: ZiteErrorCode; message: string }) {",
-        "    super(options.message);",
+        "  /** Short, non-technical message suitable for showing to an end user. */",
+        "  userFacingMessage?: string;",
+        "  // Both shapes, mirroring the worker's own class: object form preferred,",
+        "  // positional form is what pre-monorepo app code was written against.",
+        "  constructor(options: { code: ZiteErrorCode; message: string; userFacingMessage?: string });",
+        "  constructor(message: string, code?: ZiteErrorCode);",
+        "  constructor(",
+        "    optionsOrMessage: { code: ZiteErrorCode; message: string; userFacingMessage?: string } | string,",
+        "    legacyCode?: ZiteErrorCode,",
+        "  ) {",
+        "    if (typeof optionsOrMessage === 'string') {",
+        "      super(optionsOrMessage);",
+        "      this.code = legacyCode ?? 'INTERNAL_ERROR';",
+        "    } else {",
+        "      super(optionsOrMessage.message);",
+        "      this.code = optionsOrMessage.code;",
+        "      this.userFacingMessage = optionsOrMessage.userFacingMessage;",
+        "    }",
         "    this.name = 'ZiteError';",
-        "    this.code = options.code;",
         "  }",
         "}",
         "",
@@ -928,7 +1022,7 @@ function generateBackendWrapperTs(envVarNames = []) {
         // TStream mirrors zitejs/backend/base. Without it `stream: true` endpoints
         // get no `stream` argument here — and this wrapper, not the base module, is
         // what `zitejs/backend` resolves to in every app.
-        "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput> {",
+        "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {",
         "  description?: string;",
         "  inputSchema?: SchemaLike<TInput, TRawInput>;",
         "  outputSchema?: SchemaLike<TOutput>;",
@@ -936,18 +1030,19 @@ function generateBackendWrapperTs(envVarNames = []) {
         "  authenticated?: boolean;",
         "  /** When set, the endpoint also fires on this cron schedule. It stays request-callable — declaring one widens `context`, so `context.user` must be null-checked. */",
         "  schedule?: TSchedule;",
-        "  webhook?: ZiteWebhook;",
+        "  /** When set, an inbound webhook can also trigger this endpoint. Like `schedule`, it widens `context` — a webhook fire has no session. */",
+        "  webhook?: TWebhook;",
         "  execute: (",
         "    params: {",
         "      input: TInput;",
-        "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
+        "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
         "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}),",
         "  ) => Promise<TOutput> | TOutput;",
         "}",
         "",
-        "export function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput>(",
-        "  config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>,",
-        "): EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput> {",
+        "export function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput>(",
+        "  config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>,",
+        "): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput> {",
         "  return config;",
         "}",
         "",

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

@@ -27,13 +27,22 @@ export type ZiteErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_
  * through a fixed table (BAD_REQUEST -> 400, and so on); it reads `code` and
  * nothing else, so an error carrying only a numeric `statusCode` fell through
  * to a generic 500.
+ *
+ * Both call shapes, mirroring the worker's own class (`zite-runtime.ts`): the
+ * object form is preferred, and the positional form is what pre-monorepo app
+ * code was written against. Typing only the object form would have failed the
+ * typecheck of every migrated app that throws one.
  */
 export declare class ZiteError extends Error {
     code: ZiteErrorCode;
+    /** Short, non-technical message suitable for showing to an end user. */
+    userFacingMessage?: string;
     constructor(options: {
         code: ZiteErrorCode;
         message: string;
+        userFacingMessage?: string;
     });
+    constructor(message: string, code?: ZiteErrorCode);
 }
 /**
  * Structurally matches a zod schema. `TIn` is the schema's *input* type, which
@@ -49,7 +58,7 @@ export type ZiteStreamInterface = {
     write: (data: unknown) => Promise<void>;
     forward: (asyncIterable: AsyncIterable<string>) => Promise<string>;
 };
-export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput> {
+export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {
     description?: string;
     inputSchema?: SchemaLike<TInput, TRawInput>;
     outputSchema?: SchemaLike<TOutput>;
@@ -61,12 +70,17 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      * Declaring one widens `context` so `context.user` must be null-checked.
      */
     schedule?: TSchedule;
-    webhook?: ZiteWebhook;
+    /**
+     * When set, the endpoint can also be triggered by an inbound webhook. Like
+     * `schedule`, this widens `context` — the workflow-runner sends
+     * `{ user: null }` for a webhook fire exactly as it does for a cron one.
+     */
+    webhook?: TWebhook;
     execute: (params: {
         input: TInput;
-        context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
+        context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
     } : {})) => Promise<TOutput> | TOutput;
 }
-export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput>(config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>): EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>;
+export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput>(config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>;

package/dist/esm/backend/index.js

@@ -3,13 +3,27 @@
  * through a fixed table (BAD_REQUEST -> 400, and so on); it reads `code` and
  * nothing else, so an error carrying only a numeric `statusCode` fell through
  * to a generic 500.
+ *
+ * Both call shapes, mirroring the worker's own class (`zite-runtime.ts`): the
+ * object form is preferred, and the positional form is what pre-monorepo app
+ * code was written against. Typing only the object form would have failed the
+ * typecheck of every migrated app that throws one.
  */
 export class ZiteError extends Error {
     code;
-    constructor(options) {
-        super(options.message);
+    /** Short, non-technical message suitable for showing to an end user. */
+    userFacingMessage;
+    constructor(optionsOrMessage, legacyCode) {
+        if (typeof optionsOrMessage === "string") {
+            super(optionsOrMessage);
+            this.code = legacyCode ?? "INTERNAL_ERROR";
+        }
+        else {
+            super(optionsOrMessage.message);
+            this.code = optionsOrMessage.code;
+            this.userFacingMessage = optionsOrMessage.userFacingMessage;
+        }
         this.name = "ZiteError";
-        this.code = options.code;
     }
 }
 export function createEndpoint(config) {

package/dist/esm/bundle/index.js

@@ -563,8 +563,13 @@ export async function runBundle() {
     if (appFlag !== -1 && args[appFlag + 1]) {
         baseDir = path.resolve(baseDir, 'apps', args[appFlag + 1]);
     }
-    // If explicit endpoint names passed, use those; otherwise find all
-    const explicitNames = args.filter(a => !a.startsWith('--'));
+    // If explicit endpoint names passed, use those; otherwise find all.
+    // Skipping `--app`'s VALUE as well as the flag: it is a positional arg, so
+    // filtering on the `--` prefix alone treated the app directory name as an
+    // endpoint name — `zitejs bundle --app myapp` tried to bundle
+    // `src/api/myapp.ts`, found nothing else, and reported every real endpoint
+    // as missing.
+    const explicitNames = args.filter((a, i) => !a.startsWith('--') && !(appFlag !== -1 && i === appFlag + 1));
     let endpointNames;
     if (explicitNames.length > 0) {
         endpointNames = explicitNames;

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

@@ -2,21 +2,30 @@ import type { NotificationsCreateParams, NotificationsCreateResult } from "../no
 /**
  * A comparison against one field. Mirrors base-runner's operator set
  * (`LegacyWhereConditionOperators`); anything else in the object is ignored.
+ *
+ * The operand types deliberately match the pre-monorepo `FilterOperators`
+ * rather than tightening to the field's own type. The value of typing filters
+ * is in the KEY — an unknown key silently returns every row — and tightening
+ * the operands buys little while breaking real migrated code: dates are ISO
+ * strings here but 1.0 accepted `number | Date` on every comparison, and
+ * `contains` was `any`.
  */
 export type FilterCondition<V> = {
     /** Substring match (text fields) or "has any of these" (linked records). */
-    contains?: V extends Array<infer E> ? E | E[] : V;
+    contains?: any;
     /** Not equal, or — against `null` — "is set". */
     not?: V | null;
     /** Empty array means "no filter", not "match nothing". */
     in?: V extends Array<infer E> ? E[] : V[];
     /** Empty array means "no filter", not "match everything". */
     notIn?: V extends Array<infer E> ? E[] : V[];
-    lt?: V;
-    lte?: V;
-    gt?: V;
-    gte?: V;
+    lt?: V | number | Date;
+    lte?: V | number | Date;
+    gt?: V | number | Date;
+    gte?: V | number | Date;
 };
+/** Pre-monorepo name for {@link FilterCondition}. Kept so migrated app code that spells the type out still compiles. */
+export type FilterOperators<V> = FilterCondition<V> | V;
 /**
  * Filters keyed by the record's own field names. Typed rather than `unknown`
  * because an unrecognized key is not an error at runtime — it passes through
@@ -24,8 +33,16 @@ export type FilterCondition<V> = {
  * comes back **unfiltered**. A typo silently returns every row.
  */
 export type RecordFilters<T> = {
-    [K in keyof T]?: T[K] | FilterCondition<T[K]>;
+    [K in keyof T]?: T[K] | (T[K] extends Array<infer E> ? E : never) | FilterCondition<T[K]>;
 };
+/**
+ * Resolves a zod schema to the type it produces. `createEndpoint` infers this
+ * for you, so it is rarely needed — it exists because the pre-monorepo SDK
+ * exposed it and migrated app code may still name it.
+ */
+export type InferSchemaType<T> = T extends {
+    _output: infer U;
+} ? U : T;
 export interface TableFindAllOptions<T = Record<string, unknown>> {
     limit?: number;
     offset?: number;

package/dist/esm/sync/lib.js

@@ -42,10 +42,15 @@ const FIELD_INPUT_TYPE_MAP = {
     user: "string | string[] | null",
 };
 /**
- * Computed and system-managed fields. base-runner rejects a write to any of
- * these outright (`createRecordDataSchema` in `trpc/schemas/records.ts`), so
- * they are omitted from the generated input type rather than typed and then
- * refused at runtime.
+ * Computed and system-managed fields, omitted from the generated input type
+ * rather than typed and then refused at runtime.
+ *
+ * Mirrors `COMPUTED_FIELD_TYPES` in the product's own `shared/bases/fields`.
+ * The first six are rejected by `createRecordDataSchema` — each has a
+ * `refine(val => val == null)`, so a non-null write errors (null is a no-op
+ * clear). `created_at` / `updated_at` are refused differently: they have no
+ * column at all, so a write is silently dropped, which is the worse outcome to
+ * leave typed as writable.
  */
 const READ_ONLY_FIELD_TYPES = new Set([
     "lookup",
@@ -54,6 +59,8 @@ const READ_ONLY_FIELD_TYPES = new Set([
     "formula",
     "autonumber",
     "updated_by",
+    "created_at",
+    "updated_at",
 ]);
 /**
  * Emitted once per `db.ts`. The old inline `{ url: string; name?: string }` was
@@ -100,6 +107,19 @@ const DURATION_FORMAT_EXAMPLES = {
     "h:mm:ss.ss": "1:23:03.00",
     "h:mm:ss.sss": "1:23:03.000",
 };
+// Naming the format alone ("display as `european` format") doesn't say what to
+// render — these mirror the pickers in the database UI, which is what the user
+// chose from. `local` is the viewer's system locale, so it has no fixed example.
+const DATE_FORMAT_EXAMPLES = {
+    long: "January 15, 2024",
+    us: "1/15/2024",
+    european: "15/01/2024",
+    iso: "2024-01-15",
+};
+const withDateFormatExample = (format) => {
+    const example = DATE_FORMAT_EXAMPLES[format];
+    return example ? `"${format}" format (e.g. ${example})` : `"${format}" format`;
+};
 export function toPascalCase(name) {
     const pascal = name
         .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
@@ -178,13 +198,13 @@ function fieldJsdoc(schemaField, table, schema) {
     if (def.type === "date") {
         const tpl = def.template;
         if (tpl.dateFormat)
-            parts.push(`Date-only field (YYYY-MM-DD string), null when unset, display as "${tpl.dateFormat}" format`);
+            parts.push(`Date-only field (YYYY-MM-DD string), null when unset, display as ${withDateFormatExample(tpl.dateFormat)}`);
     }
     if (def.type === "datetime") {
         const tpl = def.template;
         const timeParts = ["Date+time field (ISO 8601 timestamp), null when unset"];
         if (tpl.dateFormat)
-            timeParts.push(`date: ${tpl.dateFormat}`);
+            timeParts.push(`date: ${withDateFormatExample(tpl.dateFormat)}`);
         if (tpl.timeFormat)
             timeParts.push(`time: ${tpl.timeFormat}`);
         if (tpl.timezone)
@@ -383,13 +403,13 @@ export function generateDbTs(schema) {
     lines.push("//     operators: contains, not, in, notIn, lt, lte, gt, gte");
     lines.push('//       `not: null` means "is set"; `in`/`notIn` with an empty array apply NO filter');
     lines.push("//     sort: [{ field: 'fieldName', direction: 'asc' | 'desc' }]");
-    lines.push("//     limit defaults to 500, max 5000; offset is a row count (a number)");
+    lines.push("//     limit defaults to 500, max 2000; offset is a row count (a number)");
     lines.push("//   .findOne({ id?, filters?, fields? }) → T | undefined");
     lines.push("//   .create({ record }) → T");
     lines.push("//   .update({ id, record }) → { id: string, fields: Partial<T> }");
     lines.push("//   .delete({ id }) → { success: true, id: string }");
     lines.push("//   .bulkCreate({ records, matchOn? }) → { success: boolean, records: T[] }");
-    lines.push("//     up to 500 records per call; matchOn upserts on those fields");
+    lines.push("//     up to 100 records per call; matchOn upserts on those fields");
     lines.push("//");
     lines.push("// Reading these types:");
     lines.push("//   SDK names are stable identifiers — they do NOT change when a table or field is");
@@ -400,8 +420,9 @@ export function generateDbTs(schema) {
     lines.push("//   display yourself, following the display config in each field's comment.");
     lines.push("//   PERCENT fields are stored as decimals — 0.5 is 50%, 1.0 is 100%.");
     lines.push("//   LINKED RECORD fields hold UUID record ids from findOne/findAll — never invent one.");
-    lines.push("//   Computed fields (formula, rollup, lookup, autonumber) are absent from the *Input");
-    lines.push("//   types — writing to one is rejected.");
+    lines.push("//   Computed and system-managed fields (formula, rollup, lookup, autonumber,");
+    lines.push("//   created/updated timestamps and more) are absent from the *Input types —");
+    lines.push("//   a write to one is rejected or silently dropped.");
     lines.push("//");
     lines.push("// Zite auth users:");
     lines.push("//   zite.auth.findAllUsers({ appIds?, filter?, filters?, sort?, limit?, offset? })");
@@ -415,7 +436,7 @@ export function generateDbTs(schema) {
     lines.push("//     → { rows: Record<string, unknown>[], columns, rowCount, truncated }");
     lines.push("//     Capped at 2000 rows — `truncated: true` means there were more, so paginate in");
     lines.push("//     SQL rather than assuming you got everything. Queries time out after 10s.");
-    lines.push("//     columns[].name is the SDK name; columns[].originalName is the user-facing one.");
+    lines.push("//     columns[].name is the SDK name; columns[].originalName is the underlying", "//     database column (or your own SQL alias).");
     lines.push("//");
     lines.push("// SQL guidelines:");
     lines.push("//   - Use SDK names for tables (PascalCase) and fields (camelCase)");
@@ -473,38 +494,74 @@ export function generateDbTs(schema) {
     lines.push("");
     return lines.join("\n");
 }
+const NOT_AN_ENDPOINT = {
+    isEndpoint: false,
+    hasDefaultExport: false,
+    stream: false,
+};
+/** `createEndpoint(...)` anywhere in the expression, through wrappers. */
+function callsCreateEndpoint(node) {
+    if (!node || typeof node !== "object")
+        return false;
+    const n = node;
+    if (n.type === "CallExpression" &&
+        n.callee?.name ===
+            "createEndpoint") {
+        return true;
+    }
+    return Object.values(n).some((v) => Array.isArray(v) ? v.some(callsCreateEndpoint) : callsCreateEndpoint(v));
+}
+/** Unwrap `x satisfies T` / `x as const` to the expression underneath. */
+function unwrapExpression(node) {
+    let current = node;
+    while ((current?.type === "TSAsExpression" ||
+        current?.type === "TSSatisfiesExpression" ||
+        current?.type === "TSNonNullExpression" ||
+        current?.type === "ParenthesizedExpression") &&
+        current.expression) {
+        current = current.expression;
+    }
+    return current;
+}
 function inspectEndpointFile(source) {
+    let ast;
     try {
-        const ast = parse(source, {
-            sourceType: "module",
-            plugins: ["typescript"],
-        });
-        const defaultExport = ast.program.body.find((n) => n.type === "ExportDefaultDeclaration" &&
-            n.declaration.type === "CallExpression");
-        if (!defaultExport || defaultExport.type !== "ExportDefaultDeclaration")
-            return { isEndpoint: false, stream: false };
-        const call = defaultExport.declaration;
-        if (call.type !== "CallExpression" || call.arguments.length === 0)
-            return { isEndpoint: false, stream: false };
-        const arg = call.arguments[0];
-        // `createEndpoint(config)` — anything else defaulting out of src/api/ is
-        // not an endpoint we can type a caller for.
-        if (arg.type !== "ObjectExpression")
-            return { isEndpoint: false, stream: false };
-        const streamProp = arg.properties.find((p) => p.type === "ObjectProperty" &&
-            ((p.key.type === "Identifier" && p.key.name === "stream") ||
-                (p.key.type === "StringLiteral" && p.key.value === "stream")));
-        const stream = !!streamProp &&
-            streamProp.type === "ObjectProperty" &&
-            streamProp.value.type === "BooleanLiteral" &&
-            streamProp.value.value === true;
-        return { isEndpoint: true, stream };
+        ast = parse(source, { sourceType: "module", plugins: ["typescript"] });
     }
     catch {
-        // A file that doesn't parse can't be typed either. Leaving it out keeps
-        // one broken file from taking the whole generated module down with it.
-        return { isEndpoint: false, stream: false };
+        // Unparseable with a TS-only plugin set — most likely TSX, which is still
+        // a real endpoint file. Assume yes and let the app's own typecheck judge
+        // it, rather than dropping a route the bundler will deploy regardless.
+        return { isEndpoint: true, hasDefaultExport: true, stream: false };
     }
+    const body = ast.program.body;
+    const hasDefaultExport = body.some((n) => n.type === "ExportDefaultDeclaration" ||
+        (n.type === "ExportNamedDeclaration" &&
+            n.specifiers?.some((spec) => spec.type === "ExportSpecifier" &&
+                (spec.exported.type === "Identifier"
+                    ? spec.exported.name
+                    : spec.exported.value) === "default")));
+    const isEndpoint = hasDefaultExport || body.some(callsCreateEndpoint);
+    if (!isEndpoint)
+        return NOT_AN_ENDPOINT;
+    // Stream detection is best-effort on the literal config: it is the only
+    // shape we can read `stream: true` out of statically.
+    const defaultExport = body.find((n) => n.type === "ExportDefaultDeclaration");
+    const call = defaultExport
+        ? unwrapExpression(defaultExport.declaration)
+        : undefined;
+    const arg = call?.type === "CallExpression"
+        ? unwrapExpression(call.arguments?.[0] ?? {})
+        : undefined;
+    if (arg?.type !== "ObjectExpression") {
+        return { isEndpoint, hasDefaultExport, stream: false };
+    }
+    const streamProp = arg.properties.find((prop) => prop.type === "ObjectProperty" &&
+        ((prop.key?.type === "Identifier" && prop.key.name === "stream") ||
+            (prop.key?.type === "StringLiteral" && prop.key.value === "stream")));
+    const stream = streamProp?.value?.type === "BooleanLiteral" &&
+        streamProp.value.value === true;
+    return { isEndpoint, hasDefaultExport, stream };
 }
 /**
  * Reserved words can't be `const` names. The route is the filename either way,
@@ -546,8 +603,9 @@ export function generateApiTs(endpointFiles) {
         const ident = toSafeIdentifier(key);
         // Distinct files can collide on one identifier (`send-email.ts` and
         // `send_email.ts` both camelCase to `sendEmail`), which used to emit the
-        // same `export const` twice. Input is sorted by every caller, so first-wins
-        // is stable across runs.
+        // same `export const` twice. First-wins, which is stable because every
+        // caller sorts its input before calling — the two in this package and
+        // `generateApiClient` in the backend's migration assembler.
         if (seenIdents.has(ident)) {
             skipped.push(`${fileName} (name collides with '${ident}')`);
             continue;
@@ -559,6 +617,9 @@ export function generateApiTs(endpointFiles) {
             ident,
             pascal: toPascalCase(key),
             stream: shape?.stream ?? false,
+            // No content to inspect means a bare-filename caller, which historically
+            // assumed a default export — keep that assumption.
+            typed: shape ? shape.hasDefaultExport : true,
         });
     }
     if (endpoints.length === 0)
@@ -578,11 +639,24 @@ export function generateApiTs(endpointFiles) {
             lines.push(`//   ${name}`);
         lines.push("");
     }
-    for (const { pascal, baseName } of endpoints) {
+    for (const { pascal, baseName, typed } of endpoints) {
+        if (!typed)
+            continue;
         lines.push(`import type { default as _${pascal}Ep } from '../src/api/${baseName}';`);
     }
     lines.push("");
-    for (const { baseName, ident, pascal, stream } of endpoints) {
+    for (const { baseName, ident, pascal, stream, typed } of endpoints) {
+        if (!typed) {
+            // Declared with `export const x = createEndpoint(...)` — the 1.0 shape.
+            // The route is real and the bundler deploys it, so the caller has to
+            // exist; there is just no default export to read its types from.
+            lines.push(`// '${baseName}' has no default export, so its input/output are untyped.`);
+            lines.push(`export type ${pascal}InputType = unknown;`);
+            lines.push(`export type ${pascal}OutputType = unknown;`);
+            lines.push(`export const ${ident} = ${stream ? "createStreamingCaller" : "createCaller"}<${pascal}InputType, ${pascal}OutputType>('${baseName}');`);
+            lines.push("");
+            continue;
+        }
         lines.push(`type _${pascal}Cfg = typeof _${pascal}Ep;`);
         // A caller sends the schema's INPUT type, not its output: a field with a
         // `.default()` or a transform is optional to send and guaranteed on the
@@ -829,12 +903,14 @@ export function generateAirtableTs(lock) {
         "//   Fields marked \"Links to X\" hold Airtable record ids (rec...) from",
         "//   findOne/findAll — never invent one.",
         "//   Read-only fields are absent from the *RecordInput types: Airtable rejects a",
-        "//   write to a formula, rollup, lookup or autonumber with a 422.",
+        "//   write to a computed one (formula, rollup, lookup, autonumber, the created/",
+        "//   modified metadata, button, aiText) with a 422.",
         "//",
         "// Usage tips:",
         "//   - Airtable has a strict rate limit of 5 requests/second per base",
-        "//   - Use bulkCreate() instead of calling create() in a loop. Pass any number of",
-        "//     records — it chunks into Airtable's 10-per-request batches for you",
+        "//   - Use bulkCreate() instead of calling create() in a loop, but chunk it",
+        "//     yourself: Airtable rejects more than 10 records in one create request",
+        "//     with a 422, and not every runtime path batches for you",
         "//   - findAll() offsets are opaque cursor strings from a previous call, NOT row",
         "//     counts (unlike zite.<table>.findAll, whose offset IS a number)",
         "//   - Always destructure record properties individually in create/update calls",
@@ -896,13 +972,31 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteWebhook };",
+        // The pre-monorepo SDK put this in scope for every endpoint, so migrated
+        // code can name it. `createEndpoint` infers the same thing without it.
+        "export type InferSchemaType<T> = T extends { _output: infer U } ? U : T;",
         "",
         "export class ZiteError extends Error {",
         "  code: ZiteErrorCode;",
-        "  constructor(options: { code: ZiteErrorCode; message: string }) {",
-        "    super(options.message);",
+        "  /** Short, non-technical message suitable for showing to an end user. */",
+        "  userFacingMessage?: string;",
+        "  // Both shapes, mirroring the worker's own class: object form preferred,",
+        "  // positional form is what pre-monorepo app code was written against.",
+        "  constructor(options: { code: ZiteErrorCode; message: string; userFacingMessage?: string });",
+        "  constructor(message: string, code?: ZiteErrorCode);",
+        "  constructor(",
+        "    optionsOrMessage: { code: ZiteErrorCode; message: string; userFacingMessage?: string } | string,",
+        "    legacyCode?: ZiteErrorCode,",
+        "  ) {",
+        "    if (typeof optionsOrMessage === 'string') {",
+        "      super(optionsOrMessage);",
+        "      this.code = legacyCode ?? 'INTERNAL_ERROR';",
+        "    } else {",
+        "      super(optionsOrMessage.message);",
+        "      this.code = optionsOrMessage.code;",
+        "      this.userFacingMessage = optionsOrMessage.userFacingMessage;",
+        "    }",
         "    this.name = 'ZiteError';",
-        "    this.code = options.code;",
         "  }",
         "}",
         "",
@@ -918,7 +1012,7 @@ export function generateBackendWrapperTs(envVarNames = []) {
         // TStream mirrors zitejs/backend/base. Without it `stream: true` endpoints
         // get no `stream` argument here — and this wrapper, not the base module, is
         // what `zitejs/backend` resolves to in every app.
-        "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput> {",
+        "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {",
         "  description?: string;",
         "  inputSchema?: SchemaLike<TInput, TRawInput>;",
         "  outputSchema?: SchemaLike<TOutput>;",
@@ -926,18 +1020,19 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "  authenticated?: boolean;",
         "  /** When set, the endpoint also fires on this cron schedule. It stays request-callable — declaring one widens `context`, so `context.user` must be null-checked. */",
         "  schedule?: TSchedule;",
-        "  webhook?: ZiteWebhook;",
+        "  /** When set, an inbound webhook can also trigger this endpoint. Like `schedule`, it widens `context` — a webhook fire has no session. */",
+        "  webhook?: TWebhook;",
         "  execute: (",
         "    params: {",
         "      input: TInput;",
-        "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
+        "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
         "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}),",
         "  ) => Promise<TOutput> | TOutput;",
         "}",
         "",
-        "export function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput>(",
-        "  config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>,",
-        "): EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput> {",
+        "export function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput>(",
+        "  config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>,",
+        "): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput> {",
         "  return config;",
         "}",
         "",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zitejs",
-  "version": "0.9.95",
-  "description": "The Zite framework — build apps on Zite Database",
+  "version": "0.9.96",
+  "description": "The Zite framework \u2014 build apps on Zite Database",
   "type": "module",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",