zitejs 0.10.0-start.6 → 0.10.0-start.8

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

@@ -23,6 +23,8 @@ export type ZiteTrigger = {
     paused?: boolean;
     every?: never;
     events?: never;
+    table?: never;
+    form?: never;
 } | {
     /**
      * The connection's name in `zite.config.json`, for a provider whose
@@ -37,6 +39,8 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     every?: never;
+    table?: never;
+    form?: never;
 } | {
     /** `<n>m` (1–59) or `<n>h` (1–23). What makes the trigger a poll. */
     every: string;
@@ -46,6 +50,78 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     events?: never;
+    table?: never;
+    form?: never;
+} | {
+    /**
+     * A table in the project's own database, as `zite.<table>` names it.
+     * Every write to it reaches the trigger, from apps, forms, imports, the
+     * database view and other automations; nothing is registered.
+     */
+    table: string;
+    on: ZiteDatabaseTriggerEvent[];
+    /** Narrows `"updated"` to updates that changed one of these fields. */
+    fields?: string[];
+    /** The sentence the editor shows, e.g. "When an order ships". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    form?: never;
+} | {
+    /**
+     * One of the project's own Fillout forms, by its name as the project
+     * lists it, or its id. Each finished live submission fires the
+     * endpoint; nothing is registered.
+     */
+    form: string;
+    on: "submitted"[];
+    /** The sentence the editor shows, e.g. "When someone fills in the intake form". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    table?: never;
+};
+/**
+ * What a form trigger's run gets as `input`: one submission. `answers` is
+ * keyed by question name, `answersById` by question id; `submission` is the
+ * whole export, as the Fillout API returns it (`questions`, `calculations`,
+ * `urlParameters`, …). Two questions with the same label are named
+ * `Email` and `Email (1)` in an order the form doesn't show, so read those by
+ * id.
+ */
+export type ZiteFormTriggerInput = {
+    event: "submitted";
+    form: string;
+    formId: string;
+    submissionId: string;
+    submittedAt: string | null;
+    answers: Record<string, unknown>;
+    answersById: Record<string, unknown>;
+    submission: Record<string, unknown> & {
+        submissionId: string;
+    };
+};
+export type ZiteDatabaseTriggerEvent = "created" | "updated" | "deleted";
+/**
+ * What a database trigger's run gets as `input`: one changed record. Field
+ * keys are the SDK's, as `zite.<table>.findOne` returns them; cast `record`
+ * and `previous` to the table's generated `<Table>RecordType` from
+ * `zitejs/db` to type their fields.
+ */
+export type ZiteDatabaseTriggerInput<TRecord extends Record<string, unknown> = Record<string, unknown>> = {
+    event: ZiteDatabaseTriggerEvent;
+    table: string;
+    recordId: string;
+    /** Null if it was deleted before the run read it; on `"deleted"`, the record as it was. */
+    record: TRecord | null;
+    /** The record before an `"updated"`; null otherwise, and on a very large bulk write. */
+    previous: TRecord | null;
+    /** What an `"updated"` changed. */
+    changedFields: string[];
 };
 /**
  * What a provider trigger's `subscribe` export receives. Write it as
@@ -115,10 +191,20 @@ export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
 export type ZiteTriggerContext<TTrigger> = TTrigger extends {
     every: string;
 } ? ZiteTriggerRun : TTrigger extends {
+    table: string;
+} | {
+    form: string;
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
     events: string[];
 } ? ZiteTriggerDeliveryInfo : TTrigger extends {
     integration: string;
 } ? ZiteTriggerDeliveryRun : never;
+/** A database or form trigger's runs get the change or submission as `input`. */
+export type ZiteEndpointInput<TInput, TTrigger> = TTrigger extends {
+    table: string;
+} ? ZiteDatabaseTriggerInput : TTrigger extends {
+    form: string;
+} ? ZiteFormTriggerInput : TInput;
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -215,13 +301,15 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TInput;
+        input: ZiteEndpointInput<TInput, TTrigger>;
         /**
          * Durable steps. `step.run(name, fn)` runs `fn` once per logical run:
          * its result is saved before anything after it executes, and when a
          * failed run is resumed, completed steps return their saved results
          * instead of re-running their side effects. Names must be unique within
-         * a run, and results must be plain JSON data under 256KB.
+         * a run, and results must be plain JSON data under 256KB. In a run
+         * fired by a schedule, webhook or trigger, `step.sleep` pauses the run
+         * and a failed step is tried again.
          */
         step: ZiteStep;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
@@ -240,8 +328,32 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
  * it would matter, and give a step inside a loop the item's id in its name.
  */
 export interface ZiteStep {
-    run<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+    /**
+     * In a run fired by a schedule, webhook or trigger, a step that throws is
+     * tried again `retries` more times (default 3, at most 10), 30 seconds,
+     * 2 minutes, then 10 minutes apart. Elsewhere its error fails the request.
+     */
+    run<T>(name: string, fn: () => Promise<T> | T, options?: ZiteStepOptions): Promise<T>;
+    /**
+     * Pause the run for `duration`: `"30s"`, `"15m"`, `"2h"`, `"3d"`, `"1w"`,
+     * or milliseconds, at most 30 days. Only a run fired by a schedule, webhook
+     * or trigger can wait; an editor test run goes straight past, and a request
+     * from the app throws.
+     *
+     * The run continues in a later call, which runs `execute` again from the
+     * top: finished steps return their saved results, and code outside a step
+     * runs again, so keep side effects inside steps.
+     */
+    sleep(name: string, duration: ZiteStepDuration): Promise<void>;
+    /** Pause the run until `when`, at most 30 days ahead. See {@link ZiteStep.sleep}. */
+    sleepUntil(name: string, when: Date | string): Promise<void>;
+}
+export interface ZiteStepOptions {
+    /** How many more times to try the step after it throws: 0 to 10, default 3. */
+    retries?: number;
 }
+/** Milliseconds, or a number with a unit: `ms`, `s`, `m`, `h`, `d` or `w`. */
+export type ZiteStepDuration = number | `${number}${"ms" | "s" | "m" | "h" | "d" | "w"}`;
 /**
  * Create an endpoint definition, parsing `input` against `inputSchema` before
  * `execute` runs. Nothing downstream parses it — the worker calls `execute` on

package/dist/cjs/backend/index.test.js

@@ -8,6 +8,8 @@ const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
 // Direct execute() calls need the step surface the runtime always provides.
 const stepStub = {
     run: async (_name, fn) => await fn(),
+    sleep: async () => { },
+    sleepUntil: async () => { },
 };
 (0, vitest_1.afterEach)(() => {
     vitest_1.vi.unstubAllGlobals();
@@ -207,6 +209,62 @@ const stepStub = {
                 return params.trigger;
             },
         });
+        (0, index_js_1.createEndpoint)({
+            trigger: { table: "orders", on: ["updated"], fields: ["status"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a database change has no cursor API
+                trigger?.advance("x");
+                const status = input.record?.status;
+                return { status, changed: input.changedFields, at: input.event };
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error a database trigger names its table, not a connection
+            trigger: { table: "orders", on: ["created"], integration: "x" },
+            execute: async () => 1,
+        });
+        (0, index_js_1.createEndpoint)({
+            trigger: { form: "Intake form", on: ["submitted"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a form submission has no cursor API
+                trigger?.advance("x");
+                return {
+                    email: input.answers.Email,
+                    workEmail: input.answersById["wWorkEmail"],
+                    id: input.submissionId,
+                };
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error a form trigger watches submissions only
+            trigger: { form: "Intake form", on: ["updated"] },
+            execute: async () => 1,
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error only created, updated and deleted
+            trigger: { table: "orders", on: ["archived"] },
+            execute: async () => 1,
+        });
+    });
+    (0, vitest_1.it)("hands a database trigger its change without parsing it against the input schema", async () => {
+        const endpoint = (0, index_js_1.createEndpoint)({
+            inputSchema: zod_1.z.object({ orderId: zod_1.z.string() }),
+            trigger: { table: "orders", on: ["created"] },
+            execute: async ({ input }) => input.recordId,
+        });
+        await (0, vitest_1.expect)(endpoint.execute({
+            step: stepStub,
+            input: {
+                event: "created",
+                table: "orders",
+                recordId: "rec_1",
+                record: { id: "rec_1" },
+                previous: null,
+                changedFields: [],
+            },
+            context: { user: null },
+            trigger: { headers: {}, deliveryId: "db:e1:rec_1" },
+        })).resolves.toBe("rec_1");
     });
     (0, vitest_1.it)("types a trigger's registration exports and checks what subscribe returns", async () => {
         const subscribe = (async (input) => ({

package/dist/cjs/integrations/rules.d.ts

@@ -38,11 +38,24 @@ declare const FIELDS_BY_TYPE: {
     jira: readonly string[];
     typeform: readonly string[];
     apollo: readonly string[];
+    clay: readonly string[];
     attio: readonly string[];
     granola: readonly string[];
+    clickup: readonly string[];
     dropbox: readonly string[];
+    zendesk: readonly string[];
+    smartsheet: readonly string[];
     amazonS3: readonly string[];
     snowflake: readonly string[];
+    databricks: readonly string[];
+    confluence: readonly string[];
+    pipedrive: readonly string[];
+    shopify: readonly string[];
+    sharepoint: readonly string[];
+    excel: readonly string[];
+    x: readonly string[];
+    zoomMeetings: readonly string[];
+    smartsuite: readonly string[];
 };
 /** A service type `integrations.get` serves: one used through its npm package with a token. */
 export type CredentialServiceType = keyof typeof FIELDS_BY_TYPE;

package/dist/cjs/integrations/rules.js

@@ -47,15 +47,43 @@ const FIELDS_BY_TYPE = {
     jira: extras("cloudId", "siteUrl"),
     typeform: extras(),
     apollo: extras(),
+    clay: extras(),
     attio: extras(),
     granola: extras(),
+    clickup: extras(),
     dropbox: extras(),
+    // Every path is https://{subdomain}.zendesk.com/api/v2/..., and a token is
+    // only valid on the account it was issued for, so the subdomain travels with
+    // it rather than being configured per app.
+    zendesk: extras("subdomain"),
+    // Smartsheet's US, EU, AU and Gov regions are separate, and a token is only
+    // valid on its own region's host, so the host travels with it.
+    smartsheet: extras("apiBaseUrl"),
     // The IAM key alone reaches nothing: every call needs the region and the
     // bucket, and S3-compatible providers need the endpoint too.
     amazonS3: extras("keyId", "region", "bucket", "endpoint", "pathPrefix"),
     // The SQL API lives on each account's own host, and the token is pinned to
     // one role; the warehouse is optional and falls back to the user's default.
     snowflake: extras("accountUrl", "role", "warehouse"),
+    // A statement is addressed by workspace host and SQL warehouse, and the token
+    // derives neither.
+    databricks: extras("host", "warehouseId"),
+    // Cloud Confluence is addressed through api.atlassian.com by cloud id, the
+    // same as Jira; the site URL is only for links a human will click.
+    confluence: extras("cloudId", "siteUrl"),
+    // OAuth returns a per-company api_domain alongside the token, so there is no
+    // one host to call.
+    pipedrive: extras("apiBaseUrl"),
+    // Shopify has no global API host: every call goes to the store's own domain
+    // under a pinned API version. The storefront pair is the shopper-facing API,
+    // which installs predating those scopes do not have.
+    shopify: extras("shopDomain", "apiBaseUrl", "storefrontApiUrl", "storefrontAccessToken"),
+    sharepoint: extras(),
+    excel: extras(),
+    x: extras(),
+    zoomMeetings: extras(),
+    // Every request names the workspace in an Account-Id header beside the key.
+    smartsuite: extras("workspaceId"),
 };
 /** Per service type: `accessToken`, then its extra labels sorted (Salesforce `instanceUrl`). */
 exports.CREDENTIAL_FIELDS = FIELDS_BY_TYPE;
@@ -68,6 +96,7 @@ exports.OPTIONAL_CREDENTIAL_FIELDS = {
     // Only S3-compatible providers set an endpoint, and a prefix is opt-in.
     amazonS3: ["endpoint", "pathPrefix"],
     snowflake: ["warehouse"],
+    shopify: ["storefrontApiUrl", "storefrontAccessToken"],
 };
 /**
  * Types the runtime never serves: those with a generated client (Airtable, email,

package/dist/cjs/integrations/rules.test.js

@@ -18,6 +18,7 @@ const index_js_1 = require("../index.js");
         ]);
         (0, vitest_1.expect)(index_js_1.CREDENTIAL_FIELDS.jira).toEqual(["accessToken", "cloudId", "siteUrl"]);
         (0, vitest_1.expect)(index_js_1.CREDENTIAL_FIELDS.granola).toEqual(["accessToken"]);
+        (0, vitest_1.expect)(index_js_1.CREDENTIAL_FIELDS.smartsheet).toEqual(["accessToken", "apiBaseUrl"]);
     });
     (0, vitest_1.it)("has no type the runtime never serves", () => {
         for (const type of index_js_1.NON_CREDENTIAL_SERVICE_TYPES) {

package/dist/cjs/sync/lib.js

@@ -83,6 +83,7 @@ const FIELD_TYPE_MAP = {
     formula: "any",
     created_at: "string",
     updated_at: "string",
+    created_by: "string",
     updated_by: "string",
 };
 /**
@@ -108,7 +109,7 @@ const FIELD_INPUT_TYPE_MAP = {
  * 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
+ * The first seven 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
@@ -120,6 +121,7 @@ const READ_ONLY_FIELD_TYPES = new Set([
     "source",
     "formula",
     "autonumber",
+    "created_by",
     "updated_by",
     "created_at",
     "updated_at",
@@ -260,13 +262,8 @@ function fieldJsdoc(schemaField, table, schema) {
     const parts = [];
     if (table.primaryFieldId === schemaField.id)
         parts.push("Primary field");
-    if (def.type === "created_at" ||
-        def.type === "updated_at" ||
-        def.type === "lookup" ||
-        def.type === "formula" ||
-        def.type === "autonumber") {
+    if (READ_ONLY_FIELD_TYPES.has(def.type))
         parts.push("Read-only");
-    }
     if (def.type === "linked_record") {
         const tpl = def.template;
         if (tpl.tableId) {
@@ -524,7 +521,7 @@ function generateDbTs(inputSchema) {
     lines.push('//       `not: null` means "is set". An empty `in: []` matches nothing; an', "//       empty `notIn: []` applies no filter.");
     lines.push("//     sort is currently IGNORED here — it is stripped before the request.", "//       (it does work on zite.auth.findAllUsers). Order in SQL instead.");
     lines.push("//     limit defaults to 500, max 2000; offset is a row count (a number)");
-    lines.push('//     a filter value of `undefined` is REJECTED (it would query unfiltered', '//       and match an arbitrary record). Check the value first.');
+    lines.push("//     a filter value of `undefined` is REJECTED (it would query unfiltered", "//       and match an arbitrary record). Check the value first.");
     lines.push("//   .findOne({ id?, filters?, fields? }) → T | undefined");
     lines.push("//   .create({ record }) → T");
     lines.push("//   .update({ id, record }) → { id: string, fields: Partial<T> }");
@@ -1232,13 +1229,13 @@ function generateBackendWrapperTs(envVarNames = []) {
         "// Auto-generated type-narrowing wrapper. Do not edit manually.",
         "// Re-exports createEndpoint with context.user typed to the app User.",
         "",
-        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStep, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteWebhook } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStep, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteEndpointInput, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStep, ZiteStreamInterface, ZiteTrigger, ZiteWebhook };",
         // A trigger's registration exports are typed against these, and they
         // only reach app code through this file.
-        "export type { ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
+        "export type { ZiteDatabaseTriggerEvent, ZiteDatabaseTriggerInput, ZiteFormTriggerInput, ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
         // 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;",
@@ -1326,12 +1323,12 @@ function generateBackendWrapperTs(envVarNames = []) {
         "  schedule?: TSchedule;",
         "  /** When set, an inbound webhook can also trigger this endpoint. Like `schedule`, it widens `context` — a webhook fire has no session. */",
         "  webhook?: TWebhook;",
-        "  /** When set, a connection's events (registered by this file's own `subscribe` export) or a poll (`every`) also fire this endpoint. Like `webhook`, it widens `context` — a trigger fire has no session. */",
+        "  /** When set, a connection's events (registered by this file's own `subscribe` export), a poll (`every`), a change to one of the project's tables (`table`) or a submission to one of its forms (`form`) also fire this endpoint. Like `webhook`, it widens `context` — a trigger fire has no session. */",
         "  trigger?: TTrigger;",
         "  execute: (",
         "    params: {",
-        "      input: TInput;",
-        "      /** Durable steps: step.run(name, fn) runs fn once per logical run — its result is saved before anything after it executes, and a resumed run replays completed steps from their saved results. Provided by the platform; never define a local stand-in. */",
+        "      input: ZiteEndpointInput<TInput, TTrigger>;",
+        "      /** Durable steps: step.run(name, fn) runs fn once per logical run — its result is saved before anything after it executes, and a resumed run replays completed steps from their saved results. In a run fired by a schedule, webhook or trigger, step.sleep(name, \"2d\") pauses the run and a failed step is tried again. Provided by the platform; never define a local stand-in. */",
         "      step: ZiteStep;",
         "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
         // Mirrors the base module: a trigger's run gets `trigger`.

package/dist/cjs/vite/index.js

@@ -75,11 +75,12 @@ function ziteId() {
         name: "vite-plugin-zite-id",
         enforce: "pre",
         async transform(code, id) {
-            if (!validExtensions.has(path_1.default.extname(id)) ||
-                id.includes("node_modules")) {
+            // TanStack's route code splitting moves a route's component into its own module, `route.tsx?tsr-split=…`.
+            const file = id.split("?")[0];
+            if (!validExtensions.has(path_1.default.extname(file)) || file.includes("node_modules")) {
                 return null;
             }
-            const relativePath = path_1.default.relative(cwd, id);
+            const relativePath = path_1.default.relative(cwd, file);
             try {
                 const ast = (0, parser_1.parse)(code, {
                     sourceType: "module",
@@ -134,6 +135,10 @@ function ziteId() {
                             if (!isTagged) {
                                 return;
                             }
+                            // A module split from one already tagged keeps its tags.
+                            if (openingElement.attributes?.some((attr) => attr.type === "JSXAttribute" && attr.name?.name === "data-zite-id")) {
+                                return;
+                            }
                             const line = openingElement.loc?.start?.line ?? 0;
                             const col = openingElement.loc?.start?.column ?? 0;
                             const dataComponentId = `${relativePath}|${line}|${col}`;

package/dist/cjs/vite/index.test.js

@@ -6,16 +6,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const vitest_1 = require("vitest");
 const index_js_1 = require("./index.js");
-async function transform(code) {
+async function transform(code, file = 'src/App.tsx') {
     const plugin = (0, index_js_1.ziteId)();
     const handler = plugin.transform;
-    const result = await handler(code, path_1.default.join(process.cwd(), 'src/App.tsx'));
+    const result = await handler(code, path_1.default.join(process.cwd(), file));
     if (!result) {
         throw new Error('transform returned null');
     }
     return result.code;
 }
 (0, vitest_1.describe)('ziteId', () => {
+    (0, vitest_1.it)("tags a route's component that TanStack split into its own module, by the source file", async () => {
+        const code = await transform('const a = <p>Hi</p>;', 'src/routes/index.tsx?tsr-split=component');
+        (0, vitest_1.expect)(code).toContain('<p data-zite-id="src/routes/index.tsx|1|10" data-zite-editable="true">');
+    });
+    (0, vitest_1.it)('leaves an element that already has its tag', async () => {
+        const code = await transform('const a = <p data-zite-id="src/routes/index.tsx|1|10">Hi</p>;');
+        (0, vitest_1.expect)(code.match(/data-zite-id/g)).toHaveLength(1);
+    });
     (0, vitest_1.it)('tags html and svg elements without a component name', async () => {
         const code = await transform('const a = <div><svg><path d="M0" /></svg><p>Hello</p></div>;');
         (0, vitest_1.expect)(code).toContain('<div data-zite-id="src/App.tsx|1|10">');

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

@@ -23,6 +23,8 @@ export type ZiteTrigger = {
     paused?: boolean;
     every?: never;
     events?: never;
+    table?: never;
+    form?: never;
 } | {
     /**
      * The connection's name in `zite.config.json`, for a provider whose
@@ -37,6 +39,8 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     every?: never;
+    table?: never;
+    form?: never;
 } | {
     /** `<n>m` (1–59) or `<n>h` (1–23). What makes the trigger a poll. */
     every: string;
@@ -46,6 +50,78 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     events?: never;
+    table?: never;
+    form?: never;
+} | {
+    /**
+     * A table in the project's own database, as `zite.<table>` names it.
+     * Every write to it reaches the trigger, from apps, forms, imports, the
+     * database view and other automations; nothing is registered.
+     */
+    table: string;
+    on: ZiteDatabaseTriggerEvent[];
+    /** Narrows `"updated"` to updates that changed one of these fields. */
+    fields?: string[];
+    /** The sentence the editor shows, e.g. "When an order ships". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    form?: never;
+} | {
+    /**
+     * One of the project's own Fillout forms, by its name as the project
+     * lists it, or its id. Each finished live submission fires the
+     * endpoint; nothing is registered.
+     */
+    form: string;
+    on: "submitted"[];
+    /** The sentence the editor shows, e.g. "When someone fills in the intake form". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    table?: never;
+};
+/**
+ * What a form trigger's run gets as `input`: one submission. `answers` is
+ * keyed by question name, `answersById` by question id; `submission` is the
+ * whole export, as the Fillout API returns it (`questions`, `calculations`,
+ * `urlParameters`, …). Two questions with the same label are named
+ * `Email` and `Email (1)` in an order the form doesn't show, so read those by
+ * id.
+ */
+export type ZiteFormTriggerInput = {
+    event: "submitted";
+    form: string;
+    formId: string;
+    submissionId: string;
+    submittedAt: string | null;
+    answers: Record<string, unknown>;
+    answersById: Record<string, unknown>;
+    submission: Record<string, unknown> & {
+        submissionId: string;
+    };
+};
+export type ZiteDatabaseTriggerEvent = "created" | "updated" | "deleted";
+/**
+ * What a database trigger's run gets as `input`: one changed record. Field
+ * keys are the SDK's, as `zite.<table>.findOne` returns them; cast `record`
+ * and `previous` to the table's generated `<Table>RecordType` from
+ * `zitejs/db` to type their fields.
+ */
+export type ZiteDatabaseTriggerInput<TRecord extends Record<string, unknown> = Record<string, unknown>> = {
+    event: ZiteDatabaseTriggerEvent;
+    table: string;
+    recordId: string;
+    /** Null if it was deleted before the run read it; on `"deleted"`, the record as it was. */
+    record: TRecord | null;
+    /** The record before an `"updated"`; null otherwise, and on a very large bulk write. */
+    previous: TRecord | null;
+    /** What an `"updated"` changed. */
+    changedFields: string[];
 };
 /**
  * What a provider trigger's `subscribe` export receives. Write it as
@@ -115,10 +191,20 @@ export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
 export type ZiteTriggerContext<TTrigger> = TTrigger extends {
     every: string;
 } ? ZiteTriggerRun : TTrigger extends {
+    table: string;
+} | {
+    form: string;
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
     events: string[];
 } ? ZiteTriggerDeliveryInfo : TTrigger extends {
     integration: string;
 } ? ZiteTriggerDeliveryRun : never;
+/** A database or form trigger's runs get the change or submission as `input`. */
+export type ZiteEndpointInput<TInput, TTrigger> = TTrigger extends {
+    table: string;
+} ? ZiteDatabaseTriggerInput : TTrigger extends {
+    form: string;
+} ? ZiteFormTriggerInput : TInput;
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -215,13 +301,15 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TInput;
+        input: ZiteEndpointInput<TInput, TTrigger>;
         /**
          * Durable steps. `step.run(name, fn)` runs `fn` once per logical run:
          * its result is saved before anything after it executes, and when a
          * failed run is resumed, completed steps return their saved results
          * instead of re-running their side effects. Names must be unique within
-         * a run, and results must be plain JSON data under 256KB.
+         * a run, and results must be plain JSON data under 256KB. In a run
+         * fired by a schedule, webhook or trigger, `step.sleep` pauses the run
+         * and a failed step is tried again.
          */
         step: ZiteStep;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
@@ -240,8 +328,32 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
  * it would matter, and give a step inside a loop the item's id in its name.
  */
 export interface ZiteStep {
-    run<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+    /**
+     * In a run fired by a schedule, webhook or trigger, a step that throws is
+     * tried again `retries` more times (default 3, at most 10), 30 seconds,
+     * 2 minutes, then 10 minutes apart. Elsewhere its error fails the request.
+     */
+    run<T>(name: string, fn: () => Promise<T> | T, options?: ZiteStepOptions): Promise<T>;
+    /**
+     * Pause the run for `duration`: `"30s"`, `"15m"`, `"2h"`, `"3d"`, `"1w"`,
+     * or milliseconds, at most 30 days. Only a run fired by a schedule, webhook
+     * or trigger can wait; an editor test run goes straight past, and a request
+     * from the app throws.
+     *
+     * The run continues in a later call, which runs `execute` again from the
+     * top: finished steps return their saved results, and code outside a step
+     * runs again, so keep side effects inside steps.
+     */
+    sleep(name: string, duration: ZiteStepDuration): Promise<void>;
+    /** Pause the run until `when`, at most 30 days ahead. See {@link ZiteStep.sleep}. */
+    sleepUntil(name: string, when: Date | string): Promise<void>;
+}
+export interface ZiteStepOptions {
+    /** How many more times to try the step after it throws: 0 to 10, default 3. */
+    retries?: number;
 }
+/** Milliseconds, or a number with a unit: `ms`, `s`, `m`, `h`, `d` or `w`. */
+export type ZiteStepDuration = number | `${number}${"ms" | "s" | "m" | "h" | "d" | "w"}`;
 /**
  * Create an endpoint definition, parsing `input` against `inputSchema` before
  * `execute` runs. Nothing downstream parses it — the worker calls `execute` on