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

package/dist/durable-object-runtime-LgOJbsVm.js

@@ -0,0 +1,1255 @@
+import { t as websocket_protocol_exports } from "./websocket-protocol.js";
+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 { EDACommand } from "effect-durable-agent/types/commands";
+import { SequenceNumber, SummaryId, durablePosition } from "effect-durable-agent/types/core";
+import { makeRootEDATraceMetadata } from "effect-durable-agent/types/tracing";
+import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
+import * as Deferred from "effect/Deferred";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as Queue from "effect/Queue";
+import * as Redacted from "effect/Redacted";
+import "effect/Tracer";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import "effect/unstable/http/HttpBody";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+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 { EDARuntime } from "effect-durable-agent/services/runtime";
+import { makeEDARuntimeLayer } from "effect-durable-agent/services/runtime-layer";
+import { CommittedDurableEvent, EDASessionStore, EDASessionStoreError } from "effect-durable-agent/services/session-store";
+import { annotateEdaSpan, committedBatchAttributes, compactSpanAttributes, toEdaExternalSpan } from "effect-durable-agent/services/tracing";
+import { SubscriberLagged, SubscriberProtocolError, SubscriberSendFailed, runWebSocketSubscriber } from "effect-durable-agent/services/websocket-subscriber";
+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 { SinkCheckpointStore } from "effect-durable-agent/services/sink-checkpoint-store";
+/**
+* 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;
+	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;
+	}
+	/** 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;
+		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) {
+			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-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/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-runtime.ts
+const resolveRuntimeFactory = (value, sessionId) => typeof value === "function" ? value({ sessionId }) : value;
+/**
+* Compose the full EDA service graph for one raw Durable Object session.
+*
+* The layer is intentionally host-owned: tests can pass a fake model layer,
+* while the Worker host can pass a provider-backed layer from Env.
+*/
+const makeEDADurableObjectRuntimeLayer = ({ config, compactionExecutorLayer, compactionPolicyLayer, keepAlive, modelLayer, promptProjectorLayer, reducers, sessionId, sinks, storage, toolkit, toolRegistry, tracer }) => {
+	const Store = DurableObjectSessionStore.layer({
+		sessionId,
+		storage
+	});
+	const KeepAlive = keepAlive === void 0 ? EDAKeepAlive.Noop : EDAKeepAlive.FromAcquire(() => keepAlive.acquire());
+	const SinkCheckpoints = DurableObjectSinkCheckpointStore.layer(storage);
+	return makeEDARuntimeLayer({
+		config,
+		compactionExecutorLayer,
+		compactionPolicyLayer,
+		keepAliveLayer: KeepAlive,
+		modelLayer,
+		promptProjectorLayer,
+		reducerRegistryLayer: EDAReducerRegistry.Live(reducers ?? []),
+		sessionId,
+		sessionStoreLayer: Store,
+		sinkCheckpointStoreLayer: SinkCheckpoints,
+		sinks,
+		toolkit,
+		toolRegistry,
+		tracer
+	});
+};
+/** OpenAI-backed Effect AI model layer for the default Worker host. */
+const makeEDADurableObjectOpenAiModelLayer = (options) => {
+	const apiKey = optionalNonEmptyString(options.apiKey);
+	if (apiKey === void 0 && options.aiGateway === void 0) throw new Error("OPENAI_API_KEY is required unless the EDA OpenAI model layer is backed by a Cloudflare AI Gateway binding.");
+	const baseHttpClient = options.aiGateway === void 0 ? FetchHttpClient.layer : Layer.succeed(HttpClient.HttpClient, makeCloudflareAiGatewayHttpClient(options.aiGateway));
+	const client = OpenAiClient.layer({
+		...apiKey === void 0 ? {} : { apiKey: Redacted.make(apiKey) },
+		...options.apiUrl === void 0 ? {} : { apiUrl: options.apiUrl }
+	}).pipe(Layer.provide(baseHttpClient));
+	return OpenAiLanguageModel.layer({
+		model: options.modelId,
+		...options.config === void 0 ? {} : { config: options.config }
+	}).pipe(Layer.provide(client));
+};
+const OPENAI_API_BASE_PATH_PREFIX = "/v1/";
+const makeCloudflareAiGatewayHttpClient = (gateway) => HttpClient.make((request, url, signal) => Effect.tryPromise({
+	try: async () => {
+		const response = await gateway.run({
+			endpoint: openAiGatewayEndpointFromUrl(url),
+			headers: requestHeadersForGateway(request),
+			provider: "openai",
+			query: requestBodyForGateway(request.body)
+		}, { signal });
+		return HttpClientResponse.fromWeb(request, response);
+	},
+	catch: (cause) => new HttpClientError.HttpClientError({ reason: new HttpClientError.TransportError({
+		request,
+		cause,
+		description: "Cloudflare AI Gateway request failed"
+	}) })
+}));
+const openAiGatewayEndpointFromUrl = (url) => {
+	return `${url.pathname.startsWith(OPENAI_API_BASE_PATH_PREFIX) ? url.pathname.slice(4) : url.pathname.replace(/^\/+/, "")}${url.search}`;
+};
+const requestHeadersForGateway = (request) => Object.fromEntries(Object.entries(request.headers).filter((entry) => {
+	const [key, value] = entry;
+	return typeof value === "string" && key.toLowerCase() !== "host";
+}));
+const requestBodyForGateway = (body) => {
+	switch (body._tag) {
+		case "Empty": return;
+		case "Raw": return body.body;
+		case "Uint8Array": return JSON.parse(new TextDecoder().decode(body.body));
+		default: throw new Error(`Unsupported OpenAI request body for Cloudflare AI Gateway: ${body._tag}`);
+	}
+};
+const optionalNonEmptyString = (value) => {
+	const trimmed = value?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
+};
+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) }
+});
+/** Raw Durable Object host controller for one EDA session object. */
+var EDASessionDurableObjectHost = class {
+	options;
+	keepAlive;
+	eventSockets = /* @__PURE__ */ new WeakMap();
+	runtimeState;
+	runtimePromise;
+	constructor(options) {
+		this.options = options;
+		this.keepAlive = options.keepAlive ?? new DurableObjectKeepAlive(options.storage, options.background);
+	}
+	/** Run idempotent host and event-store migrations. Safe from `blockConcurrencyWhile`. */
+	static migrate = (storage) => Effect.gen(function* () {
+		yield* DurableObjectSessionStore.migrate(storage);
+		yield* DurableObjectSinkCheckpointStore.migrate(storage);
+	});
+	/** Admit one command durably. Active runtime work holds EDA keep-alive leases internally. */
+	async submit(input) {
+		const runtime = await this.getRuntime(input.sessionId);
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return await runtime.runtime.runPromise(Effect.gen(function* () {
+			return yield* (yield* EDARuntime).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
+		}))));
+	}
+	/** Submit an ordered durable batch of commands and app events. */
+	async submitBatch(input) {
+		const runtime = await this.getRuntime(input.sessionId);
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return await runtime.runtime.runPromise(Effect.gen(function* () {
+			return yield* (yield* EDARuntime).submit(input.items);
+		}).pipe(Effect.withSpan("agent.command.submit", hostSpanOptions(trace, {
+			"eda.session.id": input.sessionId,
+			"eda.command.submittable_count": input.items.length,
+			"eda.command.count": input.items.filter((item) => "_tag" in item).length
+		}))));
+	}
+	/** Admit one command and wait for its terminal command boundary. */
+	async submitAndBlock(input) {
+		const runtime = await this.getRuntime(input.sessionId);
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return await runtime.runtime.runPromise(Effect.gen(function* () {
+			return yield* (yield* EDARuntime).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
+		}))));
+	}
+	/** Wait for an existing command to reach its terminal command boundary. */
+	async blockOnCommand(input) {
+		const runtime = await this.getRuntime(input.sessionId);
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return await runtime.runtime.runPromise(Effect.gen(function* () {
+			return yield* (yield* EDARuntime).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
+		}))));
+	}
+	/** Read the authoritative live session snapshot. */
+	snapshot(input) {
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return this.withRuntime(input.sessionId, (eda) => eda.snapshot().pipe(Effect.withSpan("agent.session.snapshot", hostSpanOptions(trace, { "eda.session.id": input.sessionId }))));
+	}
+	/** Read durable transcript messages in committed order. */
+	messages(input) {
+		const trace = input.trace ?? makeRootEDATraceMetadata();
+		return this.withRuntime(input.sessionId, (eda) => eda.messages().pipe(Effect.withSpan("agent.messages.list", hostSpanOptions(trace, { "eda.session.id": input.sessionId }))));
+	}
+	/** Accept one WebSocket as the live event stream for this session. */
+	async acceptEventWebSocket(input) {
+		const attachment = websocket_protocol_exports.EDAWebSocketAttachment.make({
+			kind: "eda-events-v1",
+			sessionId: input.sessionId,
+			subscriberId: websocket_protocol_exports.SubscriberId.make(crypto.randomUUID()),
+			lastAckedSeq: input.afterSeq ?? SequenceNumber.make(0),
+			trace: input.trace ?? makeRootEDATraceMetadata()
+		});
+		input.webSocket.serializeAttachment(attachment);
+		await this.startEventWebSocket(input.webSocket, attachment);
+	}
+	/** Restore hibernated event WebSockets whose in-memory subscriber fibers disappeared. */
+	async restoreEventWebSockets(webSockets) {
+		for (const webSocket of webSockets) {
+			if (this.eventSockets.has(webSocket)) continue;
+			const decoded = await decodeWebSocketAttachment(webSocket.deserializeAttachment());
+			if (decoded._tag === "Decoded") await this.startEventWebSocket(webSocket, decoded.attachment);
+			else if (decoded._tag === "Malformed") closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_PROTOCOL_ERROR, "attachment");
+		}
+	}
+	/** Route one inbound WebSocket message into the subscriber ACK queue. */
+	async webSocketMessage(webSocket, message) {
+		const state = await this.ensureEventWebSocket(webSocket);
+		if (state === void 0) {
+			closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+			return;
+		}
+		if (typeof message !== "string") {
+			closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_PROTOCOL_ERROR, "binary");
+			state.interrupt?.();
+			return;
+		}
+		try {
+			const frame = await Effect.runPromise((0, websocket_protocol_exports.decodeEDAWebSocketClientMessage)(message));
+			await Effect.runPromise(Queue.offer(state.incoming, frame));
+		} catch {
+			closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol");
+			state.interrupt?.();
+		}
+	}
+	/** Interrupt subscriber work after the client closes the WebSocket. */
+	async webSocketClose(webSocket) {
+		const state = this.eventSockets.get(webSocket);
+		if (state === void 0) return;
+		await Effect.runPromise(Deferred.succeed(state.closed, void 0).pipe(Effect.ignore));
+		state.interrupt?.();
+		this.eventSockets.delete(webSocket);
+	}
+	/** Interrupt subscriber work after a host WebSocket error. */
+	async webSocketError(webSocket) {
+		const state = this.eventSockets.get(webSocket);
+		if (state === void 0) return;
+		await Effect.runPromise(Deferred.succeed(state.closed, void 0).pipe(Effect.ignore));
+		state.interrupt?.();
+		this.eventSockets.delete(webSocket);
+	}
+	/** Dispose any live runtime before the host deletes its Durable Object storage. */
+	async destroy(_input) {
+		await this.keepAlive.shutdown();
+		await this.dispose();
+		this.runtimeState = void 0;
+		this.runtimePromise = void 0;
+	}
+	/** Durable Object alarm hook: wake/recover the runtime and re-arm while EDA has active work. */
+	async alarm(input) {
+		const sessionId = input?.sessionId ?? this.runtimeState?.sessionId;
+		if (sessionId !== void 0) await this.getRuntime(sessionId);
+		await this.keepAlive.alarm();
+	}
+	/** Dispose the Effect runtime if the host wrapper is torn down by tests. */
+	async dispose() {
+		await this.runtimeState?.runtime.dispose();
+	}
+	async withRuntime(sessionId, f) {
+		return await (await this.getRuntime(sessionId)).runtime.runPromise(Effect.gen(function* () {
+			return yield* f(yield* EDARuntime);
+		}));
+	}
+	async ensureEventWebSocket(webSocket) {
+		const existing = this.eventSockets.get(webSocket);
+		if (existing !== void 0) return existing;
+		const decoded = await decodeWebSocketAttachment(webSocket.deserializeAttachment());
+		if (decoded._tag !== "Decoded") return;
+		await this.startEventWebSocket(webSocket, decoded.attachment);
+		return this.eventSockets.get(webSocket);
+	}
+	async startEventWebSocket(webSocket, attachment) {
+		if (this.eventSockets.has(webSocket)) return;
+		const runtime = await this.getRuntime(attachment.sessionId);
+		const state = {
+			...await runtime.runtime.runPromise(Effect.gen(function* () {
+				return {
+					incoming: yield* Queue.unbounded(),
+					closed: yield* Deferred.make()
+				};
+			})),
+			interrupt: void 0,
+			lastAckedSeq: attachment.lastAckedSeq,
+			sessionId: attachment.sessionId,
+			subscriberId: attachment.subscriberId
+		};
+		this.eventSockets.set(webSocket, state);
+		const send = (frame) => Effect.try({
+			try: () => webSocket.send((0, websocket_protocol_exports.encodeEDAWebSocketServerFrame)(frame, this.options.webSocketProtocol)),
+			catch: (cause) => new SubscriberSendFailed({
+				subscriberId: state.subscriberId,
+				cause
+			})
+		});
+		const persistAck = (seq) => Effect.sync(() => {
+			state.lastAckedSeq = seq;
+			webSocket.serializeAttachment({
+				kind: "eda-events-v1",
+				sessionId: state.sessionId,
+				subscriberId: state.subscriberId,
+				lastAckedSeq: seq,
+				trace: attachment.trace
+			});
+		});
+		const closeForError = (error) => {
+			if (error instanceof SubscriberLagged || isTagged(error, "SubscriberLagged")) {
+				const lagged = error;
+				return send(websocket_protocol_exports.EDAWebSocketLaggedFrame.make({
+					_tag: "lagged",
+					resumeSeq: lagged.lastAckedSeq,
+					reason: lagged.reason
+				})).pipe(Effect.ignore, Effect.andThen(Effect.sync(() => closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_LAGGED, (0, websocket_protocol_exports.laggedCloseReason)(lagged.lastAckedSeq)))));
+			}
+			if (error instanceof SubscriberProtocolError || isTagged(error, "SubscriberProtocolError")) {
+				const protocolError = error;
+				return send(websocket_protocol_exports.EDAWebSocketErrorFrame.make({
+					_tag: "error",
+					message: protocolError.message.slice(0, 120)
+				})).pipe(Effect.ignore, Effect.andThen(Effect.sync(() => closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_PROTOCOL_ERROR, "protocol"))));
+			}
+			return Effect.sync(() => closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_SEND_FAILED, "send-failed"));
+		};
+		const program = Effect.scoped(runWebSocketSubscriber({
+			subscriberId: state.subscriberId,
+			resumeSeq: state.lastAckedSeq,
+			policy: websocket_protocol_exports.defaultEDAWebSocketFlowControl,
+			transport: {
+				send,
+				incoming: state.incoming,
+				closed: state.closed,
+				persistAck
+			}
+		}).pipe(Effect.catch((error) => closeForError(error)), Effect.ensuring(Effect.sync(() => {
+			this.eventSockets.delete(webSocket);
+		})), Effect.withSpan("agent.events.stream", hostSpanOptions(attachment.trace, {
+			"eda.session.id": state.sessionId,
+			"eda.subscriber.id": state.subscriberId,
+			"eda.seq.after": state.lastAckedSeq
+		}))));
+		state.interrupt = runtime.runtime.runCallback(program, { onExit: (exit) => {
+			this.eventSockets.delete(webSocket);
+			if (Exit.isFailure(exit)) closeWebSocket(webSocket, websocket_protocol_exports.EDA_WS_CLOSE_SEND_FAILED, "subscriber-failed");
+		} });
+	}
+	async getRuntime(sessionId) {
+		if (this.runtimeState !== void 0) {
+			if (this.runtimeState.sessionId !== sessionId) throw new Error(`EDASessionDurableObjectHost is scoped to session ${this.runtimeState.sessionId}; received ${sessionId}`);
+			return this.runtimeState;
+		}
+		this.keepAlive.restart();
+		const runtimePromise = this.runtimePromise ?? this.buildRuntime(sessionId);
+		this.runtimePromise = runtimePromise;
+		try {
+			return await runtimePromise;
+		} catch (error) {
+			if (this.runtimePromise === runtimePromise) this.runtimePromise = void 0;
+			throw error;
+		}
+	}
+	async buildRuntime(sessionId) {
+		const runtime = ManagedRuntime.make(makeEDADurableObjectRuntimeLayer({
+			config: this.options.config,
+			compactionExecutorLayer: this.options.compactionExecutorLayer,
+			compactionPolicyLayer: this.options.compactionPolicyLayer,
+			keepAlive: this.keepAlive,
+			modelLayer: this.options.modelLayer,
+			promptProjectorLayer: this.options.promptProjectorLayer,
+			reducers: this.options.reducers,
+			sessionId,
+			sinks: this.options.sinks,
+			storage: this.options.storage,
+			toolkit: resolveRuntimeFactory(this.options.toolkit, sessionId),
+			toolRegistry: resolveRuntimeFactory(this.options.toolRegistry, sessionId),
+			tracer: resolveRuntimeFactory(this.options.tracer, sessionId)
+		}));
+		const state = {
+			runtime,
+			sessionId
+		};
+		try {
+			await runtime.context();
+			this.runtimeState = state;
+			return state;
+		} catch (error) {
+			await runtime.dispose().catch(() => void 0);
+			throw error;
+		}
+	}
+};
+const decodeWebSocketAttachment = async (input) => {
+	if (input === null || input === void 0) return { _tag: "Missing" };
+	try {
+		return {
+			_tag: "Decoded",
+			attachment: await Effect.runPromise((0, websocket_protocol_exports.decodeEDAWebSocketAttachment)(input))
+		};
+	} catch {
+		return { _tag: "Malformed" };
+	}
+};
+const closeWebSocket = (webSocket, code, reason) => {
+	try {
+		webSocket.close(code, reason);
+	} catch {}
+};
+const isTagged = (input, tag) => typeof input === "object" && input !== null && "_tag" in input && input._tag === tag;
+/** Decode a raw RPC command payload at the Durable Object boundary. */
+const encodeEdaRpcCommand = (input) => Schema.encodeSync(EDACommand)(input);
+const EDARpcSubmittable = Schema.Union([EDACommand, DurableEventEnvelope]);
+/** Encode a command/app-event batch into structured-clone-safe RPC values. */
+const encodeEdaRpcSubmittables = (input) => input.map((item) => Schema.encodeSync(EDARpcSubmittable)(item));
+/** Decode a raw RPC command payload at the Durable Object boundary. */
+const decodeEdaRpcCommand = (input) => Schema.decodeUnknownEffect(EDACommand)(input);
+/** Decode a raw RPC batch item at the Durable Object boundary. */
+const decodeEdaRpcSubmittable = (input) => Schema.decodeUnknownEffect(EDARpcSubmittable)(input);
+/** Decode raw RPC batch items at the Durable Object boundary. */
+const decodeEdaRpcSubmittables = (input) => Effect.forEach(input, decodeEdaRpcSubmittable);
+//#endregion
+export { encodeEdaRpcCommand as a, makeEDADurableObjectRuntimeLayer as c, decodeEdaRpcSubmittables as i, decodeEdaRpcCommand as n, encodeEdaRpcSubmittables as o, decodeEdaRpcSubmittable as r, makeEDADurableObjectOpenAiModelLayer as s, EDASessionDurableObjectHost as t };
+
+//# sourceMappingURL=durable-object-runtime-LgOJbsVm.js.map