@zapier/zapier-sdk 0.48.1 → 0.50.0

package/dist/plugins/triggers/drainTriggerInbox/index.js

@@ -0,0 +1,227 @@
+import { definePlugin } from "../../../utils/plugin-utils";
+import { DrainTriggerInboxSchema, ZapierAbortDrainSignal, ZapierReleaseTriggerMessageSignal, } from "./schemas";
+import { runBatchedDrainPipeline } from "./pipeline";
+import { ZapierApiError, ZapierValidationError } from "../../../types/errors";
+import { ZapierSignal } from "../../../types/signals";
+import { triggerInboxResolver } from "../../../resolvers";
+import { resolveTriggerInboxId } from "../utils";
+import { triggersDefaults } from "../shared";
+import { isAbortError } from "../../../utils/abort-utils";
+export { ZapierAbortDrainSignal, ZapierReleaseTriggerMessageSignal, } from "./schemas";
+/**
+ * Server returns 400 lease_expired when a UUIDv7 timestamp is in the
+ * past. The API atomically quarantines messages that have hit
+ * MESSAGE_LEASE_MAX before raising — work has been done server-side
+ * already, so failing the drain on a clock-skew race would be a poor
+ * UX.
+ */
+function isLeaseExpiredError(err) {
+    if (!(err instanceof ZapierValidationError))
+        return false;
+    return err.errors?.some((e) => e.code === "lease_expired") ?? false;
+}
+/**
+ * One drain pass through `runBatchedDrainPipeline`. Used directly by
+ * `drainTriggerInbox` (single pass) and as the inner loop body of
+ * `watchTriggerInbox` (called repeatedly with poll backoff between
+ * empty passes).
+ */
+export async function runDrainPass(options) {
+    const { sdk, inboxId, onMessage, concurrency, leaseLimit, leaseSeconds, maxMessages, releaseOnError, continueOnError, onError, signal, } = options;
+    let firstFetch = options.firstFetch;
+    let abortedFromCallback = false;
+    let firstHandlerError = undefined;
+    const outcomes = await runBatchedDrainPipeline({
+        concurrency,
+        maxItems: maxMessages,
+        leaseSize: leaseLimit,
+        fetchBatch: async (requestedSize) => {
+            if (signal?.aborted)
+                return "exhausted";
+            let lease;
+            try {
+                ({ data: lease } = await sdk.leaseTriggerInboxMessages({
+                    inbox: inboxId,
+                    leaseLimit: requestedSize,
+                    leaseSeconds,
+                    signal,
+                }));
+            }
+            catch (err) {
+                // Only swallow abort-shaped failures. A real auth / validation
+                // / transport error that races with cancellation must still
+                // reject — checking `signal?.aborted` alone would silently hide
+                // a 401 that landed in the same tick the user pressed Ctrl-C.
+                if (signal?.aborted && isAbortError(err))
+                    return "exhausted";
+                throw err;
+            }
+            if (lease.results.length === 0) {
+                if (firstFetch &&
+                    lease.inbox_attributes.status === "initialization_failure") {
+                    throw new ZapierApiError(`Trigger inbox ${inboxId} is in initialization_failure state — inspect via getTriggerInbox.`);
+                }
+                firstFetch = false;
+                return "exhausted";
+            }
+            firstFetch = false;
+            if (!lease.lease_id)
+                return "exhausted";
+            return { id: lease.lease_id, items: lease.results };
+        },
+        processItem: async (message) => {
+            if (signal?.aborted) {
+                return {
+                    value: message,
+                    action: "release",
+                    abort: true,
+                };
+            }
+            try {
+                await onMessage(message);
+                return { value: message, action: "ack" };
+            }
+            catch (err) {
+                let action = "ignore";
+                let abort = false;
+                if (err instanceof ZapierAbortDrainSignal) {
+                    abort = true;
+                    abortedFromCallback = true;
+                    if (releaseOnError)
+                        action = "release";
+                }
+                else if (err instanceof ZapierReleaseTriggerMessageSignal) {
+                    action = "release";
+                }
+                else if (releaseOnError) {
+                    action = "release";
+                }
+                // Observe (signals filtered — they're control-flow, not failures).
+                if (onError && !(err instanceof ZapierSignal)) {
+                    try {
+                        await onError(err, message);
+                    }
+                    catch {
+                        // observer's own error is intentionally swallowed.
+                    }
+                }
+                // Fail-fast: capture the first real error and tell the
+                // pipeline to abort. continueOnError keeps it running.
+                if (!continueOnError && !(err instanceof ZapierSignal)) {
+                    if (firstHandlerError === undefined)
+                        firstHandlerError = err;
+                    abort = true;
+                }
+                return { value: message, action, abort };
+            }
+        },
+        ackItem: async (leaseId, messageId) => {
+            try {
+                await sdk.ackTriggerInboxMessages({
+                    inbox: inboxId,
+                    lease: leaseId,
+                    messages: [messageId],
+                });
+            }
+            catch (err) {
+                if (!isLeaseExpiredError(err))
+                    throw err;
+            }
+        },
+        releaseItems: async (leaseId, messageIds) => {
+            try {
+                await sdk.releaseTriggerInboxMessages({
+                    inbox: inboxId,
+                    lease: leaseId,
+                    messages: messageIds,
+                });
+            }
+            catch (err) {
+                if (!isLeaseExpiredError(err))
+                    throw err;
+            }
+        },
+    });
+    if (firstHandlerError !== undefined)
+        throw firstHandlerError;
+    return { abortedFromCallback, processed: outcomes.length };
+}
+/**
+ * Validate the per-message callback. `onMessage` is required — no
+ * identity default, since "lease and ack everything in this inbox"
+ * is a footgun on a casual call. JS callers that skip onMessage hit
+ * this guard at runtime; TS callers are rejected at the call site.
+ */
+export function requireOnMessage(onMessage) {
+    if (typeof onMessage !== "function") {
+        throw new ZapierValidationError("onMessage is required.");
+    }
+    return onMessage;
+}
+/**
+ * Compute concurrency and lease size with symmetric defaulting:
+ *
+ *   both unset     -> concurrency=1, leaseLimit=1
+ *   concurrency=N  -> concurrency=N, leaseLimit=N
+ *   leaseLimit=L   -> concurrency=L, leaseLimit=L
+ *   both set       -> use both as given
+ *
+ * The symmetry kills the "set leaseLimit alone, get prefetch
+ * pathology" footgun: a leased message buffer is never larger than
+ * the worker pool that can immediately work it.
+ */
+export function resolveConcurrencyAndLease(options) {
+    const concurrency = options.concurrency ?? options.leaseLimit ?? 1;
+    const leaseLimit = options.leaseLimit ?? concurrency;
+    return { concurrency, leaseLimit };
+}
+export const drainTriggerInboxPlugin = definePlugin((sdk) => {
+    async function drainTriggerInbox(options) {
+        const onMessage = requireOnMessage(options.onMessage);
+        const { concurrency, leaseLimit } = resolveConcurrencyAndLease(options);
+        const inboxId = await resolveTriggerInboxId({
+            api: sdk.context.api,
+            inbox: options.inbox,
+        });
+        await runDrainPass({
+            sdk,
+            inboxId,
+            onMessage,
+            concurrency,
+            leaseLimit,
+            leaseSeconds: options.leaseSeconds,
+            maxMessages: options.maxMessages,
+            releaseOnError: options.releaseOnError ?? false,
+            continueOnError: options.continueOnError ?? false,
+            onError: options.onError,
+            signal: options.signal,
+            firstFetch: true,
+        });
+    }
+    return {
+        drainTriggerInbox,
+        context: {
+            meta: {
+                drainTriggerInbox: {
+                    ...triggersDefaults,
+                    type: "create",
+                    description: "Drain an existing trigger inbox: lease currently-available messages, process each via onMessage, return when the inbox is empty, maxMessages is reached, or the abort signal fires.",
+                    itemType: "void",
+                    // The doc generator's default for type="create" + itemType
+                    // appends "Item" (e.g. "RecordItem"), which would render
+                    // "voidItem" here. drainTriggerInbox returns Promise<void>,
+                    // so we override.
+                    returnType: "void",
+                    inputSchema: DrainTriggerInboxSchema,
+                    resolvers: {
+                        inbox: triggerInboxResolver,
+                    },
+                    // Returns Promise<void>; the CLI ships a hand-written
+                    // drain-trigger-inbox plugin that adds presentation flags
+                    // (interactive, --json, etc.) around this command.
+                    packages: ["sdk"],
+                },
+            },
+        },
+    };
+});

