effect-durable-agent-cloudflare 0.1.0-alpha.23 → 0.1.0-alpha.25

package/dist/durable-object-CkrxIOH4.js

@@ -0,0 +1,627 @@
+import { S as encodeEdaRpcDurableEvent, a as SessionOutcomeInput, d as SessionTranscriptWindowInput, g as DurableObjectTranscriptStore, h as DurableObjectTranscriptBuilder, i as SessionGrantRunInput, l as SessionTranscriptSummaryInput, m as edaSessionRpc, n as SessionBlockInput, o as SessionScopedInput, r as SessionCommandInput, s as SessionTranscriptBodyInput, t as SessionBatchInput } from "./rpc-spec-BupIkBhI.js";
+import { i as readDurableObjectSummary, m as resolveTranscriptSliceLimits, r as readDurableObjectCommittedEvent, s as defaultTranscriptSliceLimits } from "./durable-object-store-Ca0pvpa_.js";
+import { t as EDASessionController } from "./session-controller-KWMuKhlX.js";
+import * as Effect from "effect/Effect";
+import { durableEventEnvelope } from "effect-durable-agent/types/events/durable";
+import * as Schema from "effect/Schema";
+import { CommandId, RunRequestId, SequenceNumber, SessionId } from "effect-durable-agent/types/core";
+import { EDATraceMetadata, makeEDATraceMetadataFromParent, makeRootEDATraceMetadata, parseEDATraceparent } from "effect-durable-agent/types/tracing";
+import { EDASessionStoreError } from "effect-durable-agent/services/session-store";
+import { defaultTranscriptWindowLimits, emptyTranscriptMappings, makeTranscriptDefinition, resolveTranscriptBody } from "effect-durable-agent/transcript";
+import * as Result from "effect/Result";
+import { DurableObject } from "cloudflare:workers";
+import { EDA_WEB_SOCKET_PING_MESSAGE, EDA_WEB_SOCKET_PONG_MESSAGE } from "effect-durable-agent/websocket";
+//#region src/durable-object-alarm-handler.ts
+/** Longest delay between builder retries. */
+const maxBuilderRetryDelayMs = 36e5;
+/**
+* Handle one platform alarm shared by the runtime and the transcript builder.
+*
+* - The runtime runs for its own wakeup, or for an alarm no owner recorded (one armed by a
+*   release before wakeups were recorded). The builder runs for its wakeup even when the runtime
+*   failed.
+* - No wakeup is consumed up front: each owner's is cleared only after its work succeeds, so a
+*   handler that throws or dies mid-work leaves the platform's retry attributed to every owner it
+*   fired for.
+* - A failed builder retries with exponential backoff; its consecutive failures persist with its
+*   wakeup, so eviction cannot reset them, and at `maxBuilderFailures` it stops scheduling itself.
+*   No failure re-arms the alarm sooner than the backoff, so no object can loop on its alarm.
+* - A failed runtime rethrows without re-arming the platform alarm, so the platform's own retry
+*   (backoff and retry cap) applies; otherwise the alarm is pointed at the earliest wakeup left.
+*/
+const runEDASessionAlarm = async (participants) => {
+	const { alarms } = participants;
+	const now = participants.now();
+	const due = alarms.due(now);
+	let runtimeFailure;
+	if (due.has("runtime") || due.size === 0) try {
+		await participants.runRuntime();
+		alarms.clearThrough("runtime", due.get("runtime") ?? now);
+	} catch (error) {
+		runtimeFailure = { error };
+	}
+	const builderWakeup = due.get("transcript");
+	if (builderWakeup !== void 0) {
+		const runBuilderSlices = participants.runBuilderSlices;
+		if (runBuilderSlices === void 0) alarms.clear("transcript");
+		else try {
+			if (await runBuilderSlices()) alarms.retain("transcript", participants.now());
+			else alarms.clearThrough("transcript", builderWakeup);
+		} catch (error) {
+			const consecutiveFailures = alarms.failures("transcript") + 1;
+			const stopped = consecutiveFailures >= participants.maxBuilderFailures;
+			if (stopped) alarms.clear("transcript");
+			else {
+				const delayMs = Math.min(participants.builderRetryDelayMs * 2 ** (consecutiveFailures - 1), maxBuilderRetryDelayMs);
+				alarms.retain("transcript", participants.now() + delayMs, consecutiveFailures);
+			}
+			participants.onBuilderFailure({
+				error,
+				consecutiveFailures,
+				stopped
+			});
+		}
+	}
+	if (runtimeFailure !== void 0) throw runtimeFailure.error;
+	await alarms.sync();
+};
+//#endregion
+//#region src/durable-object-alarms.ts
+/**
+* Shares one Durable Object alarm between owners that each keep a durable wakeup.
+*
+* Each owner's wakeup is a row in `_eda_alarm_wakeups`, and the platform alarm is always set to the
+* earliest row, so no owner can delete or postpone another's wakeup, and after an eviction the
+* alarm handler still knows which owners it fired for. An owner's view (`owner(...)`) has the
+* same shape as the platform alarm API, so the keep-alive heartbeat uses it unchanged.
+*/
+var DurableObjectAlarmScheduler = class {
+	storage;
+	now;
+	#tail = Promise.resolve();
+	constructor(storage, now = () => Date.now()) {
+		this.storage = storage;
+		this.now = now;
+	}
+	/**
+	* One owner's alarm, behaving like the platform alarm restricted to that owner. Like the
+	* platform's, it reports no alarm once its time has passed: a wakeup left behind when the
+	* platform gave up retrying a failed alarm must not look armed, or its owner would never re-arm.
+	*/
+	owner(owner) {
+		return {
+			getAlarm: () => {
+				const wakeup = this.#wakeup(owner);
+				return wakeup === void 0 || wakeup < this.now() ? null : wakeup;
+			},
+			setAlarm: (scheduledTimeMs) => {
+				this.#write(owner, scheduledTimeMs);
+				return this.sync();
+			},
+			deleteAlarm: () => {
+				this.#write(owner, void 0);
+				return this.sync();
+			}
+		};
+	}
+	/**
+	* Adopt a platform alarm no owner recorded (one armed before wakeups were recorded) as the
+	* runtime's, so the first wakeup another owner requests cannot replace it. Call once at startup,
+	* before any owner writes a wakeup.
+	*/
+	async adoptUnrecordedAlarm() {
+		if (this.#rows().length > 0) return;
+		const armed = await this.storage.getAlarm();
+		if (armed !== null && this.#rows().length === 0) this.#write("runtime", armed);
+	}
+	/**
+	* Record `owner`'s wakeup without touching the platform alarm, for use inside `alarm()`: the
+	* caller syncs once at the end, or not at all when it rethrows, which leaves the platform's own
+	* retry (with its backoff and cap) in force.
+	*/
+	retain(owner, atMs, failures = 0) {
+		this.#write(owner, atMs, failures);
+	}
+	/** Consecutive failures recorded with `owner`'s wakeup; 0 without one. */
+	failures(owner) {
+		return this.storage.sql.exec("SELECT failures FROM _eda_alarm_wakeups WHERE owner = ?", owner).toArray()[0]?.failures ?? 0;
+	}
+	/** Remove `owner`'s wakeup whatever its time; call `sync` afterwards. */
+	clear(owner) {
+		this.#write(owner, void 0);
+	}
+	/** Wake `owner` no later than `atMs`; an earlier wakeup it already holds is kept. */
+	request(owner, atMs) {
+		const current = this.#wakeup(owner);
+		if (current !== void 0 && current <= atMs) return this.sync();
+		this.#write(owner, atMs);
+		return this.sync();
+	}
+	/**
+	* Called when the platform alarm fires: the owners it fired for (every wakeup at or before now,
+	* and always the earliest one) and the wakeup each held. Nothing is consumed here: each owner
+	* `clearThrough`s its wakeup only after its work succeeds, so a handler that throws, or dies
+	* mid-work (eviction, deploy, a resource limit), leaves the platform's retry attributed to every
+	* owner it fired for. An owner's view already reports a past wakeup as no alarm, so the runtime's
+	* keep-alive re-arms during its work as it did with the platform alarm.
+	*/
+	due(nowMs) {
+		const rows = this.#rows();
+		const earliest = rows.reduce((min, row) => Math.min(min, row.at_ms), Number.POSITIVE_INFINITY);
+		const threshold = Math.max(nowMs, earliest);
+		const due = /* @__PURE__ */ new Map();
+		for (const row of rows) if (row.at_ms <= threshold && isOwner(row.owner)) due.set(row.owner, row.at_ms);
+		return due;
+	}
+	/**
+	* Remove `owner`'s wakeup if it is still at or before `atMs`, once the work it fired for has
+	* succeeded. A later wakeup the owner re-armed during that work is kept.
+	*/
+	clearThrough(owner, atMs) {
+		this.storage.sql.exec("DELETE FROM _eda_alarm_wakeups WHERE owner = ? AND at_ms <= ?", owner, atMs);
+	}
+	/** Point the platform alarm at the earliest wakeup, or clear it when none remains. */
+	sync() {
+		this.#tail = this.#tail.catch(() => void 0).then(async () => {
+			const earliest = this.storage.sql.exec("SELECT MIN(at_ms) AS at_ms FROM _eda_alarm_wakeups").one().at_ms;
+			if (earliest === null) {
+				await this.storage.deleteAlarm();
+				return;
+			}
+			if (await this.storage.getAlarm() !== earliest) await this.storage.setAlarm(earliest);
+		});
+		return this.#tail;
+	}
+	#rows() {
+		return this.storage.sql.exec("SELECT owner, at_ms FROM _eda_alarm_wakeups").toArray();
+	}
+	#wakeup(owner) {
+		return this.storage.sql.exec("SELECT at_ms FROM _eda_alarm_wakeups WHERE owner = ?", owner).toArray()[0]?.at_ms;
+	}
+	/** Upsert or delete `owner`'s wakeup. Without `failures`, an existing count is kept. */
+	#write(owner, atMs, failures) {
+		if (atMs === void 0) {
+			this.storage.sql.exec("DELETE FROM _eda_alarm_wakeups WHERE owner = ?", owner);
+			return;
+		}
+		if (failures === void 0) {
+			this.storage.sql.exec(`INSERT INTO _eda_alarm_wakeups (owner, at_ms) VALUES (?, ?)
+        ON CONFLICT(owner) DO UPDATE SET at_ms = excluded.at_ms`, owner, atMs);
+			return;
+		}
+		this.storage.sql.exec(`INSERT INTO _eda_alarm_wakeups (owner, at_ms, failures) VALUES (?, ?, ?)
+      ON CONFLICT(owner) DO UPDATE SET at_ms = excluded.at_ms, failures = excluded.failures`, owner, atMs, failures);
+	}
+};
+const isOwner = (owner) => owner === "runtime" || owner === "transcript";
+//#endregion
+//#region src/durable-object.ts
+/** Internal Worker-to-object header selecting an app-owned WebSocket projection. */
+const EDA_WEB_SOCKET_PROJECTION_HEADER = "x-eda-websocket-projection";
+/**
+* Upgrade query parameter selecting the socket's stream: `transcript` selects the ordered
+* transcript-window stream; anything else keeps the raw event stream.
+*/
+const EDA_WEB_SOCKET_STREAM_PARAM = "stream";
+/** Slices a backfill `transcriptStatus` call may run before it returns. */
+const transcriptStatusMaxSlices = 16;
+/** Server bounds on one `readTranscriptWindow` RPC, whatever limits the caller asks for. */
+const transcriptWindowMaxRecords = 500;
+const transcriptWindowMaxBytes = 8388608;
+/** First retry delay after a failed builder alarm; doubled per consecutive failure. */
+const transcriptBuilderRetryDelayMs = 3e4;
+/** Slices one builder alarm runs before rescheduling itself. */
+const transcriptAlarmMaxSlices = 4;
+/** Resolve a concrete EDA session Durable Object binding by domain session id. */
+const getEDASessionDurableObjectByName = (namespace, sessionId) => namespace.getByName(sessionId);
+/**
+* Base class for raw Cloudflare Durable Object hosts of one EDA session.
+*
+* Concrete products should extend this class, pass provider/tool layers from
+* their own constructor, and register only that subclass in Wrangler. The base
+* class is deliberately not exported from `workers/app.ts` and owns no binding
+* name or routing convention.
+*/
+var EDASessionDurableObject = class extends DurableObject {
+	#controller;
+	#webSocketProjectionId;
+	#alarms;
+	#transcriptOptions;
+	#transcript;
+	#transcriptEnabled;
+	constructor(ctx, env, options) {
+		super(ctx, env);
+		this.#webSocketProjectionId = options.webSocketProjection?.id;
+		const storage = toEDASessionStorage(this.ctx.storage);
+		this.#alarms = new DurableObjectAlarmScheduler(storage);
+		const { transcript: transcriptHostOptions, transcriptSockets, ...controllerOptions } = options;
+		const transcript = this.transcriptOptions(transcriptHostOptions);
+		this.#transcriptOptions = transcript;
+		const enabled = transcriptHostOptions?.enabled ?? false;
+		this.#transcriptEnabled = typeof enabled === "function" ? enabled : () => enabled;
+		this.#controller = new EDASessionController({
+			...controllerOptions,
+			alarmStorage: this.#alarms.owner("runtime"),
+			background: this.ctx,
+			getWebSockets: () => this.ctx.getWebSockets(),
+			storage,
+			transcript: ({ sessionId }) => this.transcriptFor(sessionId).enabled ? transcript : void 0,
+			...transcriptSockets === void 0 ? {} : { transcriptSockets: {
+				...transcriptSockets,
+				transcriptStore: transcriptSockets.transcriptStore ?? this.transcriptPort()
+			} }
+		});
+		this.ctx.setWebSocketAutoResponse(new WebSocketRequestResponsePair(EDA_WEB_SOCKET_PING_MESSAGE, EDA_WEB_SOCKET_PONG_MESSAGE));
+		this.ctx.blockConcurrencyWhile(async () => {
+			await Effect.runPromise(EDASessionController.migrate(storage));
+			await this.#alarms.adoptUnrecordedAlarm();
+			await this.maintainedTranscript()?.builder.start();
+		});
+	}
+	async fetch(request) {
+		if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") return new Response("Expected WebSocket upgrade.", { status: 426 });
+		const url = new URL(request.url);
+		const sessionIdRaw = url.searchParams.get("sessionId");
+		if (sessionIdRaw === null) return new Response("Missing sessionId.", { status: 400 });
+		const afterSeqRaw = url.searchParams.get("afterSeq");
+		const afterSeq = afterSeqRaw === null ? void 0 : Number(afterSeqRaw);
+		if (afterSeq !== void 0 && (!Number.isInteger(afterSeq) || afterSeq < 0)) return new Response("Invalid afterSeq.", { status: 400 });
+		const projectionId = request.headers.get("x-eda-websocket-projection") ?? void 0;
+		if (projectionId !== void 0 && projectionId !== this.#webSocketProjectionId) return new Response("Unsupported WebSocket projection.", { status: 400 });
+		const sessionId = this.parseSessionIdOrUndefined(sessionIdRaw);
+		if (sessionId === void 0) return new Response("This object does not serve that session.", { status: 400 });
+		const trace = traceMetadataFromRequest(request);
+		if (url.searchParams.get("stream") === "transcript") {
+			if (projectionId !== void 0 || !this.#controller.supportsTranscriptWebSocket) return new Response("Unsupported transcript stream.", { status: 400 });
+			if (!this.transcriptFor(sessionId).enabled) return new Response("Transcript is not enabled for this session.", { status: 409 });
+			const pair = new WebSocketPair();
+			this.ctx.acceptWebSocket(pair[1]);
+			this.#controller.acceptTranscriptWebSocket({
+				sessionId,
+				trace,
+				webSocket: pair[1]
+			});
+			return new Response(null, {
+				status: 101,
+				webSocket: pair[0]
+			});
+		}
+		const prepared = await this.#controller.prepareEventWebSocket({
+			...afterSeq === void 0 ? {} : { afterSeq: SequenceNumber.make(afterSeq) },
+			sessionId,
+			trace,
+			...projectionId === void 0 ? {} : { projectionId }
+		});
+		const pair = new WebSocketPair();
+		const client = pair[0];
+		const server = pair[1];
+		this.ctx.acceptWebSocket(server);
+		await this.#controller.acceptPreparedEventWebSocket({
+			...prepared,
+			webSocket: server
+		});
+		return new Response(null, {
+			status: 101,
+			webSocket: client
+		});
+	}
+	async submit(raw) {
+		const input = Schema.decodeUnknownSync(SessionCommandInput)(raw);
+		const committed = await this.#controller.submit({
+			command: input.command,
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		return encodeEdaRpcCommittedDurableEvent(committed);
+	}
+	/** Reconcile lost grant replies from durable request and run facts. */
+	async runRequestOutcome(raw) {
+		const input = Schema.decodeUnknownSync(SessionOutcomeInput)(raw);
+		const result = await this.#controller.runRequestOutcome({
+			requestId: Schema.decodeUnknownSync(RunRequestId)(input.requestId),
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		return Schema.encodeSync(edaSessionRpc.runRequestOutcome.output)(result);
+	}
+	/** Trusted RPC only: the calling Worker owns scheduler authentication and authorization. */
+	async grantRun(raw) {
+		const input = Schema.decodeUnknownSync(SessionGrantRunInput)(raw);
+		const command = input.command;
+		const result = await this.#controller.grantRun({
+			command,
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		return Schema.encodeSync(edaSessionRpc.grantRun.output)(result);
+	}
+	async submitBatch(raw) {
+		const input = Schema.decodeUnknownSync(SessionBatchInput)(raw);
+		return (await this.#controller.submitBatch({
+			items: input.items,
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		})).map(encodeEdaRpcCommittedDurableEvent);
+	}
+	async submitAndBlock(raw) {
+		const input = Schema.decodeUnknownSync(SessionCommandInput)(raw);
+		const committed = await this.#controller.submitAndBlock({
+			command: input.command,
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		return Schema.encodeSync(edaSessionRpc.submitAndBlock.output)(committed);
+	}
+	async blockOnCommand(raw) {
+		const input = Schema.decodeUnknownSync(SessionBlockInput)(raw);
+		const committed = await this.#controller.blockOnCommand({
+			...input.afterSeq === void 0 ? {} : { afterSeq: SequenceNumber.make(input.afterSeq) },
+			commandId: CommandId.make(input.commandId),
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		return Schema.encodeSync(edaSessionRpc.blockOnCommand.output)(committed);
+	}
+	async snapshot(raw) {
+		const input = Schema.decodeUnknownSync(SessionScopedInput)(raw);
+		const snapshot = await this.#controller.snapshot({
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		return Schema.encodeSync(edaSessionRpc.snapshot.output)(snapshot);
+	}
+	async messages(raw) {
+		const input = Schema.decodeUnknownSync(SessionScopedInput)(raw);
+		const result = await this.#controller.messages({
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		return Schema.encodeSync(edaSessionRpc.messages.output)(result);
+	}
+	async webSocketMessage(webSocket, message) {
+		await this.#controller.webSocketMessage(webSocket, message);
+	}
+	async webSocketClose(webSocket, _code, _reason, _wasClean) {
+		this.#controller.webSocketClose(webSocket);
+	}
+	async webSocketError(webSocket, _error) {
+		this.#controller.webSocketError(webSocket);
+	}
+	async destroySession(raw) {
+		const input = Schema.decodeUnknownSync(SessionScopedInput)(raw);
+		await this.#controller.destroy({
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		await this.ctx.storage.deleteAlarm();
+		await this.ctx.storage.deleteAll();
+		Effect.runSync(EDASessionController.migrate(toEDASessionStorage(this.ctx.storage)));
+	}
+	/**
+	* Storage-only backfill entry point: advance pending transcript build work by bounded slices
+	* and return the transcript status. It never starts the model runtime, reducers or sinks.
+	*/
+	async transcriptStatus(raw) {
+		const input = Schema.decodeUnknownSync(SessionScopedInput)(raw);
+		const transcript = this.transcriptFor(this.parseSessionId(input.sessionId));
+		if (!transcript.enabled) return Schema.encodeSync(edaSessionRpc.transcriptStatus.output)(transcript.store.disabledStatus());
+		await transcript.builder.run(transcriptStatusMaxSlices);
+		return Schema.encodeSync(edaSessionRpc.transcriptStatus.output)(transcript.store.status());
+	}
+	/** Runtime-free transcript window read for SSR and CLIs. Hosts authorize the caller. */
+	async readTranscriptWindow(raw) {
+		const input = Schema.decodeUnknownSync(SessionTranscriptWindowInput)(raw);
+		const transcript = this.transcriptFor(this.parseSessionId(input.sessionId));
+		if (!transcript.enabled) return Schema.encodeSync(edaSessionRpc.readTranscriptWindow.output)({ _tag: "Disabled" });
+		const limits = input.limits ?? defaultTranscriptWindowLimits;
+		const window = transcript.store.readWindow(input.selector, {
+			...limits,
+			maxRecords: Math.min(limits.maxRecords, transcriptWindowMaxRecords),
+			maxBytes: Math.min(limits.maxBytes, transcriptWindowMaxBytes)
+		});
+		return Schema.encodeSync(edaSessionRpc.readTranscriptWindow.output)(Result.isSuccess(window) ? {
+			_tag: "Window",
+			window: window.success
+		} : {
+			_tag: "CursorMismatch",
+			message: window.failure.message
+		});
+	}
+	/**
+	* Runtime-free read of the body a transcript `Ref` names, resolved through the immutable log
+	* (so it stays valid after projection rows are rebuilt). Hosts authorize the caller.
+	*/
+	async readTranscriptBody(raw) {
+		const input = Schema.decodeUnknownSync(SessionTranscriptBodyInput)(raw);
+		const scope = this.transcriptReadScope(input.sessionId, input.incarnation);
+		if (scope._tag !== "Scope") return Schema.encodeSync(edaSessionRpc.readTranscriptBody.output)(scope);
+		const sessionId = scope.sessionId;
+		const committed = readDurableObjectCommittedEvent(toEDASessionStorage(this.ctx.storage).sql, sessionId, input.source.seq);
+		const resolved = committed === void 0 ? {
+			_tag: "Missing",
+			message: `no event at seq ${input.source.seq}`
+		} : resolveTranscriptBody(committed.event, input.source.path);
+		return Schema.encodeSync(edaSessionRpc.readTranscriptBody.output)(resolved._tag === "Found" ? {
+			_tag: "Body",
+			value: resolved.value
+		} : {
+			_tag: "NotFound",
+			message: resolved.message
+		});
+	}
+	/** Runtime-free read of a compaction summary's text. Hosts authorize the caller. */
+	async readTranscriptSummary(raw) {
+		const input = Schema.decodeUnknownSync(SessionTranscriptSummaryInput)(raw);
+		const scope = this.transcriptReadScope(input.sessionId, input.incarnation);
+		if (scope._tag !== "Scope") return Schema.encodeSync(edaSessionRpc.readTranscriptSummary.output)(scope);
+		const artifact = readDurableObjectSummary(toEDASessionStorage(this.ctx.storage).sql, input.summaryId);
+		return Schema.encodeSync(edaSessionRpc.readTranscriptSummary.output)(artifact === void 0 ? {
+			_tag: "NotFound",
+			message: `no summary ${input.summaryId}`
+		} : {
+			_tag: "Summary",
+			summary: {
+				compactionId: artifact.compactionId,
+				summaryId: artifact.summaryId,
+				text: artifact.text,
+				sourceFromSeq: artifact.sourceFromSeq,
+				sourceToSeq: artifact.sourceToSeq
+			}
+		});
+	}
+	/**
+	* The alarm is shared by the runtime heartbeat and the transcript builder; see
+	* `runEDASessionAlarm`.
+	*/
+	async alarm() {
+		const transcript = this.maintainedTranscript();
+		await runEDASessionAlarm({
+			alarms: this.#alarms,
+			now: () => Date.now(),
+			runRuntime: async () => {
+				const sessionId = this.sessionIdFromObjectName();
+				await this.#controller.alarm(sessionId === void 0 ? void 0 : {
+					sessionId,
+					trace: makeRootEDATraceMetadata()
+				});
+			},
+			runBuilderSlices: transcript === void 0 ? void 0 : () => transcript.builder.runSlices(transcriptAlarmMaxSlices),
+			maxBuilderFailures: this.#transcriptOptions.sliceLimits?.maxSliceFailures ?? defaultTranscriptSliceLimits.maxSliceFailures,
+			builderRetryDelayMs: transcriptBuilderRetryDelayMs,
+			onBuilderFailure: ({ error, consecutiveFailures, stopped }) => {
+				console.error("EDA transcript builder slice failed", error);
+				if (stopped) transcript?.store.alert({
+					_tag: "BuilderStopped",
+					consecutiveFailures,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		});
+	}
+	transcriptOptions(options) {
+		const key = options?.adoptIncarnationKey;
+		return {
+			definitions: options?.definitions ?? { current: Effect.runSync(makeTranscriptDefinition(emptyTranscriptMappings)) },
+			...key === void 0 ? {} : { adoptIncarnation: {
+				key,
+				kv: this.ctx.storage.kv
+			} },
+			sliceLimits: resolveTranscriptSliceLimits(options?.sliceLimits),
+			observer: {
+				onAlert: options?.onAlert ?? ((alert) => console.error("EDA transcript alert", JSON.stringify(alert))),
+				onPendingWork: () => {
+					const builder = this.maintainedTranscript()?.builder;
+					if (builder !== void 0) this.ctx.waitUntil(builder.kick());
+				},
+				onServedChanged: () => {
+					this.ctx.waitUntil(this.#controller.refreshTranscriptWebSockets());
+				},
+				onActivated: (activation) => {
+					this.ctx.waitUntil(this.#controller.refreshTranscriptWebSockets());
+					options?.onActivated?.(activation);
+				}
+			}
+		};
+	}
+	/** This object's transcript store as the port transcript sockets read, resolved per call. */
+	transcriptPort() {
+		const port = () => this.maintainedTranscript()?.store.port;
+		const unbound = () => Effect.fail(new EDASessionStoreError({ message: this.objectTranscript()?.enabled === false ? "EDA transcript is not enabled for this session" : "EDA transcript read before the session was named" }));
+		return {
+			readTranscriptWindow: (selector, limits) => Effect.suspend(() => port()?.readTranscriptWindow(selector, limits) ?? unbound()),
+			readTranscriptMeta: Effect.suspend(() => port()?.readTranscriptMeta ?? unbound())
+		};
+	}
+	/**
+	* The session and log a body or summary read may serve: pinned to the session this object's
+	* transcript serves, like window reads, and to the incarnation the caller's reference names.
+	*/
+	transcriptReadScope(rawSessionId, incarnation) {
+		const transcript = this.transcriptFor(this.parseSessionId(rawSessionId));
+		if (!transcript.enabled) return { _tag: "Disabled" };
+		const current = transcript.store.incarnation();
+		return incarnation === current ? {
+			_tag: "Scope",
+			sessionId: transcript.sessionId
+		} : {
+			_tag: "IncarnationMismatch",
+			incarnation: current
+		};
+	}
+	/** The transcript service of this object's session, created on first use. */
+	transcriptFor(sessionId) {
+		if (this.#transcript !== void 0) {
+			if (this.#transcript.sessionId !== sessionId) throw new Error(`EDA transcript is scoped to session ${this.#transcript.sessionId}; received ${sessionId}`);
+			return this.#transcript;
+		}
+		const store = new DurableObjectTranscriptStore({
+			sessionId,
+			storage: toEDASessionStorage(this.ctx.storage),
+			transcript: this.#transcriptOptions
+		});
+		const builder = new DurableObjectTranscriptBuilder(store, () => this.#alarms.request("transcript", Date.now()));
+		this.#transcript = {
+			sessionId,
+			enabled: this.#transcriptEnabled(sessionId),
+			store,
+			builder
+		};
+		return this.#transcript;
+	}
+	/** The transcript service when this object's session is enabled for maintenance. */
+	maintainedTranscript() {
+		const transcript = this.objectTranscript();
+		return transcript?.enabled === true ? transcript : void 0;
+	}
+	/** The transcript service when the object is named by a valid session id. */
+	objectTranscript() {
+		if (this.#transcript !== void 0) return this.#transcript;
+		const name = this.ctx.id.name;
+		return name !== void 0 && Schema.is(SessionId)(name) ? this.transcriptFor(SessionId.make(name)) : void 0;
+	}
+	/** `parseSessionId` for request paths that answer a foreign session with a 400. */
+	parseSessionIdOrUndefined(input) {
+		if (!Schema.is(SessionId)(input)) return void 0;
+		const name = this.ctx.id.name;
+		if (name !== void 0 && name !== input) return void 0;
+		const bound = this.#transcript?.sessionId;
+		return bound === void 0 || bound === input ? SessionId.make(input) : void 0;
+	}
+	parseSessionId(input) {
+		const sessionId = SessionId.make(input);
+		const objectName = this.ctx.id.name;
+		if (objectName !== void 0 && objectName !== sessionId) throw new Error(`EDA Durable Object name ${objectName} cannot serve session ${sessionId}`);
+		return sessionId;
+	}
+	sessionIdFromObjectName() {
+		return this.ctx.id.name === void 0 ? void 0 : SessionId.make(this.ctx.id.name);
+	}
+};
+const toEDASessionStorage = (storage) => {
+	return storage;
+};
+const decodeTraceMetadata = (input) => Schema.decodeUnknownSync(EDATraceMetadata)(input);
+const traceMetadataFromRequest = (request) => {
+	const parent = parseEDATraceparent(request.headers.get("traceparent"), request.headers.get("tracestate"));
+	return parent === null ? makeRootEDATraceMetadata() : makeEDATraceMetadataFromParent(parent);
+};
+/** Convenience config constructor for subclasses that need only provider/model ids. */
+const edaRuntimeConfig = (input) => ({
+	modelSelection: {
+		modelId: input.modelId,
+		provider: input.provider
+	},
+	...input.maxToolCallsPerRun === void 0 ? {} : { maxToolCallsPerRun: input.maxToolCallsPerRun },
+	...input.systemPrompt === void 0 ? {} : { systemPrompt: input.systemPrompt }
+});
+/** Encode committed events into the existing structured-clone envelope. */
+const encodeEdaRpcCommittedDurableEvent = (entry) => ({
+	position: entry.position,
+	event: encodeEdaRpcDurableEvent(durableEventEnvelope(entry.event))
+});
+/** Encode query snapshots without asserting that encoded command values are decoded classes. */
+const encodeEdaRpcSessionSnapshot = Schema.encodeSync(edaSessionRpc.snapshot.output);
+//#endregion
+export { encodeEdaRpcCommittedDurableEvent as a, DurableObjectAlarmScheduler as c, edaRuntimeConfig as i, EDA_WEB_SOCKET_PROJECTION_HEADER as n, encodeEdaRpcSessionSnapshot as o, EDA_WEB_SOCKET_STREAM_PARAM as r, getEDASessionDurableObjectByName as s, EDASessionDurableObject as t };
+
+//# sourceMappingURL=durable-object-CkrxIOH4.js.map