@relayfx/test 0.2.14 → 0.2.16

package/dist/types/runtime/schedule/scheduler-service.d.ts

@@ -1,6 +1,6 @@
 import { Schedule } from "../../schema/index";
 import { ExecutionRepository, ScheduleRepository } from "@relayfx/store-sql/portable";
-import { Config, Context, Cron, Effect, Layer, Schema } from "effect";
+import { Config, Context, Cron, Effect, Layer, Option, Schema } from "effect";
 import { Service as EventLogService } from "../execution/event-log-service";
 import { Service as WaitServiceService } from "../wait/wait-service";
 declare const SchedulerError_base: Schema.Class<SchedulerError, Schema.TaggedStruct<"SchedulerError", {
@@ -17,13 +17,13 @@ export declare class ScheduleCronInvalid extends ScheduleCronInvalid_base {
 export interface Interface {
     readonly runOnce: Effect.Effect<number, SchedulerError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/SchedulerService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/schedule/scheduler-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const pollIntervalMillisConfig: Config.Config<number>;
 export declare const claimTtlMillisConfig: Config.Config<number>;
 export declare const enabledConfig: Config.Config<boolean>;
-export declare const workerIdConfig: Config.Config<string>;
+export declare const workerIdConfig: Config.Config<Option.Option<string>>;
 export declare const parseCron: (cronExpr: string) => Effect.Effect<Cron.Cron, ScheduleCronInvalid>;
 export declare const startIdempotencyKey: (schedule: Schedule.ScheduleRecord) => string;
 export declare const make: Effect.Effect<Interface, Config.ConfigError, ExecutionRepository.Service | ScheduleRepository.Service | EventLogService | WaitServiceService | import("effect/unstable/cluster/Sharding").Sharding>;

package/dist/types/runtime/schema-registry/schema-registry-service.d.ts

@@ -15,11 +15,11 @@ export interface Interface {
     readonly registrations: Effect.Effect<ReadonlyArray<Registration>>;
     readonly resolve: (ref: string) => Effect.Effect<Registration, SchemaRefNotRegistered>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/SchemaRegistry", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/schema-registry/schema-registry-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: (initialRegistrations?: ReadonlyArray<Registration>) => Layer.Layer<Service, never, never>;
-export declare const memoryLayer: (initialRegistrations?: ReadonlyArray<Registration>) => Layer.Layer<Service, never, never>;
+export declare const memoryLayer: typeof layer;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const register: (registration: Registration) => Effect.Effect<void, never, Service>;
 export declare const registrations: () => Effect.Effect<readonly Registration[], never, Service>;

package/dist/types/runtime/session/session-store-service.d.ts

@@ -3,12 +3,21 @@ import { Ids } from "../../schema/index";
 import { SessionRepository } from "@relayfx/store-sql/portable";
 import { Context, Effect, Layer } from "effect";
 export type Interface = Session.Interface;
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/RelaySessionStore", Session.Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/session/session-store-service/Service", Session.Interface>;
 export declare class Service extends Service_base {
 }
 export declare const make: (sessionId: string & import("effect/Brand").Brand<"Relay.SessionId">, entryScope?: string | undefined) => Effect.Effect<Session.Interface, never, SessionRepository.Service>;
-export declare const serviceLayer: (sessionId: Ids.SessionId, entryScope?: string) => Layer.Layer<Service, never, SessionRepository.Service>;
-export declare const layer: (sessionId: Ids.SessionId, entryScope?: string) => Layer.Layer<Session.SessionStore, never, SessionRepository.Service>;
-export declare const memoryLayer: (sessionId: Ids.SessionId, entryScope?: string) => Layer.Layer<Session.SessionStore, never, never>;
+export declare const serviceLayer: {
+    (sessionId: Ids.SessionId, entryScope?: string): Layer.Layer<Service, never, SessionRepository.Service>;
+    (entryScope?: string): (sessionId: Ids.SessionId) => Layer.Layer<Service, never, SessionRepository.Service>;
+};
+export declare const layer: {
+    (sessionId: Ids.SessionId, entryScope?: string): Layer.Layer<Session.SessionStore, never, SessionRepository.Service>;
+    (entryScope?: string): (sessionId: Ids.SessionId) => Layer.Layer<Session.SessionStore, never, SessionRepository.Service>;
+};
+export declare const memoryLayer: {
+    (sessionId: Ids.SessionId, entryScope?: string): Layer.Layer<Session.SessionStore>;
+    (entryScope?: string): (sessionId: Ids.SessionId) => Layer.Layer<Session.SessionStore>;
+};
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Session.SessionStore, never, never>;
 export {};

package/dist/types/runtime/skill/skill-registry-service.d.ts

@@ -20,13 +20,13 @@ export interface Interface {
     readonly register: (input: Skill.RegisterDefinitionPayload) => Effect.Effect<Skill.DefinitionRegistered, SkillDefinitionInvalid | SkillRegistryError>;
     readonly get: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRecord | undefined, SkillRegistryError>;
     readonly getRevision: (input: SkillDefinitionRepository.GetSkillDefinitionRevisionInput) => Effect.Effect<Skill.DefinitionRevisionRecord | undefined, SkillRegistryError>;
-    readonly list: () => Effect.Effect<Skill.DefinitionList, SkillRegistryError>;
+    readonly list: Effect.Effect<Skill.DefinitionList, SkillRegistryError>;
     readonly listRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRevisionList, SkillRegistryError>;
     readonly pinExecution: (input: PinExecutionSkillsInput) => Effect.Effect<Skill.ExecutionPinList, SkillRegistryError>;
     readonly listPins: (executionId: Ids.ExecutionId) => Effect.Effect<Skill.ExecutionPinList, SkillRegistryError>;
     readonly getPinned: (input: SkillDefinitionRepository.GetPinnedSkillInput) => Effect.Effect<Skill.ExecutionPinRecord | undefined, SkillRegistryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/SkillRegistry", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/skill/skill-registry-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, SkillDefinitionRepository.Service>;

package/dist/types/runtime/state/execution-state-service.d.ts

@@ -19,7 +19,10 @@ export interface StateKey<A, I extends Shared.JsonValue> {
     readonly name: string;
     readonly schema: Schema.Codec<A, I>;
 }
-export declare const key: <A, I extends Shared.JsonValue>(name: string, schema: Schema.Codec<A, I>) => StateKey<A, I>;
+export declare const key: {
+    <A, I extends Shared.JsonValue>(name: string, schema: Schema.Codec<A, I>): StateKey<A, I>;
+    (name: string): <A, I extends Shared.JsonValue>(schema: Schema.Codec<A, I>) => StateKey<A, I>;
+};
 export interface PutInput<A, I extends Shared.JsonValue> {
     readonly executionId: Ids.ExecutionId;
     readonly key: StateKey<A, I>;
@@ -48,7 +51,7 @@ export interface Interface {
     readonly remove: (input: RemoveInput) => Effect.Effect<State.StateRecordView | undefined, ExecutionStateRepository.StateVersionConflict | ExecutionStateError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<State.StateRecordView>, ExecutionStateError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ExecutionStateService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/state/execution-state-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, ExecutionStateRepository.Service | BlobStoreService>;

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

@@ -1,5 +1,5 @@
 import { Execution, Ids, Shared, Tool } from "../../schema/index";
-import { EnvelopeRepository, ScheduleRepository, ToolCallRepository } from "@relayfx/store-sql/portable";
+import { ToolCallRepository } from "@relayfx/store-sql/portable";
 import { Tool as AiTool, Toolkit } from "effect/unstable/ai";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Service as EventLogService } from "../execution/event-log-service";
@@ -50,7 +50,7 @@ export interface ToolExecutionContext {
 }
 export interface ToolCallInfoData extends ToolExecutionContext {
 }
-declare const ToolCallInfo_base: Context.ServiceClass<ToolCallInfo, "@relayfx/runtime/ToolCallInfo", ToolCallInfoData>;
+declare const ToolCallInfo_base: Context.ServiceClass<ToolCallInfo, "@relayfx/runtime/tool/tool-runtime-service/ToolCallInfo", ToolCallInfoData>;
 export declare class ToolCallInfo extends ToolCallInfo_base {
 }
 export interface RegisteredTool {
@@ -58,10 +58,10 @@ export interface RegisteredTool {
     readonly tool: AiTool.Any;
     readonly placement?: Tool.Placement | undefined;
     readonly requiredPermissions?: ReadonlyArray<string>;
-    readonly validateInput?: (input: Shared.JsonValue) => Effect.Effect<void, ToolInputInvalid, any>;
-    readonly run?: ((input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, unknown, any>) | undefined;
+    readonly validateInput?: (input: Shared.JsonValue) => Effect.Effect<void, ToolInputInvalid>;
+    readonly run?: ((input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>) | undefined;
 }
-export interface ToolOptions<Input extends Schema.Constraint, Output extends Schema.Constraint> {
+export interface ToolOptions<Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>> {
     readonly description: string;
     readonly input: Input;
     readonly output: Output;
@@ -71,7 +71,7 @@ export interface ToolOptions<Input extends Schema.Constraint, Output extends Sch
     readonly needsApproval?: boolean | undefined;
     readonly metadata?: Shared.Metadata | undefined;
     readonly placement?: Tool.Placement | undefined;
-    readonly run: (input: Input["Type"], context: ToolExecutionContext) => Effect.Effect<Output["Type"], unknown, any>;
+    readonly run: (input: Input["Type"], context: ToolExecutionContext) => Effect.Effect<Output["Type"], ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, ToolCallInfo>;
 }
 export interface DynamicToolOptions {
     readonly description: string;
@@ -83,7 +83,7 @@ export interface DynamicToolOptions {
     readonly needsApproval?: boolean | undefined;
     readonly metadata?: Shared.Metadata | undefined;
     readonly placement?: Tool.Placement | undefined;
-    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, unknown, any>;
+    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>;
 }
 export interface ToolkitToolOptions {
     readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
@@ -107,15 +107,24 @@ export interface Interface {
     readonly register: (tool: RegisteredTool) => Effect.Effect<void>;
     readonly definitions: Effect.Effect<ReadonlyArray<Tool.Definition>>;
     readonly registeredTools: Effect.Effect<ReadonlyArray<RegisteredTool>>;
-    readonly run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, any>;
+    readonly run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, never>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ToolRuntime", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/tool/tool-runtime-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const toolFromRegistered: (tool: RegisteredTool) => AiTool.Any;
-export declare const toolsFromToolkit: <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.WithHandler<Tools>, options?: ToolkitRegistrationOptions) => ReadonlyArray<RegisteredTool>;
-export declare const tool: <const Name extends string, Input extends Schema.Constraint, Output extends Schema.Constraint>(name: Name, options: ToolOptions<Input, Output>) => RegisteredTool;
-export declare const dynamicTool: <const Name extends string>(name: Name, options: DynamicToolOptions) => RegisteredTool;
+export declare const toolsFromToolkit: {
+    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.WithHandler<Tools>, options?: ToolkitRegistrationOptions): ReadonlyArray<RegisteredTool>;
+    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.WithHandler<Tools>) => ReadonlyArray<RegisteredTool>;
+};
+export declare const tool: {
+    <const Name extends string, Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(name: Name, options: ToolOptions<Input, Output>): RegisteredTool;
+    <Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(options: ToolOptions<Input, Output>): <const Name extends string>(name: Name) => RegisteredTool;
+};
+export declare const dynamicTool: {
+    <const Name extends string>(name: Name, options: DynamicToolOptions): RegisteredTool;
+    (options: DynamicToolOptions): <const Name extends string>(name: Name) => RegisteredTool;
+};
 export interface PlacedToolOptions {
     readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
     readonly requiredPermissions?: ReadonlyArray<string> | undefined;
@@ -123,17 +132,31 @@ export interface PlacedToolOptions {
     readonly needsApproval?: boolean | undefined;
     readonly metadata?: Shared.Metadata | undefined;
 }
-export declare const clientTool: (modelTool: AiTool.Any, options?: PlacedToolOptions) => RegisteredTool;
-export declare const remoteTool: (modelTool: AiTool.Any, options: PlacedToolOptions & {
-    readonly queue: Tool.PlacementKey;
-}) => RegisteredTool;
+export declare const clientTool: {
+    (modelTool: AiTool.Any, options?: PlacedToolOptions): RegisteredTool;
+    (options?: PlacedToolOptions): (modelTool: AiTool.Any) => RegisteredTool;
+};
+export declare const remoteTool: {
+    (modelTool: AiTool.Any, options: PlacedToolOptions & {
+        readonly queue: Tool.PlacementKey;
+    }): RegisteredTool;
+    (options: PlacedToolOptions & {
+        readonly queue: Tool.PlacementKey;
+    }): (modelTool: AiTool.Any) => RegisteredTool;
+};
 export declare const layer: (initialTools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<Service, never, ToolCallRepository.Service | EventLogService | WaitServiceService>;
-export declare const layerFromToolkit: <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions) => Layer.Layer<Service, never, ToolCallRepository.Service | EventLogService | WaitServiceService | Exclude<AiTool.HandlersFor<Tools>, import("effect/Scope").Scope>>;
+export declare const layerFromToolkit: {
+    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<Service, never, ToolCallRepository.Service | EventLogService | WaitServiceService | AiTool.HandlersFor<Tools>>;
+    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<Service, never, ToolCallRepository.Service | EventLogService | WaitServiceService | AiTool.HandlersFor<Tools>>;
+};
 export declare const memoryLayer: (tools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<Service, never, never>;
-export declare const memoryLayerFromToolkit: <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions) => Layer.Layer<Service, never, Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<AiTool.HandlersFor<Tools>, import("effect/Scope").Scope>, WaitServiceService>, ToolCallRepository.Service>, EnvelopeRepository.Service>, ScheduleRepository.Service>, EventLogService>>;
+export declare const memoryLayerFromToolkit: {
+    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<Service, never, Exclude<AiTool.HandlersFor<Tools>, ToolCallRepository.Service | EventLogService | WaitServiceService>>;
+    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<Service, never, Exclude<AiTool.HandlersFor<Tools>, ToolCallRepository.Service | EventLogService | WaitServiceService>>;
+};
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const register: (registeredTool: RegisteredTool) => Effect.Effect<void, never, Service>;
 export declare const definitions: () => Effect.Effect<readonly Tool.Definition[], never, Service>;
 export declare const registeredTools: () => Effect.Effect<readonly RegisteredTool[], never, Service>;
-export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, any>;
+export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, ToolExecutionFailed | ToolExecutionWaitRequested | ToolInputInvalid | ToolNotRegistered | ToolPermissionDenied | ToolRuntimeError, Service>;
 export {};

package/dist/types/runtime/tool/tool-transition-coordinator.d.ts

@@ -4,10 +4,10 @@ import type { SqlError } from "effect/unstable/sql/SqlError";
 export interface Interface {
     readonly coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError, R>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ToolTransitionCoordinator", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/tool/tool-transition-coordinator/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const sqlLayer: Layer.Layer<Service, never, SqlClient>;
-export declare const coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, SqlError | E, Service | R>;
+export declare const coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError, R | Service>;
 export {};

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

@@ -37,7 +37,7 @@ export interface Interface {
     readonly publish: (input: PublishInput) => Effect.Effect<PublishResult, TopicServiceError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<TopicRepository.Subscription>, TopicServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/TopicService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/topic/topic-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | ExecutionRepository.Service | TopicRepository.Service | InboxServiceService>;

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

@@ -66,7 +66,7 @@ export interface Interface {
     readonly timeout: (input: TimeoutInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
     readonly cancel: (input: CancelWaitInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WaitService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/wait/wait-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | ScheduleRepository.Service | EventLogService>;

package/dist/types/runtime/wait/wait-signal.d.ts

@@ -1,9 +1,17 @@
 import { Ids } from "../../schema/index";
 import { ExecutionRepository } from "@relayfx/store-sql/portable";
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
+import { ExecutionWorkflowFailed } from "../workflow/execution-workflow";
 import type { SignalWaitInput, WaitSignalState } from "../workflow/execution-workflow";
 export interface ExecutionSignalClient {
-    readonly signalWait: (input: SignalWaitInput) => Effect.Effect<void, unknown>;
+    readonly signalWait: (input: SignalWaitInput) => Effect.Effect<void, {
+        readonly _tag: string;
+    }>;
+}
+declare const WaitSignalError_base: Schema.Class<WaitSignalError, Schema.TaggedStruct<"WaitSignalError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WaitSignalError extends WaitSignalError_base {
 }
 export type ExecutionClientFactory = (executionId: Ids.ExecutionId) => ExecutionSignalClient;
 export interface SignalWorkflowWaitInput {
@@ -13,4 +21,5 @@ export interface SignalWorkflowWaitInput {
     readonly state: WaitSignalState;
     readonly signaledAt: number;
 }
-export declare const signalWorkflowWait: (input: SignalWorkflowWaitInput) => Effect.Effect<void, unknown, ExecutionRepository.Service>;
+export declare const signalWorkflowWait: (input: SignalWorkflowWaitInput) => Effect.Effect<void, WaitSignalError | ExecutionWorkflowFailed, ExecutionRepository.Service>;
+export {};

package/dist/types/runtime/workflow/activity-version-registry.d.ts

@@ -72,9 +72,13 @@ export declare const currentManifest: () => Effect.Effect<{
         signature_hash: string;
     }[];
 }, import("effect/PlatformError").PlatformError, Crypto.Crypto>;
-export declare const diffManifests: (baseline: ActivityManifest, current: ActivityManifest) => {
-    breaking: ActivityManifestChange[];
-    additive: ActivityManifestChange[];
+export declare function diffManifests(baseline: ActivityManifest, current: ActivityManifest): {
+    breaking: Array<ActivityManifestChange>;
+    additive: Array<ActivityManifestChange>;
+};
+export declare function diffManifests(current: ActivityManifest): (baseline: ActivityManifest) => {
+    breaking: Array<ActivityManifestChange>;
+    additive: Array<ActivityManifestChange>;
 };
 export declare const evaluateGuard: (input: {
     readonly baseline: ActivityManifest;

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

@@ -1,6 +1,7 @@
 import { ChildOrchestration, Ids, Shared, Workflow } from "../../schema/index";
 import { WorkflowDefinitionRepository } from "@relayfx/store-sql/portable";
 import { Cause, Context, Effect, Layer, Schema } from "effect";
+import { SqlError } from "effect/unstable/sql/SqlError";
 export interface SideEffectContext {
     readonly execution_id: Ids.ExecutionId;
     readonly operation_id: Ids.WorkflowOperationId;
@@ -28,32 +29,45 @@ declare const PinnedDefinitionMismatch_base: Schema.Class<PinnedDefinitionMismat
 }>, Cause.YieldableError>;
 export declare class PinnedDefinitionMismatch extends PinnedDefinitionMismatch_base {
 }
+declare const WorkflowRuntimeError_base: Schema.Class<WorkflowRuntimeError, Schema.TaggedStruct<"WorkflowRuntimeError", {
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class WorkflowRuntimeError extends WorkflowRuntimeError_base {
+}
+declare const WorkflowJoinPolicyNotSatisfied_base: Schema.Class<WorkflowJoinPolicyNotSatisfied, Schema.TaggedStruct<"WorkflowJoinPolicyNotSatisfied", {
+    readonly policy: Schema.String;
+}>, Cause.YieldableError>;
+export declare class WorkflowJoinPolicyNotSatisfied extends WorkflowJoinPolicyNotSatisfied_base {
+}
 export interface Handlers {
-    readonly tool?: (executionId: Ids.ExecutionId, operation: typeof Workflow.ToolOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, unknown>;
-    readonly child: (executionId: Ids.ExecutionId, operation: typeof Workflow.ChildOperation.Type | typeof Workflow.DispatchableChildOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, unknown>;
-    readonly approval: (executionId: Ids.ExecutionId, operation: typeof Workflow.ApprovalOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, unknown>;
-    readonly timer: (executionId: Ids.ExecutionId, operation: typeof Workflow.TimerOperation.Type, context: SideEffectContext) => Effect.Effect<void, unknown>;
-    readonly branch: (executionId: Ids.ExecutionId, operation: typeof Workflow.BranchOperation.Type, context: SideEffectContext) => Effect.Effect<boolean, unknown>;
-    readonly structuredCompletion: (schemaRef: string, value: Shared.JsonValue | undefined, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, unknown>;
-    readonly createChildFanOut?: (definition: ChildOrchestration.FanOutDefinition, context: SideEffectContext) => Effect.Effect<ChildOrchestration.FanOutState, unknown>;
-    readonly admitChildFanOut?: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<void, unknown>;
-    readonly inspectChildFanOut?: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<ChildOrchestration.FanOutState | undefined, unknown>;
+    readonly tool?: (executionId: Ids.ExecutionId, operation: typeof Workflow.ToolOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
+    readonly child: (executionId: Ids.ExecutionId, operation: typeof Workflow.ChildOperation.Type | typeof Workflow.DispatchableChildOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
+    readonly approval: (executionId: Ids.ExecutionId, operation: typeof Workflow.ApprovalOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
+    readonly timer: (executionId: Ids.ExecutionId, operation: typeof Workflow.TimerOperation.Type, context: SideEffectContext) => Effect.Effect<void, WorkflowRuntimeError>;
+    readonly branch: (executionId: Ids.ExecutionId, operation: typeof Workflow.BranchOperation.Type, context: SideEffectContext) => Effect.Effect<boolean, WorkflowRuntimeError>;
+    readonly structuredCompletion: (schemaRef: string, value: Shared.JsonValue | undefined, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
+    readonly createChildFanOut?: (definition: ChildOrchestration.FanOutDefinition, context: SideEffectContext) => Effect.Effect<ChildOrchestration.FanOutState, WorkflowRuntimeError>;
+    readonly admitChildFanOut?: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<void, WorkflowRuntimeError>;
+    readonly inspectChildFanOut?: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<ChildOrchestration.FanOutState | undefined, WorkflowRuntimeError>;
 }
-declare const HandlerService_base: Context.ServiceClass<HandlerService, "@relayfx/runtime/WorkflowDefinitionHandlers", Handlers>;
+declare const HandlerService_base: Context.ServiceClass<HandlerService, "@relayfx/runtime/workflow/definition-runtime/HandlerService", Handlers>;
 export declare class HandlerService extends HandlerService_base {
 }
 export interface Interface {
-    readonly start: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, unknown>;
-    readonly run: (executionId: Ids.ExecutionId) => Effect.Effect<Shared.JsonValue | undefined, unknown>;
-    readonly recover: () => Effect.Effect<ReadonlyArray<Ids.ExecutionId>, unknown>;
-    readonly inspect: (executionId: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, unknown>;
-    readonly replay: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.LifecycleEvent>, unknown>;
-    readonly cancel: (executionId: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, unknown>;
+    readonly start: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, WorkflowDefinitionRepository.RepositoryError | SqlError>;
+    readonly run: (executionId: Ids.ExecutionId) => Effect.Effect<Shared.JsonValue | undefined, WorkflowExecutionError>;
+    readonly recover: Effect.Effect<ReadonlyArray<Ids.ExecutionId>, WorkflowRuntimeError>;
+    readonly inspect: (executionId: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, WorkflowDefinitionRepository.RepositoryError | SqlError>;
+    readonly replay: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.LifecycleEvent>, WorkflowDefinitionRepository.RepositoryError | SqlError>;
+    readonly cancel: (executionId: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, WorkflowDefinitionRepository.RepositoryError | SqlError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkflowDefinitionRuntime", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workflow/definition-runtime/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const fanOutIdFor: (executionId: Ids.ExecutionId, fanOutKey: string) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
+export declare const fanOutIdFor: {
+    (fanOutKey: string): (executionId: Ids.ExecutionId) => Ids.ChildFanOutId;
+    (executionId: Ids.ExecutionId, fanOutKey: string): Ids.ChildFanOutId;
+};
 declare const WorkflowCancelled_base: Schema.Class<WorkflowCancelled, Schema.TaggedStruct<"WorkflowCancelled", {}>, Cause.YieldableError>;
 export declare class WorkflowCancelled extends WorkflowCancelled_base {
 }
@@ -71,10 +85,11 @@ declare const WorkflowJoining_base: Schema.Class<WorkflowJoining, Schema.TaggedS
 }>, Cause.YieldableError>;
 export declare class WorkflowJoining extends WorkflowJoining_base {
 }
+type WorkflowExecutionError = WorkflowDefinitionRepository.RepositoryError | SqlError | WorkflowRuntimeError | UnsupportedOperation | PinnedDefinitionNotFound | PinnedDefinitionMismatch | WorkflowCancelled | WorkflowBudgetExceeded | WorkflowJoining | WorkflowJoinPolicyNotSatisfied;
 export declare const validate: (definition: Workflow.Definition) => Effect.Effect<void, never, never> | Effect.Effect<never, UnsupportedOperation, never>;
-export declare const run: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Schema.Json | undefined, unknown, WorkflowDefinitionRepository.Service | HandlerService>;
+export declare const run: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Schema.Json | undefined, PinnedDefinitionMismatch | PinnedDefinitionNotFound | WorkflowDefinitionRepository.RepositoryError | SqlError | UnsupportedOperation | WorkflowBudgetExceeded | WorkflowCancelled | WorkflowJoinPolicyNotSatisfied | WorkflowJoining | WorkflowRuntimeError, HandlerService | WorkflowDefinitionRepository.Service>;
 export declare const handlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
-export declare const testHandlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
-export declare const layerFromRuntime: Layer.Layer<Service, unknown, WorkflowDefinitionRepository.Service | HandlerService>;
-export declare const layer: Layer.Layer<Service, unknown, WorkflowDefinitionRepository.Service | HandlerService>;
+export declare const testHandlersLayer: typeof handlersLayer;
+export declare const layerFromRuntime: Layer.Layer<Service, WorkflowRuntimeError, HandlerService | WorkflowDefinitionRepository.Service>;
+export declare const layer: Layer.Layer<Service, WorkflowRuntimeError, HandlerService | WorkflowDefinitionRepository.Service>;
 export {};