effect-durable-agent-cloudflare 0.1.0-alpha.10

package/dist/session-controller-C31DhUNp.js

@@ -0,0 +1,1459 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { DurableEventEnvelope, assistantMessageCommittedEventType, assistantMessageImportedEventType, assistantPartialCommittedEventType, commandAdmittedEventType, commandCancelledEventType, commandCompletedEventType, commandFailedEventType, commandStartedEventType, contextRebasedEventType, decodeUnknownEDADurableEventSync, effectDurableAgentNamespace, steeringMessageQueuedEventType, summaryCreatedEventType, systemMessageCommittedEventType, userMessageCommittedEventType } from "effect-durable-agent/types/events";
+import { SequenceNumber, SessionId, SummaryId, durablePosition } from "effect-durable-agent/types/core";
+import { EDATraceMetadata, makeRootEDATraceMetadata } from "effect-durable-agent/types/tracing";
+import { annotateEdaSpan, committedBatchAttributes, compactSpanAttributes, toEdaExternalSpan } from "effect-durable-agent/services/tracing";
+import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import { EDARuntime } from "effect-durable-agent/services/runtime";
+import { CommittedDurableEvent, EDASessionStore, EDASessionStoreError } from "effect-durable-agent/services/session-store";
+import { SinkCheckpointStore } from "effect-durable-agent/services/sink-checkpoint-store";
+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 { RunSchedulingWakeup } from "effect-durable-agent/services/run-scheduling-wakeup";
+import "effect-durable-agent/services/compaction";
+import { EDAKeepAlive } from "effect-durable-agent/services/keep-alive";
+import "effect-durable-agent/services/prompt-projector";
+import { EDAReducerRegistry } from "effect-durable-agent/services/reducer-registry";
+import { makeEDARuntimeLayer } from "effect-durable-agent/services/runtime-layer";
+import { SessionEventObserver } from "effect-durable-agent/services/session-event-observer";
+import { EDAWebSocketDeliveryCheckpoint, EDA_WEB_SOCKET_PING_MESSAGE, EDA_WEB_SOCKET_PONG_MESSAGE, EDA_WS_CLOSE_PROTOCOL_ERROR, EDA_WS_CLOSE_SEND_FAILED, SubscriberId, checkpointWebSocketDeliveryState, decodeEDAWebSocketClientMessage, defaultEDAWebSocketFlowControl, deliveryHelloFrame, encodeEDAWebSocketServerFrame, makeWebSocketDeliveryState, onClientAck, onDurableEvents, onEphemeralEvent, onHostSuppressedFrame, restoreWebSocketDeliveryState } from "effect-durable-agent/websocket";
+/**
+* Alarm-backed in-memory keepalive for a raw Durable Object host.
+*
+* The active lease count is intentionally not durable: if the object is evicted
+* or crashes, the fibers the leases represented are gone too, and normal EDA
+* durable recovery must explain any escaped lifecycle boundaries.
+*/
+var DurableObjectKeepAlive = class {
+	storage;
+	background;
+	intervalMs;
+	now;
+	onBackgroundError;
+	activeLeases = 0;
+	runSchedulingPending = false;
+	generation = 0;
+	scheduleTail = Promise.resolve();
+	shutdownRequested = false;
+	constructor(storage, background = void 0, options = {}) {
+		this.storage = storage;
+		this.background = background;
+		this.intervalMs = options.intervalMs ?? 3e4;
+		this.now = options.now ?? (() => Date.now());
+		this.onBackgroundError = options.onBackgroundError ?? (() => void 0);
+	}
+	/** Number of active unsettled host roots currently holding the heartbeat. */
+	get activeLeaseCount() {
+		return this.activeLeases;
+	}
+	/** Durable delivery work survives the release of every in-memory active lease. */
+	setRunSchedulingPending(pending) {
+		this.runSchedulingPending = pending;
+		return this.reschedule();
+	}
+	/** Acquire one active-work lease and arm the heartbeat if this is the first lease. */
+	acquire() {
+		if (this.shutdownRequested) return Promise.reject(/* @__PURE__ */ new Error("DurableObjectKeepAlive is shut down"));
+		this.activeLeases += 1;
+		const generation = this.generation;
+		let released = false;
+		return this.reschedule().then(() => ({ release: async () => {
+			if (released) return;
+			released = true;
+			if (generation !== this.generation) return;
+			this.activeLeases = Math.max(0, this.activeLeases - 1);
+			await this.reschedule();
+		} }), async (error) => {
+			released = true;
+			if (generation !== this.generation) throw error;
+			this.activeLeases = Math.max(0, this.activeLeases - 1);
+			await this.reschedule().catch(this.onBackgroundError);
+			throw error;
+		});
+	}
+	/** Run a promise while holding a lease. Intended for host adapters, not EDA internals. */
+	async runWhileActive(fn) {
+		const lease = await this.acquire();
+		try {
+			return await fn();
+		} finally {
+			await lease.release();
+		}
+	}
+	/**
+	* Track an already-forked Effect fiber as active host work until it settles.
+	*
+	* Use this with `ManagedRuntime.runFork(...)` when the fiber needs an already
+	* built runtime context. The returned lease can be released manually, but it
+	* is normally released by the fiber observer.
+	*/
+	async trackFiber(fiber) {
+		const lease = await this.acquire();
+		fiber.addObserver(() => {
+			this.waitUntil(lease.release().catch((error) => {
+				this.onBackgroundError(error);
+			}));
+		});
+		if (fiber.pollUnsafe() !== void 0) await lease.release();
+		return lease;
+	}
+	/**
+	* Fork an Effect as host-tracked active work.
+	*
+	* This mirrors Effect's host-runner pattern: observe the root fiber and release
+	* the alarm lease when it settles. It deliberately does not patch Effect
+	* internals or try to classify runnable vs suspended fibers.
+	*/
+	async fork(effect) {
+		const fiber = Effect.runFork(effect);
+		await this.trackFiber(fiber);
+		return fiber;
+	}
+	/** Handle the Durable Object `alarm()` callback and re-arm while work remains. */
+	alarm() {
+		return this.reschedule();
+	}
+	/** Permanently stop the heartbeat and prevent later lease releases from re-arming it. */
+	shutdown() {
+		this.shutdownRequested = true;
+		this.generation += 1;
+		this.activeLeases = 0;
+		this.runSchedulingPending = false;
+		return this.reschedule();
+	}
+	/** Start a fresh lease generation after the host intentionally resets its durable state. */
+	restart() {
+		this.shutdownRequested = false;
+	}
+	waitUntil(promise) {
+		if (this.background !== void 0) {
+			this.background.waitUntil(promise);
+			return;
+		}
+	}
+	reschedule() {
+		this.scheduleTail = this.scheduleTail.catch(() => void 0).then(() => this.syncAlarm());
+		return this.scheduleTail;
+	}
+	async syncAlarm() {
+		if (this.shutdownRequested || this.activeLeases === 0 && !this.runSchedulingPending) {
+			await this.storage.deleteAlarm();
+			return;
+		}
+		const desiredAt = this.now() + this.intervalMs;
+		const currentAt = await this.storage.getAlarm();
+		if (currentAt === null || currentAt > desiredAt) await this.storage.setAlarm(desiredAt);
+	}
+};
+//#endregion
+//#region src/durable-object-sink-checkpoints.ts
+/**
+* Durable Object SQLite adapter for EDA sink checkpoints.
+*
+* Checkpoint SQL stays in the host layer for the same reason session storage SQL
+* does: framework sink code should depend on checkpoint semantics, not table access.
+*/
+var DurableObjectSinkCheckpointStore = class DurableObjectSinkCheckpointStore {
+	/** Ensure the fixed `_eda_sink_cursors` table exists during host startup. */
+	static migrate = (storage) => migrateSinkCheckpointStore(storage);
+	/** Build the semantic checkpoint store over native DO SQLite. */
+	static make = (storage) => makeDurableObjectSinkCheckpointStore(storage);
+	static layer = (storage) => Layer.effect(SinkCheckpointStore, DurableObjectSinkCheckpointStore.make(storage));
+};
+/** Create the sink checkpoint table inside the current EDA storage schema. */
+const migrateSinkCheckpointStore = (storage) => Effect.try({
+	try: () => {
+		storage.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
+        )
+      `);
+	},
+	catch: (error) => sinkCheckpointError("migrating SinkCheckpointStore", error)
+});
+/** Interpret checkpoint load/save/commit with idempotent upserts. */
+const makeDurableObjectSinkCheckpointStore = (storage) => Effect.gen(function* () {
+	yield* DurableObjectSinkCheckpointStore.migrate(storage);
+	const { sql } = storage;
+	return {
+		load: (sinkName) => Effect.try({
+			try: () => {
+				const row = sql.exec(`SELECT after_seq, payload_json FROM _eda_sink_cursors WHERE sink_name = ?`, sinkName).toArray()[0];
+				return row === void 0 ? {
+					afterSeq: SequenceNumber.make(0),
+					payload: void 0
+				} : {
+					afterSeq: SequenceNumber.make(row.after_seq),
+					payload: JSON.parse(row.payload_json)
+				};
+			},
+			catch: (error) => sinkCheckpointError("reading sink checkpoint", error)
+		}),
+		saveState: (sinkName, payload) => Effect.try({
+			try: () => {
+				sql.exec(`
+                INSERT INTO _eda_sink_cursors (sink_name, after_seq, payload_json)
+                VALUES (?, 0, ?)
+                ON CONFLICT(sink_name) DO UPDATE SET
+                  payload_json = excluded.payload_json
+              `, sinkName, JSON.stringify(payload));
+			},
+			catch: (error) => sinkCheckpointError("saving sink checkpoint state", error)
+		}),
+		commit: (sinkName, afterSeq, payload) => Effect.try({
+			try: () => {
+				sql.exec(`
+                INSERT INTO _eda_sink_cursors (sink_name, after_seq, payload_json)
+                VALUES (?, ?, ?)
+                ON CONFLICT(sink_name) DO UPDATE SET
+                  after_seq = excluded.after_seq,
+                  payload_json = excluded.payload_json
+              `, sinkName, afterSeq, JSON.stringify(payload ?? { updatedAtMs: Date.now() }));
+			},
+			catch: (error) => sinkCheckpointError("committing sink checkpoint", error)
+		})
+	};
+});
+const sinkCheckpointError = (operation, cause) => new EDASessionStoreError({ message: cause instanceof Error ? `${operation}: ${cause.message}` : `${operation}: ${String(cause)}` });
+//#endregion
+//#region src/durable-object-store.ts
+/** Safe payload ceiling below the Durable Object SQLite 2 MB value limit. */
+/** Conservative JSON limit below the Durable Object SQLite per-value ceiling. */
+const durableObjectSerializedJsonHardCapBytes = 15e5;
+const ProjectionPayload = Schema.Record(Schema.String, Schema.Unknown);
+const AdmittedCommandProjection = Schema.Struct({
+	commandId: Schema.Unknown,
+	idempotencyKey: Schema.optionalKey(Schema.Unknown)
+});
+/** Single squashed schema version for the current pre-release DO store. */
+const durableObjectSessionStoreSchemaVersion = 1;
+const jsonEncoder = new TextEncoder();
+/**
+* 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 }) => Effect.gen(function* () {
+		yield* DurableObjectSessionStore.migrate(storage);
+		return makeDurableObjectSessionStore(sessionId, storage);
+	});
+	/** 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'))
+          )
+        `);
+		if ((sql.exec("SELECT COALESCE(MAX(id), 0) AS version FROM _eda_schema_migrations").one().version ?? 0) < 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);
+		}
+	}),
+	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) => {
+	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.
+	*/
+	const insertOrRead = (entry) => {
+		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);
+		return rowToCommittedDurableEvent(sql, row, sessionId);
+	};
+	/** Execute an entire append batch as one synchronous SQLite transaction. */
+	const append = (batch) => Effect.try({
+		try: () => storage.transactionSync(() => batch.entries.map(insertOrRead)),
+		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)
+		})
+	};
+};
+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) => {
+	return rowToCommittedDurableEvent(sql, 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(), sessionId);
+};
+const rowToCommittedDurableEvent = (sql, row, sessionId) => CommittedDurableEvent.make({
+	position: durablePosition(SequenceNumber.make(row.seq)),
+	event: decodeDurableEvent({
+		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 decodeDurableEvent = (input) => {
+	const event = Schema.decodeUnknownSync(DurableEventEnvelope)(input);
+	return event.namespace === effectDurableAgentNamespace ? decodeUnknownEDADurableEventSync(event) : event;
+};
+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) return { command: readCommandInputPayload(sql, readCommandIdFromFact(row)) };
+	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 = 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 commandId = JSON.parse(row.fact_json).command?.commandId;
+	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 command = Schema.encodeSync(DurableEventEnvelope)(event).payload.command;
+	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 = 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 = encoded.payload.messageId;
+	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 = 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 = 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];
+};
+/** 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;
+};
+const durableStoreError = (operation, cause) => new EDASessionStoreError({ message: cause instanceof Error ? `${operation}: ${cause.message}` : `${operation}: ${String(cause)}` });
+//#endregion
+//#region src/runtime/runtime-layer.ts
+/** Compose the platform-neutral runtime with Cloudflare persistence and lifecycle adapters. */
+const makeEDADurableObjectRuntimeLayer = ({ config, compactionExecutorLayer, compactionPolicyLayer, keepAlive, modelResolverLayer, promptProjectorLayer, reducers, runSchedulerLayer, sessionEventObserverLayer, sessionId, sinks, storage, toolkit, toolRegistry, tracer }) => {
+	const lifecycle = keepAlive ?? new DurableObjectKeepAlive(storage);
+	return makeEDARuntimeLayer({
+		config,
+		compactionExecutorLayer,
+		compactionPolicyLayer,
+		keepAliveLayer: EDAKeepAlive.FromAcquire(() => lifecycle.acquire()),
+		modelResolverLayer,
+		promptProjectorLayer,
+		runSchedulerLayer,
+		runSchedulingWakeupLayer: Layer.succeed(RunSchedulingWakeup, { setPending: (pending) => Effect.tryPromise({
+			try: () => lifecycle.setRunSchedulingPending(pending),
+			catch: (error) => new EDASessionStoreError({ message: `Persisting run scheduling wakeup: ${String(error)}` })
+		}) }),
+		reducerRegistryLayer: EDAReducerRegistry.Live(reducers ?? []),
+		sessionEventObserverLayer,
+		sessionId,
+		sessionStoreLayer: DurableObjectSessionStore.layer({
+			sessionId,
+			storage
+		}),
+		sinkCheckpointStoreLayer: DurableObjectSinkCheckpointStore.layer(storage),
+		sinks,
+		toolkit,
+		toolRegistry,
+		tracer
+	});
+};
+//#endregion
+//#region src/runtime/session-runtime.ts
+/** Owns the disposable ManagedRuntime and nothing about WebSocket transport. */
+var EDASessionRuntime = class {
+	options;
+	keepAlive;
+	state;
+	building;
+	constructor(options) {
+		this.options = options;
+		this.keepAlive = options.keepAlive ?? new DurableObjectKeepAlive(options.storage, options.background);
+	}
+	static migrate = (storage) => Effect.gen(function* () {
+		yield* DurableObjectSessionStore.migrate(storage);
+		yield* DurableObjectSinkCheckpointStore.migrate(storage);
+	});
+	isReady(sessionId) {
+		return this.state?.sessionId === sessionId;
+	}
+	async prepare(sessionId) {
+		await this.get(sessionId);
+	}
+	async run(sessionId, operation) {
+		return await (await this.get(sessionId)).runtime.runPromise(Effect.gen(function* () {
+			return yield* operation(yield* EDARuntime);
+		}));
+	}
+	async alarm(sessionId) {
+		const resolved = sessionId ?? this.state?.sessionId;
+		if (resolved !== void 0) await this.run(resolved, (runtime) => runtime.retryRunSchedulingDelivery());
+		await this.keepAlive.alarm();
+	}
+	async destroy() {
+		await this.keepAlive.shutdown();
+		await this.dispose();
+		this.state = void 0;
+		this.building = void 0;
+	}
+	async dispose() {
+		await this.state?.runtime.dispose();
+	}
+	async get(sessionId) {
+		if (this.state !== void 0) {
+			if (this.state.sessionId !== sessionId) throw new Error(`EDA session runtime is scoped to session ${this.state.sessionId}; received ${sessionId}`);
+			return this.state;
+		}
+		this.keepAlive.restart();
+		const building = this.building ?? this.build(sessionId);
+		this.building = building;
+		try {
+			return await building;
+		} catch (error) {
+			if (this.building === building) this.building = void 0;
+			throw error;
+		}
+	}
+	async build(sessionId) {
+		const runtime = ManagedRuntime.make(makeEDADurableObjectRuntimeLayer({
+			config: this.options.config,
+			compactionExecutorLayer: this.options.compactionExecutorLayer,
+			compactionPolicyLayer: this.options.compactionPolicyLayer,
+			keepAlive: this.keepAlive,
+			modelResolverLayer: this.options.modelResolverLayer,
+			promptProjectorLayer: this.options.promptProjectorLayer,
+			reducers: this.options.reducers,
+			runSchedulerLayer: this.options.runSchedulerLayer,
+			sessionEventObserverLayer: this.options.sessionEventObserverLayer,
+			sessionId,
+			sinks: this.options.sinks,
+			storage: this.options.storage,
+			toolkit: resolveFactory(this.options.toolkit, sessionId),
+			toolRegistry: resolveFactory(this.options.toolRegistry, sessionId),
+			tracer: resolveFactory(this.options.tracer, sessionId)
+		}));
+		const state = {
+			runtime,
+			sessionId
+		};
+		try {
+			await runtime.context();
+			this.state = state;
+			return state;
+		} catch (error) {
+			await runtime.dispose().catch(() => void 0);
+			throw error;
+		}
+	}
+};
+const resolveFactory = (value, sessionId) => typeof value === "function" ? value({ sessionId }) : value;
+//#endregion
+//#region src/websocket/projection.ts
+/** Stable non-empty identity persisted with an app WebSocket projection. */
+const EDAWebSocketProjectionId = Schema.NonEmptyString.pipe(Schema.brand("EDAWebSocketProjectionId"));
+//#endregion
+//#region src/websocket/attachment.ts
+/** Versioned state required to resume strict delivery after Durable Object hibernation. */
+const EDAWebSocketAttachment = Schema.Struct({
+	kind: Schema.Literal("eda-events-v2"),
+	sessionId: SessionId,
+	subscriberId: SubscriberId,
+	trace: EDATraceMetadata,
+	delivery: EDAWebSocketDeliveryCheckpoint,
+	projection: Schema.optionalKey(Schema.Struct({
+		id: EDAWebSocketProjectionId,
+		state: Schema.Unknown
+	}))
+});
+/** Decode and classify an attachment read from Cloudflare's structured-clone boundary. */
+const decodeWebSocketAttachment = async (input) => {
+	if (input === null || input === void 0) return { _tag: "Missing" };
+	try {
+		return {
+			_tag: "Decoded",
+			attachment: await Effect.runPromise(Schema.decodeUnknownEffect(EDAWebSocketAttachment)(input))
+		};
+	} catch {
+		return { _tag: "Malformed" };
+	}
+};
+/** Encode before serialization so schema transformations cannot leak into attachments. */
+const encodeWebSocketAttachment = (attachment) => Schema.encodeSync(EDAWebSocketAttachment)(attachment);
+//#endregion
+//#region src/websocket/connection-manager.ts
+/**
+* Owns Cloudflare WebSockets, hibernation attachments, and interpretation of
+* the platform-neutral delivery state machine.
+*/
+var EDAWebSocketConnectionManager = class {
+	options;
+	observerLayer = SessionEventObserver.FromHandler((event) => Effect.tryPromise(() => this.fanoutPublishedEvent(event)).pipe(Effect.catchCause((cause) => Effect.logError("EDA WebSocket event observer recovered from a host failure", { cause }))));
+	sockets = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	resolveProjection(id) {
+		if (id === void 0) return void 0;
+		if (this.options.webSocketProjection?.id === id) return this.options.webSocketProjection;
+	}
+	async accept(input) {
+		const subscriberId = SubscriberId.make(crypto.randomUUID());
+		const delivery = makeWebSocketDeliveryState({
+			subscriberId,
+			resumeSeq: input.afterSeq,
+			policy: defaultEDAWebSocketFlowControl
+		});
+		const state = {
+			sessionId: input.sessionId,
+			subscriberId,
+			trace: input.trace,
+			delivery,
+			catchUpDeferred: false,
+			head: input.afterSeq,
+			queue: Promise.resolve(),
+			...input.projectionState === void 0 ? {} : { projectionState: input.projectionState }
+		};
+		this.sockets.set(input.webSocket, state);
+		if (!this.persist(input.webSocket, state)) return;
+		if (!await this.send(input.webSocket, state, [deliveryHelloFrame(delivery)])) return;
+		if (!await this.prepare(input.webSocket, state)) return;
+		await this.enqueue(input.webSocket, state, async () => {
+			await this.readAndDeliver(input.webSocket, state, input.afterSeq);
+		});
+	}
+	async message(webSocket, message) {
+		if (typeof message !== "string") {
+			this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "binary");
+			return;
+		}
+		if (message === EDA_WEB_SOCKET_PING_MESSAGE) {
+			try {
+				webSocket.send(EDA_WEB_SOCKET_PONG_MESSAGE);
+			} catch {
+				this.close(webSocket, EDA_WS_CLOSE_SEND_FAILED, "send-failed");
+			}
+			return;
+		}
+		const state = await this.restore(webSocket);
+		if (state === void 0) {
+			this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+			return;
+		}
+		const frame = await Effect.runPromise(this.decodeClientMessage(message, state).pipe(Effect.option));
+		if (frame._tag === "None") {
+			this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+			return;
+		}
+		const clientFrame = frame.value;
+		if (clientFrame._tag === "ping") return;
+		if (!await this.prepare(webSocket, state)) return;
+		await this.enqueue(webSocket, state, async () => {
+			await this.interpret(webSocket, state, onClientAck(state.delivery, clientFrame, Date.now()));
+		});
+	}
+	closed(webSocket) {
+		this.sockets.delete(webSocket);
+	}
+	async flushDeferredCatchUp(sessionId) {
+		const deliveries = [];
+		for (const [webSocket, state] of this.sockets) {
+			if (state.sessionId !== sessionId || !state.catchUpDeferred) continue;
+			deliveries.push(this.enqueue(webSocket, state, async () => {
+				if (!state.catchUpDeferred) return;
+				state.catchUpDeferred = false;
+				await this.readAndDeliver(webSocket, state, state.delivery.sentDurableThroughSeq);
+			}));
+		}
+		await Promise.all(deliveries);
+	}
+	async fanoutPublishedEvent(event) {
+		const webSockets = new Set([...this.options.getWebSockets?.() ?? [], ...this.sockets.keys()]);
+		const deliveries = [];
+		for (const webSocket of webSockets) {
+			const state = await this.restore(webSocket);
+			if (state === void 0) continue;
+			deliveries.push(this.enqueue(webSocket, state, async () => {
+				if (event.event.durability !== "durable") {
+					await this.interpret(webSocket, state, onEphemeralEvent(state.delivery, event, Date.now()));
+					return;
+				}
+				state.head = SequenceNumber.make(Math.max(state.head, event.position.seq));
+				if (event.position.seq <= state.delivery.sentDurableThroughSeq) return;
+				if (event.position.seq === state.delivery.sentDurableThroughSeq + 1) {
+					await this.interpret(webSocket, state, onDurableEvents(state.delivery, [event], state.head, Date.now()));
+					return;
+				}
+				if (!this.options.isSessionReady(state.sessionId)) {
+					state.catchUpDeferred = true;
+					return;
+				}
+				await this.readAndDeliver(webSocket, state, state.delivery.sentDurableThroughSeq);
+			}));
+		}
+		await Promise.all(deliveries);
+	}
+	async restore(webSocket) {
+		const existing = this.sockets.get(webSocket);
+		if (existing !== void 0) return existing;
+		const decoded = await decodeWebSocketAttachment(webSocket.deserializeAttachment());
+		if (decoded._tag !== "Decoded") {
+			this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+			return;
+		}
+		const attachment = decoded.attachment;
+		const projectionState = attachment.projection === void 0 ? void 0 : await this.decodeProjectionState(attachment.projection.id, attachment.projection.state);
+		if (attachment.projection !== void 0 && projectionState === void 0) {
+			this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+			return;
+		}
+		const state = {
+			sessionId: attachment.sessionId,
+			subscriberId: attachment.subscriberId,
+			trace: attachment.trace,
+			delivery: restoreWebSocketDeliveryState({
+				subscriberId: attachment.subscriberId,
+				policy: defaultEDAWebSocketFlowControl,
+				checkpoint: attachment.delivery
+			}),
+			catchUpDeferred: false,
+			head: attachment.delivery.sentDurableThroughSeq,
+			queue: Promise.resolve(),
+			...projectionState === void 0 ? {} : { projectionState }
+		};
+		this.sockets.set(webSocket, state);
+		return state;
+	}
+	async prepare(webSocket, state) {
+		try {
+			await this.options.prepareSession(state.sessionId);
+			return this.sockets.get(webSocket) === state;
+		} catch (error) {
+			await Effect.runPromise(Effect.logError("EDA WebSocket session preparation failed", {
+				error,
+				subscriberId: state.subscriberId
+			}));
+			this.close(webSocket, EDA_WS_CLOSE_SEND_FAILED, "subscriber-failed");
+			return false;
+		}
+	}
+	async interpret(webSocket, state, result) {
+		state.delivery = result.state;
+		for (const action of result.actions) switch (action._tag) {
+			case "Persist":
+				if (!this.persist(webSocket, state)) return false;
+				break;
+			case "Send":
+				if (!await this.send(webSocket, state, action.frames)) return false;
+				break;
+			case "ReadEventPage":
+				if (!await this.readAndDeliver(webSocket, state, action.afterSeq)) return false;
+				break;
+			case "Close":
+				this.close(webSocket, action.code, action.reason);
+				return false;
+		}
+		return true;
+	}
+	async readAndDeliver(webSocket, state, afterSeq) {
+		const page = await this.options.readEventPage({
+			afterSeq,
+			limit: state.delivery.policy.maxInFlightFrames * state.delivery.policy.maxFrameEvents,
+			sessionId: state.sessionId,
+			subscriberId: state.subscriberId,
+			trace: state.trace
+		});
+		state.head = SequenceNumber.make(Math.max(state.head, page.head));
+		if (page.events.length === 0) return true;
+		return await this.interpret(webSocket, state, onDurableEvents(state.delivery, page.events, state.head, Date.now()));
+	}
+	persist(webSocket, state) {
+		try {
+			const projection = state.projectionState === void 0 ? void 0 : this.options.webSocketProjection;
+			if (state.projectionState !== void 0 && projection === void 0) {
+				this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+				return false;
+			}
+			const attachment = EDAWebSocketAttachment.make({
+				kind: "eda-events-v2",
+				sessionId: state.sessionId,
+				subscriberId: state.subscriberId,
+				trace: state.trace,
+				delivery: checkpointWebSocketDeliveryState(state.delivery),
+				...state.projectionState === void 0 || projection === void 0 ? {} : { projection: {
+					id: projection.id,
+					state: projection.encodeState(state.projectionState)
+				} }
+			});
+			webSocket.serializeAttachment(encodeWebSocketAttachment(attachment));
+			return true;
+		} catch {
+			this.close(webSocket, EDA_WS_CLOSE_SEND_FAILED, "attachment-failed");
+			return false;
+		}
+	}
+	send(webSocket, state, frames) {
+		return this.sendPrepared(webSocket, state, frames);
+	}
+	async sendPrepared(webSocket, state, frames) {
+		try {
+			const encodedFrames = [];
+			const followUpActions = [];
+			for (const frame of frames) {
+				const projected = state.projectionState === void 0 ? void 0 : this.options.webSocketProjection?.encodeServerFrame(frame, state.projectionState);
+				if (state.projectionState !== void 0 && projected === void 0) {
+					this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+					return false;
+				}
+				if (projected?._tag === "SuppressAndAck") {
+					if (frame._tag !== "events") {
+						this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+						return false;
+					}
+					state.projectionState = projected.state;
+					const acknowledged = onHostSuppressedFrame(state.delivery, {
+						durableThroughSeq: frame.durableThroughSeq,
+						frameId: frame.frameId
+					}, Date.now());
+					state.delivery = acknowledged.state;
+					followUpActions.push(...acknowledged.actions.filter((action) => action._tag !== "Persist"));
+					continue;
+				}
+				if (projected !== void 0) state.projectionState = projected.state;
+				const encoded = projected?._tag === "Send" ? projected.frame : encodeEDAWebSocketServerFrame(frame, this.options.webSocketProtocol);
+				if (new TextEncoder().encode(encoded).byteLength > state.delivery.policy.maxFrameBytes) {
+					this.close(webSocket, EDA_WS_CLOSE_PROTOCOL_ERROR, "frame-too-large");
+					return false;
+				}
+				encodedFrames.push(encoded);
+			}
+			if (state.projectionState !== void 0 && !this.persist(webSocket, state)) return false;
+			for (const encoded of encodedFrames) webSocket.send(encoded);
+			if (followUpActions.length > 0) return await this.interpret(webSocket, state, {
+				state: state.delivery,
+				actions: coalesceFollowUpActions(followUpActions)
+			});
+			return true;
+		} catch {
+			this.close(webSocket, EDA_WS_CLOSE_SEND_FAILED, "send-failed");
+			return false;
+		}
+	}
+	enqueue(webSocket, state, operation) {
+		const run = async () => {
+			try {
+				await operation();
+			} catch (error) {
+				await Effect.runPromise(Effect.logError("EDA WebSocket operation failed", {
+					error,
+					subscriberId: state.subscriberId
+				}));
+				this.close(webSocket, EDA_WS_CLOSE_SEND_FAILED, "subscriber-failed");
+			}
+		};
+		const next = state.queue.then(run);
+		state.queue = next;
+		return next;
+	}
+	close(webSocket, code, reason) {
+		this.sockets.delete(webSocket);
+		try {
+			webSocket.close(code, reason);
+		} catch {}
+	}
+	decodeClientMessage(message, state) {
+		return state.projectionState === void 0 ? decodeEDAWebSocketClientMessage(message) : this.options.webSocketProjection?.decodeClientMessage(message) ?? Effect.fail("protocol");
+	}
+	async decodeProjectionState(id, encoded) {
+		const projection = this.resolveProjection(id);
+		if (projection === void 0) return void 0;
+		const decoded = await Effect.runPromise(projection.decodeState(encoded).pipe(Effect.option));
+		return decoded._tag === "Some" ? decoded.value : void 0;
+	}
+};
+const coalesceFollowUpActions = (actions) => {
+	let readAfterSeq;
+	const retained = [];
+	for (const action of actions) {
+		if (action._tag !== "ReadEventPage") {
+			retained.push(action);
+			continue;
+		}
+		readAfterSeq = SequenceNumber.make(Math.max(readAfterSeq ?? 0, action.afterSeq));
+	}
+	return readAfterSeq === void 0 ? retained : [...retained, {
+		_tag: "ReadEventPage",
+		afterSeq: readAfterSeq
+	}];
+};
+//#endregion
+//#region src/session-controller.ts
+/**
+* Public application-facing use cases for one EDA session.
+*
+* Runtime lifecycle belongs to EDASessionRuntime; WebSocket transport belongs
+* to EDAWebSocketConnectionManager. This class only coordinates them.
+*/
+var EDASessionController = class {
+	runtime;
+	webSockets;
+	constructor(options) {
+		this.webSockets = new EDAWebSocketConnectionManager({
+			getWebSockets: options.getWebSockets,
+			isSessionReady: (sessionId) => this.runtime.isReady(sessionId),
+			prepareSession: (sessionId) => this.prepareSession(sessionId),
+			readEventPage: async ({ afterSeq, limit, sessionId, subscriberId, trace }) => await this.runtime.run(sessionId, (eda) => eda.readEventPage(afterSeq, limit).pipe(Effect.withSpan("agent.events.page", hostSpanOptions(trace, {
+				"eda.session.id": sessionId,
+				"eda.subscriber.id": subscriberId,
+				"eda.seq.after": afterSeq
+			})))),
+			webSocketProjection: options.webSocketProjection,
+			webSocketProtocol: options.webSocketProtocol
+		});
+		this.runtime = new EDASessionRuntime({
+			...options,
+			sessionEventObserverLayer: this.webSockets.observerLayer
+		});
+	}
+	static migrate = EDASessionRuntime.migrate;
+	/** Trusted reconciliation read; never submits or grants replacement work. */
+	runRequestOutcome(input) {
+		return this.run(input.sessionId, (eda) => eda.runRequestOutcome(input.requestId));
+	}
+	/** Trusted scheduler ingress. Hosts must authorize callers before invoking this method. */
+	grantRun(input) {
+		const parent = input.trace?.parent;
+		return this.run(input.sessionId, (eda) => {
+			const operation = eda.grantRun(input.command);
+			return parent === void 0 || parent === null ? operation : operation.pipe(Effect.withParentSpan(toEdaExternalSpan(parent)));
+		});
+	}
+	submit(input) {
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return this.run(input.sessionId, (eda) => eda.submit(input.command).pipe(Effect.withSpan("agent.command.submit", hostSpanOptions(trace, {
+			"eda.session.id": input.sessionId,
+			"eda.command.kind": input.command._tag,
+			"eda.command.id": input.command.commandId
+		}))));
+	}
+	submitBatch(input) {
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return this.run(input.sessionId, (eda) => eda.submit(input.items).pipe(Effect.withSpan("agent.command.submit", hostSpanOptions(trace, {
+			"eda.session.id": input.sessionId,
+			"eda.command.submittable_count": input.items.length
+		}))));
+	}
+	submitAndBlock(input) {
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return this.run(input.sessionId, (eda) => eda.submitAndBlock(input.command).pipe(Effect.withSpan("agent.command.submit.wait", hostSpanOptions(trace, {
+			"eda.session.id": input.sessionId,
+			"eda.command.kind": input.command._tag,
+			"eda.command.id": input.command.commandId
+		}))));
+	}
+	blockOnCommand(input) {
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return this.run(input.sessionId, (eda) => eda.blockOnCommand(input.commandId, input.afterSeq ?? SequenceNumber.make(0)).pipe(Effect.withSpan("agent.command.wait", hostSpanOptions(trace, {
+			"eda.session.id": input.sessionId,
+			"eda.command.id": input.commandId,
+			"eda.seq.after": input.afterSeq
+		}))));
+	}
+	snapshot(input) {
+		return this.query(input, (eda) => eda.snapshot(), "agent.session.snapshot");
+	}
+	messages(input) {
+		return this.query(input, (eda) => eda.messages(), "agent.messages.list");
+	}
+	acceptEventWebSocket(input) {
+		return this.acceptEventWebSocketUnhosted(input);
+	}
+	async acceptEventWebSocketUnhosted(input) {
+		const prepared = await this.prepareEventWebSocket(input);
+		await this.acceptPreparedEventWebSocket({
+			...prepared,
+			webSocket: input.webSocket
+		});
+	}
+	async prepareEventWebSocket(input) {
+		const projection = this.webSockets.resolveProjection(input.projectionId);
+		if (input.projectionId !== void 0 && projection === void 0) throw new Error(`Unsupported EDA WebSocket projection: ${input.projectionId}`);
+		const initialized = projection === void 0 ? void 0 : projection.initialize({
+			...input.afterSeq === void 0 ? {} : { requestedAfterSeq: input.afterSeq },
+			snapshot: await this.snapshot({
+				sessionId: input.sessionId,
+				trace: input.trace
+			})
+		});
+		return {
+			afterSeq: initialized?.afterSeq ?? input.afterSeq ?? SequenceNumber.make(0),
+			sessionId: input.sessionId,
+			trace: input.trace ?? makeRootEDATraceMetadata(),
+			...initialized === void 0 ? {} : { projectionState: initialized.state }
+		};
+	}
+	acceptPreparedEventWebSocket(input) {
+		return this.webSockets.accept(input);
+	}
+	webSocketMessage(webSocket, message) {
+		return this.webSockets.message(webSocket, message);
+	}
+	webSocketClose(webSocket) {
+		this.webSockets.closed(webSocket);
+	}
+	webSocketError(webSocket) {
+		this.webSockets.closed(webSocket);
+	}
+	async destroy(_input) {
+		await this.runtime.destroy();
+	}
+	async alarm(input) {
+		if (input !== void 0) await this.prepareSession(input.sessionId);
+		await this.runtime.alarm(input?.sessionId);
+	}
+	dispose() {
+		return this.runtime.dispose();
+	}
+	query(input, operation, spanName) {
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return this.run(input.sessionId, (eda) => operation(eda).pipe(Effect.withSpan(spanName, hostSpanOptions(trace, { "eda.session.id": input.sessionId }))));
+	}
+	async prepareSession(sessionId) {
+		await this.runtime.prepare(sessionId);
+		await this.webSockets.flushDeferredCatchUp(sessionId);
+	}
+	async run(sessionId, operation) {
+		await this.prepareSession(sessionId);
+		return await this.runtime.run(sessionId, operation);
+	}
+};
+const hostSpanOptions = (trace, attributes) => ({
+	kind: "server",
+	attributes: compactSpanAttributes({
+		...trace.attributes,
+		...attributes
+	}),
+	links: trace.links.map((link) => ({
+		span: toEdaExternalSpan(link.context),
+		attributes: link.attributes
+	})),
+	...trace.parent === null ? {} : { parent: toEdaExternalSpan(trace.parent) }
+});
+//#endregion
+export { EDAWebSocketProjectionId as n, makeEDADurableObjectRuntimeLayer as r, EDASessionController as t };
+
+//# sourceMappingURL=session-controller-C31DhUNp.js.map