package/dist/plugins/triggers/drainTriggerInbox/pipeline.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Generic worker-pool drain over a batched fetch source. The pipeline
+ * owns mechanism: concurrent workers, low-watermark refill,
+ * batch-completion detection, deferred-release accumulation, and
+ * end-of-drain cleanup. Plugin-specific policy (signal interpretation,
+ * error swallowing, locator resolution) lives in the caller's hooks.
+ */
+export type ItemAction = "ack" | "release" | "ignore";
+export interface ProcessItemResult<TValue> {
+    /** Pushed onto the drain's results array. */
+    value: TValue;
+    /** What the pipeline does with the item: ack, release, or ignore (lease timeout returns it). */
+    action: ItemAction;
+    /** Stop the drain after current in-flight items finish. */
+    abort?: boolean;
+}
+export interface BatchedDrainPipelineOptions<TItem extends {
+    id: string;
+}, TValue> {
+    concurrency: number;
+    maxItems?: number;
+    leaseSize: number;
+    /**
+     * Fetch the next batch. `"exhausted"` signals no more items will arrive.
+     * Errors thrown after the initial fetch surface only after in-flight
+     * workers wind down.
+     */
+    fetchBatch(requestedSize: number): Promise<{
+        id: string;
+        items: TItem[];
+    } | "exhausted">;
+    /**
+     * Run the per-item callback. The returned `action` controls
+     * ack/release; `abort: true` short-circuits the drain after current
+     * in-flight items finish.
+     */
+    processItem(item: TItem): Promise<ProcessItemResult<TValue>>;
+    /**
+     * Called once per item the callback marked `"ack"`, immediately after
+     * processItem returns. Per-item rather than per-batch so a crash
+     * mid-drain can't roll back already-committed items. The hook is on
+     * the hot path; in drainTriggerInbox it issues one
+     * sdk.ackTriggerInboxMessages call per acked message.
+     */
+    ackItem(batchId: string, itemId: string): Promise<void>;
+    /**
+     * Called once at drain end per batch with items the callback marked
+     * `"release"`. Stays batched (vs ackItem's per-item) because an
+     * unreleased item just waits for the lease timeout — no work is lost.
+     */
+    releaseItems(batchId: string, itemIds: string[]): Promise<void>;
+}
+export declare function runBatchedDrainPipeline<TItem extends {
+    id: string;
+}, TValue>(options: BatchedDrainPipelineOptions<TItem, TValue>): Promise<TValue[]>;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/plugins/triggers/drainTriggerInbox/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/drainTriggerInbox/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtD,MAAM,WAAW,iBAAiB,CAAC,MAAM;IACvC,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,gGAAgG;IAChG,MAAM,EAAE,UAAU,CAAC;IACnB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,2BAA2B,CAC1C,KAAK,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC5B,MAAM;IAEN,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CACR,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,EAAE,CAAA;KAAE,GAAG,WAAW,CAAC,CAAC;IACzD;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7D;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD;;;;OAIG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjE;AA4ED,wBAAsB,uBAAuB,CAC3C,KAAK,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC5B,MAAM,EACN,OAAO,EAAE,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAyKxE"}

