@zapier/zapier-sdk 0.77.0 → 0.77.2

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

@@ -1,260 +0,0 @@
-import { definePlugin } from "kitcore";
-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";
-/**
- * Drain errors that must NOT be retried, by error identity: a fail-fast handler
- * error (the user's own failure — retrying would re-run a handler that already
- * chose to stop) and an `initialization_failure` (a permanent inbox setup
- * problem). The watch loop retries transient infrastructure errors but consults
- * this set to leave these fatal. A WeakSet rather than a marker property because
- * handler errors are the user's own values and must reach their catch
- * unmodified. `markNonRetryableDrainError` no-ops on a non-object throw (it
- * can't be weakly held), but that case is still fatal without this set: the
- * watch loop classifies any non-object thrown value as non-retryable on its own,
- * since the API client only ever throws Error objects, so a primitive can only
- * be a user fail-fast throw. Permanent HTTP errors are non-retryable too, but
- * the caller classifies those by status code, not via this set.
- */
-const nonRetryableDrainErrors = new WeakSet();
-export function markNonRetryableDrainError(err) {
-    if (typeof err === "object" && err !== null) {
-        nonRetryableDrainErrors.add(err);
-    }
-    return err;
-}
-export function isNonRetryableDrainError(err) {
-    return (typeof err === "object" && err !== null && nonRetryableDrainErrors.has(err));
-}
-/**
- * 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 once per drain request, with bounded error
- * backoff between passes that fail with a transient error).
- */
-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;
-    // A boolean rather than a `firstHandlerError !== undefined` sentinel so a
-    // handler that throws a falsy value (`throw undefined` / `throw null`) is still
-    // captured and surfaced as fatal, not silently swallowed.
-    let handlerErrorCaptured = 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 markNonRetryableDrainError(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 (!handlerErrorCaptured) {
-                        firstHandlerError = err;
-                        handlerErrorCaptured = true;
-                    }
-                    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;
-            }
-        },
-    });
-    // Mark so the watch loop treats this as fatal and never retries it (a
-    // fail-fast handler error means the user already chose to stop).
-    if (handlerErrorCaptured) {
-        throw markNonRetryableDrainError(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

@@ -1,56 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,225 +0,0 @@
-/**
- * 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

@@ -1,104 +0,0 @@
-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("kitcore").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("kitcore").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

@@ -1 +0,0 @@
-{"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"}