@gestaltrun/dsh-im-runtime 0.1.0 → 0.1.5

package/lib/read-state-CnUZKCuY.js

@@ -0,0 +1,1868 @@
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { WorkspaceId } from "@deepseek-ai/dsh-workspace";
+import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
+import { basename } from "node:path";
+//#region src/errors.ts
+/** Structured IM runtime failure for requests that cannot produce a durable receipt. */
+var ImRuntimeError = class extends Error {
+	code;
+	/** @param code - stable failure code. @param message - diagnostic detail. */
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ImRuntimeError";
+	}
+};
+//#endregion
+//#region src/delivery-schema.ts
+const accountId = z.string().min(1).transform((value) => brandString(value));
+const operationId = z.string().min(1).transform((value) => brandString(value));
+const messageId = z.string().min(1).transform((value) => brandString(value));
+const outboundRequestId = z.string().min(1).transform((value) => brandString(value));
+const outboundAttemptId = z.string().min(1).transform((value) => brandString(value));
+const scopeId = z.string().min(1).transform((value) => brandString(value));
+const providerCursorId = z.string().min(1).transform((value) => brandString(value));
+const admissionId = z.string().min(1).transform((value) => brandString(value));
+const agentTaskId = z.string().min(1).transform((value) => brandString(value));
+const timestamp$1 = z.iso.datetime();
+/** Captured platform identities; legacy observations omit the whole value. */
+const imUploadIdentitySchema = z.object({
+	senderAccountId: z.string().min(1).nullable(),
+	senderDisplayName: z.string().min(1).nullable(),
+	senderDomain: z.string().min(1).nullable(),
+	assignedAccountId: z.string().min(1).nullable()
+});
+const realScope = z.object({
+	kind: z.literal("real"),
+	platform: z.enum(["dingtalk", "wangwang"]),
+	accountId,
+	conversationKind: z.enum(["direct", "group"]),
+	conversationId: z.string().min(1)
+});
+const simulationScope = z.object({
+	kind: z.literal("simulation"),
+	instanceId: z.string().min(1).transform((value) => brandString(value)),
+	platform: z.enum(["dingtalk", "wangwang"]),
+	accountId,
+	conversationKind: z.enum(["direct", "group"]),
+	conversationId: z.string().min(1)
+});
+const imDeliveryScopeSchema = z.discriminatedUnion("kind", [realScope, simulationScope]);
+const humanDshSender = z.object({
+	kind: z.literal("human-dsh"),
+	outboundRequestId,
+	providerActorId: z.string().min(1).optional()
+});
+const sender = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("external"),
+		senderId: z.string().min(1),
+		senderDisplayName: z.string().optional(),
+		userId: z.string().min(1).optional(),
+		openDingTalkId: z.string().min(1).optional()
+	}),
+	z.object({
+		kind: z.literal("human-native"),
+		accountId,
+		providerActorId: z.string().min(1)
+	}),
+	humanDshSender,
+	z.object({
+		kind: z.literal("ai"),
+		outboundRequestId
+	}),
+	z.object({
+		kind: z.literal("unknown"),
+		reason: z.enum([
+			"insufficient-evidence",
+			"unmatched-self",
+			"unmatched-echo",
+			"provider-unknown"
+		]),
+		observedSenderId: z.string().optional()
+	})
+]);
+const quote = z.object({
+	text: z.string(),
+	senderDisplayName: z.string().min(1).optional(),
+	externalMessageId: z.string().min(1).optional()
+});
+const forbiddenDetailKeys = /* @__PURE__ */ new Set([
+	"accesskey",
+	"accesskeyid",
+	"accesskeysecret",
+	"authorization",
+	"connectionconfig",
+	"cookie",
+	"credential",
+	"credentials",
+	"header",
+	"headers",
+	"password",
+	"secret",
+	"token",
+	"transportconfig"
+]);
+function unsafeDetailPath(value, path = []) {
+	if (value === null || typeof value !== "object") return void 0;
+	if (Array.isArray(value)) {
+		for (const [index, entry] of value.entries()) {
+			const unsafe = unsafeDetailPath(entry, [...path, String(index)]);
+			if (unsafe !== void 0) return unsafe;
+		}
+		return;
+	}
+	for (const [key, entry] of Object.entries(value)) {
+		const next = [...path, key];
+		if (forbiddenDetailKeys.has(key.replaceAll("-", "").replaceAll("_", "").toLowerCase())) return next;
+		const unsafe = unsafeDetailPath(entry, next);
+		if (unsafe !== void 0) return unsafe;
+	}
+}
+const displaySafeJson = z.json().superRefine((value, context) => {
+	const path = unsafeDetailPath(value);
+	if (path !== void 0) context.addIssue({
+		code: "custom",
+		message: "unsupported-message details contain private transport configuration",
+		path: [...path]
+	});
+});
+const content = z.discriminatedUnion("format", [
+	z.object({
+		text: z.string(),
+		format: z.literal("media"),
+		media: z.object({
+			kind: z.enum(["image", "file"]),
+			name: z.string().min(1),
+			mime: z.string(),
+			bytes: z.number().int().nonnegative(),
+			sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+			sourceFile: z.object({
+				attachmentId: z.string().min(1).transform((value) => brandString(value)),
+				name: z.string().min(1),
+				bytes: z.number().int().nonnegative()
+			}).optional()
+		}),
+		quote: quote.optional()
+	}),
+	z.object({
+		text: z.string(),
+		format: z.enum(["text", "markdown"]),
+		quote: quote.optional()
+	}),
+	z.object({
+		text: z.string(),
+		format: z.literal("image"),
+		quote: quote.optional()
+	}),
+	z.object({
+		text: z.string(),
+		format: z.literal("unsupported"),
+		messageType: z.string().min(1),
+		details: displaySafeJson,
+		quote: quote.optional()
+	})
+]);
+/** Parser for provider and JSONL inbound records. */
+const imInboundMessageInputSchema = z.object({
+	uploadIdentity: imUploadIdentitySchema.optional(),
+	externalMessageId: z.string().min(1),
+	sender,
+	content,
+	occurredAt: timestamp$1,
+	mentionedConfiguredAccount: z.boolean().optional()
+});
+const inboundMessage = z.object({
+	uploadIdentity: imUploadIdentitySchema.optional(),
+	messageId,
+	scopeId,
+	externalMessageId: z.string().min(1),
+	sender,
+	content,
+	origin: z.enum(["live", "jsonl-import"]),
+	stage: z.enum(["received", "submitted"]),
+	sequenceNumber: z.number().int().positive(),
+	occurredAt: timestamp$1,
+	mentionedConfiguredAccount: z.boolean().optional(),
+	receivedAt: timestamp$1,
+	submission: z.object({
+		sessionId: z.string().min(1).transform(SessionId),
+		submittedAt: timestamp$1
+	}).optional()
+});
+const cursor = z.object({
+	scopeId,
+	platformCursor: z.string().nullable(),
+	lastReceivedSequenceNumber: z.number().int().nonnegative(),
+	lastSubmittedSequenceNumber: z.number().int().nonnegative(),
+	pendingCount: z.number().int().nonnegative(),
+	lastSuppressedSequenceNumber: z.number().int().nonnegative().optional(),
+	lastSyncedAt: timestamp$1.optional(),
+	updatedAt: timestamp$1
+});
+const conversationPresentation = z.object({
+	displayName: z.string().min(1).optional(),
+	memberCount: z.number().int().positive().optional(),
+	assignedActorId: z.string().min(1).optional()
+});
+const pageResult = z.object({
+	kind: z.literal("page"),
+	operationId,
+	status: z.enum(["applied", "conflict"]),
+	acceptedCount: z.number().int().nonnegative(),
+	evidenceMergedCount: z.number().int().nonnegative().optional(),
+	duplicateCount: z.number().int().nonnegative(),
+	messages: z.array(inboundMessage),
+	cursor
+});
+const importResult = z.object({
+	kind: z.literal("jsonl-import"),
+	operationId,
+	status: z.literal("applied"),
+	fileName: z.string().min(1),
+	messageCount: z.number().int().nonnegative(),
+	importedCount: z.number().int().nonnegative(),
+	duplicateCount: z.number().int().nonnegative()
+});
+const routeBinding = z.object({
+	handlingEpoch: z.number().int().nonnegative().optional(),
+	routeId: z.string().min(1).transform((value) => brandString(value)),
+	routeRevision: z.string().min(1).transform((value) => brandString(value)),
+	accountRevision: z.string().min(1).transform((value) => brandString(value)),
+	workspaceId: z.string().min(1).transform(WorkspaceId)
+});
+const receipt = z.object({
+	providerReceiptId: z.string().optional(),
+	providerStatus: z.string().optional(),
+	errorCode: z.string().optional(),
+	observedAt: timestamp$1
+});
+const outbound = z.object({
+	requestId: outboundRequestId,
+	scopeId,
+	intent: z.enum(["ai", "human-manual"]),
+	content,
+	media: z.object({
+		state: z.enum(["uploading", "prepared"]),
+		imageUrl: z.url().optional()
+	}).optional(),
+	status: z.enum([
+		"pending",
+		"dispatching",
+		"pre-send-failed",
+		"sent",
+		"result-unknown",
+		"confirmed-failed"
+	]),
+	sequenceNumber: z.number().int().positive(),
+	handlingEpoch: z.number().int().nonnegative().optional(),
+	routeBinding: routeBinding.optional(),
+	sender: humanDshSender.optional(),
+	manualBinding: z.object({
+		sessionId: z.string().min(1).transform(SessionId),
+		taskId: agentTaskId
+	}).optional(),
+	retryOfRequestId: outboundRequestId.optional(),
+	preSendFailureReason: z.enum([
+		"account-not-found",
+		"platform-mismatch",
+		"account-paused",
+		"route-disabled",
+		"route-unmatched",
+		"route-changed",
+		"cancelled"
+	]).optional(),
+	attempt: z.object({
+		attemptId: outboundAttemptId,
+		startedAt: timestamp$1
+	}).optional(),
+	receipt: receipt.optional(),
+	externalMessageId: z.string().optional(),
+	replyToExternalMessageId: z.string().optional(),
+	createdAt: timestamp$1,
+	updatedAt: timestamp$1
+});
+/** Parser shared by the sqlite transfer journal and the external queue file. */
+const uploadTarget = z.object({
+	serverOrigin: z.url(),
+	tenantId: z.string().min(1).transform((value) => brandString(value)),
+	shopAccountId: z.string().min(1),
+	traffic: z.enum([
+		"formal",
+		"test",
+		"simulation"
+	]),
+	testRunId: z.string().nullable()
+});
+/** Server V2 control-result fields shared by the journal and queue parsers. */
+const imUploadConversationEventSchema = z.object({
+	eventId: z.string().min(1),
+	conversationKey: z.string().min(1),
+	accountId: z.string().min(1),
+	kind: z.enum([
+		"ai_to_human",
+		"hosting_disabled",
+		"hosting_resumed"
+	]),
+	occurredAt: timestamp$1,
+	controlRevision: z.string().regex(/^(0|[1-9][0-9]{0,18})$/u),
+	relatedMessageIds: z.array(z.string().min(1)).max(200),
+	sourceOperationId: z.string().min(1),
+	sourceKind: z.literal("dsh-control-result"),
+	payloadHash: z.string().regex(/^[0-9a-f]{64}$/u)
+});
+const imUploadObservationSchema = z.object({
+	id: z.string().min(1).transform((value) => brandString(value)),
+	target: uploadTarget,
+	scope: imDeliveryScopeSchema,
+	observedAt: timestamp$1,
+	identity: imUploadIdentitySchema.optional(),
+	message: z.discriminatedUnion("kind", [
+		z.object({
+			kind: z.literal("inbound"),
+			value: inboundMessage
+		}),
+		z.object({
+			kind: z.literal("outbound"),
+			value: outbound
+		}),
+		z.object({
+			kind: z.literal("conversation-event"),
+			value: imUploadConversationEventSchema
+		})
+	])
+});
+const imDeliveryAggregateSchema = z.object({
+	uploadIdentities: z.record(z.string(), imUploadIdentitySchema).optional(),
+	scope: imDeliveryScopeSchema,
+	scopeId,
+	uploadTargets: z.record(z.string(), uploadTarget).optional(),
+	uploadPending: z.array(imUploadObservationSchema).optional(),
+	uploadObservedAt: timestamp$1.optional(),
+	nextMessageSequenceNumber: z.number().int().positive(),
+	nextOutboundSequenceNumber: z.number().int().positive(),
+	cursor,
+	presentation: conversationPresentation.optional(),
+	directRecipient: z.object({
+		providerActorId: z.string().min(1),
+		userId: z.string().min(1).optional(),
+		openDingTalkId: z.string().min(1).optional()
+	}).optional(),
+	messages: z.record(z.string(), inboundMessage),
+	messageIdsByExternalId: z.record(z.string(), messageId),
+	operations: z.record(z.string(), z.object({
+		fingerprint: z.string(),
+		result: z.union([pageResult, importResult])
+	})),
+	outbounds: z.record(z.string(), outbound)
+});
+const providerCursorOwner = z.object({
+	platform: z.enum(["dingtalk", "wangwang"]),
+	accountId,
+	streamId: z.string().min(1)
+});
+const providerCursorView = z.object({
+	id: providerCursorId,
+	owner: providerCursorOwner,
+	cursor: z.string().nullable(),
+	updatedAt: timestamp$1
+});
+const providerCursorResult = z.object({
+	operationId,
+	status: z.enum([
+		"applied",
+		"unchanged",
+		"conflict",
+		"rejected"
+	]),
+	cursor: providerCursorView,
+	code: z.literal("IM_PROVIDER_PAGE_NOT_DURABLE").optional(),
+	message: z.string().optional()
+});
+/** Parser for one provider-owned feed cursor plus its CAS receipts. */
+const imProviderCursorAggregateSchema = z.object({
+	id: providerCursorId,
+	owner: providerCursorOwner,
+	cursor: z.string().nullable(),
+	updatedAt: timestamp$1,
+	operations: z.record(z.string(), z.object({
+		fingerprint: z.string(),
+		result: providerCursorResult
+	}))
+});
+const triggerReason = z.enum([
+	"direct",
+	"mention",
+	"every-n",
+	"fixed-interval"
+]);
+/** Frozen analysis parse path, shared by JSON records and compatibility fixtures. */
+const imAdmissionAnnotationSchema = z.discriminatedUnion("status", [z.object({
+	id: z.string().min(1).transform((value) => brandString(value)),
+	annotatorId: z.string().min(1).transform((value) => brandString(value)),
+	version: z.string().min(1),
+	status: z.literal("success"),
+	text: z.string().min(1)
+}), z.object({
+	id: z.string().min(1).transform((value) => brandString(value)),
+	annotatorId: z.string().min(1).transform((value) => brandString(value)),
+	version: z.string().min(1),
+	status: z.enum(["timeout", "failed"])
+})]);
+/** Parser for the frozen batch retained until its exact Session append commits. */
+const imPendingAdmissionSchema = z.object({
+	annotations: z.array(imAdmissionAnnotationSchema).optional(),
+	handlingEpoch: z.number().int().nonnegative().optional(),
+	admissionId,
+	messageIds: z.array(messageId).min(1),
+	triggerReasons: z.array(triggerReason).min(1),
+	createdAt: timestamp$1
+});
+/** Parser for one route-bound Agent task generation. */
+const imExecutionAggregateSchema = z.object({
+	taskId: agentTaskId,
+	generation: z.number().int().positive(),
+	scope: imDeliveryScopeSchema,
+	scopeId,
+	sessionId: z.string().min(1).transform(SessionId),
+	routeId: z.string().min(1).transform((value) => brandString(value)),
+	routeRevision: z.string().min(1).transform((value) => brandString(value)),
+	accountRevision: z.string().min(1).transform((value) => brandString(value)),
+	workspaceId: z.string().min(1).transform(WorkspaceId),
+	agentPreset: z.string().min(1),
+	controller: z.string().min(1).optional(),
+	groupTrigger: z.object({
+		mention: z.boolean().optional(),
+		everyN: z.number().int().positive().optional(),
+		fixedIntervalSeconds: z.number().int().positive().optional()
+	}).optional(),
+	directRecipient: z.object({
+		providerActorId: z.string().min(1),
+		userId: z.string().min(1).optional(),
+		openDingTalkId: z.string().min(1).optional()
+	}).optional(),
+	createdAt: timestamp$1,
+	updatedAt: timestamp$1,
+	pendingAdmission: imPendingAdmissionSchema.optional()
+});
+//#endregion
+//#region src/delivery.ts
+/** Durable receive, history, Session reconciliation, and outbox state. */
+const settled = async (promise) => {
+	try {
+		await promise;
+	} catch {}
+};
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/**
+* Encode every scope component in an ordered JSON tuple before hashing.
+* @param scope - complete real or simulation conversation identity.
+* @returns stable scope identifier shared by history, Session sources, and outbox rows.
+*/
+function encodeImScopeId(scope) {
+	const tuple = scope.kind === "real" ? [
+		scope.kind,
+		scope.platform,
+		scope.accountId,
+		scope.conversationKind,
+		scope.conversationId
+	] : [
+		scope.kind,
+		scope.instanceId,
+		scope.platform,
+		scope.accountId,
+		scope.conversationKind,
+		scope.conversationId
+	];
+	return brandString(`im-scope:${createHash("sha256").update(JSON.stringify(tuple)).digest("base64url")}`);
+}
+/**
+* Encode the platform account and provider feed name that jointly own a cursor.
+* @param owner - provider cursor owner.
+* @returns stable provider cursor identifier.
+*/
+function encodeImProviderCursorId(owner) {
+	return brandString(`im-provider-cursor:${createHash("sha256").update(JSON.stringify([
+		owner.platform,
+		owner.accountId,
+		owner.streamId
+	])).digest("base64url")}`);
+}
+function messageIdentity(scopeId, externalMessageId) {
+	return brandString(`im-message:${createHash("sha256").update(JSON.stringify([scopeId, externalMessageId])).digest("base64url")}`);
+}
+function existingInboundId(messages, byExternalId, input) {
+	const byId = byExternalId[input.externalMessageId];
+	if (byId !== void 0) return byId;
+	if (input.sender.kind !== "human-dsh") return void 0;
+	const requestId = input.sender.outboundRequestId;
+	return Object.values(messages).find((message) => message.sender.kind === "human-dsh" && message.sender.outboundRequestId === requestId)?.messageId;
+}
+function attemptIdentity() {
+	return brandString(`im-attempt:${randomUUID()}`);
+}
+/** @param outbound - intent that now owns this platform message id. @returns its durable sender, or absence for an intent that has no echo attribution. */
+function echoSender(outbound) {
+	if (outbound.intent === "ai") return {
+		kind: "ai",
+		outboundRequestId: outbound.requestId
+	};
+	if (outbound.intent !== "human-manual") return void 0;
+	return outbound.sender?.kind === "human-dsh" ? outbound.sender : {
+		kind: "human-dsh",
+		outboundRequestId: outbound.requestId
+	};
+}
+/**
+* Reattribute live history that already carries this exact platform id.
+* Rows with any other id, imported history, and buyer evidence stay as stored.
+* @param messages - current history map.
+* @param outbound - settled outbox row.
+* @param externalMessageId - platform message id from the receipt.
+* @returns the next map and the ids whose sender changed.
+*/
+function claimExactEcho(messages, outbound, externalMessageId) {
+	const sender = echoSender(outbound);
+	if (sender === void 0) return {
+		messages,
+		revised: []
+	};
+	let next;
+	const revised = [];
+	for (const [id, message] of Object.entries(messages)) {
+		if (message.origin !== "live" || message.externalMessageId !== externalMessageId) continue;
+		if (message.sender.kind !== "human-native" && message.sender.kind !== "unknown") continue;
+		if (JSON.stringify(message.sender) === JSON.stringify(sender)) continue;
+		const updated = {
+			...message,
+			sender
+		};
+		next ??= { ...messages };
+		next[id] = updated;
+		revised.push(updated.messageId);
+	}
+	return {
+		messages: next ?? messages,
+		revised
+	};
+}
+function assertLimit(limit) {
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) throw new ImRuntimeError("IM_DELIVERY_SCOPE_INVALID", "IM delivery query limit must be an integer from 1 through 1000");
+}
+function sameScope(left, right) {
+	return encodeImScopeId(left) === encodeImScopeId(right);
+}
+function initialAggregate(scope) {
+	const scopeId = encodeImScopeId(scope);
+	return {
+		scope,
+		scopeId,
+		nextMessageSequenceNumber: 1,
+		nextOutboundSequenceNumber: 1,
+		cursor: {
+			scopeId,
+			platformCursor: null,
+			lastReceivedSequenceNumber: 0,
+			lastSubmittedSequenceNumber: 0,
+			pendingCount: 0,
+			updatedAt: timestamp()
+		},
+		messages: {},
+		messageIdsByExternalId: {},
+		operations: {},
+		outbounds: {}
+	};
+}
+function sortedMessages(aggregate) {
+	return Object.values(aggregate.messages).sort((left, right) => left.sequenceNumber - right.sequenceNumber);
+}
+function sortedOutbounds(aggregate) {
+	return Object.values(aggregate.outbounds).sort((left, right) => left.sequenceNumber - right.sequenceNumber);
+}
+/** @param messages - one document's messages in sequence order. @param request - validated page bounds and origin filter. @returns the ascending page that ends before the bound. */
+function historyPage(messages, request) {
+	const acceptedOrigins = request.origins === void 0 ? void 0 : new Set(request.origins);
+	const before = request.beforeSequenceNumber ?? Number.POSITIVE_INFINITY;
+	const candidates = messages.filter((message) => message.sequenceNumber < before && (acceptedOrigins?.has(message.origin) ?? true));
+	const offset = Math.max(0, candidates.length - request.limit);
+	const items = candidates.slice(offset);
+	return {
+		items,
+		hasMore: offset > 0,
+		...offset > 0 && items[0] !== void 0 ? { nextBeforeSequenceNumber: items[0].sequenceNumber } : {}
+	};
+}
+/** @param outbounds - one document's outbounds in sequence order. @param request - validated page bounds. @returns the ascending page that ends before the bound. */
+function outboundPage(outbounds, request) {
+	const before = request.beforeSequenceNumber ?? Number.POSITIVE_INFINITY;
+	const candidates = outbounds.filter((outbound) => outbound.sequenceNumber < before);
+	const offset = Math.max(0, candidates.length - request.limit);
+	const items = candidates.slice(offset);
+	return {
+		items,
+		hasMore: offset > 0,
+		...offset > 0 && items[0] !== void 0 ? { nextBeforeSequenceNumber: items[0].sequenceNumber } : {}
+	};
+}
+/**
+* @param aggregate - stored or initial conversation document.
+* @returns records over the document with the same paging as `ImDeliveryStore.queryHistory` and `queryOutbound`.
+*/
+function conversationRecords(aggregate) {
+	let messages;
+	let outbounds;
+	return {
+		scope: aggregate.scope,
+		cursor: aggregate.cursor,
+		queryHistory: (request) => {
+			assertLimit(request.limit);
+			messages ??= sortedMessages(aggregate);
+			return historyPage(messages, request);
+		},
+		queryOutbound: (request) => {
+			assertLimit(request.limit);
+			outbounds ??= sortedOutbounds(aggregate);
+			return outboundPage(outbounds, request);
+		}
+	};
+}
+function suppressedThrough(aggregate) {
+	return aggregate.cursor.lastSuppressedSequenceNumber ?? 0;
+}
+function pendingCount(aggregate) {
+	const suppressed = suppressedThrough(aggregate);
+	return Object.values(aggregate.messages).filter((message) => message.origin === "live" && message.stage === "received" && message.sequenceNumber > suppressed).length;
+}
+function submittedWatermark(aggregate) {
+	let watermark = 0;
+	for (const message of sortedMessages(aggregate)) {
+		if (message.origin !== "live") continue;
+		if (message.stage !== "submitted") break;
+		watermark = message.sequenceNumber;
+	}
+	return watermark;
+}
+function pageFingerprint(request, includePeer = true) {
+	return JSON.stringify([
+		"page",
+		request.scope,
+		request.observedCursor,
+		request.nextCursor,
+		request.presentation ?? null,
+		request.messages,
+		...!includePeer || request.directRecipient === void 0 ? [] : [request.directRecipient]
+	]);
+}
+function importFingerprint(request, fileName, messages) {
+	return JSON.stringify([
+		"jsonl-import",
+		request.scope,
+		fileName,
+		messages
+	]);
+}
+function assertOperation(existing, fingerprint, operationId) {
+	if (existing !== void 0 && existing.fingerprint !== fingerprint) throw new ImRuntimeError("IM_DELIVERY_OPERATION_REUSED", `IM delivery operation '${operationId}' was already used for a different request`);
+}
+function assertOutbound(existing, request) {
+	if (existing === void 0) return;
+	if (JSON.stringify([
+		existing.intent,
+		existing.content,
+		existing.sender ?? null,
+		existing.manualBinding ?? null,
+		existing.retryOfRequestId ?? null,
+		existing.replyToExternalMessageId ?? null
+	]) !== JSON.stringify([
+		request.intent,
+		request.content,
+		request.sender ?? null,
+		request.manualBinding ?? null,
+		request.retryOfRequestId ?? null,
+		request.replyToExternalMessageId ?? null
+	])) throw new ImRuntimeError("IM_OUTBOUND_REQUEST_REUSED", `IM outbound request '${request.requestId}' was already used for a different intent`);
+}
+function preparationUnknown(outbound, changedAt) {
+	return {
+		...outbound,
+		status: "result-unknown",
+		receipt: {
+			providerStatus: "media-preparation-unknown",
+			errorCode: "IM_MEDIA_PREPARATION_UNKNOWN",
+			observedAt: changedAt
+		},
+		updatedAt: changedAt
+	};
+}
+/** One-record mutations for complete conversation scopes. */
+var ImDeliveryStore = class {
+	records;
+	host;
+	tails = /* @__PURE__ */ new Map();
+	cursorTails = /* @__PURE__ */ new Map();
+	cursors;
+	/** @param records - sqlite delivery records. @param host - account policy and post-commit publisher. */
+	constructor(records, host) {
+		this.records = records;
+		this.host = host;
+		this.cursors = records.projectScopes((value) => value.cursor);
+	}
+	/** Recover interrupted sends and unfinished file preparations before publishing the runtime, independently of provider availability. */
+	async recoverInterruptedAttempts() {
+		const unfinishedFiles = new Set(this.records.unfinishedFilePreparationIds());
+		const scopeIds = new Set(this.records.dispatchingScopeIds());
+		for (const requestId of unfinishedFiles) {
+			const owner = this.records.outboundOwner(requestId);
+			if (owner !== void 0) scopeIds.add(encodeImScopeId(owner.scope));
+		}
+		for (const scopeId of scopeIds) await this.enqueue(scopeId, async () => {
+			const current = this.require(scopeId);
+			const changedAt = timestamp();
+			let changed = false;
+			const outbounds = Object.fromEntries(Object.entries(current.outbounds).map(([id, outbound]) => {
+				if (unfinishedFiles.has(outbound.requestId) && outbound.status !== "sent") {
+					if (outbound.status === "result-unknown" && outbound.receipt?.errorCode === "IM_MEDIA_PREPARATION_UNKNOWN") return [id, outbound];
+					changed = true;
+					return [id, preparationUnknown(outbound, changedAt)];
+				}
+				if (outbound.status !== "dispatching") return [id, outbound];
+				changed = true;
+				return [id, {
+					...outbound,
+					status: "result-unknown",
+					receipt: outbound.receipt ?? {
+						providerStatus: "interrupted",
+						observedAt: changedAt
+					},
+					updatedAt: changedAt
+				}];
+			}));
+			if (changed) await this.persistMutation(current, {
+				...current,
+				outbounds
+			});
+		});
+	}
+	/** @param request - Validated page and scope. @param receiptTime - Instance script time; absent uses the ingestion clock. @returns The durable page receipt. */
+	async ingestInboundPage(request, receiptTime) {
+		if (request.scope.kind === "real") this.assertRealScope(request.scope);
+		if (request.scope.conversationKind === "direct" && request.presentation?.memberCount !== void 0) throw new ImRuntimeError("IM_DELIVERY_SCOPE_INVALID", "direct-conversation presentation cannot carry a member count");
+		const scopeId = encodeImScopeId(request.scope);
+		const fingerprint = pageFingerprint(request);
+		return this.mutate(request.scope, (current) => {
+			const existing = current.operations[request.operationId];
+			assertOperation(existing, existing !== void 0 && existing.fingerprint === pageFingerprint(request, false) ? existing.fingerprint : fingerprint, request.operationId);
+			if (existing !== void 0) {
+				if (existing.result.kind !== "page") throw new ImRuntimeError("IM_DELIVERY_OPERATION_REUSED", `IM delivery operation '${request.operationId}' is not a page operation`);
+				return {
+					aggregate: current,
+					value: existing.result,
+					changed: false
+				};
+			}
+			if (current.cursor.platformCursor !== request.observedCursor) {
+				const result = {
+					kind: "page",
+					operationId: request.operationId,
+					status: "conflict",
+					acceptedCount: 0,
+					evidenceMergedCount: 0,
+					duplicateCount: 0,
+					messages: [],
+					cursor: current.cursor
+				};
+				return {
+					aggregate: {
+						...current,
+						operations: {
+							...current.operations,
+							[request.operationId]: {
+								fingerprint,
+								result
+							}
+						}
+					},
+					value: result,
+					changed: true
+				};
+			}
+			let nextSequence = current.nextMessageSequenceNumber;
+			const messages = { ...current.messages };
+			const byExternalId = { ...current.messageIdsByExternalId };
+			const accepted = [];
+			const evidenceMerged = [];
+			let duplicateCount = 0;
+			const ordered = [...request.messages].sort((left, right) => left.occurredAt.localeCompare(right.occurredAt) || (request.scope.kind === "simulation" ? 0 : left.externalMessageId.localeCompare(right.externalMessageId)));
+			const receivedAt = receiptTime ?? timestamp();
+			for (const input of ordered) {
+				const existingId = existingInboundId(messages, byExternalId, input);
+				if (existingId !== void 0) {
+					duplicateCount++;
+					const existingMessage = messages[existingId];
+					if (existingMessage !== void 0 && existingMessage.mentionedConfiguredAccount !== true && input.mentionedConfiguredAccount === true) {
+						const enriched = {
+							...existingMessage,
+							mentionedConfiguredAccount: true
+						};
+						messages[existingId] = enriched;
+						evidenceMerged.push(enriched);
+					}
+					if (existingMessage !== void 0 && input.sender.kind !== "unknown" && JSON.stringify(existingMessage.sender) !== JSON.stringify(input.sender)) {
+						const revised = {
+							...messages[existingId],
+							sender: input.sender
+						};
+						messages[existingId] = revised;
+						evidenceMerged.push(revised);
+					}
+					if (existingMessage !== void 0 && existingMessage.externalMessageId !== input.externalMessageId) {
+						delete byExternalId[existingMessage.externalMessageId];
+						messages[existingId] = {
+							...messages[existingId],
+							externalMessageId: input.externalMessageId
+						};
+						byExternalId[input.externalMessageId] = existingId;
+					}
+					continue;
+				}
+				const id = messageIdentity(scopeId, input.externalMessageId);
+				const message = {
+					...input,
+					messageId: id,
+					scopeId,
+					origin: "live",
+					stage: "received",
+					sequenceNumber: nextSequence++,
+					receivedAt: request.scope.kind === "simulation" ? input.occurredAt : receivedAt
+				};
+				messages[id] = message;
+				byExternalId[input.externalMessageId] = id;
+				accepted.push(message);
+			}
+			const mergedMessages = [...new Set(evidenceMerged.map((message) => message.messageId))].map((id) => messages[id]);
+			const nextMessages = {
+				...current,
+				nextMessageSequenceNumber: nextSequence,
+				messages
+			};
+			const cursor = {
+				...current.cursor,
+				platformCursor: request.nextCursor,
+				lastReceivedSequenceNumber: accepted.at(-1)?.sequenceNumber ?? current.cursor.lastReceivedSequenceNumber,
+				pendingCount: pendingCount(nextMessages),
+				lastSyncedAt: receivedAt,
+				updatedAt: receivedAt
+			};
+			const result = {
+				kind: "page",
+				operationId: request.operationId,
+				status: "applied",
+				acceptedCount: accepted.length,
+				evidenceMergedCount: mergedMessages.length,
+				duplicateCount,
+				messages: [...accepted, ...mergedMessages],
+				cursor
+			};
+			return {
+				aggregate: {
+					...current,
+					nextMessageSequenceNumber: nextSequence,
+					cursor,
+					messages,
+					messageIdsByExternalId: byExternalId,
+					...request.presentation === void 0 ? {} : { presentation: {
+						...current.presentation,
+						...request.presentation
+					} },
+					...request.directRecipient === void 0 ? {} : { directRecipient: request.directRecipient },
+					operations: {
+						...current.operations,
+						[request.operationId]: {
+							fingerprint,
+							result
+						}
+					}
+				},
+				value: result,
+				changed: true
+			};
+		}).then((result) => {
+			if (result.changed) this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "inbound",
+				messageIds: result.value.messages.map((message) => message.messageId)
+			});
+			return result.value;
+		});
+	}
+	queryInboundOperation(scope, operationId) {
+		const result = this.lookup(scope)?.operations[operationId]?.result;
+		return result === void 0 ? { state: "not-found" } : {
+			state: "known",
+			result
+		};
+	}
+	getConversationCursor(scope) {
+		return this.cursors.get(encodeImScopeId(scope)) ?? initialAggregate(scope).cursor;
+	}
+	/**
+	* @param project - pure function of one conversation's records.
+	* @returns values derived at each document parse or write; a conversation without a document projects its initial records on every read.
+	*/
+	projectConversations(project) {
+		const projection = this.records.projectScopes((value) => project(conversationRecords(value)));
+		return {
+			get: (scope) => projection.get(encodeImScopeId(scope)) ?? project(conversationRecords(initialAggregate(scope))),
+			dispose: () => {
+				projection.dispose();
+			}
+		};
+	}
+	/** @param scope - durable conversation. @returns last admitted presentation, including the assigned service account when known. */
+	getConversationPresentation(scope) {
+		return this.lookup(scope)?.presentation;
+	}
+	getProviderCursor(owner) {
+		const id = encodeImProviderCursorId(owner);
+		const aggregate = this.records.getCursor(id);
+		if (aggregate !== void 0) return {
+			id,
+			owner: aggregate.owner,
+			cursor: aggregate.cursor,
+			updatedAt: aggregate.updatedAt
+		};
+		return {
+			id,
+			owner,
+			cursor: null,
+			updatedAt: timestamp()
+		};
+	}
+	async commitProviderCursor(request) {
+		const account = this.host.inspectAccount(request.owner.accountId);
+		if (account === void 0) throw new ImRuntimeError("IM_ACCOUNT_NOT_FOUND", `IM account '${request.owner.accountId}' is unknown`);
+		if (account.platform !== request.owner.platform || request.owner.streamId.trim() === "") throw new ImRuntimeError("IM_DELIVERY_SCOPE_INVALID", "provider cursor owner must use the configured account platform and a non-empty streamId");
+		const id = encodeImProviderCursorId(request.owner);
+		const fingerprint = JSON.stringify([
+			"provider-cursor",
+			request.owner,
+			request.observedCursor,
+			request.nextCursor,
+			request.pages.map((page) => [page.scope, page.operationId])
+		]);
+		return this.enqueueCursor(id, async () => {
+			const current = this.records.getCursor(id) ?? {
+				id,
+				owner: request.owner,
+				cursor: null,
+				updatedAt: timestamp(),
+				operations: {}
+			};
+			const existing = current.operations[request.operationId];
+			assertOperation(existing, fingerprint, request.operationId);
+			if (existing !== void 0) return existing.result;
+			let status;
+			let code;
+			let message;
+			if (current.cursor !== request.observedCursor) status = "conflict";
+			else {
+				const missing = request.pages.find((page) => {
+					const receipt = this.lookup(page.scope)?.operations[page.operationId]?.result;
+					return receipt?.kind !== "page" || receipt.status !== "applied";
+				});
+				if (missing !== void 0) {
+					status = "rejected";
+					code = "IM_PROVIDER_PAGE_NOT_DURABLE";
+					message = `conversation page '${missing.operationId}' is not durably applied`;
+				} else status = current.cursor === request.nextCursor ? "unchanged" : "applied";
+			}
+			const updatedAt = timestamp();
+			const cursor = {
+				id,
+				owner: current.owner,
+				cursor: status === "applied" ? request.nextCursor : current.cursor,
+				updatedAt: status === "applied" ? updatedAt : current.updatedAt
+			};
+			const result = {
+				operationId: request.operationId,
+				status,
+				cursor,
+				...code === void 0 ? {} : { code },
+				...message === void 0 ? {} : { message }
+			};
+			await this.records.putCursor(id, {
+				id,
+				owner: current.owner,
+				cursor: cursor.cursor,
+				updatedAt: cursor.updatedAt,
+				operations: {
+					...current.operations,
+					[request.operationId]: {
+						fingerprint,
+						result
+					}
+				}
+			});
+			if (status === "applied") this.host.onProviderCursorApplied?.(request.owner);
+			return result;
+		});
+	}
+	queryProviderCursorOperation(owner, operationId) {
+		const result = this.records.getCursor(encodeImProviderCursorId(owner))?.operations[operationId]?.result;
+		return result === void 0 ? { state: "not-found" } : {
+			state: "known",
+			result
+		};
+	}
+	queryHistory(request) {
+		assertLimit(request.limit);
+		const aggregate = this.lookup(request.scope);
+		if (aggregate === void 0) return {
+			items: [],
+			hasMore: false
+		};
+		return historyPage(sortedMessages(aggregate), request);
+	}
+	pendingInbound(request) {
+		assertLimit(request.limit);
+		if (!this.records.hasPendingInbound(encodeImScopeId(request.scope))) return [];
+		const aggregate = this.lookup(request.scope);
+		if (aggregate === void 0) return [];
+		const suppressed = suppressedThrough(aggregate);
+		return sortedMessages(aggregate).filter((message) => message.origin === "live" && message.stage === "received" && message.sequenceNumber > suppressed).slice(0, request.limit);
+	}
+	/**
+	* Consume the current received live batch without an Agent turn.
+	* A later allow only admits newer sequence numbers.
+	* @param scope - conversation whose policy just refused admission.
+	*/
+	suppressUnadmitted(scope) {
+		const scopeId = encodeImScopeId(scope);
+		return this.enqueue(scopeId, async () => {
+			if (!this.records.hasPendingInbound(scopeId)) return;
+			await this.applyMutation(scope, (current) => {
+				let through = suppressedThrough(current);
+				for (const message of Object.values(current.messages)) if (message.origin === "live" && message.stage === "received" && message.sequenceNumber > through) through = message.sequenceNumber;
+				if (through === suppressedThrough(current)) return {
+					aggregate: current,
+					value: void 0,
+					changed: false
+				};
+				const cursor = {
+					...current.cursor,
+					lastSuppressedSequenceNumber: through,
+					pendingCount: pendingCount({
+						...current,
+						cursor: {
+							...current.cursor,
+							lastSuppressedSequenceNumber: through
+						}
+					}),
+					updatedAt: timestamp()
+				};
+				return {
+					aggregate: {
+						...current,
+						cursor
+					},
+					value: void 0,
+					changed: true
+				};
+			});
+		});
+	}
+	messageSource(scope, messageId) {
+		const message = this.lookup(scope)?.messages[messageId];
+		if (message === void 0) throw new ImRuntimeError("IM_MESSAGE_NOT_FOUND", `IM message '${messageId}' is unknown for scope '${encodeImScopeId(scope)}'`);
+		return {
+			kind: "im",
+			scopeId: message.scopeId,
+			messageId: message.messageId,
+			sequenceNumber: message.sequenceNumber
+		};
+	}
+	/** @param source - durable Session message source. @returns matched scope, or absence for stale or foreign evidence. */
+	matchMessageSource(source) {
+		const aggregate = this.records.getScope(source.scopeId);
+		const message = aggregate?.messages[source.messageId];
+		if (aggregate === void 0 || message === void 0 || message.origin !== "live" || message.sequenceNumber !== source.sequenceNumber) return void 0;
+		return {
+			scope: aggregate.scope,
+			messageId: message.messageId
+		};
+	}
+	/** @param scope - complete scope. @param messageId - inbound identity. @returns stored row. */
+	getInbound(scope, messageId) {
+		const message = this.lookup(scope)?.messages[messageId];
+		if (message === void 0) throw new ImRuntimeError("IM_MESSAGE_NOT_FOUND", `IM message '${messageId}' is unknown for scope '${encodeImScopeId(scope)}'`);
+		return message;
+	}
+	markSubmitted(request) {
+		const scopeId = encodeImScopeId(request.scope);
+		return this.mutate(request.scope, (current) => {
+			const submittedAt = request.submittedAt ?? timestamp();
+			const messages = { ...current.messages };
+			const changed = [];
+			for (const id of new Set(request.messageIds)) {
+				const message = messages[id];
+				if (message === void 0 || message.origin !== "live") throw new ImRuntimeError("IM_MESSAGE_NOT_FOUND", `live IM message '${id}' is unknown for scope '${scopeId}'`);
+				if (message.submission !== void 0 && message.submission.sessionId !== request.sessionId) throw new ImRuntimeError("IM_MESSAGE_ALREADY_SUBMITTED", `IM message '${id}' is already submitted to Session '${message.submission.sessionId}'`);
+				if (message.stage === "submitted") continue;
+				const submitted = {
+					...message,
+					stage: "submitted",
+					submission: {
+						sessionId: request.sessionId,
+						submittedAt
+					}
+				};
+				messages[id] = submitted;
+				changed.push(submitted);
+			}
+			if (changed.length === 0) return {
+				aggregate: current,
+				value: {
+					messages: [],
+					cursor: current.cursor
+				},
+				changed: false
+			};
+			const next = {
+				...current,
+				messages
+			};
+			const cursor = {
+				...current.cursor,
+				lastSubmittedSequenceNumber: submittedWatermark(next),
+				pendingCount: pendingCount(next),
+				updatedAt: submittedAt
+			};
+			return {
+				aggregate: {
+					...next,
+					cursor
+				},
+				value: {
+					messages: changed,
+					cursor
+				},
+				changed: true
+			};
+		}).then((result) => {
+			if (result.changed) this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "submitted",
+				messageIds: result.value.messages.map((message) => message.messageId)
+			});
+			return result.value;
+		});
+	}
+	async importJsonlHistory(request) {
+		const fileName = basename(request.fileName.trim().replaceAll("\\", "/"));
+		if (fileName === "" || fileName === "." || fileName === "..") throw new ImRuntimeError("IM_JSONL_INVALID", "IM history import fileName must name a file");
+		const parsed = [];
+		for (const [index, line] of request.jsonl.split(/\r?\n/u).entries()) {
+			if (line.trim() === "") continue;
+			let value;
+			try {
+				value = JSON.parse(line);
+			} catch (error) {
+				throw new ImRuntimeError("IM_JSONL_INVALID", `IM JSONL line ${index + 1} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			const admitted = imInboundMessageInputSchema.safeParse(value);
+			if (!admitted.success) throw new ImRuntimeError("IM_JSONL_INVALID", `IM JSONL line ${index + 1} is invalid: ${admitted.error.message}`);
+			parsed.push(admitted.data);
+		}
+		const scopeId = encodeImScopeId(request.scope);
+		const fingerprint = importFingerprint(request, fileName, parsed);
+		return this.mutate(request.scope, (current) => {
+			const existing = current.operations[request.operationId];
+			assertOperation(existing, fingerprint, request.operationId);
+			if (existing !== void 0) {
+				if (existing.result.kind !== "jsonl-import") throw new ImRuntimeError("IM_DELIVERY_OPERATION_REUSED", `IM delivery operation '${request.operationId}' is not an import operation`);
+				return {
+					aggregate: current,
+					value: existing.result,
+					changed: false
+				};
+			}
+			let nextSequence = current.nextMessageSequenceNumber;
+			const messages = { ...current.messages };
+			const byExternalId = { ...current.messageIdsByExternalId };
+			let importedCount = 0;
+			let duplicateCount = 0;
+			const receivedAt = timestamp();
+			for (const input of parsed) {
+				if (byExternalId[input.externalMessageId] !== void 0) {
+					duplicateCount++;
+					continue;
+				}
+				const id = messageIdentity(scopeId, input.externalMessageId);
+				messages[id] = {
+					...input,
+					messageId: id,
+					scopeId,
+					origin: "jsonl-import",
+					stage: "submitted",
+					sequenceNumber: nextSequence++,
+					receivedAt
+				};
+				byExternalId[input.externalMessageId] = id;
+				importedCount++;
+			}
+			const result = {
+				kind: "jsonl-import",
+				operationId: request.operationId,
+				status: "applied",
+				fileName,
+				messageCount: parsed.length,
+				importedCount,
+				duplicateCount
+			};
+			return {
+				aggregate: {
+					...current,
+					nextMessageSequenceNumber: nextSequence,
+					messages,
+					messageIdsByExternalId: byExternalId,
+					operations: {
+						...current.operations,
+						[request.operationId]: {
+							fingerprint,
+							result
+						}
+					}
+				},
+				value: result,
+				changed: true
+			};
+		}).then((result) => {
+			if (result.changed) this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "inbound"
+			});
+			return result.value;
+		});
+	}
+	/** @param request - Scoped send intent. @param frozenBinding - Route observed by the Agent task. @param clock - Time sampled when the intent is stored. @returns Durable outbox intent. */
+	registerOutbound(request, frozenBinding, clock = Date.now) {
+		const scopeId = encodeImScopeId(request.scope);
+		return this.mutate(request.scope, (current) => {
+			const existing = current.outbounds[request.requestId];
+			assertOutbound(existing, request);
+			if (existing !== void 0) return {
+				aggregate: current,
+				value: existing,
+				changed: false
+			};
+			if (request.sender !== void 0 && (request.intent !== "human-manual" || request.sender.outboundRequestId !== request.requestId)) throw new ImRuntimeError("IM_MANUAL_MESSAGE_INVALID", "manual sender evidence must identify its own human-manual request");
+			if (request.manualBinding !== void 0 && (request.intent !== "human-manual" || request.sender === void 0)) throw new ImRuntimeError("IM_MANUAL_MESSAGE_INVALID", "manual Session binding requires persisted human sender evidence");
+			if (request.retryOfRequestId !== void 0) {
+				const prior = current.outbounds[request.retryOfRequestId];
+				if (request.intent !== "human-manual" || request.retryOfRequestId === request.requestId || prior?.intent !== "human-manual" || !(prior.content.format === "media" ? ["confirmed-failed", "pre-send-failed"].includes(prior.status) : prior.status === "result-unknown") || prior.content.format === "media" && this.records.hasUnfinishedFilePreparation(prior.requestId) || JSON.stringify(prior.manualBinding) !== JSON.stringify(request.manualBinding)) throw new ImRuntimeError("IM_MANUAL_RETRY_INVALID", "manual retry must name a distinct eligible human message in the same scope");
+			}
+			const policy = this.registrationPolicy(request, frozenBinding);
+			const createdAt = new Date(clock()).toISOString();
+			const outbound = {
+				requestId: request.requestId,
+				scopeId,
+				intent: request.intent,
+				content: request.content,
+				status: policy.reason === void 0 ? "pending" : "pre-send-failed",
+				sequenceNumber: current.nextOutboundSequenceNumber,
+				...request.intent === "ai" ? { handlingEpoch: frozenBinding?.handlingEpoch ?? this.records.getHandlingControl(scopeId)?.handlingEpoch ?? 0 } : {},
+				...policy.binding === void 0 ? {} : { routeBinding: policy.binding },
+				...request.sender === void 0 ? {} : { sender: request.sender },
+				...request.manualBinding === void 0 ? {} : { manualBinding: request.manualBinding },
+				...request.retryOfRequestId === void 0 ? {} : { retryOfRequestId: request.retryOfRequestId },
+				...policy.reason === void 0 ? {} : { preSendFailureReason: policy.reason },
+				...request.replyToExternalMessageId === void 0 ? {} : { replyToExternalMessageId: request.replyToExternalMessageId },
+				createdAt,
+				updatedAt: createdAt
+			};
+			return {
+				aggregate: {
+					...current,
+					nextOutboundSequenceNumber: current.nextOutboundSequenceNumber + 1,
+					outbounds: {
+						...current.outbounds,
+						[request.requestId]: outbound
+					}
+				},
+				value: outbound,
+				changed: true
+			};
+		}).then((result) => {
+			if (result.changed) this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "outbound",
+				requestId: request.requestId
+			});
+			return result.value;
+		});
+	}
+	/** @param request - owning real outbox intent. @param media - durable upload display facts. @returns the updated row after its preparation commit. */
+	recordMediaPreparation(request, media) {
+		const scopeId = encodeImScopeId(request.scope);
+		return this.mutate(request.scope, (current) => {
+			const outbound = current.outbounds[request.requestId];
+			if (outbound === void 0 || outbound.status !== "pending" || outbound.content.format !== "media") throw new ImRuntimeError("IM_OUTBOUND_STATE_INVALID", "media preparation requires a pending media intent");
+			const updated = {
+				...outbound,
+				media,
+				updatedAt: timestamp()
+			};
+			return {
+				aggregate: {
+					...current,
+					outbounds: {
+						...current.outbounds,
+						[request.requestId]: updated
+					}
+				},
+				value: updated,
+				changed: true
+			};
+		}).then((result) => {
+			this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "outbound",
+				requestId: request.requestId
+			});
+			return result.value;
+		});
+	}
+	beginOutboundAttempt(request) {
+		const scopeId = encodeImScopeId(request.scope);
+		return this.mutate(request.scope, (current) => {
+			const outbound = current.outbounds[request.requestId];
+			if (outbound === void 0) throw new ImRuntimeError("IM_OUTBOUND_NOT_FOUND", `IM outbound request '${request.requestId}' is unknown`);
+			if (outbound.status !== "sent" && this.records.hasUnfinishedFilePreparation(request.requestId) && (outbound.status !== "result-unknown" || outbound.receipt?.errorCode !== "IM_MEDIA_PREPARATION_UNKNOWN")) {
+				const updated = preparationUnknown(outbound, timestamp());
+				return {
+					aggregate: {
+						...current,
+						outbounds: {
+							...current.outbounds,
+							[request.requestId]: updated
+						}
+					},
+					value: {
+						state: "result-unknown",
+						outbound: updated
+					},
+					changed: true
+				};
+			}
+			if (outbound.status === "result-unknown") return {
+				aggregate: current,
+				value: {
+					state: "result-unknown",
+					outbound
+				},
+				changed: false
+			};
+			if (outbound.status === "dispatching") {
+				const updated = {
+					...outbound,
+					status: "result-unknown",
+					receipt: outbound.receipt ?? {
+						providerStatus: "repeated-begin",
+						observedAt: timestamp()
+					},
+					updatedAt: timestamp()
+				};
+				return {
+					aggregate: {
+						...current,
+						outbounds: {
+							...current.outbounds,
+							[request.requestId]: updated
+						}
+					},
+					value: {
+						state: "result-unknown",
+						outbound: updated
+					},
+					changed: true
+				};
+			}
+			if (outbound.status !== "pending") return {
+				aggregate: current,
+				value: {
+					state: "blocked",
+					outbound
+				},
+				changed: false
+			};
+			const reason = this.dispatchFailure(request.scope, outbound);
+			if (reason !== void 0) {
+				const updated = {
+					...outbound,
+					status: "pre-send-failed",
+					preSendFailureReason: reason,
+					updatedAt: timestamp()
+				};
+				return {
+					aggregate: {
+						...current,
+						outbounds: {
+							...current.outbounds,
+							[request.requestId]: updated
+						}
+					},
+					value: {
+						state: "blocked",
+						outbound: updated
+					},
+					changed: true
+				};
+			}
+			const attempt = {
+				attemptId: attemptIdentity(),
+				startedAt: timestamp()
+			};
+			const updated = {
+				...outbound,
+				status: "dispatching",
+				attempt,
+				updatedAt: attempt.startedAt
+			};
+			return {
+				aggregate: {
+					...current,
+					outbounds: {
+						...current.outbounds,
+						[request.requestId]: updated
+					}
+				},
+				value: {
+					state: "ready",
+					attemptId: attempt.attemptId,
+					outbound: updated
+				},
+				changed: true
+			};
+		}).then((result) => {
+			if (result.changed) this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "outbound",
+				requestId: request.requestId
+			});
+			return result.value;
+		});
+	}
+	/** @param request - Owning attempt. @returns Whether its frozen route and handling epoch still authorize an external submission. */
+	authorizeOutboundSubmission(request) {
+		const outbound = this.lookup(request.scope)?.outbounds[request.requestId];
+		return outbound?.status === "dispatching" && outbound.attempt?.attemptId === request.attemptId && this.dispatchFailure(request.scope, outbound) === void 0;
+	}
+	settleOutboundAttempt(request) {
+		const scopeId = encodeImScopeId(request.scope);
+		return this.mutate(request.scope, (current) => {
+			const outbound = current.outbounds[request.requestId];
+			if (outbound === void 0) throw new ImRuntimeError("IM_OUTBOUND_NOT_FOUND", `IM outbound request '${request.requestId}' is unknown`);
+			if (outbound.attempt?.attemptId !== request.attemptId) throw new ImRuntimeError("IM_OUTBOUND_ATTEMPT_MISMATCH", `IM outbound request '${request.requestId}' does not own attempt '${request.attemptId}'`);
+			const unchanged = {
+				outbound,
+				revised: []
+			};
+			if (outbound.status === request.status && outbound.externalMessageId === request.externalMessageId && JSON.stringify(outbound.receipt) === JSON.stringify(request.receipt)) return {
+				aggregate: current,
+				value: unchanged,
+				changed: false
+			};
+			if (outbound.status === "sent") return {
+				aggregate: current,
+				value: unchanged,
+				changed: false
+			};
+			if (outbound.status !== "dispatching" && outbound.status !== "result-unknown") throw new ImRuntimeError("IM_OUTBOUND_STATE_INVALID", `IM outbound request '${request.requestId}' cannot settle from '${outbound.status}'`);
+			const updated = {
+				...outbound,
+				status: request.status,
+				...request.receipt === void 0 ? {} : { receipt: request.receipt },
+				...request.externalMessageId === void 0 ? {} : { externalMessageId: request.externalMessageId },
+				updatedAt: timestamp()
+			};
+			const claimed = request.status === "sent" && request.externalMessageId !== void 0 ? claimExactEcho(current.messages, updated, request.externalMessageId) : {
+				messages: current.messages,
+				revised: []
+			};
+			return {
+				aggregate: {
+					...current,
+					messages: claimed.messages,
+					outbounds: {
+						...current.outbounds,
+						[request.requestId]: updated
+					}
+				},
+				value: {
+					outbound: updated,
+					revised: claimed.revised
+				},
+				changed: true
+			};
+		}).then((result) => {
+			if (result.changed) {
+				this.host.publish({
+					scope: request.scope,
+					scopeId,
+					kind: "outbound",
+					requestId: request.requestId
+				});
+				if (result.value.revised.length > 0) this.host.publish({
+					scope: request.scope,
+					scopeId,
+					kind: "inbound",
+					messageIds: result.value.revised
+				});
+			}
+			return result.value.outbound;
+		});
+	}
+	/** @param request - Local simulation intent. @param clock - Time sampled when the send settles. @returns Durable local receipt. */
+	settleSimulationOutbound(request, clock = Date.now) {
+		const scopeId = encodeImScopeId(request.scope);
+		return this.mutate(request.scope, (current) => {
+			const outbound = current.outbounds[request.requestId];
+			if (outbound === void 0) throw new ImRuntimeError("IM_OUTBOUND_NOT_FOUND", `IM outbound request '${request.requestId}' is unknown`);
+			if (outbound.status === "sent") return {
+				aggregate: current,
+				value: outbound,
+				changed: false
+			};
+			if (outbound.intent === "ai" && this.handlingRevoked(request.scope, outbound)) {
+				const updated = {
+					...outbound,
+					status: "pre-send-failed",
+					preSendFailureReason: "cancelled",
+					updatedAt: timestamp()
+				};
+				return {
+					aggregate: {
+						...current,
+						outbounds: {
+							...current.outbounds,
+							[request.requestId]: updated
+						}
+					},
+					value: updated,
+					changed: true
+				};
+			}
+			if (outbound.status !== "pending") throw new ImRuntimeError("IM_OUTBOUND_STATE_INVALID", `simulation outbound request '${request.requestId}' cannot settle from '${outbound.status}'`);
+			const sentAt = new Date(clock()).toISOString();
+			const updated = {
+				...outbound,
+				status: "sent",
+				receipt: {
+					providerStatus: "simulation",
+					observedAt: sentAt
+				},
+				updatedAt: sentAt
+			};
+			return {
+				aggregate: {
+					...current,
+					outbounds: {
+						...current.outbounds,
+						[request.requestId]: updated
+					}
+				},
+				value: updated,
+				changed: true
+			};
+		}).then((result) => {
+			if (result.changed) this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "outbound",
+				requestId: request.requestId
+			});
+			return result.value;
+		});
+	}
+	getOutbound(request) {
+		return this.lookup(request.scope)?.outbounds[request.requestId];
+	}
+	queryOutbound(request) {
+		assertLimit(request.limit);
+		const aggregate = this.lookup(request.scope);
+		if (aggregate === void 0) return {
+			items: [],
+			hasMore: false
+		};
+		return outboundPage(sortedOutbounds(aggregate), request);
+	}
+	cancelPendingAi(request) {
+		const scopeId = encodeImScopeId(request.scope);
+		return this.mutate(request.scope, (current) => {
+			const updatedAt = timestamp();
+			const cancelled = [];
+			const outbounds = Object.fromEntries(Object.entries(current.outbounds).map(([id, outbound]) => {
+				if (outbound.intent !== "ai" || outbound.status !== "pending") return [id, outbound];
+				const updated = {
+					...outbound,
+					status: "pre-send-failed",
+					preSendFailureReason: request.reason,
+					updatedAt
+				};
+				cancelled.push(updated);
+				return [id, updated];
+			}));
+			return {
+				aggregate: cancelled.length === 0 ? current : {
+					...current,
+					outbounds
+				},
+				value: cancelled,
+				changed: cancelled.length > 0
+			};
+		}).then((result) => {
+			if (result.changed) this.host.publish({
+				scope: request.scope,
+				scopeId,
+				kind: "outbound"
+			});
+			return result.value;
+		});
+	}
+	findSentOutbound(scope, externalMessageId) {
+		return Object.values(this.lookup(scope)?.outbounds ?? {}).find((outbound) => outbound.status === "sent" && (outbound.externalMessageId === externalMessageId || outbound.receipt?.providerReceiptId === externalMessageId));
+	}
+	findUnknownOutbound(scope, text) {
+		const needle = text.replace(/\s+/gu, " ").trim();
+		if (needle === "") return void 0;
+		return Object.values(this.lookup(scope)?.outbounds ?? {}).filter((outbound) => outbound.status === "result-unknown" && outbound.attempt !== void 0 && outbound.content.text.replace(/\s+/gu, " ").trim() === needle).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.requestId.localeCompare(right.requestId)).at(-1);
+	}
+	registrationPolicy(request, frozenBinding) {
+		const account = this.host.inspectAccount(request.scope.accountId, request.scope);
+		if (account === void 0) return { reason: "account-not-found" };
+		if (account.platform !== request.scope.platform) return { reason: "platform-mismatch" };
+		if (request.intent === "human-manual") return {};
+		const control = this.records.getHandlingControl(encodeImScopeId(request.scope));
+		if (this.host.automaticHandlingBlocked(encodeImScopeId(request.scope)) || frozenBinding !== void 0 && (frozenBinding.handlingEpoch ?? 0) !== (control?.handlingEpoch ?? 0)) return { reason: "cancelled" };
+		if (request.scope.kind === "simulation") return {};
+		if (account.paused) return { reason: "account-paused" };
+		const resolution = this.host.resolveRoute(request.scope);
+		if (frozenBinding !== void 0) return resolution?.state === "matched" && account.revision === frozenBinding.accountRevision && resolution.route.id === frozenBinding.routeId && resolution.route.revision === frozenBinding.routeRevision && resolution.route.workspaceId === frozenBinding.workspaceId ? { binding: frozenBinding } : {
+			binding: frozenBinding,
+			reason: "route-changed"
+		};
+		if (resolution?.state === "matched") return { binding: {
+			routeId: resolution.route.id,
+			routeRevision: resolution.route.revision,
+			workspaceId: resolution.route.workspaceId,
+			accountRevision: account.revision
+		} };
+		if (resolution?.state === "disabled") return { reason: "route-disabled" };
+		return { reason: "route-unmatched" };
+	}
+	handlingRevoked(scope, outbound) {
+		const control = this.records.getHandlingControl(encodeImScopeId(scope));
+		return this.host.automaticHandlingBlocked(encodeImScopeId(scope)) || (control?.handlingEpoch ?? 0) !== (outbound.handlingEpoch ?? 0);
+	}
+	dispatchFailure(scope, outbound) {
+		const account = this.host.inspectAccount(scope.accountId);
+		if (account === void 0) return "account-not-found";
+		if (account.platform !== scope.platform) return "platform-mismatch";
+		if (outbound.intent === "human-manual") return void 0;
+		if (this.handlingRevoked(scope, outbound)) return "cancelled";
+		if (account.paused) return "account-paused";
+		const resolution = this.host.resolveRoute(scope);
+		if (resolution?.state !== "matched" || outbound.routeBinding === void 0) return "route-changed";
+		const binding = outbound.routeBinding;
+		return account.revision === binding.accountRevision && resolution.route.id === binding.routeId && resolution.route.revision === binding.routeRevision && resolution.route.workspaceId === binding.workspaceId ? void 0 : "route-changed";
+	}
+	assertRealScope(scope) {
+		if (scope.conversationId.trim() === "") throw new ImRuntimeError("IM_DELIVERY_SCOPE_INVALID", "IM conversationId must be non-empty");
+		const account = this.host.inspectAccount(scope.accountId);
+		if (account === void 0) throw new ImRuntimeError("IM_ACCOUNT_NOT_FOUND", `IM account '${scope.accountId}' is unknown`);
+		if (account.platform !== scope.platform) throw new ImRuntimeError("IM_DELIVERY_SCOPE_INVALID", "IM delivery scope platform does not match its account");
+	}
+	lookup(scope) {
+		const aggregate = this.records.getScope(encodeImScopeId(scope));
+		if (aggregate !== void 0 && !sameScope(aggregate.scope, scope)) throw new Error("IM scope hash collision");
+		return aggregate;
+	}
+	require(scopeId) {
+		const aggregate = this.records.getScope(scopeId);
+		if (aggregate === void 0) throw new Error(`IM delivery scope '${scopeId}' disappeared during a serialized mutation`);
+		return aggregate;
+	}
+	mutate(scope, fn) {
+		return this.enqueue(encodeImScopeId(scope), () => this.applyMutation(scope, fn));
+	}
+	/** Apply one transform to the stored or initial aggregate; the caller already holds the scope's queue. */
+	async applyMutation(scope, fn) {
+		const current = this.lookup(scope) ?? initialAggregate(scope);
+		const result = fn(current);
+		if (result.changed) await this.persistMutation(current, result.aggregate);
+		return result;
+	}
+	/** @param queue - external durable queue. @returns completion after every journal transfer is synced and removed from SQLite. */
+	async transferUploads(queue) {
+		for (const scopeId of this.records.uploadScopeIds()) await this.enqueue(scopeId, async () => {
+			const current = this.require(scopeId);
+			const pending = current.uploadPending ?? [];
+			if (pending.length === 0) return;
+			queue.append(pending);
+			await this.records.putScope(scopeId, {
+				...current,
+				uploadPending: []
+			});
+		});
+	}
+	async persistMutation(current, next) {
+		const target = this.host.uploadTarget?.(next.scope);
+		const observations = [];
+		const destinations = { ...current.uploadTargets };
+		const identities = { ...current.uploadIdentities };
+		const unknownIdentity = {
+			senderAccountId: null,
+			senderDisplayName: null,
+			senderDomain: null,
+			assignedAccountId: null
+		};
+		let observedAt = new Date(Math.max(Date.now(), Date.parse(current.uploadObservedAt ?? "1970-01-01T00:00:00.000Z") + 1)).toISOString();
+		const record = (message, destination, key) => {
+			destinations[key] = destination;
+			let identity = identities[key];
+			if (message.kind === "inbound") {
+				const value = message.value;
+				const sender = value.sender;
+				const previous = current.messages[value.messageId];
+				const unchangedSender = previous !== void 0 && JSON.stringify(previous.sender) === JSON.stringify(sender);
+				const own = sender.kind === "ai" || sender.kind === "human-dsh" ? identities[`outbound:${sender.outboundRequestId}`] : void 0;
+				identity = previous !== void 0 && identity === void 0 && previous.uploadIdentity === void 0 ? unknownIdentity : own === void 0 ? value.uploadIdentity ?? (unchangedSender ? identity : void 0) ?? {
+					senderAccountId: sender.kind === "external" ? sender.senderId : sender.kind === "human-native" || sender.kind === "human-dsh" ? sender.providerActorId ?? null : null,
+					senderDisplayName: sender.kind === "external" ? sender.senderDisplayName ?? null : null,
+					senderDomain: null,
+					assignedAccountId: next.presentation?.assignedActorId ?? null
+				} : {
+					...own,
+					assignedAccountId: value.uploadIdentity?.assignedAccountId ?? own.assignedAccountId
+				};
+			} else if (message.kind === "outbound" && identity === void 0) {
+				const actor = this.host.uploadIdentity?.(next.scope);
+				identity = current.outbounds[message.value.requestId] !== void 0 ? unknownIdentity : {
+					senderAccountId: message.value.sender?.providerActorId ?? actor?.accountId ?? null,
+					senderDisplayName: actor?.displayName ?? null,
+					senderDomain: actor?.domain ?? null,
+					assignedAccountId: next.presentation?.assignedActorId ?? null
+				};
+			}
+			if (identity !== void 0) identities[key] = identity;
+			observations.push({
+				id: brandString(randomUUID()),
+				target: destination,
+				scope: next.scope,
+				observedAt,
+				message,
+				...identity === void 0 ? {} : { identity }
+			});
+			observedAt = new Date(Date.parse(observedAt) + 1).toISOString();
+		};
+		for (const [id, value] of Object.entries(next.messages)) {
+			const key = `inbound:${id}`;
+			const previous = current.messages[id];
+			const ownEcho = value.sender.kind === "ai" || value.sender.kind === "human-dsh";
+			const senderRevised = previous !== void 0 && JSON.stringify(previous.sender) !== JSON.stringify(value.sender);
+			const destination = destinations[key] ?? (previous === void 0 ? target : void 0);
+			if (destination !== void 0 && value.origin === "live" && JSON.stringify(value) !== JSON.stringify(previous) && (!ownEcho || senderRevised)) record({
+				kind: "inbound",
+				value
+			}, destination, key);
+		}
+		for (const [id, value] of Object.entries(next.outbounds)) {
+			const key = `outbound:${id}`;
+			const destination = destinations[key] ?? (current.outbounds[id] === void 0 ? target : void 0);
+			if (destination !== void 0 && JSON.stringify(value) !== JSON.stringify(current.outbounds[id])) record({
+				kind: "outbound",
+				value
+			}, destination, key);
+		}
+		await this.records.putScope(next.scopeId, observations.length === 0 ? next : {
+			...next,
+			uploadPending: [...current.uploadPending ?? [], ...observations],
+			uploadObservedAt: observedAt,
+			uploadTargets: destinations,
+			uploadIdentities: identities
+		});
+		if (observations.length > 0) this.host.onUploadReady?.();
+	}
+	enqueue(scopeId, job) {
+		const result = (this.tails.get(scopeId) ?? Promise.resolve()).then(job);
+		const tail = settled(result);
+		this.tails.set(scopeId, tail);
+		tail.finally(() => {
+			if (this.tails.get(scopeId) === tail) this.tails.delete(scopeId);
+		});
+		return result;
+	}
+	enqueueCursor(id, job) {
+		const result = (this.cursorTails.get(id) ?? Promise.resolve()).then(job);
+		const tail = settled(result);
+		this.cursorTails.set(id, tail);
+		tail.finally(() => {
+			if (this.cursorTails.get(id) === tail) this.cursorTails.delete(id);
+		});
+		return result;
+	}
+};
+//#endregion
+//#region src/read-state.ts
+/** Strict interpretation of untrusted single-chat buyer receipt evidence. */
+/** @param buyer - verified direct recipient. @returns its SDK user id when present, otherwise the platform actor id. */
+function buyerUid(buyer) {
+	return buyer.userId ?? buyer.providerActorId;
+}
+/** @param sender - SDK sender string or object; absent receipt senders remain absent. @returns the supplied sender UID, or absence. */
+function senderUid(sender) {
+	return typeof sender === "string" ? sender : sender?.uid;
+}
+/** @param uid - SDK identity. @param buyer - verified OpenAPI buyer UID. @returns whether domain-qualified or unqualified SDK identity names this buyer. */
+function sameBuyer(uid, buyer) {
+	return uid === buyer || uid === `${buyer}@cntaobao`;
+}
+/** @param data - raw 40103 counts. @param singleton - independently verified receiver set consists solely of the target buyer. @returns conservative buyer state. */
+function buyerReadState(data, singleton) {
+	if (!singleton || data.receiverCount !== 1) return "unknown";
+	return data.unreadCount === 0 ? "read" : data.unreadCount === 1 ? "unread" : "unknown";
+}
+const rowsSchema = z.array(z.object({
+	uid: z.string(),
+	status: z.number().int().optional()
+}));
+/** @param data - ListMessageReadStatus response body. @param buyer - independently verified buyer UID. @returns matched status and whether the response establishes a singleton receiver set. */
+function buyerReadQuery(data, buyer) {
+	const parsed = rowsSchema.safeParse(data);
+	if (!parsed.success) return {
+		state: "unknown",
+		singleton: false
+	};
+	const matches = parsed.data.filter((row) => sameBuyer(row.uid, buyer));
+	if (matches.length !== 1) return {
+		state: "unknown",
+		singleton: false
+	};
+	const status = matches[0].status;
+	return {
+		state: status === 2 ? "read" : status === 0 ? "unread" : "unknown",
+		singleton: parsed.data.length === 1
+	};
+}
+//#endregion
+export { senderUid as a, encodeImScopeId as c, imExecutionAggregateSchema as d, imProviderCursorAggregateSchema as f, sameBuyer as i, imDeliveryAggregateSchema as l, ImRuntimeError as m, buyerReadState as n, ImDeliveryStore as o, imUploadObservationSchema as p, buyerUid as r, encodeImProviderCursorId as s, buyerReadQuery as t, imDeliveryScopeSchema as u };