package/dist/plugins/triggers/drainTriggerInbox/pipeline.js

@@ -0,0 +1,225 @@
+/**
+ * Generic worker-pool drain over a batched fetch source. The pipeline
+ * owns mechanism: concurrent workers, low-watermark refill,
+ * batch-completion detection, deferred-release accumulation, and
+ * end-of-drain cleanup. Plugin-specific policy (signal interpretation,
+ * error swallowing, locator resolution) lives in the caller's hooks.
+ */
+// With per-item ack the tracker is purely a counter for refill math and
+// the worker exit condition. It used to also accumulate fulfilled item
+// ids for a per-batch ack call.
+function createBatchTracker() {
+    const batches = new Map();
+    return {
+        addBatch(id, total) {
+            batches.set(id, { total, inFlight: 0, completed: 0 });
+        },
+        markInFlight(id) {
+            const e = batches.get(id);
+            if (e)
+                e.inFlight++;
+        },
+        /** Decrement inFlight and increment completed. Paired with markInFlight. */
+        markCompleted(id) {
+            const e = batches.get(id);
+            if (!e)
+                return;
+            e.inFlight--;
+            e.completed++;
+        },
+        /** Drop the batch once all items completed; tracker stays small over long drains. */
+        finalizeIfDone(id) {
+            const e = batches.get(id);
+            if (e && e.completed === e.total)
+                batches.delete(id);
+        },
+        inFlightTotal() {
+            let n = 0;
+            for (const e of batches.values())
+                n += e.inFlight;
+            return n;
+        },
+        /** Items leased but not yet completed (queued + in-flight). */
+        pipelineSize() {
+            let n = 0;
+            for (const e of batches.values())
+                n += e.total - e.completed;
+            return n;
+        },
+    };
+}
+/**
+ * One-shot waiter. Workers `wait()` when the queue is empty; producers
+ * `notifyAll()` to wake them. Each `notifyAll` swaps in a fresh waiter
+ * so already-woken workers don't re-fire on the next notify.
+ */
+function createWaiter() {
+    const make = () => {
+        let signal;
+        const promise = new Promise((r) => {
+            signal = r;
+        });
+        return { promise, signal };
+    };
+    let current = make();
+    return {
+        wait: () => current.promise,
+        notifyAll: () => {
+            const prev = current;
+            current = make();
+            prev.signal();
+        },
+    };
+}
+function addToMap(m, key, value) {
+    const existing = m.get(key) ?? [];
+    m.set(key, [...existing, value]);
+}
+export async function runBatchedDrainPipeline(options) {
+    const { concurrency, maxItems, leaseSize, fetchBatch, processItem, ackItem, releaseItems, } = options;
+    const tracker = createBatchTracker();
+    const waiter = createWaiter();
+    const accumulated = [];
+    const pendingReleases = new Map();
+    const queue = [];
+    let totalProcessed = 0;
+    let aborted = false;
+    let exhausted = false;
+    let fetchInProgress = false;
+    let fetchError = undefined;
+    async function tryFetch() {
+        if (fetchInProgress || exhausted || aborted)
+            return;
+        const remainingCap = maxItems !== undefined
+            ? maxItems - totalProcessed - tracker.pipelineSize()
+            : Number.POSITIVE_INFINITY;
+        if (remainingCap <= 0)
+            return;
+        const requestedSize = Math.min(remainingCap, leaseSize);
+        fetchInProgress = true;
+        try {
+            const result = await fetchBatch(requestedSize);
+            if (result === "exhausted") {
+                exhausted = true;
+                return;
+            }
+            tracker.addBatch(result.id, result.items.length);
+            for (const item of result.items) {
+                queue.push({ item, batchId: result.id });
+            }
+        }
+        catch (err) {
+            fetchError = err;
+            exhausted = true;
+        }
+        finally {
+            fetchInProgress = false;
+            waiter.notifyAll();
+        }
+    }
+    async function processQueueEntry(entry) {
+        tracker.markInFlight(entry.batchId);
+        // markCompleted / finalizeIfDone / notifyAll all run in finally so a
+        // throw from processItem or ackItem still decrements inFlight and
+        // wakes peer workers. Skipping markCompleted on a processItem throw
+        // wedges sibling workers: they wake on notifyAll, check
+        // `inFlightTotal === 0` for exit, see the never-decremented count,
+        // and block again — permanently with concurrency > 1.
+        try {
+            const result = await processItem(entry.item);
+            accumulated.push(result.value);
+            totalProcessed++;
+            if (result.action === "release") {
+                addToMap(pendingReleases, entry.batchId, entry.item.id);
+            }
+            if (result.abort)
+                aborted = true;
+            if (result.action === "ack") {
+                await ackItem(entry.batchId, entry.item.id);
+            }
+        }
+        finally {
+            tracker.markCompleted(entry.batchId);
+            tracker.finalizeIfDone(entry.batchId);
+            waiter.notifyAll();
+        }
+    }
+    async function worker() {
+        while (true) {
+            if (aborted)
+                return;
+            if (maxItems !== undefined && totalProcessed >= maxItems)
+                return;
+            const entry = queue.shift();
+            if (entry !== undefined) {
+                // Low-watermark refill: keep the pipeline at ~concurrency so a
+                // freed worker has work queued. Fire-and-forget so the worker
+                // doesn't block on the lease HTTP.
+                if (tracker.pipelineSize() < concurrency &&
+                    !fetchInProgress &&
+                    !exhausted) {
+                    void tryFetch();
+                }
+                await processQueueEntry(entry);
+                continue;
+            }
+            if (!exhausted && !fetchInProgress)
+                void tryFetch();
+            if (queue.length === 0 &&
+                !fetchInProgress &&
+                (exhausted || aborted) &&
+                tracker.inFlightTotal() === 0) {
+                return;
+            }
+            await waiter.wait();
+        }
+    }
+    // Initial fetch primes the queue. Errors here surface directly without
+    // ever spinning up workers.
+    await tryFetch();
+    if (fetchError !== undefined)
+        throw fetchError;
+    // Cleanup runs in finally so a thrown lease-boundary ack or a captured
+    // mid-drain fetchError still flushes deferred releases.
+    let cleanupError = undefined;
+    try {
+        if (!exhausted || queue.length > 0) {
+            // Catch-and-track on each worker so all settle before we surface
+            // the first error. With Promise.all, a failing worker rejects
+            // immediately and sibling workers continue running on the next
+            // tick, firing API calls after the caller has received the
+            // rejection.
+            let firstWorkerError = undefined;
+            const workers = Array.from({ length: concurrency }, () => worker().catch((err) => {
+                if (firstWorkerError === undefined)
+                    firstWorkerError = err;
+            }));
+            await Promise.all(workers);
+            if (firstWorkerError !== undefined)
+                throw firstWorkerError;
+        }
+        if (fetchError !== undefined)
+            throw fetchError;
+    }
+    finally {
+        // Aborted-but-unstarted items are still leased to us but were never
+        // offered to the callback — release them. With per-item ack there's
+        // nothing else to flush at cleanup; successful items were acked
+        // immediately as they completed.
+        while (queue.length > 0) {
+            const entry = queue.shift();
+            addToMap(pendingReleases, entry.batchId, entry.item.id);
+        }
+        for (const [batchId, itemIds] of pendingReleases) {
+            try {
+                await releaseItems(batchId, itemIds);
+            }
+            catch (err) {
+                cleanupError ?? (cleanupError = err);
+            }
+        }
+    }
+    if (cleanupError !== undefined)
+        throw cleanupError;
+    return accumulated;
+}

