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

package/dist/{durable-object-runtime-LgOJbsVm.js → session-controller-CMbW7vgf.js}

@@ -1,38 +1,25 @@
-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 { 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 * 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 { 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 { SinkCheckpointStore } from "effect-durable-agent/services/sink-checkpoint-store";
+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.
 *
@@ -155,6 +142,78 @@ var DurableObjectKeepAlive = class {
 	}
 };
 //#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. */
@@ -776,422 +835,87 @@ const stringifyJsonForColumn = (value, column) => {
 };
 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);
+//#region src/runtime/runtime-layer.ts
+/** Compose the platform-neutral runtime with Cloudflare persistence and lifecycle adapters. */
+const makeEDADurableObjectRuntimeLayer = ({ config, compactionExecutorLayer, compactionPolicyLayer, keepAlive, modelLayer, promptProjectorLayer, reducers, sessionEventObserverLayer, sessionId, sinks, storage, toolkit, toolRegistry, tracer }) => {
 	return makeEDARuntimeLayer({
 		config,
 		compactionExecutorLayer,
 		compactionPolicyLayer,
-		keepAliveLayer: KeepAlive,
+		keepAliveLayer: keepAlive === void 0 ? EDAKeepAlive.Noop : EDAKeepAlive.FromAcquire(() => keepAlive.acquire()),
 		modelLayer,
 		promptProjectorLayer,
 		reducerRegistryLayer: EDAReducerRegistry.Live(reducers ?? []),
+		sessionEventObserverLayer,
 		sessionId,
-		sessionStoreLayer: Store,
-		sinkCheckpointStoreLayer: SinkCheckpoints,
+		sessionStoreLayer: DurableObjectSessionStore.layer({
+			sessionId,
+			storage
+		}),
+		sinkCheckpointStoreLayer: DurableObjectSinkCheckpointStore.layer(storage),
 		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 {
+//#endregion
+//#region src/runtime/session-runtime.ts
+/** Owns the disposable ManagedRuntime and nothing about WebSocket transport. */
+var EDASessionRuntime = class {
 	options;
 	keepAlive;
-	eventSockets = /* @__PURE__ */ new WeakMap();
-	runtimeState;
-	runtimePromise;
+	state;
+	building;
 	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
-		}))));
+	isReady(sessionId) {
+		return this.state?.sessionId === sessionId;
 	}
-	/** 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
-		}))));
+	async prepare(sessionId) {
+		await this.get(sessionId);
 	}
-	/** 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");
-		}
+	async run(sessionId, operation) {
+		return await (await this.get(sessionId)).runtime.runPromise(Effect.gen(function* () {
+			return yield* operation(yield* EDARuntime);
+		}));
 	}
-	/** 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?.();
-		}
+	async alarm(sessionId) {
+		const resolved = sessionId ?? this.state?.sessionId;
+		if (resolved !== void 0) await this.get(resolved);
+		await this.keepAlive.alarm();
 	}
-	/** 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) {
+	async destroy() {
 		await this.keepAlive.shutdown();
 		await this.dispose();
-		this.runtimeState = void 0;
-		this.runtimePromise = void 0;
+		this.state = void 0;
+		this.building = 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);
+		await this.state?.runtime.dispose();
 	}
-	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;
+	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 runtimePromise = this.runtimePromise ?? this.buildRuntime(sessionId);
-		this.runtimePromise = runtimePromise;
+		const building = this.building ?? this.build(sessionId);
+		this.building = building;
 		try {
-			return await runtimePromise;
+			return await building;
 		} catch (error) {
-			if (this.runtimePromise === runtimePromise) this.runtimePromise = void 0;
+			if (this.building === building) this.building = void 0;
 			throw error;
 		}
 	}
-	async buildRuntime(sessionId) {
+	async build(sessionId) {
 		const runtime = ManagedRuntime.make(makeEDADurableObjectRuntimeLayer({
 			config: this.options.config,
 			compactionExecutorLayer: this.options.compactionExecutorLayer,
@@ -1200,12 +924,13 @@ var EDASessionDurableObjectHost = class {
 			modelLayer: this.options.modelLayer,
 			promptProjectorLayer: this.options.promptProjectorLayer,
 			reducers: this.options.reducers,
+			sessionEventObserverLayer: this.options.sessionEventObserverLayer,
 			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)
+			toolkit: resolveFactory(this.options.toolkit, sessionId),
+			toolRegistry: resolveFactory(this.options.toolRegistry, sessionId),
+			tracer: resolveFactory(this.options.tracer, sessionId)
 		}));
 		const state = {
 			runtime,
@@ -1213,7 +938,7 @@ var EDASessionDurableObjectHost = class {
 		};
 		try {
 			await runtime.context();
-			this.runtimeState = state;
+			this.state = state;
 			return state;
 		} catch (error) {
 			await runtime.dispose().catch(() => void 0);
@@ -1221,35 +946,487 @@ var EDASessionDurableObjectHost = class {
 		}
 	}
 };
+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((0, websocket_protocol_exports.decodeEDAWebSocketAttachment)(input))
+			attachment: await Effect.runPromise(Schema.decodeUnknownEffect(EDAWebSocketAttachment)(input))
 		};
 	} catch {
 		return { _tag: "Malformed" };
 	}
 };
-const closeWebSocket = (webSocket, code, reason) => {
-	try {
-		webSocket.close(code, reason);
-	} catch {}
+/** 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 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);
+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;
+	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 { encodeEdaRpcCommand as a, makeEDADurableObjectRuntimeLayer as c, decodeEdaRpcSubmittables as i, decodeEdaRpcCommand as n, encodeEdaRpcSubmittables as o, decodeEdaRpcSubmittable as r, makeEDADurableObjectOpenAiModelLayer as s, EDASessionDurableObjectHost as t };
+export { EDAWebSocketProjectionId as n, makeEDADurableObjectRuntimeLayer as r, EDASessionController as t };
 
-//# sourceMappingURL=durable-object-runtime-LgOJbsVm.js.map
+//# sourceMappingURL=session-controller-CMbW7vgf.js.map