@yielded/agent-storage-cloudflare 0.1.0-beta.166 → 0.1.0-beta.168

package/dist/do-journal-Cawnsetj.mjs

@@ -0,0 +1,761 @@
+import { DoAppendConflict, DoCheckpointConflict, DoStorageCorruptionError, DoStorageError, DoValueBoundExceeded } from "./DoStorageError.mjs";
+import { n as ensureDoStorageLayout } from "./migrations-D_EP3KYf.mjs";
+import { n as ownedRows, r as ownedState } from "./owned-state-BHzUi0eb.mjs";
+import { SqlLifecycleRetainer, SqlLifecycleSource, makeSqlLifecyclePublication } from "@yielded/agent-storage-sql/sql-lifecycle-publication";
+import { SqlStorageOwner } from "@yielded/agent/sql-memory-store";
+import { Cause, Clock, Effect, Option, Predicate, Result, Schema, Stream } from "effect";
+import * as SqlClient$1 from "effect/sql/SqlClient";
+import { makeCanonicalStorage, recordBatchId } from "@yielded/agent-storage-sql/sql-canonical-storage";
+import { makeSqlExecutions } from "@yielded/agent-storage-sql/sql-journal";
+import { SqlStorageProgress } from "@yielded/agent-storage-sql/sql-storage-progress";
+import { canonicalRecordJson, makeSqlThreadArchiveRange } from "@yielded/agent-storage-sql/sql-thread-archive-range";
+import { makeProgressAppendValidation } from "@yielded/agent-storage-sql/sql-thread-native-reads";
+import { makeSqlThreadWork } from "@yielded/agent-storage-sql/sql-thread-work";
+import { ThreadId } from "@yielded/agent/identifiers";
+import { LifecyclePublicationError, LifecyclePublicationFact } from "@yielded/agent/lifecycle-publication";
+import { CanonicalRecord, CanonicalSequence } from "@yielded/agent/records";
+import { ThreadStoreDiagnostic, ThreadStoreError } from "@yielded/agent/thread-store";
+import { SqlError } from "effect/sql/SqlError";
+//#region src/internal/storage-span.ts
+const isAppendContention = (error) => (error._tag === "DoAppendConflict" || error._tag === "AppendConflict") && error.reason === "tail";
+/** Expected refusals remain typed at the port, but are outcomes of the storage operation. */
+const storageResult = (effect, expected) => effect.pipe(Effect.map(Result.succeed), Effect.catchIf(expected, (error) => Effect.succeed(Result.fail(error))));
+/** Only error discriminants enter telemetry; messages, SQL, identities and payloads do not. */
+const annotateStorageError = (error) => Effect.annotateCurrentSpan({
+	"error.type": error._tag,
+	...Predicate.hasProperty(error, "cause") && Predicate.hasProperty(error.cause, "_tag") && typeof error.cause._tag === "string" ? { "error.cause.type": error.cause._tag } : {}
+});
+const withStorageSpan = (name, expected = () => false) => (effect) => storageResult(effect, expected).pipe(Effect.tap((result) => Result.isFailure(result) ? Effect.annotateCurrentSpan({ "storage.outcome": result.failure._tag }) : Effect.void), Effect.tapError(annotateStorageError), Effect.withSpan(name), Effect.flatMap(Effect.fromResult));
+//#endregion
+//#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_IDENTIFIER_LENGTH = 1024;
+const MAX_READ_PAGE_JSON_BYTES = 4194304;
+const MAX_RECORD_CACHE_JSON_BYTES = 8388608;
+const MAX_RECORD_CACHE_ENTRIES = 4096;
+/** Durable Object SQL storage allows at most 100 bound parameters per statement. */
+const MAX_BOUND_PARAMETERS = 100;
+const isSqlError$1 = 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 ThreadRow = class extends Schema.Class("ThreadRow")({
+	thread_id: BoundedIdentifier,
+	created_at: Schema.NullOr(Schema.NonEmptyString.check(Schema.isMaxLength(128))),
+	tail_sequence: CanonicalSequence
+}) {};
+const threadRows = ownedRows(ThreadRow, "effect_agent_threads", (row) => row.thread_id, "thread_id");
+var RecordRow = class extends Schema.Class("RecordRow")({
+	batch_id: Schema.fromJsonString(BoundedIdentifier),
+	thread_id: BoundedIdentifier,
+	record_id: Schema.fromJsonString(BoundedIdentifier),
+	record_json: BoundedStoredText,
+	sequence: CanonicalSequence
+}) {};
+const isolateRecords = /* @__PURE__ */ new Map();
+let isolateRecordBytes = 0;
+const releaseRecord = (entry) => {
+	if (!isolateRecords.delete(entry)) return;
+	isolateRecordBytes -= entry.bytes;
+	entry.evict();
+};
+const recordCaches = /* @__PURE__ */ new WeakMap();
+const makeRecordCache = () => {
+	const records = /* @__PURE__ */ new Map();
+	const key = (thread, sequence) => JSON.stringify([thread, sequence]);
+	return {
+		clear: () => {
+			for (const entry of records.values()) releaseRecord(entry);
+		},
+		get: (thread, sequence) => records.get(key(thread, sequence))?.row,
+		prefix: (thread, through) => {
+			const prefix = [];
+			for (let sequence = 1; sequence <= through; sequence++) {
+				const row = records.get(key(thread, sequence));
+				if (row === void 0) return void 0;
+				prefix.push(row.row);
+			}
+			return prefix;
+		},
+		put: (row, capturedBytes) => {
+			const id = key(row.thread_id, row.sequence);
+			const prior = records.get(id);
+			if (prior?.row === row) return;
+			const size = capturedBytes ?? storedTextBytes(row.record_json);
+			if (prior !== void 0) releaseRecord(prior);
+			const entry = {
+				row,
+				bytes: size,
+				evict: () => records.delete(id)
+			};
+			records.set(id, entry);
+			isolateRecords.set(entry, true);
+			isolateRecordBytes += size;
+			while (isolateRecordBytes > MAX_RECORD_CACHE_JSON_BYTES || isolateRecords.size > MAX_RECORD_CACHE_ENTRIES) {
+				const oldest = isolateRecords.keys().next().value;
+				if (oldest === void 0) break;
+				releaseRecord(oldest);
+			}
+		}
+	};
+};
+const ReadPlanRow = Schema.Struct({
+	sequence: CanonicalSequence,
+	record_json_bytes: Schema.Natural.check(Schema.isLessThanOrEqualTo(MAX_READ_PAGE_JSON_BYTES))
+});
+var CheckpointRow = class extends Schema.Class("CheckpointRow")({
+	checkpoint_json: BoundedStoredText,
+	thread_id: BoundedIdentifier,
+	through_sequence: CanonicalSequence
+}) {};
+const LifecycleCursorRow = Schema.Struct({
+	thread_id: BoundedIdentifier,
+	through_sequence: CanonicalSequence
+});
+const lifecycleCursorRows = ownedRows(LifecycleCursorRow, "effect_agent_lifecycle_cursors", (row) => row.thread_id, "thread_id");
+const initializedLifecycleSources = /* @__PURE__ */ new WeakSet();
+var RawAppendResult = class extends Schema.Class("@effect-agent/storage-cloudflare/RawAppendResult")({
+	firstSequence: CanonicalSequence,
+	lastSequence: CanonicalSequence,
+	replayed: Schema.Boolean
+}) {};
+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,
+	throughSequence: CanonicalSequence
+}) {};
+const noFailpoint = () => Effect.void;
+const storageError = (operation) => (error) => DoStorageError.make({
+	cause: error,
+	operation,
+	message: error.message,
+	diagnostic: ThreadStoreDiagnostic.make({
+		causeTag: error._tag,
+		operation,
+		issueTag: error.reason._tag
+	})
+});
+/** Decode raw Durable Object SQLite rows against a Schema, reporting failures as typed corruption. */
+const decodeRows = (schema, table, rowKey, rows, decoder = table) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
+	table,
+	rowKey,
+	message: "Stored rows do not satisfy the storage schema",
+	diagnostic: ThreadStoreDiagnostic.make({
+		causeTag: error._tag,
+		operation: "decode storage rows",
+		decoder,
+		issueTag: error.issue._tag
+	})
+})), Effect.tapError((error) => Effect.annotateCurrentSpan({
+	"storage.failure.operation": error.diagnostic?.operation,
+	"storage.failure.cause": error.diagnostic?.causeTag,
+	"storage.failure.decoder": decoder,
+	"storage.failure.issue": error.diagnostic?.issueTag
+})));
+/** Decode exactly one raw row against a Schema, reporting failures as typed corruption. */
+const decodeSingleRow = (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}.`
+}))));
+/** Open a validated layout and bind this Object's storage owner. */
+const ensureCurrentStorage = Effect.fnUntraced(function* (sql, failpoint = noFailpoint, maxStoredValueBytes) {
+	yield* ensureDoStorageLayout().pipe(Effect.provideService(SqlClient$1.SqlClient, sql));
+	const state = yield* ownedState(sql);
+	const owner = (yield* SqlStorageOwner) ?? state;
+	let journal;
+	const lifecycle = yield* makeSqlLifecyclePublication(void 0, maxStoredValueBytes).pipe(Effect.provideService(SqlStorageOwner, owner), Effect.provideService(SqlLifecycleSource, {
+		beforeRetain: (threadId) => Effect.suspend(() => journal === void 0 ? Effect.fail(LifecyclePublicationError.make({ reason: "unavailable" })) : journal.flushCanonical(threadId)),
+		beforePending: Effect.suspend(() => journal === void 0 ? Effect.fail(LifecyclePublicationError.make({ reason: "unavailable" })) : journal.flushPublications())
+	}), Effect.provideService(SqlClient$1.SqlClient, sql), Effect.mapError((cause) => DoStorageError.make({
+		operation: "initialize lifecycle publication",
+		message: "Native publication storage unavailable",
+		cause
+	})));
+	journal = yield* makeJournal(sql, failpoint, maxStoredValueBytes, lifecycle, state).pipe(Effect.provideService(SqlStorageOwner, owner));
+	if (lifecycle !== void 0) yield* journal.initializeLifecycleSource();
+	return journal;
+});
+const makeJournal = (sql, failpoint, maxStoredValueBytes, lifecycle, state) => Effect.gen(function* () {
+	const owner = (yield* SqlStorageOwner) ?? state;
+	const progress = yield* SqlStorageProgress;
+	const work = yield* makeSqlThreadWork({
+		read: (body) => state.read(body),
+		write: (body) => owner.transaction(body.pipe(Effect.tap(() => state.invalidate))).pipe(Effect.provideService(SqlClient$1.SqlClient, sql), Effect.catchTag("SqlError", (cause) => ThreadStoreError.make({
+			operation: "rebuild Thread work",
+			message: "Thread work transaction failed",
+			cause
+		})))
+	}).pipe(Effect.provideService(SqlClient$1.SqlClient, sql));
+	yield* Effect.acquireRelease(Effect.sync(() => state.invalidators.add(work.invalidate)), () => Effect.sync(() => state.invalidators.delete(work.invalidate)));
+	const workFailure = (cause) => DoStorageError.make({
+		operation: "publish Thread work",
+		message: "Canonical work metadata could not be published",
+		cause
+	});
+	const validateProgress = yield* makeProgressAppendValidation().pipe(Effect.provideService(SqlClient$1.SqlClient, sql));
+	const executions = yield* makeSqlExecutions().pipe(Effect.provideService(SqlClient$1.SqlClient, sql));
+	const executionConflict = (effect) => effect.pipe(Effect.catchTag("AppendConflict", (error) => Effect.fail(DoAppendConflict.make({
+		reason: error.reason,
+		message: "Active execution conflicts with the captured commit",
+		...error.actualTailSequence === void 0 ? {} : { actualTailSequence: error.actualTailSequence }
+	}))));
+	const threads = threadRows(state, sql);
+	const cursors = lifecycleCursorRows(state, sql);
+	let records = recordCaches.get(state);
+	if (records === void 0) {
+		records = makeRecordCache();
+		recordCaches.set(state, records);
+		state.invalidators.add(records.clear);
+	}
+	const recordCache = records;
+	const archives = yield* makeSqlThreadArchiveRange({
+		read: (body) => state.read(body),
+		write: (body) => owner.transaction(body.pipe(Effect.tap(() => state.invalidate))).pipe(Effect.provideService(SqlClient$1.SqlClient, sql), Effect.catchTag("SqlError", (cause) => ThreadStoreError.make({
+			operation: "archive write",
+			message: "Archive transaction failed.",
+			cause
+		})))
+	}).pipe(Effect.provideService(SqlClient$1.SqlClient, sql));
+	const recordJson = canonicalRecordJson(sql);
+	const physical = yield* makeCanonicalStorage().pipe(Effect.provideService(SqlClient$1.SqlClient, sql));
+	/** Typed pre-write refusal for any single value over the configured byte bound. */
+	const checkValueBound = (operation, value, 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.
+	* The shared local owner gate covers the transaction and acknowledgement.
+	*
+	* 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. Expected outcomes may be captured only when every such refusal precedes
+	* mutation; real faults still roll back. Successful preflight reads never authorize a write.
+	*/
+	const withWriteTransaction = (operation, expected = () => false) => (effect) => state.owner.withMutation(owner.transaction(storageResult(effect, expected))).pipe(Effect.provideService(SqlClient$1.SqlClient, sql), Effect.mapError((error) => isSqlError$1(error) ? storageError(operation)(error) : error), Effect.tapError(annotateStorageError), Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }), Effect.flatMap(Effect.fromResult));
+	const materialize = Effect.fnUntraced(function* (threadId, createdAt) {
+		if (threadId.length > MAX_IDENTIFIER_LENGTH) return yield* DoStorageError.make({
+			operation: "materialize thread",
+			message: "Thread identity exceeds the Durable Object storage bounds."
+		});
+		if ((yield* getThread(threadId)).length === 1) return;
+		yield* withWriteTransaction("materialize transaction")(Effect.gen(function* () {
+			const existingRows = yield* getThread(threadId);
+			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
+            ) VALUES (
+              ${threadId},
+              ${createdAt},
+              0
+            ) ON CONFLICT(thread_id) DO UPDATE SET created_at=excluded.created_at
+              WHERE effect_agent_threads.created_at IS NULL
+           RETURNING *`.pipe(threads.write, Effect.mapError((error) => error._tag === "SqlError" ? storageError("materialize thread")(error) : error));
+				if (lifecycle !== void 0) yield* sql`INSERT INTO effect_agent_lifecycle_cursors (thread_id, through_sequence)
+              VALUES (${threadId}, 0) RETURNING *`.pipe(cursors.write, Effect.mapError((error) => error._tag === "SqlError" ? storageError("initialize lifecycle source")(error) : error));
+				return;
+			}
+		}));
+	}, withStorageSpan("DoJournal.materialize"));
+	const getThread = Effect.fnUntraced(function* (threadId) {
+		return (yield* threads.by("thread_id", threadId).pipe(Effect.mapError((error) => error._tag === "SqlError" ? storageError("read thread")(error) : error))).filter((row) => row.thread_id === threadId && row.created_at !== null);
+	});
+	const hasRecord = Effect.fnUntraced(function* (threadId, recordId) {
+		const thread = (yield* getThread(threadId))[0];
+		const prefix = recordCache.prefix(threadId, thread?.tail_sequence ?? 0);
+		if (prefix !== void 0) return prefix.some((row) => row.record_id === recordId);
+		return (yield* sql`SELECT record_id FROM effect_agent_canonical_records
+      WHERE thread_id = ${threadId} AND record_id = ${JSON.stringify(recordId)}`.pipe(Effect.mapError(storageError("read canonical record identity")))).length > 0;
+	});
+	const prepareAppend = Effect.fnUntraced(function* (request) {
+		if (request.threadId.length > MAX_IDENTIFIER_LENGTH || request.batchId.length > MAX_IDENTIFIER_LENGTH || request.executionWrites.some(({ update }) => update.checkpoint.progress.runId.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, request.batchBytes);
+		for (const record of request.records) if (record.recordBytes > maxStoredValueBytes) return yield* DoValueBoundExceeded.make({
+			actualBytes: record.recordBytes,
+			maxBytes: maxStoredValueBytes,
+			operation: "append canonical record"
+		});
+		for (const write of request.executionWrites) yield* checkValueBound("commit active execution", write.json, write.bytes);
+		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"
+		});
+		return request;
+	});
+	const appendPrepared = Effect.fnUntraced(function* (request) {
+		const recordIds = request.records.map((record) => record.recordId);
+		const threadRows = yield* getThread(request.threadId);
+		const thread = threadRows.length === 1 ? threadRows[0] : void 0;
+		if (thread === void 0) return yield* DoStorageCorruptionError.make({
+			table: "effect_agent_threads",
+			rowKey: request.threadId,
+			message: `Expected exactly one row but found ${threadRows.length}.`
+		});
+		const prefix = recordCache.prefix(request.threadId, thread.tail_sequence);
+		const replay = yield* executionConflict(executions.replay(request));
+		if (replay !== void 0) return RawAppendResult.make(replay);
+		const existing = prefix !== void 0 && !prefix.some((row) => row.batch_id === request.batchId) ? void 0 : yield* archives.replay(request.threadId, request.batchId);
+		if (existing !== void 0) {
+			if (existing.batch_json !== request.batchJson) return yield* DoAppendConflict.make({
+				message: `Batch ${request.batchId} already exists with different canonical content.`,
+				reason: "batch-content"
+			});
+			return RawAppendResult.make({
+				firstSequence: existing.first_sequence,
+				lastSequence: existing.last_sequence,
+				replayed: true
+			});
+		}
+		yield* executionConflict(executions.rejectSuperseded(request));
+		if (request.expectedTailSequence !== thread.tail_sequence) return yield* DoAppendConflict.make({
+			message: `Expected tail ${request.expectedTailSequence} but found ${thread.tail_sequence}.`,
+			reason: "tail",
+			actualTailSequence: thread.tail_sequence
+		});
+		const existingRecords = prefix === void 0 ? [] : prefix.filter((row) => recordIds.includes(row.record_id));
+		for (const chunk of prefix === void 0 ? chunked(recordIds, 90) : []) {
+			const existingRecordRows = yield* sql`
+            SELECT
+              thread_id,
+              sequence,
+              record_id,
+              ${recordBatchId(sql)} AS batch_id,
+              ${recordJson} AS record_json
+            FROM effect_agent_canonical_records
+            WHERE thread_id = ${request.threadId}
+              AND record_id IN ${sql.in(chunk.map((id) => JSON.stringify(id)))}
+          `.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.decodeEffect(CanonicalSequence)(thread.tail_sequence + (request.records.length === 0 ? 0 : 1)).pipe(Effect.mapError((error) => DoStorageError.make({
+			cause: error,
+			operation: "append canonical batch",
+			message: error.message
+		})));
+		const lastSequence = yield* Schema.decodeEffect(CanonicalSequence)(thread.tail_sequence + request.records.length).pipe(Effect.mapError((error) => DoStorageError.make({
+			cause: error,
+			operation: "append canonical batch",
+			message: error.message
+		})));
+		yield* executionConflict(executions.validate(request));
+		yield* validateProgress(request);
+		const result = RawAppendResult.make({
+			firstSequence,
+			lastSequence,
+			replayed: false
+		});
+		if (request.records.length > 0) yield* sql`
+          INSERT INTO effect_agent_canonical_batches (
+            thread_id,
+            batch_id,
+            first_sequence,
+            last_sequence,
+            producer_id_json
+          ) VALUES (
+            ${request.threadId},
+            ${JSON.stringify(request.batchId)},
+            ${firstSequence},
+            ${lastSequence},
+            ${request.producerIdJson}
+          )
+        `.pipe(Effect.mapError(storageError("insert canonical batch")));
+		yield* failpoint("append:after-batch-insert");
+		const records = (yield* physical.records(request.threadId, firstSequence, request.records)).map(({ columns, memberships }, index) => ({
+			record: request.records[index],
+			canonical: request.records[index].canonical,
+			row: columns,
+			memberships
+		}));
+		for (const group of chunked(records, Math.floor(MAX_BOUND_PARAMETERS / 18))) {
+			yield* sql`INSERT INTO effect_agent_canonical_records ${sql.insert(group.map(({ row }) => row))}`.pipe(Effect.mapError(storageError("insert canonical records")));
+			const memberships = group.flatMap(({ memberships }) => memberships);
+			for (const members of chunked(memberships, Math.floor(MAX_BOUND_PARAMETERS / 3))) yield* sql`INSERT INTO effect_agent_record_runs ${sql.insert(members)}`.pipe(Effect.mapError(storageError("index canonical Run membership")));
+			for (const { row, record } of group) {
+				recordCache.put(RecordRow.make({
+					...row,
+					record_id: record.recordId,
+					batch_id: request.batchId,
+					record_json: record.recordJson,
+					sequence: Schema.decodeSync(CanonicalSequence)(row.sequence)
+				}), record.recordBytes);
+				yield* failpoint("append:after-record-insert");
+			}
+		}
+		if (request.records.length > 0) {
+			const workFields = yield* work.apply(yield* Schema.decodeEffect(ThreadId)(request.threadId).pipe(Effect.mapError(workFailure)), firstSequence, request.records.map((record) => record.canonical)).pipe(Effect.mapError(workFailure));
+			yield* sql`UPDATE effect_agent_threads SET ${sql.update({
+				tail_sequence: lastSequence,
+				...workFields
+			})}
+          WHERE thread_id=${request.threadId} RETURNING *`.pipe(threads.write, Effect.mapError((error) => error._tag === "SqlError" ? storageError("advance thread tail")(error) : error));
+		}
+		yield* executionConflict(executions.commit(request, result));
+		if (request.executionWrites.length > 0) yield* failpoint("append:after-record-insert");
+		if (lifecycle !== void 0 && request.executionWrites.some(({ update }) => update.facts.some(({ payload }) => payload._tag === "RunStarted"))) yield* flushCanonical(request.threadId).pipe(Effect.provideService(SqlLifecycleRetainer, { retainMany: lifecycle.retainMany }), Effect.mapError((cause) => DoStorageError.make({
+			operation: "retain lifecycle start prefix",
+			message: "Lifecycle start intent could not be retained",
+			cause
+		})));
+		for (const { update } of request.executionWrites) for (const fact of update.facts) if (lifecycle !== void 0 && Schema.is(Schema.toType(LifecyclePublicationFact))(fact.payload)) yield* lifecycle.retain({
+			id: JSON.stringify([
+				request.threadId,
+				"record",
+				fact.recordId
+			]),
+			ownerThreadId: request.threadId,
+			canonicalSequence: lastSequence,
+			createdAt: fact.createdAt,
+			fact: fact.payload
+		}).pipe(Effect.mapError((cause) => DoStorageError.make({
+			operation: "retain operational lifecycle",
+			message: cause.message,
+			cause
+		})));
+		yield* failpoint("append:after-tail-update");
+		if (lifecycle !== void 0 && records.some(({ canonical: { payload } }) => payload._tag === "RunStarted" || payload._tag === "SubagentStarted")) yield* flushCanonical(request.threadId).pipe(Effect.provideService(SqlLifecycleRetainer, { retainMany: lifecycle.retainMany }), Effect.mapError((cause) => DoStorageError.make({
+			operation: "retain lifecycle start prefix",
+			message: "Lifecycle start intent could not be retained",
+			cause
+		})));
+		yield* progress.committed("canonical").pipe(Effect.catchCause((cause) => Effect.failCause(Cause.map(cause, (error) => DoStorageError.make({
+			operation: "enroll canonical progress",
+			message: error.message,
+			cause: error
+		})))));
+		return result;
+	});
+	const append = Effect.fnUntraced(function* (request, observed) {
+		yield* prepareAppend(request);
+		if (request.records.length > 0 && request.expectedTailSequence !== observed.tail_sequence) {
+			if ((yield* sql`
+          SELECT batch_id FROM effect_agent_canonical_batches
+          WHERE thread_id = ${request.threadId} AND batch_id = ${JSON.stringify(request.batchId)}
+          UNION ALL SELECT last_commit_id FROM effect_agent_executions
+          WHERE thread_id = ${request.threadId} AND last_commit_id = ${request.batchId}
+          LIMIT 1
+        `.pipe(Effect.mapError(storageError("preflight append replay")))).length === 0) return yield* DoAppendConflict.make({
+				reason: "tail",
+				message: "The canonical tail has advanced.",
+				actualTailSequence: observed.tail_sequence
+			});
+		}
+		return yield* withWriteTransaction("append transaction", isAppendContention)(appendPrepared(request));
+	}, withStorageSpan("DoJournal.append", isAppendContention));
+	const read = Effect.fnUntraced(function* (request) {
+		const thread = (yield* getThread(request.threadId))[0];
+		const through = Math.min(thread?.tail_sequence ?? 0, request.fromSequenceExclusive + request.limit);
+		const cached = [];
+		for (let sequence = request.fromSequenceExclusive + 1; sequence <= through; sequence++) {
+			const record = recordCache.get(request.threadId, sequence);
+			if (record === void 0) break;
+			cached.push(record);
+		}
+		if (cached.length === Math.max(0, through - request.fromSequenceExclusive)) return {
+			count: cached.length,
+			records: Stream.fromIterable(cached)
+		};
+		const planRows = yield* sql`
+      SELECT
+        sequence,
+        length(CAST(${recordJson} AS BLOB)) AS record_json_bytes
+      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")));
+		const plan = yield* decodeRows(Schema.Array(ReadPlanRow), "effect_agent_canonical_records", `${request.threadId}>${request.fromSequenceExclusive}`, planRows, "ReadPlanRow");
+		const mismatch = () => DoStorageCorruptionError.make({
+			table: "effect_agent_canonical_records",
+			rowKey: `${request.threadId}>${request.fromSequenceExclusive}`,
+			message: "Canonical read membership, sequence, or payload size changed from its read plan."
+		});
+		if (plan.length > request.limit) return yield* mismatch();
+		const pages = [];
+		let page;
+		let pageBytes = 0;
+		let previousSequence = request.fromSequenceExclusive;
+		for (const row of plan) {
+			if (row.sequence !== previousSequence + 1) return yield* mismatch();
+			previousSequence = row.sequence;
+			if (page === void 0 || pageBytes + row.record_json_bytes > MAX_READ_PAGE_JSON_BYTES) {
+				page = [row];
+				pages.push(page);
+				pageBytes = row.record_json_bytes;
+			} else {
+				page.push(row);
+				pageBytes += row.record_json_bytes;
+			}
+		}
+		const readPage = Effect.fnUntraced(function* (page) {
+			const rows = yield* sql`
+        SELECT thread_id, sequence, record_id, ${recordBatchId(sql)} AS batch_id, ${recordJson} AS record_json
+        FROM effect_agent_canonical_records
+        WHERE thread_id = ${request.threadId}
+          AND sequence >= ${page[0].sequence}
+          AND sequence <= ${page[page.length - 1].sequence}
+        ORDER BY sequence
+      `.pipe(Effect.mapError(storageError("read canonical records")));
+			const decoded = yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}/${page[0].sequence}`, rows, "RecordRow");
+			if (decoded.length !== page.length || decoded.some((row, index) => row.thread_id !== request.threadId || row.sequence !== page[index].sequence || storedTextBytes(row.record_json) !== page[index].record_json_bytes)) return yield* mismatch();
+			for (const row of decoded) recordCache.put(row);
+			return decoded;
+		});
+		return {
+			count: plan.length,
+			records: Stream.fromIterable(pages).pipe(Stream.flatMap((page) => Stream.fromIterableEffect(state.read(readPage(page)))))
+		};
+	});
+	const saveCheckpoint = Effect.fnUntraced(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* getThread(checkpoint.threadId);
+			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", checkpoint.threadId, threadRows);
+			if (checkpoint.throughSequence > thread.tail_sequence) return yield* DoCheckpointConflict.make({
+				reason: "ahead-of-tail",
+				message: `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ${thread.tail_sequence}.`
+			});
+			if (!(yield* isBatchBoundary(checkpoint.threadId, checkpoint.throughSequence))) return yield* DoCheckpointConflict.make({
+				reason: "not-batch-boundary",
+				message: "Checkpoint sequence is not the end of a complete canonical batch."
+			});
+			const checkpointRows = yield* sql`
+          SELECT
+            thread_id,
+            through_sequence,
+            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].checkpoint_json !== checkpoint.checkpointJson) return yield* DoCheckpointConflict.make({
+					reason: "corrupt",
+					message: "A different checkpoint already exists at this canonical sequence."
+				});
+				return;
+			}
+			yield* sql`
+          INSERT INTO effect_agent_checkpoints (
+            thread_id,
+            through_sequence,
+            checkpoint_json
+          ) VALUES (
+            ${checkpoint.threadId},
+            ${checkpoint.throughSequence},
+            ${checkpoint.checkpointJson}
+          )
+        `.pipe(Effect.mapError(storageError("insert checkpoint")));
+		}));
+	});
+	const loadCheckpoint = Effect.fnUntraced(function* (threadId, atOrBeforeSequence) {
+		const rows = yield* sql`
+      SELECT
+        thread_id,
+        through_sequence,
+        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);
+	});
+	const isBatchBoundary = Effect.fnUntraced(function* (threadId, sequence) {
+		if (sequence === 0) return true;
+		const rows = yield* sql`
+        SELECT last_sequence FROM effect_agent_canonical_batches
+        WHERE thread_id = ${threadId}
+          AND batch_id = (
+            SELECT ${recordBatchId(sql)} FROM effect_agent_canonical_records
+            WHERE thread_id = ${threadId} AND sequence = ${sequence}
+          )
+          AND last_sequence = ${sequence}
+      `.pipe(Effect.mapError(storageError("read canonical batch boundary")));
+		return (yield* decodeRows(Schema.Array(Schema.Struct({ last_sequence: CanonicalSequence })), "effect_agent_canonical_batches", `${threadId}/${sequence}`, rows)).length === 1;
+	});
+	const sourceFailure = (cause) => LifecyclePublicationError.make({
+		reason: "unavailable",
+		cause
+	});
+	const sourceThreads = Effect.fnUntraced(function* () {
+		const all = yield* threads.matching("lifecycle-owners", (row) => row.created_at !== null, sql`SELECT * FROM effect_agent_threads WHERE created_at IS NOT NULL LIMIT 129`, 128);
+		if (all.length <= 128) return all;
+		return yield* Schema.decodeUnknownEffect(Schema.Array(ThreadRow))(yield* sql`SELECT t.* FROM effect_agent_threads t LEFT JOIN effect_agent_lifecycle_cursors c ON c.thread_id=t.thread_id
+        WHERE t.created_at IS NOT NULL AND (c.thread_id IS NULL OR t.tail_sequence > c.through_sequence) ORDER BY t.thread_id LIMIT 128`);
+	});
+	const initializeLifecycleSource = Effect.fnUntraced(function* () {
+		if (initializedLifecycleSources.has(state)) return;
+		yield* state.transaction(Effect.gen(function* () {
+			if ((yield* sql`SELECT name FROM sqlite_master WHERE name='effect_agent_lifecycle_cursors'`).length === 0) yield* sql`CREATE TABLE effect_agent_lifecycle_cursors (
+        thread_id TEXT PRIMARY KEY, through_sequence INTEGER NOT NULL
+      )`;
+			yield* sql`INSERT INTO effect_agent_lifecycle_cursors(thread_id, through_sequence)
+        SELECT thread_id, tail_sequence FROM effect_agent_threads WHERE created_at IS NOT NULL
+        ON CONFLICT(thread_id) DO NOTHING`;
+			yield* sourceThreads();
+		})).pipe(Effect.provideService(SqlClient$1.SqlClient, sql), Effect.mapError((cause) => DoStorageError.make({
+			operation: "initialize lifecycle source",
+			message: "Lifecycle source cursor unavailable",
+			cause
+		})));
+		initializedLifecycleSources.add(state);
+	});
+	/** The journal is durable intent; only the bounded publication wave materializes a write set. */
+	const flushCanonical = Effect.fnUntraced(function* (threadId, maxRecords = Infinity) {
+		const { retainMany } = yield* SqlLifecycleRetainer;
+		const thread = (yield* getThread(threadId))[0];
+		if (thread === void 0) return;
+		const cursor = (yield* cursors.by("thread_id", threadId))[0];
+		if (cursor === void 0 || cursor.through_sequence > thread.tail_sequence) return yield* LifecyclePublicationError.make({ reason: "corrupt" });
+		let through = cursor.through_sequence;
+		const bound = Math.min(thread.tail_sequence, through + maxRecords);
+		while (through < bound) {
+			const page = yield* read(RawReadRequest.make({
+				threadId,
+				fromSequenceExclusive: through,
+				limit: Math.min(128, bound - through)
+			}));
+			const facts = [];
+			let bytes = 0;
+			yield* Stream.runForEach(page.records, (row) => Effect.gen(function* () {
+				const record = yield* Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(row.record_json);
+				if (record.recordId !== row.record_id || row.sequence !== through + 1) return yield* LifecyclePublicationError.make({ reason: "corrupt" });
+				if (Schema.is(Schema.toType(LifecyclePublicationFact))(record.payload)) {
+					if (bytes + storedTextBytes(row.record_json) > MAX_READ_PAGE_JSON_BYTES && facts.length > 0) {
+						yield* retainMany(facts);
+						facts.length = 0;
+						bytes = 0;
+					}
+					facts.push({
+						id: JSON.stringify([
+							threadId,
+							"record",
+							record.recordId
+						]),
+						ownerThreadId: yield* Schema.decodeEffect(ThreadId)(threadId),
+						canonicalSequence: row.sequence,
+						createdAt: record.createdAt,
+						fact: record.payload
+					});
+					bytes += storedTextBytes(row.record_json);
+				}
+				through = row.sequence;
+			}));
+			if (page.count === 0) return yield* LifecyclePublicationError.make({ reason: "corrupt" });
+			yield* retainMany(facts);
+			yield* sql`UPDATE effect_agent_lifecycle_cursors SET through_sequence=${through} WHERE thread_id=${threadId} RETURNING *`.pipe(cursors.write);
+		}
+	}, Effect.mapError(sourceFailure));
+	const flushPublications = Effect.fnUntraced(function* () {
+		let owners = 0;
+		for (const thread of yield* sourceThreads()) {
+			const cursor = (yield* cursors.by("thread_id", thread.thread_id))[0];
+			if (cursor !== void 0 && cursor.through_sequence === thread.tail_sequence) continue;
+			yield* flushCanonical(thread.thread_id, 1024);
+			if (++owners === 4) break;
+		}
+	}, Effect.mapError(sourceFailure));
+	const sourcePending = Effect.gen(function* () {
+		for (const thread of yield* sourceThreads()) {
+			const cursor = (yield* cursors.by("thread_id", thread.thread_id))[0];
+			if (cursor === void 0 || cursor.through_sequence > thread.tail_sequence) return yield* LifecyclePublicationError.make({ reason: "corrupt" });
+			if (cursor.through_sequence < thread.tail_sequence) return true;
+		}
+		return false;
+	}).pipe(Effect.mapError(sourceFailure));
+	const ownedLifecycle = lifecycle === void 0 ? void 0 : {
+		...lifecycle,
+		storage: {
+			...lifecycle.storage,
+			retainedPendingDeadline: lifecycle.storage.pendingDeadline,
+			pendingDeadline: state.read(Effect.gen(function* () {
+				const deadline = yield* lifecycle.storage.pendingDeadline;
+				if (!(yield* sourcePending)) return deadline;
+				const now = yield* Clock.currentTimeMillis;
+				return Option.some(Option.isSome(deadline) ? Math.min(now, deadline.value) : now);
+			}))
+		}
+	};
+	return {
+		archives: archives.storage,
+		archiveRanges: archives,
+		work,
+		state,
+		owner,
+		threads,
+		lifecycle: ownedLifecycle,
+		initializeLifecycleSource,
+		flushCanonical,
+		flushPublications,
+		append,
+		prepareAppend,
+		appendPrepared,
+		checkCommitIntent: (request) => executionConflict(executions.checkCommitIntent(request)),
+		readExecution: executions.read,
+		checkValueBound,
+		getThread,
+		hasRecord,
+		isBatchBoundary,
+		loadCheckpoint,
+		materialize,
+		read: (request) => state.read(read(request)),
+		saveCheckpoint,
+		withWriteTransaction
+	};
+});
+const initializeDoJournal = ensureCurrentStorage;
+//#endregion
+export { isAppendContention as a, initializeDoJournal as i, RawReadRequest as n, withStorageSpan as o, decodeRows as r, RawCheckpoint as t };
+
+//# sourceMappingURL=do-journal-Cawnsetj.mjs.map