effect-agent 0.1.0-beta.16 → 0.1.0-beta.161

package/dist/durable/MessageDelivery.mjs

@@ -0,0 +1,589 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { AgentId, DelegationId, ThreadId } from "../core/Identifiers.mjs";
+import { IdempotencyKey, Receipt } from "../core/Receipt.mjs";
+import { o as Value, r as Diagnostic, s as capture } from "../FailureDiagnostic-BElLOoED.mjs";
+import { b as WorkerUpdate } from "../Worker-CfwzMZEK.mjs";
+import { Digest } from "./Records.mjs";
+import { Settlement } from "./SubmissionLedger.mjs";
+import { digestJson } from "./Digest.mjs";
+import { ScheduleInstant, ScheduleRetry, ScheduleRetryReason } from "./Schedule.mjs";
+import { PreparedInputAdmission, admitPreparedInput } from "./PreparedInputAdmission.mjs";
+import { PreparedInput } from "./Subscription.mjs";
+import { Clock, Context, Crypto, Effect, Layer, Result, Schema, Semaphore } from "effect";
+//#region src/durable/MessageDelivery.ts
+var MessageDelivery_exports = /* @__PURE__ */ __exportAll({
+	MessageDeliveryChange: () => MessageDeliveryChange,
+	MessageDeliveryCompletion: () => MessageDeliveryCompletion,
+	MessageDeliveryDriver: () => MessageDeliveryDriver,
+	MessageDeliveryDriverLimits: () => MessageDeliveryDriverLimits,
+	MessageDeliveryError: () => MessageDeliveryError,
+	MessageDeliveryFailpoint: () => MessageDeliveryFailpoint,
+	MessageDeliveryFailpointError: () => MessageDeliveryFailpointError,
+	MessageDeliveryKey: () => MessageDeliveryKey,
+	MessageDeliveryPage: () => MessageDeliveryPage,
+	MessageDeliveryPageRequest: () => MessageDeliveryPageRequest,
+	MessageDeliveryPolicy: () => MessageDeliveryPolicy,
+	MessageDeliveryRecord: () => MessageDeliveryRecord,
+	MessageDeliveryStore: () => MessageDeliveryStore,
+	MessageDeliveryStoreLimits: () => MessageDeliveryStoreLimits,
+	applyMessageDeliveryChange: () => applyMessageDeliveryChange,
+	defaultMessageDeliveryPolicy: () => defaultMessageDeliveryPolicy,
+	defaultMessageDeliveryStoreLimits: () => defaultMessageDeliveryStoreLimits,
+	isWorkerUpdateDelivery: () => isWorkerUpdateDelivery,
+	messageDeliveryCapacity: () => messageDeliveryCapacity,
+	messageDeliveryDeadline: () => messageDeliveryDeadline,
+	messageDeliveryKeyString: () => messageDeliveryKeyString,
+	messageDeliveryUsesCapacity: () => messageDeliveryUsesCapacity,
+	prepareMessageDelivery: () => prepareMessageDelivery,
+	readPending: () => readPending,
+	sameMessageDeliveryIdentity: () => sameMessageDeliveryIdentity,
+	validateMessageDelivery: () => validateMessageDelivery
+});
+const Positive = Schema.Int.check(Schema.isGreaterThan(0));
+const BoundedName = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));
+const receiptsEqual = Schema.toEquivalence(Receipt);
+const settlementsEqual = Schema.toEquivalence(Settlement);
+/** An owner is always a source Thread. Destination admission has its own frozen key. */
+const MessageDeliveryKey = Schema.Struct({
+	ownerThreadId: ThreadId,
+	messageId: IdempotencyKey
+});
+const MessageDeliveryPolicy = Schema.Struct({
+	maxAutomaticAttempts: Positive.check(Schema.isLessThanOrEqualTo(100)),
+	attemptTimeoutMillis: Positive.check(Schema.isLessThanOrEqualTo(3e5)),
+	retryBaseMillis: Positive,
+	retryMaxMillis: Positive,
+	settlementPollMillis: Positive
+}).check(Schema.makeFilter((value) => value.retryBaseMillis <= value.retryMaxMillis));
+const defaultMessageDeliveryPolicy = {
+	maxAutomaticAttempts: 8,
+	attemptTimeoutMillis: 3e4,
+	retryBaseMillis: 1e3,
+	retryMaxMillis: 6e4,
+	settlementPollMillis: 5e3
+};
+const MessageDeliveryStoreLimits = Schema.Struct({
+	maxPendingPerOwner: Positive,
+	maxRetainedPerOwner: Positive,
+	maxEnvelopeBytes: Positive,
+	/** Separate update capacity preserves the full ordinary allowance for terminal reports. */
+	maxPendingUpdatesPerOwner: Schema.optionalKey(Positive),
+	maxRetainedUpdatesPerOwner: Schema.optionalKey(Positive)
+}).check(Schema.makeFilter((value) => value.maxPendingPerOwner <= value.maxRetainedPerOwner && (value.maxPendingUpdatesPerOwner ?? 32) <= (value.maxRetainedUpdatesPerOwner ?? 256)));
+const defaultMessageDeliveryStoreLimits = {
+	maxPendingPerOwner: 100,
+	maxRetainedPerOwner: 1e3,
+	maxEnvelopeBytes: 262144,
+	maxPendingUpdatesPerOwner: 32,
+	maxRetainedUpdatesPerOwner: 256
+};
+const ParkReason = Schema.Literals([
+	"exhausted",
+	"deadline",
+	"status-unavailable",
+	"awaiting-settlement"
+]);
+const MessageDeliveryRecord = Schema.Struct({
+	schemaVersion: Schema.Literal(1),
+	key: MessageDeliveryKey,
+	envelope: PreparedInput,
+	envelopeDigest: Digest,
+	/** Same-owner predecessor whose admission must be known before this message is submitted. */
+	predecessor: Schema.optionalKey(IdempotencyKey),
+	createdAtMillis: ScheduleInstant,
+	/** Immutable creation identity; explicit recovery only renews deadlineAtMillis. */
+	initialDeadlineAtMillis: ScheduleInstant,
+	deadlineAtMillis: ScheduleInstant,
+	policy: MessageDeliveryPolicy,
+	version: Positive,
+	status: Schema.Literals([
+		"pending",
+		"accepted",
+		"processed",
+		"refused",
+		"parked"
+	]),
+	receipt: Schema.NullOr(Receipt),
+	settlement: Schema.NullOr(Settlement),
+	refusal: Schema.NullOr(BoundedName),
+	parkReason: Schema.NullOr(ParkReason),
+	leaseUntilMillis: Schema.NullOr(ScheduleInstant),
+	retry: ScheduleRetry,
+	/** Last failed admission/status check, retained across retries and successful recovery. */
+	lastFailureDiagnostic: Schema.optionalKey(Diagnostic)
+}).check(Schema.makeFilter((record) => record.deadlineAtMillis > record.createdAtMillis && record.initialDeadlineAtMillis > record.createdAtMillis && record.predecessor !== record.key.messageId && record.status === "processed" === (record.settlement !== null) && record.status === "refused" === (record.refusal !== null) && record.status === "parked" === (record.parkReason !== null) && record.status === "parked" === record.retry.parked && (record.status === "accepted" || record.status === "processed" ? record.receipt !== null : true) && (record.status === "pending" || record.status === "refused" ? record.receipt === null : true) && (record.receipt === null || record.receipt.threadId === record.envelope.threadId) && (record.settlement === null || record.settlement.receiptId === record.receipt?.receiptId && record.settlement.submissionId === record.receipt.submissionId) && (record.status === "processed" || record.status === "refused" || record.status === "parked" ? record.leaseUntilMillis === null : true)));
+var MessageDeliveryError = class extends Schema.TaggedError()("MessageDeliveryError", {
+	cause: Schema.optionalKey(Value),
+	stack: Schema.optionalKey(Schema.String),
+	reason: Schema.Literals([
+		"validation",
+		"conflict",
+		"capacity",
+		"not-found",
+		"storage",
+		"corrupt"
+	]),
+	operation: Schema.String
+}) {};
+var MessageDeliveryFailpointError = class extends Schema.TaggedError()("MessageDeliveryFailpointError", { point: Schema.String }) {};
+const MessageDeliveryFailpoint = Context.Reference("@effect-agent/thread/MessageDeliveryFailpoint", { defaultValue: () => ({ hit: () => Effect.void }) });
+const fence = {
+	expectedVersion: Positive,
+	nowMillis: ScheduleInstant
+};
+/** Terminal destination evidence, independent of an expiring source transport claim. */
+const MessageDeliveryCompletion = Schema.Struct({
+	receipt: Receipt,
+	settlement: Settlement,
+	admissionKey: IdempotencyKey,
+	inputDigest: Digest
+});
+const MessageDeliveryChange = Schema.Union([
+	Schema.Struct({
+		_tag: Schema.Literal("Complete"),
+		nowMillis: ScheduleInstant,
+		...MessageDeliveryCompletion.fields
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Claim"),
+		...fence
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Accept"),
+		...fence,
+		receipt: Receipt
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Process"),
+		...fence,
+		settlement: Settlement
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("ObservePending"),
+		...fence
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Refuse"),
+		...fence,
+		code: BoundedName,
+		diagnostic: Schema.optionalKey(Diagnostic)
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Retry"),
+		...fence,
+		reason: ScheduleRetryReason,
+		diagnostic: Schema.optionalKey(Diagnostic)
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Park"),
+		...fence,
+		reason: ParkReason,
+		diagnostic: Schema.optionalKey(Diagnostic)
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Recover"),
+		...fence,
+		deadlineAtMillis: ScheduleInstant
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Defer"),
+		...fence,
+		untilMillis: ScheduleInstant
+	})
+]);
+/** Select one native index per page; index filters cannot be combined. */
+const MessageDeliveryPageRequest = Schema.Struct({
+	ownerThreadId: ThreadId,
+	limit: Positive.check(Schema.isLessThanOrEqualTo(4096)),
+	after: Schema.optionalKey(IdempotencyKey),
+	/** Native pending index, including accepted, future-due and parked obligations. */
+	pendingOnly: Schema.optionalKey(Schema.Boolean),
+	/** First retained envelopes, including starts not admitted at the destination. */
+	workerStarts: Schema.optionalKey(Schema.Struct({
+		delegationId: DelegationId,
+		targetAgentId: AgentId
+	})),
+	/** Retained inputs not yet acknowledged by one destination worker. */
+	pendingWorker: Schema.optionalKey(ThreadId)
+}).check(Schema.makeFilter((request) => Number(request.pendingOnly === true) + Number(request.workerStarts !== void 0) + Number(request.pendingWorker !== void 0) <= 1));
+const MessageDeliveryPage = Schema.Struct({
+	items: Schema.Array(MessageDeliveryRecord),
+	next: Schema.NullOr(IdempotencyKey)
+});
+/**
+* Trusted host port, independent of either Thread's active Submission. List/get require an owner.
+* Inserts and changes are atomic; identical inserts return current state even after completion.
+* No automatic deletion: completed rows retain deduplication evidence and count toward retention.
+* `due`/`nextDeadline` are bounded host recovery seams, never model-facing management operations.
+*/
+var MessageDeliveryStore = class extends Context.Service()("@effect-agent/thread/MessageDeliveryStore") {};
+/**
+* Read current source-owned obligations without acquiring a runtime or scanning completed history.
+* A retained receipt is native accepted-admission evidence, not proof of destination materialization.
+* Shipped worker admission reserves the source input before returning that receipt. Policy can
+* therefore leave accepted worker discovery to canonical outstanding inputs; a no-receipt action
+* delivery remains uncertain, including when parked or due in the future.
+*/
+const readPending = Effect.fn("MessageDelivery.readPending")(function* (request) {
+	const store = yield* MessageDeliveryStore;
+	const input = yield* validateMessageDelivery(MessageDeliveryPageRequest, {
+		ownerThreadId: request.ownerThreadId,
+		limit: request.limit,
+		pendingOnly: true
+	}, "read-pending");
+	const page = yield* validateMessageDelivery(MessageDeliveryPage, yield* store.list(input), "read-pending result");
+	if (page.next !== null || page.items.length > input.limit) return yield* MessageDeliveryError.make({
+		reason: "capacity",
+		operation: "read-pending"
+	});
+	const records = page.items;
+	if (records.some((record) => record.key.ownerThreadId !== input.ownerThreadId || !messageDeliveryUsesCapacity(record)) || new Set(records.map((record) => record.key.messageId)).size !== records.length) return yield* MessageDeliveryError.make({
+		reason: "corrupt",
+		operation: "read-pending result"
+	});
+	return records;
+});
+const messageDeliveryKeyString = (key) => JSON.stringify([key.ownerThreadId, key.messageId]);
+const messageDeliveryUsesCapacity = (record) => record.status !== "processed" && record.status !== "refused";
+const isWorkerUpdateDelivery = (record) => Schema.is(WorkerUpdate)(record.envelope.messageAdmission);
+const messageDeliveryCapacity = (limits, update) => ({
+	pending: update ? limits.maxPendingUpdatesPerOwner ?? 32 : limits.maxPendingPerOwner,
+	retained: update ? limits.maxRetainedUpdatesPerOwner ?? 256 : limits.maxRetainedPerOwner
+});
+const messageDeliveryDeadline = (record) => record.status === "pending" || record.status === "accepted" ? Math.min(record.deadlineAtMillis, record.leaseUntilMillis ?? record.retry.nextAttemptAtMillis) : null;
+/** Creation identity deliberately excludes operational counters and renewed recovery deadlines. */
+const sameMessageDeliveryIdentity = (left, right) => messageDeliveryKeyString(left.key) === messageDeliveryKeyString(right.key) && left.envelopeDigest === right.envelopeDigest && left.predecessor === right.predecessor && Schema.toEquivalence(PreparedInput)(left.envelope, right.envelope) && Schema.toEquivalence(MessageDeliveryPolicy)(left.policy, right.policy) && left.createdAtMillis === right.createdAtMillis && left.initialDeadlineAtMillis === right.initialDeadlineAtMillis;
+const error = (reason, operation, cause) => MessageDeliveryError.make({
+	reason,
+	operation,
+	...cause === void 0 ? {} : { cause }
+});
+const validateMessageDelivery = (schema, value, operation) => Schema.decodeUnknownEffect(Schema.toType(schema))(value).pipe(Effect.mapError(() => error("validation", operation)));
+const MessageDeliveryPreparation = Schema.Struct({
+	key: MessageDeliveryKey,
+	envelope: PreparedInput,
+	createdAtMillis: ScheduleInstant,
+	deadlineAtMillis: ScheduleInstant,
+	policy: MessageDeliveryPolicy,
+	predecessor: Schema.optionalKey(IdempotencyKey)
+});
+/** Freeze and digest the complete admission envelope before publishing the obligation. */
+const prepareMessageDelivery = Effect.fn("MessageDelivery.prepare")(function* (options) {
+	const snapshot = yield* Schema.encodeEffect(Schema.fromJsonString(MessageDeliveryPreparation))({
+		...options,
+		policy: options.policy ?? defaultMessageDeliveryPolicy
+	}).pipe(Effect.flatMap(Schema.decodeEffect(Schema.fromJsonString(MessageDeliveryPreparation))), Effect.mapError((cause) => error("validation", "prepare", cause)));
+	const envelope = snapshot.envelope;
+	const encoded = yield* Schema.encodeEffect(PreparedInput)(envelope).pipe(Effect.mapError((cause) => error("validation", "prepare", cause)));
+	if ((yield* digestJson(encoded.input).pipe(Effect.mapError((cause) => error("storage", "digest", cause)))) !== envelope.inputDigest) return yield* error("corrupt", "input-digest");
+	const envelopeDigest = yield* digestJson(encoded).pipe(Effect.mapError((cause) => error("storage", "digest", cause)));
+	return yield* validateMessageDelivery(MessageDeliveryRecord, {
+		schemaVersion: 1,
+		key: snapshot.key,
+		envelope,
+		envelopeDigest,
+		...snapshot.predecessor === void 0 ? {} : { predecessor: snapshot.predecessor },
+		createdAtMillis: snapshot.createdAtMillis,
+		initialDeadlineAtMillis: snapshot.deadlineAtMillis,
+		deadlineAtMillis: snapshot.deadlineAtMillis,
+		policy: snapshot.policy,
+		version: 1,
+		status: "pending",
+		receipt: null,
+		settlement: null,
+		refusal: null,
+		parkReason: null,
+		leaseUntilMillis: null,
+		retry: {
+			attempts: 0,
+			generation: 0,
+			automaticAttempts: 0,
+			parked: false,
+			nextAttemptAtMillis: snapshot.createdAtMillis,
+			lastAttemptAtMillis: null,
+			lastFailure: null
+		}
+	}, "prepare");
+});
+/** Pure reducer used under the adapter's atomic compare-and-swap boundary. */
+const applyMessageDeliveryChange = (record, change) => {
+	const conflict = () => Result.fail(error("conflict", change._tag));
+	if (change._tag === "Complete") {
+		if (change.admissionKey !== record.envelope.admissionKey || change.inputDigest !== record.envelope.inputDigest || change.receipt.threadId !== record.envelope.threadId || change.settlement.submissionId !== change.receipt.submissionId || change.settlement.receiptId !== change.receipt.receiptId || record.receipt !== null && !receiptsEqual(record.receipt, change.receipt)) return Result.fail(error("corrupt", "completion-identity"));
+		if (record.status === "refused") return conflict();
+		if (record.status === "processed") return record.settlement !== null && settlementsEqual(record.settlement, change.settlement) ? Result.succeed(record) : Result.fail(error("corrupt", "completion-identity"));
+		return Result.succeed({
+			...record,
+			version: record.version + 1,
+			status: "processed",
+			receipt: change.receipt,
+			settlement: change.settlement,
+			leaseUntilMillis: null,
+			parkReason: null,
+			retry: {
+				...record.retry,
+				parked: false
+			}
+		});
+	}
+	if (record.version !== change.expectedVersion) return conflict();
+	if (record.status === "processed" || record.status === "refused") return conflict();
+	const now = change.nowMillis;
+	const base = {
+		...record,
+		version: record.version + 1,
+		..."diagnostic" in change && change.diagnostic !== void 0 ? { lastFailureDiagnostic: change.diagnostic } : {}
+	};
+	const parked = (reason) => ({
+		...base,
+		status: "parked",
+		parkReason: reason,
+		leaseUntilMillis: null,
+		retry: {
+			...record.retry,
+			parked: true
+		}
+	});
+	if (change._tag === "Defer") {
+		if (record.status !== "pending" || record.leaseUntilMillis !== null && record.leaseUntilMillis > now) return conflict();
+		if (now >= record.deadlineAtMillis) return Result.succeed(parked("deadline"));
+		if (change.untilMillis <= now) return conflict();
+		return Result.succeed({
+			...base,
+			leaseUntilMillis: null,
+			retry: {
+				...record.retry,
+				nextAttemptAtMillis: Math.min(change.untilMillis, record.deadlineAtMillis)
+			}
+		});
+	}
+	if (change._tag === "Recover") {
+		if (record.status !== "parked" || change.deadlineAtMillis <= now) return conflict();
+		return Result.succeed({
+			...base,
+			deadlineAtMillis: change.deadlineAtMillis,
+			status: record.receipt === null ? "pending" : "accepted",
+			parkReason: null,
+			retry: {
+				...record.retry,
+				generation: record.retry.generation + 1,
+				automaticAttempts: 0,
+				parked: false,
+				nextAttemptAtMillis: now
+			}
+		});
+	}
+	if (record.status === "parked") return conflict();
+	if (change._tag === "Park") return Result.succeed(parked(change.reason));
+	if (change._tag === "Claim") {
+		const due = messageDeliveryDeadline(record);
+		if (due === null || due > now) return conflict();
+		if (now >= record.deadlineAtMillis) return Result.succeed(parked("deadline"));
+		if (record.retry.automaticAttempts >= record.policy.maxAutomaticAttempts) return Result.succeed(parked("exhausted"));
+		return Result.succeed({
+			...base,
+			leaseUntilMillis: Math.min(now + record.policy.attemptTimeoutMillis, record.deadlineAtMillis),
+			retry: {
+				...record.retry,
+				attempts: record.retry.attempts + 1,
+				automaticAttempts: record.retry.automaticAttempts + 1,
+				lastAttemptAtMillis: now
+			}
+		});
+	}
+	if (record.leaseUntilMillis === null || now > record.leaseUntilMillis) return conflict();
+	if (change._tag === "Accept") {
+		if (record.status !== "pending") return conflict();
+		if (change.receipt.threadId !== record.envelope.threadId) return Result.fail(error("corrupt", "receipt-identity"));
+		return Result.succeed({
+			...base,
+			status: "accepted",
+			receipt: change.receipt,
+			leaseUntilMillis: null,
+			retry: {
+				...record.retry,
+				automaticAttempts: 0,
+				nextAttemptAtMillis: Math.min(now + record.policy.settlementPollMillis, record.deadlineAtMillis),
+				lastFailure: null
+			}
+		});
+	}
+	if (change._tag === "Process") {
+		if (record.status !== "accepted") return conflict();
+		if (change.settlement.submissionId !== record.receipt?.submissionId || change.settlement.receiptId !== record.receipt.receiptId) return Result.fail(error("corrupt", "settlement-identity"));
+		return Result.succeed({
+			...base,
+			status: "processed",
+			settlement: change.settlement,
+			leaseUntilMillis: null
+		});
+	}
+	if (change._tag === "ObservePending") {
+		if (record.status !== "accepted") return conflict();
+		return Result.succeed(parked("awaiting-settlement"));
+	}
+	if (change._tag === "Refuse") {
+		if (record.status !== "pending") return conflict();
+		return Result.succeed({
+			...base,
+			status: "refused",
+			refusal: change.code,
+			leaseUntilMillis: null
+		});
+	}
+	if (now >= record.deadlineAtMillis) return Result.succeed(parked("deadline"));
+	if (record.retry.automaticAttempts >= record.policy.maxAutomaticAttempts) return Result.succeed(parked("exhausted"));
+	const delay = Math.min(record.policy.retryBaseMillis * 2 ** Math.min(record.retry.automaticAttempts - 1, 52), record.policy.retryMaxMillis);
+	return Result.succeed({
+		...base,
+		leaseUntilMillis: null,
+		retry: {
+			...record.retry,
+			nextAttemptAtMillis: Math.min(now + (record.status === "accepted" ? record.policy.settlementPollMillis : delay), record.deadlineAtMillis),
+			lastFailure: change.reason
+		}
+	});
+};
+const MessageDeliveryDriverLimits = Schema.Struct({
+	batchSize: Positive.check(Schema.isLessThanOrEqualTo(100)),
+	concurrency: Positive.check(Schema.isLessThanOrEqualTo(32))
+});
+/**
+* Finite, structured host pump. The host owns its Scope and wakes it from nextDeadline even
+* after source/receiver settlement. Failed or interrupted calls retain their expiring claim;
+* no ordinary tool is replayed here, only idempotent PreparedInput admission/status lookup.
+* Spans expose operation names; envelopes, principals, and message contents are never logged.
+*/
+var MessageDeliveryDriver = class MessageDeliveryDriver extends Context.Service()("@effect-agent/thread/MessageDeliveryDriver") {
+	static layer(limits = {
+		batchSize: 100,
+		concurrency: 4
+	}) {
+		return Layer.effect(MessageDeliveryDriver, Effect.gen(function* () {
+			const config = yield* validateMessageDelivery(MessageDeliveryDriverLimits, limits, "driver-limits");
+			const store = yield* MessageDeliveryStore;
+			const admission = yield* PreparedInputAdmission;
+			const crypto = yield* Crypto.Crypto;
+			const failpoint = yield* MessageDeliveryFailpoint;
+			const semaphore = yield* Semaphore.make(config.concurrency);
+			const process = Effect.fn("MessageDelivery.process")((key) => semaphore.withPermit(Effect.gen(function* () {
+				const current = yield* store.get(key);
+				if (current === null) return yield* error("not-found", "process");
+				const nowMillis = yield* Clock.currentTimeMillis;
+				const due = messageDeliveryDeadline(current);
+				if (due === null || due > nowMillis) return current;
+				if (current.status === "pending" && current.predecessor !== void 0) {
+					const previous = yield* store.get({
+						ownerThreadId: key.ownerThreadId,
+						messageId: current.predecessor
+					});
+					if (previous === null || previous.receipt === null && previous.status !== "refused") return yield* store.change(key, {
+						_tag: "Defer",
+						expectedVersion: current.version,
+						nowMillis,
+						untilMillis: nowMillis + current.policy.settlementPollMillis
+					});
+				}
+				const claimed = yield* store.change(key, {
+					_tag: "Claim",
+					expectedVersion: current.version,
+					nowMillis
+				});
+				if (claimed.status === "parked") return claimed;
+				const envelope = yield* Schema.encodeEffect(PreparedInput)(claimed.envelope).pipe(Effect.mapError((cause) => error("corrupt", "envelope", cause)));
+				if ((yield* digestJson(envelope).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((cause) => error("storage", "digest", cause)))) !== claimed.envelopeDigest) return yield* error("corrupt", "envelope-digest");
+				const timeout = Math.min(claimed.policy.attemptTimeoutMillis, (claimed.leaseUntilMillis ?? claimed.deadlineAtMillis) - (yield* Clock.currentTimeMillis));
+				if (timeout <= 0) return claimed;
+				const commit = (change) => Clock.currentTimeMillis.pipe(Effect.flatMap((time) => store.change(key, {
+					...change,
+					expectedVersion: claimed.version,
+					nowMillis: time
+				})));
+				if (claimed.status === "pending") {
+					const outcome = yield* admitPreparedInput(admission.submit(claimed.envelope), timeout).pipe(Effect.mapError((cause) => error("corrupt", "admission", cause)));
+					yield* failpoint.hit("message-delivery:admission:after");
+					if (outcome._tag === "Receipt") {
+						const accepted = yield* commit({
+							_tag: "Accept",
+							receipt: outcome.receipt
+						});
+						return yield* store.change(key, {
+							_tag: "Park",
+							reason: "awaiting-settlement",
+							expectedVersion: accepted.version,
+							nowMillis: yield* Clock.currentTimeMillis
+						});
+					}
+					if (outcome._tag === "Refused") return yield* commit({
+						_tag: "Refuse",
+						code: outcome.error.code,
+						diagnostic: capture(outcome.error)
+					});
+					return yield* commit({
+						_tag: "Retry",
+						reason: outcome.reason,
+						diagnostic: outcome.diagnostic
+					});
+				}
+				if (claimed.receipt === null) return yield* error("corrupt", "receipt");
+				if (admission.submissionStatus === void 0) return yield* commit({
+					_tag: "Park",
+					reason: "status-unavailable"
+				});
+				const status = yield* admission.submissionStatus(claimed.receipt).pipe(Effect.timeout(timeout), Effect.map((status) => ({
+					_tag: "Status",
+					status
+				})), Effect.catchTag("ScheduledInputRetryable", (failure) => Effect.succeed({
+					_tag: "Retry",
+					reason: failure.reason,
+					diagnostic: capture(failure)
+				})), Effect.catchTag("ScheduledInputRefused", (failure) => Effect.succeed({
+					_tag: "Unavailable",
+					diagnostic: capture(failure)
+				})), Effect.catchTag("TimeoutError", (failure) => Effect.succeed({
+					_tag: "Retry",
+					reason: "timeout",
+					diagnostic: capture(failure)
+				})), Effect.catchTag("ScheduleStorageError", (failure) => failure.reason === "unavailable" ? Effect.succeed({
+					_tag: "Retry",
+					reason: "storage",
+					diagnostic: capture(failure)
+				}) : Effect.fail(error("corrupt", "status", failure))));
+				if (status._tag === "Unavailable") return yield* commit({
+					_tag: "Park",
+					reason: "status-unavailable",
+					diagnostic: status.diagnostic
+				});
+				if (status._tag === "Status" && status.status._tag === "settled") return yield* commit({
+					_tag: "Process",
+					settlement: status.status.settlement
+				});
+				if (status._tag === "Status") return yield* commit({ _tag: "ObservePending" });
+				return yield* commit({
+					_tag: "Retry",
+					reason: status.reason,
+					diagnostic: status.diagnostic
+				});
+			})).pipe(Effect.catchTag("MessageDeliveryError", (failure) => failure.reason === "conflict" ? store.get(key).pipe(Effect.filterOrFail((record) => record !== null, () => failure)) : Effect.fail(failure))));
+			return MessageDeliveryDriver.of({
+				process,
+				runDue: Effect.fn("MessageDelivery.runDue")(function* (ownerThreadId) {
+					const keys = yield* store.due(yield* Clock.currentTimeMillis, config.batchSize, ownerThreadId);
+					return yield* Effect.forEach(keys, process, { concurrency: config.concurrency });
+				}),
+				retry: Effect.fn("MessageDelivery.retry")(function* (key, expectedVersion, deadlineAtMillis) {
+					return yield* store.change(key, {
+						_tag: "Recover",
+						expectedVersion,
+						deadlineAtMillis,
+						nowMillis: yield* Clock.currentTimeMillis
+					});
+				})
+			});
+		}));
+	}
+};
+//#endregion
+export { MessageDeliveryChange, MessageDeliveryCompletion, MessageDeliveryDriver, MessageDeliveryDriverLimits, MessageDeliveryError, MessageDeliveryFailpoint, MessageDeliveryFailpointError, MessageDeliveryKey, MessageDeliveryPage, MessageDeliveryPageRequest, MessageDeliveryPolicy, MessageDeliveryRecord, MessageDeliveryStore, MessageDeliveryStoreLimits, applyMessageDeliveryChange, defaultMessageDeliveryPolicy, defaultMessageDeliveryStoreLimits, isWorkerUpdateDelivery, messageDeliveryCapacity, messageDeliveryDeadline, messageDeliveryKeyString, messageDeliveryUsesCapacity, prepareMessageDelivery, readPending, sameMessageDeliveryIdentity, MessageDelivery_exports as t, validateMessageDelivery };
+
+//# sourceMappingURL=MessageDelivery.mjs.map