effect-durable-agent-cloudflare 0.1.0-alpha.22 → 0.1.0-alpha.24

package/dist/durable-object-store-Dct3N6rk.js

@@ -0,0 +1,1148 @@
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { ContextRebasedPayload, DurableEventEnvelope, SummaryCreatedPayload, assistantMessageCommittedEventType, assistantMessageImportedEventType, assistantPartialCommittedEventType, commandAdmittedEventType, commandCancelledEventType, commandCompletedEventType, commandFailedEventType, commandStartedEventType, contextRebasedEventType, decodeDurableEventSync, effectDurableAgentNamespace, steeringMessageQueuedEventType, summaryCreatedEventType, systemMessageCommittedEventType, userMessageCommittedEventType } from "effect-durable-agent/types/events";
+import { SequenceNumber, SummaryId, durablePosition } from "effect-durable-agent/types/core";
+import { EDASessionStore, EDASessionStoreError } from "effect-durable-agent/services/session-store";
+import { TranscriptLogIncarnation, TranscriptRecordFromEnvelope, TranscriptRecordId, TranscriptVersion, isPendingTranscriptUserRecord, isTopLevelTranscriptRecord, planTranscriptBatch } from "effect-durable-agent/transcript";
+import * as Cause from "effect/Cause";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { CompactionSummaryArtifact } from "effect-durable-agent/domain/context-projection";
+import { annotateEdaSpan, committedBatchAttributes } from "effect-durable-agent/services/tracing";
+import { IdGenerator } from "effect-durable-agent/services/id-generator";
+//#region src/durable-object-json.ts
+/** Conservative JSON limit below the Durable Object SQLite per-value ceiling (2 MB). */
+const durableObjectSerializedJsonHardCapBytes = 15e5;
+const jsonEncoder = new TextEncoder();
+/** Serialize and size-check one JSON column before it reaches DO SQLite. */
+const stringifyJsonForColumn = (value, column) => {
+	const json = JSON.stringify(value);
+	if (json === void 0) throw new Error(`${column} value is not JSON serializable`);
+	const bytes = jsonEncoder.encode(json).byteLength;
+	if (bytes > 15e5) throw new Error(`${column} serialized JSON is ${bytes} bytes; hard cap is ${durableObjectSerializedJsonHardCapBytes} bytes`);
+	return json;
+};
+//#endregion
+//#region src/durable-object-transcript-tables.ts
+/**
+* SQL layout of the transcript projection (design §5.1), created by the store's forward migration.
+*
+* Rows are keyed by a **slot**: one stored instance of one transcript version. A version is built
+* in a fresh slot, so a retired slot that is still being deleted in bounded slices never collides
+* with a later slot of the same version. At most one slot is `active` and at most one is
+* `building`; `retired` slots are garbage awaiting cleanup and are never read.
+*
+* `_eda_log_incarnation` holds the identity of this physical event log (§8); `_eda_alarm_wakeups`
+* holds each alarm owner's durable wakeup (see `durable-object-alarms.ts`).
+*/
+const transcriptTableStatements = [
+	`CREATE TABLE IF NOT EXISTS _eda_transcript_meta (
+    slot INTEGER PRIMARY KEY AUTOINCREMENT,
+    version TEXT NOT NULL,
+    role TEXT NOT NULL CHECK (role IN ('active', 'building', 'retired')),
+    cursor INTEGER NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('ok', 'failed')),
+    failed_at_seq INTEGER,
+    error TEXT
+  )`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS _eda_transcript_meta_role_idx
+    ON _eda_transcript_meta(role) WHERE role IN ('active', 'building')`,
+	`CREATE TABLE IF NOT EXISTS _eda_transcript_records (
+    slot INTEGER NOT NULL,
+    id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    anchor_seq INTEGER,
+    ordinal INTEGER,
+    top_level INTEGER NOT NULL,
+    pending INTEGER NOT NULL,
+    assistant_id TEXT,
+    updated_seq INTEGER NOT NULL,
+    envelope_json TEXT NOT NULL,
+    PRIMARY KEY (slot, id)
+  )`,
+	`CREATE INDEX IF NOT EXISTS _eda_transcript_records_order_idx
+    ON _eda_transcript_records(slot, top_level, anchor_seq, ordinal, id)`,
+	`CREATE INDEX IF NOT EXISTS _eda_transcript_records_anchor_idx
+    ON _eda_transcript_records(slot, anchor_seq, ordinal) WHERE anchor_seq IS NOT NULL`,
+	`CREATE INDEX IF NOT EXISTS _eda_transcript_records_updated_idx
+    ON _eda_transcript_records(slot, updated_seq)`,
+	`CREATE INDEX IF NOT EXISTS _eda_transcript_records_pending_idx
+    ON _eda_transcript_records(slot, id) WHERE pending = 1`,
+	`CREATE INDEX IF NOT EXISTS _eda_transcript_records_tool_idx
+    ON _eda_transcript_records(slot, assistant_id) WHERE assistant_id IS NOT NULL`,
+	`CREATE TABLE IF NOT EXISTS _eda_transcript_aliases (
+    slot INTEGER NOT NULL,
+    namespace TEXT NOT NULL,
+    key TEXT NOT NULL,
+    record_id TEXT NOT NULL,
+    PRIMARY KEY (slot, namespace, key)
+  )`,
+	`CREATE TABLE IF NOT EXISTS _eda_log_incarnation (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    incarnation TEXT NOT NULL
+  )`,
+	`CREATE TABLE IF NOT EXISTS _eda_alarm_wakeups (
+    owner TEXT PRIMARY KEY,
+    at_ms INTEGER NOT NULL
+  )`
+];
+const decodeVersion = Schema.decodeUnknownSync(TranscriptVersion);
+const decodeSlot = (row) => {
+	if (row.role !== "active" && row.role !== "building" && row.role !== "retired") throw new Error(`transcript slot ${row.slot} has unknown role ${row.role}`);
+	if (row.status === "failed" && (row.failed_at_seq === null || row.error === null)) throw new Error(`failed transcript slot ${row.slot} has no failure seq or error`);
+	return {
+		slot: row.slot,
+		version: decodeVersion(row.version),
+		role: row.role,
+		cursor: SequenceNumber.make(row.cursor),
+		status: row.status === "failed" ? {
+			_tag: "Failed",
+			failedAtSeq: SequenceNumber.make(row.failed_at_seq ?? 0),
+			error: row.error ?? ""
+		} : { _tag: "Ok" }
+	};
+};
+/** Every stored slot, in creation order. */
+const readTranscriptSlots = (sql) => sql.exec("SELECT slot, version, role, cursor, status, failed_at_seq, error FROM _eda_transcript_meta ORDER BY slot").toArray().map(decodeSlot);
+/** The port's view of a slot; retired slots have none. */
+const transcriptVersionMetaOf = (slot) => slot.role === "retired" ? void 0 : {
+	version: slot.version,
+	role: slot.role,
+	cursor: slot.cursor,
+	status: slot.status
+};
+const insertTranscriptSlot = (sql, version, role) => {
+	sql.exec("INSERT INTO _eda_transcript_meta (version, role, cursor, status) VALUES (?, ?, 0, 'ok')", version, role);
+};
+const setTranscriptSlotRole = (sql, slot, role) => {
+	sql.exec("UPDATE _eda_transcript_meta SET role = ? WHERE slot = ?", role, slot);
+};
+/** Freeze a slot at its unchanged cursor. A failed slot is never written again. */
+const markTranscriptSlotFailed = (sql, slot, failedAtSeq, error) => {
+	sql.exec("UPDATE _eda_transcript_meta SET status = 'failed', failed_at_seq = ?, error = ? WHERE slot = ?", failedAtSeq, error, slot);
+};
+/**
+* Delete up to `limit` rows of a retired slot, records first, and the slot itself once empty.
+* Returns the number of rows deleted.
+*/
+const deleteRetiredTranscriptRows = (sql, slot, limit) => {
+	const records = sql.exec(`DELETE FROM _eda_transcript_records WHERE rowid IN (
+        SELECT rowid FROM _eda_transcript_records WHERE slot = ? LIMIT ?
+      ) RETURNING 1 AS deleted`, slot, limit).toArray().length;
+	const aliases = records >= limit ? 0 : sql.exec(`DELETE FROM _eda_transcript_aliases WHERE rowid IN (
+              SELECT rowid FROM _eda_transcript_aliases WHERE slot = ? LIMIT ?
+            ) RETURNING 1 AS deleted`, slot, limit - records).toArray().length;
+	if (records + aliases < limit) sql.exec("DELETE FROM _eda_transcript_meta WHERE slot = ? AND role = 'retired'", slot);
+	return records + aliases;
+};
+const encodeEnvelope = Schema.encodeSync(TranscriptRecordFromEnvelope);
+const decodeEnvelope = Schema.decodeUnknownSync(TranscriptRecordFromEnvelope);
+/** A stored record row this release cannot decode. */
+var TranscriptRowDecodeError = class extends Error {
+	name = "TranscriptRowDecodeError";
+};
+/**
+* Decode one stored row. A row this release cannot decode throws; maintenance treats that as a
+* projection failure and reads as an unreadable window, never as a wrong view.
+*/
+const decodeRecordRow = (row) => {
+	try {
+		return decodeEnvelope(JSON.parse(row.envelope_json));
+	} catch (cause) {
+		throw new TranscriptRowDecodeError(`undecodable transcript row: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+	}
+};
+const positionOf = (record) => "position" in record ? record.position : void 0;
+const encodeTranscriptPlan = (plan) => ({
+	records: plan.records.map((record) => {
+		const position = positionOf(record);
+		return [
+			record.id,
+			record.kind,
+			position?.anchorSeq ?? null,
+			position?.ordinal ?? null,
+			isTopLevelTranscriptRecord(record) ? 1 : 0,
+			isPendingTranscriptUserRecord(record) ? 1 : 0,
+			record.kind === "tool" ? record.assistantId : null,
+			record.updatedSeq,
+			stringifyJsonForColumn(encodeEnvelope(record), "_eda_transcript_records.envelope_json")
+		];
+	}),
+	aliases: plan.aliases,
+	throughSeq: plan.throughSeq
+});
+/** Write an encoded plan to a slot and advance its cursor; the caller owns the transaction. */
+const writeTranscriptPlan = (sql, slot, plan) => {
+	for (const row of plan.records) sql.exec(`INSERT INTO _eda_transcript_records (
+        slot, id, kind, anchor_seq, ordinal, top_level, pending, assistant_id, updated_seq, envelope_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(slot, id) DO UPDATE SET
+        kind = excluded.kind,
+        anchor_seq = excluded.anchor_seq,
+        ordinal = excluded.ordinal,
+        top_level = excluded.top_level,
+        pending = excluded.pending,
+        assistant_id = excluded.assistant_id,
+        updated_seq = excluded.updated_seq,
+        envelope_json = excluded.envelope_json`, slot, ...row);
+	for (const alias of plan.aliases) sql.exec(`INSERT INTO _eda_transcript_aliases (slot, namespace, key, record_id) VALUES (?, ?, ?, ?)
+      ON CONFLICT(slot, namespace, key) DO NOTHING`, slot, alias.namespace, alias.key, alias.recordId);
+	sql.exec("UPDATE _eda_transcript_meta SET cursor = ? WHERE slot = ?", plan.throughSeq, slot);
+};
+const readRecord = (sql, slot, id) => {
+	const row = sql.exec("SELECT envelope_json FROM _eda_transcript_records WHERE slot = ? AND id = ?", slot, id).toArray()[0];
+	return row === void 0 ? void 0 : decodeRecordRow(row);
+};
+const decodeRecordId = Schema.decodeUnknownSync(TranscriptRecordId);
+const readAlias = (sql, slot, namespace, key) => {
+	const row = sql.exec("SELECT record_id FROM _eda_transcript_aliases WHERE slot = ? AND namespace = ? AND key = ?", slot, namespace, key).toArray()[0];
+	return row === void 0 ? void 0 : decodeRecordId(row.record_id);
+};
+/** Indexed synchronous reads of one slot as committed so far in this transaction. */
+const makeTranscriptLookup = (sql, slot) => ({
+	cursor: slot.cursor,
+	record: (id) => readRecord(sql, slot.slot, id),
+	alias: (namespace, key) => readAlias(sql, slot.slot, namespace, key),
+	nextOrdinal: (anchorSeq) => sql.exec(`SELECT MAX(ordinal) + 1 AS next FROM _eda_transcript_records
+        WHERE slot = ? AND anchor_seq = ?`, slot.slot, anchorSeq).one().next ?? 0
+});
+const topLevel = (record) => {
+	if (!isTopLevelTranscriptRecord(record)) throw new TranscriptRowDecodeError(`transcript record ${record.id} is indexed as top-level but is not`);
+	return record;
+};
+/**
+* Window reads over one served slot. Every method is a synchronous indexed query, so a window
+* assembled from them inside one synchronous call is one cut. Record ids are ASCII, so SQLite's
+* binary text order equals `TranscriptOrder`'s code-unit order.
+*/
+const makeTranscriptWindowSource = (sql, incarnation, slot, carried) => {
+	const meta = transcriptVersionMetaOf(slot);
+	if (meta === void 0) throw new Error(`retired transcript slot ${slot.slot} is not servable`);
+	const topLevelPage = (key, limit, inclusive, direction) => {
+		const comparison = direction === "before" ? inclusive ? "<=" : "<" : inclusive ? ">=" : ">";
+		const order = direction === "before" ? "DESC" : "ASC";
+		const keyClause = key === void 0 ? "" : `AND (anchor_seq, ordinal, id) ${comparison} (?, ?, ?)`;
+		const keyBindings = key === void 0 ? [] : [
+			key.anchorSeq,
+			key.ordinal,
+			key.recordId
+		];
+		return sql.exec(`SELECT envelope_json FROM _eda_transcript_records
+        WHERE slot = ? AND top_level = 1 ${keyClause}
+        ORDER BY anchor_seq ${order}, ordinal ${order}, id ${order}
+        LIMIT ?`, slot.slot, ...keyBindings, limit).toArray().map((row) => topLevel(decodeRecordRow(row)));
+	};
+	return {
+		incarnation,
+		meta,
+		carried,
+		topLevelBefore: (key, limit, inclusive) => topLevelPage(key, limit, inclusive, "before"),
+		topLevelAfter: (key, limit, inclusive) => topLevelPage(key, limit, inclusive, "after"),
+		record: (id) => readRecord(sql, slot.slot, id),
+		alias: (namespace, key) => readAlias(sql, slot.slot, namespace, key),
+		toolsOf: (assistantId) => sql.exec("SELECT envelope_json FROM _eda_transcript_records WHERE slot = ? AND assistant_id = ?", slot.slot, assistantId).toArray().flatMap((row) => {
+			const record = decodeRecordRow(row);
+			return record.kind === "tool" ? [record] : [];
+		}),
+		pendingUsers: () => sql.exec("SELECT envelope_json FROM _eda_transcript_records WHERE slot = ? AND pending = 1", slot.slot).toArray().flatMap((row) => {
+			const record = decodeRecordRow(row);
+			return record.kind === "user" ? [record] : [];
+		})
+	};
+};
+const mintUuidV7 = () => Effect.runSync(Effect.gen(function* () {
+	return yield* (yield* IdGenerator).makeCorrelationId();
+}).pipe(Effect.provide(IdGenerator.Live)));
+/**
+* Read this log's incarnation, minting one on first need. The caller runs it inside a
+* `transactionSync`, so read-or-mint is atomic; storage wipes delete the row and so mint anew.
+*/
+const readOrMintLogIncarnation = (sql, adopt) => {
+	const row = sql.exec("SELECT incarnation FROM _eda_log_incarnation WHERE id = 1").toArray()[0];
+	if (row !== void 0) return TranscriptLogIncarnation.make(row.incarnation);
+	const adopted = adopt?.kv.get(adopt.key);
+	const incarnation = typeof adopted === "string" && adopted.length > 0 ? adopted : mintUuidV7();
+	if (adopt !== void 0 && adopted !== incarnation) adopt.kv.put(adopt.key, incarnation);
+	sql.exec("INSERT INTO _eda_log_incarnation (id, incarnation) VALUES (1, ?)", incarnation);
+	return TranscriptLogIncarnation.make(incarnation);
+};
+//#endregion
+//#region src/durable-object-transcript-maintenance.ts
+const defaultTranscriptSliceLimits = {
+	maxEvents: 512,
+	pageEvents: 16,
+	maxDeletedRows: 2e3
+};
+const emptyTranscriptEffects = () => ({
+	alerts: [],
+	pendingWork: false
+});
+/**
+* Publish committed outcomes to the host. Call only after the outer transaction returns. A hook
+* that throws is reported and otherwise ignored: the work it describes is already committed.
+*/
+const publishTranscriptEffects = (observer, effects) => {
+	const notify = (hook) => {
+		try {
+			hook();
+		} catch (error) {
+			console.error("EDA transcript observer failed", error);
+		}
+	};
+	for (const alert of effects.alerts) notify(() => observer?.onAlert?.(alert));
+	const activated = effects.activated;
+	if (activated !== void 0) notify(() => observer?.onActivated?.(activated));
+	if (effects.pendingWork) notify(() => observer?.onPendingWork?.());
+};
+/** The carried definition for a stored version, if this release still carries it. */
+const carriedDefinition = (config, version) => config.current.version === version ? config.current : config.previous?.version === version ? config.previous : void 0;
+const liveSlots = (storage) => readTranscriptSlots(storage.sql).filter((slot) => slot.role !== "retired");
+/**
+* Bring the stored versions in line with this release's definitions (§7 steps 2, 3 and 5),
+* writing only metadata. Rows are never touched here: building and cleanup happen in slices.
+*
+* - No version yet: an empty log starts `current` as active at seq 0; a log written before
+*   transcripts existed builds `current` from the log while nothing is served.
+* - A building version that is not `current` is retired (discarded).
+* - If the active version is not `current` and no build of `current` exists, one starts. A build
+*   of `current` that failed counts as existing, so it is never retried.
+*/
+const reconcileTranscriptSlots = (storage, config, head, effects) => {
+	const { sql } = storage;
+	const current = config.current.version;
+	const slots = liveSlots(storage);
+	if (slots.length === 0) {
+		insertTranscriptSlot(sql, current, head === 0 ? "active" : "building");
+		if (head > 0) effects.pendingWork = true;
+		return;
+	}
+	for (const slot of slots) if (slot.role === "building" && slot.version !== current) {
+		setTranscriptSlotRole(sql, slot.slot, "retired");
+		effects.pendingWork = true;
+	}
+	const active = slots.find((slot) => slot.role === "active");
+	const buildingCurrent = slots.some((slot) => slot.role === "building" && slot.version === current);
+	if (active?.version !== current && !buildingCurrent) {
+		insertTranscriptSlot(sql, current, "building");
+		effects.pendingWork = true;
+	}
+};
+const nestedTransactionSupport = /* @__PURE__ */ new WeakMap();
+const nestedTransactionRejection = /cannot start a transaction within a transaction/i;
+/**
+* Whether this storage runs a `transactionSync` nested in another as an independent inner
+* transaction. workerd does; celld rejects nesting ("cannot start a transaction within a
+* transaction") without disturbing the enclosing transaction. Probed once per storage object.
+*/
+const supportsNestedTransactions = (storage) => {
+	const known = nestedTransactionSupport.get(storage);
+	if (known !== void 0) return known;
+	let supported;
+	try {
+		storage.transactionSync(() => storage.transactionSync(() => void 0));
+		supported = true;
+	} catch (error) {
+		if (!(error instanceof Error && nestedTransactionRejection.test(error.message))) throw error;
+		supported = false;
+	}
+	nestedTransactionSupport.set(storage, supported);
+	return supported;
+};
+/** Freeze a slot at its unchanged cursor and raise the alert. */
+const freezeSlot = (storage, slot, failedAtSeq, cause, effects) => {
+	const error = cause instanceof Error ? cause.message : String(cause);
+	markTranscriptSlotFailed(storage.sql, slot.slot, failedAtSeq, error);
+	if (slot.role !== "retired") effects.alerts.push({
+		_tag: "ProjectionFailed",
+		version: slot.version,
+		role: slot.role,
+		failedAtSeq,
+		error
+	});
+	return {
+		...slot,
+		status: {
+			_tag: "Failed",
+			failedAtSeq,
+			error
+		}
+	};
+};
+/**
+* Project committed events into one slot, or freeze the slot (§5.2).
+*
+* Planning, row decoding and row encoding (serialization and the size cap) all run before any
+* write, so every recoverable projection error is raised before the slot is touched. Where the
+* platform nests transactions (workerd), the writes also run inside an inner `transactionSync`,
+* so even a failing write rolls back only that slot. Either way the failure is recorded in the
+* caller's transaction and the events the caller appended still commit. Where it does not
+* (celld), a write that fails after planning succeeded is a storage failure, which fails the
+* caller's whole transaction atomically, exactly as a failed event insert does.
+*/
+const advanceSlot = (storage, slot, definition, events, effects) => {
+	const first = events.find((entry) => entry.position.seq > slot.cursor);
+	if (first === void 0 || slot.status._tag === "Failed" || slot.role === "retired") return slot;
+	const nested = supportsNestedTransactions(storage);
+	const project = () => {
+		const plan = encodeTranscriptPlan(planTranscriptBatch(makeTranscriptLookup(storage.sql, slot), events, definition));
+		if (nested) writeTranscriptPlan(storage.sql, slot.slot, plan);
+		return plan;
+	};
+	let plan;
+	try {
+		plan = nested ? storage.transactionSync(project) : project();
+	} catch (cause) {
+		return freezeSlot(storage, slot, first.position.seq, cause, effects);
+	}
+	if (!nested) writeTranscriptPlan(storage.sql, slot.slot, plan);
+	return {
+		...slot,
+		cursor: plan.throughSeq
+	};
+};
+/**
+* The append hook: one batch-level call inside the append transaction, after every entry has
+* been inserted.
+*
+* A version is maintained here exactly when it is carried, healthy and caught up — its cursor is
+* the head the batch started from — so the new events are precisely what it is missing. Anything
+* behind (a building version) is caught up by builder slices instead, and frozen versions are
+* never touched. Each version fails independently.
+*/
+const maintainTranscriptsOnAppend = (storage, config, headBeforeBatch, appended, effects) => {
+	reconcileTranscriptSlots(storage, config, headBeforeBatch, effects);
+	if (appended.length === 0) return;
+	for (const slot of liveSlots(storage)) {
+		const definition = carriedDefinition(config, slot.version);
+		if (definition === void 0 || slot.status._tag === "Failed") continue;
+		if (slot.cursor !== headBeforeBatch) continue;
+		advanceSlot(storage, slot, definition, appended, effects);
+	}
+};
+/**
+* The missed-session alert for a session whose active version this release no longer carries,
+* raised whenever an object starts, so it does not depend on observing the build's creation.
+*/
+const missedSessionAlert = (storage, config) => {
+	const active = liveSlots(storage).find((slot) => slot.role === "active");
+	return active === void 0 || carriedDefinition(config, active.version) !== void 0 ? void 0 : {
+		_tag: "MissedSession",
+		activeVersion: active.version,
+		currentVersion: config.current.version
+	};
+};
+/** The one slot a builder slice advances: the building version, else an active one behind. */
+const buildTarget = (config, slots, head) => {
+	const healthy = (slot) => slot.status._tag === "Ok" && carriedDefinition(config, slot.version) !== void 0;
+	return slots.find((slot) => slot.role === "building" && healthy(slot)) ?? slots.find((slot) => slot.role === "active" && healthy(slot) && slot.cursor < head);
+};
+/** Whether any builder or cleanup slice has work to do. Read-only. */
+const hasPendingTranscriptWork = (storage, config, head) => {
+	const slots = readTranscriptSlots(storage.sql);
+	if (slots.some((slot) => slot.role === "retired")) return true;
+	const live = slots.filter((slot) => slot.role !== "retired");
+	if (live.length === 0) return head > 0;
+	const current = config.current.version;
+	if (live.some((slot) => slot.role === "building" && slot.version !== current)) return true;
+	if (live.find((slot) => slot.role === "active")?.version !== current && !live.some((slot) => slot.role === "building" && slot.version === current)) return true;
+	return buildTarget(config, live, head) !== void 0;
+};
+/**
+* One bounded builder slice. The caller runs it inside one outer `transactionSync`.
+*
+* It reconciles versions, projects at most `maxEvents` log events into the building version
+* (page by page, each page's rows and cursor committed together, so an eviction resumes from the
+* cursor), activates the build when its cursor equals the head re-read in this transaction, and
+* deletes a bounded number of retired rows. Returns whether more work remains.
+*/
+const runTranscriptSlice = (storage, config, log, limits, effects) => {
+	const { sql } = storage;
+	const head = log.head();
+	reconcileTranscriptSlots(storage, config, head, effects);
+	const slots = liveSlots(storage);
+	const target = buildTarget(config, slots, head);
+	if (target !== void 0) {
+		const definition = carriedDefinition(config, target.version);
+		let slot = target;
+		let remaining = limits.maxEvents;
+		while (definition !== void 0 && slot.status._tag === "Ok" && slot.cursor < head && remaining > 0) {
+			let page;
+			try {
+				page = log.after(slot.cursor, Math.min(limits.pageEvents, remaining));
+			} catch (cause) {
+				slot = freezeSlot(storage, slot, SequenceNumber.make(slot.cursor + 1), cause, effects);
+				break;
+			}
+			if (page.length === 0) break;
+			remaining -= page.length;
+			slot = advanceSlot(storage, slot, definition, page, effects);
+		}
+		if (slot.role === "building" && slot.status._tag === "Ok" && slot.cursor === log.head()) {
+			const previous = slots.find((candidate) => candidate.role === "active");
+			if (previous !== void 0) setTranscriptSlotRole(sql, previous.slot, "retired");
+			setTranscriptSlotRole(sql, slot.slot, "active");
+			effects.activated = {
+				version: slot.version,
+				previousVersion: previous?.version
+			};
+		}
+	}
+	let deleteBudget = limits.maxDeletedRows;
+	for (const slot of readTranscriptSlots(sql)) {
+		if (deleteBudget <= 0) break;
+		if (slot.role === "retired") deleteBudget -= deleteRetiredTranscriptRows(sql, slot.slot, deleteBudget);
+	}
+	return hasPendingTranscriptWork(storage, config, log.head());
+};
+//#endregion
+//#region src/durable-object-store.ts
+const ProjectionPayload = Schema.Record(Schema.String, Schema.Unknown);
+const AdmittedCommandProjection = Schema.Struct({
+	commandId: Schema.Unknown,
+	idempotencyKey: Schema.optionalKey(Schema.Unknown)
+});
+/** Squashed pre-release framework schema. */
+const durableObjectSessionStoreSchemaVersion = 1;
+/** Forward migration adding the transcript projection, log incarnation and alarm wakeups. */
+const durableObjectTranscriptSchemaVersion = 2;
+/**
+* Bound one synchronous DO SQLite event-log read/decode to a small CPU and memory slice.
+*
+* A single logical event can already approach the per-row JSON hard cap, and logical decode may
+* touch sidecar rows. Sixteen rows keeps worst-case page memory materially below isolate limits
+* while still amortizing SQL cursor setup for normal small framework events. Revisit with page
+* duration/byte telemetry before increasing.
+*/
+const durableObjectEventReadPageRows = 16;
+/**
+* Durable Object SQLite-backed implementation of the semantic `EDASessionStore`.
+*
+* This adapter is the only place EDA framework storage code touches DO SQL. It
+* translates domain append intent into synchronous SQLite writes while keeping
+* `SessionState` and runners SQL-agnostic.
+*/
+var DurableObjectSessionStore = class DurableObjectSessionStore {
+	/** Run the single squashed framework migration for the current pre-release schema. */
+	static migrate = (storage) => migrateDurableObjectSessionStore(storage);
+	/** Build a session-scoped store after migrations have completed. */
+	static make = ({ sessionId, storage, transcript }) => Effect.gen(function* () {
+		yield* DurableObjectSessionStore.migrate(storage);
+		return makeDurableObjectSessionStore(sessionId, storage, transcript);
+	});
+	/** Layer constructor used by the Durable Object host runtime graph. */
+	static layer = (options) => Layer.effect(EDASessionStore, DurableObjectSessionStore.make(options));
+};
+/**
+* Create all framework-owned tables in one idempotent startup step.
+*
+* The project is still pre-release, so this remains a squashed version-1 schema
+* rather than a chain of compatibility migrations.
+*/
+const migrateDurableObjectSessionStore = (storage) => Effect.try({
+	try: () => storage.transactionSync(() => {
+		const { sql } = storage;
+		sql.exec(`
+          CREATE TABLE IF NOT EXISTS _eda_schema_migrations (
+            id INTEGER PRIMARY KEY,
+            applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+          )
+        `);
+		const currentVersion = sql.exec("SELECT COALESCE(MAX(id), 0) AS version FROM _eda_schema_migrations").one().version ?? 0;
+		if (currentVersion < durableObjectSessionStoreSchemaVersion) {
+			sql.exec(`
+            CREATE TABLE IF NOT EXISTS _eda_event_log (
+              seq INTEGER PRIMARY KEY AUTOINCREMENT,
+              event_id TEXT NOT NULL UNIQUE,
+              namespace TEXT NOT NULL,
+              type TEXT NOT NULL,
+              schema_version INTEGER NOT NULL,
+              created_at_ms INTEGER NOT NULL,
+              trace_json TEXT NOT NULL,
+              fact_json TEXT NOT NULL
+            )
+          `);
+			sql.exec(`
+            CREATE INDEX IF NOT EXISTS _eda_event_log_namespace_type_seq_idx
+              ON _eda_event_log(namespace, type, seq)
+          `);
+			sql.exec(`
+            CREATE TABLE IF NOT EXISTS _eda_command_state (
+              command_id TEXT PRIMARY KEY,
+              admitted_seq INTEGER NOT NULL,
+              status TEXT NOT NULL,
+              idempotency_key TEXT,
+              payload_json TEXT NOT NULL
+            )
+          `);
+			sql.exec(`
+            CREATE TABLE IF NOT EXISTS _eda_command_inputs (
+              command_id TEXT PRIMARY KEY,
+              admitted_seq INTEGER NOT NULL UNIQUE,
+              payload_json TEXT NOT NULL
+            )
+          `);
+			sql.exec(`
+            CREATE INDEX IF NOT EXISTS _eda_command_state_status_seq_idx
+              ON _eda_command_state(status, admitted_seq)
+          `);
+			sql.exec(`
+            CREATE UNIQUE INDEX IF NOT EXISTS _eda_command_state_idempotency_idx
+              ON _eda_command_state(idempotency_key) WHERE idempotency_key IS NOT NULL
+          `);
+			sql.exec(`
+            CREATE TABLE IF NOT EXISTS _eda_context_messages (
+              message_id TEXT PRIMARY KEY,
+              context_seq INTEGER NOT NULL UNIQUE,
+              payload_json TEXT NOT NULL
+            )
+          `);
+			sql.exec(`
+            CREATE INDEX IF NOT EXISTS _eda_context_messages_context_seq_idx
+              ON _eda_context_messages(context_seq)
+          `);
+			sql.exec(`
+            CREATE TABLE IF NOT EXISTS _eda_context_summaries (
+              summary_id TEXT PRIMARY KEY,
+              created_seq INTEGER NOT NULL UNIQUE,
+              payload_json TEXT NOT NULL
+            )
+          `);
+			sql.exec(`
+            CREATE INDEX IF NOT EXISTS _eda_context_summaries_created_seq_idx
+              ON _eda_context_summaries(created_seq)
+          `);
+			sql.exec(`
+            CREATE TABLE IF NOT EXISTS _eda_reducer_checkpoints (
+              reducer_name TEXT PRIMARY KEY,
+              schema_version INTEGER NOT NULL,
+              through_seq INTEGER NOT NULL,
+              payload_json TEXT NOT NULL,
+              updated_at_ms INTEGER NOT NULL
+            )
+          `);
+			sql.exec(`
+            CREATE TABLE IF NOT EXISTS _eda_sink_cursors (
+              sink_name TEXT PRIMARY KEY,
+              after_seq INTEGER NOT NULL,
+              payload_json TEXT NOT NULL
+            )
+          `);
+			sql.exec("INSERT INTO _eda_schema_migrations (id) VALUES (?)", durableObjectSessionStoreSchemaVersion);
+		}
+		if (currentVersion < durableObjectTranscriptSchemaVersion) {
+			for (const statement of transcriptTableStatements) sql.exec(statement);
+			sql.exec("INSERT INTO _eda_schema_migrations (id) VALUES (?)", durableObjectTranscriptSchemaVersion);
+		}
+	}),
+	catch: (error) => durableStoreError("migrating DurableObjectSessionStore", error)
+});
+/**
+* Interpret the semantic store API with native DO SQLite.
+*
+* All writes that affect durable ordering happen inside `transactionSync`; replay
+* and lookup reads stay synchronous SQL wrapped in Effect boundaries.
+*/
+const makeDurableObjectSessionStore = (sessionId, storage, transcript) => {
+	const { sql } = storage;
+	const ensureSession = (event) => {
+		if (event.sessionId !== sessionId) throw new Error(`DurableObjectSessionStore is scoped to session ${sessionId}; received ${event.sessionId}`);
+	};
+	/**
+	* Insert one append entry or return its existing idempotent event position.
+	*
+	* The event row is the sequence allocator. Artifact/projection writes happen
+	* only for newly inserted events, preventing duplicate appends from advancing
+	* body rows or metadata; only those are collected into `inserted`.
+	*/
+	const insertOrRead = (entry, inserted) => {
+		const { event } = entry;
+		ensureSession(event);
+		const existing = readCommittedByEventIdOptional(sql, sessionId, event.eventId);
+		if (existing !== void 0) return existing;
+		const encoded = encodeEventLogRow(event);
+		sql.exec(`
+        INSERT INTO _eda_event_log (
+          event_id,
+          namespace,
+          type,
+          schema_version,
+          created_at_ms,
+          trace_json,
+          fact_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `, encoded.eventId, encoded.namespace, encoded.type, encoded.schemaVersion, encoded.createdAtMs, encoded.traceJson, encoded.factJson);
+		const row = readEventLogRowByEventId(sql, event.eventId);
+		applySynchronousProjections(sql, entry, SequenceNumber.make(row.seq), encoded.factJson);
+		const committed = rowToCommittedDurableEvent(sql, row, sessionId);
+		inserted.push(committed);
+		return committed;
+	};
+	/**
+	* Execute an entire append batch as one synchronous SQLite transaction.
+	*
+	* Transcript maintenance is one batch-level hook inside the same transaction, after every
+	* entry. A projection failure freezes only the failing version and never fails the append;
+	* its alert is published only after the transaction commits.
+	*/
+	const append = (batch) => Effect.try({
+		try: () => {
+			const effects = emptyTranscriptEffects();
+			const committed = storage.transactionSync(() => {
+				const headBeforeBatch = transcript === void 0 ? void 0 : readEventLogHead(sql);
+				const inserted = [];
+				const entries = batch.entries.map((entry) => insertOrRead(entry, inserted));
+				if (transcript !== void 0 && headBeforeBatch !== void 0) maintainTranscriptsOnAppend(storage, transcript.definitions, headBeforeBatch, inserted, effects);
+				return entries;
+			});
+			publishTranscriptEffects(transcript?.observer, effects);
+			return committed;
+		},
+		catch: (error) => durableStoreError("appending DurableObjectSessionStore batch", error)
+	}).pipe(Effect.tap((committed) => annotateEdaSpan(committedBatchAttributes(committed))));
+	return {
+		append,
+		eventsAfter: (afterSeq) => makeCommittedEventStream(sql, sessionId, afterSeq),
+		loadCommittedEventsBySeq: (seqs) => Effect.try({
+			try: () => uniqueSequenceNumbers(seqs).sort((left, right) => left - right).map((seq) => readCommittedBySeq(sql, sessionId, seq)),
+			catch: (error) => durableStoreError("loading DurableObjectSessionStore events by seq", error)
+		}),
+		findCommandAdmission: (input) => Effect.try({
+			try: () => {
+				const row = findCommandAdmissionRow(sql, input.commandId, input.idempotencyKey);
+				return row === void 0 ? void 0 : readCommittedBySeq(sql, sessionId, row.admitted_seq);
+			},
+			catch: (error) => durableStoreError("finding command admission", error)
+		}),
+		loadSummaryArtifact: (summaryId) => Effect.try({
+			try: () => readSummaryPayloadOptional(sql, summaryId),
+			catch: (error) => durableStoreError("loading DurableObjectSessionStore summary", error)
+		}),
+		loadReducerCheckpoint: (name) => Effect.try({
+			try: () => readReducerCheckpoint(sql, name),
+			catch: (error) => durableStoreError(`loading DurableObjectSessionStore reducer checkpoint ${name}`, error)
+		}),
+		saveReducerCheckpoint: (checkpoint) => Effect.try({
+			try: () => writeReducerCheckpoint(sql, checkpoint),
+			catch: (error) => durableStoreError(`saving DurableObjectSessionStore reducer checkpoint ${checkpoint.name}`, error)
+		}),
+		saveReducerCheckpoints: (checkpoints) => Effect.try({
+			try: () => storage.transactionSync(() => checkpoints.forEach((checkpoint) => writeReducerCheckpoint(sql, checkpoint))),
+			catch: (error) => durableStoreError("saving DurableObjectSessionStore reducer checkpoints", error)
+		})
+	};
+};
+/** Synchronous committed-log reads for the transcript builder, decoded like every replay. */
+const makeDurableObjectEventLog = (sql, sessionId) => ({
+	head: () => readEventLogHead(sql),
+	after: (afterSeq, limit) => sql.exec(`
+          SELECT seq, event_id, namespace, type, schema_version, created_at_ms, trace_json, fact_json
+          FROM _eda_event_log
+          WHERE seq > ?
+          ORDER BY seq ASC
+          LIMIT ?
+        `, afterSeq, limit).toArray().map((row) => rowToCommittedDurableEvent(sql, row, sessionId))
+});
+const makeCommittedEventStream = (sql, sessionId, afterSeq) => Stream.fromPull(Effect.sync(() => {
+	let cursor = {
+		afterSeq,
+		throughSeq: void 0
+	};
+	let done = false;
+	return Effect.gen(function* () {
+		if (done) return yield* Cause.done();
+		yield* Effect.yieldNow;
+		const page = yield* readCommittedEventPage(sql, sessionId, cursor);
+		if (page.events.length === 0) {
+			done = true;
+			return yield* Cause.done();
+		}
+		if (Option.isSome(page.next)) cursor = page.next.value;
+		else done = true;
+		return page.events;
+	});
+}));
+const readCommittedEventPage = (sql, sessionId, cursor) => Effect.try({
+	try: () => {
+		const throughSeq = cursor.throughSeq ?? readEventLogHead(sql);
+		if (cursor.afterSeq >= throughSeq) return {
+			events: [],
+			next: Option.none()
+		};
+		const events = sql.exec(`
+            SELECT seq, event_id, namespace, type, schema_version, created_at_ms, trace_json, fact_json
+            FROM _eda_event_log
+            WHERE seq > ? AND seq <= ?
+            ORDER BY seq ASC
+            LIMIT ?
+          `, cursor.afterSeq, throughSeq, durableObjectEventReadPageRows).toArray().map((row) => rowToCommittedDurableEvent(sql, row, sessionId));
+		const lastSeq = events.at(-1)?.position.seq ?? cursor.afterSeq;
+		return {
+			events,
+			next: lastSeq < throughSeq ? Option.some({
+				afterSeq: lastSeq,
+				throughSeq
+			}) : Option.none()
+		};
+	},
+	catch: (error) => durableStoreError("replaying DurableObjectSessionStore events", error)
+});
+const readEventLogHead = (sql) => SequenceNumber.make(sql.exec(`
+          SELECT COALESCE(MAX(seq), 0) AS head
+          FROM _eda_event_log
+        `).one().head ?? 0);
+const uniqueSequenceNumbers = (seqs) => Array.from(new Set(seqs.map((seq) => Number(seq)))).map((seq) => SequenceNumber.make(seq));
+const readEventLogRowByEventId = (sql, eventId) => sql.exec(`
+        SELECT seq, event_id, namespace, type, schema_version, created_at_ms, trace_json, fact_json
+        FROM _eda_event_log
+        WHERE event_id = ?
+      `, eventId).one();
+const readCommittedByEventIdOptional = (sql, sessionId, eventId) => {
+	const row = sql.exec(`
+        SELECT seq, event_id, namespace, type, schema_version, created_at_ms, trace_json, fact_json
+        FROM _eda_event_log
+        WHERE event_id = ?
+      `, eventId).toArray()[0];
+	return row === void 0 ? void 0 : rowToCommittedDurableEvent(sql, row, sessionId);
+};
+const readReducerCheckpoint = (sql, name) => {
+	const row = sql.exec(`
+        SELECT reducer_name, schema_version, through_seq, payload_json, updated_at_ms
+        FROM _eda_reducer_checkpoints
+        WHERE reducer_name = ?
+      `, name).toArray()[0];
+	return row === void 0 ? void 0 : {
+		name: row.reducer_name,
+		schemaVersion: row.schema_version,
+		throughSeq: SequenceNumber.make(row.through_seq),
+		payload: JSON.parse(row.payload_json),
+		updatedAtMs: row.updated_at_ms
+	};
+};
+const writeReducerCheckpoint = (sql, checkpoint) => {
+	sql.exec(`
+      INSERT INTO _eda_reducer_checkpoints (
+        reducer_name,
+        schema_version,
+        through_seq,
+        payload_json,
+        updated_at_ms
+      ) VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(reducer_name) DO UPDATE SET
+        schema_version = excluded.schema_version,
+        through_seq = excluded.through_seq,
+        payload_json = excluded.payload_json,
+        updated_at_ms = excluded.updated_at_ms
+    `, checkpoint.name, checkpoint.schemaVersion, checkpoint.throughSeq, stringifyJsonForColumn(checkpoint.payload, "_eda_reducer_checkpoints.payload_json"), checkpoint.updatedAtMs);
+};
+const readMessagePayloadByContextSeq = (sql, contextSeq) => {
+	const message = sql.exec(`
+        SELECT context_seq, payload_json
+        FROM _eda_context_messages
+        WHERE context_seq = ?
+      `, contextSeq).toArray()[0];
+	if (message === void 0) throw new Error(`Context message at seq ${contextSeq} missing from _eda_context_messages`);
+	return message;
+};
+const readCommittedBySeq = (sql, sessionId, seq) => {
+	const row = sql.exec(`
+        SELECT seq, event_id, namespace, type, schema_version, created_at_ms, trace_json, fact_json
+        FROM _eda_event_log
+        WHERE seq = ?
+      `, seq).one();
+	return rowToCommittedDurableEvent(sql, row, sessionId);
+};
+const rowToCommittedDurableEvent = (sql, row, sessionId) => ({
+	position: durablePosition(SequenceNumber.make(row.seq)),
+	event: decodeDurableEventSync({
+		namespace: row.namespace,
+		type: row.type,
+		schemaVersion: row.schema_version,
+		durability: "durable",
+		eventId: row.event_id,
+		sessionId,
+		createdAtMs: row.created_at_ms,
+		trace: JSON.parse(row.trace_json),
+		payload: readLogicalPayload(sql, row)
+	})
+});
+const encodeEventLogRow = (event) => {
+	const encoded = Schema.encodeSync(DurableEventEnvelope)(event);
+	return {
+		eventId: encoded.eventId,
+		namespace: encoded.namespace,
+		type: encoded.type,
+		schemaVersion: encoded.schemaVersion,
+		createdAtMs: encoded.createdAtMs,
+		traceJson: stringifyJsonForColumn(encoded.trace, "_eda_event_log.trace_json"),
+		factJson: stringifyJsonForColumn(eventLogFactPayload(encoded.namespace, encoded.type, encoded.payload), "_eda_event_log.fact_json")
+	};
+};
+const readLogicalPayload = (sql, row) => {
+	if (row.namespace !== effectDurableAgentNamespace) return JSON.parse(row.fact_json);
+	if (row.type === commandAdmittedEventType) {
+		const commandId = readCommandIdFromFact(row);
+		return { command: readCommandInputPayload(sql, commandId) };
+	}
+	if (contextMessageEventTypes.has(row.type)) return JSON.parse(readMessagePayloadByContextSeq(sql, row.seq).payload_json);
+	if (row.type === summaryCreatedEventType) return {
+		...JSON.parse(row.fact_json),
+		summary: readSummaryPayloadFromCreatedSeq(sql, row.seq)
+	};
+	return JSON.parse(row.fact_json);
+};
+const eventLogFactPayload = (namespace, type, payload) => {
+	if (namespace !== effectDurableAgentNamespace || typeof payload !== "object" || payload === null) return payload;
+	const record = Schema.decodeUnknownSync(Schema.Record(Schema.String, Schema.Unknown))(payload);
+	switch (type) {
+		case commandAdmittedEventType: return { command: commandFact(record.command) };
+		case systemMessageCommittedEventType: return pick(record, ["messageId"]);
+		case userMessageCommittedEventType: return pick(record, ["commandId", "messageId"]);
+		case steeringMessageQueuedEventType: return pick(record, [
+			"commandId",
+			"messageId",
+			"runId"
+		]);
+		case assistantMessageCommittedEventType:
+		case assistantMessageImportedEventType: return pick(record, [
+			"messageId",
+			"runId",
+			"turnId",
+			"inferenceId"
+		]);
+		case assistantPartialCommittedEventType: return pick(record, [
+			"messageId",
+			"runId",
+			"turnId",
+			"inferenceId",
+			"reason"
+		]);
+		case summaryCreatedEventType: return pick(record, [
+			"compactionId",
+			"summaryId",
+			"sourceFromSeq",
+			"sourceToSeq"
+		]);
+		default: return payload;
+	}
+};
+const commandFact = (command) => {
+	if (typeof command !== "object" || command === null) return command;
+	const record = command;
+	return record._tag === "SubmitMessage" ? pick(record, [
+		"_tag",
+		"commandId",
+		"disposition",
+		"idempotencyKey"
+	]) : command;
+};
+const pick = (record, keys) => {
+	const out = {};
+	for (const key of keys) if (record[key] !== void 0) out[key] = record[key];
+	return out;
+};
+const readCommandIdFromFact = (row) => {
+	const { command: { commandId } } = Schema.decodeUnknownSync(Schema.Struct({ command: Schema.Struct({ commandId: Schema.String }) }))(JSON.parse(row.fact_json));
+	if (typeof commandId !== "string") throw new Error(`CommandAdmitted fact at seq ${row.seq} missing command.commandId`);
+	return commandId;
+};
+const readCommandInputPayload = (sql, commandId) => {
+	const row = sql.exec(`
+        SELECT payload_json
+        FROM _eda_command_inputs
+        WHERE command_id = ?
+      `, commandId).toArray()[0];
+	if (row === void 0) throw new Error(`Command input ${commandId} missing from _eda_command_inputs`);
+	return JSON.parse(row.payload_json);
+};
+const readSummaryPayloadOptional = (sql, summaryId) => {
+	const row = sql.exec(`
+        SELECT payload_json
+        FROM _eda_context_summaries
+        WHERE summary_id = ?
+      `, summaryId).toArray()[0];
+	return row === void 0 ? void 0 : Schema.decodeUnknownSync(CompactionSummaryArtifact)(JSON.parse(row.payload_json));
+};
+const readSummaryPayloadFromCreatedSeq = (sql, createdSeq) => {
+	const row = sql.exec(`
+        SELECT payload_json
+        FROM _eda_context_summaries
+        WHERE created_seq = ?
+      `, createdSeq).toArray()[0];
+	if (row === void 0) throw new Error(`SummaryCreated at seq ${createdSeq} missing from _eda_context_summaries`);
+	return JSON.parse(row.payload_json);
+};
+/**
+* Maintain bounded storage projections in the same transaction as the event.
+*
+* These rows are durability aids, not a second source of lifecycle truth: event
+* order still comes from `_eda_event_log.seq`, while projections make command
+* lookup and body-sidecar hydration bounded.
+*/
+const applySynchronousProjections = (sql, entry, seq, factJson) => {
+	const { event } = entry;
+	if (event.namespace !== effectDurableAgentNamespace) return;
+	writeCommandProjection(sql, event, seq, factJson);
+	writeCommandInputProjection(sql, event, seq);
+	writeMessageProjection(sql, event, seq);
+	writeSummaryProjection(sql, event, seq);
+	writeContextRebaseProjection(sql, event, seq);
+};
+const writeCommandProjection = (sql, event, seq, factJson) => {
+	const payload = Schema.decodeUnknownSync(ProjectionPayload)(event.payload);
+	switch (event.type) {
+		case commandAdmittedEventType: {
+			const command = Schema.decodeUnknownSync(AdmittedCommandProjection)(payload.command);
+			const commandId = command.commandId;
+			if (commandId === void 0) throw new Error("CommandAdmitted missing command.commandId");
+			sql.exec(`
+          INSERT INTO _eda_command_state (
+            command_id,
+            admitted_seq,
+            status,
+            idempotency_key,
+            payload_json
+          ) VALUES (?, ?, ?, ?, ?)
+          ON CONFLICT(command_id) DO UPDATE SET
+            admitted_seq = excluded.admitted_seq,
+            status = excluded.status,
+            idempotency_key = excluded.idempotency_key,
+            payload_json = excluded.payload_json
+        `, commandId, seq, "admitted", command.idempotencyKey ?? null, factJson);
+			return;
+		}
+		case commandStartedEventType:
+			writeCommandStatus(sql, payload.commandId, seq, "started", factJson);
+			return;
+		case commandCompletedEventType:
+			writeCommandStatus(sql, payload.commandId, seq, "completed", factJson);
+			return;
+		case commandFailedEventType:
+			writeCommandStatus(sql, payload.commandId, seq, "failed", factJson);
+			return;
+		case commandCancelledEventType:
+			writeCommandStatus(sql, payload.commandId, seq, "cancelled", factJson);
+			return;
+		default: return;
+	}
+};
+const writeCommandStatus = (sql, commandId, seq, status, payloadJson) => {
+	if (commandId === void 0) throw new Error(`${status} command event missing commandId`);
+	sql.exec(`
+      INSERT INTO _eda_command_state (
+        command_id,
+        admitted_seq,
+        status,
+        idempotency_key,
+        payload_json
+      ) VALUES (?, ?, ?, NULL, ?)
+      ON CONFLICT(command_id) DO UPDATE SET
+        status = excluded.status,
+        payload_json = excluded.payload_json
+    `, commandId, seq, status, payloadJson);
+};
+const writeCommandInputProjection = (sql, event, seq) => {
+	if (event.type !== commandAdmittedEventType) return;
+	const encoded = Schema.encodeSync(DurableEventEnvelope)(event);
+	const { command } = Schema.decodeUnknownSync(Schema.Struct({ command: Schema.Record(Schema.String, Schema.Unknown) }))(encoded.payload);
+	const commandId = command?.commandId;
+	if (commandId === void 0) throw new Error("CommandAdmitted missing command.commandId");
+	sql.exec(`
+      INSERT INTO _eda_command_inputs (
+        command_id,
+        admitted_seq,
+        payload_json
+      ) VALUES (?, ?, ?)
+      ON CONFLICT(command_id) DO UPDATE SET
+        admitted_seq = excluded.admitted_seq,
+        payload_json = excluded.payload_json
+    `, commandId, seq, stringifyJsonForColumn(command, "_eda_command_inputs.payload_json"));
+};
+const contextMessageEventTypes = /* @__PURE__ */ new Set([
+	systemMessageCommittedEventType,
+	userMessageCommittedEventType,
+	steeringMessageQueuedEventType,
+	assistantMessageCommittedEventType,
+	assistantMessageImportedEventType,
+	assistantPartialCommittedEventType
+]);
+/** Persist model-visible message bodies with the seq that exposed them to context. */
+const writeMessageProjection = (sql, event, seq) => {
+	if (!contextMessageEventTypes.has(event.type)) return;
+	const encoded = Schema.encodeSync(DurableEventEnvelope)(event);
+	const { messageId } = Schema.decodeUnknownSync(Schema.Struct({ messageId: Schema.Unknown }))(encoded.payload);
+	if (messageId === void 0) throw new Error(`${event.type} missing messageId`);
+	sql.exec(`
+      INSERT INTO _eda_context_messages (
+        message_id,
+        context_seq,
+        payload_json
+      ) VALUES (?, ?, ?)
+      ON CONFLICT(message_id) DO UPDATE SET
+        context_seq = excluded.context_seq,
+        payload_json = excluded.payload_json
+    `, messageId, seq, stringifyJsonForColumn(encoded.payload, "_eda_context_messages.payload_json"));
+};
+/**
+* Persist a cumulative summary artifact without making it the active context.
+*
+* `ContextRebased` selects summaries in the framework reduced-state checkpoint;
+* failed compactions can leave orphaned summaries without changing future context.
+*/
+const writeSummaryProjection = (sql, event, seq) => {
+	if (event.type !== summaryCreatedEventType) return;
+	const payload = Schema.decodeUnknownSync(SummaryCreatedPayload)(event.payload);
+	const summaryId = payload.summaryId;
+	if (summaryId === void 0) throw new Error("SummaryCreated missing summaryId");
+	if (payload.summary === void 0) throw new Error("SummaryCreated requires summary payload");
+	const summary = Schema.decodeUnknownSync(CompactionSummaryArtifact)(payload.summary);
+	if (summary.summaryId !== summaryId) throw new Error("SummaryCreated summaryId does not match summary payload");
+	if (summary.compactionId !== payload.compactionId) throw new Error("SummaryCreated compactionId does not match summary payload");
+	sql.exec(`
+      INSERT INTO _eda_context_summaries (
+        summary_id,
+        created_seq,
+        payload_json
+      ) VALUES (?, ?, ?)
+      ON CONFLICT(summary_id) DO UPDATE SET
+        created_seq = excluded.created_seq,
+        payload_json = excluded.payload_json
+    `, summaryId, seq, stringifyJsonForColumn(summary, "_eda_context_summaries.payload_json"));
+};
+/** Validate that `ContextRebased` points at a committed summary sidecar. */
+const writeContextRebaseProjection = (sql, event, _seq) => {
+	if (event.type !== contextRebasedEventType) return;
+	const payload = Schema.decodeUnknownSync(ContextRebasedPayload)(event.payload);
+	if (payload.summaryId === void 0) throw new Error("ContextRebased missing summaryId");
+	const summary = readSummaryPayloadOptional(sql, SummaryId.make(String(payload.summaryId)));
+	if (summary === void 0) throw new Error(`ContextRebased references unknown summaryId ${String(payload.summaryId)}`);
+	if (summary.compactionId !== payload.compactionId) throw new Error("ContextRebased summary compactionId does not match event payload");
+	if (summary.retainedFromContextSeq !== payload.retainedFromContextSeq) throw new Error("ContextRebased retained cursor does not match summary payload");
+};
+/**
+* Lookup prior command admission through `_eda_command_state` instead of genesis replay.
+*
+* Idempotency key wins over explicit command id so caller-owned retry keys remain
+* the stable dedupe surface for external ingress.
+*/
+const findCommandAdmissionRow = (sql, commandId, idempotencyKey) => {
+	if (idempotencyKey !== void 0) {
+		const row = sql.exec(`
+          SELECT admitted_seq
+          FROM _eda_command_state
+          WHERE idempotency_key = ?
+        `, idempotencyKey).toArray()[0];
+		if (row !== void 0) return row;
+	}
+	if (commandId === void 0) return;
+	return sql.exec(`
+        SELECT admitted_seq
+        FROM _eda_command_state
+        WHERE command_id = ?
+      `, commandId).toArray()[0];
+};
+const durableStoreError = (operation, cause) => new EDASessionStoreError({ message: cause instanceof Error ? `${operation}: ${cause.message}` : `${operation}: ${String(cause)}` });
+//#endregion
+export { emptyTranscriptEffects as a, publishTranscriptEffects as c, TranscriptRowDecodeError as d, makeTranscriptWindowSource as f, transcriptVersionMetaOf as h, defaultTranscriptSliceLimits as i, reconcileTranscriptSlots as l, readTranscriptSlots as m, makeDurableObjectEventLog as n, hasPendingTranscriptWork as o, readOrMintLogIncarnation as p, carriedDefinition as r, missedSessionAlert as s, DurableObjectSessionStore as t, runTranscriptSlice as u };
+
+//# sourceMappingURL=durable-object-store-Dct3N6rk.js.map