@takboo/dsh-session-bin 0.0.0-stage → 0.1.1

package/dist/client-model.js

@@ -0,0 +1,1673 @@
+// src/operations/schema.ts
+import { z } from "zod";
+var identity = z.string().min(1).max(1024);
+var actionSchema = z.enum(["bin", "restore"]);
+var blockerSchema = z.object({
+  code: z.string().min(1),
+  activity: z.array(z.string()).optional()
+}).strict();
+var entrySchema = z.object({
+  schemaVersion: z.literal(1),
+  sessionId: identity,
+  entryId: z.uuid(),
+  operationId: identity,
+  binnedAt: z.iso.datetime(),
+  workspaceIdAtBin: identity.nullable(),
+  wasArchived: z.boolean()
+}).strict();
+var planSchema = z.object({
+  schemaVersion: z.literal(1),
+  operationId: identity,
+  action: actionSchema,
+  sessionId: identity,
+  expected: z.object({ archived: z.boolean(), entryId: z.uuid().nullable() }).strict(),
+  blockers: z.array(blockerSchema)
+}).strict();
+var resultSchema = z.object({
+  operationId: identity,
+  action: actionSchema,
+  sessionId: identity,
+  status: z.enum(["success", "rejected", "conflict"]),
+  reason: z.string().min(1).nullable(),
+  entryId: z.uuid().nullable()
+}).strict();
+var operationSchema = z.object({
+  schemaVersion: z.literal(1),
+  plan: planSchema,
+  createdAt: z.iso.datetime(),
+  phase: z.enum(["intent", "applied", "done"]),
+  ownershipInvalidated: z.boolean(),
+  entry: entrySchema.nullable(),
+  result: resultSchema.nullable()
+}).strict().superRefine((operation, ctx) => {
+  const { plan, entry, result, phase } = operation;
+  if (phase === "done" !== (result !== null)) {
+    ctx.addIssue({ code: "custom", message: "Only a done operation has a result." });
+  }
+  if (phase !== "done" && entry === null) {
+    ctx.addIssue({ code: "custom", message: "An unfinished operation requires its entry snapshot." });
+  }
+  if (entry && (entry.sessionId !== plan.sessionId || plan.action === "bin" && (entry.operationId !== plan.operationId || entry.wasArchived !== plan.expected.archived) || plan.action === "restore" && entry.entryId !== plan.expected.entryId)) {
+    ctx.addIssue({ code: "custom", message: "Entry snapshot does not match the operation." });
+  }
+  if (result && (result.status === "success" !== (result.reason === null) || result.entryId !== (entry?.entryId ?? null) || result.status === "success" && !entry)) {
+    ctx.addIssue({ code: "custom", message: "Result outcome or entry snapshot is inconsistent." });
+  }
+  if (operation.ownershipInvalidated && !entry) {
+    ctx.addIssue({ code: "custom", message: "Ownership invalidation requires an entry identity." });
+  }
+  if (result && (result.operationId !== plan.operationId || result.sessionId !== plan.sessionId || result.action !== plan.action)) {
+    ctx.addIssue({ code: "custom", message: "Result does not match the operation." });
+  }
+});
+var prepareRequestSchema = z.object({
+  action: actionSchema,
+  sessionId: identity,
+  operationId: identity.optional()
+}).strict();
+
+// src/operations/archive.ts
+import { z as z2 } from "zod";
+var identity2 = z2.string().min(1).max(1024);
+var archiveEntrySchema = z2.object({
+  schemaVersion: z2.literal(2),
+  sessionId: identity2,
+  entryId: z2.uuid()
+}).strict();
+var archivePlanSchema = z2.object({
+  schemaVersion: z2.literal(2),
+  operationId: identity2,
+  action: z2.literal("unarchive"),
+  sessionId: identity2,
+  expected: z2.object({ archived: z2.boolean(), entryId: z2.uuid().nullable() }).strict(),
+  blockers: z2.array(blockerSchema)
+}).strict();
+var archiveResultSchema = z2.object({
+  operationId: identity2,
+  action: z2.literal("unarchive"),
+  sessionId: identity2,
+  status: z2.enum(["success", "rejected", "conflict"]),
+  reason: z2.string().min(1).nullable(),
+  entryId: z2.uuid().nullable()
+}).strict();
+var archiveOperationSchema = z2.object({
+  schemaVersion: z2.literal(2),
+  plan: archivePlanSchema,
+  createdAt: z2.iso.datetime(),
+  phase: z2.enum(["intent", "applied", "done"]),
+  entry: archiveEntrySchema.nullable(),
+  result: archiveResultSchema.nullable()
+}).strict().superRefine(({ plan, entry, result, phase }, ctx) => {
+  if (phase === "done" !== (result !== null) || phase !== "done" && (entry === null || !plan.expected.archived)) {
+    ctx.addIssue({ code: "custom", message: "Only done operations have results; unfinished operations require an entry." });
+  }
+  if (entry && (entry.sessionId !== plan.sessionId || entry.entryId !== plan.expected.entryId)) {
+    ctx.addIssue({ code: "custom", message: "Entry snapshot does not match the plan." });
+  }
+  if (result && (result.operationId !== plan.operationId || result.sessionId !== plan.sessionId || result.action !== plan.action || result.entryId !== (entry?.entryId ?? null) || result.status === "success" !== (result.reason === null) || result.status === "success" && !entry)) {
+    ctx.addIssue({ code: "custom", message: "Result does not match the operation." });
+  }
+});
+var archivePrepareRequestSchema = z2.object({
+  action: z2.literal("unarchive"),
+  sessionId: identity2,
+  operationId: identity2.optional()
+}).strict();
+
+// src/remote/contracts.ts
+import { z as z4 } from "zod";
+
+// src/operations/retirement.ts
+import { z as z3 } from "zod";
+var key = z3.string().min(1).max(1024);
+var lifecycleKeySchema = z3.object({ storeId: key, sessionId: key, lifecycleId: key }).strict();
+var retirementParticipantSchema = z3.object({ id: key, version: key }).strict();
+var retirementCapabilitiesSchema = z3.object({
+  protocolVersion: z3.literal(1),
+  ownerId: key,
+  hostVersion: key,
+  providerId: key,
+  storeId: key,
+  participants: z3.array(retirementParticipantSchema).min(1).max(64)
+}).strict().superRefine((value2, ctx) => {
+  if (new Set(value2.participants.map((item) => item.id)).size !== value2.participants.length) {
+    ctx.addIssue({ code: "custom", message: "Participant identities must be unique." });
+  }
+});
+var legacyRetirementBindingSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  entryId: z3.uuid(),
+  entryVersion: z3.literal(1),
+  lifecycle: lifecycleKeySchema,
+  capabilities: retirementCapabilitiesSchema
+}).strict();
+var nativeRetirementBindingSchema = z3.object({
+  schemaVersion: z3.literal(2),
+  target: z3.literal("native-archive"),
+  entryId: z3.uuid(),
+  entryVersion: z3.literal(2),
+  lifecycle: lifecycleKeySchema,
+  capabilities: retirementCapabilitiesSchema
+}).strict();
+var retirementBindingSchema = z3.union([legacyRetirementBindingSchema, nativeRetirementBindingSchema]).superRefine((value2, ctx) => {
+  if (value2.lifecycle.storeId !== value2.capabilities.storeId) {
+    ctx.addIssue({ code: "custom", message: "Binding store differs from its owner." });
+  }
+});
+var retirementResourceSchema = z3.object({
+  ownerId: key,
+  resourceId: key,
+  revision: key,
+  kind: z3.enum(["transcript", "workspace", "index", "cache", "attachment", "spill", "coordination"]),
+  disposition: z3.enum(["erase", "release-reference", "retain-shared", "retain-coordination"]),
+  retention: z3.object({
+    reason: z3.enum(["shared-reference", "coordination-identity"]),
+    retainedBy: z3.array(lifecycleKeySchema).max(4096)
+  }).strict().nullable()
+}).strict();
+var retirementManifestSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  lifecycle: lifecycleKeySchema,
+  capabilities: retirementCapabilitiesSchema,
+  resources: z3.array(retirementResourceSchema).min(1).max(4096)
+}).strict().superRefine((value2, ctx) => {
+  const owners = new Set(value2.capabilities.participants.map((item) => item.id));
+  const resourceKeys = value2.resources.map((item) => JSON.stringify([item.ownerId, item.resourceId]));
+  if (new Set(resourceKeys).size !== resourceKeys.length || value2.resources.some((item) => !owners.has(item.ownerId))) {
+    ctx.addIssue({ code: "custom", message: "Resources require unique keys and declared owners." });
+  }
+  if (value2.lifecycle.storeId !== value2.capabilities.storeId || !value2.resources.some((item) => item.kind === "transcript" && item.disposition === "erase")) {
+    ctx.addIssue({ code: "custom", message: "Manifest must identify its store and erase the target transcript." });
+  }
+  for (const resource of value2.resources) {
+    if (resource.kind === "coordination" && resource.disposition !== "retain-coordination") {
+      ctx.addIssue({ code: "custom", message: "Stable coordination identity must be retained." });
+    }
+    const retained = resource.retention;
+    if (resource.disposition === "retain-shared") {
+      if (!retained || retained.reason !== "shared-reference" || !retained.retainedBy.length || retained.retainedBy.some((key2) => lifecycleEqual(key2, value2.lifecycle)) || new Set(retained.retainedBy.map((key2) => JSON.stringify([key2.storeId, key2.sessionId, key2.lifecycleId]))).size !== retained.retainedBy.length) {
+        ctx.addIssue({ code: "custom", message: "Shared retention requires distinct surviving lifecycle witnesses." });
+      }
+    } else if (resource.disposition === "retain-coordination") {
+      if (resource.kind !== "coordination" || !retained || retained.reason !== "coordination-identity" || retained.retainedBy.length) {
+        ctx.addIssue({ code: "custom", message: "Coordination retention must state its identity purpose." });
+      }
+    } else if (retained !== null) {
+      ctx.addIssue({ code: "custom", message: "Erasure/reference release does not retain this resource." });
+    }
+  }
+});
+var retirementRequestSchema = z3.object({
+  operationId: key,
+  expected: lifecycleKeySchema,
+  bin: z3.union([
+    z3.object({ entryId: z3.uuid(), entryVersion: z3.literal(1) }).strict(),
+    z3.object({ kind: z3.literal("native-archive"), entryId: z3.uuid(), entryVersion: z3.literal(2) }).strict()
+  ]),
+  manifestDigest: z3.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var retirementResourceReceiptSchema = z3.object({
+  ownerId: key,
+  resourceId: key,
+  status: z3.enum(["erased", "reference-released", "retained", "failed"]),
+  reason: key.nullable()
+}).strict().superRefine((value2, ctx) => {
+  if ((value2.status === "failed" || value2.status === "retained") !== (value2.reason !== null)) {
+    ctx.addIssue({ code: "custom", message: "Failure and retention require a reason; erased/released resources do not." });
+  }
+});
+var retirementAuthorizationSchema = z3.discriminatedUnion("authorized", [
+  z3.object({ authorized: z3.literal(true), authorizationId: z3.uuid() }).strict(),
+  z3.object({ authorized: z3.literal(false), reason: key }).strict()
+]);
+var retirementStateSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  request: retirementRequestSchema,
+  manifest: retirementManifestSchema,
+  authorizationId: z3.uuid().nullable(),
+  phase: z3.enum(["rejected", "conflict", "fenced", "quiesced", "erasing", "converging", "done"]),
+  reason: key.nullable(),
+  resources: z3.array(retirementResourceReceiptSchema).max(4096)
+}).strict().superRefine((value2, ctx) => {
+  if (!lifecycleEqual(value2.request.expected, value2.manifest.lifecycle)) {
+    ctx.addIssue({ code: "custom", message: "Owner state changed the requested lifecycle." });
+  }
+  const refused = value2.phase === "rejected" || value2.phase === "conflict";
+  if (refused !== (value2.authorizationId === null)) {
+    ctx.addIssue({ code: "custom", message: "Admitted owner state requires its handed-off authorization grant." });
+  }
+  if (refused !== (value2.reason !== null)) {
+    ctx.addIssue({ code: "custom", message: "Admission refusal requires a reason." });
+  }
+  const keys = value2.resources.map((item) => JSON.stringify([item.ownerId, item.resourceId]));
+  if (new Set(keys).size !== keys.length) ctx.addIssue({ code: "custom", message: "Duplicate resource receipts." });
+  for (const receipt of value2.resources) {
+    const resource = value2.manifest.resources.find((item) => item.ownerId === receipt.ownerId && item.resourceId === receipt.resourceId);
+    if (!resource) ctx.addIssue({ code: "custom", message: "Receipt is outside the frozen manifest." });
+    if (resource && receipt.status !== "failed") {
+      const expected = resource.disposition === "erase" ? "erased" : resource.disposition === "release-reference" ? "reference-released" : "retained";
+      if (receipt.status !== expected || receipt.status === "retained" && receipt.reason !== resource.retention?.reason) {
+        ctx.addIssue({ code: "custom", message: "Resource acknowledgement did not satisfy its frozen disposition and retention reason." });
+      }
+    }
+  }
+  if (value2.phase === "done" && (value2.resources.length !== value2.manifest.resources.length || value2.resources.some((receipt) => receipt.status === "failed"))) {
+    ctx.addIssue({ code: "custom", message: "Completion requires every resource receipt without failures." });
+  }
+  if (["rejected", "conflict", "fenced", "quiesced"].includes(value2.phase) && value2.resources.length) {
+    ctx.addIssue({ code: "custom", message: "Admission and quiescence phases cannot include resource erasure effects." });
+  }
+});
+var preparePurgeRequestSchema = z3.object({ sessionId: key, operationId: key.optional() }).strict();
+var purgePlanSchema = z3.object({
+  schemaVersion: z3.union([z3.literal(1), z3.literal(2)]),
+  action: z3.literal("purge"),
+  operationId: key,
+  sessionId: key,
+  expectedEntryId: z3.uuid().nullable(),
+  binding: retirementBindingSchema.nullable(),
+  manifest: retirementManifestSchema.nullable(),
+  blockers: z3.array(blockerSchema)
+}).strict().superRefine((value2, ctx) => {
+  if (value2.binding && value2.binding.schemaVersion !== value2.schemaVersion) {
+    ctx.addIssue({ code: "custom", message: "Legacy Bin and native archive deletion bindings cannot be interchanged." });
+  }
+  if (value2.binding && (value2.binding.entryId !== value2.expectedEntryId || value2.binding.lifecycle.sessionId !== value2.sessionId)) {
+    ctx.addIssue({ code: "custom", message: "Purge binding differs from its target entry." });
+  }
+  if (value2.manifest && (!value2.binding || !lifecycleEqual(value2.binding.lifecycle, value2.manifest.lifecycle))) {
+    ctx.addIssue({ code: "custom", message: "Purge manifest differs from its bound lifecycle." });
+  }
+});
+var purgeResultSchema = z3.object({
+  action: z3.literal("purge"),
+  operationId: key,
+  sessionId: key,
+  entryId: z3.uuid().nullable(),
+  status: z3.enum(["success", "rejected", "conflict", "pending-recovery", "partial-failure"]),
+  reason: key.nullable(),
+  ownerState: retirementStateSchema.nullable()
+}).strict().superRefine((value2, ctx) => {
+  if (value2.status === "success" !== (value2.reason === null) || value2.status === "success" && value2.ownerState?.phase !== "done") {
+    ctx.addIssue({ code: "custom", message: "Success requires a complete owner receipt." });
+  }
+  if (value2.ownerState && (value2.ownerState.request.operationId !== value2.operationId || value2.ownerState.request.expected.sessionId !== value2.sessionId || value2.ownerState.request.bin.entryId !== value2.entryId)) {
+    ctx.addIssue({ code: "custom", message: "Purge result differs from its owner receipt." });
+  }
+});
+var purgeOperationSchema = z3.object({
+  schemaVersion: z3.union([z3.literal(1), z3.literal(2)]),
+  plan: purgePlanSchema,
+  createdAt: z3.iso.datetime(),
+  phase: z3.enum(["intent", "authorizing", "owner-pending", "done"]),
+  entry: z3.union([entrySchema, archiveEntrySchema]).nullable(),
+  authorizationId: z3.uuid().nullable(),
+  ownerState: retirementStateSchema.nullable(),
+  result: purgeResultSchema.nullable()
+}).strict().superRefine((value2, ctx) => {
+  const { plan, entry, result, ownerState } = value2;
+  if (value2.schemaVersion !== plan.schemaVersion || entry && entry.schemaVersion !== plan.schemaVersion || ownerState && ownerState.request.bin.entryVersion !== plan.schemaVersion) {
+    ctx.addIssue({ code: "custom", message: "Deletion journal target versions must agree." });
+  }
+  if (entry && (entry.entryId !== plan.expectedEntryId || entry.sessionId !== plan.sessionId)) {
+    ctx.addIssue({ code: "custom", message: "Purge journal entry differs from the plan." });
+  }
+  if (value2.phase !== "done" && (!entry || !plan.binding || !plan.manifest)) {
+    ctx.addIssue({ code: "custom", message: "Unfinished purge requires an entry, binding and manifest." });
+  }
+  const terminalResult = result && ["success", "rejected", "conflict"].includes(result.status);
+  if (value2.phase === "done" !== Boolean(terminalResult) || ["intent", "authorizing"].includes(value2.phase) && (ownerState !== null || result !== null) || value2.phase === "intent" && value2.authorizationId !== null || value2.phase === "authorizing" && value2.authorizationId === null || ownerState && ownerState.authorizationId !== null && ownerState.authorizationId !== value2.authorizationId || value2.phase === "owner-pending" && (ownerState === null || result === null)) {
+    ctx.addIssue({ code: "custom", message: "Purge journal phase and receipt are inconsistent." });
+  }
+  if (result && (result.operationId !== plan.operationId || result.sessionId !== plan.sessionId || result.entryId !== (entry?.entryId ?? null) || JSON.stringify(result.ownerState) !== JSON.stringify(ownerState))) {
+    ctx.addIssue({ code: "custom", message: "Purge journal result differs from its saved state." });
+  }
+});
+function lifecycleEqual(a, b) {
+  return a.storeId === b.storeId && a.sessionId === b.sessionId && a.lifecycleId === b.lifecycleId;
+}
+
+// src/remote/contracts.ts
+var sessionBinRemoteNamespace = "sessionBin";
+var sessionBinRemoteServiceKey = "sessionBinRemote";
+var snapshotSchema = z4.object({ schemaVersion: z4.literal(2), entries: z4.array(archiveEntrySchema) }).strict();
+var operationIdSchema = z4.string().min(1).max(1024);
+var entriesSchema = z4.array(archiveEntrySchema);
+var optionalOperationSchema = z4.union([archiveOperationSchema, operationSchema]).nullable();
+var nativePurgePlanSchema = purgePlanSchema.refine((plan) => plan.schemaVersion === 2, "Only native archive v2 deletion plans may be executed remotely.");
+var optionalPurgeOperationSchema = purgeOperationSchema.nullable();
+var purgeOperationsSchema = z4.array(purgeOperationSchema);
+function strictCodec(name, schema) {
+  return {
+    mode: "strict",
+    typeSymbol: `@takboo/dsh-session-bin#${name}`,
+    create: () => schema,
+    encode: (value2) => schema.parse(value2),
+    decode: (value2) => schema.parse(value2)
+  };
+}
+var codecs = {
+  request: strictCodec("ArchivePrepareRequest", archivePrepareRequestSchema),
+  plan: strictCodec("ArchivePlan", archivePlanSchema),
+  result: strictCodec("ArchiveResult", archiveResultSchema),
+  entries: strictCodec("ArchiveEntries", entriesSchema),
+  operationId: strictCodec("OperationId", operationIdSchema),
+  operation: strictCodec("OptionalArchiveOperation", optionalOperationSchema),
+  purgeRequest: strictCodec("PreparePurgeRequest", preparePurgeRequestSchema),
+  purgePlan: strictCodec("NativePurgePlan", nativePurgePlanSchema),
+  purgeResult: strictCodec("PurgeResult", purgeResultSchema),
+  purgeOperation: strictCodec("OptionalPurgeOperation", optionalPurgeOperationSchema),
+  purgeOperations: strictCodec("PurgeOperations", purgeOperationsSchema),
+  snapshot: strictCodec("ArchiveSnapshot", snapshotSchema)
+};
+function descriptor(method, parameters, result, mode) {
+  return {
+    id: `@takboo/dsh-session-bin#sessionBin/${method}`,
+    service: sessionBinRemoteServiceKey,
+    namespace: sessionBinRemoteNamespace,
+    method,
+    invocation: { kind: "direct" },
+    parameters,
+    result,
+    cancellation: { parameter: "signal" },
+    ...mode === void 0 ? {} : { mode }
+  };
+}
+var descriptors = [
+  descriptor("prepare", [{ name: "request", wire: "request", source: "json", codec: codecs.request }], codecs.plan),
+  descriptor("execute", [{ name: "plan", wire: "plan", source: "json", codec: codecs.plan }], codecs.result),
+  descriptor("list", [], codecs.entries),
+  descriptor("getOperation", [{ name: "operationId", wire: "operationId", source: "json", codec: codecs.operationId }], codecs.operation),
+  descriptor("preparePurge", [{ name: "request", wire: "request", source: "json", codec: codecs.purgeRequest }], codecs.purgePlan),
+  descriptor("executePurge", [{ name: "plan", wire: "plan", source: "json", codec: codecs.purgePlan }], codecs.purgeResult),
+  descriptor("getPurgeOperation", [{ name: "operationId", wire: "operationId", source: "json", codec: codecs.operationId }], codecs.purgeOperation),
+  descriptor("purgeOperations", [], codecs.purgeOperations),
+  descriptor("follow", [], codecs.snapshot, "stream")
+];
+
+// src/client/retirement-digest.ts
+var SHA256_CONSTANTS = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function canonical(value2) {
+  if (Array.isArray(value2)) return `[${value2.map(canonical).join(",")}]`;
+  if (value2 && typeof value2 === "object") {
+    return `{${Object.keys(value2).sort().map((key2) => `${JSON.stringify(key2)}:${canonical(value2[key2])}`).join(",")}}`;
+  }
+  return JSON.stringify(value2);
+}
+function rotateRight(value2, count) {
+  return value2 >>> count | value2 << 32 - count;
+}
+function sha256(input) {
+  const bytes = new TextEncoder().encode(input);
+  const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.length] = 128;
+  const view = new DataView(padded.buffer);
+  const bitLength = bytes.length * 8;
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+  const hash = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) words[index] = view.getUint32(offset + index * 4);
+    for (let index = 16; index < 64; index += 1) {
+      const first = words[index - 15];
+      const second = words[index - 2];
+      const sigma0 = rotateRight(first, 7) ^ rotateRight(first, 18) ^ first >>> 3;
+      const sigma1 = rotateRight(second, 17) ^ rotateRight(second, 19) ^ second >>> 10;
+      words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
+    }
+    let a = hash[0];
+    let b = hash[1];
+    let c = hash[2];
+    let d = hash[3];
+    let e = hash[4];
+    let f = hash[5];
+    let g = hash[6];
+    let h = hash[7];
+    for (let index = 0; index < 64; index += 1) {
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temporary1 = h + sum1 + choice + SHA256_CONSTANTS[index] + words[index] >>> 0;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temporary2 = sum0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temporary1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temporary1 + temporary2 >>> 0;
+    }
+    hash[0] = hash[0] + a >>> 0;
+    hash[1] = hash[1] + b >>> 0;
+    hash[2] = hash[2] + c >>> 0;
+    hash[3] = hash[3] + d >>> 0;
+    hash[4] = hash[4] + e >>> 0;
+    hash[5] = hash[5] + f >>> 0;
+    hash[6] = hash[6] + g >>> 0;
+    hash[7] = hash[7] + h >>> 0;
+  }
+  return [...hash].map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function canonicalRetirementManifest(input) {
+  const manifest = retirementManifestSchema.parse(input);
+  const capabilities = {
+    ...manifest.capabilities,
+    participants: [...manifest.capabilities.participants].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  };
+  const resources = [...manifest.resources].sort((a, b) => {
+    const first = JSON.stringify([a.ownerId, a.resourceId]);
+    const second = JSON.stringify([b.ownerId, b.resourceId]);
+    return first < second ? -1 : first > second ? 1 : 0;
+  });
+  return canonical({ ...manifest, capabilities, resources });
+}
+function retirementManifestDigest(input) {
+  return sha256(canonicalRetirementManifest(input));
+}
+
+// src/client/purge-batch.ts
+function emptyPurgeBatchResourceCounts() {
+  return { erase: 0, releaseReference: 0, retainShared: 0, retainCoordination: 0 };
+}
+function countPurgeBatchResources(items) {
+  const counts = emptyPurgeBatchResourceCounts();
+  for (const resource of items.flatMap((item) => item.plan?.manifest?.resources ?? [])) {
+    if (resource.disposition === "erase") counts.erase += 1;
+    else if (resource.disposition === "release-reference") counts.releaseReference += 1;
+    else if (resource.disposition === "retain-shared") counts.retainShared += 1;
+    else counts.retainCoordination += 1;
+  }
+  return counts;
+}
+function clonePurgeBatch(batch) {
+  return batch === null ? null : structuredClone(batch);
+}
+
+// src/client/model.ts
+function value(result) {
+  if (!result.ok) throw new Error("Session Bin Remote request failed.", { cause: result.error });
+  return result.value;
+}
+function pendingPlans(raw) {
+  if (!Array.isArray(raw)) return [];
+  const valid = [];
+  for (const item of raw.slice(0, 64)) {
+    const parsed = archivePlanSchema.safeParse(item);
+    const plan = parsed.success ? parsed.data : planSchema.safeParse(item).data;
+    if (plan && !valid.some((row) => row.operationId === plan.operationId)) valid.push(plan);
+  }
+  return valid;
+}
+function purgePlans(raw) {
+  if (!Array.isArray(raw)) return [];
+  const valid = [];
+  for (const row of raw) {
+    const parsed = nativePurgePlanSchema.safeParse(row);
+    if (parsed.success && parsed.data.binding && parsed.data.manifest && parsed.data.expectedEntryId && !valid.some((plan) => plan.operationId === parsed.data.operationId)) valid.push(parsed.data);
+  }
+  return valid;
+}
+function purgeGrantSnapshots(raw) {
+  if (!Array.isArray(raw)) return [];
+  const valid = [];
+  const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  for (const row of raw) {
+    if (!row || typeof row !== "object") continue;
+    const { operationId, authorizationId } = row;
+    if (typeof operationId === "string" && operationId.length > 0 && operationId.length <= 1024 && typeof authorizationId === "string" && uuid.test(authorizationId) && !valid.some((item) => item.operationId === operationId)) valid.push({ operationId, authorizationId });
+  }
+  return valid;
+}
+function purgeGrantObservations(raw) {
+  if (!Array.isArray(raw)) return [];
+  const valid = [];
+  for (const row of raw) {
+    if (!row || typeof row !== "object") continue;
+    const { operationId } = row;
+    if (typeof operationId === "string" && operationId.length > 0 && operationId.length <= 1024 && !valid.some((item) => item.operationId === operationId)) valid.push({ operationId });
+  }
+  return valid;
+}
+function purgeBatchOperations(raw) {
+  if (!Array.isArray(raw)) return [];
+  return [...new Set(raw.filter((operationId) => typeof operationId === "string" && operationId.length > 0 && operationId.length <= 1024))];
+}
+function purgeCacheOverflow(...values) {
+  return values.some((value2) => Array.isArray(value2) && value2.length > 64);
+}
+function canonical2(value2) {
+  if (Array.isArray(value2)) return `[${value2.map(canonical2).join(",")}]`;
+  if (value2 && typeof value2 === "object") return `{${Object.keys(value2).sort().map((key2) => `${JSON.stringify(key2)}:${canonical2(value2[key2])}`).join(",")}}`;
+  return JSON.stringify(value2);
+}
+function capabilitiesSnapshot(value2) {
+  return { ...value2, participants: [...value2.participants].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0) };
+}
+function manifestKey(value2) {
+  return canonicalRetirementManifest(value2);
+}
+function frozenPurgeKey(plan) {
+  return canonical2([
+    plan.schemaVersion,
+    plan.action,
+    plan.operationId,
+    plan.sessionId,
+    plan.expectedEntryId,
+    plan.binding ? { ...plan.binding, capabilities: capabilitiesSnapshot(plan.binding.capabilities) } : null,
+    plan.manifest ? manifestKey(plan.manifest) : null
+  ]);
+}
+var SessionBinClientModel = class {
+  constructor(api, createStream, cache) {
+    this.api = api;
+    this.createStream = createStream;
+    this.cache = cache;
+    try {
+      this.state = { ...this.state, pending: pendingPlans(cache?.load()) };
+    } catch {
+    }
+    let purgePending = [];
+    let rawPurgePlans;
+    let rawPurgeGrants;
+    let rawPurgeObservations;
+    let rawPurgeBatchOperations;
+    try {
+      rawPurgePlans = cache?.loadPurge?.();
+      purgePending = purgePlans(rawPurgePlans);
+      this.state = { ...this.state, purgePending, busy: [...new Set(purgePending.map((plan) => plan.sessionId))] };
+    } catch {
+    }
+    const pendingIds = new Set(purgePending.map((plan) => plan.operationId));
+    try {
+      rawPurgeBatchOperations = cache?.loadPurgeBatchOperations?.();
+      for (const operationId of purgeBatchOperations(rawPurgeBatchOperations)) {
+        if (pendingIds.has(operationId)) this.batchPurgeOperationIds.add(operationId);
+      }
+      this.state = { ...this.state, purgeBatchOperationIds: [...this.batchPurgeOperationIds] };
+    } catch {
+    }
+    let grantsReadable = false;
+    let observationsReadable = false;
+    try {
+      if (cache && typeof cache.loadPurgeGrants !== "function") throw new Error("Grant cache unavailable.");
+      rawPurgeGrants = cache?.loadPurgeGrants?.();
+      for (const grant of purgeGrantSnapshots(rawPurgeGrants)) {
+        if (pendingIds.has(grant.operationId)) this.observedPurgeGrants.set(grant.operationId, grant.authorizationId);
+      }
+      grantsReadable = Boolean(cache);
+    } catch {
+    }
+    const observations = /* @__PURE__ */ new Set();
+    try {
+      if (cache && typeof cache.loadPurgeGrantObservations !== "function") throw new Error("Grant observation cache unavailable.");
+      rawPurgeObservations = cache?.loadPurgeGrantObservations?.();
+      for (const observation of purgeGrantObservations(rawPurgeObservations)) {
+        if (pendingIds.has(observation.operationId)) observations.add(observation.operationId);
+      }
+      observationsReadable = Boolean(cache);
+    } catch {
+    }
+    if (cache) {
+      const canPersist = typeof cache.stagePurgeGrantObservation === "function" && typeof cache.savePurgeGrants === "function";
+      for (const operationId of pendingIds) {
+        if (!this.observedPurgeGrants.has(operationId) && (observations.has(operationId) || !grantsReadable || !observationsReadable || !canPersist)) {
+          this.uncertainPurgeGrants.add(operationId);
+        }
+      }
+    }
+    const purgeCacheBlocked = Boolean(cache?.isPurgeCacheBlocked?.()) || purgeCacheOverflow(rawPurgePlans, rawPurgeGrants, rawPurgeObservations, rawPurgeBatchOperations);
+    this.state = { ...this.state, purgeCacheBlocked };
+    this.snapshot = structuredClone(this.state);
+  }
+  state = {
+    phase: "loading",
+    entries: [],
+    busy: [],
+    pending: [],
+    results: [],
+    error: null,
+    notice: null,
+    purgeConfirmation: null,
+    purgePending: [],
+    purgeResults: [],
+    purgeBatch: null,
+    purgeBatchOperationIds: [],
+    purgeCacheBlocked: false
+  };
+  snapshot = structuredClone(this.state);
+  listeners = /* @__PURE__ */ new Set();
+  lifetime = new AbortController();
+  stream;
+  consumption = Promise.resolve();
+  epoch = 0;
+  noticeSequence = 0;
+  checking = /* @__PURE__ */ new Set();
+  purgeExecuting = /* @__PURE__ */ new Set();
+  purgeChecking = /* @__PURE__ */ new Set();
+  purgeDiscovering = false;
+  settledPurgeIds = /* @__PURE__ */ new Set();
+  observedPurgeGrants = /* @__PURE__ */ new Map();
+  uncertainPurgeGrants = /* @__PURE__ */ new Set();
+  unpersistedPurgeGrants = /* @__PURE__ */ new Set();
+  batchPurgeOperationIds = /* @__PURE__ */ new Set();
+  confirmation = null;
+  purgeBatch = null;
+  purgeBatchRun = null;
+  purgePreparationEpoch = 0;
+  getSnapshot = () => this.snapshot;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  publish(next) {
+    if (this.lifetime.signal.aborted) return;
+    this.state = { ...this.state, ...next };
+    this.snapshot = structuredClone(this.state);
+    for (const listener of this.listeners) listener();
+  }
+  persist(plans) {
+    try {
+      this.cache?.save(plans);
+    } catch {
+    }
+  }
+  pending(plans) {
+    this.persist(plans);
+    this.publish({ pending: plans });
+  }
+  async refresh() {
+    if (this.lifetime.signal.aborted) return;
+    const epoch = ++this.epoch;
+    this.publish({ phase: "loading", error: null });
+    await this.stream?.dispose();
+    if (epoch !== this.epoch || this.lifetime.signal.aborted) return;
+    const stream = this.createStream();
+    this.stream = stream;
+    this.consumption = (async () => {
+      try {
+        for await (const item of stream) {
+          if (epoch !== this.epoch || item.signal.aborted || this.lifetime.signal.aborted) continue;
+          const snapshot = snapshotSchema.parse(item.value);
+          this.publish({ entries: snapshot.entries, phase: "ready", error: null });
+          item.accept();
+          void this.checkPending(false);
+          void this.checkPurgePending();
+          void this.discoverPurgePending();
+        }
+      } catch {
+        if (epoch === this.epoch) this.publish({ phase: "error", error: "connection-failed" });
+      }
+    })();
+  }
+  async dispose() {
+    this.lifetime.abort();
+    ++this.epoch;
+    await this.stream?.dispose();
+    await this.consumption;
+    this.listeners.clear();
+  }
+  dismissNotice() {
+    this.publish({ notice: null });
+  }
+  hasActivePurgeBatch() {
+    return this.purgeBatch !== null && ["preparing", "confirming", "running", "paused"].includes(this.purgeBatch.phase);
+  }
+  isPurgeCacheBlocked() {
+    const blocked = this.state.purgeCacheBlocked || Boolean(this.cache?.isPurgeCacheBlocked?.());
+    if (blocked && !this.state.purgeCacheBlocked) this.publish({ purgeCacheBlocked: true });
+    return blocked;
+  }
+  rejectPurgeCacheCapacity() {
+    if (!this.isPurgeCacheBlocked()) return false;
+    this.publish({ error: "purge-cache-capacity", purgeCacheBlocked: true });
+    return true;
+  }
+  publishPurgeBatch() {
+    if (this.purgeBatch) this.purgeBatch.resourceCounts = countPurgeBatchResources(this.purgeBatch.items);
+    this.publish({ purgeBatch: clonePurgeBatch(this.purgeBatch) });
+  }
+  savePurgePending(plans, batchOperationId = null) {
+    const snapshots = plans.map((plan) => nativePurgePlanSchema.parse(plan));
+    const activeIds = new Set(snapshots.map((plan) => plan.operationId));
+    if (this.isPurgeCacheBlocked()) {
+      const removesGuard = this.state.purgePending.some((plan) => !activeIds.has(plan.operationId));
+      if (!removesGuard) this.publish({ purgePending: snapshots, purgeBatchOperationIds: [...this.batchPurgeOperationIds] });
+      return;
+    }
+    if (batchOperationId && activeIds.has(batchOperationId)) this.batchPurgeOperationIds.add(batchOperationId);
+    for (const operationId of this.batchPurgeOperationIds) {
+      if (!activeIds.has(operationId)) this.batchPurgeOperationIds.delete(operationId);
+    }
+    for (const operationId of this.observedPurgeGrants.keys()) {
+      if (!activeIds.has(operationId)) this.observedPurgeGrants.delete(operationId);
+    }
+    for (const operationId of this.uncertainPurgeGrants) {
+      if (!activeIds.has(operationId)) this.uncertainPurgeGrants.delete(operationId);
+    }
+    for (const operationId of this.unpersistedPurgeGrants) {
+      if (!activeIds.has(operationId)) this.unpersistedPurgeGrants.delete(operationId);
+    }
+    const batchOperationIds = [...this.batchPurgeOperationIds];
+    try {
+      this.cache?.savePurge?.(snapshots, batchOperationIds);
+    } catch {
+      if (this.cache?.isPurgeCacheBlocked?.()) this.publish({ purgeCacheBlocked: true });
+    }
+    if ([...this.observedPurgeGrants.keys()].some((operationId) => activeIds.has(operationId))) {
+      try {
+        this.persistPurgeGrants(activeIds);
+      } catch {
+        for (const operationId of this.observedPurgeGrants.keys()) {
+          if (activeIds.has(operationId)) this.unpersistedPurgeGrants.add(operationId);
+        }
+      }
+    }
+    this.publish({ purgePending: snapshots, purgeBatchOperationIds: batchOperationIds });
+  }
+  persistPurgeGrants(activeIds = new Set(this.state.purgePending.map((plan) => plan.operationId))) {
+    if (this.isPurgeCacheBlocked()) throw new Error("Deletion cache capacity exceeded.");
+    const grants = [...this.observedPurgeGrants].filter(([operationId]) => activeIds.has(operationId)).map(([operationId, authorizationId]) => ({ operationId, authorizationId }));
+    if (!this.cache) return;
+    if (typeof this.cache.savePurgeGrants !== "function") throw new Error("Grant cache unavailable.");
+    this.cache.savePurgeGrants(grants);
+  }
+  stagePurgeGrantObservation(operationId) {
+    if (this.isPurgeCacheBlocked()) throw new Error("Deletion cache capacity exceeded.");
+    if (!this.cache) return;
+    if (typeof this.cache.stagePurgeGrantObservation !== "function") {
+      this.uncertainPurgeGrants.add(operationId);
+      throw new Error("Grant observation cache unavailable.");
+    }
+    try {
+      this.cache.stagePurgeGrantObservation(operationId);
+    } catch {
+      this.uncertainPurgeGrants.add(operationId);
+      throw new Error("Grant observation could not be saved.");
+    }
+  }
+  validatePurgeOwnerState(plan, state) {
+    const manifestDigest = plan.manifest ? retirementManifestDigest(plan.manifest) : null;
+    if (!plan.binding || !plan.manifest || state.request.operationId !== plan.operationId || state.request.bin.entryVersion !== 2 || state.request.bin.entryId !== plan.expectedEntryId || !lifecycleEqual(state.request.expected, plan.binding.lifecycle) || manifestKey(state.manifest) !== manifestKey(plan.manifest) || state.request.manifestDigest !== manifestDigest) {
+      throw new Error("Deletion result changed its confirmed lifecycle or resource scope.");
+    }
+    const observed = this.observedPurgeGrants.get(plan.operationId);
+    if (observed !== void 0 && observed !== state.authorizationId) {
+      throw new Error("Deletion result changed its observed Host authorization grant.");
+    }
+    if (this.uncertainPurgeGrants.has(plan.operationId)) {
+      throw new Error("Deletion authorization continuity is uncertain.");
+    }
+    if (state.authorizationId === null) return;
+    if (observed === void 0) {
+      this.stagePurgeGrantObservation(plan.operationId);
+      this.observedPurgeGrants.set(plan.operationId, state.authorizationId);
+      this.unpersistedPurgeGrants.add(plan.operationId);
+    }
+    if (this.unpersistedPurgeGrants.has(plan.operationId)) {
+      try {
+        this.persistPurgeGrants();
+        this.unpersistedPurgeGrants.delete(plan.operationId);
+      } catch {
+        throw new Error("Deletion authorization grant could not be saved.");
+      }
+    }
+  }
+  purgeOutcome(plan, status, reason) {
+    const outcome = { operationId: plan.operationId, sessionId: plan.sessionId, entryId: plan.expectedEntryId, status, reason };
+    this.publish({ purgeResults: [outcome, ...this.state.purgeResults.filter((row) => row.operationId !== plan.operationId)].slice(0, 64) });
+    const item = this.purgeBatch?.items.find((row) => row.plan?.operationId === plan.operationId);
+    if (item) {
+      item.state = "settled";
+      item.outcome = structuredClone(outcome);
+      item.reason = reason;
+      this.publishPurgeBatch();
+    }
+    return outcome;
+  }
+  publishConfirmation() {
+    const confirmation = this.confirmation;
+    this.publish({ purgeConfirmation: confirmation ? {
+      plan: nativePurgePlanSchema.parse(confirmation.plan),
+      title: confirmation.title,
+      acknowledged: confirmation.acknowledged
+    } : null });
+  }
+  async requestPurgePlan(target) {
+    if (this.rejectPurgeCacheCapacity()) return { plan: null, reason: "purge-cache-capacity" };
+    try {
+      const plan = nativePurgePlanSchema.parse(value(await this.api.preparePurge({
+        sessionId: target.sessionId,
+        operationId: crypto.randomUUID()
+      }, this.lifetime.signal)));
+      this.lifetime.signal.throwIfAborted();
+      if (plan.sessionId !== target.sessionId || plan.expectedEntryId !== target.entryId || !this.state.entries.some((row) => row.sessionId === target.sessionId && row.entryId === target.entryId)) {
+        return { plan: null, reason: "entry-changed" };
+      }
+      return { plan: nativePurgePlanSchema.parse(plan), reason: null };
+    } catch {
+      return { plan: null, reason: "connection-failed" };
+    }
+  }
+  async preparePurge(entry, title) {
+    const target = { sessionId: entry.sessionId, entryId: entry.entryId, title };
+    if (this.rejectPurgeCacheCapacity() || this.state.phase !== "ready" || this.state.busy.includes(target.sessionId) || this.confirmation || this.hasActivePurgeBatch() || this.state.purgePending.length > 0 || this.state.pending.some((plan) => plan.schemaVersion === 2 && plan.sessionId === target.sessionId) || this.lifetime.signal.aborted) return null;
+    this.publish({ busy: [...this.state.busy, target.sessionId], error: null });
+    try {
+      const prepared = await this.requestPurgePlan(target);
+      if (!prepared.plan) {
+        this.publish({ error: prepared.reason });
+        return null;
+      }
+      this.confirmation = {
+        plan: prepared.plan,
+        title: target.title,
+        acknowledged: false,
+        batchId: null,
+        batchItemIndex: null,
+        replacesOperationId: null
+      };
+      this.publishConfirmation();
+      return nativePurgePlanSchema.parse(prepared.plan);
+    } finally {
+      this.publish({ busy: this.state.busy.filter((id) => id !== target.sessionId) });
+    }
+  }
+  acknowledgePurge(acknowledged) {
+    if (!this.confirmation) return;
+    this.confirmation = { ...this.confirmation, acknowledged };
+    this.publishConfirmation();
+  }
+  cancelPurge() {
+    this.confirmation = null;
+    this.publishConfirmation();
+  }
+  async confirmPurge() {
+    const confirmation = this.confirmation;
+    if (!confirmation?.acknowledged || confirmation.plan.blockers.length || !confirmation.plan.binding || !confirmation.plan.manifest || this.state.phase !== "ready" || this.lifetime.signal.aborted || this.rejectPurgeCacheCapacity()) return;
+    const connectionEpoch = this.epoch;
+    const plan = nativePurgePlanSchema.parse(confirmation.plan);
+    const replacedOperationId = confirmation.replacesOperationId;
+    if (replacedOperationId === null) {
+      if (this.state.purgePending.length > 0 || this.hasActivePurgeBatch()) return;
+      this.cancelPurge();
+      return this.runPurge(plan, false, connectionEpoch);
+    }
+    const previous = this.state.purgePending.find((row) => row.operationId === replacedOperationId);
+    const batch = confirmation.batchId === null ? null : this.purgeBatch;
+    const item = batch && confirmation.batchItemIndex !== null ? batch.items[confirmation.batchItemIndex] : null;
+    const associationIsCurrent = () => {
+      const current = this.state.purgePending.find((row) => row.operationId === replacedOperationId);
+      if (this.confirmation !== confirmation || !current || frozenPurgeKey(current) !== frozenPurgeKey(previous) || this.state.purgePending.some((row) => row.operationId !== replacedOperationId) || this.observedPurgeGrants.has(replacedOperationId) || this.uncertainPurgeGrants.has(replacedOperationId) || plan.sessionId !== current.sessionId || plan.expectedEntryId !== current.expectedEntryId) return false;
+      if (confirmation.batchId === null) return !this.hasActivePurgeBatch();
+      return batch !== null && batch === this.purgeBatch && batch.batchId === confirmation.batchId && (batch.phase === "paused" && !batch.stopRequested || batch.phase === "cancelled" && batch.stopRequested) && item != null && batch.items[confirmation.batchItemIndex] === item && item.state === "settled" && item.plan?.operationId === replacedOperationId && item.outcome?.operationId === replacedOperationId && item.outcome.reason === "deletion-result-missing" && item.target.sessionId === plan.sessionId && item.target.entryId === plan.expectedEntryId;
+    };
+    if (!previous || this.purgeExecuting.has(replacedOperationId) || this.purgeChecking.has(replacedOperationId) || !associationIsCurrent()) return;
+    this.purgeChecking.add(replacedOperationId);
+    try {
+      if (await this.readPurgeOperation(previous) !== null) {
+        if (associationIsCurrent()) this.publish({ error: "deletion-pending" });
+        return;
+      }
+    } catch {
+      if (associationIsCurrent()) this.publish({ error: "deletion-pending" });
+      return;
+    } finally {
+      this.purgeChecking.delete(replacedOperationId);
+    }
+    if (this.state.phase !== "ready" || this.epoch !== connectionEpoch || this.lifetime.signal.aborted || !associationIsCurrent()) return;
+    const batchOrigin = this.batchPurgeOperationIds.has(replacedOperationId) || confirmation.batchId !== null;
+    this.savePurgePending([
+      ...this.state.purgePending.filter((row) => row.operationId !== replacedOperationId),
+      plan
+    ], batchOrigin ? plan.operationId : null);
+    this.publish({ purgeResults: this.state.purgeResults.filter((row) => row.operationId !== replacedOperationId) });
+    if (item) {
+      item.plan = plan;
+      item.state = "running";
+      item.outcome = null;
+      item.reason = null;
+      this.publishPurgeBatch();
+    }
+    this.cancelPurge();
+    return this.runPurge(plan, batchOrigin, connectionEpoch);
+  }
+  async preparePurgeBatch(scope, titlesBySessionId = {}) {
+    if (this.rejectPurgeCacheCapacity() || this.state.phase !== "ready" || this.confirmation || this.hasActivePurgeBatch() || this.state.purgePending.length > 0 || this.lifetime.signal.aborted) return null;
+    const selected = scope.kind === "selection" ? new Set(scope.entryIds) : null;
+    const seen = /* @__PURE__ */ new Set();
+    const targets = this.state.entries.filter((row) => selected === null || selected.has(row.entryId)).filter((row) => {
+      const key2 = `${row.sessionId}\0${row.entryId}`;
+      if (seen.has(key2)) return false;
+      seen.add(key2);
+      return true;
+    }).map((row) => {
+      const title = titlesBySessionId[row.sessionId];
+      return { sessionId: row.sessionId, entryId: row.entryId, title: typeof title === "string" ? title : row.sessionId };
+    });
+    if (!targets.length) return null;
+    ++this.purgePreparationEpoch;
+    const batch = {
+      batchId: crypto.randomUUID(),
+      scope: scope.kind,
+      phase: "preparing",
+      frozenCount: targets.length,
+      acknowledged: false,
+      stopRequested: false,
+      items: targets.map((target) => ({ target, state: "preparing", plan: null, reason: null, outcome: null })),
+      resourceCounts: emptyPurgeBatchResourceCounts()
+    };
+    this.purgeBatch = batch;
+    this.publish({ error: null });
+    this.publishPurgeBatch();
+    for (let index = 0; index < batch.items.length; index += 1) {
+      if (batch.stopRequested || this.lifetime.signal.aborted) break;
+      const item = batch.items[index];
+      if (!item) continue;
+      if (this.state.pending.some((plan) => plan.schemaVersion === 2 && plan.sessionId === item.target.sessionId)) {
+        item.state = "blocked";
+        item.reason = "pending-result";
+        this.publishPurgeBatch();
+        continue;
+      }
+      this.publish({ busy: [.../* @__PURE__ */ new Set([...this.state.busy, item.target.sessionId])] });
+      const prepared = await this.requestPurgePlan(item.target);
+      this.publish({ busy: this.state.busy.filter((id) => id !== item.target.sessionId) });
+      if (batch !== this.purgeBatch || batch.stopRequested || this.lifetime.signal.aborted) {
+        item.state = "cancelled";
+        item.reason = null;
+        this.publishPurgeBatch();
+        break;
+      }
+      if (!prepared.plan) {
+        item.state = "blocked";
+        item.reason = prepared.reason;
+        this.publishPurgeBatch();
+        continue;
+      }
+      item.plan = prepared.plan;
+      if (prepared.plan.blockers.length || !prepared.plan.binding || !prepared.plan.manifest) {
+        item.state = "blocked";
+        item.reason = prepared.plan.blockers[0]?.code ?? "deletion-not-ready";
+      } else item.state = "ready";
+      this.publishPurgeBatch();
+    }
+    if (batch !== this.purgeBatch) return null;
+    if (batch.stopRequested || this.lifetime.signal.aborted) {
+      for (const item of batch.items) {
+        if (item.state === "preparing" || item.state === "ready") item.state = "cancelled";
+      }
+      batch.phase = "cancelled";
+    } else batch.phase = "confirming";
+    this.publishPurgeBatch();
+    return clonePurgeBatch(batch);
+  }
+  acknowledgePurgeBatch(acknowledged) {
+    if (!this.purgeBatch || this.purgeBatch.phase !== "confirming") return;
+    this.purgeBatch.acknowledged = acknowledged;
+    this.publishPurgeBatch();
+  }
+  async runPurgeBatch() {
+    if (this.purgeBatchRun) return this.purgeBatchRun;
+    const batch = this.purgeBatch;
+    if (!batch || this.state.phase !== "ready" || this.rejectPurgeCacheCapacity() || this.lifetime.signal.aborted || this.confirmation) return;
+    if (batch.phase === "confirming" && !batch.acknowledged) return;
+    if (batch.phase !== "confirming" && batch.phase !== "paused") return;
+    const terminal = (outcome) => outcome !== null && ["success", "rejected", "conflict"].includes(outcome.status);
+    if (batch.phase === "paused" && batch.items.some((item) => item.state === "settled" && !terminal(item.outcome))) return;
+    if (this.state.purgePending.length > 0) {
+      batch.phase = "paused";
+      this.publishPurgeBatch();
+      return clonePurgeBatch(batch) ?? void 0;
+    }
+    const connectionEpoch = this.epoch;
+    batch.phase = "running";
+    this.publishPurgeBatch();
+    this.purgeBatchRun = (async () => {
+      for (const item of batch.items) {
+        if (batch !== this.purgeBatch || this.lifetime.signal.aborted) break;
+        if (batch.stopRequested) break;
+        if (item.state !== "ready") continue;
+        if (this.state.phase !== "ready" || this.epoch !== connectionEpoch || this.state.purgePending.length > 0) {
+          batch.phase = "paused";
+          this.publishPurgeBatch();
+          return clonePurgeBatch(batch) ?? void 0;
+        }
+        const plan = item.plan;
+        if (!plan) {
+          item.state = "blocked";
+          item.reason = "deletion-not-ready";
+          this.publishPurgeBatch();
+          continue;
+        }
+        item.state = "running";
+        item.reason = null;
+        this.publishPurgeBatch();
+        if (batch.stopRequested || this.lifetime.signal.aborted) {
+          item.state = "cancelled";
+          break;
+        }
+        if (this.state.phase !== "ready" || this.epoch !== connectionEpoch) {
+          item.state = "ready";
+          batch.phase = "paused";
+          this.publishPurgeBatch();
+          return clonePurgeBatch(batch) ?? void 0;
+        }
+        const outcome = await this.runPurge(plan, true, connectionEpoch);
+        if (!terminal(outcome)) {
+          batch.phase = batch.stopRequested ? "cancelled" : "paused";
+          if (batch.stopRequested) {
+            for (const unsent of batch.items) {
+              if (unsent.state === "preparing" || unsent.state === "ready") unsent.state = "cancelled";
+            }
+          }
+          this.publishPurgeBatch();
+          return clonePurgeBatch(batch) ?? void 0;
+        }
+      }
+      if (batch.stopRequested || this.lifetime.signal.aborted) {
+        for (const item of batch.items) {
+          if (item.state === "preparing" || item.state === "ready") item.state = "cancelled";
+        }
+        batch.phase = "cancelled";
+      } else batch.phase = "done";
+      this.publishPurgeBatch();
+      return clonePurgeBatch(batch) ?? void 0;
+    })();
+    try {
+      return await this.purgeBatchRun;
+    } finally {
+      this.purgeBatchRun = null;
+    }
+  }
+  stopPurgeBatch() {
+    if (!this.purgeBatch || !this.hasActivePurgeBatch()) return;
+    const batch = this.purgeBatch;
+    ++this.purgePreparationEpoch;
+    if (this.confirmation?.batchId === batch.batchId) {
+      this.confirmation = null;
+      this.publishConfirmation();
+    }
+    batch.stopRequested = true;
+    for (const item of batch.items) {
+      if (item.state === "preparing" || item.state === "ready") item.state = "cancelled";
+    }
+    if (batch.phase !== "preparing" && (batch.phase !== "running" || !batch.items.some((item) => item.state === "running"))) {
+      batch.phase = "cancelled";
+    }
+    this.publishPurgeBatch();
+  }
+  dismissPurgeBatch() {
+    if (!this.purgeBatch || !["done", "cancelled"].includes(this.purgeBatch.phase)) return;
+    ++this.purgePreparationEpoch;
+    if (this.confirmation?.batchId === this.purgeBatch.batchId) this.cancelPurge();
+    this.purgeBatch = null;
+    this.publishPurgeBatch();
+  }
+  async readPurgeOperation(plan) {
+    const raw = value(await this.api.getPurgeOperation(plan.operationId, this.lifetime.signal));
+    if (raw === null) {
+      if (this.observedPurgeGrants.has(plan.operationId) || this.uncertainPurgeGrants.has(plan.operationId)) {
+        throw new Error("An admitted deletion lost its saved Host journal.");
+      }
+      return null;
+    }
+    const operation = purgeOperationSchema.parse(raw);
+    if (operation.schemaVersion !== 2 || frozenPurgeKey(operation.plan) !== frozenPurgeKey(plan)) throw new Error("Deletion receipt changed its confirmed binding.");
+    if (this.uncertainPurgeGrants.has(plan.operationId)) throw new Error("Deletion authorization continuity is uncertain.");
+    const observed = this.observedPurgeGrants.get(plan.operationId);
+    if (observed !== void 0 && operation.authorizationId !== observed) throw new Error("Deletion journal lost its observed authorization grant.");
+    if (operation.ownerState) this.validatePurgeOwnerState(plan, operation.ownerState);
+    return operation;
+  }
+  async discoverPurgePending() {
+    if (this.purgeDiscovering || this.lifetime.signal.aborted || typeof this.api.purgeOperations !== "function") return;
+    this.purgeDiscovering = true;
+    try {
+      const operations = purgeOperationsSchema.parse(value(await this.api.purgeOperations(this.lifetime.signal)));
+      this.lifetime.signal.throwIfAborted();
+      for (const operation of operations.filter((row) => row.schemaVersion === 2 && row.phase !== "done")) {
+        const plan = nativePurgePlanSchema.parse(operation.plan);
+        if (this.settledPurgeIds.has(plan.operationId) || this.purgeExecuting.has(plan.operationId) || this.purgeChecking.has(plan.operationId)) continue;
+        const existing = this.state.purgePending.find((row) => row.operationId === plan.operationId);
+        if (existing && frozenPurgeKey(existing) !== frozenPurgeKey(plan)) throw new Error("Discovered deletion changed its confirmed binding.");
+        if (!existing) this.savePurgePending([...this.state.purgePending, plan]);
+        this.publish({ busy: [.../* @__PURE__ */ new Set([...this.state.busy, plan.sessionId])] });
+        if (operation.result) this.settlePurge(plan, operation.result, false);
+        else {
+          this.purgeOutcome(plan, "pending", "deletion-pending");
+          this.publish({ error: "deletion-pending" });
+        }
+      }
+    } catch {
+      this.publish({ error: "deletion-pending" });
+    } finally {
+      this.purgeDiscovering = false;
+    }
+  }
+  /** Automatic checks and reload only observe; no missing or unfinished deletion is replayed. */
+  async checkPurgePending() {
+    for (const plan of [...this.state.purgePending]) {
+      if (this.purgeExecuting.has(plan.operationId) || this.purgeChecking.has(plan.operationId) || this.lifetime.signal.aborted) continue;
+      this.purgeChecking.add(plan.operationId);
+      try {
+        const operation = await this.readPurgeOperation(plan);
+        if (operation?.result) this.settlePurge(plan, operation.result, false);
+        else {
+          const reason = operation === null ? "deletion-result-missing" : "deletion-pending";
+          this.purgeOutcome(plan, "pending", reason);
+          this.publish({ error: reason });
+        }
+      } catch {
+        this.publish({ error: this.isPurgeCacheBlocked() ? "purge-cache-capacity" : "deletion-pending" });
+      } finally {
+        this.purgeChecking.delete(plan.operationId);
+      }
+    }
+  }
+  /** Explicit continuation may only submit a known saved operation's original plan. */
+  async retryPurge(operationId) {
+    const plan = this.state.purgePending.find((row) => row.operationId === operationId);
+    if (this.rejectPurgeCacheCapacity() || this.state.phase !== "ready" || !plan || this.purgeExecuting.has(operationId) || this.purgeChecking.has(operationId) || this.lifetime.signal.aborted) return;
+    const connectionEpoch = this.epoch;
+    this.purgeChecking.add(operationId);
+    try {
+      const operation = await this.readPurgeOperation(plan);
+      this.lifetime.signal.throwIfAborted();
+      if (operation === null) {
+        this.publish({ error: "deletion-result-missing" });
+        return this.purgeOutcome(plan, "pending", "deletion-result-missing");
+      }
+      if (operation.phase === "done" && operation.result) return this.settlePurge(plan, operation.result);
+      if (this.state.phase !== "ready" || this.epoch !== connectionEpoch) {
+        return this.purgeOutcome(plan, "pending", "connection-failed");
+      }
+      return await this.runPurge(plan, false, connectionEpoch);
+    } catch {
+      this.publish({ error: "deletion-pending" });
+      return this.purgeOutcome(plan, "pending", "deletion-pending");
+    } finally {
+      this.purgeChecking.delete(operationId);
+    }
+  }
+  /** A confirmed missing operation requires fresh preparation and another explicit confirmation. */
+  async preparePurgeAgain(operationId, title) {
+    const previous = this.state.purgePending.find((plan) => plan.operationId === operationId);
+    const belongsToBatch = this.batchPurgeOperationIds.has(operationId);
+    const batch = this.purgeBatch;
+    const batchItemIndex = batch?.items.findIndex((item2) => item2.plan?.operationId === operationId) ?? -1;
+    const item = batch && batchItemIndex >= 0 ? batch.items[batchItemIndex] : null;
+    const batchReplacement = belongsToBatch && batch !== null && (batch.phase === "paused" && !batch.stopRequested || batch.phase === "cancelled" && batch.stopRequested) && item?.state === "settled" && item.outcome?.operationId === operationId && item.outcome.reason === "deletion-result-missing";
+    if (this.rejectPurgeCacheCapacity() || this.state.phase !== "ready" || !previous || this.confirmation || this.purgeExecuting.has(operationId) || this.purgeChecking.has(operationId) || this.lifetime.signal.aborted || this.hasActivePurgeBatch() && !batchReplacement || this.state.purgePending.some((plan) => plan.operationId !== operationId)) return null;
+    const connectionEpoch = this.epoch;
+    const preparationEpoch = ++this.purgePreparationEpoch;
+    const associationIsCurrent = () => {
+      const current = this.state.purgePending.find((plan) => plan.operationId === operationId);
+      if (this.state.phase !== "ready" || this.epoch !== connectionEpoch || preparationEpoch !== this.purgePreparationEpoch || this.confirmation !== null || !current || frozenPurgeKey(current) !== frozenPurgeKey(previous) || this.state.purgePending.some((plan) => plan.operationId !== operationId)) return false;
+      if (!batchReplacement) return !this.hasActivePurgeBatch();
+      return batch !== null && batch === this.purgeBatch && (batch.phase === "paused" && !batch.stopRequested || batch.phase === "cancelled" && batch.stopRequested) && batch.items[batchItemIndex] === item && item?.state === "settled" && item.plan?.operationId === operationId && item.outcome?.operationId === operationId && item.outcome.reason === "deletion-result-missing";
+    };
+    this.purgeChecking.add(operationId);
+    try {
+      const operation = await this.readPurgeOperation(previous);
+      if (!associationIsCurrent()) return null;
+      if (operation !== null) {
+        this.publish({ error: "deletion-pending" });
+        return null;
+      }
+      this.lifetime.signal.throwIfAborted();
+      const entry = this.state.entries.find((row) => row.sessionId === previous.sessionId && row.entryId === previous.expectedEntryId);
+      if (!entry) {
+        this.publish({ error: "entry-changed" });
+        return null;
+      }
+      const prepared = await this.requestPurgePlan(entry);
+      if (!associationIsCurrent()) return null;
+      if (!prepared.plan) {
+        this.publish({ error: prepared.reason });
+        return null;
+      }
+      this.publish({ error: null });
+      if (!associationIsCurrent()) return null;
+      this.confirmation = {
+        plan: prepared.plan,
+        title,
+        acknowledged: false,
+        batchId: batchReplacement ? batch.batchId : null,
+        batchItemIndex: batchReplacement ? batchItemIndex : null,
+        replacesOperationId: operationId
+      };
+      this.publishConfirmation();
+      return nativePurgePlanSchema.parse(prepared.plan);
+    } catch {
+      if (associationIsCurrent()) this.publish({ error: "deletion-pending" });
+      return null;
+    } finally {
+      this.purgeChecking.delete(operationId);
+    }
+  }
+  async discardMissingPurge(operationId) {
+    const plan = this.state.purgePending.find((row) => row.operationId === operationId);
+    const belongsToBatch = this.batchPurgeOperationIds.has(operationId) || (this.purgeBatch?.items.some((item) => item.plan?.operationId === operationId) ?? false);
+    if (this.rejectPurgeCacheCapacity() || belongsToBatch || !plan || this.purgeExecuting.has(operationId) || this.purgeChecking.has(operationId) || this.lifetime.signal.aborted) return false;
+    this.purgeChecking.add(operationId);
+    try {
+      if (await this.readPurgeOperation(plan) !== null) return false;
+      this.lifetime.signal.throwIfAborted();
+      this.savePurgePending(this.state.purgePending.filter((row) => row.operationId !== operationId));
+      if (!this.state.purgePending.some((row) => row.sessionId === plan.sessionId)) this.publish({ busy: this.state.busy.filter((id) => id !== plan.sessionId) });
+      this.publish({ error: this.state.purgePending.length ? "deletion-pending" : null });
+      return true;
+    } catch {
+      this.publish({ error: "deletion-pending" });
+      return false;
+    } finally {
+      this.purgeChecking.delete(operationId);
+    }
+  }
+  settlePurge(plan, raw, announce = true) {
+    const result = purgeResultSchema.parse(raw);
+    const admitted = ["success", "pending-recovery", "partial-failure"].includes(result.status);
+    if (result.operationId !== plan.operationId || result.sessionId !== plan.sessionId || result.entryId !== null && result.entryId !== plan.expectedEntryId || admitted && result.entryId !== plan.expectedEntryId) {
+      throw new Error("Deletion result changed its confirmed lifecycle or resource scope.");
+    }
+    if (this.uncertainPurgeGrants.has(plan.operationId)) throw new Error("Deletion authorization continuity is uncertain.");
+    if (this.observedPurgeGrants.has(plan.operationId) && (result.status === "rejected" || result.status === "conflict" || !result.ownerState)) {
+      throw new Error("An admitted deletion cannot lose its observed owner authorization.");
+    }
+    if (result.ownerState) this.validatePurgeOwnerState(plan, result.ownerState);
+    const terminal = ["success", "rejected", "conflict"].includes(result.status);
+    const cacheBlocked = this.isPurgeCacheBlocked();
+    if (terminal && !cacheBlocked) {
+      this.settledPurgeIds.add(plan.operationId);
+      this.savePurgePending(this.state.purgePending.filter((row) => row.operationId !== plan.operationId));
+      this.publish({ busy: this.state.busy.filter((id) => id !== plan.sessionId) });
+    }
+    const outcome = this.purgeOutcome(plan, result.status, result.reason);
+    this.publish({ error: cacheBlocked ? "purge-cache-capacity" : terminal ? this.state.purgePending.length ? "deletion-pending" : null : "deletion-pending" });
+    if (!cacheBlocked && (announce || terminal)) this.publish({ notice: {
+      sequence: ++this.noticeSequence,
+      kind: result.status === "success" ? "deleted" : "failed",
+      sessionId: result.sessionId,
+      entryId: result.entryId,
+      reason: terminal ? result.reason : "deletion-pending"
+    } });
+    return outcome;
+  }
+  async runPurge(input, batchOrigin = false, connectionEpoch = this.epoch) {
+    const plan = nativePurgePlanSchema.parse(input);
+    const alreadyPending = this.state.purgePending.some((row) => row.operationId === plan.operationId);
+    const cacheBlocked = this.rejectPurgeCacheCapacity();
+    if (cacheBlocked || this.state.purgePending.length > 0 && !alreadyPending || this.purgeExecuting.has(plan.operationId) || this.lifetime.signal.aborted) {
+      return this.purgeOutcome(plan, "pending", cacheBlocked ? "purge-cache-capacity" : "deletion-pending");
+    }
+    this.purgeExecuting.add(plan.operationId);
+    this.publish({ busy: [.../* @__PURE__ */ new Set([...this.state.busy, plan.sessionId])], error: null });
+    this.savePurgePending(
+      [...this.state.purgePending.filter((row) => row.operationId !== plan.operationId), plan],
+      batchOrigin ? plan.operationId : null
+    );
+    try {
+      this.lifetime.signal.throwIfAborted();
+      if (this.state.phase !== "ready" || this.epoch !== connectionEpoch) {
+        this.publish({ error: "connection-failed" });
+        return this.purgeOutcome(plan, "pending", "connection-failed");
+      }
+      return this.settlePurge(plan, value(await this.api.executePurge(nativePurgePlanSchema.parse(plan), this.lifetime.signal)));
+    } catch {
+      try {
+        const operation = await this.readPurgeOperation(plan);
+        if (operation?.result) return this.settlePurge(plan, operation.result);
+        if (operation === null) {
+          this.publish({ error: "deletion-result-missing" });
+          return this.purgeOutcome(plan, "pending", "deletion-result-missing");
+        }
+      } catch {
+      }
+      this.publish({ error: "deletion-pending" });
+      return this.purgeOutcome(plan, "pending", "deletion-pending");
+    } finally {
+      this.purgeExecuting.delete(plan.operationId);
+      if (!this.state.purgePending.some((row) => row.sessionId === plan.sessionId)) this.publish({ busy: this.state.busy.filter((id) => id !== plan.sessionId) });
+    }
+  }
+  async unarchive(entry) {
+    return this.run(entry.sessionId, entry.entryId);
+  }
+  async unarchiveMany(entries) {
+    const targets = entries.map((entry) => ({ sessionId: entry.sessionId, entryId: entry.entryId }));
+    const results = [];
+    for (const target of targets) {
+      if (this.lifetime.signal.aborted) break;
+      results.push(await this.unarchive(target));
+    }
+    this.publish({ results });
+    return results;
+  }
+  /** Baselines only query receipts. Explicit retry can resend the same missing
+   * v2 unarchive identity/plan; v1 bin/restore plans remain query-only forever.
+   */
+  async checkPending(retryMissing = true) {
+    for (const plan of [...this.state.pending]) {
+      if (this.checking.has(plan.operationId) || this.state.busy.includes(plan.sessionId) || this.lifetime.signal.aborted) continue;
+      this.checking.add(plan.operationId);
+      try {
+        const operation = value(await this.api.getOperation(plan.operationId, this.lifetime.signal));
+        if (operation?.result) {
+          if (operation.plan.operationId !== plan.operationId || operation.plan.sessionId !== plan.sessionId || operation.plan.action !== plan.action || operation.schemaVersion !== plan.schemaVersion) throw new Error("Receipt identity changed.");
+          if (plan.schemaVersion === 1) {
+            this.pending(this.state.pending.filter((row) => row.operationId !== plan.operationId));
+            this.publish({ error: this.state.pending.length ? "pending-result" : null });
+          } else if (operation.result.action === "unarchive") this.settle(plan, operation.result);
+        } else if (operation === null && retryMissing && plan.schemaVersion === 2) {
+          this.settle(plan, value(await this.api.execute(plan, this.lifetime.signal)));
+        } else if (plan.schemaVersion === 1) this.publish({ error: "legacy-pending" });
+      } catch {
+        this.publish({ error: "pending-result" });
+      } finally {
+        this.checking.delete(plan.operationId);
+      }
+    }
+  }
+  settle(plan, result) {
+    if (result.operationId !== plan.operationId || result.sessionId !== plan.sessionId || result.action !== plan.action || result.status === "success" && result.entryId !== plan.expected.entryId) {
+      throw new Error("Receipt identity changed.");
+    }
+    const outcome = {
+      sessionId: result.sessionId,
+      entryId: result.entryId,
+      status: result.status,
+      reason: result.reason
+    };
+    this.pending(this.state.pending.filter((row) => row.operationId !== plan.operationId));
+    this.publish({
+      results: [outcome],
+      error: this.state.pending.length ? "pending-result" : null,
+      notice: {
+        sequence: ++this.noticeSequence,
+        kind: result.status === "success" ? "unarchived" : "failed",
+        sessionId: result.sessionId,
+        entryId: result.entryId,
+        reason: result.reason
+      }
+    });
+    return outcome;
+  }
+  async run(sessionId, expectedEntryId) {
+    if (this.state.phase !== "ready" || this.state.busy.includes(sessionId) || this.state.pending.some((plan2) => plan2.schemaVersion === 2 && plan2.sessionId === sessionId) || this.lifetime.signal.aborted) {
+      return { sessionId, entryId: expectedEntryId, status: "pending", reason: "pending-result" };
+    }
+    this.publish({ busy: [...this.state.busy, sessionId], error: null });
+    let plan;
+    try {
+      plan = archivePlanSchema.parse(value(await this.api.prepare({ action: "unarchive", sessionId, operationId: crypto.randomUUID() }, this.lifetime.signal)));
+      if (plan.sessionId !== sessionId || plan.expected.entryId !== expectedEntryId) {
+        const result = {
+          operationId: plan.operationId,
+          action: "unarchive",
+          sessionId: plan.sessionId,
+          entryId: expectedEntryId,
+          status: "conflict",
+          reason: "entry-changed"
+        };
+        return this.settle(plan, result);
+      }
+      this.pending([...this.state.pending, plan]);
+      return this.settle(plan, value(await this.api.execute(plan, this.lifetime.signal)));
+    } catch {
+      if (plan) {
+        try {
+          const operation = value(await this.api.getOperation(plan.operationId, this.lifetime.signal));
+          if (operation?.schemaVersion === 2 && operation.result) return this.settle(plan, operation.result);
+        } catch {
+        }
+      }
+      const outcome = {
+        sessionId,
+        entryId: expectedEntryId,
+        status: plan ? "pending" : "rejected",
+        reason: plan ? "pending-result" : "connection-failed"
+      };
+      this.publish({ error: outcome.reason, results: [outcome], notice: {
+        sequence: ++this.noticeSequence,
+        kind: "failed",
+        sessionId,
+        entryId: outcome.entryId,
+        reason: outcome.reason
+      } });
+      return outcome;
+    } finally {
+      this.publish({ busy: this.state.busy.filter((id) => id !== sessionId) });
+    }
+  }
+};
+function browserPendingCache(storage) {
+  const key2 = "dsh-session-bin.pending.v2";
+  const legacyKey = "dsh-session-bin.pending.v1";
+  const purgeKey = "dsh-session-bin.purge.pending.v2";
+  const purgeGrantKey = "dsh-session-bin.purge.grants.v2";
+  let purgeCacheBlocked = false;
+  const emptyPurgeEnvelope = () => ({
+    schemaVersion: 1,
+    plans: [],
+    grants: [],
+    observationAttempts: [],
+    batchOperations: []
+  });
+  const parse = (item) => {
+    try {
+      return pendingPlans(JSON.parse(item ?? "[]"));
+    } catch {
+      return [];
+    }
+  };
+  const assertPurgeCacheWritable = (...arrays) => {
+    if (arrays.some((array) => array.length > 64)) purgeCacheBlocked = true;
+    if (purgeCacheBlocked) throw new Error("Deletion cache capacity exceeded.");
+  };
+  const writePurgeEnvelope = (envelope) => {
+    assertPurgeCacheWritable(envelope.plans, envelope.grants, envelope.observationAttempts, envelope.batchOperations);
+    storage.setItem(purgeKey, JSON.stringify(envelope));
+    storage.removeItem(purgeGrantKey);
+  };
+  const readPurgeEnvelope = () => {
+    const encoded = storage.getItem(purgeKey);
+    let raw = null;
+    try {
+      raw = JSON.parse(encoded ?? "null");
+    } catch {
+    }
+    const legacyEncoded = storage.getItem(purgeGrantKey);
+    let rawLegacyGrants = [];
+    try {
+      rawLegacyGrants = JSON.parse(legacyEncoded ?? "[]");
+    } catch {
+    }
+    const legacyArray = encoded !== null && Array.isArray(raw);
+    const record = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+    const rawPlans = legacyArray ? raw : record?.schemaVersion === 1 ? record.plans : [];
+    const rawGrants = record?.schemaVersion === 1 ? record.grants : [];
+    const rawObservations = record?.schemaVersion === 1 ? record.observationAttempts : [];
+    const rawBatchOperations = record?.schemaVersion === 1 ? record.batchOperations : [];
+    if (purgeCacheOverflow(rawPlans, rawGrants, rawObservations, rawBatchOperations, rawLegacyGrants)) purgeCacheBlocked = true;
+    let envelope = emptyPurgeEnvelope();
+    if (legacyArray) envelope.plans = purgePlans(rawPlans);
+    else if (record?.schemaVersion === 1) {
+      envelope = {
+        schemaVersion: 1,
+        plans: purgePlans(rawPlans),
+        grants: purgeGrantSnapshots(rawGrants),
+        observationAttempts: purgeGrantObservations(rawObservations),
+        batchOperations: purgeBatchOperations(rawBatchOperations)
+      };
+    }
+    const activeIds = new Set(envelope.plans.map((plan) => plan.operationId));
+    envelope.grants = purgeGrantSnapshots([...envelope.grants, ...purgeGrantSnapshots(rawLegacyGrants)]).filter((grant) => activeIds.has(grant.operationId));
+    envelope.observationAttempts = purgeGrantObservations(envelope.observationAttempts).filter((observation) => activeIds.has(observation.operationId));
+    envelope.batchOperations = purgeBatchOperations(envelope.batchOperations).filter((operationId) => activeIds.has(operationId));
+    if (legacyArray) {
+      const grantedIds = new Set(envelope.grants.map((grant) => grant.operationId));
+      envelope.observationAttempts = purgeGrantObservations([
+        ...envelope.observationAttempts,
+        ...envelope.plans.filter((plan) => !grantedIds.has(plan.operationId)).map((plan) => ({ operationId: plan.operationId }))
+      ]);
+    }
+    if (purgeCacheOverflow(envelope.plans, envelope.grants, envelope.observationAttempts, envelope.batchOperations)) purgeCacheBlocked = true;
+    if (!purgeCacheBlocked && (legacyArray || legacyEncoded !== null)) {
+      try {
+        if (envelope.plans.length) writePurgeEnvelope(envelope);
+        else {
+          storage.removeItem(purgeGrantKey);
+          storage.removeItem(purgeKey);
+        }
+      } catch {
+      }
+    }
+    return envelope;
+  };
+  const save = (plans) => {
+    if (plans.length) storage.setItem(key2, JSON.stringify(plans));
+    else storage.removeItem(key2);
+    storage.removeItem(legacyKey);
+  };
+  const savePurge = (plans, batchOperationIds = []) => {
+    assertPurgeCacheWritable(plans, batchOperationIds);
+    const snapshots = purgePlans(plans);
+    const batchOperations = purgeBatchOperations(batchOperationIds);
+    assertPurgeCacheWritable(snapshots, batchOperations);
+    if (!snapshots.length) {
+      storage.removeItem(purgeGrantKey);
+      storage.removeItem(purgeKey);
+      return;
+    }
+    const current = readPurgeEnvelope();
+    assertPurgeCacheWritable(current.plans, current.grants, current.observationAttempts, current.batchOperations);
+    const activeIds = new Set(snapshots.map((plan) => plan.operationId));
+    writePurgeEnvelope({
+      schemaVersion: 1,
+      plans: snapshots,
+      grants: current.grants.filter((grant) => activeIds.has(grant.operationId)),
+      observationAttempts: current.observationAttempts.filter((observation) => activeIds.has(observation.operationId)),
+      batchOperations: batchOperations.filter((operationId) => activeIds.has(operationId))
+    });
+  };
+  return {
+    load: () => {
+      const plans = pendingPlans([...parse(storage.getItem(key2)), ...parse(storage.getItem(legacyKey))]);
+      try {
+        save(plans);
+      } catch {
+      }
+      return plans;
+    },
+    save,
+    loadPurge: () => readPurgeEnvelope().plans,
+    savePurge,
+    loadPurgeGrants: () => readPurgeEnvelope().grants,
+    savePurgeGrants: (grants) => {
+      assertPurgeCacheWritable(grants);
+      const current = readPurgeEnvelope();
+      assertPurgeCacheWritable(current.plans, current.grants, current.observationAttempts, current.batchOperations);
+      const activeIds = new Set(current.plans.map((plan) => plan.operationId));
+      writePurgeEnvelope({ ...current, grants: purgeGrantSnapshots(grants).filter((grant) => activeIds.has(grant.operationId)) });
+    },
+    loadPurgeGrantObservations: () => readPurgeEnvelope().observationAttempts,
+    stagePurgeGrantObservation: (operationId) => {
+      if (typeof operationId !== "string" || operationId.length === 0 || operationId.length > 1024) throw new Error("Invalid operation identity.");
+      const current = readPurgeEnvelope();
+      assertPurgeCacheWritable(current.plans, current.grants, current.observationAttempts, current.batchOperations);
+      if (!current.plans.some((plan) => plan.operationId === operationId)) throw new Error("Cannot stage an observation without its pending plan.");
+      writePurgeEnvelope({ ...current, observationAttempts: purgeGrantObservations([...current.observationAttempts, { operationId }]) });
+    },
+    loadPurgeBatchOperations: () => readPurgeEnvelope().batchOperations,
+    isPurgeCacheBlocked: () => {
+      readPurgeEnvelope();
+      return purgeCacheBlocked;
+    }
+  };
+}
+export {
+  SessionBinClientModel,
+  browserPendingCache,
+  retirementManifestDigest
+};