@femtomc/mu-server 26.2.69 → 26.2.71

package/dist/control_plane_telegram_generation.js

@@ -0,0 +1,520 @@
+import { TelegramControlPlaneAdapter, } from "@femtomc/mu-control-plane";
+const TELEGRAM_GENERATION_SUPERVISOR_ID = "telegram-adapter";
+const TELEGRAM_WARMUP_TIMEOUT_MS = 2_000;
+const TELEGRAM_DRAIN_TIMEOUT_MS = 5_000;
+function cloneControlPlaneConfig(config) {
+    return JSON.parse(JSON.stringify(config));
+}
+function controlPlaneNonTelegramFingerprint(config) {
+    return JSON.stringify({
+        adapters: {
+            slack: config.adapters.slack,
+            discord: config.adapters.discord,
+        },
+        operator: config.operator,
+    });
+}
+function telegramAdapterConfigFromControlPlane(config) {
+    const webhookSecret = config.adapters.telegram.webhook_secret;
+    if (!webhookSecret) {
+        return null;
+    }
+    return {
+        webhookSecret,
+        botToken: config.adapters.telegram.bot_token,
+        botUsername: config.adapters.telegram.bot_username,
+    };
+}
+function applyTelegramAdapterConfig(base, telegram) {
+    const next = cloneControlPlaneConfig(base);
+    next.adapters.telegram.webhook_secret = telegram?.webhookSecret ?? null;
+    next.adapters.telegram.bot_token = telegram?.botToken ?? null;
+    next.adapters.telegram.bot_username = telegram?.botUsername ?? null;
+    return next;
+}
+function cloneTelegramAdapterConfig(config) {
+    return {
+        webhookSecret: config.webhookSecret,
+        botToken: config.botToken,
+        botUsername: config.botUsername,
+    };
+}
+function describeError(err) {
+    if (err instanceof Error && err.message.trim().length > 0) {
+        return err.message;
+    }
+    return String(err);
+}
+async function runWithTimeout(opts) {
+    if (opts.timeoutMs <= 0) {
+        return await opts.run();
+    }
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(new Error(opts.timeoutMessage));
+        }, opts.timeoutMs);
+        void opts
+            .run()
+            .then((value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        })
+            .catch((err) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+export class TelegramAdapterGenerationManager {
+    #pipeline;
+    #outbox;
+    #nowMs;
+    #onOutboxEnqueued;
+    #signalObserver;
+    #hooks;
+    #generationSeq = -1;
+    #active = null;
+    #previousConfig = null;
+    #activeControlPlaneConfig;
+    constructor(opts) {
+        this.#pipeline = opts.pipeline;
+        this.#outbox = opts.outbox;
+        this.#nowMs = opts.nowMs ?? Date.now;
+        this.#onOutboxEnqueued = opts.onOutboxEnqueued ?? null;
+        this.#signalObserver = opts.signalObserver ?? null;
+        this.#hooks = opts.hooks ?? null;
+        this.#activeControlPlaneConfig = cloneControlPlaneConfig(opts.initialConfig);
+    }
+    #nextGeneration() {
+        const nextSeq = this.#generationSeq + 1;
+        return {
+            generation_id: `${TELEGRAM_GENERATION_SUPERVISOR_ID}-gen-${nextSeq}`,
+            generation_seq: nextSeq,
+        };
+    }
+    #buildAdapter(config, opts) {
+        return new TelegramControlPlaneAdapter({
+            pipeline: this.#pipeline,
+            outbox: this.#outbox,
+            webhookSecret: config.webhookSecret,
+            botUsername: config.botUsername,
+            deferredIngress: true,
+            onOutboxEnqueued: this.#onOutboxEnqueued ?? undefined,
+            signalObserver: this.#signalObserver ?? undefined,
+            acceptIngress: opts.acceptIngress,
+            ingressDrainEnabled: opts.ingressDrainEnabled,
+            nowMs: this.#nowMs,
+        });
+    }
+    async initialize() {
+        const initial = telegramAdapterConfigFromControlPlane(this.#activeControlPlaneConfig);
+        if (!initial) {
+            return;
+        }
+        const generation = this.#nextGeneration();
+        const adapter = this.#buildAdapter(initial, {
+            acceptIngress: true,
+            ingressDrainEnabled: true,
+        });
+        await adapter.warmup();
+        const health = await adapter.healthCheck();
+        if (!health.ok) {
+            await adapter.stop({ force: true, reason: "startup_health_gate_failed" });
+            throw new Error(`telegram adapter warmup health failed: ${health.reason}`);
+        }
+        this.#active = {
+            generation,
+            config: cloneTelegramAdapterConfig(initial),
+            adapter,
+        };
+        this.#generationSeq = generation.generation_seq;
+    }
+    hasActiveGeneration() {
+        return this.#active != null;
+    }
+    activeGeneration() {
+        return this.#active ? { ...this.#active.generation } : null;
+    }
+    activeBotToken() {
+        return this.#active?.config.botToken ?? null;
+    }
+    activeAdapter() {
+        return this.#active?.adapter ?? null;
+    }
+    canHandleConfig(nextConfig, reason) {
+        if (reason === "rollback") {
+            return true;
+        }
+        return (controlPlaneNonTelegramFingerprint(nextConfig) ===
+            controlPlaneNonTelegramFingerprint(this.#activeControlPlaneConfig));
+    }
+    async #rollbackToPrevious(opts) {
+        if (!opts.previous) {
+            return { ok: false, error: "rollback_unavailable" };
+        }
+        try {
+            opts.previous.adapter.activateIngress();
+            this.#active = opts.previous;
+            this.#previousConfig = cloneTelegramAdapterConfig(opts.failedRecord.config);
+            await opts.failedRecord.adapter.stop({ force: true, reason: `rollback:${opts.reason}` });
+            this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, opts.previous.config);
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: describeError(err) };
+        }
+    }
+    async reload(opts) {
+        if (!this.canHandleConfig(opts.config, opts.reason)) {
+            return {
+                handled: false,
+                ok: false,
+                reason: opts.reason,
+                route: "/webhooks/telegram",
+                from_generation: this.#active?.generation ?? null,
+                to_generation: null,
+                active_generation: this.#active?.generation ?? null,
+                warmup: null,
+                cutover: null,
+                drain: null,
+                rollback: {
+                    requested: opts.reason === "rollback",
+                    trigger: null,
+                    attempted: false,
+                    ok: true,
+                },
+            };
+        }
+        const rollbackRequested = opts.reason === "rollback";
+        let rollbackTrigger = rollbackRequested ? "manual" : null;
+        let rollbackAttempted = false;
+        let rollbackOk = true;
+        let rollbackError;
+        const fromGeneration = this.#active?.generation ?? null;
+        const previousRecord = this.#active;
+        const warmupTimeoutMs = Math.max(0, Math.trunc(opts.warmupTimeoutMs ?? TELEGRAM_WARMUP_TIMEOUT_MS));
+        const drainTimeoutMs = Math.max(0, Math.trunc(opts.drainTimeoutMs ?? TELEGRAM_DRAIN_TIMEOUT_MS));
+        const targetConfig = rollbackRequested
+            ? this.#previousConfig
+            : telegramAdapterConfigFromControlPlane(opts.config);
+        if (rollbackRequested && !targetConfig) {
+            return {
+                handled: true,
+                ok: false,
+                reason: opts.reason,
+                route: "/webhooks/telegram",
+                from_generation: fromGeneration,
+                to_generation: null,
+                active_generation: fromGeneration,
+                warmup: null,
+                cutover: null,
+                drain: null,
+                rollback: {
+                    requested: true,
+                    trigger: "rollback_unavailable",
+                    attempted: false,
+                    ok: false,
+                    error: "rollback_unavailable",
+                },
+                error: "rollback_unavailable",
+            };
+        }
+        if (!targetConfig && !previousRecord) {
+            this.#activeControlPlaneConfig = cloneControlPlaneConfig(opts.config);
+            return {
+                handled: true,
+                ok: true,
+                reason: opts.reason,
+                route: "/webhooks/telegram",
+                from_generation: null,
+                to_generation: null,
+                active_generation: null,
+                warmup: null,
+                cutover: null,
+                drain: null,
+                rollback: {
+                    requested: rollbackRequested,
+                    trigger: rollbackTrigger,
+                    attempted: false,
+                    ok: true,
+                },
+            };
+        }
+        if (!targetConfig && previousRecord) {
+            const drainStartedAtMs = Math.trunc(this.#nowMs());
+            let forcedStop = false;
+            let drainError;
+            let drainTimedOut = false;
+            try {
+                previousRecord.adapter.beginDrain();
+                if (this.#hooks?.onDrain) {
+                    await this.#hooks.onDrain({
+                        generation: previousRecord.generation,
+                        reason: opts.reason,
+                        timeout_ms: drainTimeoutMs,
+                    });
+                }
+                const drain = await runWithTimeout({
+                    timeoutMs: drainTimeoutMs,
+                    timeoutMessage: "telegram_drain_timeout",
+                    run: async () => await previousRecord.adapter.drain({ timeoutMs: drainTimeoutMs, reason: opts.reason }),
+                });
+                drainTimedOut = drain.timed_out;
+                if (!drain.ok || drain.timed_out) {
+                    forcedStop = true;
+                    await previousRecord.adapter.stop({ force: true, reason: "disable_drain_timeout" });
+                }
+                else {
+                    await previousRecord.adapter.stop({ force: false, reason: "disable" });
+                }
+            }
+            catch (err) {
+                drainError = describeError(err);
+                forcedStop = true;
+                drainTimedOut = drainError.includes("timeout");
+                await previousRecord.adapter.stop({ force: true, reason: "disable_drain_failed" });
+            }
+            this.#previousConfig = cloneTelegramAdapterConfig(previousRecord.config);
+            this.#active = null;
+            this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, null);
+            return {
+                handled: true,
+                ok: drainError == null,
+                reason: opts.reason,
+                route: "/webhooks/telegram",
+                from_generation: fromGeneration,
+                to_generation: null,
+                active_generation: null,
+                warmup: null,
+                cutover: {
+                    ok: true,
+                    elapsed_ms: 0,
+                },
+                drain: {
+                    ok: drainError == null && !drainTimedOut,
+                    elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - drainStartedAtMs),
+                    timed_out: drainTimedOut,
+                    forced_stop: forcedStop,
+                    ...(drainError ? { error: drainError } : {}),
+                },
+                rollback: {
+                    requested: rollbackRequested,
+                    trigger: rollbackTrigger,
+                    attempted: false,
+                    ok: true,
+                },
+                ...(drainError ? { error: drainError } : {}),
+            };
+        }
+        const nextConfig = cloneTelegramAdapterConfig(targetConfig);
+        const toGeneration = this.#nextGeneration();
+        const nextAdapter = this.#buildAdapter(nextConfig, {
+            acceptIngress: false,
+            ingressDrainEnabled: false,
+        });
+        const nextRecord = {
+            generation: toGeneration,
+            config: nextConfig,
+            adapter: nextAdapter,
+        };
+        const warmupStartedAtMs = Math.trunc(this.#nowMs());
+        try {
+            if (this.#hooks?.onWarmup) {
+                await this.#hooks.onWarmup({ generation: toGeneration, reason: opts.reason });
+            }
+            await runWithTimeout({
+                timeoutMs: warmupTimeoutMs,
+                timeoutMessage: "telegram_warmup_timeout",
+                run: async () => {
+                    await nextAdapter.warmup();
+                    const health = await nextAdapter.healthCheck();
+                    if (!health.ok) {
+                        throw new Error(`telegram_health_gate_failed:${health.reason}`);
+                    }
+                },
+            });
+        }
+        catch (err) {
+            const error = describeError(err);
+            rollbackTrigger = error.includes("health_gate") ? "health_gate_failed" : "warmup_failed";
+            await nextAdapter.stop({ force: true, reason: "warmup_failed" });
+            return {
+                handled: true,
+                ok: false,
+                reason: opts.reason,
+                route: "/webhooks/telegram",
+                from_generation: fromGeneration,
+                to_generation: toGeneration,
+                active_generation: fromGeneration,
+                warmup: {
+                    ok: false,
+                    elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - warmupStartedAtMs),
+                    error,
+                },
+                cutover: null,
+                drain: null,
+                rollback: {
+                    requested: rollbackRequested,
+                    trigger: rollbackTrigger,
+                    attempted: false,
+                    ok: true,
+                },
+                error,
+            };
+        }
+        const cutoverStartedAtMs = Math.trunc(this.#nowMs());
+        try {
+            if (this.#hooks?.onCutover) {
+                await this.#hooks.onCutover({
+                    from_generation: fromGeneration,
+                    to_generation: toGeneration,
+                    reason: opts.reason,
+                });
+            }
+            nextAdapter.activateIngress();
+            if (previousRecord) {
+                previousRecord.adapter.beginDrain();
+            }
+            this.#active = nextRecord;
+            this.#generationSeq = toGeneration.generation_seq;
+            const postCutoverHealth = await nextAdapter.healthCheck();
+            if (!postCutoverHealth.ok) {
+                throw new Error(`telegram_post_cutover_health_failed:${postCutoverHealth.reason}`);
+            }
+        }
+        catch (err) {
+            const error = describeError(err);
+            rollbackTrigger = error.includes("post_cutover") ? "post_cutover_health_failed" : "cutover_failed";
+            rollbackAttempted = true;
+            const rollback = await this.#rollbackToPrevious({
+                failedRecord: nextRecord,
+                previous: previousRecord,
+                reason: opts.reason,
+            });
+            rollbackOk = rollback.ok;
+            rollbackError = rollback.error;
+            if (!rollback.ok) {
+                await nextAdapter.stop({ force: true, reason: "rollback_failed" });
+                this.#active = previousRecord ?? null;
+                this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, previousRecord?.config ?? null);
+            }
+            return {
+                handled: true,
+                ok: false,
+                reason: opts.reason,
+                route: "/webhooks/telegram",
+                from_generation: fromGeneration,
+                to_generation: toGeneration,
+                active_generation: this.#active?.generation ?? fromGeneration,
+                warmup: {
+                    ok: true,
+                    elapsed_ms: Math.max(0, cutoverStartedAtMs - warmupStartedAtMs),
+                },
+                cutover: {
+                    ok: false,
+                    elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - cutoverStartedAtMs),
+                    error,
+                },
+                drain: null,
+                rollback: {
+                    requested: rollbackRequested,
+                    trigger: rollbackTrigger,
+                    attempted: rollbackAttempted,
+                    ok: rollbackOk,
+                    ...(rollbackError ? { error: rollbackError } : {}),
+                },
+                error,
+            };
+        }
+        let drain = null;
+        if (previousRecord) {
+            const drainStartedAtMs = Math.trunc(this.#nowMs());
+            let forcedStop = false;
+            let drainTimedOut = false;
+            let drainError;
+            try {
+                if (this.#hooks?.onDrain) {
+                    await this.#hooks.onDrain({
+                        generation: previousRecord.generation,
+                        reason: opts.reason,
+                        timeout_ms: drainTimeoutMs,
+                    });
+                }
+                const drained = await runWithTimeout({
+                    timeoutMs: drainTimeoutMs,
+                    timeoutMessage: "telegram_drain_timeout",
+                    run: async () => await previousRecord.adapter.drain({ timeoutMs: drainTimeoutMs, reason: opts.reason }),
+                });
+                drainTimedOut = drained.timed_out;
+                if (!drained.ok || drained.timed_out) {
+                    forcedStop = true;
+                    await previousRecord.adapter.stop({ force: true, reason: "generation_drain_timeout" });
+                }
+                else {
+                    await previousRecord.adapter.stop({ force: false, reason: "generation_drained" });
+                }
+            }
+            catch (err) {
+                drainError = describeError(err);
+                forcedStop = true;
+                drainTimedOut = drainError.includes("timeout");
+                await previousRecord.adapter.stop({ force: true, reason: "generation_drain_failed" });
+            }
+            drain = {
+                ok: drainError == null && !drainTimedOut,
+                elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - drainStartedAtMs),
+                timed_out: drainTimedOut,
+                forced_stop: forcedStop,
+                ...(drainError ? { error: drainError } : {}),
+            };
+        }
+        this.#previousConfig = previousRecord ? cloneTelegramAdapterConfig(previousRecord.config) : this.#previousConfig;
+        this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, nextConfig);
+        return {
+            handled: true,
+            ok: true,
+            reason: opts.reason,
+            route: "/webhooks/telegram",
+            from_generation: fromGeneration,
+            to_generation: toGeneration,
+            active_generation: toGeneration,
+            warmup: {
+                ok: true,
+                elapsed_ms: Math.max(0, cutoverStartedAtMs - warmupStartedAtMs),
+            },
+            cutover: {
+                ok: true,
+                elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - cutoverStartedAtMs),
+            },
+            drain,
+            rollback: {
+                requested: rollbackRequested,
+                trigger: rollbackTrigger,
+                attempted: rollbackAttempted,
+                ok: rollbackOk,
+                ...(rollbackError ? { error: rollbackError } : {}),
+            },
+        };
+    }
+    async stop() {
+        const active = this.#active;
+        this.#active = null;
+        if (!active) {
+            return;
+        }
+        await active.adapter.stop({ force: true, reason: "shutdown" });
+    }
+}

