effect-agent 0.1.0-beta.11 → 0.1.0-beta.111

package/dist/durable/MessageDeliveryStoreConformance.d.mts

@@ -0,0 +1,376 @@
+import { d as SubagentReservationAmounts, l as SubagentGrant, o as SubagentDelegationCaps, s as SubagentExecutionFailure } from "../SubagentContract-DdT7Cqe6.mjs";
+import { a as Receipt } from "../Receipt-BAHyigAF.mjs";
+import { r as Update } from "../AgentUpdates-DMJ-_xow.mjs";
+import { r as Diagnostic } from "../FailureDiagnostic-CaAkzGHL.mjs";
+import { t as AgentPolicy } from "../AgentPolicy-BqDoSXO6.mjs";
+import { co as Settlement, h as DefinitionDigests, mi as DigestError } from "../Records-4qnRmniE.mjs";
+import { MessageDeliveryError, MessageDeliveryFailure, MessageDeliveryStore } from "./MessageDelivery.mjs";
+import { Effect, Schema } from "effect";
+//#region src/durable/MessageDeliveryStoreConformance.d.ts
+declare const MessageDeliveryConformanceViolation_base: Schema.Class<MessageDeliveryConformanceViolation, Schema.TaggedStruct<"MessageDeliveryConformanceViolation", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageDeliveryConformanceViolation extends MessageDeliveryConformanceViolation_base {}
+/** One valid frozen envelope shared by real storage and restart tests. */
+export declare const makeMessageDeliveryFixture: (messageId?: any, owner?: any, text?: any) => Effect.Effect<{
+  readonly schemaVersion: 1;
+  readonly key: {
+    readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+  };
+  readonly envelope: {
+    readonly schemaVersion: 1;
+    readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly deliveryPrincipal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">;
+    readonly admissionGroup?: string | undefined;
+    readonly admissionFence?: {
+      readonly policyId: string;
+      readonly key: string;
+      readonly revision: string;
+    } | undefined;
+    readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+    readonly definitions: DefinitionDigests;
+    readonly input: Schema.Json;
+    readonly inputDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
+    readonly admissionKey: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+    readonly authorization: {
+      readonly policyId: string;
+      readonly decisionId: string;
+    };
+    readonly workerAdmission?: {
+      readonly origin: {
+        readonly worker: {
+          readonly schemaVersion: 1;
+          readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+          readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly source: {
+          readonly _tag: "tool";
+          readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+          readonly runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+          readonly toolCallId: string & import("effect/Brand").Brand<"@effect-agent/core/ToolCallId">;
+        } | {
+          readonly _tag: "programmatic";
+          readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly budgetScope?: "source-subtree" | "worker-run" | undefined;
+        readonly targetDigests: DefinitionDigests;
+        readonly policy: AgentPolicy;
+        readonly budget: {
+          readonly caps: SubagentDelegationCaps;
+          readonly allocation: SubagentReservationAmounts;
+          readonly descendantInvocations?: number | undefined;
+        };
+        readonly grant: SubagentGrant;
+        readonly depth: number;
+        readonly toolCallAllowance?: number | undefined;
+        readonly firstMessageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+        readonly createdAtMillis: number;
+        readonly expiresAtMillis: number;
+        readonly reporting?: {
+          readonly mode?: "standard" | undefined;
+          readonly sourceDigests: DefinitionDigests;
+          readonly destinationDelegationId?: (string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">) | undefined;
+          readonly returnAddress?: {
+            readonly input: Schema.Json;
+            readonly principal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">;
+            readonly policy: AgentPolicy;
+            readonly depth: number;
+            readonly grant?: SubagentGrant | undefined;
+            readonly workerAdmission?: Schema.Json | undefined;
+          } | undefined;
+        } | undefined;
+      };
+      readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      readonly parameters: Schema.Json;
+      readonly createdAtMillis: number;
+      readonly sourceSubmissionId?: (string & import("effect/Brand").Brand<"@effect-agent/core/SubmissionId">) | undefined;
+      readonly deliveryPrincipal?: (string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">) | undefined;
+      readonly reportKind?: "update" | undefined;
+    } | undefined;
+    readonly messageAdmission?: {
+      readonly schemaVersion: 1;
+      readonly message: {
+        readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      };
+      readonly peerName: string;
+      readonly sender: {
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      };
+      readonly returnAddress: {
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      };
+      readonly inReplyTo?: {
+        readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      } | undefined;
+    } | {
+      readonly _tag: "WorkerCompletion";
+      readonly budgetExhausted: boolean;
+      readonly schemaVersion: 1;
+      readonly report: {
+        readonly _tag: "Settled";
+        readonly worker: {
+          readonly schemaVersion: 1;
+          readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+          readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly receipt: Receipt;
+        readonly runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+        readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+        readonly outcome: "completed";
+        readonly result: Schema.Json;
+      } | {
+        readonly _tag: "Settled";
+        readonly worker: {
+          readonly schemaVersion: 1;
+          readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+          readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly receipt: Receipt;
+        readonly runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+        readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+        readonly outcome: "aborted" | "failed";
+        readonly failure: SubagentExecutionFailure;
+      };
+    } | {
+      readonly _tag: "WorkerUpdate";
+      readonly schemaVersion: 1;
+      readonly worker: {
+        readonly schemaVersion: 1;
+        readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+        readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+      };
+      readonly update: Update;
+    } | undefined;
+  };
+  readonly envelopeDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
+  readonly predecessor?: (string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">) | undefined;
+  readonly createdAtMillis: number;
+  readonly initialDeadlineAtMillis: number;
+  readonly deadlineAtMillis: number;
+  readonly policy: {
+    readonly maxAutomaticAttempts: number;
+    readonly attemptTimeoutMillis: number;
+    readonly retryBaseMillis: number;
+    readonly retryMaxMillis: number;
+    readonly settlementPollMillis: number;
+  };
+  readonly version: number;
+  readonly status: "accepted" | "parked" | "pending" | "processed" | "refused";
+  readonly receipt: Receipt | null;
+  readonly settlement: Settlement | null;
+  readonly refusal: string | null;
+  readonly parkReason: "deadline" | "exhausted" | "status-unavailable" | null;
+  readonly leaseUntilMillis: number | null;
+  readonly retry: {
+    readonly attempts: number;
+    readonly generation: number;
+    readonly automaticAttempts: number;
+    readonly parked: boolean;
+    readonly nextAttemptAtMillis: number;
+    readonly lastAttemptAtMillis: number | null;
+    readonly lastFailure: "ambiguous" | "capacity" | "host-closed" | "storage" | "timeout" | "transport" | null;
+  };
+  readonly lastFailureDiagnostic?: Diagnostic | undefined;
+}, DigestError | MessageDeliveryError, import("effect/Crypto").Crypto>;
+export declare const messageDeliveryFixtureReceipt: Receipt;
+export declare const makeWorkerUpdateDeliveryFixture: (id: string) => Effect.Effect<{
+  readonly schemaVersion: 1;
+  readonly key: {
+    readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+  };
+  readonly envelope: {
+    readonly schemaVersion: 1;
+    readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly deliveryPrincipal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">;
+    readonly admissionGroup?: string | undefined;
+    readonly admissionFence?: {
+      readonly policyId: string;
+      readonly key: string;
+      readonly revision: string;
+    } | undefined;
+    readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+    readonly definitions: DefinitionDigests;
+    readonly input: Schema.Json;
+    readonly inputDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
+    readonly admissionKey: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+    readonly authorization: {
+      readonly policyId: string;
+      readonly decisionId: string;
+    };
+    readonly workerAdmission?: {
+      readonly origin: {
+        readonly worker: {
+          readonly schemaVersion: 1;
+          readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+          readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly source: {
+          readonly _tag: "tool";
+          readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+          readonly runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+          readonly toolCallId: string & import("effect/Brand").Brand<"@effect-agent/core/ToolCallId">;
+        } | {
+          readonly _tag: "programmatic";
+          readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly budgetScope?: "source-subtree" | "worker-run" | undefined;
+        readonly targetDigests: DefinitionDigests;
+        readonly policy: AgentPolicy;
+        readonly budget: {
+          readonly caps: SubagentDelegationCaps;
+          readonly allocation: SubagentReservationAmounts;
+          readonly descendantInvocations?: number | undefined;
+        };
+        readonly grant: SubagentGrant;
+        readonly depth: number;
+        readonly toolCallAllowance?: number | undefined;
+        readonly firstMessageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+        readonly createdAtMillis: number;
+        readonly expiresAtMillis: number;
+        readonly reporting?: {
+          readonly mode?: "standard" | undefined;
+          readonly sourceDigests: DefinitionDigests;
+          readonly destinationDelegationId?: (string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">) | undefined;
+          readonly returnAddress?: {
+            readonly input: Schema.Json;
+            readonly principal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">;
+            readonly policy: AgentPolicy;
+            readonly depth: number;
+            readonly grant?: SubagentGrant | undefined;
+            readonly workerAdmission?: Schema.Json | undefined;
+          } | undefined;
+        } | undefined;
+      };
+      readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      readonly parameters: Schema.Json;
+      readonly createdAtMillis: number;
+      readonly sourceSubmissionId?: (string & import("effect/Brand").Brand<"@effect-agent/core/SubmissionId">) | undefined;
+      readonly deliveryPrincipal?: (string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">) | undefined;
+      readonly reportKind?: "update" | undefined;
+    } | undefined;
+    readonly messageAdmission?: {
+      readonly schemaVersion: 1;
+      readonly message: {
+        readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      };
+      readonly peerName: string;
+      readonly sender: {
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      };
+      readonly returnAddress: {
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      };
+      readonly inReplyTo?: {
+        readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      } | undefined;
+    } | {
+      readonly _tag: "WorkerCompletion";
+      readonly budgetExhausted: boolean;
+      readonly schemaVersion: 1;
+      readonly report: {
+        readonly _tag: "Settled";
+        readonly worker: {
+          readonly schemaVersion: 1;
+          readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+          readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly receipt: Receipt;
+        readonly runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+        readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+        readonly outcome: "completed";
+        readonly result: Schema.Json;
+      } | {
+        readonly _tag: "Settled";
+        readonly worker: {
+          readonly schemaVersion: 1;
+          readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+          readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+          readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        };
+        readonly receipt: Receipt;
+        readonly runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+        readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+        readonly outcome: "aborted" | "failed";
+        readonly failure: SubagentExecutionFailure;
+      };
+    } | {
+      readonly _tag: "WorkerUpdate";
+      readonly schemaVersion: 1;
+      readonly worker: {
+        readonly schemaVersion: 1;
+        readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+        readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+      };
+      readonly update: Update;
+    } | undefined;
+  };
+  readonly envelopeDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
+  readonly predecessor?: (string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">) | undefined;
+  readonly createdAtMillis: number;
+  readonly initialDeadlineAtMillis: number;
+  readonly deadlineAtMillis: number;
+  readonly policy: {
+    readonly maxAutomaticAttempts: number;
+    readonly attemptTimeoutMillis: number;
+    readonly retryBaseMillis: number;
+    readonly retryMaxMillis: number;
+    readonly settlementPollMillis: number;
+  };
+  readonly version: number;
+  readonly status: "accepted" | "parked" | "pending" | "processed" | "refused";
+  readonly receipt: Receipt | null;
+  readonly settlement: Settlement | null;
+  readonly refusal: string | null;
+  readonly parkReason: "deadline" | "exhausted" | "status-unavailable" | null;
+  readonly leaseUntilMillis: number | null;
+  readonly retry: {
+    readonly attempts: number;
+    readonly generation: number;
+    readonly automaticAttempts: number;
+    readonly parked: boolean;
+    readonly nextAttemptAtMillis: number;
+    readonly lastAttemptAtMillis: number | null;
+    readonly lastFailure: "ambiguous" | "capacity" | "host-closed" | "storage" | "timeout" | "transport" | null;
+  };
+  readonly lastFailureDiagnostic?: Diagnostic | undefined;
+}, DigestError | MessageDeliveryError, import("effect/Crypto").Crypto>;
+/** Every case starts with an empty store; all clocks and expected values are explicit. */
+export declare const messageDeliveryStoreConformanceCases: readonly [{
+  readonly name: "reserves ordinary delivery capacity when worker updates saturate their separate bound";
+  readonly run: Effect.Effect<void, DigestError | MessageDeliveryConformanceViolation | MessageDeliveryFailure, import("effect/Crypto").Crypto | MessageDeliveryStore>;
+}, {
+  readonly name: "retains predecessor identity and defers ordering waits without spending attempts";
+  readonly run: Effect.Effect<void, DigestError | MessageDeliveryConformanceViolation | MessageDeliveryFailure, import("effect/Crypto").Crypto | MessageDeliveryStore>;
+}, {
+  readonly name: "retains pending, accepted and processed facts with stable duplicate admission";
+  readonly run: Effect.Effect<void, DigestError | MessageDeliveryConformanceViolation | MessageDeliveryFailure, import("effect/Crypto").Crypto | MessageDeliveryStore>;
+}, {
+  readonly name: "rejects conflicting identity and scopes cursors and discovery to the source owner";
+  readonly run: Effect.Effect<void, DigestError | MessageDeliveryConformanceViolation | MessageDeliveryFailure, import("effect/Crypto").Crypto | MessageDeliveryStore>;
+}, {
+  readonly name: "fences stale completion and preserves parked work for explicit recovery";
+  readonly run: Effect.Effect<void, DigestError | MessageDeliveryConformanceViolation | MessageDeliveryFailure, import("effect/Crypto").Crypto | MessageDeliveryStore>;
+}];
+//#endregion
+//# sourceMappingURL=MessageDeliveryStoreConformance.d.mts.map

package/dist/durable/MessageDeliveryStoreConformance.mjs

@@ -0,0 +1,270 @@
+import { AgentId, DelegationId, ReceiptId, RunId, SettlementId, SubmissionId, ThreadId } from "../core/Identifiers.mjs";
+import { IdempotencyKey, Principal, QueueSequence, Receipt } from "../core/Receipt.mjs";
+import { Update } from "../core/AgentUpdates.mjs";
+import { p as WorkerUpdate } from "../Worker-T_3RbaKc.mjs";
+import { DefinitionDigests, Digest } from "./Records.mjs";
+import { Settlement } from "./SubmissionLedger.mjs";
+import { digestJson } from "./Digest.mjs";
+import { MessageDeliveryStore, messageDeliveryCapacity, prepareMessageDelivery, readPending } from "./MessageDelivery.mjs";
+import { DateTime, Effect, Equal, Result, Schema } from "effect";
+//#region src/durable/MessageDeliveryStoreConformance.ts
+var MessageDeliveryConformanceViolation = class extends Schema.TaggedError()("MessageDeliveryConformanceViolation", { message: Schema.String }) {};
+const verify = (condition, message) => condition ? Effect.void : Effect.fail(MessageDeliveryConformanceViolation.make({ message }));
+/** One valid frozen envelope shared by real storage and restart tests. */
+const makeMessageDeliveryFixture = Effect.fn("MessageDeliveryConformance.fixture")(function* (messageId = "message", owner = "sender", text = "hello") {
+	const digest = Schema.decodeSync(Digest)("a".repeat(64));
+	const input = { text };
+	return yield* prepareMessageDelivery({
+		key: {
+			ownerThreadId: Schema.decodeSync(ThreadId)(owner),
+			messageId: Schema.decodeSync(IdempotencyKey)(messageId)
+		},
+		createdAtMillis: 0,
+		deadlineAtMillis: 1e3,
+		policy: {
+			maxAutomaticAttempts: 3,
+			attemptTimeoutMillis: 100,
+			retryBaseMillis: 10,
+			retryMaxMillis: 20,
+			settlementPollMillis: 5
+		},
+		envelope: {
+			schemaVersion: 1,
+			threadId: Schema.decodeSync(ThreadId)("receiver"),
+			deliveryPrincipal: Schema.decodeSync(Principal)("principal"),
+			agentId: Schema.decodeSync(AgentId)("agent"),
+			definitions: DefinitionDigests.make({
+				agent: digest,
+				model: digest,
+				tools: digest
+			}),
+			input,
+			inputDigest: yield* digestJson(input),
+			admissionKey: Schema.decodeSync(IdempotencyKey)(`admit:${owner}:${messageId}`),
+			authorization: {
+				policyId: "policy",
+				decisionId: "decision"
+			}
+		}
+	});
+});
+const messageDeliveryFixtureReceipt = Receipt.make({
+	threadId: Schema.decodeSync(ThreadId)("receiver"),
+	receiptId: Schema.decodeSync(ReceiptId)("receipt"),
+	submissionId: Schema.decodeSync(SubmissionId)("submission"),
+	queueSequence: Schema.decodeSync(QueueSequence)(0)
+});
+const makeWorkerUpdateDeliveryFixture = Effect.fn("MessageDeliveryConformance.updateFixture")(function* (id) {
+	const base = yield* makeMessageDeliveryFixture(id);
+	return yield* prepareMessageDelivery({
+		key: base.key,
+		createdAtMillis: base.createdAtMillis,
+		deadlineAtMillis: base.deadlineAtMillis,
+		policy: base.policy,
+		envelope: {
+			...base.envelope,
+			messageAdmission: WorkerUpdate.make({
+				_tag: "WorkerUpdate",
+				schemaVersion: 1,
+				worker: {
+					schemaVersion: 1,
+					delegationId: Schema.decodeSync(DelegationId)("worker"),
+					targetAgentId: Schema.decodeSync(AgentId)("child"),
+					threadId: base.key.ownerThreadId
+				},
+				update: Update.make({
+					schemaVersion: 1,
+					agentId: Schema.decodeSync(AgentId)("child"),
+					threadId: base.key.ownerThreadId,
+					runId: Schema.decodeSync(RunId)("run"),
+					updateId: base.key.messageId,
+					sequence: 1,
+					value: { finding: id }
+				})
+			})
+		}
+	});
+});
+/** Every case starts with an empty store; all clocks and expected values are explicit. */
+const messageDeliveryStoreConformanceCases = [
+	{
+		name: "reserves ordinary delivery capacity when worker updates saturate their separate bound",
+		run: Effect.gen(function* () {
+			const store = yield* MessageDeliveryStore;
+			const capacity = messageDeliveryCapacity(store.limits, true);
+			for (let index = 0; index < capacity.pending; index++) yield* store.insert(yield* makeWorkerUpdateDeliveryFixture(`update-${index}`));
+			const refused = yield* store.insert(yield* makeWorkerUpdateDeliveryFixture("overflow")).pipe(Effect.result);
+			yield* verify(Result.isFailure(refused) && refused.failure._tag === "MessageDeliveryError" && refused.failure.reason === "capacity", "Updates must stop at their independent pending bound");
+			const terminal = yield* makeMessageDeliveryFixture("terminal");
+			yield* verify((yield* store.insert(terminal)).status === "pending", "Update pressure must preserve ordinary terminal capacity");
+			yield* verify((yield* store.get({
+				...terminal.key,
+				messageId: Schema.decodeSync(IdempotencyKey)("overflow")
+			})) === null, "Rejected update must not mutate delivery storage");
+		})
+	},
+	{
+		name: "retains predecessor identity and defers ordering waits without spending attempts",
+		run: Effect.gen(function* () {
+			const store = yield* MessageDeliveryStore;
+			const initial = {
+				...yield* makeMessageDeliveryFixture("later"),
+				predecessor: Schema.decodeSync(IdempotencyKey)("earlier")
+			};
+			yield* store.insert(initial);
+			const deferred = yield* store.change(initial.key, {
+				_tag: "Defer",
+				expectedVersion: 1,
+				nowMillis: 0,
+				untilMillis: 100
+			});
+			yield* verify(deferred.retry.attempts === 0 && deferred.retry.automaticAttempts === 0 && deferred.retry.nextAttemptAtMillis === 100, "Ordering waits must remain bounded without exhausting transport retries");
+			yield* verify((yield* store.due(99, 10)).length === 0 && (yield* store.due(100, 10)).length === 1, "Deferral must advance the persisted wake deadline");
+			yield* verify(Equal.equals(yield* readPending({
+				ownerThreadId: initial.key.ownerThreadId,
+				limit: 1
+			}), [deferred]), "Future-due retained work must remain visible before any canonical reservation");
+			const changed = yield* store.insert({
+				...initial,
+				predecessor: Schema.decodeSync(IdempotencyKey)("different")
+			}).pipe(Effect.result);
+			yield* verify(Result.isFailure(changed) && changed.failure._tag === "MessageDeliveryError" && changed.failure.reason === "conflict", "A retry cannot replace its ordering predecessor");
+		})
+	},
+	{
+		name: "retains pending, accepted and processed facts with stable duplicate admission",
+		run: Effect.gen(function* () {
+			const store = yield* MessageDeliveryStore;
+			const initial = yield* makeMessageDeliveryFixture();
+			yield* store.insert(initial);
+			yield* verify(Equal.equals(yield* store.due(0, 10), [initial.key]), "Pending work must be independently discoverable");
+			const claim = yield* store.change(initial.key, {
+				_tag: "Claim",
+				nowMillis: 0,
+				expectedVersion: 1
+			});
+			const accepted = yield* store.change(initial.key, {
+				_tag: "Accept",
+				nowMillis: 1,
+				expectedVersion: claim.version,
+				receipt: messageDeliveryFixtureReceipt
+			});
+			yield* verify(accepted.status === "accepted" && accepted.settlement === null, "Acceptance must not claim processing");
+			yield* verify(Equal.equals(yield* readPending({
+				ownerThreadId: initial.key.ownerThreadId,
+				limit: 1
+			}), [accepted]), "Accepted work must retain its exact receipt and envelope in the pending read");
+			const secondClaim = yield* store.change(initial.key, {
+				_tag: "Claim",
+				nowMillis: 6,
+				expectedVersion: accepted.version
+			});
+			const settlement = Settlement.make({
+				receiptId: messageDeliveryFixtureReceipt.receiptId,
+				submissionId: messageDeliveryFixtureReceipt.submissionId,
+				settlementId: Schema.decodeSync(SettlementId)("settlement"),
+				outcome: "completed",
+				settledAt: DateTime.makeUnsafe(7)
+			});
+			const processed = yield* store.change(initial.key, {
+				_tag: "Process",
+				nowMillis: 7,
+				expectedVersion: secondClaim.version,
+				settlement
+			});
+			yield* verify(processed.status === "processed", "Canonical settlement must finish processing");
+			yield* verify(Equal.equals(yield* store.insert(initial), processed), "Replay must preserve terminal evidence");
+			yield* verify((yield* store.nextDeadline()) === null, "Processed work must release its wake deadline");
+			yield* verify((yield* readPending({
+				ownerThreadId: initial.key.ownerThreadId,
+				limit: 1
+			})).length === 0, "Processed history must not enter pending authorization reads");
+		})
+	},
+	{
+		name: "rejects conflicting identity and scopes cursors and discovery to the source owner",
+		run: Effect.gen(function* () {
+			const store = yield* MessageDeliveryStore;
+			const a = yield* makeMessageDeliveryFixture("a");
+			const b = yield* makeMessageDeliveryFixture("b");
+			const other = yield* makeMessageDeliveryFixture("a", "other");
+			yield* store.insert(a);
+			yield* store.insert(b);
+			yield* store.insert(other);
+			const conflict = yield* store.insert(yield* makeMessageDeliveryFixture("a", "sender", "changed")).pipe(Effect.result);
+			yield* verify(Result.isFailure(conflict) && conflict.failure._tag === "MessageDeliveryError" && conflict.failure.reason === "conflict", "Conflicting replay must be refused");
+			yield* verify(Equal.equals(yield* store.get(a.key), a), "Refusal must preserve original input");
+			const overflow = yield* readPending({
+				ownerThreadId: a.key.ownerThreadId,
+				limit: 1
+			}).pipe(Effect.result);
+			yield* verify(Result.isFailure(overflow) && overflow.failure.reason === "capacity", "Overflow must fail without a partial inventory");
+			yield* verify(Equal.equals(yield* readPending({
+				ownerThreadId: other.key.ownerThreadId,
+				limit: 1
+			}), [other]), "Pending reads must use the source owner");
+			const page = yield* store.list({
+				ownerThreadId: a.key.ownerThreadId,
+				limit: 1,
+				pendingOnly: true
+			});
+			yield* verify(page.items.length === 1 && page.items[0]?.key.messageId === "a" && page.next === "a", "First page must remain owner scoped");
+			const next = yield* store.list({
+				ownerThreadId: a.key.ownerThreadId,
+				limit: 1,
+				after: a.key.messageId,
+				pendingOnly: true
+			});
+			yield* verify(next.items.length === 1 && next.items[0]?.key.messageId === "b" && next.next === null, "Cursor must be stable");
+			yield* verify(Equal.equals(yield* store.due(0, 10, other.key.ownerThreadId), [other.key]), "Owner-scoped scans must not expose another source");
+		})
+	},
+	{
+		name: "fences stale completion and preserves parked work for explicit recovery",
+		run: Effect.gen(function* () {
+			const store = yield* MessageDeliveryStore;
+			const initial = yield* makeMessageDeliveryFixture();
+			yield* store.insert(initial);
+			const old = yield* store.change(initial.key, {
+				_tag: "Claim",
+				nowMillis: 0,
+				expectedVersion: 1
+			});
+			const current = yield* store.change(initial.key, {
+				_tag: "Claim",
+				nowMillis: 101,
+				expectedVersion: old.version
+			});
+			const stale = yield* store.change(initial.key, {
+				_tag: "Accept",
+				nowMillis: 102,
+				expectedVersion: old.version,
+				receipt: messageDeliveryFixtureReceipt
+			}).pipe(Effect.result);
+			yield* verify(Result.isFailure(stale) && stale.failure._tag === "MessageDeliveryError" && stale.failure.reason === "conflict", "Old claims cannot commit");
+			const parked = yield* store.change(initial.key, {
+				_tag: "Park",
+				nowMillis: 102,
+				expectedVersion: current.version,
+				reason: "exhausted"
+			});
+			yield* verify((yield* store.nextDeadline()) === null && parked.status === "parked", "Parked work must remain inspectable without busy polling");
+			yield* verify(Equal.equals(yield* readPending({
+				ownerThreadId: initial.key.ownerThreadId,
+				limit: 1
+			}), [parked]), "Parked uncertainty must remain visible without a wake deadline");
+			const recovered = yield* store.change(initial.key, {
+				_tag: "Recover",
+				nowMillis: 103,
+				expectedVersion: parked.version,
+				deadlineAtMillis: 2e3
+			});
+			yield* verify(recovered.retry.generation === 1 && Equal.equals(recovered.envelope, initial.envelope), "Explicit retry must preserve the frozen envelope");
+			yield* verify((yield* store.nextDeadline()) === 103, "Recovered work must be discoverable");
+		})
+	}
+];
+//#endregion
+export { MessageDeliveryConformanceViolation, makeMessageDeliveryFixture, makeWorkerUpdateDeliveryFixture, messageDeliveryFixtureReceipt, messageDeliveryStoreConformanceCases };
+
+//# sourceMappingURL=MessageDeliveryStoreConformance.mjs.map