@effect-agent/storage-cloudflare 0.1.0-beta.45 → 0.1.0-beta.46

package/dist/DoThreadStore-D9ebIYPv.mjs

@@ -0,0 +1,1083 @@
+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-Bo4GU-pp.mjs";
+import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-do";
+import { Clock, Context, Crypto, Duration, Effect, Layer, Option, Ref, 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 { SqlError } from "effect/unstable/sql/SqlError";
+//#region src/internal/do-journal.ts
+/**
+* Static schema ceiling for stored text columns. Writes are bounded in BYTES by the
+* configured `maxStoredValueBytes` (always ≤ 2,000,000); UTF-8 byte length is never smaller
+* than UTF-16 string length, so any value that passed the byte bound also passes this
+* decode-side character ceiling.
+*/
+const BoundedStoredText = Schema.String.check(Schema.isMaxLength(2e6));
+const BoundedIdentifier = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
+const MAX_RECORDS_PER_THREAD = 65536;
+const MAX_IDENTIFIER_LENGTH = 1024;
+const isSqlError = Schema.is(SqlError);
+const storedTextBytes = (value) => new TextEncoder().encode(value).byteLength;
+const chunked = (values, size) => {
+	const chunks = [];
+	for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size));
+	return chunks;
+};
+var DoMetaRow = class extends Schema.Class("DoMetaRow")({ value: Schema.NonEmptyString.check(Schema.isMaxLength(128)) }) {};
+var DoNameRow = class extends Schema.Class("DoNameRow")({ name: BoundedIdentifier }) {};
+var ThreadRow = class extends Schema.Class("ThreadRow")({
+	thread_id: BoundedIdentifier,
+	created_at: Schema.NonEmptyString.check(Schema.isMaxLength(128)),
+	producer_epoch: ProducerEpoch,
+	tail_digest: BoundedStoredText,
+	tail_sequence: CanonicalSequence
+}) {};
+var BatchRow = class extends Schema.Class("BatchRow")({
+	batch_digest: BoundedStoredText,
+	batch_id: BoundedIdentifier,
+	batch_json: BoundedStoredText,
+	thread_id: BoundedIdentifier,
+	first_sequence: CanonicalSequence,
+	last_sequence: CanonicalSequence,
+	tail_digest: BoundedStoredText
+}) {};
+var RecordRow = class extends Schema.Class("RecordRow")({
+	batch_id: BoundedIdentifier,
+	thread_id: BoundedIdentifier,
+	record_id: BoundedIdentifier,
+	record_json: BoundedStoredText,
+	sequence: CanonicalSequence
+}) {};
+var CheckpointRow = class extends Schema.Class("CheckpointRow")({
+	checkpoint_json: BoundedStoredText,
+	thread_id: BoundedIdentifier,
+	tail_digest: BoundedStoredText,
+	through_sequence: CanonicalSequence
+}) {};
+var RawRecord = class extends Schema.Class("@effect-agent/storage-cloudflare/RawRecord")({
+	recordId: BoundedIdentifier,
+	recordJson: BoundedStoredText
+}) {};
+var RawAppendRequest = class extends Schema.Class("@effect-agent/storage-cloudflare/RawAppendRequest")({
+	batchDigest: BoundedStoredText,
+	batchId: BoundedIdentifier,
+	batchJson: BoundedStoredText,
+	threadId: BoundedIdentifier,
+	expectedTailDigest: BoundedStoredText,
+	expectedTailSequence: CanonicalSequence,
+	producerEpoch: ProducerEpoch,
+	records: Schema.NonEmptyArray(RawRecord).check(Schema.isMaxLength(256)),
+	tailDigest: BoundedStoredText
+}) {};
+var RawAppendResult = class extends Schema.Class("@effect-agent/storage-cloudflare/RawAppendResult")({
+	firstSequence: CanonicalSequence,
+	lastSequence: CanonicalSequence,
+	replayed: Schema.Boolean,
+	tailDigest: BoundedStoredText
+}) {};
+var RawReadRequest = class extends Schema.Class("@effect-agent/storage-cloudflare/RawReadRequest")({
+	threadId: BoundedIdentifier,
+	fromSequenceExclusive: CanonicalSequence,
+	limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024))
+}) {};
+var RawCheckpoint = class extends Schema.Class("@effect-agent/storage-cloudflare/RawCheckpoint")({
+	checkpointJson: BoundedStoredText,
+	threadId: BoundedIdentifier,
+	tailDigest: BoundedStoredText,
+	throughSequence: CanonicalSequence
+}) {};
+var RawThreadExport = class extends Schema.Class("@effect-agent/storage-cloudflare/RawThreadExport")({
+	batches: Schema.Array(BatchRow),
+	checkpoints: Schema.Array(CheckpointRow),
+	thread: ThreadRow,
+	records: Schema.Array(RecordRow)
+}) {};
+const noFailpoint = () => Effect.void;
+const storageError = (operation) => (error) => DoStorageError.make({
+	cause: error,
+	operation,
+	message: error.message
+});
+/** Decode raw Durable Object SQLite rows against a Schema, reporting failures as typed corruption. */
+const decodeRows = Effect.fn((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
+	table,
+	rowKey,
+	message: String(error)
+}))));
+/** Decode exactly one raw row against a Schema, reporting failures as typed corruption. */
+const decodeSingleRow = Effect.fn((schema, table, rowKey, rows) => decodeRows(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(DoStorageCorruptionError.make({
+	table,
+	rowKey,
+	message: `Expected exactly one row but found ${decoded.length}.`
+})))));
+const REQUIRED_TABLES = [
+	"effect_agent_abort_intents",
+	"effect_agent_approval_decisions",
+	"effect_agent_attempts",
+	"effect_agent_canonical_batches",
+	"effect_agent_canonical_records",
+	"effect_agent_checkpoints",
+	"effect_agent_child_reservations",
+	"effect_agent_child_settlements",
+	"effect_agent_threads",
+	"effect_agent_meta",
+	"effect_agent_settlement_reservations",
+	"effect_agent_submission_ownership",
+	"effect_agent_submissions",
+	"effect_agent_unknown_resolutions"
+];
+/**
+* Exact-or-fresh storage gate (DEPLOY-008) over `effect_agent_meta` instead of
+* `PRAGMA user_version` (unverified on Durable Object SQL storage; a meta table is portable
+* regardless). No WAL check (Durable Object storage owns durability and confirms writes
+* through output gates) and no busy timeout (a Durable Object has exactly one writer): the
+* Node machinery those served has no DC analogue and is deliberately absent.
+*/
+const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(function* (sql, failpoint = noFailpoint, maxStoredValueBytes) {
+	const metaTableRows = yield* sql`
+    SELECT name
+    FROM sqlite_master
+    WHERE type = 'table'
+      AND name = 'effect_agent_meta'
+  `.pipe(Effect.mapError(storageError("read storage version table")));
+	if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_meta", metaTableRows)).length === 0) {
+		const existingRows = yield* sql`
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'table'
+        AND name LIKE 'effect_agent_%'
+      ORDER BY name
+    `.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: 2,
+			message: "The Durable Object contains unversioned Effect Agent tables. Reset the development namespace explicitly; refusing to mutate ambiguous stored data."
+		});
+		yield* SqliteMigrator.run({ loader: doMigrations }).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.mapError((error) => DoStorageError.make({
+			cause: error,
+			operation: "initialize current storage",
+			message: error.message
+		})));
+	} else {
+		const versionRows = yield* sql`
+      SELECT value
+      FROM effect_agent_meta
+      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 !== String(2)) {
+			const actualVersion = Number.parseInt(version.value, 10);
+			return yield* DoStorageCompatibilityError.make({
+				actualVersion: Number.isSafeInteger(actualVersion) ? actualVersion : -1,
+				supportedVersion: 2,
+				message: `The Durable Object uses private-development storage version ${version.value}; this build supports exactly version 2. Replace the development namespace explicitly; automatic stored-data migrations are not provided during private development.`
+			});
+		}
+	}
+	const requiredRows = yield* sql`
+    SELECT name
+    FROM sqlite_master
+    WHERE type = 'table'
+      AND name IN ${sql.in([...REQUIRED_TABLES])}
+    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: 2,
+		supportedVersion: 2,
+		message: "The Durable Object claims the current format but is missing required tables. Reset the corrupt private-development data."
+	});
+	return makeJournal(sql, failpoint, maxStoredValueBytes);
+});
+const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
+	/** Typed pre-write refusal for any single value over the configured byte bound. */
+	const checkValueBound = (operation, value) => {
+		const actualBytes = storedTextBytes(value);
+		return actualBytes > maxStoredValueBytes ? Effect.fail(DoValueBoundExceeded.make({
+			actualBytes,
+			maxBytes: maxStoredValueBytes,
+			operation
+		})) : Effect.void;
+	};
+	/**
+	* Runs one journal write transaction on the Durable Object storage-backed
+	* `withTransaction` (`ctx.storage.transaction()` under the hood). Within one Durable
+	* Object there is exactly ONE writer, so the Node `BEGIN IMMEDIATE` + busy-retry +
+	* `SqliteWriteContention` machinery has no analogue here and is deliberately absent.
+	* Ownership-token and epoch checks still run INSIDE the transaction, so fencing atomicity
+	* (DUR-006) is preserved identically.
+	*
+	* Journal write transactions are always top level: the Durable Object client rejects
+	* nested transactions, so new journal operations must not wrap this helper inside another
+	* transaction.
+	*/
+	const withWriteTransaction = (operation) => (effect) => sql.withTransaction(effect).pipe(Effect.mapError((error) => isSqlError(error) ? storageError(operation)(error) : error), Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }));
+	const materialize = Effect.fn("DoJournal.materialize")(function* (threadId, createdAt, emptyTailDigest, producerEpoch) {
+		if (threadId.length > MAX_IDENTIFIER_LENGTH) return yield* DoStorageError.make({
+			operation: "materialize thread",
+			message: "Thread identity exceeds the Durable Object storage bounds."
+		});
+		yield* checkValueBound("materialize thread", emptyTailDigest);
+		yield* withWriteTransaction("materialize transaction")(Effect.gen(function* () {
+			const existingRows = yield* sql`
+          SELECT
+            thread_id,
+            created_at,
+            tail_sequence,
+            tail_digest,
+            producer_epoch
+          FROM effect_agent_threads
+          WHERE thread_id = ${threadId}
+        `.pipe(Effect.mapError(storageError("read materialized thread")));
+			const existing = yield* decodeRows(Schema.Array(ThreadRow), "effect_agent_threads", threadId, existingRows);
+			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
+				table: "effect_agent_threads",
+				rowKey: threadId,
+				message: "A thread primary key returned more than one row."
+			});
+			if (existing.length === 0) {
+				yield* sql`
+            INSERT INTO effect_agent_threads (
+              thread_id,
+              created_at,
+              tail_sequence,
+              tail_digest,
+              producer_epoch
+            ) VALUES (
+              ${threadId},
+              ${createdAt},
+              0,
+              ${emptyTailDigest},
+              ${producerEpoch}
+            )
+          `.pipe(Effect.mapError(storageError("materialize thread")));
+				return;
+			}
+			if (producerEpoch < existing[0].producer_epoch) return yield* DoFenceRejected.make({
+				producerEpoch,
+				actualEpoch: existing[0].producer_epoch,
+				message: `Producer epoch ${producerEpoch} is stale; current epoch is ${existing[0].producer_epoch}.`
+			});
+			if (producerEpoch > existing[0].producer_epoch) yield* sql`
+            UPDATE effect_agent_threads
+            SET producer_epoch = ${producerEpoch}
+            WHERE thread_id = ${threadId}
+          `.pipe(Effect.mapError(storageError("advance materialization epoch")));
+		}));
+	});
+	const getThread = Effect.fn("DoJournal.getThread")(function* (threadId) {
+		const rows = yield* sql`
+      SELECT
+        thread_id,
+        created_at,
+        tail_sequence,
+        tail_digest,
+        producer_epoch
+      FROM effect_agent_threads
+      WHERE thread_id = ${threadId}
+    `.pipe(Effect.mapError(storageError("read thread")));
+		return yield* decodeRows(Schema.Array(ThreadRow), "effect_agent_threads", threadId, rows);
+	});
+	const append = Effect.fn("DoJournal.append")(function* (request) {
+		if (request.threadId.length > MAX_IDENTIFIER_LENGTH || request.batchId.length > MAX_IDENTIFIER_LENGTH || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH)) return yield* DoStorageError.make({
+			operation: "append canonical batch",
+			message: "Canonical identifiers exceed the Durable Object storage bounds."
+		});
+		yield* checkValueBound("append canonical batch", request.batchJson);
+		yield* checkValueBound("append canonical batch", request.batchDigest);
+		yield* checkValueBound("append canonical batch", request.tailDigest);
+		yield* Effect.forEach(request.records, (record) => checkValueBound("append canonical record", record.recordJson), { discard: true });
+		return yield* withWriteTransaction("append transaction")(Effect.gen(function* () {
+			const recordIds = request.records.map((record) => record.recordId);
+			if (new Set(recordIds).size !== recordIds.length) return yield* DoAppendConflict.make({
+				message: `Batch ${request.batchId} contains duplicate canonical record IDs.`,
+				reason: "record-identity"
+			});
+			const threadRows = yield* sql`
+          SELECT
+            thread_id,
+            created_at,
+            tail_sequence,
+            tail_digest,
+            producer_epoch
+          FROM effect_agent_threads
+          WHERE thread_id = ${request.threadId}
+        `.pipe(Effect.mapError(storageError("read append tail")));
+			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", request.threadId, threadRows);
+			if (request.producerEpoch !== thread.producer_epoch) return yield* DoFenceRejected.make({
+				producerEpoch: request.producerEpoch,
+				actualEpoch: thread.producer_epoch,
+				message: `Producer epoch ${request.producerEpoch} is not the current epoch ${thread.producer_epoch}.`
+			});
+			const batchRows = yield* sql`
+          SELECT
+            thread_id,
+            batch_id,
+            first_sequence,
+            last_sequence,
+            batch_digest,
+            tail_digest,
+            batch_json
+          FROM effect_agent_canonical_batches
+          WHERE thread_id = ${request.threadId}
+            AND batch_id = ${request.batchId}
+        `.pipe(Effect.mapError(storageError("read idempotent batch")));
+			const batches = yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.threadId}/${request.batchId}`, batchRows);
+			if (batches.length > 1) return yield* DoStorageCorruptionError.make({
+				table: "effect_agent_canonical_batches",
+				rowKey: `${request.threadId}/${request.batchId}`,
+				message: "A canonical batch primary key returned more than one row."
+			});
+			if (batches.length === 1) {
+				const existing = batches[0];
+				if (existing.batch_digest !== request.batchDigest) return yield* DoAppendConflict.make({
+					message: `Batch ${request.batchId} already exists with different canonical content.`,
+					reason: "batch-digest"
+				});
+				return RawAppendResult.make({
+					firstSequence: existing.first_sequence,
+					lastSequence: existing.last_sequence,
+					replayed: true,
+					tailDigest: existing.tail_digest
+				});
+			}
+			if (request.expectedTailSequence !== thread.tail_sequence || request.expectedTailDigest !== thread.tail_digest) return yield* DoAppendConflict.make({
+				message: `Expected tail ${request.expectedTailSequence}/${request.expectedTailDigest} but found ${thread.tail_sequence}/${thread.tail_digest}.`,
+				reason: "tail",
+				actualTailSequence: thread.tail_sequence,
+				actualTailDigest: thread.tail_digest
+			});
+			if (thread.tail_sequence + request.records.length > MAX_RECORDS_PER_THREAD) return yield* DoStorageError.make({
+				operation: "append canonical batch",
+				message: `Thread record limit ${MAX_RECORDS_PER_THREAD} would be exceeded.`
+			});
+			const existingRecords = [];
+			for (const chunk of chunked(recordIds, 90)) {
+				const existingRecordRows = yield* sql`
+            SELECT
+              thread_id,
+              sequence,
+              record_id,
+              batch_id,
+              record_json
+            FROM effect_agent_canonical_records
+            WHERE thread_id = ${request.threadId}
+              AND record_id IN ${sql.in([...chunk])}
+            ORDER BY sequence
+          `.pipe(Effect.mapError(storageError("check canonical record identities")));
+				existingRecords.push(...yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}/record_ids`, existingRecordRows));
+			}
+			if (existingRecords.length > 0) return yield* DoAppendConflict.make({
+				message: `Canonical record ID ${existingRecords[0].record_id} already exists.`,
+				reason: "record-identity"
+			});
+			const firstSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(thread.tail_sequence + 1).pipe(Effect.mapError((error) => DoStorageError.make({
+				cause: error,
+				operation: "append canonical batch",
+				message: error.message
+			})));
+			const lastSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(firstSequence + request.records.length - 1).pipe(Effect.mapError((error) => DoStorageError.make({
+				cause: error,
+				operation: "append canonical batch",
+				message: error.message
+			})));
+			yield* sql`
+          INSERT INTO effect_agent_canonical_batches (
+            thread_id,
+            batch_id,
+            first_sequence,
+            last_sequence,
+            batch_digest,
+            tail_digest,
+            batch_json
+          ) VALUES (
+            ${request.threadId},
+            ${request.batchId},
+            ${firstSequence},
+            ${lastSequence},
+            ${request.batchDigest},
+            ${request.tailDigest},
+            ${request.batchJson}
+          )
+        `.pipe(Effect.mapError(storageError("insert canonical batch")));
+			yield* failpoint("append:after-batch-insert");
+			yield* Effect.forEach(request.records, (record, index) => Effect.gen(function* () {
+				yield* sql`
+                  INSERT INTO effect_agent_canonical_records (
+                    thread_id,
+                    sequence,
+                    record_id,
+                    batch_id,
+                    record_json
+                  ) VALUES (
+                    ${request.threadId},
+                    ${firstSequence + index},
+                    ${record.recordId},
+                    ${request.batchId},
+                    ${record.recordJson}
+                  )
+                `.pipe(Effect.mapError(storageError("insert canonical record")));
+				yield* failpoint("append:after-record-insert");
+			}), { discard: true });
+			yield* sql`
+          UPDATE effect_agent_threads
+          SET
+            tail_sequence = ${lastSequence},
+            tail_digest = ${request.tailDigest},
+            producer_epoch = ${request.producerEpoch}
+          WHERE thread_id = ${request.threadId}
+        `.pipe(Effect.mapError(storageError("advance thread tail")));
+			yield* failpoint("append:after-tail-update");
+			return RawAppendResult.make({
+				firstSequence,
+				lastSequence,
+				replayed: false,
+				tailDigest: request.tailDigest
+			});
+		}));
+	});
+	const read = Effect.fn("DoJournal.read")(function* (request) {
+		const rows = yield* sql`
+      SELECT
+        thread_id,
+        sequence,
+        record_id,
+        batch_id,
+        record_json
+      FROM effect_agent_canonical_records
+      WHERE thread_id = ${request.threadId}
+        AND sequence > ${request.fromSequenceExclusive}
+      ORDER BY sequence
+      LIMIT ${request.limit}
+    `.pipe(Effect.mapError(storageError("read canonical records")));
+		return yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}>${request.fromSequenceExclusive}`, rows);
+	});
+	const exportThread = Effect.fn("DoJournal.exportThread")(function* (threadId) {
+		return yield* sql.withTransaction(Effect.gen(function* () {
+			const threadRows = yield* sql`
+            SELECT
+              thread_id,
+              created_at,
+              tail_sequence,
+              tail_digest,
+              producer_epoch
+            FROM effect_agent_threads
+            WHERE thread_id = ${threadId}
+          `.pipe(Effect.mapError(storageError("export thread")));
+			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", threadId, threadRows);
+			yield* failpoint("export:after-thread-read");
+			const batchRows = yield* sql`
+            SELECT
+              thread_id,
+              batch_id,
+              first_sequence,
+              last_sequence,
+              batch_digest,
+              tail_digest,
+              batch_json
+            FROM effect_agent_canonical_batches
+            WHERE thread_id = ${threadId}
+            ORDER BY first_sequence
+          `.pipe(Effect.mapError(storageError("export canonical batches")));
+			const recordRows = yield* sql`
+            SELECT
+              thread_id,
+              sequence,
+              record_id,
+              batch_id,
+              record_json
+            FROM effect_agent_canonical_records
+            WHERE thread_id = ${threadId}
+            ORDER BY sequence
+          `.pipe(Effect.mapError(storageError("export canonical records")));
+			const checkpointRows = yield* sql`
+            SELECT
+              thread_id,
+              through_sequence,
+              tail_digest,
+              checkpoint_json
+            FROM effect_agent_checkpoints
+            WHERE thread_id = ${threadId}
+            ORDER BY through_sequence
+          `.pipe(Effect.mapError(storageError("export checkpoints")));
+			return RawThreadExport.make({
+				thread,
+				batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", threadId, batchRows),
+				records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", threadId, recordRows),
+				checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", threadId, checkpointRows)
+			});
+		})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("export transaction")(error))));
+	});
+	const saveCheckpoint = Effect.fn("DoJournal.saveCheckpoint")(function* (checkpoint) {
+		if (checkpoint.threadId.length > MAX_IDENTIFIER_LENGTH) return yield* DoStorageError.make({
+			operation: "save checkpoint",
+			message: "Checkpoint identity exceeds the Durable Object storage bounds."
+		});
+		yield* checkValueBound("save checkpoint", checkpoint.checkpointJson);
+		yield* withWriteTransaction("checkpoint transaction")(Effect.gen(function* () {
+			const threadRows = yield* sql`
+          SELECT
+            thread_id,
+            created_at,
+            tail_sequence,
+            tail_digest,
+            producer_epoch
+          FROM effect_agent_threads
+          WHERE thread_id = ${checkpoint.threadId}
+        `.pipe(Effect.mapError(storageError("read checkpoint tail")));
+			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", checkpoint.threadId, threadRows);
+			if (checkpoint.throughSequence > thread.tail_sequence) return yield* DoCheckpointConflict.make({ message: `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ${thread.tail_sequence}.` });
+			const checkpointRows = yield* sql`
+          SELECT
+            thread_id,
+            through_sequence,
+            tail_digest,
+            checkpoint_json
+          FROM effect_agent_checkpoints
+          WHERE thread_id = ${checkpoint.threadId}
+            AND through_sequence = ${checkpoint.throughSequence}
+        `.pipe(Effect.mapError(storageError("read idempotent checkpoint")));
+			const existing = yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.threadId}/${checkpoint.throughSequence}`, checkpointRows);
+			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
+				table: "effect_agent_checkpoints",
+				rowKey: `${checkpoint.threadId}/${checkpoint.throughSequence}`,
+				message: "A checkpoint primary key returned more than one row."
+			});
+			if (existing.length === 1) {
+				if (existing[0].tail_digest !== checkpoint.tailDigest || existing[0].checkpoint_json !== checkpoint.checkpointJson) return yield* DoCheckpointConflict.make({ message: "A different checkpoint already exists at this canonical sequence." });
+				return;
+			}
+			yield* sql`
+          INSERT INTO effect_agent_checkpoints (
+            thread_id,
+            through_sequence,
+            tail_digest,
+            checkpoint_json
+          ) VALUES (
+            ${checkpoint.threadId},
+            ${checkpoint.throughSequence},
+            ${checkpoint.tailDigest},
+            ${checkpoint.checkpointJson}
+          )
+        `.pipe(Effect.mapError(storageError("insert checkpoint")));
+		}));
+	});
+	const loadCheckpoint = Effect.fn("DoJournal.loadCheckpoint")(function* (threadId, atOrBeforeSequence) {
+		const rows = yield* sql`
+      SELECT
+        thread_id,
+        through_sequence,
+        tail_digest,
+        checkpoint_json
+      FROM effect_agent_checkpoints
+      WHERE thread_id = ${threadId}
+        AND through_sequence <= ${atOrBeforeSequence}
+      ORDER BY through_sequence DESC
+      LIMIT 1
+    `.pipe(Effect.mapError(storageError("load checkpoint")));
+		return yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${threadId}<=${atOrBeforeSequence}`, rows);
+	});
+	return {
+		append,
+		checkValueBound,
+		exportThread,
+		getThread,
+		getTailDigestAt: Effect.fn("DoJournal.getTailDigestAt")(function* (threadId, sequence) {
+			if (sequence === 0) {
+				const threads = yield* getThread(threadId);
+				return threads.length === 0 ? [] : [threads[0].tail_sequence === 0 ? threads[0].tail_digest : void 0].filter((value) => value !== void 0);
+			}
+			const rows = yield* sql`
+      SELECT
+        thread_id,
+        batch_id,
+        first_sequence,
+        last_sequence,
+        batch_digest,
+        tail_digest,
+        batch_json
+      FROM effect_agent_canonical_batches
+      WHERE thread_id = ${threadId}
+        AND last_sequence = ${sequence}
+    `.pipe(Effect.mapError(storageError("read canonical digest at sequence")));
+			return (yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${threadId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
+		}),
+		loadCheckpoint,
+		materialize,
+		read,
+		saveCheckpoint,
+		scanStoredPayloads: Effect.fn("DoJournal.scanStoredPayloads")(function* () {
+			return yield* sql.withTransaction(Effect.gen(function* () {
+				const threads = yield* sql`
+            SELECT
+              thread_id,
+              created_at,
+              tail_sequence,
+              tail_digest,
+              producer_epoch
+            FROM effect_agent_threads
+            ORDER BY thread_id
+          `.pipe(Effect.mapError(storageError("scan threads")));
+				const batches = yield* sql`
+            SELECT
+              thread_id,
+              batch_id,
+              first_sequence,
+              last_sequence,
+              batch_digest,
+              tail_digest,
+              batch_json
+            FROM effect_agent_canonical_batches
+            ORDER BY thread_id, first_sequence
+          `.pipe(Effect.mapError(storageError("scan canonical batches")));
+				const records = yield* sql`
+            SELECT
+              thread_id,
+              sequence,
+              record_id,
+              batch_id,
+              record_json
+            FROM effect_agent_canonical_records
+            ORDER BY thread_id, sequence
+          `.pipe(Effect.mapError(storageError("scan canonical records")));
+				const checkpoints = yield* sql`
+            SELECT
+              thread_id,
+              through_sequence,
+              tail_digest,
+              checkpoint_json
+            FROM effect_agent_checkpoints
+            ORDER BY thread_id, through_sequence
+          `.pipe(Effect.mapError(storageError("scan checkpoints")));
+				return {
+					threads: yield* decodeRows(Schema.Array(ThreadRow), "effect_agent_threads", "startup_scan", threads),
+					batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
+					records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
+					checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
+				};
+			})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("startup scan transaction")(error))));
+		}),
+		withWriteTransaction
+	};
+};
+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 rows = yield* journal.read(request).pipe(Effect.mapError((error) => storeError("read canonical records", error)));
+		return yield* Effect.forEach(rows, 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);
+		const records = yield* loadRecords(RawReadRequest.make({
+			threadId: validated.threadId,
+			fromSequenceExclusive: validated.afterSequence ?? ZERO_CANONICAL_SEQUENCE,
+			limit: validated.limit
+		}));
+		return Stream.fromIterable(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 records = yield* loadRecords(RawReadRequest.make({
+				threadId: validated.threadId,
+				fromSequenceExclusive,
+				limit: 1024
+			}));
+			if (records.length === 0) {
+				yield* Effect.sleep(config.observationPollInterval);
+				return [];
+			}
+			yield* Ref.set(cursor, records[records.length - 1].sequence);
+			return records;
+		});
+		return Stream.fromIterableEffectRepeat(poll());
+	});
+	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 checkpoint = yield* decodeCheckpoint(rows[0].checkpoint_json);
+		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 };
+
+//# sourceMappingURL=DoThreadStore-D9ebIYPv.mjs.map