package/dist/control_plane_wake_delivery.d.ts

@@ -0,0 +1,50 @@
+import type { Channel, IdentityBinding, OutboundEnvelope } from "@femtomc/mu-control-plane";
+export type WakeFanoutSkipReasonCode = "channel_delivery_unsupported" | "telegram_bot_token_missing";
+export type WakeFanoutContext = {
+    wakeId: string;
+    dedupeKey: string;
+    wakeSource: string | null;
+    programId: string | null;
+    sourceTsMs: number | null;
+};
+export type WakeDeliveryMetadata = {
+    wakeId: string;
+    wakeDedupeKey: string;
+    bindingId: string;
+    channel: Channel;
+    outboxId: string;
+    outboxDedupeKey: string;
+};
+export declare function wakeFanoutDedupeKey(opts: {
+    dedupeKey: string;
+    wakeId: string;
+    binding: Pick<IdentityBinding, "channel" | "binding_id">;
+}): string;
+export declare function resolveWakeFanoutCapability(opts: {
+    binding: IdentityBinding;
+    isChannelDeliverySupported: (channel: Channel) => boolean;
+    telegramBotToken: string | null;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    reasonCode: WakeFanoutSkipReasonCode;
+};
+export declare function buildWakeOutboundEnvelope(opts: {
+    repoRoot: string;
+    nowMs: number;
+    message: string;
+    binding: IdentityBinding;
+    context: WakeFanoutContext;
+    metadata?: Record<string, unknown>;
+}): OutboundEnvelope;
+export declare function wakeDeliveryMetadataFromOutboxRecord(record: {
+    outbox_id: string;
+    dedupe_key: string;
+    envelope: Pick<OutboundEnvelope, "channel" | "metadata">;
+}): WakeDeliveryMetadata | null;
+export declare function wakeDispatchReasonCode(opts: {
+    state: "delivered" | "retried" | "dead_letter";
+    lastError: string | null;
+    deadLetterReason: string | null;
+}): string;

package/dist/control_plane_wake_delivery.js

@@ -0,0 +1,123 @@
+function sha256Hex(input) {
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(input);
+    return hasher.digest("hex");
+}
+function normalizeString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeChannel(value) {
+    switch (value) {
+        case "slack":
+        case "discord":
+        case "telegram":
+        case "terminal":
+            return value;
+        default:
+            return null;
+    }
+}
+export function wakeFanoutDedupeKey(opts) {
+    const base = opts.dedupeKey.trim().length > 0 ? opts.dedupeKey.trim() : `wake:${opts.wakeId}`;
+    return `${base}:wake:${opts.wakeId}:${opts.binding.channel}:${opts.binding.binding_id}`;
+}
+export function resolveWakeFanoutCapability(opts) {
+    const { binding } = opts;
+    if (!opts.isChannelDeliverySupported(binding.channel)) {
+        return { ok: false, reasonCode: "channel_delivery_unsupported" };
+    }
+    if (binding.channel === "telegram" && (!opts.telegramBotToken || opts.telegramBotToken.trim().length === 0)) {
+        return { ok: false, reasonCode: "telegram_bot_token_missing" };
+    }
+    return { ok: true };
+}
+export function buildWakeOutboundEnvelope(opts) {
+    const channelConversationId = opts.binding.channel_actor_id;
+    const requestId = `wake-req-${sha256Hex(`${opts.context.wakeId}:${opts.binding.binding_id}`).slice(0, 20)}`;
+    const responseId = `wake-resp-${sha256Hex(`${opts.context.wakeId}:${opts.binding.binding_id}:${opts.nowMs}`).slice(0, 20)}`;
+    return {
+        v: 1,
+        ts_ms: opts.nowMs,
+        channel: opts.binding.channel,
+        channel_tenant_id: opts.binding.channel_tenant_id,
+        channel_conversation_id: channelConversationId,
+        request_id: requestId,
+        response_id: responseId,
+        kind: "lifecycle",
+        body: opts.message,
+        correlation: {
+            command_id: `wake-${opts.context.wakeId}-${opts.binding.binding_id}`,
+            idempotency_key: `wake-idem-${opts.context.wakeId}-${opts.binding.binding_id}`,
+            request_id: requestId,
+            channel: opts.binding.channel,
+            channel_tenant_id: opts.binding.channel_tenant_id,
+            channel_conversation_id: channelConversationId,
+            actor_id: opts.binding.channel_actor_id,
+            actor_binding_id: opts.binding.binding_id,
+            assurance_tier: opts.binding.assurance_tier,
+            repo_root: opts.repoRoot,
+            scope_required: "cp.ops.admin",
+            scope_effective: "cp.ops.admin",
+            target_type: "operator_wake",
+            target_id: opts.context.wakeId,
+            attempt: 1,
+            state: "completed",
+            error_code: null,
+            operator_session_id: null,
+            operator_turn_id: null,
+            cli_invocation_id: null,
+            cli_command_kind: null,
+            run_root_id: null,
+        },
+        metadata: {
+            wake_delivery: true,
+            wake_id: opts.context.wakeId,
+            wake_dedupe_key: opts.context.dedupeKey,
+            wake_binding_id: opts.binding.binding_id,
+            wake_channel: opts.binding.channel,
+            wake_source: opts.context.wakeSource,
+            wake_program_id: opts.context.programId,
+            wake_source_ts_ms: opts.context.sourceTsMs,
+            ...(opts.metadata ?? {}),
+        },
+    };
+}
+export function wakeDeliveryMetadataFromOutboxRecord(record) {
+    const metadata = record.envelope.metadata;
+    if (metadata.wake_delivery !== true) {
+        return null;
+    }
+    const wakeId = normalizeString(metadata.wake_id);
+    const bindingId = normalizeString(metadata.wake_binding_id);
+    const wakeDedupeKey = normalizeString(metadata.wake_dedupe_key) ?? record.dedupe_key;
+    const metadataChannel = normalizeChannel(metadata.wake_channel);
+    const envelopeChannel = normalizeChannel(record.envelope.channel);
+    const channel = metadataChannel ?? envelopeChannel;
+    if (!wakeId || !bindingId || !channel) {
+        return null;
+    }
+    return {
+        wakeId,
+        wakeDedupeKey,
+        bindingId,
+        channel,
+        outboxId: record.outbox_id,
+        outboxDedupeKey: record.dedupe_key,
+    };
+}
+export function wakeDispatchReasonCode(opts) {
+    switch (opts.state) {
+        case "delivered":
+            return "outbox_delivered";
+        case "retried":
+            return opts.lastError && opts.lastError.trim().length > 0 ? opts.lastError : "outbox_retry";
+        case "dead_letter":
+            return opts.deadLetterReason && opts.deadLetterReason.trim().length > 0
+                ? opts.deadLetterReason
+                : "outbox_dead_letter";
+    }
+}

package/dist/cron_request.d.ts

@@ -0,0 +1,8 @@
+import type { CronProgramTarget } from "./cron_programs.js";
+export type ParsedCronTarget = {
+    target: CronProgramTarget | null;
+    error: string | null;
+};
+export declare function parseCronTarget(body: Record<string, unknown>): ParsedCronTarget;
+export declare function hasCronScheduleInput(body: Record<string, unknown>): boolean;
+export declare function cronScheduleInputFromBody(body: Record<string, unknown>): Record<string, unknown>;