@relayfx/sdk 0.2.15 → 0.3.0

package/dist/{index-xbbfagnb.js → index-pn652eef.js}

@@ -52,7 +52,7 @@ import {
   exports_wait_service,
   exports_wait_signal,
   exports_workflow_definition_repository
-} from "./index-z9xk02sv.js";
+} from "./index-c2skef55.js";
 
 // src/operation.ts
 var exports_operation = {};
@@ -101,6 +101,8 @@ __export(exports_operation, {
   PendingToolCall: () => PendingToolCall,
   PendingToolApprovalList: () => PendingToolApprovalList,
   PendingToolApproval: () => PendingToolApproval,
+  PageExecutionEventsResult: () => PageExecutionEventsResult,
+  PageExecutionEventsInput: () => PageExecutionEventsInput,
   ListWaitsInput: () => ListWaitsInput,
   ListTopicSubscriptionsInput: () => ListTopicSubscriptionsInput,
   ListToolAttemptsInput: () => ListToolAttemptsInput,
@@ -129,6 +131,7 @@ __export(exports_operation, {
   FollowExecutionInput: () => FollowExecutionInput,
   ExecutionListChange: () => ExecutionListChange,
   ExecutionInspection: () => ExecutionInspection,
+  ExecutionEventPageDirection: () => ExecutionEventPageDirection,
   ExecutionCursor: () => ExecutionCursor,
   EventLogCursorNotFound: () => EventLogCursorNotFound,
   EnvelopeReadyReleased: () => EnvelopeReadyReleased,
@@ -675,6 +678,27 @@ var ReplayExecutionInput = Schema.Struct({
 var ReplayExecutionResult = Schema.Struct({
   events: Schema.Array(exports_execution_schema.ExecutionEvent)
 }).annotate({ identifier: "Relay.Operation.ReplayExecutionResult" });
+var ExecutionEventPageDirection = Schema.Literals(["forward", "backward"]).annotate({
+  identifier: "Relay.Operation.ExecutionEventPageDirection"
+});
+var PageExecutionEventsInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  direction: ExecutionEventPageDirection,
+  after_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  before_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1000)))
+}).check(Schema.makeFilter((input) => {
+  if (input.direction === "forward") {
+    return input.before_cursor === undefined ? undefined : { path: ["before_cursor"], issue: "forward pages accept only after_cursor" };
+  }
+  return input.after_cursor === undefined ? undefined : { path: ["after_cursor"], issue: "backward pages accept only before_cursor" };
+})).annotate({ identifier: "Relay.Operation.PageExecutionEventsInput" });
+var PageExecutionEventsResult = Schema.Struct({
+  events: Schema.Array(exports_execution_schema.ExecutionEvent),
+  has_more: Schema.Boolean,
+  oldest_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  newest_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.PageExecutionEventsResult" });
 var RunnerSummary = Schema.Struct({
   address: Schema.String,
   healthy: Schema.Boolean,
@@ -702,8 +726,8 @@ __export(exports_command, {
   CommandTimedOut: () => CommandTimedOut,
   CommandReplyInvalid: () => CommandReplyInvalid
 });
-import { Schema as Schema2 } from "effect";
-var make = (name, options) => ({ name, ...options });
+import { Function, Schema as Schema2 } from "effect";
+var make = Function.dual(2, (name, options) => ({ name, ...options }));
 var inputSchemaRef = (name) => `relay/command/${name}/input`;
 var outputSchemaRef = (name) => `relay/command/${name}/output`;
 
@@ -756,6 +780,7 @@ __export(exports_client, {
   registerAgent: () => registerAgent,
   registerAddressBookRoute: () => registerAddressBookRoute,
   publishTopic: () => publishTopic,
+  pageExecutionEvents: () => pageExecutionEvents,
   listWaits: () => listWaits,
   listTopicSubscriptions: () => listTopicSubscriptions,
   listToolAttempts: () => listToolAttempts,
@@ -805,10 +830,10 @@ __export(exports_client, {
   EntityNamespaceReserved: () => EntityNamespaceReserved,
   ClientError: () => ClientError
 });
-import { Clock, Context as Context2, Effect as Effect2, Layer as Layer2, Option, Schema as Schema4, SchemaGetter, SchemaIssue, Stream } from "effect";
+import { Clock, Context as Context2, Effect as Effect2, Layer as Layer2, Option, Random, Schema as Schema4, SchemaGetter, SchemaIssue, Stream } from "effect";
 import { EntityId, ShardId, Sharding, ShardingConfig } from "effect/unstable/cluster";
 // src/runtime-capability-policy.ts
-import { Context, Effect, Layer, Schema as Schema3 } from "effect";
+import { Context, Effect, Function as Function2, Layer, Schema as Schema3 } from "effect";
 
 class RuntimeCapabilityUnavailable extends Schema3.TaggedErrorClass()("RuntimeCapabilityUnavailable", {
   capability: Schema3.Literals(["fan-out", "workflow-definition"]),
@@ -817,18 +842,18 @@ class RuntimeCapabilityUnavailable extends Schema3.TaggedErrorClass()("RuntimeCa
 }) {
 }
 
-class Service extends Context.Service()("@relayfx/sdk/RuntimeCapabilityPolicy") {
+class Service extends Context.Service()("@relayfx/sdk/runtime-capability-policy/Service") {
 }
-var layer = (role, capabilities) => Layer.succeed(Service, {
+var layer = Function2.dual(2, (role, capabilities) => Layer.succeed(Service, {
   admit: (capability) => {
     const enabled = capability === "fan-out" ? capabilities.fanOut : capabilities.workflowDefinition;
-    return enabled ? Effect.void : Effect.fail(new RuntimeCapabilityUnavailable({
+    return enabled ? Effect.void : Effect.fail(RuntimeCapabilityUnavailable.make({
       capability,
       role,
       nextAction: role === "embedded" ? "enable-embedded-capability" : "use-embedded-runtime"
     }));
   }
-});
+}));
 
 // src/client.ts
 class ClientError extends Schema4.TaggedErrorClass()("ClientError", {
@@ -852,7 +877,7 @@ class WaitKindMismatch extends Schema4.TaggedErrorClass()("WaitKindMismatch", {
 }) {
 }
 
-class Service2 extends Context2.Service()("@relayfx/sdk/Client") {
+class Service2 extends Context2.Service()("@relayfx/sdk/client/Service") {
 }
 var followTerminalStatus = (type) => type === "execution.completed" ? "completed" : type === "execution.failed" ? "failed" : type === "execution.cancelled" ? "cancelled" : undefined;
 var followReconnectDelayMillis = (attempt) => Math.min(100 * 2 ** (attempt - 1), 5000);
@@ -864,7 +889,7 @@ var followStopped = (reason, cursor) => ({
 var followExecutionFrom = (dependencies) => (input) => {
   const maxReconnects = input.max_reconnects ?? 10;
   const stopModes = input.stop_on_wait_modes;
-  const inspect = Effect2.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect2.catchTag("ExecutionNotFound", (error) => new ClientError({ message: `execution ${error.execution_id} not found` })));
+  const inspect = Effect2.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect2.catchTag("ExecutionNotFound", (error) => ClientError.make({ message: `execution ${error.execution_id} not found` })));
   const reconcile = (state, message) => Stream.unwrap(Effect2.gen(function* () {
     const inspection = yield* inspect;
     const terminal = followTerminalStatus(`execution.${inspection.status}`);
@@ -876,7 +901,7 @@ var followExecutionFrom = (dependencies) => (input) => {
       return Stream.make(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
     }
     if (state.attempts >= maxReconnects) {
-      return Stream.fail(new ClientError({
+      return Stream.fail(ClientError.make({
         message: `follow of ${input.execution_id} exhausted ${maxReconnects} reconnects: ${message}`
       }));
     }
@@ -900,7 +925,7 @@ var followExecutionFrom = (dependencies) => (input) => {
     if (stopModes !== undefined && event.type === "wait.created") {
       const mode = event.data?.mode;
       if (typeof mode === "string" && stopModes.includes(mode)) {
-        const inspection = yield* dependencies.inspectExecution(input.execution_id).pipe(Effect2.catchTag("ExecutionNotFound", () => Effect2.succeed(undefined)));
+        const inspection = yield* dependencies.inspectExecution(input.execution_id).pipe(Effect2.catchTag("ExecutionNotFound", () => Effect2.void));
         const actionable = inspection?.waiting_on.find((wait) => wait.state === "open" && wait.wait_id === event.data?.wait_id);
         if (actionable !== undefined) {
           items.push(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
@@ -916,7 +941,7 @@ var followExecutionFrom = (dependencies) => (input) => {
   return Stream.unwrap(Effect2.gen(function* () {
     const existing = yield* dependencies.getExecution(input.execution_id);
     if (existing === undefined) {
-      return Stream.fail(new ClientError({ message: `execution ${input.execution_id} not found` }));
+      return Stream.fail(ClientError.make({ message: `execution ${input.execution_id} not found` }));
     }
     const state = {
       cursor: input.after_cursor,
@@ -938,8 +963,8 @@ var errorMessage = (error) => {
   }
   return String(error);
 };
-var toClientError = (error) => new ClientError({ message: errorMessage(error) });
-var rejectReserved = (id, prefix) => id.startsWith(prefix) ? Effect2.fail(new EntityNamespaceReserved({ id, message: "start entities via Client.getOrCreateEntity" })) : Effect2.void;
+var toClientError = (error) => ClientError.make({ message: errorMessage(error) });
+var rejectReserved = (id, prefix) => id.startsWith(prefix) ? Effect2.fail(EntityNamespaceReserved.make({ id, message: "start entities via Client.getOrCreateEntity" })) : Effect2.void;
 var replyValueFrom = (content) => {
   if (content === undefined || content.length === 0)
     return Option.none();
@@ -1087,9 +1112,9 @@ var modelSelectionFromBatonAgent = (selection) => ({
   model: selection.model,
   ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
 });
-var decodeBatonAgentName = (name) => Schema4.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect2.mapError(() => new ClientError({ message: "Baton agent name must not be blank" })));
-var decodeBatonAgentMetadata = (metadata) => metadata === undefined ? Effect2.succeed(undefined) : Schema4.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata).pipe(Effect2.mapError(() => new ClientError({ message: "Baton agent metadata must be JSON metadata" })));
-var decodeBatonMemorySubject = (subject) => Schema4.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect2.mapError(() => new ClientError({ message: "Baton agent memory subject must be a MemorySubjectId" })));
+var decodeBatonAgentName = (name) => Schema4.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect2.mapError(() => ClientError.make({ message: "Baton agent name must not be blank" })));
+var decodeBatonAgentMetadata = (metadata) => metadata === undefined ? Effect2.void : Schema4.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata).pipe(Effect2.mapError(() => ClientError.make({ message: "Baton agent metadata must be JSON metadata" })));
+var decodeBatonMemorySubject = (subject) => Schema4.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect2.mapError(() => ClientError.make({ message: "Baton agent memory subject must be a MemorySubjectId" })));
 var metadataFromBatonAgent = Effect2.fn("Client.metadataFromBatonAgent")(function* (input) {
   const agentMetadata = yield* decodeBatonAgentMetadata(input.agent.metadata);
   const memorySubject = input.agent.memory === undefined ? undefined : yield* decodeBatonMemorySubject(input.agent.memory.subject);
@@ -1105,32 +1130,32 @@ var modelSelectionFromRegisterInput = (input) => {
     return Effect2.succeed(input.model);
   if (input.agent.model !== undefined)
     return Effect2.succeed(modelSelectionFromBatonAgent(input.agent.model));
-  return Effect2.fail(new ClientError({ message: "Client.registerAgent requires model or agent.model" }));
+  return Effect2.fail(ClientError.make({ message: "Client.registerAgent requires model or agent.model" }));
 };
-var batonTurnPolicyInvalid = (detail) => new ClientError({ message: `Baton agent turn policy is not durably portable: ${detail}` });
+var batonTurnPolicyInvalid = (detail) => ClientError.make({ message: `Baton agent turn policy is not durably portable: ${detail}` });
 var turnPolicySnapshotFromBaton = Effect2.fn("Client.turnPolicySnapshotFromBaton")(function* (snapshot) {
   let nodes = 0;
   const visit = (current, depth) => Effect2.gen(function* () {
     if (typeof current !== "object" || current === null || Array.isArray(current)) {
-      return yield* Effect2.fail(batonTurnPolicyInvalid("snapshot nodes must be objects"));
+      return yield* batonTurnPolicyInvalid("snapshot nodes must be objects");
     }
     const node = current;
     nodes += 1;
     if (depth > exports_agent_schema.maxTurnPolicySnapshotDepth) {
-      return yield* Effect2.fail(batonTurnPolicyInvalid(`depth exceeds ${exports_agent_schema.maxTurnPolicySnapshotDepth}`));
+      return yield* batonTurnPolicyInvalid(`depth exceeds ${exports_agent_schema.maxTurnPolicySnapshotDepth}`);
     }
     if (nodes > exports_agent_schema.maxTurnPolicySnapshotNodes) {
-      return yield* Effect2.fail(batonTurnPolicyInvalid(`node count exceeds ${exports_agent_schema.maxTurnPolicySnapshotNodes}`));
+      return yield* batonTurnPolicyInvalid(`node count exceeds ${exports_agent_schema.maxTurnPolicySnapshotNodes}`);
     }
     switch (node._tag) {
       case "Recurs":
         if (typeof node.count !== "number" || !Number.isInteger(node.count) || node.count < 0) {
-          return yield* Effect2.fail(batonTurnPolicyInvalid("recurs count must be a non-negative integer"));
+          return yield* batonTurnPolicyInvalid("recurs count must be a non-negative integer");
         }
         return { kind: "recurs", count: node.count };
       case "UntilToolCall":
         if (typeof node.name !== "string" || node.name.trim().length === 0) {
-          return yield* Effect2.fail(batonTurnPolicyInvalid("until-tool-call name must not be blank"));
+          return yield* batonTurnPolicyInvalid("until-tool-call name must not be blank");
         }
         return { kind: "until-tool-call", name: node.name };
       case "Both":
@@ -1140,7 +1165,7 @@ var turnPolicySnapshotFromBaton = Effect2.fn("Client.turnPolicySnapshotFromBaton
           second: yield* visit(node.second, depth + 1)
         };
       default:
-        return yield* Effect2.fail(batonTurnPolicyInvalid("snapshot tag is not recognized"));
+        return yield* batonTurnPolicyInvalid("snapshot tag is not recognized");
     }
   });
   return yield* visit(snapshot, 1);
@@ -1150,7 +1175,7 @@ var turnPolicyFieldsFromRegisterInput = Effect2.fn("Client.turnPolicyFieldsFromR
     return { max_tool_turns: input.max_tool_turns };
   const snapshot = input.agent.policy.snapshot;
   if (snapshot === undefined) {
-    return yield* Effect2.fail(batonTurnPolicyInvalid("opaque policies require an explicit max_tool_turns replacement"));
+    return yield* batonTurnPolicyInvalid("opaque policies require an explicit max_tool_turns replacement");
   }
   const durable = yield* turnPolicySnapshotFromBaton(snapshot);
   if (durable.kind === "recurs" && durable.count === 8)
@@ -1243,19 +1268,19 @@ var resolveToolOutcomeWait = Effect2.fn("Client.resolveToolOutcomeWait")(functio
   const waitId = call.waitId ?? toolWaitId(call.call.id);
   const wait = yield* waits.get(waitId).pipe(Effect2.mapError(toClientError));
   if (wait === undefined)
-    return yield* new ClientError({ message: `Tool wait not found: ${waitId}` });
+    return yield* ClientError.make({ message: `Tool wait not found: ${waitId}` });
   if (wait.executionId !== call.executionId) {
-    return yield* new ClientError({ message: `Tool wait does not match call: ${call.call.id}` });
+    return yield* ClientError.make({ message: `Tool wait does not match call: ${call.call.id}` });
   }
   if (wait.state === "resolved") {
     const accepted = yield* acceptedWaitOutcome(wait);
     if (exports_shared_schema.canonicalString(accepted) !== exports_shared_schema.canonicalString(outcome)) {
-      return yield* new ClientError({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
+      return yield* ClientError.make({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
     }
     return wait;
   }
   if (wait.state !== "open") {
-    return yield* new ClientError({ message: `Tool wait is ${wait.state}: ${call.call.id}` });
+    return yield* ClientError.make({ message: `Tool wait is ${wait.state}: ${call.call.id}` });
   }
   const eventSequence = yield* nextEventSequence(eventLog, call.executionId);
   const resolved = yield* waits.wake({
@@ -1267,19 +1292,19 @@ var resolveToolOutcomeWait = Effect2.fn("Client.resolveToolOutcomeWait")(functio
   if (!resolved.transitioned) {
     const accepted = yield* acceptedWaitOutcome(resolved.wait);
     if (exports_shared_schema.canonicalString(accepted) !== exports_shared_schema.canonicalString(outcome)) {
-      return yield* new ClientError({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
+      return yield* ClientError.make({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
     }
   }
   return resolved.wait;
 });
 var signalToolOutcome = Effect2.fn("Client.signalToolOutcome")(function* (executionRepository, makeExecutionClient, wait, signaledAt) {
-  yield* exports_wait_signal.signalWorkflowWait({
-    makeExecutionClient,
+  yield* Effect2.mapError(Effect2.orDie(exports_wait_signal.signalWorkflowWait({
+    makeExecutionClient: typedWaitSignalClient(makeExecutionClient),
     executionId: wait.executionId,
     waitId: wait.id,
     state: "resolved",
     signaledAt
-  }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository), Effect2.mapError(toClientError));
+  }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository))), toClientError);
 });
 var toReady = (record) => ({
   id: record.id,
@@ -1294,6 +1319,12 @@ var toLease = (record) => ({
   worker_id: record.claimOwner ?? "unclaimed",
   claim_expires_at: record.claimExpiresAt ?? record.updatedAt
 });
+var typedWaitSignalClient = (makeExecutionClient) => (executionId) => {
+  const client = makeExecutionClient(executionId);
+  return {
+    signalWait: (input) => client.signalWait(input).pipe(Effect2.mapError((error) => exports_wait_signal.WaitSignalError.make({ message: String(error) })))
+  };
+};
 var nextEventSequence = Effect2.fn("Client.nextEventSequence")(function* (eventLog, executionId) {
   const max = yield* eventLog.maxSequence(executionId).pipe(Effect2.mapError(toClientError));
   return max === undefined ? 0 : max + 1;
@@ -1306,10 +1337,10 @@ var terminalChildStatus = (metadata) => {
 var wakeRuntime = Effect2.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input, accepts) {
   const wait = yield* waits.get(input.wait_id).pipe(Effect2.mapError(toClientError));
   if (wait === undefined)
-    return yield* new ClientError({ message: `Wait not found: ${input.wait_id}` });
+    return yield* ClientError.make({ message: `Wait not found: ${input.wait_id}` });
   const kind = waitSemanticKind(wait);
   if (accepts !== undefined && kind !== accepts) {
-    return yield* new WaitKindMismatch({
+    return yield* WaitKindMismatch.make({
       wait_id: input.wait_id,
       expected: accepts,
       actual: kind,
@@ -1317,7 +1348,7 @@ var wakeRuntime = Effect2.fn("Client.wakeRuntime")(function* (waits, eventLog, e
     });
   }
   if (accepts === undefined && kind === "child" && !terminalChildStatus(input.metadata)) {
-    return yield* new WaitKindMismatch({
+    return yield* WaitKindMismatch.make({
       wait_id: input.wait_id,
       expected: 'child wake with terminal metadata.child_status ("completed" | "failed" | "cancelled")',
       actual: kind,
@@ -1325,7 +1356,7 @@ var wakeRuntime = Effect2.fn("Client.wakeRuntime")(function* (waits, eventLog, e
     });
   }
   if (input.state === "cancelled" && wait.metadata.kind === "tool-placement") {
-    return yield* new ClientError({ message: "Tool placement waits must be cancelled through cancelExecution" });
+    return yield* ClientError.make({ message: "Tool placement waits must be cancelled through cancelExecution" });
   }
   const eventSequence = yield* nextEventSequence(eventLog, wait.executionId);
   const result = input.state === "resolved" ? yield* waits.wake({
@@ -1345,13 +1376,13 @@ var wakeRuntime = Effect2.fn("Client.wakeRuntime")(function* (waits, eventLog, e
     metadata: wakeMetadata(input)
   }).pipe(Effect2.mapError(toClientError));
   if (result.transitioned) {
-    yield* exports_wait_signal.signalWorkflowWait({
-      makeExecutionClient,
+    yield* Effect2.mapError(Effect2.orDie(exports_wait_signal.signalWorkflowWait({
+      makeExecutionClient: typedWaitSignalClient(makeExecutionClient),
       executionId: result.wait.executionId,
       waitId: result.wait.id,
       state: input.state,
       signaledAt: input.signaled_at
-    }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository), Effect2.mapError(toClientError));
+    }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository))), toClientError);
   }
   return {
     wait_id: result.wait.id,
@@ -1420,20 +1451,20 @@ var reconcileExistingChildSpawn = Effect2.fn("Client.reconcileExistingChildSpawn
   if (existing === undefined)
     return;
   if (existing.executionId !== input.execution_id || existing.addressId !== input.address_id || childSpawnFingerprint(existing) !== exports_shared_schema.canonicalString(input)) {
-    return yield* new ClientError({ message: `Child execution conflicts: ${childExecutionId}` });
+    return yield* ClientError.make({ message: `Child execution conflicts: ${childExecutionId}` });
   }
   const spawned = yield* eventLog.findByCursor({
     executionId: input.execution_id,
     cursor: `${input.execution_id}:child:${childExecutionId}:spawned`
   }).pipe(Effect2.mapError(toClientError));
   if (Option.isNone(spawned)) {
-    return yield* new ClientError({ message: `Child spawn event missing: ${childExecutionId}` });
+    return yield* ClientError.make({ message: `Child spawn event missing: ${childExecutionId}` });
   }
   const parentWaitId = input.wait === true ? childJoinWaitId(childExecutionId) : undefined;
   if (parentWaitId !== undefined) {
     const wait = yield* waits.get(parentWaitId).pipe(Effect2.mapError(toClientError));
     if (wait === undefined) {
-      return yield* new ClientError({ message: `Child join wait missing: ${childExecutionId}` });
+      return yield* ClientError.make({ message: `Child join wait missing: ${childExecutionId}` });
     }
   }
   return {
@@ -1445,10 +1476,10 @@ var reconcileExistingChildSpawn = Effect2.fn("Client.reconcileExistingChildSpawn
 var parentDefinitionPin = Effect2.fn("Client.parentDefinitionPin")(function* (executionRepository, executionId) {
   const record = yield* executionRepository.get(executionId).pipe(Effect2.mapError(toClientError));
   if (record === undefined) {
-    return yield* new ClientError({ message: `Execution not found: ${executionId}` });
+    return yield* ClientError.make({ message: `Execution not found: ${executionId}` });
   }
   if (record.agentId === undefined || record.agentRevision === undefined || record.agentSnapshot === undefined) {
-    return yield* new ClientError({ message: `Parent execution is not pinned to an agent: ${executionId}` });
+    return yield* ClientError.make({ message: `Parent execution is not pinned to an agent: ${executionId}` });
   }
   return {
     agentId: record.agentId,
@@ -1515,12 +1546,12 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
     if (Option.isSome(childFanOutRuntime)) {
       const fanOut = yield* childFanOutRuntime.value.cancel(input.fan_out_id, input.cancelled_at, input.reason ?? "child fan-out cancelled").pipe(Effect2.mapError(toClientError));
       if (fanOut === undefined)
-        return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
+        return yield* ClientError.make({ message: `Child fan-out not found: ${input.fan_out_id}` });
       return { fan_out: fanOut };
     }
     const result = yield* childFanOuts.cancel(input.fan_out_id, input.cancelled_at).pipe(Effect2.mapError(toClientError));
     if (result === undefined)
-      return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
+      return yield* ClientError.make({ message: `Child fan-out not found: ${input.fan_out_id}` });
     yield* Effect2.forEach(result.activeChildExecutionIds, (childId) => makeExecutionClient(exports_ids_schema.ExecutionId.make(childId)).cancel({
       execution_id: exports_ids_schema.ExecutionId.make(childId),
       cancelled_at: input.cancelled_at,
@@ -1566,14 +1597,14 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
   const awaitWaitOperation = Effect2.fn("Client.runtime.awaitWait")(function* (input) {
     const current = yield* envelopeReady.getWait(input.wait_id).pipe(Effect2.mapError(toClientError));
     if (current === undefined) {
-      return yield* new ClientError({ message: `wait ${input.wait_id} not found` });
+      return yield* ClientError.make({ message: `wait ${input.wait_id} not found` });
     }
     if (current.state !== "open")
       return yield* waitOutcomeFrom(current);
     yield* eventLog.stream({ executionId: input.execution_id }).pipe(Stream.filter((event) => (event.type === "wait.woken" || event.type === "wait.timed_out" || event.type === "wait.cancelled") && event.data?.wait_id === input.wait_id), Stream.take(1), Stream.runDrain, Effect2.mapError(toClientError));
     const terminal = yield* envelopeReady.getWait(input.wait_id).pipe(Effect2.mapError(toClientError));
     if (terminal === undefined || terminal.state === "open") {
-      return yield* new ClientError({ message: `wait ${input.wait_id} did not reach a terminal state` });
+      return yield* ClientError.make({ message: `wait ${input.wait_id} did not reach a terminal state` });
     }
     return yield* waitOutcomeFrom(terminal);
   });
@@ -1589,7 +1620,7 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
   const inspectExecutionOperation = Effect2.fn("Client.runtime.inspectExecution")(function* (executionId) {
     const execution = yield* executionRepository.get(executionId).pipe(Effect2.mapError(toClientError));
     if (execution === undefined)
-      return yield* new ExecutionNotFound({ execution_id: executionId });
+      return yield* ExecutionNotFound.make({ execution_id: executionId });
     const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect2.mapError(toClientError));
     const calls = yield* toolCalls.listCalls(executionId).pipe(Effect2.mapError(toClientError));
     const pendingChunks = yield* Effect2.forEach(calls, (call) => toolCalls.getResult(call.call.id).pipe(Effect2.mapError(toClientError), Effect2.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
@@ -1676,8 +1707,8 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
     getAgentDefinition: Effect2.fn("Client.runtime.getAgentDefinition")(function* (id) {
       return yield* agentRegistry.get(id).pipe(Effect2.mapError(toClientError));
     }),
-    listAgentDefinitions: Effect2.fn("Client.runtime.listAgentDefinitions")(function* () {
-      return yield* agentRegistry.list().pipe(Effect2.mapError(toClientError));
+    listAgentDefinitions: Effect2.fn("Client.runtime.listAgentDefinitions")(function* (_) {
+      return yield* agentRegistry.list.pipe(Effect2.mapError(toClientError));
     }),
     listAgentDefinitionRevisions: Effect2.fn("Client.runtime.listAgentDefinitionRevisions")(function* (id) {
       return yield* agentRegistry.listRevisions(id).pipe(Effect2.mapError(toClientError));
@@ -1685,8 +1716,8 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
     getSkillDefinition: Effect2.fn("Client.runtime.getSkillDefinition")(function* (id) {
       return yield* skillRegistry.get(id).pipe(Effect2.mapError(toClientError));
     }),
-    listSkillDefinitions: Effect2.fn("Client.runtime.listSkillDefinitions")(function* () {
-      return yield* skillRegistry.list().pipe(Effect2.mapError(toClientError));
+    listSkillDefinitions: Effect2.fn("Client.runtime.listSkillDefinitions")(function* (_) {
+      return yield* skillRegistry.list.pipe(Effect2.mapError(toClientError));
     }),
     listSkillDefinitionRevisions: Effect2.fn("Client.runtime.listSkillDefinitionRevisions")(function* (id) {
       return yield* skillRegistry.listRevisions(id).pipe(Effect2.mapError(toClientError));
@@ -1698,8 +1729,8 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
     getAddressBookRoute: Effect2.fn("Client.runtime.getAddressBookRoute")(function* (id) {
       return yield* addressBook.get(id).pipe(Effect2.mapError(toClientError));
     }),
-    listAddressBookRoutes: Effect2.fn("Client.runtime.listAddressBookRoutes")(function* () {
-      return yield* addressBook.list().pipe(Effect2.mapError(toClientError));
+    listAddressBookRoutes: Effect2.fn("Client.runtime.listAddressBookRoutes")(function* (_) {
+      return yield* addressBook.list.pipe(Effect2.mapError(toClientError));
     }),
     startExecution: Effect2.fn("Client.runtime.startExecution")(function* (input) {
       yield* rejectReserved(input.execution_id, "execution:entity:");
@@ -1726,7 +1757,9 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
         yield* rejectReserved(input.session_id, "session:entity:");
       const definition = yield* agentRegistry.getRevision({ id: input.agent_id, revision: input.agent_revision }).pipe(Effect2.mapError(toClientError));
       if (definition === undefined) {
-        return yield* Effect2.fail(new ClientError({ message: `Agent revision not found: ${input.agent_id}@${input.agent_revision}` }));
+        return yield* ClientError.make({
+          message: `Agent revision not found: ${input.agent_id}@${input.agent_revision}`
+        });
       }
       const payload = startExecutionByAgentDefinitionPayload(input, definition);
       const client = makeExecutionClient(payload.execution_id);
@@ -1749,10 +1782,10 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
     steer: Effect2.fn("Client.runtime.steer")(function* (input) {
       const execution = yield* executionRepository.get(input.execution_id).pipe(Effect2.mapError(toClientError));
       if (execution === undefined) {
-        return yield* new ClientError({ message: `Execution not found: ${input.execution_id}` });
+        return yield* ClientError.make({ message: `Execution not found: ${input.execution_id}` });
       }
       if (execution.status !== "running") {
-        return yield* new ClientError({ message: `Execution is not running: ${input.execution_id}` });
+        return yield* ClientError.make({ message: `Execution is not running: ${input.execution_id}` });
       }
       const record = yield* steering.appendForRunning({
         executionId: input.execution_id,
@@ -1778,19 +1811,19 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
       return records.map(toWaitView);
     }),
     listExecutions: Effect2.fn("Client.runtime.listExecutions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect2.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(ExecutionCursorFromString)(input.cursor);
       const result = yield* executionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.status === undefined ? {} : { status: input.status },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
-      }).pipe(Effect2.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect2.mapError(toClientError));
+      });
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(ExecutionCursorFromString)(result.nextCursor);
       return {
         records: result.records.map(toConversationSummary),
         ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
       };
-    }),
+    }, Effect2.mapError(toClientError)),
     subscribeTopic: Effect2.fn("Client.runtime.subscribeTopic")(function* (input) {
       return yield* topicService.subscribe({
         topicAddressId: input.topic_address_id,
@@ -1828,22 +1861,22 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
       }).pipe(Effect2.mapError(toClientError));
     }),
     listSessions: Effect2.fn("Client.runtime.listSessions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(SessionCursorFromString)(input.cursor).pipe(Effect2.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(SessionCursorFromString)(input.cursor);
       const result = yield* sessionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
-      }).pipe(Effect2.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(SessionCursorFromString)(result.nextCursor).pipe(Effect2.mapError(toClientError));
+      });
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(SessionCursorFromString)(result.nextCursor);
       return {
         records: result.records.map(toSessionSummary),
         ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
       };
-    }),
+    }, Effect2.mapError(toClientError)),
     getSession: Effect2.fn("Client.runtime.getSession")(function* (input) {
       const session = yield* sessionRepository.get(input.session_id).pipe(Effect2.mapError(toClientError));
       if (session === undefined)
-        return yield* new ClientError({ message: `Session not found: ${input.session_id}` });
+        return yield* ClientError.make({ message: `Session not found: ${input.session_id}` });
       const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect2.mapError(toClientError));
       const result = yield* executionRepository.list({
         sessionId: input.session_id,
@@ -1865,7 +1898,27 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
       }).pipe(Effect2.mapError(toClientError));
       return { events };
     }),
-    listRunners: Effect2.fn("Client.runtime.listRunners")(function* () {
+    pageExecutionEvents: Effect2.fn("Client.runtime.pageExecutionEvents")(function* (input) {
+      const pageInput = input.direction === "forward" ? {
+        executionId: input.execution_id,
+        direction: "forward",
+        ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
+        ...input.limit === undefined ? {} : { limit: input.limit }
+      } : {
+        executionId: input.execution_id,
+        direction: "backward",
+        ...input.before_cursor === undefined ? {} : { beforeCursor: input.before_cursor },
+        ...input.limit === undefined ? {} : { limit: input.limit }
+      };
+      const result = yield* eventLog.page(pageInput).pipe(Effect2.mapError(toStreamError));
+      return {
+        events: result.events,
+        has_more: result.hasMore,
+        ...result.oldestCursor === undefined ? {} : { oldest_cursor: result.oldestCursor },
+        ...result.newestCursor === undefined ? {} : { newest_cursor: result.newestCursor }
+      };
+    }),
+    listRunners: Effect2.fn("Client.runtime.listRunners")(function* (_) {
       const runners = yield* clusterRegistry.listRunners().pipe(Effect2.mapError(toClientError));
       return {
         runners: runners.map((runner) => ({
@@ -1893,7 +1946,7 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
     askEntity: Effect2.fn("Client.runtime.askEntity")(function* (input) {
       const instance = yield* entities.get({ kind: input.kind, key: input.key }).pipe(Effect2.mapError(toClientError));
       if (instance === undefined || instance.status === "destroyed") {
-        return yield* new EntityNotFound({ kind: input.kind, key: input.key });
+        return yield* EntityNotFound.make({ kind: input.kind, key: input.key });
       }
       const encoded = yield* Schema4.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect2.mapError(toClientError));
       const inputRef = inputSchemaRef(input.command.name);
@@ -1902,7 +1955,7 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
         yield* schemaRegistry.value.register({ ref: inputRef, schema: input.command.input });
         yield* schemaRegistry.value.register({ ref: outputRef, schema: input.command.output });
       }
-      const correlation = `command:${input.command.name}:${globalThis.crypto.randomUUID()}`;
+      const correlation = `command:${input.command.name}:${yield* Random.nextInt}`;
       const accepted = yield* sendEnvelope({
         from: input.from,
         to: instance.address_id,
@@ -1921,28 +1974,28 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
         }
       });
       if (accepted.wait_id === undefined) {
-        return yield* new ClientError({ message: "askEntity send did not create a reply wait" });
+        return yield* ClientError.make({ message: "askEntity send did not create a reply wait" });
       }
       const outcome = yield* awaitWaitOperation({ wait_id: accepted.wait_id, execution_id: accepted.execution_id });
       if (outcome.state === "timed_out") {
-        return yield* new CommandTimedOut({
+        return yield* CommandTimedOut.make({
           command: input.command.name,
           wait_id: outcome.wait_id,
           timeout: input.timeout ?? "unspecified"
         });
       }
       if (outcome.state === "cancelled") {
-        return yield* new ClientError({ message: `reply wait ${outcome.wait_id} was cancelled` });
+        return yield* ClientError.make({ message: `reply wait ${outcome.wait_id} was cancelled` });
       }
       const replyValue = replyValueFrom(outcome.content);
       if (replyValue._tag === "None") {
-        return yield* new CommandReplyInvalid({
+        return yield* CommandReplyInvalid.make({
           command: input.command.name,
           wait_id: outcome.wait_id,
           message: "reply carried no decodable content"
         });
       }
-      return yield* Schema4.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect2.mapError((issue) => new CommandReplyInvalid({
+      return yield* Schema4.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect2.mapError((issue) => CommandReplyInvalid.make({
         command: input.command.name,
         wait_id: outcome.wait_id,
         message: errorMessage(issue)
@@ -1983,14 +2036,14 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
       ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
       ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
       updatedAt: input.updated_at
-    }).pipe(Effect2.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
+    }).pipe(Effect2.mapError((error) => Schema4.is(exports_execution_state_service.StateVersionConflict)(error) ? error : toClientError(error)))),
     deleteEntityState: Effect2.fn("Client.runtime.deleteEntityState")((input) => executionState.remove({
       executionId: input.execution_id,
       key: input.key,
       ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
       ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
       removedAt: input.removed_at
-    }).pipe(Effect2.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
+    }).pipe(Effect2.mapError((error) => Schema4.is(exports_execution_state_service.StateVersionConflict)(error) ? error : toClientError(error)))),
     listEntityState: Effect2.fn("Client.runtime.listEntityState")((input) => executionState.list({
       executionId: input.execution_id,
       ...input.prefix === undefined ? {} : { prefix: input.prefix },
@@ -2041,7 +2094,7 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
       const coordinated = yield* coordinateToolTransition(Effect2.gen(function* () {
         const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect2.mapError(toClientError));
         if (call === undefined || call.executionId !== input.execution_id || call.placement.kind !== "client") {
-          return yield* new ClientError({ message: `Client tool call not found: ${input.tool_call_id}` });
+          return yield* ClientError.make({ message: `Client tool call not found: ${input.tool_call_id}` });
         }
         const wait = yield* resolveToolOutcomeWait(waits, eventLog, call, input.outcome, input.fulfilled_at);
         const accepted = yield* toolCalls.acceptClientOutcome({
@@ -2070,7 +2123,7 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
         const active = call !== undefined && call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attempt_id && call.claimOwner === input.worker_id && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.completed_at;
         const acceptedRetry = call !== undefined && call.placement.kind === "remote" && call.state === "submitted" && call.activeAttemptId === input.attempt_id && call.externalOutcome !== undefined;
         if (call === undefined || !active && !acceptedRetry) {
-          return yield* new ClientError({ message: `Remote tool claim is not active: ${input.tool_call_id}` });
+          return yield* ClientError.make({ message: `Remote tool claim is not active: ${input.tool_call_id}` });
         }
         const wait = yield* resolveToolOutcomeWait(waits, eventLog, call, input.outcome, input.completed_at);
         const accepted = yield* toolCalls.acceptRemoteOutcome({
@@ -2113,8 +2166,8 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
       const pin = yield* parentDefinitionPin(executionRepository, input.execution_id);
       const createdAt = yield* Clock.currentTimeMillis;
       const internal = internalSpawnChildRunInput(input, pin, createdAt);
-      const context = yield* exports_child_run_service.resolveForDispatch(internal).pipe(Effect2.mapError((error) => new ClientError({ message: error._tag })));
-      const definition = yield* exports_child_run_service.childDefinition(pin.agentSnapshot, context).pipe(Effect2.mapError((error) => new ClientError({ message: error._tag })));
+      const context = yield* exports_child_run_service.resolveForDispatch(internal).pipe(Effect2.mapError((error) => ClientError.make({ message: error._tag })));
+      const definition = yield* exports_child_run_service.childDefinition(pin.agentSnapshot, context).pipe(Effect2.mapError((error) => ClientError.make({ message: error._tag })));
       const coordinated = yield* coordinateChildSpawn(Effect2.gen(function* () {
         const existing = yield* reconcileExistingChildSpawn(childExecutions, waits, eventLog, input);
         if (existing !== undefined)
@@ -2122,7 +2175,7 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
         const accepted = yield* executions.spawnChildRun(internal).pipe(Effect2.mapError(toClientError));
         const parentWaitId = input.wait === true ? yield* createChildJoinWait(waits, eventLog, internal, accepted, createdAt) : undefined;
         return { accepted, createdAt, parentWaitId };
-      })).pipe(Effect2.catch((error) => error.message === "DuplicateChildExecution" ? coordinateChildSpawn(reconcileExistingChildSpawn(childExecutions, waits, eventLog, input).pipe(Effect2.flatMap((existing) => existing === undefined ? Effect2.fail(new ClientError({ message: `Child execution retry missing: ${input.execution_id}` })) : Effect2.succeed(existing)))) : Effect2.fail(error)));
+      })).pipe(Effect2.catch((error) => error.message === "DuplicateChildExecution" ? coordinateChildSpawn(reconcileExistingChildSpawn(childExecutions, waits, eventLog, input).pipe(Effect2.flatMap((existing) => existing === undefined ? Effect2.fail(ClientError.make({ message: `Child execution retry missing: ${input.execution_id}` })) : Effect2.succeed(existing)))) : Effect2.fail(error)));
       const startPayload = childStartInput(internal, coordinated.accepted, pin, definition, coordinated.createdAt, coordinated.parentWaitId);
       const client = makeExecutionClient(startPayload.execution_id);
       yield* client.dispatch(startPayload).pipe(Effect2.mapError(toClientError));
@@ -2132,7 +2185,7 @@ var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
       if (Option.isSome(runtimeCapabilityPolicy))
         yield* runtimeCapabilityPolicy.value.admit("fan-out");
       if (Option.isNone(childFanOutRuntime)) {
-        return yield* new ClientError({
+        return yield* ClientError.make({
           message: "Child fan-out runtime unavailable; provide ChildFanOutRuntime.Service to Client.layerFromRuntime"
         });
       }
@@ -2218,10 +2271,11 @@ var testLayer = (implementation) => Layer2.succeed(Service2, Service2.of({
     streamExecution: implementation.streamExecution
   }),
   registerEntityKind: implementation.registerEntityKind ?? ((input) => Effect2.succeed(input)),
-  getOrCreateEntity: implementation.getOrCreateEntity ?? (() => Effect2.fail(new ClientError({ message: "Entity service unavailable" }))),
-  getEntity: implementation.getEntity ?? (() => Effect2.succeed(undefined)),
-  destroyEntity: implementation.destroyEntity ?? (() => Effect2.fail(new ClientError({ message: "Entity service unavailable" }))),
+  getOrCreateEntity: implementation.getOrCreateEntity ?? (() => Effect2.fail(ClientError.make({ message: "Entity service unavailable" }))),
+  getEntity: implementation.getEntity ?? (() => Effect2.void.pipe(Effect2.as(undefined))),
+  destroyEntity: implementation.destroyEntity ?? (() => Effect2.fail(ClientError.make({ message: "Entity service unavailable" }))),
   listEntities: implementation.listEntities ?? (() => Effect2.succeed([])),
+  pageExecutionEvents: implementation.pageExecutionEvents ?? (() => Effect2.fail(ClientError.make({ message: "Execution event paging unavailable" }))),
   streamSession: implementation.streamSession ?? (() => Stream.empty),
   watchExecutions: implementation.watchExecutions ?? (() => Stream.empty),
   getPresence: implementation.getPresence ?? ((scope) => Effect2.succeed({ scope, entries: [], observed_at: 0 })),
@@ -2342,6 +2396,10 @@ var replayExecution = Effect2.fn("Client.replayExecution.call")(function* (input
   const service = yield* Service2;
   return yield* service.replayExecution(input);
 });
+var pageExecutionEvents = Effect2.fn("Client.pageExecutionEvents.call")(function* (input) {
+  const service = yield* Service2;
+  return yield* service.pageExecutionEvents(input);
+});
 var listRunners = Effect2.fn("Client.listRunners.call")(function* () {
   const service = yield* Service2;
   return yield* service.listRunners();
@@ -2525,12 +2583,13 @@ __export(exports_runtime_database, {
 });
 import { Context as Context3 } from "effect";
 
-class Service3 extends Context3.Service()("@relayfx/sdk/RuntimeDatabase") {
+class Service3 extends Context3.Service()("@relayfx/sdk/runtime-database/Service") {
 }
 
 // src/runtime.ts
 var DatabaseIdentity = Schema5.NonEmptyString.pipe(Schema5.brand("@relayfx/sdk/DatabaseIdentity"));
-var makeDatabaseIdentity = Schema5.decodeUnknownSync(DatabaseIdentity);
+var decodeDatabaseIdentity = Schema5.decodeUnknownSync(DatabaseIdentity);
+var makeDatabaseIdentity = (input) => decodeDatabaseIdentity(input);
 var Dialect = Schema5.Literals(["pg", "mysql", "sqlite"]);
 var DatabaseDialect = Symbol("@relayfx/sdk/DatabaseDialect");
 
@@ -2649,29 +2708,30 @@ class RuntimeReadinessError extends Schema5.TaggedErrorClass()("RuntimeReadiness
 }) {
 }
 
-class Service4 extends Context4.Service()("@relayfx/sdk/Runtime") {
+class Service4 extends Context4.Service()("@relayfx/sdk/runtime/Service") {
 }
+var embeddedOutput = (layer2) => layer2;
 var isAcquisitionError = (error) => typeof error === "object" && error !== null && ("_tag" in error) && (error._tag === "RuntimeConfigurationError" || error._tag === "RuntimeTopologyError" || error._tag === "RuntimeMigrationError");
 var normalizeHost = (layer2, role, dialect) => {
   const normalize = (error) => {
     if (isAcquisitionError(error))
       return error;
     if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "ClusterConfigMismatch") {
-      const clusterFailure = new ClusterFailure({ reason: "cluster configuration is incompatible" });
+      const clusterFailure = ClusterFailure.make({ reason: "cluster configuration is incompatible" });
       Object.defineProperty(clusterFailure, "originalCause", { value: error, enumerable: false });
-      return new RuntimeTopologyError({
+      return RuntimeTopologyError.make({
         dialect,
         role,
         nextAction: role === "embedded" ? "use-embedded" : "use-different-database",
         cause: clusterFailure
       });
     }
-    const hostFailure = new HostLayerError({
+    const hostFailure = HostLayerError.make({
       service: "Runtime host graph",
       reason: "host layer acquisition failed"
     });
     Object.defineProperty(hostFailure, "originalCause", { value: error, enumerable: false });
-    return new RuntimeConfigurationError({
+    return RuntimeConfigurationError.make({
       setting: "host layers",
       nextAction: "provide-host-layer",
       cause: hostFailure
@@ -2698,11 +2758,11 @@ var validatedDatabase = (databaseLayer, role) => {
     const sql = yield* SqlClient;
     const actual = actualDialect(sql);
     if (actual !== database.dialect) {
-      return yield* new RuntimeTopologyError({
+      return yield* RuntimeTopologyError.make({
         dialect: database.dialect,
         role,
         nextAction: role === "embedded" ? "use-different-database" : "use-postgres-or-mysql",
-        cause: new DatabaseDialectMismatch({ expected: database.dialect, actual })
+        cause: DatabaseDialectMismatch.make({ expected: database.dialect, actual })
       });
     }
     if (database.dialect === "sqlite") {
@@ -2719,10 +2779,10 @@ var runtimeServiceLayer = (role, capabilities) => Layer3.effect(Service4, Effect
   const database = yield* Service3;
   const runner = yield* exports_runner_runtime_service.Service;
   return Service4.of({
-    readiness: runner.check().pipe(Effect3.mapError((error) => {
-      const cause = new SqlFailure({ category: "unknown", operation: "readiness", retryable: false });
+    readiness: runner.check.pipe(Effect3.mapError((error) => {
+      const cause = SqlFailure.make({ category: "unknown", operation: "readiness", retryable: false });
       Object.defineProperty(cause, "originalCause", { value: error, enumerable: false });
-      return new RuntimeReadinessError({ phase: "database", cause });
+      return RuntimeReadinessError.make({ phase: "database", cause });
     }), Effect3.as({
       ready: true,
       role,
@@ -2756,7 +2816,7 @@ var withHosts = (runner, options) => {
   const workflowHost = options.workflowDefinitionHandlersLayer === undefined ? Layer3.empty : exports_definition_runtime.layerFromRuntime.pipe(Layer3.provide(options.workflowDefinitionHandlersLayer), Layer3.provideMerge(childHost), Layer3.provide(runner));
   return Layer3.mergeAll(runner, childHost, workflowHost);
 };
-var layerEmbedded = (options) => {
+function layerEmbedded(options) {
   const runner = exports_runner_runtime_service.layerWithServices({
     databaseLayer: ambientDatabaseLayer,
     languageModelLayer: options.languageModelLayer,
@@ -2767,11 +2827,12 @@ var layerEmbedded = (options) => {
     promptAssemblerLayer: options.promptAssemblerLayer,
     schemaRegistryLayer: options.schemaRegistryLayer
   });
-  return normalizeHost(publicGraph(withHosts(runner, options), options.databaseLayer, "embedded", {
+  const host = normalizeHost(publicGraph(withHosts(runner, options), options.databaseLayer, "embedded", {
     fanOut: options.childFanOutHandlersLayer !== undefined,
     workflowDefinition: options.workflowDefinitionHandlersLayer !== undefined
   }), "embedded", options.databaseLayer[DatabaseDialect]);
-};
+  return embeddedOutput(host);
+}
 var layerRunner = (options) => {
   const runner = exports_runner_runtime_service.layerWithServicesMultiNode({
     databaseLayer: ambientDatabaseLayer,