package/dist/plugins/triggers/drainTriggerInbox/schemas.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import type { LeasedTriggerMessageItem } from "../../../schemas/TriggerMessage";
+import { ZapierSignal } from "../../../types/signals";
+/**
+ * Signal an `onMessage` callback can throw to release the current
+ * message back to the inbox immediately (status returns to
+ * `available`) rather than leaving it leased until the lease
+ * timeout. The actual release call is deferred to the end of the
+ * drain so the same drain doesn't immediately re-lease it.
+ *
+ * Always triggers release regardless of `releaseOnError`.
+ */
+export declare class ZapierReleaseTriggerMessageSignal extends ZapierSignal {
+    readonly name = "ZapierReleaseTriggerMessageSignal";
+    readonly code: "ZAPIER_RELEASE_TRIGGER_MESSAGE_SIGNAL";
+}
+/**
+ * Signal an `onMessage` callback can throw to stop the drain after
+ * the current batch — no further leases, no further callbacks. The
+ * triggering message gets the same release-or-leave treatment as any
+ * thrown error (per `releaseOnError`). Other in-flight messages in
+ * the same batch finish normally before the command returns.
+ * Already-leased-but-not-yet-started messages are released so
+ * they're available for re-lease.
+ */
+export declare class ZapierAbortDrainSignal extends ZapierSignal {
+    readonly name = "ZapierAbortDrainSignal";
+    readonly code: "ZAPIER_ABORT_DRAIN_SIGNAL";
+}
+/**
+ * Per-message handler. Resolves to ack the message; rejects to
+ * release-or-leave per `releaseOnError`. Throw a
+ * `ZapierReleaseTriggerMessageSignal` for explicit release; throw a
+ * `ZapierAbortDrainSignal` to stop the drain after the current
+ * batch.
+ */
+export type DrainTriggerInboxCallback = (message: LeasedTriggerMessageItem) => void | Promise<void>;
+/**
+ * Per-message error observer for `continueOnError: true` mode.
+ * Called with the failure reason and the message; signals
+ * (`ZapierSignal` subclasses) are filtered out — they're
+ * control-flow throws, not failures to observe. Synchronous from
+ * the loop's perspective; throwing from `onError` is swallowed,
+ * since it's an observer not a flow controller.
+ */
+export type DrainTriggerInboxErrorObserver = (error: unknown, message: LeasedTriggerMessageItem) => void | Promise<void>;
+export declare const DrainTriggerInboxSchema: z.ZodObject<{
+    inbox: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    onMessage: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    leaseLimit: z.ZodOptional<z.ZodNumber>;
+    leaseSeconds: z.ZodOptional<z.ZodNumber>;
+    releaseOnError: z.ZodOptional<z.ZodBoolean>;
+    continueOnError: z.ZodOptional<z.ZodBoolean>;
+    onError: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+    maxMessages: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const WatchTriggerInboxSchema: z.ZodObject<{
+    inbox: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    onMessage: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    leaseLimit: z.ZodOptional<z.ZodNumber>;
+    leaseSeconds: z.ZodOptional<z.ZodNumber>;
+    releaseOnError: z.ZodOptional<z.ZodBoolean>;
+    continueOnError: z.ZodOptional<z.ZodBoolean>;
+    onError: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+    maxDrainIntervalSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Fields shared by both `drainTriggerInbox` and `watchTriggerInbox`.
+ * `onMessage` is required at the type level; runtime validation in
+ * the handler covers JS callers who bypass TS.
+ */
+interface TriggerInboxCommandSharedFields {
+    inbox: string;
+    onMessage: DrainTriggerInboxCallback;
+    concurrency?: number;
+    leaseLimit?: number;
+    leaseSeconds?: number;
+    releaseOnError?: boolean;
+    continueOnError?: boolean;
+    onError?: DrainTriggerInboxErrorObserver;
+    signal?: AbortSignal;
+}
+/**
+ * Hand-typed options for `drainTriggerInbox`. The Zod schema above is
+ * for docs and registry; this type is what the SDK function accepts,
+ * with `onMessage` / `onError` typed as proper callbacks instead of
+ * opaque `z.function()`.
+ */
+export type DrainTriggerInboxOptions = TriggerInboxCommandSharedFields & {
+    maxMessages?: number;
+};
+export type WatchTriggerInboxOptions = TriggerInboxCommandSharedFields & {
+    maxDrainIntervalSeconds?: number;
+};
+export type { LeasedTriggerMessageItem };
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/triggers/drainTriggerInbox/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/drainTriggerInbox/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD;;;;;;;;GAQG;AACH,qBAAa,iCAAkC,SAAQ,YAAY;IACjE,QAAQ,CAAC,IAAI,uCAAuC;IACpD,QAAQ,CAAC,IAAI,EAAG,uCAAuC,CAAU;CAClE;AAED;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,SAAQ,YAAY;IACtD,QAAQ,CAAC,IAAI,4BAA4B;IACzC,QAAQ,CAAC,IAAI,EAAG,2BAA2B,CAAU;CACtD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,CACtC,OAAO,EAAE,wBAAwB,KAC9B,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;;;;;;GAOG;AACH,MAAM,MAAM,8BAA8B,GAAG,CAC3C,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,wBAAwB,KAC9B,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAoE1B,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;iBAWnC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;iBAWnC,CAAC;AAEF;;;;GAIG;AACH,UAAU,+BAA+B;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,yBAAyB,CAAC;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,8BAA8B,CAAC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG,+BAA+B,GAAG;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,+BAA+B,GAAG;IACvE,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,YAAY,EAAE,wBAAwB,EAAE,CAAC"}