@sentry/junior 0.265.0 → 0.267.0

package/dist/store-DdT74Lvq.js

@@ -1,1424 +0,0 @@
-import { i as getChatConfig } from "./config-BayQ9hHH.js";
-import { B as toOptionalNumber, V as toOptionalString, z as isRecord } from "./logging-D2QBriUo.js";
-import { s as parseStoredSlackActor } from "./actor-tlxzqaRe.js";
-import { V as sameDestination, d as getConversationStore, z as parseDestination } from "./viewer-B2wXNspU.js";
-import { ln as JUNIOR_THREAD_STATE_TTL_MS } from "./credentialed-C6pKlB1p.js";
-import { n as getDefaultRedisStateAdapterFor, r as getStateAdapter } from "./adapter-cUkPH3Om.js";
-import "./job-queue-Cjo6Yg_b.js";
-import { z } from "zod";
-import { randomUUID } from "node:crypto";
-import { destinationSchema } from "@sentry/junior-plugin-api";
-// src/chat/task-execution/state.ts
-/**
-* Expiring conversation mailbox and execution index store.
-*
-* The conversation record owns pending inbound work, execution status, and the
-* lease. `conversation:active` feeds heartbeat recovery and contains every
-* non-idle conversation until the lease/status path makes it idle.
-* `conversation:by-activity` supports legacy SQL import only; SQL owns durable
-* conversation metadata in configured runtime.
-*/
-const CONVERSATION_PREFIX = "junior:conversation:v2";
-const CONVERSATION_SCHEMA_VERSION = 2;
-const CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
-const CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
-const CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
-const CONVERSATION_INDEX_LOCK_RETRY_MS = 25;
-const CONVERSATION_MUTATION_LOCK_TTL_MS = 1e4;
-const CONVERSATION_MUTATION_WAIT_MS = 1e4;
-const CONVERSATION_MUTATION_RETRY_MS = 25;
-var InvalidConversationRecordError = class extends Error {
-	constructor(conversationId) {
-		super(`Conversation record is invalid for ${conversationId}`);
-		this.name = "InvalidConversationRecordError";
-	}
-};
-/** Return whether an error means a stored conversation record failed validation. */
-function isInvalidConversationRecordError(error) {
-	return error instanceof InvalidConversationRecordError;
-}
-var ConversationMutationFencedError = class extends Error {
-	constructor(conversationId) {
-		super(`Conversation mutation lock was lost before write for ${conversationId}`);
-		this.name = "ConversationMutationFencedError";
-	}
-};
-const CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
-const CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
-const CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
-const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
-const CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
-const inboundMessageSourceSchema = z.enum([
-	"api",
-	"internal",
-	"local",
-	"plugin",
-	"event",
-	"scheduler",
-	"slack",
-	"web"
-]);
-const agentInputSchema = z.object({
-	attachments: z.array(z.unknown()).optional(),
-	authorId: z.string().min(1).optional(),
-	metadata: z.record(z.string(), z.unknown()).optional(),
-	text: z.string()
-}).strict().refine((input) => input.text.trim() || input.attachments?.length, { message: "agent input requires text or attachments" });
-/** Durable delivery modes for pending inbound mailbox work. */
-const inboundMessageDeliverySchema = z.enum(["defer", "interrupt"]);
-/** Sentry trace propagation headers captured when an inbound message arrives. */
-const inboundMessageTraceContextSchema = z.object({
-	baggage: z.string().optional(),
-	sentryTrace: z.string().min(1)
-}).optional().catch(void 0);
-/** Redis mailbox shape kept for deployed workers that still require this field. */
-const storedInboundMessageSchema = z.object({
-	attemptCount: z.number().finite().optional(),
-	conversationId: z.string().refine((value) => value.trim().length > 0),
-	createdAtMs: z.number().finite(),
-	delivery: inboundMessageDeliverySchema,
-	destination: destinationSchema.optional(),
-	inboundMessageId: z.string().refine((value) => value.trim().length > 0),
-	injectedAtMs: z.number().finite().optional(),
-	input: agentInputSchema,
-	receivedAtMs: z.number().finite(),
-	source: inboundMessageSourceSchema,
-	traceContext: inboundMessageTraceContextSchema
-}).strict().extend({ publishExternally: z.boolean() });
-function conversationKey(conversationId) {
-	return `${CONVERSATION_PREFIX}:${conversationId}`;
-}
-function conversationStopKey(conversationId) {
-	return `${CONVERSATION_PREFIX}:stop:${conversationId}`;
-}
-function indexLockKey(indexKey) {
-	return `${indexKey}:lock`;
-}
-function mutationLockKey(conversationId) {
-	return `${CONVERSATION_PREFIX}:mutation:${conversationId}`;
-}
-function now$1() {
-	return Date.now();
-}
-function compareMessages(left, right) {
-	return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
-}
-function inputHasAttachments(input) {
-	return Array.isArray(input.attachments) && input.attachments.length > 0;
-}
-/**
-* Upgrade a still-pending payload when a duplicate source event carries file
-* attachments the stored copy lacks (Slack `app_mention`/`message` twins),
-* keeping the stored ordering timestamps and delivery attempts.
-*/
-function upgradedPendingMessage(stored, duplicate) {
-	const promotesInterrupt = stored.delivery === "defer" && duplicate.delivery === "interrupt";
-	const delivery = promotesInterrupt ? "interrupt" : stored.delivery;
-	const input = promotesInterrupt ? {
-		...duplicate.input,
-		...inputHasAttachments(duplicate.input) || !inputHasAttachments(stored.input) ? void 0 : { attachments: stored.input.attachments }
-	} : inputHasAttachments(duplicate.input) && !inputHasAttachments(stored.input) ? duplicate.input : stored.input;
-	if (input === stored.input && delivery === stored.delivery) return stored;
-	return {
-		...stored,
-		delivery,
-		input
-	};
-}
-function compareIndexDescending(left, right) {
-	return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
-}
-function compareIndexAscending(left, right) {
-	return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
-}
-function uniqueStrings(values) {
-	return [...new Set(values)];
-}
-function normalizeSource(value) {
-	const parsed = inboundMessageSourceSchema.safeParse(value);
-	return parsed.success ? parsed.data : void 0;
-}
-function normalizeExecutionStatus(value) {
-	if (value === "paused") return value;
-	if (value === "failed" || value === "idle" || value === "pending" || value === "running") return value;
-}
-function normalizeMessage(value) {
-	const parsed = storedInboundMessageSchema.safeParse(value);
-	if (!parsed.success) return;
-	const { publishExternally: _publishExternally, traceContext, ...message } = parsed.data;
-	return traceContext ? {
-		...message,
-		traceContext
-	} : message;
-}
-function storeMessage(message, publishExternally) {
-	return {
-		...message,
-		publishExternally
-	};
-}
-/** Whether this is the final attempt before an unacked message is dead-lettered. */
-function isFinalAttempt(message) {
-	return (message.attemptCount ?? 0) >= 4;
-}
-function normalizeActor(value) {
-	return parseStoredSlackActor(value);
-}
-function normalizeLease(value) {
-	if (!isRecord(value)) return;
-	const token = toOptionalString(value.token);
-	const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
-	const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
-	const expiresAtMs = toOptionalNumber(value.expiresAtMs);
-	if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") return;
-	return {
-		token,
-		acquiredAtMs,
-		lastCheckInAtMs,
-		expiresAtMs
-	};
-}
-function normalizeStop(value) {
-	if (!isRecord(value)) return;
-	const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(value.inboundMessageIds.filter((id) => typeof id === "string")) : [];
-	const runId = toOptionalString(value.runId);
-	return runId ? {
-		inboundMessageIds,
-		runId
-	} : void 0;
-}
-/** Decode execution state and repair idle records that still own work. */
-function normalizeExecution(conversationId, value) {
-	if (!isRecord(value)) return;
-	const status = normalizeExecutionStatus(value.status);
-	if (!status) return;
-	const pendingMessages = [];
-	if (Array.isArray(value.pendingMessages)) {
-		for (const rawMessage of value.pendingMessages) {
-			const message = normalizeMessage(rawMessage);
-			if (!message || message.conversationId !== conversationId) return;
-			if (message.injectedAtMs !== void 0) continue;
-			pendingMessages.push(message);
-		}
-		pendingMessages.sort(compareMessages);
-	}
-	const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))) : [];
-	const lease = normalizeLease(value.lease);
-	const runId = toOptionalString(value.runId);
-	return {
-		status: status === "idle" && lease ? "running" : status === "idle" && pendingMessages.length > 0 ? "pending" : status,
-		inboundMessageIds: uniqueStrings([...inboundMessageIds, ...pendingMessages.map((message) => message.inboundMessageId)]),
-		pendingCount: pendingMessages.length,
-		pendingMessages,
-		lease,
-		lastCheckpointAtMs: toOptionalNumber(value.lastCheckpointAtMs),
-		lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
-		lastProgressAtMs: toOptionalNumber(value.lastProgressAtMs),
-		retryCount: toOptionalNumber(value.retryCount),
-		runId,
-		updatedAtMs: toOptionalNumber(value.updatedAtMs)
-	};
-}
-/** Decode current conversation records. */
-function normalizeConversation(conversationId, value) {
-	if (!isRecord(value) || value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) return;
-	const storedConversationId = toOptionalString(value.conversationId);
-	const createdAtMs = toOptionalNumber(value.createdAtMs);
-	const lastActivityAtMs = toOptionalNumber(value.lastActivityAtMs);
-	const updatedAtMs = toOptionalNumber(value.updatedAtMs);
-	const execution = normalizeExecution(conversationId, value.execution);
-	const destination = value.destination === void 0 ? void 0 : parseDestination(value.destination);
-	if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) return;
-	if (execution.pendingMessages.length > 0 && execution.pendingMessages.some((message) => {
-		if (!message.destination) return false;
-		return !destination || !sameDestination(message.destination, destination);
-	})) return;
-	return {
-		schemaVersion: CONVERSATION_SCHEMA_VERSION,
-		conversationId,
-		createdAtMs,
-		lastActivityAtMs,
-		updatedAtMs,
-		execution,
-		...destination ? { destination } : void 0,
-		...toOptionalString(value.title) ? { title: toOptionalString(value.title) } : void 0,
-		...toOptionalString(value.channelName) ? { channelName: toOptionalString(value.channelName) } : void 0,
-		...normalizeActor(value.actor) ? { actor: normalizeActor(value.actor) } : void 0,
-		...normalizeSource(value.source) ? { source: normalizeSource(value.source) } : void 0
-	};
-}
-function emptyConversation(args) {
-	return {
-		schemaVersion: CONVERSATION_SCHEMA_VERSION,
-		conversationId: args.conversationId,
-		createdAtMs: args.nowMs,
-		lastActivityAtMs: args.nowMs,
-		updatedAtMs: args.nowMs,
-		...args.destination ? { destination: args.destination } : void 0,
-		...args.source ? { source: args.source } : void 0,
-		execution: {
-			status: "idle",
-			inboundMessageIds: [],
-			pendingCount: 0,
-			pendingMessages: [],
-			updatedAtMs: args.nowMs
-		}
-	};
-}
-function isLeaseActive(lease, nowMs) {
-	return Boolean(lease && lease.expiresAtMs > nowMs);
-}
-function pendingMessages(conversation) {
-	return [...conversation.execution.pendingMessages].sort(compareMessages);
-}
-function isRunnableStatus(status) {
-	return status !== "failed" && status !== "idle";
-}
-function hasRunnableWork(conversation) {
-	return isRunnableStatus(conversation.execution.status) || pendingMessages(conversation).length > 0;
-}
-function executionWithPendingMessages(execution, pending) {
-	const pendingMessages = [...pending].sort(compareMessages);
-	const status = execution.status === "idle" && execution.lease ? "running" : execution.status === "idle" && pendingMessages.length > 0 ? "pending" : execution.status;
-	return {
-		...execution,
-		status,
-		inboundMessageIds: uniqueStrings([...execution.inboundMessageIds, ...pendingMessages.map((message) => message.inboundMessageId)]),
-		pendingMessages,
-		pendingCount: pendingMessages.length
-	};
-}
-function withExecutionUpdate(conversation, execution, nowMs) {
-	return {
-		...conversation,
-		updatedAtMs: nowMs,
-		execution: {
-			...executionWithPendingMessages(execution, execution.pendingMessages),
-			updatedAtMs: nowMs
-		}
-	};
-}
-async function getConnectedState(stateAdapter) {
-	const state = stateAdapter ?? getStateAdapter();
-	await state.connect();
-	return state;
-}
-async function sleep(ms) {
-	await new Promise((resolve) => {
-		setTimeout(resolve, ms).unref?.();
-	});
-}
-async function withIndexLock(state, indexKey, callback) {
-	const startedAtMs = now$1();
-	let lock;
-	while (true) {
-		lock = await state.acquireLock(indexLockKey(indexKey), CONVERSATION_INDEX_LOCK_TTL_MS);
-		if (lock) break;
-		if (now$1() - startedAtMs >= CONVERSATION_INDEX_LOCK_WAIT_MS) throw new Error(`Could not acquire conversation index lock for ${indexKey}`);
-		await sleep(CONVERSATION_INDEX_LOCK_RETRY_MS);
-	}
-	try {
-		return await callback();
-	} finally {
-		await state.releaseLock(lock);
-	}
-}
-function normalizeIndexEntry(value) {
-	if (!isRecord(value)) return;
-	const conversationId = toOptionalString(value.conversationId);
-	const score = toOptionalNumber(value.score);
-	if (!conversationId || typeof score !== "number") return;
-	return {
-		conversationId,
-		score
-	};
-}
-function uniqueIndexEntries(value) {
-	if (!Array.isArray(value)) return [];
-	const entries = /* @__PURE__ */ new Map();
-	for (const item of value) {
-		const entry = normalizeIndexEntry(item);
-		if (!entry) continue;
-		const existing = entries.get(entry.conversationId);
-		if (!existing || entry.score > existing.score) entries.set(entry.conversationId, entry);
-	}
-	return [...entries.values()];
-}
-function retainedIndexEntries(indexKey, entries) {
-	if (indexKey === "junior:conversation:v2:by-activity") return entries.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH);
-	if (indexKey === "junior:conversation:v2:active") return entries.sort(compareIndexAscending);
-	throw new Error(`Unknown conversation index ${indexKey}`);
-}
-function redisIndexKey(indexKey) {
-	const prefix = getChatConfig().state.keyPrefix;
-	return [...prefix ? [prefix] : [], indexKey].join(":");
-}
-function parseRedisIndexEntries(values) {
-	if (!Array.isArray(values)) return [];
-	const entries = [];
-	for (let index = 0; index < values.length; index += 2) {
-		const conversationId = toOptionalString(values[index]);
-		const score = typeof values[index + 1] === "number" ? values[index + 1] : Number(values[index + 1]);
-		if (!conversationId || !Number.isFinite(score)) continue;
-		entries.push({
-			conversationId,
-			score
-		});
-	}
-	return entries;
-}
-function redisConversationIndexStore(client) {
-	const upsertBoundedActivityScript = `
-    redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
-    redis.call("PEXPIRE", KEYS[1], ARGV[3])
-    local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
-    if extra > 0 then
-      redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
-    end
-    return 1
-  `;
-	return {
-		async list(args) {
-			const key = redisIndexKey(args.indexKey);
-			const limit = args.limit;
-			const offset = Math.max(0, args.offset ?? 0);
-			if (limit === 0) return [];
-			return parseRedisIndexEntries(args.scoreMax !== void 0 ? await client.sendCommand([
-				"ZRANGEBYSCORE",
-				key,
-				"-inf",
-				String(args.scoreMax),
-				"WITHSCORES",
-				...limit !== void 0 || offset > 0 ? [
-					"LIMIT",
-					String(offset),
-					String(limit ?? 1e9)
-				] : []
-			]) : await client.sendCommand([
-				args.order === "asc" ? "ZRANGE" : "ZREVRANGE",
-				key,
-				String(offset),
-				String(limit === void 0 ? -1 : offset + Math.max(0, limit - 1)),
-				"WITHSCORES"
-			]));
-		},
-		async remove(args) {
-			await client.sendCommand([
-				"ZREM",
-				redisIndexKey(args.indexKey),
-				args.conversationId
-			]);
-		},
-		async upsert(args) {
-			const key = redisIndexKey(args.indexKey);
-			if (args.indexKey === "junior:conversation:v2:by-activity") {
-				await client.sendCommand([
-					"EVAL",
-					upsertBoundedActivityScript,
-					"1",
-					key,
-					String(args.score),
-					args.conversationId,
-					String(JUNIOR_THREAD_STATE_TTL_MS),
-					String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
-				]);
-				return;
-			}
-			if (args.indexKey === "junior:conversation:v2:active") {
-				await client.sendCommand([
-					"ZADD",
-					key,
-					String(args.score),
-					args.conversationId
-				]);
-				await client.sendCommand([
-					"PEXPIRE",
-					key,
-					String(JUNIOR_THREAD_STATE_TTL_MS)
-				]);
-				return;
-			}
-			throw new Error(`Unknown conversation index ${args.indexKey}`);
-		}
-	};
-}
-function emulatedConversationIndexStore(state) {
-	const readIndex = async (indexKey) => uniqueIndexEntries(await state.get(indexKey));
-	const writeIndex = async (indexKey, entries) => {
-		await state.set(indexKey, entries, JUNIOR_THREAD_STATE_TTL_MS);
-	};
-	return {
-		async list(args) {
-			const entries = (await readIndex(args.indexKey)).filter((entry) => args.scoreMax === void 0 ? true : entry.score <= args.scoreMax).sort(args.order === "asc" ? compareIndexAscending : compareIndexDescending);
-			const offset = Math.max(0, args.offset ?? 0);
-			return entries.slice(offset, args.limit === void 0 ? entries.length : offset + args.limit);
-		},
-		async remove(args) {
-			await withIndexLock(state, args.indexKey, async () => {
-				const entries = await readIndex(args.indexKey);
-				const next = entries.filter((entry) => entry.conversationId !== args.conversationId);
-				if (next.length === entries.length) return;
-				await writeIndex(args.indexKey, next);
-			});
-		},
-		async upsert(args) {
-			await withIndexLock(state, args.indexKey, async () => {
-				const withoutCurrent = (await readIndex(args.indexKey)).filter((entry) => entry.conversationId !== args.conversationId);
-				const next = retainedIndexEntries(args.indexKey, [...withoutCurrent, {
-					conversationId: args.conversationId,
-					score: args.score
-				}]);
-				await writeIndex(args.indexKey, next);
-			});
-		}
-	};
-}
-async function getConversationIndexStore(state) {
-	const redisStateAdapter = await getDefaultRedisStateAdapterFor(state);
-	if (redisStateAdapter) return redisConversationIndexStore(redisStateAdapter.getClient());
-	return emulatedConversationIndexStore(state);
-}
-async function upsertIndexEntry(args) {
-	await (await getConversationIndexStore(args.state)).upsert({
-		conversationId: args.conversationId,
-		indexKey: args.indexKey,
-		score: args.score
-	});
-}
-async function removeIndexEntry(args) {
-	await (await getConversationIndexStore(args.state)).remove({
-		conversationId: args.conversationId,
-		indexKey: args.indexKey
-	});
-}
-async function acquireMutationLock(state, conversationId) {
-	const startedAtMs = now$1();
-	while (true) {
-		const lock = await state.acquireLock(mutationLockKey(conversationId), CONVERSATION_MUTATION_LOCK_TTL_MS);
-		if (lock) return lock;
-		if (now$1() - startedAtMs >= CONVERSATION_MUTATION_WAIT_MS) throw new Error(`Could not acquire conversation mutation lock for ${conversationId}`);
-		await sleep(CONVERSATION_MUTATION_RETRY_MS);
-	}
-}
-async function withConversationMutation(args, callback) {
-	const state = await getConnectedState(args.state);
-	const lock = await acquireMutationLock(state, args.conversationId);
-	try {
-		return await callback(state, lock);
-	} finally {
-		await state.releaseLock(lock);
-	}
-}
-async function readConversation(state, conversationId) {
-	const raw = await state.get(conversationKey(conversationId));
-	if (raw == null) return;
-	const conversation = normalizeConversation(conversationId, raw);
-	if (!conversation) throw new InvalidConversationRecordError(conversationId);
-	return conversation;
-}
-/**
-* Persist a conversation and refresh its reporting and active-recovery indexes.
-*
-* Conversation writes are lock-serialized blind whole-record writes, so the
-* mutation lock is re-validated (and extended) immediately before the write:
-* a stalled mutator that lost its lock must fail loudly instead of clobbering
-* a newer record with a stale copy.
-*/
-async function writeConversation(state, lock, conversation) {
-	const execution = executionWithPendingMessages(conversation.execution, conversation.execution.pendingMessages);
-	const next = {
-		...conversation,
-		execution
-	};
-	await fenceConversationMutation(state, lock, next.conversationId);
-	const hasSlackDestination = next.destination?.platform === "slack";
-	const stored = {
-		...next,
-		execution: {
-			...next.execution,
-			pendingMessages: next.execution.pendingMessages.map((message) => storeMessage(message, hasSlackDestination && (message.source === "slack" || message.source === "event" || message.source === "plugin" || message.source === "scheduler")))
-		}
-	};
-	await state.set(conversationKey(next.conversationId), stored, JUNIOR_THREAD_STATE_TTL_MS);
-	await upsertIndexEntry({
-		state,
-		indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
-		conversationId: next.conversationId,
-		score: next.lastActivityAtMs
-	});
-	if (!hasRunnableWork(next)) {
-		await removeIndexEntry({
-			state,
-			indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-			conversationId: next.conversationId
-		});
-		return;
-	}
-	await upsertIndexEntry({
-		state,
-		indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-		conversationId: next.conversationId,
-		score: next.execution.updatedAtMs ?? next.updatedAtMs
-	});
-}
-function assertSameOptionalConversationDestination(args) {
-	if (!args.next || !args.current) return;
-	if (sameDestination(args.current, args.next)) return;
-	throw new Error(`Conversation destination changed for ${args.conversationId}`);
-}
-function conversationWorkState(conversation) {
-	const lease = conversation.execution.lease;
-	return {
-		...conversation,
-		lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
-		...lease ? { lease: {
-			acquiredAtMs: lease.acquiredAtMs,
-			lastCheckInAtMs: lease.lastCheckInAtMs,
-			leaseExpiresAtMs: lease.expiresAtMs,
-			leaseToken: lease.token
-		} } : void 0,
-		messages: pendingMessages(conversation),
-		needsRun: hasRunnableWork(conversation)
-	};
-}
-/** Return a persisted conversation record, if one exists. */
-async function getConversation$1(args) {
-	return await readConversation(await getConnectedState(args.state), args.conversationId);
-}
-/** Return a persisted conversation work record, if one exists. */
-async function getConversationWorkState$1(args) {
-	const conversation = await getConversation$1(args);
-	return conversation ? conversationWorkState(conversation) : void 0;
-}
-/** Return whether a conversation has pending or resumable execution work. */
-function hasRunnableConversationWork$1(conversation) {
-	return hasRunnableWork(conversation);
-}
-async function appendInboundMessageWithAdmission(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation({
-		conversationId: args.message.conversationId,
-		state: args.state
-	}, async (state, lock) => {
-		const existing = await readConversation(state, args.message.conversationId);
-		const current = existing ?? emptyConversation({
-			conversationId: args.message.conversationId,
-			destination: args.message.destination,
-			nowMs,
-			source: args.message.source
-		});
-		if (existing) assertSameOptionalConversationDestination({
-			conversationId: args.message.conversationId,
-			current: current.destination,
-			next: args.message.destination
-		});
-		const existingPending = current.execution.pendingMessages.some((message) => message.inboundMessageId === args.message.inboundMessageId);
-		if (current.execution.inboundMessageIds.includes(args.message.inboundMessageId)) {
-			if (!existingPending) return { status: "duplicate" };
-			const nextStatus = current.execution.status === "idle" ? "pending" : current.execution.status;
-			await writeConversation(state, lock, withExecutionUpdate(current, {
-				...current.execution,
-				status: nextStatus,
-				pendingMessages: current.execution.pendingMessages.map((message) => message.inboundMessageId === args.message.inboundMessageId ? upgradedPendingMessage(message, args.message) : message)
-			}, nowMs));
-			return { status: "duplicate" };
-		}
-		if (args.exclusive && hasRunnableWork(current)) return { status: "active" };
-		let status;
-		if (current.execution.lease) status = current.execution.status === "running" ? "running" : "paused";
-		else if (current.execution.status === "paused" && args.message.delivery === "defer") status = "paused";
-		else status = "pending";
-		await writeConversation(state, lock, withExecutionUpdate({
-			...current,
-			destination: current.destination ?? args.message.destination,
-			source: current.source ?? args.message.source,
-			lastActivityAtMs: nowMs
-		}, {
-			...current.execution,
-			status,
-			inboundMessageIds: [...current.execution.inboundMessageIds, args.message.inboundMessageId],
-			pendingMessages: [...current.execution.pendingMessages, args.message].sort(compareMessages)
-		}, nowMs));
-		return { status: "appended" };
-	});
-}
-/** Persist one inbound message idempotently in its conversation mailbox. */
-async function appendInboundMessage(args) {
-	const result = await appendInboundMessageWithAdmission({
-		...args,
-		exclusive: false
-	});
-	if (result.status === "active") throw new Error("Non-exclusive mailbox append returned active");
-	return result;
-}
-/** Append only when the Conversation has no other runnable work. */
-async function appendExclusiveInboundMessage(args) {
-	return await appendInboundMessageWithAdmission({
-		...args,
-		exclusive: true
-	});
-}
-/** Mark a conversation runnable when there is no new mailbox message. */
-async function requestConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const existing = await readConversation(state, args.conversationId);
-		if (existing) assertSameOptionalConversationDestination({
-			conversationId: args.conversationId,
-			current: existing.destination,
-			next: args.destination
-		});
-		const current = existing ?? emptyConversation({
-			conversationId: args.conversationId,
-			destination: args.destination,
-			nowMs
-		});
-		const status = current.execution.lease ? "paused" : "pending";
-		await writeConversation(state, lock, withExecutionUpdate({
-			...current,
-			destination: current.destination ?? args.destination
-		}, {
-			...current.execution,
-			status
-		}, nowMs));
-		return { status: existing === void 0 ? "created" : "updated" };
-	});
-}
-/** Record that a wake-up nudge was accepted for the conversation. */
-async function markConversationWorkEnqueued$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current) return;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: nowMs
-		}, nowMs));
-	});
-}
-/** Clear a wake marker after its queue delivery finds no runnable work. */
-async function clearConsumedConversationWake$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || hasRunnableWork(current) || current.execution.lastEnqueuedAtMs === void 0) return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: void 0
-		}, nowMs));
-		return true;
-	});
-}
-/** Try to acquire the durable execution lease for one conversation. */
-async function startConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current) return { status: "no_work" };
-		if (isLeaseActive(current.execution.lease, nowMs)) return {
-			status: "active",
-			leaseExpiresAtMs: current.execution.lease.expiresAtMs
-		};
-		if (!hasRunnableWork(current)) return { status: "no_work" };
-		const lease = {
-			token: randomUUID(),
-			acquiredAtMs: nowMs,
-			lastCheckInAtMs: nowMs,
-			expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-		};
-		const startsNewRun = current.execution.runId === void 0;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease,
-			status: current.execution.status === "paused" ? "paused" : "running",
-			runId: current.execution.runId ?? randomUUID(),
-			lastEnqueuedAtMs: void 0,
-			retryCount: startsNewRun ? 0 : current.execution.retryCount
-		}, nowMs));
-		return {
-			status: "acquired",
-			leaseToken: lease.token,
-			leaseExpiresAtMs: lease.expiresAtMs
-		};
-	});
-}
-/** Extend the durable execution lease when the worker checks in. */
-async function checkInConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: {
-				...current.execution.lease,
-				lastCheckInAtMs: nowMs,
-				expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-			}
-		}, nowMs));
-		return true;
-	});
-}
-/**
-* Resolve pending mailbox entries after the caller accepts responsibility.
-*
-* Returning ids acknowledges only that subset; returning nothing acknowledges
-* every pending entry passed to the handler.
-*/
-async function drainConversationMailbox$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	const pending = await withConversationMutation(args, async (state) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) throw new Error(`Conversation lease is not held for ${args.conversationId}`);
-		return pendingMessages(current);
-	});
-	if (pending.length === 0) return {
-		changed: false,
-		messages: []
-	};
-	const result = await args.handle(pending);
-	const pendingIds = new Set(pending.map((message) => message.inboundMessageId));
-	const acknowledgedIds = new Set(result ?? pending.map((message) => message.inboundMessageId));
-	for (const inboundMessageId of acknowledgedIds) if (!pendingIds.has(inboundMessageId)) throw new Error(`Conversation mailbox drain result is not pending for ${args.conversationId}`);
-	if (acknowledgedIds.size === 0) return {
-		changed: false,
-		messages: []
-	};
-	await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) throw new Error(`Conversation lease is not held for ${args.conversationId}`);
-		const pendingMessages = current.execution.pendingMessages.filter((message) => !acknowledgedIds.has(message.inboundMessageId));
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			status: current.execution.status === "pending" && pendingMessages.length === 0 ? "running" : current.execution.status,
-			lastProgressAtMs: nowMs,
-			retryCount: 0,
-			pendingMessages
-		}, nowMs));
-	});
-	return {
-		changed: true,
-		messages: pending.filter((message) => acknowledgedIds.has(message.inboundMessageId))
-	};
-}
-/** Acknowledge leased mailbox entries after the handler accepts responsibility. */
-async function ackMessages$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	const inboundMessageIds = new Set(args.inboundMessageIds);
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		if (inboundMessageIds.size === 0) return true;
-		const pendingMessages = current.execution.pendingMessages.filter((message) => !inboundMessageIds.has(message.inboundMessageId));
-		if (pendingMessages.length === current.execution.pendingMessages.length) return true;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastProgressAtMs: nowMs,
-			retryCount: 0,
-			pendingMessages
-		}, nowMs));
-		return true;
-	});
-}
-function isHumanFacingMessage(message) {
-	return message.source === "web" || message.source === "slack";
-}
-async function readConversationStop(state, conversationId) {
-	return normalizeStop(await state.get(conversationStopKey(conversationId)));
-}
-async function fenceConversationMutation(state, lock, conversationId) {
-	if (!await state.extendLock(lock, CONVERSATION_MUTATION_LOCK_TTL_MS)) throw new ConversationMutationFencedError(conversationId);
-}
-/** Return whether one Conversation run has a durable stop request. */
-async function hasConversationStop(args) {
-	return (await readConversationStop(await getConnectedState(args.state), args.conversationId))?.runId === args.runId;
-}
-/** Persist a stop request for the current run without process affinity. */
-async function stopConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || !hasRunnableWork(current)) return { status: "no_work" };
-		const runId = current.execution.runId ?? randomUUID();
-		const pendingMessages = current.execution.pendingMessages.filter(isHumanFacingMessage);
-		const inboundMessageIds = pendingMessages.map((message) => message.inboundMessageId);
-		if (current.execution.runId === void 0) await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			runId
-		}, nowMs));
-		await fenceConversationMutation(state, lock, args.conversationId);
-		await state.set(conversationStopKey(args.conversationId), {
-			inboundMessageIds,
-			runId
-		}, JUNIOR_THREAD_STATE_TTL_MS);
-		return {
-			runId,
-			status: "requested",
-			pendingMessages
-		};
-	});
-}
-/** Clear one observed stop request and discard older human-facing mailbox work. */
-async function completeConversationStop$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return {
-			status: "lost_lease",
-			removedInboundMessageIds: []
-		};
-		const stop = await readConversationStop(state, args.conversationId);
-		if (!stop || stop.runId !== args.runId) return {
-			status: "none",
-			removedInboundMessageIds: []
-		};
-		const stoppedInboundMessageIds = new Set(stop.inboundMessageIds);
-		const removedInboundMessageIds = [];
-		const pendingMessages = current.execution.pendingMessages.filter((message) => {
-			const shouldStop = stoppedInboundMessageIds.has(message.inboundMessageId);
-			if (shouldStop) removedInboundMessageIds.push(message.inboundMessageId);
-			return !shouldStop;
-		});
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: pendingMessages.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
-			pendingMessages
-		}, nowMs));
-		await fenceConversationMutation(state, lock, args.conversationId);
-		await state.delete(conversationStopKey(args.conversationId));
-		return {
-			status: "cleared",
-			removedInboundMessageIds
-		};
-	});
-}
-/** Cancel human-facing pending mailbox rows without requiring a worker lease. */
-async function cancelHumanFacingPendingMessages$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	const requestedIds = args.inboundMessageIds === void 0 ? void 0 : new Set(args.inboundMessageIds);
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current) return {
-			cancelledInboundMessageIds: [],
-			cancelledMessages: []
-		};
-		const cancelledInboundMessageIds = [];
-		const cancelledMessages = [];
-		const pendingMessages = [];
-		for (const message of current.execution.pendingMessages) {
-			const isRequested = requestedIds === void 0 || requestedIds.has(message.inboundMessageId);
-			const isInSnapshot = args.receivedBeforeMs === void 0 || message.receivedAtMs <= args.receivedBeforeMs;
-			if (isHumanFacingMessage(message) && isRequested && isInSnapshot) {
-				cancelledInboundMessageIds.push(message.inboundMessageId);
-				cancelledMessages.push(message);
-				continue;
-			}
-			pendingMessages.push(message);
-		}
-		if (cancelledInboundMessageIds.length === 0) return {
-			cancelledInboundMessageIds,
-			cancelledMessages
-		};
-		const becomesIdle = current.execution.status === "pending" && pendingMessages.length === 0;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: pendingMessages.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
-			pendingMessages,
-			retryCount: becomesIdle ? 0 : current.execution.retryCount,
-			runId: becomesIdle ? void 0 : current.execution.runId,
-			status: becomesIdle ? "idle" : current.execution.status
-		}, nowMs));
-		return {
-			cancelledInboundMessageIds,
-			cancelledMessages
-		};
-	});
-}
-/** Mark the leased conversation as needing another queue-delivered slice. */
-async function requestAnotherSlice$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		assertSameOptionalConversationDestination({
-			conversationId: args.conversationId,
-			current: current.destination,
-			next: args.destination
-		});
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			status: "paused"
-		}, nowMs));
-		return true;
-	});
-}
-/** Begin a requested turn resume under the worker's existing lease. */
-async function beginConversationResume$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken || current.execution.status !== "paused") return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			status: "running"
-		}, nowMs));
-		return true;
-	});
-}
-/** Release the durable execution lease without changing completion state. */
-async function releaseConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: void 0,
-			status: current.execution.status === "running" ? "pending" : current.execution.status
-		}, nowMs));
-		return true;
-	});
-}
-/** Count one failed execution attempt and stop the conversation when retries are exhausted. */
-async function recordConversationRetry$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
-		const count = (current.execution.retryCount ?? 0) + 1;
-		const stopped = count >= 5;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: void 0,
-			lease: stopped ? void 0 : current.execution.lease,
-			retryCount: count,
-			pendingMessages: stopped ? [] : current.execution.pendingMessages,
-			runId: stopped ? void 0 : current.execution.runId,
-			status: stopped ? "failed" : "paused"
-		}, nowMs));
-		return stopped ? "stopped" : "recorded";
-	});
-}
-/** Finish a leased conversation and report whether runnable work remains. */
-async function completeConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
-		const hasPending = pendingMessages(current).length > 0;
-		const stopped = args.resumeIfStopped === true && (await readConversationStop(state, args.conversationId))?.runId === current.execution.runId;
-		const needsRun = current.execution.status === "paused" || stopped;
-		const runnable = needsRun || hasPending;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: void 0,
-			status: needsRun ? "paused" : hasPending ? "pending" : "idle",
-			lastProgressAtMs: args.madeProgress === false ? current.execution.lastProgressAtMs : nowMs,
-			retryCount: runnable || args.madeProgress === false ? current.execution.retryCount : 0,
-			runId: runnable ? current.execution.runId : void 0
-		}, nowMs));
-		return runnable ? "pending" : "completed";
-	});
-}
-/**
-* Record one failed execution attempt for pending messages, dead-lettering
-* the conversation when its retry budget or the legacy message delivery limit
-* is exhausted.
-*
-* Retries are counted only when the run made no durable progress: if any
-* attempted message left the mailbox, the remaining pending entries may be
-* deliberate deferrals and are left untouched. Consumed message ids stay in
-* `inboundMessageIds` so source retries remain duplicates.
-*/
-async function recordAttemptFailure$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return {
-			status: "lost_lease",
-			pendingCount: 0,
-			deadLetteredMessages: [],
-			retryCount: 0
-		};
-		const pendingIds = new Set(current.execution.pendingMessages.map((message) => message.inboundMessageId));
-		if (args.inboundMessageIds.length === 0 || args.inboundMessageIds.some((id) => !pendingIds.has(id))) return {
-			status: "skipped",
-			pendingCount: current.execution.pendingMessages.length,
-			deadLetteredMessages: [],
-			retryCount: current.execution.retryCount ?? 0
-		};
-		const retryCount = (current.execution.retryCount ?? 0) + 1;
-		const retriesExhausted = retryCount >= 5;
-		const attemptedIds = new Set(args.inboundMessageIds);
-		const deadLetteredMessages = [];
-		const pendingMessages = [];
-		for (const message of current.execution.pendingMessages) {
-			if (!attemptedIds.has(message.inboundMessageId)) {
-				if (retriesExhausted) deadLetteredMessages.push(message);
-				else pendingMessages.push(message);
-				continue;
-			}
-			const attempted = {
-				...message,
-				attemptCount: (message.attemptCount ?? 0) + 1
-			};
-			if (retriesExhausted || attempted.attemptCount >= 5) {
-				deadLetteredMessages.push(attempted);
-				continue;
-			}
-			pendingMessages.push(attempted);
-		}
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			retryCount,
-			pendingMessages
-		}, nowMs));
-		return {
-			status: "recorded",
-			pendingCount: pendingMessages.length,
-			deadLetteredMessages,
-			retryCount
-		};
-	});
-}
-/** Record a terminal failure completion for a leased conversation. */
-async function deadLetterAttempt$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
-		const runnable = pendingMessages(current).length > 0;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: void 0,
-			status: runnable ? "pending" : "failed",
-			runId: runnable ? current.execution.runId : void 0
-		}, nowMs));
-		return runnable ? "pending" : "failed";
-	});
-}
-/** Recover an expired lease, consuming the retry budget under the mutation lock. */
-async function clearExpiredConversationLease$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current?.execution.lease || current.execution.lease.expiresAtMs > nowMs) return "not_expired";
-		const retryCount = (current.execution.retryCount ?? 0) + 1;
-		const stopped = retryCount >= 5;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: void 0,
-			lease: void 0,
-			retryCount,
-			pendingMessages: stopped ? [] : current.execution.pendingMessages,
-			runId: stopped ? void 0 : current.execution.runId,
-			status: stopped ? "failed" : "paused"
-		}, nowMs));
-		return stopped ? "stopped" : "requeued";
-	});
-}
-/** Remove one conversation from the active index after it is missing or idle. */
-async function removeActiveConversation$1(args) {
-	await removeIndexEntry({
-		state: await getConnectedState(args.state),
-		indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-		conversationId: args.conversationId
-	});
-}
-/** List active conversation ids by oldest execution update first. */
-async function listActiveConversationIds$1(args = {}) {
-	return (await (await getConversationIndexStore(await getConnectedState(args.state))).list({
-		indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-		limit: args.limit,
-		order: "asc",
-		scoreMax: args.staleBeforeMs
-	})).map((entry) => entry.conversationId);
-}
-// src/chat/task-execution/store.ts
-function metadataStore(options) {
-	return options.conversationStore ?? getConversationStore();
-}
-function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
-	return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
-}
-function hasRecentEnqueueMarker(conversation, nowMs) {
-	const lastEnqueuedAtMs = conversation.execution.lastEnqueuedAtMs;
-	return typeof lastEnqueuedAtMs === "number" && lastEnqueuedAtMs + 6e4 > nowMs;
-}
-function now() {
-	return Date.now();
-}
-async function recordExecutionMetadata(args) {
-	const conversation = await getConversation$1({
-		conversationId: args.conversationId,
-		state: args.state
-	});
-	if (!conversation) return;
-	await metadataStore(args).recordExecution({
-		channelName: conversation.channelName,
-		conversationId: conversation.conversationId,
-		createdAtMs: conversation.createdAtMs,
-		destination: conversation.destination,
-		execution: {
-			lastCheckpointAtMs: conversation.execution.lastCheckpointAtMs,
-			lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
-			runId: conversation.execution.runId,
-			status: conversation.execution.status,
-			updatedAtMs: conversation.execution.updatedAtMs
-		},
-		lastActivityAtMs: conversation.lastActivityAtMs,
-		metrics: null,
-		actor: conversation.actor,
-		source: conversation.source,
-		title: conversation.title,
-		updatedAtMs: conversation.updatedAtMs
-	});
-}
-/** Return a persisted conversation record, if one exists. */
-async function getConversation(args) {
-	return await getConversation$1(args);
-}
-/** Return a persisted conversation work record, if one exists. */
-async function getConversationWorkState(args) {
-	return await getConversationWorkState$1(args);
-}
-/** Count one failed conversation execution and persist its terminal retry state. */
-async function recordConversationRetry(args) {
-	const result = await recordConversationRetry$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Count mailbox messages that have not yet reached the conversation event log. */
-function countPendingConversationMessages(conversation) {
-	return conversation.execution.pendingMessages.length;
-}
-/** Return whether a conversation has pending or resumable execution work. */
-function hasRunnableConversationWork(conversation) {
-	return conversation.execution.status !== "idle" || countPendingConversationMessages(conversation) > 0;
-}
-/**
-* Ensure runnable conversation work has one accepted queue wake-up nudge.
-*
-* Ordinary wakes coalesce on a recent accepted marker. A caller can ignore the
-* marker without replacing an active lease. Replacement is only for consumed
-* or known-stale deliveries where another queue nudge must exist.
-*/
-async function ensureConversationWake(args) {
-	const nowMs = args.nowMs ?? now();
-	const conversation = await getConversation$1({
-		conversationId: args.conversationId,
-		state: args.state
-	});
-	if (!conversation || !hasRunnableConversationWork(conversation)) return { status: "no_work" };
-	if (args.replaceExistingWake !== true && conversation.execution.lease && conversation.execution.lease.expiresAtMs > nowMs) return { status: "lease_active" };
-	if (args.ignoreEnqueueMarker !== true && args.replaceExistingWake !== true && hasRecentEnqueueMarker(conversation, nowMs)) return { status: "already_enqueued" };
-	const queueResult = await args.queue.send({
-		schemaVersion: 2,
-		conversationId: args.conversationId
-	}, {
-		delayMs: args.delayMs,
-		idempotencyKey: args.idempotencyKey
-	});
-	await markConversationWorkEnqueued({
-		conversationId: args.conversationId,
-		conversationStore: args.conversationStore,
-		nowMs,
-		state: args.state
-	});
-	return {
-		status: "enqueued",
-		queueMessageId: queueResult?.messageId
-	};
-}
-async function enqueueAfterAppend(args) {
-	const nowMs = args.nowMs ?? now();
-	const appendResult = args.appendResult;
-	if (appendResult.status === "active") return appendResult;
-	let idempotencyKey = args.message.inboundMessageId;
-	if (appendResult.status === "duplicate") {
-		const conversation = await getConversation$1({
-			conversationId: args.message.conversationId,
-			state: args.state
-		});
-		if (!conversation) return appendResult;
-		if (hasRecentEnqueueMarker(conversation, nowMs)) {
-			await recordExecutionMetadata({
-				conversationId: args.message.conversationId,
-				conversationStore: args.conversationStore,
-				state: args.state
-			});
-			return appendResult;
-		}
-		if (!conversation.execution.pendingMessages.some((message) => message.inboundMessageId === args.message.inboundMessageId)) {
-			await recordExecutionMetadata({
-				conversationId: args.message.conversationId,
-				conversationStore: args.conversationStore,
-				state: args.state
-			});
-			return appendResult;
-		}
-		idempotencyKey = duplicateInboundNudgeIdempotencyKey(args.message, nowMs);
-	}
-	const wake = await ensureConversationWake({
-		conversationId: args.message.conversationId,
-		conversationStore: args.conversationStore,
-		delayMs: args.queueDelayMs,
-		idempotencyKey,
-		ignoreEnqueueMarker: args.message.source === "event" ? void 0 : true,
-		nowMs,
-		queue: args.queue,
-		replaceExistingWake: args.replaceExistingWake,
-		state: args.state
-	});
-	if (wake.status !== "enqueued") await recordExecutionMetadata({
-		conversationId: args.message.conversationId,
-		conversationStore: args.conversationStore,
-		state: args.state
-	});
-	return {
-		...appendResult,
-		...wake.status === "enqueued" ? { queueMessageId: wake.queueMessageId } : void 0
-	};
-}
-/** Persist inbound work and ensure a worker wake-up. */
-async function appendAndEnqueueInboundMessage(args) {
-	const nowMs = args.nowMs ?? now();
-	const result = await enqueueAfterAppend({
-		...args,
-		appendResult: await appendInboundMessage({
-			message: args.message,
-			nowMs,
-			state: args.state
-		}),
-		nowMs
-	});
-	if (result.status === "active") throw new Error("Non-exclusive mailbox enqueue returned active");
-	return result;
-}
-/** Persist exclusive inbound work and wake its worker when admitted. */
-async function appendAndEnqueueExclusiveInboundMessage(args) {
-	const nowMs = args.nowMs ?? now();
-	return await enqueueAfterAppend({
-		...args,
-		appendResult: await appendExclusiveInboundMessage({
-			message: args.message,
-			nowMs,
-			state: args.state
-		}),
-		nowMs
-	});
-}
-/** Persist a stop request for the current Conversation run. */
-async function stopConversationWork(args) {
-	const result = await stopConversationWork$1(args);
-	if (result.status === "requested") await recordExecutionMetadata(args);
-	return result;
-}
-/** Finish an observed stop request under the current worker lease. */
-async function completeConversationStop(args) {
-	const result = await completeConversationStop$1(args);
-	if (result.status === "cleared") await recordExecutionMetadata(args);
-	return result;
-}
-/** Clear an accepted wake marker after its delivery finds no runnable work. */
-async function clearConsumedConversationWake(args) {
-	const result = await clearConsumedConversationWake$1(args);
-	if (result) await recordExecutionMetadata(args);
-	return result;
-}
-/** Mark a conversation runnable when there is no new mailbox message. */
-async function requestConversationWork(args) {
-	const result = await requestConversationWork$1(args);
-	await recordExecutionMetadata({
-		conversationId: args.conversationId,
-		conversationStore: args.conversationStore,
-		state: args.state
-	});
-	return result;
-}
-/** Record that a wake-up nudge was accepted for the conversation. */
-async function markConversationWorkEnqueued(args) {
-	await markConversationWorkEnqueued$1(args);
-	await recordExecutionMetadata(args);
-}
-/** Try to acquire the durable execution lease for one conversation. */
-async function startConversationWork(args) {
-	const result = await startConversationWork$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Extend the durable execution lease when the worker checks in. */
-async function checkInConversationWork(args) {
-	const result = await checkInConversationWork$1(args);
-	if (result) await recordExecutionMetadata(args);
-	return result;
-}
-/** Drain pending mailbox entries after the caller accepts responsibility. */
-async function drainConversationMailbox(args) {
-	const result = await drainConversationMailbox$1(args);
-	if (result.changed) await recordExecutionMetadata(args);
-	return result.messages;
-}
-/** Acknowledge leased mailbox entries after the handler accepts responsibility. */
-async function ackMessages(args) {
-	const result = await ackMessages$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Cancel human-facing pending mailbox rows without requiring a worker lease. */
-async function cancelHumanFacingPendingMessages(args) {
-	const result = await cancelHumanFacingPendingMessages$1(args);
-	if (result.cancelledInboundMessageIds.length > 0) await recordExecutionMetadata(args);
-	return result;
-}
-/** Mark the leased conversation as needing another queue-delivered slice. */
-async function requestAnotherSlice(args) {
-	const result = await requestAnotherSlice$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Begin a requested turn resume without releasing the current lease. */
-async function beginConversationResume(args) {
-	const result = await beginConversationResume$1(args);
-	if (result) await recordExecutionMetadata(args);
-	return result;
-}
-/** Release the durable execution lease without changing completion state. */
-async function releaseConversationWork(args) {
-	const result = await releaseConversationWork$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Finish a leased conversation and report whether runnable work remains. */
-async function completeConversationWork(args) {
-	const result = await completeConversationWork$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Record one failed delivery attempt and dead-letter messages at their limit. */
-async function recordAttemptFailure(args) {
-	const result = await recordAttemptFailure$1(args);
-	if (result.status === "recorded") await recordExecutionMetadata(args);
-	return result;
-}
-/** Record a terminal failure completion for a leased conversation. */
-async function deadLetterAttempt(args) {
-	const result = await deadLetterAttempt$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Recover an expired lease and persist the resulting retry state. */
-async function clearExpiredConversationLease(args) {
-	const result = await clearExpiredConversationLease$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Remove one conversation from the active index after it is missing or idle. */
-async function removeActiveConversation(args) {
-	return await removeActiveConversation$1(args);
-}
-/** List active conversation ids by oldest execution update first. */
-async function listActiveConversationIds(args = {}) {
-	return await listActiveConversationIds$1(args);
-}
-export { hasRunnableConversationWork$1 as A, requestAnotherSlice as C, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as D, stopConversationWork as E, isInvalidConversationRecordError as M, CONVERSATION_WORK_STALE_ENQUEUE_MS as O, removeActiveConversation as S, startConversationWork as T, hasRunnableConversationWork as _, cancelHumanFacingPendingMessages as a, recordConversationRetry as b, clearExpiredConversationLease as c, countPendingConversationMessages as d, deadLetterAttempt as f, getConversationWorkState as g, getConversation as h, beginConversationResume as i, isFinalAttempt as j, hasConversationStop as k, completeConversationStop as l, ensureConversationWake as m, appendAndEnqueueExclusiveInboundMessage as n, checkInConversationWork as o, drainConversationMailbox as p, appendAndEnqueueInboundMessage as r, clearConsumedConversationWake as s, ackMessages as t, completeConversationWork as u, listActiveConversationIds as v, requestConversationWork as w, releaseConversationWork as x, recordAttemptFailure as y };