@effect-agent/storage-cloudflare 0.1.0-beta.55 → 0.1.0-beta.57

package/dist/{DoThreadStore-CCSgDto6.mjs → do-journal-Brv7xSH5.mjs}

@@ -1,17 +1,10 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { DoStorageConfig, DoStorageConfigValue } from "./DoStorageConfig.mjs";
 import { DoAppendConflict, DoCheckpointConflict, DoFenceRejected, DoStorageCompatibilityError, DoStorageCorruptionError, DoStorageError, DoValueBoundExceeded } from "./DoStorageError.mjs";
-import { DoStorageFailpoint } from "./DoStorageFailpoint.mjs";
-import { n as doMigrations } from "./migrations-B-jiT7vx.mjs";
-import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-do";
-import { Clock, Context, Crypto, Duration, Effect, Layer, Option, Ref, Schema, Stream } from "effect";
-import { checkV2ThreadLayout } from "@effect-agent/thread/SqlStorageV2Upgrade";
+import { n as doMigrations, r as createMessageDeliveryTables } from "./migrations-soC86CQA.mjs";
+import { Effect, Schema, Stream } from "effect";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
-import { CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, Digest, ObservationOffset, ProducerEpoch } from "@effect-agent/thread/Records";
-import { EMPTY_TAIL_DIGEST, digestCanonicalBatch } from "@effect-agent/thread/Digest";
-import { DEFAULT_OWNERSHIP_LEASE_DURATION } from "@effect-agent/thread/SubmissionLedger";
-import { BrowserCrypto } from "@effect/platform-browser";
-import { AppendConflict, AppendResult, CheckpointRejected, FenceRejected, FencedAppendRequest, LoadCheckpointRequest, SaveCheckpointRequest, ThreadCheckpoint, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest } from "@effect-agent/thread/ThreadStore";
+import { CanonicalSequence, ProducerEpoch } from "@effect-agent/thread/Records";
+import { checkV2ThreadLayout } from "@effect-agent/thread/SqlStorageV2Upgrade";
+import { SqliteMigrator } from "@effect/sql-sqlite-do";
 import { SqlError } from "effect/unstable/sql/SqlError";
 //#region src/internal/do-journal.ts
 /**
@@ -121,6 +114,147 @@ const decodeSingleRow = Effect.fn((schema, table, rowKey, rows) => decodeRows(sc
 	rowKey,
 	message: `Expected exactly one row but found ${decoded.length}.`
 })))));
+/** Column inventory of the supported v3 predecessor, independent of physical column order. */
+const predecessorColumns = {
+	effect_agent_threads: [
+		"thread_id",
+		"created_at",
+		"tail_sequence",
+		"tail_digest",
+		"producer_epoch"
+	],
+	effect_agent_canonical_batches: [
+		"thread_id",
+		"batch_id",
+		"first_sequence",
+		"last_sequence",
+		"batch_digest",
+		"tail_digest",
+		"batch_json"
+	],
+	effect_agent_canonical_records: [
+		"thread_id",
+		"sequence",
+		"record_id",
+		"batch_id",
+		"record_json"
+	],
+	effect_agent_checkpoints: [
+		"thread_id",
+		"through_sequence",
+		"tail_digest",
+		"checkpoint_json"
+	],
+	effect_agent_submissions: [
+		"submission_id",
+		"thread_id",
+		"queue_sequence",
+		"principal",
+		"idempotency_key",
+		"agent_id",
+		"agent_digests_json",
+		"deployment_id",
+		"input_json",
+		"input_digest",
+		"receipt_id",
+		"state",
+		"settled_outcome",
+		"created_at",
+		"ready_at",
+		"input_applied_record_id",
+		"input_applied_sequence",
+		"joined_host_submission_id",
+		"suspended_reason_json",
+		"suspended_at",
+		"unknown_reason",
+		"unknown_tool_call_ids_json",
+		"parent_submission_id",
+		"parent_tool_call_id",
+		"admission_group",
+		"admission_fence_json"
+	],
+	effect_agent_submission_ownership: [
+		"submission_id",
+		"attempt_id",
+		"ownership_token",
+		"producer_epoch",
+		"owner_producer_id",
+		"lease_expires_at"
+	],
+	effect_agent_attempts: [
+		"attempt_id",
+		"submission_id",
+		"thread_id",
+		"owner_producer_id",
+		"producer_epoch",
+		"claimed_at"
+	],
+	effect_agent_settlement_reservations: [
+		"submission_id",
+		"settlement_id",
+		"outcome",
+		"record_id",
+		"record_json",
+		"record_digest",
+		"reserved_at",
+		"finalized_at"
+	],
+	effect_agent_abort_intents: [
+		"submission_id",
+		"author",
+		"reason",
+		"requested_at",
+		"canonical_record_id"
+	],
+	effect_agent_approval_decisions: [
+		"submission_id",
+		"tool_call_id",
+		"decision",
+		"resolver",
+		"reason",
+		"decided_at"
+	],
+	effect_agent_unknown_resolutions: [
+		"submission_id",
+		"tool_call_id",
+		"author",
+		"reason",
+		"resolution_json",
+		"resolved_at"
+	],
+	effect_agent_child_reservations: [
+		"reservation_id",
+		"parent_submission_id",
+		"parent_tool_call_id",
+		"child_submission_id",
+		"status",
+		"allocation_json",
+		"allocation_digest",
+		"accounting_json",
+		"reserved_at",
+		"release_began_at",
+		"released_at"
+	],
+	effect_agent_meta: ["key", "value"],
+	effect_agent_child_settlements: [
+		"parent_submission_id",
+		"child_submission_id",
+		"child_outcome",
+		"recorded_at"
+	]
+};
+const checkPredecessorLayout = Effect.fn("DoJournal.checkPredecessorLayout")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	for (const [table, expected] of Object.entries(predecessorColumns)) {
+		const columns = yield* decodeRows(Schema.Array(Schema.Struct({ name: BoundedIdentifier })), table, "schema", yield* sql.unsafe(`PRAGMA table_info(${table})`));
+		const names = new Set(expected);
+		if (columns.length !== names.size || columns.some((column) => !names.has(column.name))) return yield* DoStorageCompatibilityError.make({
+			actualVersion: 3,
+			supportedVersion: 4,
+			message: `The v3 ${table} columns do not match the supported predecessor; no upgrade was committed.`
+		});
+	}
+});
 const REQUIRED_TABLES = [
 	"effect_agent_abort_intents",
 	"effect_agent_approval_decisions",
@@ -161,7 +295,7 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
     `.pipe(Effect.mapError(storageError("inspect unversioned storage")));
 		if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* DoStorageCompatibilityError.make({
 			actualVersion: 0,
-			supportedVersion: 3,
+			supportedVersion: 4,
 			message: "The Durable Object contains unversioned Effect Agent tables. Refusing to mutate ambiguous stored data; retain it for inspection with its original writer."
 		});
 		yield* SqliteMigrator.run({ loader: doMigrations }).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.mapError((error) => DoStorageError.make({
@@ -176,31 +310,43 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
       WHERE key = 'storage_version'
     `.pipe(Effect.mapError(storageError("read storage version")));
 		const version = yield* decodeSingleRow(Schema.Array(DoMetaRow), "effect_agent_meta", "storage_version", versionRows);
-		if (version.value === "2") yield* sql.withTransaction(Effect.gen(function* () {
+		if (version.value === "2" || version.value === "3") yield* sql.withTransaction(Effect.gen(function* () {
 			const current = yield* sql`SELECT value FROM effect_agent_meta WHERE key='storage_version'`;
-			if (current.length === 1 && current[0].value === "3") return;
-			if (current.length !== 1 || current[0].value !== "2") return yield* DoStorageCompatibilityError.make({
+			if (current.length === 1 && current[0].value === String(4)) return;
+			if (current.length !== 1 || current[0].value !== "2" && current[0].value !== "3") return yield* DoStorageCompatibilityError.make({
 				actualVersion: -1,
-				supportedVersion: 3,
+				supportedVersion: 4,
 				message: "Storage version changed while acquiring the upgrade transaction."
 			});
 			if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "required_tables", yield* sql`SELECT name FROM sqlite_master WHERE type='table' AND name IN ${sql.in([...REQUIRED_TABLES])}`)).length !== REQUIRED_TABLES.length) return yield* DoStorageCompatibilityError.make({
-				actualVersion: 2,
-				supportedVersion: 3,
-				message: "The v2 store is missing required tables. Retain the original store for inspection; no upgrade was committed."
+				actualVersion: Number(current[0].value),
+				supportedVersion: 4,
+				message: "The predecessor store is missing required tables. Retain the original store for inspection; no upgrade was committed."
 			});
-			yield* checkV2ThreadLayout();
-			for (const statement of [
-				sql`ALTER TABLE effect_agent_submissions ADD COLUMN admission_group TEXT`,
-				sql`ALTER TABLE effect_agent_submissions ADD COLUMN admission_fence_json TEXT`,
-				sql`CREATE INDEX effect_agent_submissions_group ON effect_agent_submissions (thread_id, admission_group, state)`
-			]) {
-				yield* failpoint("upgrade:before-mutation");
-				yield* statement;
-				yield* failpoint("upgrade:after-mutation");
+			if (current[0].value === "2") {
+				yield* checkV2ThreadLayout();
+				for (const statement of [
+					sql`ALTER TABLE effect_agent_submissions ADD COLUMN admission_group TEXT`,
+					sql`ALTER TABLE effect_agent_submissions ADD COLUMN admission_fence_json TEXT`,
+					sql`CREATE INDEX effect_agent_submissions_group ON effect_agent_submissions (thread_id, admission_group, state)`
+				]) {
+					yield* failpoint("upgrade:before-mutation");
+					yield* statement;
+					yield* failpoint("upgrade:after-mutation");
+				}
 			}
+			if (current[0].value === "3") yield* checkPredecessorLayout();
+			yield* failpoint("upgrade:before-mutation");
+			yield* sql`ALTER TABLE effect_agent_submissions ADD COLUMN worker_admission_json TEXT`;
+			yield* failpoint("upgrade:after-mutation");
+			yield* failpoint("upgrade:before-mutation");
+			yield* sql`ALTER TABLE effect_agent_submissions ADD COLUMN message_admission_json TEXT`;
+			yield* failpoint("upgrade:after-mutation");
+			yield* failpoint("upgrade:before-mutation");
+			yield* createMessageDeliveryTables;
+			yield* failpoint("upgrade:after-mutation");
 			yield* failpoint("upgrade:before-version");
-			yield* sql`UPDATE effect_agent_meta SET value='3' WHERE key='storage_version'`;
+			yield* sql`UPDATE effect_agent_meta SET value='4' WHERE key='storage_version'`;
 			yield* failpoint("upgrade:after-version");
 		})).pipe(Effect.catchTag("DoStorageFailpointError", (error) => DoStorageError.make({
 			cause: error,
@@ -210,13 +356,13 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
 			table: error.table,
 			rowKey: error.rowKey,
 			message: error.message
-		})), Effect.catchTag("SqlError", storageError("upgrade v2 thread storage")));
-		else if (version.value !== String(3)) {
+		})), Effect.catchTag("SqlError", storageError("upgrade supported thread storage")));
+		else if (version.value !== String(4)) {
 			const actualVersion = Number.parseInt(version.value, 10);
 			return yield* DoStorageCompatibilityError.make({
 				actualVersion: Number.isSafeInteger(actualVersion) ? actualVersion : -1,
-				supportedVersion: 3,
-				message: `The Durable Object uses unsupported storage version ${version.value}; this build supports exactly version 3. Only unpatched v2 can be upgraded automatically. Keep the original store and use a compatible library version.`
+				supportedVersion: 4,
+				message: `The Durable Object uses unsupported storage version ${version.value}; this build supports exactly version 4. Only supported v2 and v3 can be upgraded automatically. Keep the original store and use a compatible library version.`
 			});
 		}
 	}
