zitejs 0.9.134 → 0.9.135

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

@@ -7,8 +7,8 @@ export type ZiteWebhook = {
  * A provider trigger: what should fire the endpoint, declared as a literal.
  * The platform registers it with the provider at publish, verifies each
  * delivery and queues it; the endpoint only sees the payload. A `poll`
- * trigger runs the endpoint on a cadence with `input.__poll.cursor` from the
- * previous run, and the endpoint returns `{ cursor }` to advance it.
+ * trigger runs the endpoint on a cadence. Either way `execute` gets `trigger`
+ * ({@link ZiteTriggerContext}) to read the cursor and record what it handled.
  */
 export type ZiteTrigger = {
     /**
@@ -86,45 +86,39 @@ export type ZiteTriggerUnsubscribeInput = {
 };
 export type ZiteTriggerSubscribe = (input: ZiteTriggerSubscribeInput) => Promise<ZiteTriggerSubscribeResult> | ZiteTriggerSubscribeResult;
 export type ZiteTriggerUnsubscribe = (input: ZiteTriggerUnsubscribeInput) => Promise<void> | void;
-/**
- * What a poll-triggered run receives as `input.__poll`. Only on a fire from
- * the poll's schedule; a request call to the same endpoint carries none.
- */
-export type ZitePollInput = {
-    /** What the previous successful run returned as `cursor`; null on the first run. */
-    cursor: string | null;
-    /** Ids earlier runs returned as `handled`, newest last. Skip these. */
-    seen: string[];
-};
-/**
- * What a provider trigger's delivery carries as `input.__webhook`, beside the
- * provider's own body. `cursor` and `seen` work as they do for a poll: for a
- * provider whose notification only says that something changed, `subscribe`
- * returns a starting `cursor` and each delivery returns the next one. A
- * trigger that keeps a cursor gets one delivery at a time.
- */
-export type ZiteTriggerDelivery = {
+/** Where a provider delivery came from; app event triggers get only this. */
+export type ZiteTriggerDeliveryInfo = {
+    /** The delivery's headers, lowercased. */
     headers: Record<string, string>;
     /** The provider's id for this delivery; redeliveries share it. */
     deliveryId?: string;
     provider?: string;
-    /** What `subscribe` or the previous successful delivery returned as `cursor`. */
-    cursor: string | null;
-    /** Ids earlier deliveries returned as `handled`, newest last. Skip these. */
-    seen: string[];
 };
-/** What an app event trigger's run carries as `input.__webhook`: one event, no cursor. */
-export type ZiteAppEventDelivery = Omit<ZiteTriggerDelivery, "cursor" | "seen">;
 /**
- * What a poll-triggered run, or a provider trigger's delivery, returns for
- * the platform to keep: its new `cursor`, and the id of every item it acted
- * on, so the next run's `seen` includes them even if the cursor hands them
- * back.
+ * What a poll run, or a provider trigger's delivery, gets as `trigger`. Record
+ * each item acted on with `handled` as you go: it is kept even if the run
+ * later throws, so the next run skips it. The cursor staged with `advance` is
+ * committed only when the run succeeds.
  */
-export type ZitePollResult = {
-    cursor?: string;
-    handled?: string[];
+export type ZiteTriggerRun = {
+    /** The last committed cursor: what `subscribe` returned, or the last successful run's `advance`. Null when there is none yet. */
+    cursor: string | null;
+    /** Whether an earlier run, or this one, recorded `id` as handled. */
+    seen(id: string): boolean;
+    /** Record an item as acted on (1 to 512 characters). */
+    handled(id: string): void;
+    /** Stage the next cursor (at most 4096 characters). The last call wins. */
+    advance(cursor: string): void;
 };
+export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
+/** The `trigger` param for an endpoint declaring `TTrigger`. */
+export type ZiteTriggerContext<TTrigger> = TTrigger extends {
+    every: string;
+} ? ZiteTriggerRun : TTrigger extends {
+    events: string[];
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
+    integration: string;
+} ? ZiteTriggerDeliveryRun : never;
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -221,22 +215,12 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TTrigger extends {
-            every: string;
-        } ? TInput & {
-            __poll?: ZitePollInput;
-        } : TTrigger extends {
-            events: string[];
-        } ? TInput & {
-            __webhook?: ZiteAppEventDelivery;
-        } : TTrigger extends {
-            integration: string;
-        } ? TInput & {
-            __webhook?: ZiteTriggerDelivery;
-        } : TInput;
+        input: TInput;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
+    } : {}) & (TTrigger extends ZiteTrigger ? {
+        trigger?: ZiteTriggerContext<TTrigger>;
     } : {})) => Promise<TOutput> | TOutput;
 }
 /**

package/dist/cjs/backend/index.js

@@ -74,6 +74,10 @@ function createEndpoint(config) {
             // request callers doesn't describe them.
             if (isPlatformTriggeredInput(params.input))
                 return execute(params);
+            // A trigger's run carries the provider's body, not a request's input.
+            if (params.trigger !== undefined) {
+                return execute(params);
+            }
             // Same, for a fire with no input object to hold the sentinel: the runner
             // only merges `__cron` into a plain object.
             if (firesWithoutARequest && params.input === undefined) {

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

@@ -133,28 +133,51 @@ const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
         });
         await (0, vitest_1.expect)(endpoint.execute({ input: undefined, context: requestContext })).rejects.toMatchObject({ code: "BAD_REQUEST" });
     });
-    (0, vitest_1.it)("hands a poll its cursor and seen ids, typed", async () => {
+    (0, vitest_1.it)("hands a poll a typed trigger and skips the input schema for it", async () => {
+        const handled = [];
         const endpoint = (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({}),
+            inputSchema: zod_1.z.object({ required: zod_1.z.string() }),
             trigger: { every: "5m", integration: "stripe" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__poll?.seen);
-                const items = ["a", "b"].filter((id) => !seen.has(id));
-                return { cursor: input.__poll?.cursor ?? "start", handled: items };
+            execute: async ({ trigger }) => {
+                if (!trigger)
+                    return { ran: 0 };
+                const fresh = ["a", "b"].filter((id) => !trigger.seen(id));
+                for (const id of fresh)
+                    trigger.handled(id);
+                trigger.advance("c2");
+                return { ran: fresh.length, from: trigger.cursor };
             },
         });
+        const seen = new Set(["a"]);
         await (0, vitest_1.expect)(endpoint.execute({
-            input: { __poll: { cursor: "c1", seen: ["a"] } },
+            input: {},
             context: { user: null },
-        })).resolves.toEqual({ cursor: "c1", handled: ["b"] });
+            trigger: {
+                cursor: "c1",
+                seen: (id) => seen.has(id),
+                handled: (id) => void handled.push(id),
+                advance: () => { },
+            },
+        })).resolves.toEqual({ ran: 1, from: "c1" });
+        (0, vitest_1.expect)(handled).toEqual(["b"]);
     });
-    (0, vitest_1.it)("gives __poll only to poll triggers", () => {
+    (0, vitest_1.it)("types trigger by the declared kind", () => {
         (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({ action: zod_1.z.string() }),
             trigger: { integration: "github" },
-            execute: async ({ input }) => {
-                // @ts-expect-error a provider trigger's input has no __poll
-                return input.__poll;
+            execute: async ({ trigger }) => trigger?.deliveryId ?? trigger?.cursor,
+        });
+        (0, index_js_1.createEndpoint)({
+            trigger: { integration: "team-slack", events: ["message.channels"] },
+            execute: async ({ trigger }) => {
+                // @ts-expect-error an app event has no cursor API
+                trigger?.advance("x");
+                return trigger?.headers;
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            execute: async (params) => {
+                // @ts-expect-error a plain endpoint gets no trigger
+                return params.trigger;
             },
         });
     });
@@ -184,40 +207,28 @@ const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
             endpointId: "onPush",
         });
     });
-    (0, vitest_1.it)("hands a provider trigger's delivery its cursor and seen ids, typed", async () => {
+    (0, vitest_1.it)("hands a provider delivery its body as input and the cursor API on trigger", async () => {
         const endpoint = (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({}),
+            inputSchema: zod_1.z.object({ required: zod_1.z.string() }),
             trigger: { integration: "googleCalendar" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__webhook?.seen);
-                const changed = ["e1", "e2"].filter((id) => !seen.has(id));
-                return { cursor: `${input.__webhook?.cursor}+1`, handled: changed };
-            },
+            execute: async ({ input, trigger }) => ({
+                body: input,
+                cursor: trigger?.cursor,
+                delivery: trigger?.deliveryId,
+            }),
         });
         await (0, vitest_1.expect)(endpoint.execute({
-            input: {
-                __webhook: { headers: {}, cursor: "sync1", seen: ["e1"] },
-            },
+            input: { kind: "sync" },
             context: { user: null },
-        })).resolves.toEqual({ cursor: "sync1+1", handled: ["e2"] });
-    });
-    (0, vitest_1.it)("types an app event trigger's run as one event, with no cursor to keep", async () => {
-        const endpoint = (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({ event: zod_1.z.object({ text: zod_1.z.string() }) }),
-            trigger: { integration: "team-slack", events: ["message.channels"] },
-            execute: async ({ input }) => {
-                // @ts-expect-error an app event delivery has no cursor
-                void input.__webhook?.cursor;
-                return { id: input.__webhook?.deliveryId ?? null };
-            },
-        });
-        await (0, vitest_1.expect)(endpoint.execute({
-            input: {
-                event: { text: "hi" },
-                __webhook: { headers: {}, deliveryId: "slack:Ev1" },
+            trigger: {
+                cursor: "sync1",
+                seen: () => false,
+                handled: () => { },
+                advance: () => { },
+                headers: {},
+                deliveryId: "chan:2",
             },
-            context: { user: null },
-        })).resolves.toEqual({ id: "slack:Ev1" });
+        })).resolves.toEqual({ body: { kind: "sync" }, cursor: "sync1", delivery: "chan:2" });
     });
     (0, vitest_1.it)("refuses events on a trigger that also polls", () => {
         (0, index_js_1.createEndpoint)({

package/dist/cjs/sync/lib.js

@@ -1232,13 +1232,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, ZiteStreamInterface, ZiteTrigger, ZiteTriggerDelivery, ZiteAppEventDelivery, ZitePollInput, ZiteWebhook } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteTrigger, ZiteWebhook };",
         // A trigger's registration exports are typed against these, and they
         // only reach app code through this file.
-        "export type { ZiteAppEventDelivery, ZitePollInput, ZitePollResult, ZiteTriggerDelivery, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
+        "export type { 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;",
@@ -1330,11 +1330,10 @@ function generateBackendWrapperTs(envVarNames = []) {
         "  trigger?: TTrigger;",
         "  execute: (",
         "    params: {",
-        // Mirrors the base module: a poll's run carries `__poll`, a provider
-        // trigger's delivery `__webhook`.
-        "      input: TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput } : TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery } : TTrigger extends { integration: string } ? TInput & { __webhook?: ZiteTriggerDelivery } : TInput;",
+        "      input: TInput;",
         "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
-        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}),",
+        // Mirrors the base module: a trigger's run gets `trigger`.
+        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}) & (TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {}),",
         "  ) => Promise<TOutput> | TOutput;",
         "}",
         "",

package/dist/cjs/sync/lib.test.js

@@ -390,9 +390,9 @@ const duplicateIdentifierErrorsIn = (source) => {
     (0, vitest_1.it)('passes the trigger registration types and trigger inputs through to app code', () => {
         (0, vitest_1.expect)(output).toContain('ZiteTriggerSubscribe, ZiteTriggerSubscribeInput');
         (0, vitest_1.expect)(output).toContain('ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput');
-        (0, vitest_1.expect)(output).toContain("TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput }");
-        (0, vitest_1.expect)(output).toContain('TInput & { __webhook?: ZiteTriggerDelivery }');
-        (0, vitest_1.expect)(output).toContain("TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery }");
+        (0, vitest_1.expect)(output).toContain('ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun');
+        (0, vitest_1.expect)(output).toContain('(TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {})');
+        (0, vitest_1.expect)(output).not.toContain('__poll');
         (0, vitest_1.expect)(output).not.toContain('src/triggers/');
     });
     (0, vitest_1.it)('exports ZiteError', () => {

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

@@ -7,8 +7,8 @@ export type ZiteWebhook = {
  * A provider trigger: what should fire the endpoint, declared as a literal.
  * The platform registers it with the provider at publish, verifies each
  * delivery and queues it; the endpoint only sees the payload. A `poll`
- * trigger runs the endpoint on a cadence with `input.__poll.cursor` from the
- * previous run, and the endpoint returns `{ cursor }` to advance it.
+ * trigger runs the endpoint on a cadence. Either way `execute` gets `trigger`
+ * ({@link ZiteTriggerContext}) to read the cursor and record what it handled.
  */
 export type ZiteTrigger = {
     /**
@@ -86,45 +86,39 @@ export type ZiteTriggerUnsubscribeInput = {
 };
 export type ZiteTriggerSubscribe = (input: ZiteTriggerSubscribeInput) => Promise<ZiteTriggerSubscribeResult> | ZiteTriggerSubscribeResult;
 export type ZiteTriggerUnsubscribe = (input: ZiteTriggerUnsubscribeInput) => Promise<void> | void;
-/**
- * What a poll-triggered run receives as `input.__poll`. Only on a fire from
- * the poll's schedule; a request call to the same endpoint carries none.
- */
-export type ZitePollInput = {
-    /** What the previous successful run returned as `cursor`; null on the first run. */
-    cursor: string | null;
-    /** Ids earlier runs returned as `handled`, newest last. Skip these. */
-    seen: string[];
-};
-/**
- * What a provider trigger's delivery carries as `input.__webhook`, beside the
- * provider's own body. `cursor` and `seen` work as they do for a poll: for a
- * provider whose notification only says that something changed, `subscribe`
- * returns a starting `cursor` and each delivery returns the next one. A
- * trigger that keeps a cursor gets one delivery at a time.
- */
-export type ZiteTriggerDelivery = {
+/** Where a provider delivery came from; app event triggers get only this. */
+export type ZiteTriggerDeliveryInfo = {
+    /** The delivery's headers, lowercased. */
     headers: Record<string, string>;
     /** The provider's id for this delivery; redeliveries share it. */
     deliveryId?: string;
     provider?: string;
-    /** What `subscribe` or the previous successful delivery returned as `cursor`. */
-    cursor: string | null;
-    /** Ids earlier deliveries returned as `handled`, newest last. Skip these. */
-    seen: string[];
 };
-/** What an app event trigger's run carries as `input.__webhook`: one event, no cursor. */
-export type ZiteAppEventDelivery = Omit<ZiteTriggerDelivery, "cursor" | "seen">;
 /**
- * What a poll-triggered run, or a provider trigger's delivery, returns for
- * the platform to keep: its new `cursor`, and the id of every item it acted
- * on, so the next run's `seen` includes them even if the cursor hands them
- * back.
+ * What a poll run, or a provider trigger's delivery, gets as `trigger`. Record
+ * each item acted on with `handled` as you go: it is kept even if the run
+ * later throws, so the next run skips it. The cursor staged with `advance` is
+ * committed only when the run succeeds.
  */
-export type ZitePollResult = {
-    cursor?: string;
-    handled?: string[];
+export type ZiteTriggerRun = {
+    /** The last committed cursor: what `subscribe` returned, or the last successful run's `advance`. Null when there is none yet. */
+    cursor: string | null;
+    /** Whether an earlier run, or this one, recorded `id` as handled. */
+    seen(id: string): boolean;
+    /** Record an item as acted on (1 to 512 characters). */
+    handled(id: string): void;
+    /** Stage the next cursor (at most 4096 characters). The last call wins. */
+    advance(cursor: string): void;
 };
+export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
+/** The `trigger` param for an endpoint declaring `TTrigger`. */
+export type ZiteTriggerContext<TTrigger> = TTrigger extends {
+    every: string;
+} ? ZiteTriggerRun : TTrigger extends {
+    events: string[];
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
+    integration: string;
+} ? ZiteTriggerDeliveryRun : never;
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -221,22 +215,12 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TTrigger extends {
-            every: string;
-        } ? TInput & {
-            __poll?: ZitePollInput;
-        } : TTrigger extends {
-            events: string[];
-        } ? TInput & {
-            __webhook?: ZiteAppEventDelivery;
-        } : TTrigger extends {
-            integration: string;
-        } ? TInput & {
-            __webhook?: ZiteTriggerDelivery;
-        } : TInput;
+        input: TInput;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
+    } : {}) & (TTrigger extends ZiteTrigger ? {
+        trigger?: ZiteTriggerContext<TTrigger>;
     } : {})) => Promise<TOutput> | TOutput;
 }
 /**

package/dist/esm/backend/index.js

@@ -69,6 +69,10 @@ export function createEndpoint(config) {
             // request callers doesn't describe them.
             if (isPlatformTriggeredInput(params.input))
                 return execute(params);
+            // A trigger's run carries the provider's body, not a request's input.
+            if (params.trigger !== undefined) {
+                return execute(params);
+            }
             // Same, for a fire with no input object to hold the sentinel: the runner
             // only merges `__cron` into a plain object.
             if (firesWithoutARequest && params.input === undefined) {

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

@@ -131,28 +131,51 @@ describe("platform-triggered runs", () => {
         });
         await expect(endpoint.execute({ input: undefined, context: requestContext })).rejects.toMatchObject({ code: "BAD_REQUEST" });
     });
-    it("hands a poll its cursor and seen ids, typed", async () => {
+    it("hands a poll a typed trigger and skips the input schema for it", async () => {
+        const handled = [];
         const endpoint = createEndpoint({
-            inputSchema: z.object({}),
+            inputSchema: z.object({ required: z.string() }),
             trigger: { every: "5m", integration: "stripe" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__poll?.seen);
-                const items = ["a", "b"].filter((id) => !seen.has(id));
-                return { cursor: input.__poll?.cursor ?? "start", handled: items };
+            execute: async ({ trigger }) => {
+                if (!trigger)
+                    return { ran: 0 };
+                const fresh = ["a", "b"].filter((id) => !trigger.seen(id));
+                for (const id of fresh)
+                    trigger.handled(id);
+                trigger.advance("c2");
+                return { ran: fresh.length, from: trigger.cursor };
             },
         });
+        const seen = new Set(["a"]);
         await expect(endpoint.execute({
-            input: { __poll: { cursor: "c1", seen: ["a"] } },
+            input: {},
             context: { user: null },
-        })).resolves.toEqual({ cursor: "c1", handled: ["b"] });
+            trigger: {
+                cursor: "c1",
+                seen: (id) => seen.has(id),
+                handled: (id) => void handled.push(id),
+                advance: () => { },
+            },
+        })).resolves.toEqual({ ran: 1, from: "c1" });
+        expect(handled).toEqual(["b"]);
     });
-    it("gives __poll only to poll triggers", () => {
+    it("types trigger by the declared kind", () => {
         createEndpoint({
-            inputSchema: z.object({ action: z.string() }),
             trigger: { integration: "github" },
-            execute: async ({ input }) => {
-                // @ts-expect-error a provider trigger's input has no __poll
-                return input.__poll;
+            execute: async ({ trigger }) => trigger?.deliveryId ?? trigger?.cursor,
+        });
+        createEndpoint({
+            trigger: { integration: "team-slack", events: ["message.channels"] },
+            execute: async ({ trigger }) => {
+                // @ts-expect-error an app event has no cursor API
+                trigger?.advance("x");
+                return trigger?.headers;
+            },
+        });
+        createEndpoint({
+            execute: async (params) => {
+                // @ts-expect-error a plain endpoint gets no trigger
+                return params.trigger;
             },
         });
     });
@@ -182,40 +205,28 @@ describe("platform-triggered runs", () => {
             endpointId: "onPush",
         });
     });
-    it("hands a provider trigger's delivery its cursor and seen ids, typed", async () => {
+    it("hands a provider delivery its body as input and the cursor API on trigger", async () => {
         const endpoint = createEndpoint({
-            inputSchema: z.object({}),
+            inputSchema: z.object({ required: z.string() }),
             trigger: { integration: "googleCalendar" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__webhook?.seen);
-                const changed = ["e1", "e2"].filter((id) => !seen.has(id));
-                return { cursor: `${input.__webhook?.cursor}+1`, handled: changed };
-            },
+            execute: async ({ input, trigger }) => ({
+                body: input,
+                cursor: trigger?.cursor,
+                delivery: trigger?.deliveryId,
+            }),
         });
         await expect(endpoint.execute({
-            input: {
-                __webhook: { headers: {}, cursor: "sync1", seen: ["e1"] },
-            },
+            input: { kind: "sync" },
             context: { user: null },
-        })).resolves.toEqual({ cursor: "sync1+1", handled: ["e2"] });
-    });
-    it("types an app event trigger's run as one event, with no cursor to keep", async () => {
-        const endpoint = createEndpoint({
-            inputSchema: z.object({ event: z.object({ text: z.string() }) }),
-            trigger: { integration: "team-slack", events: ["message.channels"] },
-            execute: async ({ input }) => {
-                // @ts-expect-error an app event delivery has no cursor
-                void input.__webhook?.cursor;
-                return { id: input.__webhook?.deliveryId ?? null };
-            },
-        });
-        await expect(endpoint.execute({
-            input: {
-                event: { text: "hi" },
-                __webhook: { headers: {}, deliveryId: "slack:Ev1" },
+            trigger: {
+                cursor: "sync1",
+                seen: () => false,
+                handled: () => { },
+                advance: () => { },
+                headers: {},
+                deliveryId: "chan:2",
             },
-            context: { user: null },
-        })).resolves.toEqual({ id: "slack:Ev1" });
+        })).resolves.toEqual({ body: { kind: "sync" }, cursor: "sync1", delivery: "chan:2" });
     });
     it("refuses events on a trigger that also polls", () => {
         createEndpoint({

package/dist/esm/sync/lib.js

@@ -1217,13 +1217,13 @@ export 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, ZiteStreamInterface, ZiteTrigger, ZiteTriggerDelivery, ZiteAppEventDelivery, ZitePollInput, ZiteWebhook } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteTrigger, ZiteWebhook };",
         // A trigger's registration exports are typed against these, and they
         // only reach app code through this file.
-        "export type { ZiteAppEventDelivery, ZitePollInput, ZitePollResult, ZiteTriggerDelivery, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
+        "export type { 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;",
@@ -1315,11 +1315,10 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "  trigger?: TTrigger;",
         "  execute: (",
         "    params: {",
-        // Mirrors the base module: a poll's run carries `__poll`, a provider
-        // trigger's delivery `__webhook`.
-        "      input: TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput } : TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery } : TTrigger extends { integration: string } ? TInput & { __webhook?: ZiteTriggerDelivery } : TInput;",
+        "      input: TInput;",
         "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
-        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}),",
+        // Mirrors the base module: a trigger's run gets `trigger`.
+        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}) & (TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {}),",
         "  ) => Promise<TOutput> | TOutput;",
         "}",
         "",

package/dist/esm/sync/lib.test.js

@@ -385,9 +385,9 @@ describe('generateBackendWrapperTs', () => {
     it('passes the trigger registration types and trigger inputs through to app code', () => {
         expect(output).toContain('ZiteTriggerSubscribe, ZiteTriggerSubscribeInput');
         expect(output).toContain('ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput');
-        expect(output).toContain("TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput }");
-        expect(output).toContain('TInput & { __webhook?: ZiteTriggerDelivery }');
-        expect(output).toContain("TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery }");
+        expect(output).toContain('ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun');
+        expect(output).toContain('(TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {})');
+        expect(output).not.toContain('__poll');
         expect(output).not.toContain('src/triggers/');
     });
     it('exports ZiteError', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.134",
+  "version": "0.9.135",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "sideEffects": false,