@relayfx/test 0.2.14 → 0.2.16

package/dist/types/runtime/workflow/execution-workflow.d.ts

@@ -1,6 +1,6 @@
 import { Agent, Ids } from "../../schema/index";
 import { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "@relayfx/store-sql/portable";
-import { Workflow } from "effect/unstable/workflow";
+import { Workflow, WorkflowEngine } from "effect/unstable/workflow";
 import { Effect, Layer, Option, Schema } from "effect";
 import { Service as AgentLoopService } from "../agent/agent-loop-service";
 import { ChildTerminalStatus } from "../child/parent-notifier-service";
@@ -80,83 +80,105 @@ export declare const StartInput: Schema.Struct<{
     readonly agent_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_snapshot: Schema.optionalKey<Schema.Codec<Agent.Definition, {
         readonly name: string;
-        readonly permissions: readonly {
-            readonly name: string;
-            readonly value: Schema.Json;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        }[];
+        readonly instructions?: string;
         readonly model: {
             readonly provider: string;
             readonly model: string;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
             readonly registration_key?: string;
             readonly request_options?: {
                 readonly [x: string]: Schema.Json;
             };
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
         };
         readonly tool_names: readonly string[];
-        readonly metadata?: {
-            readonly [x: string]: Schema.Json;
-        };
-        readonly instructions?: string;
-        readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-            readonly context_window: Schema.Number;
-            readonly reserve_tokens: Schema.Number;
-            readonly keep_recent_tokens: Schema.Number;
-        }, "Encoded">;
-        readonly output_schema_ref?: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
         readonly skill_definition_ids?: readonly string[];
         readonly permission_rules?: {
             readonly rules: readonly {
                 readonly pattern: string;
-                readonly level: "allow" | "deny" | "ask";
+                readonly level: "allow" | "ask" | "deny";
                 readonly reason?: string;
             }[];
-            readonly fallback?: "allow" | "deny" | "ask";
+            readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly compaction_policy?: {
+            readonly context_window: number;
+            readonly reserve_tokens: number;
+            readonly keep_recent_tokens: number;
+            readonly summary_model?: {
+                readonly provider: string;
+                readonly model: string;
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+        };
         readonly max_tool_turns?: number;
         readonly max_wait_turns?: number;
         readonly token_budget?: number;
         readonly child_run_presets?: {
             readonly [x: string]: {
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-                readonly permissions?: readonly string[];
+                readonly instructions?: string;
                 readonly model?: {
                     readonly provider: string;
                     readonly model: string;
-                    readonly metadata?: {
-                        readonly [x: string]: Schema.Json;
-                    };
                     readonly registration_key?: string;
                     readonly request_options?: {
                         readonly [x: string]: Schema.Json;
                     };
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly compaction_policy?: {
+                    readonly context_window: number;
+                    readonly reserve_tokens: number;
+                    readonly keep_recent_tokens: number;
+                    readonly summary_model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
                 };
-                readonly instructions?: string;
-                readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-                    readonly context_window: Schema.Number;
-                    readonly reserve_tokens: Schema.Number;
-                    readonly keep_recent_tokens: Schema.Number;
-                }, "Encoded">;
                 readonly tool_names?: readonly string[];
+                readonly permissions?: readonly string[];
                 readonly workspace_policy?: {
-                    readonly mode: "share" | "fork";
+                    readonly mode: "fork" | "share";
                     readonly fallback?: "fail" | "fresh";
                 };
                 readonly output_schema_ref?: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
             };
         };
         readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
             readonly name: Schema.String;
             readonly preset_name: Schema.String;
         }, "Encoded">[];
+        readonly output_schema_ref?: string;
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
     }, never, never>>;
     readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
@@ -348,83 +370,105 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     readonly agent_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_snapshot: Schema.optionalKey<Schema.Codec<Agent.Definition, {
         readonly name: string;
-        readonly permissions: readonly {
-            readonly name: string;
-            readonly value: Schema.Json;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        }[];
+        readonly instructions?: string;
         readonly model: {
             readonly provider: string;
             readonly model: string;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
             readonly registration_key?: string;
             readonly request_options?: {
                 readonly [x: string]: Schema.Json;
             };
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
         };
         readonly tool_names: readonly string[];
-        readonly metadata?: {
-            readonly [x: string]: Schema.Json;
-        };
-        readonly instructions?: string;
-        readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-            readonly context_window: Schema.Number;
-            readonly reserve_tokens: Schema.Number;
-            readonly keep_recent_tokens: Schema.Number;
-        }, "Encoded">;
-        readonly output_schema_ref?: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
         readonly skill_definition_ids?: readonly string[];
         readonly permission_rules?: {
             readonly rules: readonly {
                 readonly pattern: string;
-                readonly level: "allow" | "deny" | "ask";
+                readonly level: "allow" | "ask" | "deny";
                 readonly reason?: string;
             }[];
-            readonly fallback?: "allow" | "deny" | "ask";
+            readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly compaction_policy?: {
+            readonly context_window: number;
+            readonly reserve_tokens: number;
+            readonly keep_recent_tokens: number;
+            readonly summary_model?: {
+                readonly provider: string;
+                readonly model: string;
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+        };
         readonly max_tool_turns?: number;
         readonly max_wait_turns?: number;
         readonly token_budget?: number;
         readonly child_run_presets?: {
             readonly [x: string]: {
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-                readonly permissions?: readonly string[];
+                readonly instructions?: string;
                 readonly model?: {
                     readonly provider: string;
                     readonly model: string;
-                    readonly metadata?: {
-                        readonly [x: string]: Schema.Json;
-                    };
                     readonly registration_key?: string;
                     readonly request_options?: {
                         readonly [x: string]: Schema.Json;
                     };
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly compaction_policy?: {
+                    readonly context_window: number;
+                    readonly reserve_tokens: number;
+                    readonly keep_recent_tokens: number;
+                    readonly summary_model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
                 };
-                readonly instructions?: string;
-                readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-                    readonly context_window: Schema.Number;
-                    readonly reserve_tokens: Schema.Number;
-                    readonly keep_recent_tokens: Schema.Number;
-                }, "Encoded">;
                 readonly tool_names?: readonly string[];
+                readonly permissions?: readonly string[];
                 readonly workspace_policy?: {
-                    readonly mode: "share" | "fork";
+                    readonly mode: "fork" | "share";
                     readonly fallback?: "fail" | "fresh";
                 };
                 readonly output_schema_ref?: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
             };
         };
         readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
             readonly name: Schema.String;
             readonly preset_name: Schema.String;
         }, "Encoded">[];
+        readonly output_schema_ref?: string;
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
     }, never, never>>;
     readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
@@ -451,45 +495,40 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, typeof ExecutionWorkflowFailed>;
-export declare const sessionEntryScope: (input: StartInput, turn: number) => string;
-export declare const layer: Layer.Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | ToolRuntimeService | import("../address/address-resolution-service").Service | import("../skill/skill-registry-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | import("../workspace/workspace-planner-service").Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine | AgentLoopService>;
-export declare const start: <const Discard extends boolean = false>(input: StartInput, options?: {
+export declare const sessionEntryScope: {
+    (input: StartInput, turn: number): string;
+    (turn: number): (input: StartInput) => string;
+};
+export declare const layer: Layer.Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | ToolRuntimeService | import("../address/address-resolution-service").Service | import("../skill/skill-registry-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | import("../workspace/workspace-planner-service").Service | AgentLoopService | WorkflowEngine.WorkflowEngine>;
+interface StartOptions<Discard extends boolean> {
     readonly discard?: Discard;
-}) => Effect.Effect<Discard extends true ? string : {
-    readonly status: "waiting" | "running" | "completed" | "failed" | "queued" | "cancelled";
-    readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    readonly metadata?: {
-        readonly [x: string]: Schema.Json;
-    };
-    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
-    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
-}, Discard extends true ? never : ExecutionWorkflowFailed, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
-export declare const startRequest: (input: StartInput) => Effect.Effect<{
-    readonly status: "waiting" | "running" | "completed" | "failed" | "queued" | "cancelled";
-    readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    readonly metadata?: {
-        readonly [x: string]: Schema.Json;
-    };
-    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
-    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
-}, ExecutionWorkflowFailed, ExecutionRepository.Service | import("../wait/wait-service").Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
-export declare const dispatchRequest: (input: StartInput) => Effect.Effect<void, never, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+}
+export declare const start: {
+    <const Discard extends boolean = false>(input: StartInput, options?: StartOptions<Discard>): Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
+    <const Discard extends boolean = false>(options?: StartOptions<Discard>): (input: StartInput) => Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
+};
+export declare const startRequest: (input: StartInput) => Effect.Effect<StartResult, ExecutionWorkflowFailed, ExecutionRepository.Service | import("../wait/wait-service").Service | WorkflowEngine.WorkflowEngine>;
+export declare const dispatchRequest: (input: StartInput) => Effect.Effect<void, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
 export declare const cancelRequest: (input: CancelExecutionInput) => Effect.Effect<{
     execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    status: "waiting" | "running" | "completed" | "failed" | "queued" | "cancelled";
-}, ExecutionWorkflowFailed, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+    status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
+}, ExecutionWorkflowFailed, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine>;
 export declare const poll: (executionId: string) => Effect.Effect<Option.Option<Workflow.Result<{
-    readonly status: "waiting" | "running" | "completed" | "failed" | "queued" | "cancelled";
     readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    readonly status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
+    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
+    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
     readonly metadata?: {
         readonly [x: string]: Schema.Json;
     };
-    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
-    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
-}, ExecutionWorkflowFailed>>, never, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
-export declare const resume: (executionId: string) => Effect.Effect<void, never, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+}, ExecutionWorkflowFailed>>, never, WorkflowEngine.WorkflowEngine>;
+export declare const resume: (executionId: string) => Effect.Effect<void, never, WorkflowEngine.WorkflowEngine>;
 export declare const workflowExecutionId: (input: StartInput) => Effect.Effect<string, never, never>;
-export declare const workflowExecutionIdForExecution: (executionId: Ids.ExecutionId, workflowGeneration?: number) => Effect.Effect<string, never, never>;
+export declare const workflowExecutionIdForExecution: {
+    (executionId: Ids.ExecutionId): Effect.Effect<string>;
+    (executionId: Ids.ExecutionId, workflowGeneration: number): Effect.Effect<string>;
+    (workflowGeneration: number): (executionId: Ids.ExecutionId) => Effect.Effect<string>;
+};
 export declare const activeWorkflowExecutionIdForExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<string, ExecutionWorkflowFailed, ExecutionRepository.Service>;
-export declare const signalWait: (input: SignalWaitInput) => Effect.Effect<void, never, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const signalWait: (input: SignalWaitInput) => Effect.Effect<void, never, WorkflowEngine.WorkflowEngine>;
 export {};

package/dist/types/runtime/workspace/workspace-planner-service.d.ts

@@ -50,15 +50,15 @@ export interface Interface {
     readonly release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProviderError>;
     readonly fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspacePlanner", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workspace/workspace-planner-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, WorkspaceLeaseRepository.Service | EventLogService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceUnavailable, Service>;
+export declare const suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceCapabilityUnsupported | WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing, Service>;
+export declare const resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceUnavailable, Service>;
+export declare const attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceUnavailable, Service>;
+export declare const release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing, Service>;
 export declare const fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError, Service>;
 export {};

package/dist/types/runtime/workspace/workspace-provider-service.d.ts

@@ -60,16 +60,20 @@ export interface Interface {
     readonly fork: (ref: Ids.WorkspaceRef, spec?: Partial<WorkspaceSpec>) => Effect.Effect<Ids.WorkspaceRef, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError>;
     readonly destroy: (ref: Ids.WorkspaceRef) => Effect.Effect<void, WorkspaceProviderError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspaceProvider", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workspace/workspace-provider-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const memoryHandle: (ref: Ids.WorkspaceRef, providerKey?: Workspace.WorkspaceProviderKey) => WorkspaceHandle;
+export declare const memoryHandle: {
+    (ref: Ids.WorkspaceRef, providerKey: Workspace.WorkspaceProviderKey): WorkspaceHandle;
+    (ref: Ids.WorkspaceRef): WorkspaceHandle;
+    (providerKey: Workspace.WorkspaceProviderKey): (ref: Ids.WorkspaceRef) => WorkspaceHandle;
+};
 export declare const memoryLayer: (providerKey?: Workspace.WorkspaceProviderKey) => Layer.Layer<Service, never, never>;
 export interface DaytonaSandbox {
     readonly id: string;
     state?: string;
-    readonly start: () => Effect.Effect<void, WorkspaceProviderError>;
-    readonly stop: () => Effect.Effect<void, WorkspaceProviderError>;
+    readonly start: (_?: void) => Effect.Effect<void, WorkspaceProviderError>;
+    readonly stop: (_?: void) => Effect.Effect<void, WorkspaceProviderError>;
     readonly readFile?: (path: string) => Effect.Effect<string, WorkspaceProviderError>;
     readonly writeFile?: (path: string, content: string) => Effect.Effect<void, WorkspaceProviderError>;
     readonly exec?: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceProviderError>;
@@ -100,9 +104,9 @@ export interface LocalDockerLayerConfig {
 export declare const localDockerLayer: (config: LocalDockerLayerConfig) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const acquire: (spec: WorkspaceSpec) => Effect.Effect<WorkspaceHandle, WorkspaceProviderError, Service>;
-export declare const resume: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<WorkspaceHandle, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError, Service>;
+export declare const resume: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<WorkspaceHandle, WorkspaceNotFound | WorkspaceProviderError | WorkspaceUnavailable, Service>;
 export declare const suspend: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, WorkspaceNotFound | WorkspaceProviderError, Service>;
-export declare const snapshot: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, name?: string | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.SnapshotRef">, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError, Service>;
-export declare const fork: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, spec?: Partial<WorkspaceSpec> | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError, Service>;
+export declare const snapshot: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, name?: string | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.SnapshotRef">, WorkspaceCapabilityUnsupported | WorkspaceNotFound | WorkspaceProviderError, Service>;
+export declare const fork: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, spec?: Partial<WorkspaceSpec> | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, WorkspaceCapabilityUnsupported | WorkspaceNotFound | WorkspaceProviderError, Service>;
 export declare const destroy: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<void, WorkspaceProviderError, Service>;
 export {};

package/dist/types/runtime/workspace/workspace-runtime-service.d.ts

@@ -10,7 +10,7 @@ export interface Interface {
     readonly writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceRuntimeError>;
     readonly exec: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceRuntimeError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspaceRuntime", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workspace/workspace-runtime-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layerFromHandle: (handle: WorkspaceHandle) => Layer.Layer<Service, never, never>;