@@ -224,12 +370,12 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
     SELECT name
     FROM sqlite_master
     WHERE type = 'table'
-      AND name IN ${sql.in([...REQUIRED_TABLES])}
+      AND name IN ${sql.in([...REQUIRED_TABLES, "effect_agent_message_deliveries"])}
     ORDER BY name
   `.pipe(Effect.mapError(storageError("verify storage tables")));
-	if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "required_tables", requiredRows)).length !== REQUIRED_TABLES.length) return yield* DoStorageCompatibilityError.make({
-		actualVersion: 3,
-		supportedVersion: 3,
+	if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "required_tables", requiredRows)).length !== REQUIRED_TABLES.length + 1) return yield* DoStorageCompatibilityError.make({
+		actualVersion: 4,
+		supportedVersion: 4,
 		message: "The Durable Object claims the current format but is missing required tables. Retain the original store for inspection."
 	});
 	return makeJournal(sql, failpoint, maxStoredValueBytes);
@@ -718,422 +864,6 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 };
 const initializeDoJournal = ensureCurrentStorage;
 //#endregion
-//#region src/DoThreadStore.ts
-var DoThreadStore_exports = /* @__PURE__ */ __exportAll({
-	layer: () => layer,
-	storageConfigLayer: () => storageConfigLayer,
-	storageFailpointLayer: () => storageFailpointLayer,
-	threadStoreLayer: () => threadStoreLayer
-});
-const OffsetText = Schema.String.check(Schema.isMaxLength(4096));
-const DO_OFFSET_PREFIX = "effect-agent-do@1:";
-const ZERO_CANONICAL_SEQUENCE = Schema.decodeSync(CanonicalSequence)(0);
-const isDigest = Schema.is(Digest);
-const isDoFenceRejected = Schema.is(DoFenceRejected);
-const isDoAppendConflict = Schema.is(DoAppendConflict);
-const isDoCheckpointConflict = Schema.is(DoCheckpointConflict);
-const storeError = (operation, error) => ThreadStoreError.make({
-	cause: error,
-	operation,
-	message: error.message
-});
-const schemaStoreError = (operation, error) => ThreadStoreError.make({
-	cause: error,
-	operation,
-	message: error.message
-});
-const makeOffset = Effect.fn(function* (threadId, sequence) {
-	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.flatMap((validatedSequence) => Schema.decodeUnknownEffect(ObservationOffset)(`${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`)), Effect.mapError((error) => schemaStoreError("encode observation offset", error)));
-});
-const parseOffset = Effect.fn(function* (threadId, offset) {
-	if (offset === void 0) return ZERO_CANONICAL_SEQUENCE;
-	const text = yield* Schema.decodeUnknownEffect(OffsetText)(offset).pipe(Effect.mapError((error) => schemaStoreError("decode observation offset", error)));
-	const threadPrefix = `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:`;
-	if (!text.startsWith(threadPrefix)) return yield* ThreadStoreError.make({
-		operation: "decode observation offset",
-		message: "The observation offset belongs to a different adapter, storage version, or Thread."
-	});
-	const sequenceText = text.slice(threadPrefix.length);
-	if (!/^(0|[1-9][0-9]*)$/.test(sequenceText)) return yield* ThreadStoreError.make({
-		operation: "decode observation offset",
-		message: "The observation offset is malformed."
-	});
-	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(Number(sequenceText)).pipe(Effect.mapError((error) => schemaStoreError("decode observation offset", error)));
-});
-const mapFence = (threadId, error) => FenceRejected.make({
-	threadId,
-	actualEpoch: error.actualEpoch,
-	attemptedEpoch: error.producerEpoch
-});
-const encodeCanonicalRecord = Effect.fn(function* (record) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(record).pipe(Effect.mapError((error) => schemaStoreError("encode canonical record", error)));
-});
-const encodeCanonicalBatch = Effect.fn(function* (batch) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalBatch))(batch).pipe(Effect.mapError((error) => schemaStoreError("encode canonical batch", error)));
-});
-const encodeCheckpoint = Effect.fn(function* (checkpoint) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint).pipe(Effect.mapError((error) => schemaStoreError("encode checkpoint", error)));
-});
-const decodeEnvelope = Effect.fn(function* (row) {
-	const record = yield* Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(row.record_json).pipe(Effect.mapError((error) => ThreadStoreError.make({
-		operation: "decode canonical record",
-		message: error.message
-	})));
-	const threadId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.threadId)(row.thread_id).pipe(Effect.mapError((error) => schemaStoreError("decode thread identity", error)));
-	const offset = yield* makeOffset(threadId, row.sequence);
-	const batchId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.batchId)(row.batch_id).pipe(Effect.mapError((error) => schemaStoreError("decode batch identity", error)));
-	return CanonicalRecordEnvelope.make({
-		threadId,
-		batchId,
-		sequence: row.sequence,
-		offset,
-		record
-	});
-});
-const decodeCheckpoint = Effect.fn(function* (checkpointJson) {
-	return yield* Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpointJson).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint", error)));
-});
-const requireThread = Effect.fn("DoThreadStore.requireThread")(function* (journal, threadId) {
-	const rows = yield* journal.getThread(threadId).pipe(Effect.mapError((error) => storeError("read thread", error)));
-	if (rows.length === 0) return yield* ThreadNotMaterialized.make({ threadId });
-	return rows[0];
-});
-const tailDigestAt = Effect.fn("DoThreadStore.tailDigestAt")(function* (journal, threadId, sequence) {
-	if (sequence === 0) return EMPTY_TAIL_DIGEST;
-	const digests = yield* journal.getTailDigestAt(threadId, sequence).pipe(Effect.mapError((error) => storeError("read checkpoint digest", error)));
-	if (digests.length !== 1) return yield* CheckpointRejected.make({
-		threadId,
-		reason: "digest-mismatch"
-	});
-	return yield* Schema.decodeUnknownEffect(Digest)(digests[0]).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint digest", error)));
-});
-const groupByKey = (rows, key) => {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const existing = grouped.get(key(row));
-		if (existing === void 0) grouped.set(key(row), [row]);
-		else existing.push(row);
-	}
-	return grouped;
-};
-/**
-* Opt-in full integrity audit (`verifyOnOpen`). Every stored payload is decoded, re-encoded,
-* and re-digested against the canonical chain. Routine opens skip this scan: per-operation
-* Schema decoding plus the digest chain already fail clearly on corrupt rows.
-*/
-const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(function* (journal, crypto) {
-	const stored = yield* journal.scanStoredPayloads();
-	const batches = yield* Effect.forEach(stored.batches, (batch) => Schema.decodeEffect(Schema.fromJsonString(CanonicalBatch))(batch.batch_json).pipe(Effect.map((decoded) => ({
-		decoded,
-		row: batch
-	})), Effect.mapError((error) => DoStorageCorruptionError.make({
-		table: "effect_agent_canonical_batches",
-		rowKey: `${batch.thread_id}/${batch.batch_id}`,
-		message: error.message
-	}))));
-	const records = yield* Effect.forEach(stored.records, (record) => Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(record.record_json).pipe(Effect.map((decoded) => ({
-		decoded,
-		row: record
-	})), Effect.mapError((error) => DoStorageCorruptionError.make({
-		table: "effect_agent_canonical_records",
-		rowKey: `${record.thread_id}/${record.sequence}`,
-		message: error.message
-	}))));
-	const checkpoints = yield* Effect.forEach(stored.checkpoints, (checkpoint) => Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint.checkpoint_json).pipe(Effect.map((decoded) => ({
-		decoded,
-		row: checkpoint
-	})), Effect.mapError((error) => DoStorageCorruptionError.make({
-		table: "effect_agent_checkpoints",
-		rowKey: `${checkpoint.thread_id}/${checkpoint.through_sequence}`,
-		message: error.message
-	}))));
-	const batchesByThread = groupByKey(batches, ({ row }) => row.thread_id);
-	const recordsByThread = groupByKey(records, ({ row }) => row.thread_id);
-	const checkpointsByThread = groupByKey(checkpoints, ({ row }) => row.thread_id);
-	const materializedIds = new Set(stored.threads.map((thread) => thread.thread_id));
-	for (const thread of stored.threads) {
-		const threadBatches = batchesByThread.get(thread.thread_id) ?? [];
-		const threadRecords = recordsByThread.get(thread.thread_id) ?? [];
-		const threadCheckpoints = checkpointsByThread.get(thread.thread_id) ?? [];
-		const recordsByBatch = groupByKey(threadRecords, ({ row }) => row.batch_id);
-		let previousDigest = EMPTY_TAIL_DIGEST;
-		let expectedSequence = 1;
-		const tailDigests = /* @__PURE__ */ new Map([[0, EMPTY_TAIL_DIGEST]]);
-		for (const { decoded: canonicalBatch, row: batchRow } of threadBatches) {
-			const key = `${batchRow.thread_id}/${batchRow.batch_id}`;
-			if (canonicalBatch.batchId !== batchRow.batch_id || batchRow.first_sequence !== expectedSequence || batchRow.last_sequence !== batchRow.first_sequence + canonicalBatch.records.length - 1) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: key,
-				message: "Canonical batch identity, sequence, or record count is inconsistent."
-			});
-			const digest = yield* digestCanonicalBatch(previousDigest, canonicalBatch).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((error) => DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: key,
-				message: error.message
-			})));
-			if (batchRow.batch_digest !== digest || batchRow.tail_digest !== digest) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: key,
-				message: "Canonical batch digest does not match its decoded content and prior tail."
-			});
-			const batchRecords = recordsByBatch.get(batchRow.batch_id) ?? [];
-			if (batchRecords.length !== canonicalBatch.records.length) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_records",
-				rowKey: key,
-				message: "Canonical batch and record-table counts differ."
-			});
-			for (let index = 0; index < canonicalBatch.records.length; index++) {
-				const expectedRecord = canonicalBatch.records[index];
-				const storedRecord = batchRecords[index];
-				const expectedJson = yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(expectedRecord).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
-					table: "effect_agent_canonical_batches",
-					rowKey: key,
-					message: error.message
-				})));
-				const storedJson = yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(storedRecord.decoded).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
-					table: "effect_agent_canonical_records",
-					rowKey: `${key}/${storedRecord.row.sequence}`,
-					message: error.message
-				})));
-				if (storedRecord.row.sequence !== batchRow.first_sequence + index || storedRecord.row.record_id !== expectedRecord.recordId || expectedJson !== storedJson) return yield* DoStorageCorruptionError.make({
-					table: "effect_agent_canonical_records",
-					rowKey: `${key}/${storedRecord.row.sequence}`,
-					message: "Canonical record identity, sequence, or payload differs from its batch."
-				});
-			}
-			previousDigest = digest;
-			expectedSequence = batchRow.last_sequence + 1;
-			tailDigests.set(batchRow.last_sequence, digest);
-		}
-		if (threadRecords.length !== thread.tail_sequence || thread.tail_sequence !== expectedSequence - 1 || thread.tail_digest !== previousDigest) return yield* DoStorageCorruptionError.make({
-			table: "effect_agent_threads",
-			rowKey: thread.thread_id,
-			message: "Thread tail does not match its canonical batch chain."
-		});
-		for (const checkpoint of threadCheckpoints) if (checkpoint.decoded.threadId !== thread.thread_id || checkpoint.decoded.throughSequence !== checkpoint.row.through_sequence || checkpoint.decoded.tailDigest !== checkpoint.row.tail_digest || tailDigests.get(checkpoint.row.through_sequence) !== checkpoint.row.tail_digest) return yield* DoStorageCorruptionError.make({
-			table: "effect_agent_checkpoints",
-			rowKey: `${thread.thread_id}/${checkpoint.row.through_sequence}`,
-			message: "Checkpoint identity or digest is not bound to a canonical batch tail."
-		});
-	}
-	if (batches.some(({ row }) => !materializedIds.has(row.thread_id)) || records.some(({ row }) => !materializedIds.has(row.thread_id)) || checkpoints.some(({ row }) => !materializedIds.has(row.thread_id))) return yield* DoStorageCorruptionError.make({
-		table: "effect_agent_threads",
-		rowKey: "startup_scan",
-		message: "Canonical rows exist without a materialized Thread."
-	});
-});
-const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
-	const config = yield* DoStorageConfig;
-	const failpoint = yield* DoStorageFailpoint;
-	const sql = yield* SqlClient.SqlClient;
-	const crypto = yield* Crypto.Crypto;
-	const journal = yield* initializeDoJournal(sql, failpoint.hit, config.maxStoredValueBytes);
-	if (config.verifyOnOpen) yield* decodeStartupPayloads(journal, crypto);
-	const provideCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
-	const hitFailpoint = Effect.fn((location) => failpoint.hit(location).pipe(Effect.mapError((error) => storeError(`storage failpoint ${location}`, error))));
-	const materialize = Effect.fn("DoThreadStore.materialize")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadMaterialization))(request).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
-		const now = yield* Clock.currentTimeMillis;
-		yield* hitFailpoint("materialize:before");
-		yield* journal.materialize(validated.threadId, new Date(now).toISOString(), EMPTY_TAIL_DIGEST, validated.producerEpoch).pipe(Effect.mapError((error) => error._tag === "DoFenceRejected" ? mapFence(validated.threadId, error) : storeError("materialize thread", error)));
-		yield* hitFailpoint("materialize:after");
-	});
-	const append = Effect.fn("DoThreadStore.append")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
-		yield* requireThread(journal, validated.threadId);
-		const tailDigest = yield* provideCrypto(digestCanonicalBatch(validated.expectedTailDigest, validated.batch)).pipe(Effect.mapError((error) => storeError("digest canonical append", error)));
-		const batchJson = yield* encodeCanonicalBatch(validated.batch);
-		const rawRecords = yield* Effect.forEach(validated.batch.records, (record) => encodeCanonicalRecord(record).pipe(Effect.map((recordJson) => ({
-			recordId: record.recordId,
-			recordJson
-		}))));
-		const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
-			threadId: validated.threadId,
-			batchId: validated.batch.batchId,
-			batchDigest: tailDigest,
-			batchJson,
-			expectedTailSequence: validated.expectedTailSequence,
-			expectedTailDigest: validated.expectedTailDigest,
-			producerEpoch: validated.producerEpoch,
-			records: rawRecords,
-			tailDigest
-		}).pipe(Effect.mapError((error) => schemaStoreError("encode canonical append", error)));
-		yield* hitFailpoint("append:before");
-		const result = yield* journal.append(rawRequest).pipe(Effect.mapError((error) => {
-			if (isDoFenceRejected(error)) return mapFence(validated.threadId, error);
-			if (isDoAppendConflict(error)) return error.actualTailSequence !== void 0 && isDigest(error.actualTailDigest) ? AppendConflict.make({
-				threadId: validated.threadId,
-				batchId: validated.batch.batchId,
-				reason: error.reason,
-				actualTailSequence: error.actualTailSequence,
-				actualTailDigest: error.actualTailDigest
-			}) : AppendConflict.make({
-				threadId: validated.threadId,
-				batchId: validated.batch.batchId,
-				reason: error.reason
-			});
-			return storeError("append canonical batch", error);
-		}), Effect.flatMap((result) => Schema.decodeUnknownEffect(AppendResult)(result).pipe(Effect.mapError((error) => schemaStoreError("decode append result", error)))));
-		yield* hitFailpoint("append:after");
-		return result;
-	});
-	const loadRecords = Effect.fn("DoThreadStore.loadRecords")(function* (request) {
-		const result = yield* journal.read(request).pipe(Effect.mapError((error) => storeError("read canonical records", error)));
-		return {
-			count: result.count,
-			records: result.records.pipe(Stream.mapError((error) => storeError("read canonical records", error)), Stream.mapEffect(decodeEnvelope))
-		};
-	});
-	const readEffect = Effect.fn("DoThreadStore.read")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadRead))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread read", error)));
-		yield* requireThread(journal, validated.threadId);
-		return (yield* loadRecords(RawReadRequest.make({
-			threadId: validated.threadId,
-			fromSequenceExclusive: validated.afterSequence ?? ZERO_CANONICAL_SEQUENCE,
-			limit: validated.limit
-		}))).records;
-	});
-	const read = (request) => Stream.unwrap(readEffect(request));
-	const observeEffect = Effect.fn("DoThreadStore.observe")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadObservation))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread observation", error)));
-		yield* requireThread(journal, validated.threadId);
-		const initialSequence = yield* parseOffset(validated.threadId, validated.afterOffset);
-		const cursor = yield* Ref.make(initialSequence);
-		const poll = Effect.fn("DoThreadStore.observePoll")(function* () {
-			const fromSequenceExclusive = yield* Ref.get(cursor);
-			const result = yield* loadRecords(RawReadRequest.make({
-				threadId: validated.threadId,
-				fromSequenceExclusive,
-				limit: 1024
-			}));
-			if (result.count === 0) {
-				yield* Effect.sleep(config.observationPollInterval);
-				return Stream.empty;
-			}
-			return result.records.pipe(Stream.tap((record) => Ref.set(cursor, record.sequence)));
-		});
-		return Stream.fromEffectRepeat(poll()).pipe(Stream.flatten);
-	});
-	const observe = (request) => Stream.unwrap(observeEffect(request));
-	const exportThread = Effect.fn("DoThreadStore.export")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadExportRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread export", error)));
-		yield* requireThread(journal, validated.threadId);
-		const exported = yield* journal.exportThread(validated.threadId).pipe(Effect.mapError((error) => storeError("export thread", error)));
-		const records = yield* Effect.forEach(exported.records, decodeEnvelope);
-		if (records.length > 65536) return yield* ThreadStoreError.make({
-			operation: "decode thread export",
-			message: "The thread exceeds the current export record limit."
-		});
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(exported.thread.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode export tail digest", error)));
-		return ThreadExport.make({
-			format: "effect-agent/thread@1",
-			threadId: validated.threadId,
-			tailSequence: exported.thread.tail_sequence,
-			tailDigest,
-			records
-		});
-	});
-	const inspectTail = Effect.fn("DoThreadStore.inspectTail")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadTailRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate tail inspection", error)));
-		const thread = yield* requireThread(journal, validated.threadId);
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(thread.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode tail digest", error)));
-		return ThreadTail.make({
-			threadId: validated.threadId,
-			tailSequence: thread.tail_sequence,
-			tailDigest,
-			producerEpoch: thread.producer_epoch
-		});
-	});
-	const saveCheckpoint = Effect.fn("DoThreadStore.saveCheckpoint")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SaveCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint", error)));
-		const thread = yield* requireThread(journal, validated.checkpoint.threadId);
-		if (validated.checkpoint.throughSequence > thread.tail_sequence) return yield* CheckpointRejected.make({
-			threadId: validated.checkpoint.threadId,
-			reason: "ahead-of-tail"
-		});
-		if ((yield* tailDigestAt(journal, validated.checkpoint.threadId, validated.checkpoint.throughSequence)) !== validated.checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			threadId: validated.checkpoint.threadId,
-			reason: "digest-mismatch"
-		});
-		const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
-		const raw = RawCheckpoint.make({
-			threadId: validated.checkpoint.threadId,
-			throughSequence: validated.checkpoint.throughSequence,
-			tailDigest: validated.checkpoint.tailDigest,
-			checkpointJson
-		});
-		yield* hitFailpoint("save-checkpoint:before");
-		yield* journal.saveCheckpoint(raw).pipe(Effect.mapError((error) => isDoCheckpointConflict(error) ? CheckpointRejected.make({
-			threadId: validated.checkpoint.threadId,
-			reason: "digest-mismatch"
-		}) : storeError("save checkpoint", error)));
-		yield* hitFailpoint("save-checkpoint:after");
-	});
-	const loadCheckpoint = Effect.fn("DoThreadStore.loadCheckpoint")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint lookup", error)));
-		const thread = yield* requireThread(journal, validated.threadId);
-		const rows = yield* journal.loadCheckpoint(validated.threadId, validated.atOrBeforeSequence ?? thread.tail_sequence).pipe(Effect.mapError((error) => storeError("load checkpoint", error)));
-		if (rows.length === 0) return Option.none();
-		if (rows.length !== 1) return yield* ThreadStoreError.make({
-			operation: "load checkpoint",
-			message: `Expected at most one checkpoint row but found ${rows.length}.`
-		});
-		const row = rows[0];
-		const checkpoint = yield* decodeCheckpoint(row.checkpoint_json);
-		if (row.thread_id !== validated.threadId || checkpoint.threadId !== row.thread_id || checkpoint.throughSequence !== row.through_sequence || checkpoint.tailDigest !== row.tail_digest) return yield* ThreadStoreError.make({
-			operation: "load checkpoint",
-			message: "Stored checkpoint metadata does not match its canonical row."
-		});
-		if ((yield* tailDigestAt(journal, checkpoint.threadId, checkpoint.throughSequence)) !== checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			threadId: checkpoint.threadId,
-			reason: "digest-mismatch"
-		});
-		return Option.some(checkpoint);
-	});
-	const threadStore = ThreadStore.of({
-		append,
-		export: exportThread,
-		inspectTail,
-		materialize,
-		observe,
-		read,
-		checkpoints: {
-			save: saveCheckpoint,
-			load: loadCheckpoint
-		}
-	});
-	return Context.make(ThreadStore, threadStore);
-});
-/**
-* Durable Object Thread Store implementation with configuration, failpoint, SQL, and
-* Crypto authority kept visible in its input channel.
-*/
-const threadStoreLayer = Layer.effectContext(makeServices());
-/**
-* Validated Durable Object storage configuration Layer with the documented defaults applied.
-* Shared by the ThreadStore and SubmissionLedger convenience layers so their defaults
-* cannot drift.
-*/
-const storageConfigLayer = (options) => Layer.effect(DoStorageConfig)(Schema.decodeUnknownEffect(DoStorageConfigValue)({
-	observationPollInterval: options.observationPollInterval ?? 25,
-	ownershipLeaseDuration: options.ownershipLeaseDuration ?? Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION),
-	maxStoredValueBytes: options.maxStoredValueBytes ?? 19e5,
-	verifyOnOpen: options.verifyOnOpen ?? false
-}).pipe(Effect.mapError((error) => DoStorageError.make({
-	cause: error,
-	operation: "configure Durable Object storage",
-	message: error.message
-}))));
-/** The failpoint Layer selected by convenience options: explicit handler or the no-op default. */
-const storageFailpointLayer = (options) => options.failpoint === void 0 ? DoStorageFailpoint.layer : Layer.succeed(DoStorageFailpoint)({ hit: options.failpoint });
-/**
-* A composition-root convenience Layer for canonical Threads inside one Durable Object,
-* built over `ctx.storage`. Durable accepted work is served by the separate SubmissionLedger
-* port; point both at the SAME `ctx.storage` so claims fence the same producer epochs
-* (ADR-0011 D7's "same file" rule, transposed to one object's private database).
-*/
-const layer = (options) => Layer.unwrap(Effect.map(DoStorageConfig, (config) => threadStoreLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(DoStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ storage: options.storage }), BrowserCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
-//#endregion
-export { threadStoreLayer as a, storageFailpointLayer as i, layer as n, decodeRows as o, storageConfigLayer as r, initializeDoJournal as s, DoThreadStore_exports as t };
+export { initializeDoJournal as a, decodeRows as i, RawCheckpoint as n, RawReadRequest as r, RawAppendRequest as t };
 
-//# sourceMappingURL=DoThreadStore-CCSgDto6.mjs.map
+//# sourceMappingURL=do-journal-Brv7xSH5.mjs.map