@relayfx/sdk 0.3.6 → 0.4.0

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

@@ -105,6 +105,8 @@ export interface RunInput {
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly createdAt: number;
     readonly extraTools?: ReadonlyArray<RegisteredTool>;
+    readonly onRequested?: Effect.Effect<void>;
+    readonly beforeSettlement?: Effect.Effect<Execution.ExecutionEventSequence>;
     readonly transformResult?: (result: Tool.Result) => Effect.Effect<Tool.Result, ToolRuntimeError>;
 }
 export type RunError = ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError;
@@ -112,10 +114,11 @@ export interface Interface {
     readonly register: (tool: RegisteredTool) => Effect.Effect<void>;
     readonly definitions: Effect.Effect<ReadonlyArray<Tool.Definition>>;
     readonly registeredTools: Effect.Effect<ReadonlyArray<RegisteredTool>>;
+    readonly prepare: (input: RunInput) => Effect.Effect<void, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolRuntimeError>;
     readonly run: (input: RunInput) => Effect.Effect<Tool.Result, RunError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/tool/tool-runtime-contract/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+export declare const testLayer: (implementation: Omit<Interface, "prepare"> & Partial<Pick<Interface, "prepare">>) => Layer.Layer<Service>;
 export {};

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

@@ -0,0 +1,43 @@
+import { AgentEvent } from "@batonfx/core";
+import { Content, Execution, Ids, Shared } from "../../schema/index";
+import { EnvelopeRepository, ExecutionRepository } from "../../store-sql/portable";
+import { Schema } from "effect";
+import type { StartInput, WaitSignalState, WaitSnapshot } from "./execution-workflow";
+declare const toWaitSnapshot: (record: EnvelopeRepository.WaitRecord) => WaitSnapshot;
+declare const terminalWaitState: (wait: WaitSnapshot) => WaitSignalState | undefined;
+declare const agentDefinitionPinCount: (input: StartInput) => number;
+declare const waitIdFromRecord: (record: ExecutionRepository.ExecutionRecord) => (string & import("effect/Brand").Brand<"Relay.WaitId">) | undefined;
+declare const workflowGenerationForStart: (input: StartInput) => number;
+declare const workflowGenerationFromRecord: (record: ExecutionRepository.ExecutionRecord) => number;
+declare const generationMetadata: (generation: number) => Shared.Metadata;
+declare const memorySubjectFromMetadata: (metadata: Shared.Metadata | undefined) => Schema.Json | undefined;
+declare const metadataSetting: (input: StartInput, key: string) => Shared.JsonValue | undefined;
+declare const steeringEnabledForStart: (input: StartInput) => boolean;
+export interface ChildDispatchContext {
+    readonly parentExecutionId: Ids.ExecutionId;
+    readonly childExecutionId: Ids.ChildExecutionId;
+    readonly parentWaitId?: Ids.WaitId;
+}
+declare const childDispatchContext: (input: StartInput) => ChildDispatchContext | undefined;
+declare const terminalOutput: (execution: Execution.Execution) => ReadonlyArray<Content.Part>;
+declare const waitIdFromExecution: (execution: Execution.Execution) => (string & import("effect/Brand").Brand<"Relay.WaitId">) | undefined;
+declare const pendingSuspensionFromExecution: (execution: Execution.Execution) => AgentEvent.AgentSuspended | undefined;
+export declare const ExecutionWorkflowState: {
+    agentDefinitionPinCount: typeof agentDefinitionPinCount;
+    childDispatchContext: typeof childDispatchContext;
+    continueAsNewAfterTurnsMetadataKey: string;
+    generationMetadata: typeof generationMetadata;
+    memorySubjectFromMetadata: typeof memorySubjectFromMetadata;
+    metadataSetting: typeof metadataSetting;
+    pendingSuspensionFromExecution: typeof pendingSuspensionFromExecution;
+    steeringEnabledForStart: typeof steeringEnabledForStart;
+    terminalOutput: typeof terminalOutput;
+    terminalWaitState: typeof terminalWaitState;
+    toolOutputMaxBytesMetadataKey: string;
+    toWaitSnapshot: typeof toWaitSnapshot;
+    waitIdFromExecution: typeof waitIdFromExecution;
+    waitIdFromRecord: typeof waitIdFromRecord;
+    workflowGenerationForStart: typeof workflowGenerationForStart;
+    workflowGenerationFromRecord: typeof workflowGenerationFromRecord;
+};
+export {};

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

@@ -120,6 +120,9 @@ export declare const StartInput: Schema.Struct<{
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;
@@ -405,6 +408,9 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;

package/dist/types/schema/agent-schema.d.ts

@@ -143,6 +143,9 @@ declare const DefinitionSchema: Schema.Struct<{
         readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
     }>>;
     readonly turn_policy: Schema.optionalKey<Schema.Codec<TurnPolicySnapshot, TurnPolicySnapshot, never, never>>;
+    readonly tool_execution: Schema.optionalKey<Schema.Struct<{
+        readonly concurrency: Schema.Finite;
+    }>>;
     readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
         readonly context_window: Schema.Finite;
         readonly reserve_tokens: Schema.Finite;
@@ -213,6 +216,9 @@ export interface DefineInput {
     readonly skill_definition_ids?: ReadonlyArray<SkillDefinitionId>;
     readonly permission_rules?: PermissionRuleset;
     readonly turn_policy?: TurnPolicySnapshot;
+    readonly tool_execution?: {
+        readonly concurrency: number;
+    };
     readonly compaction_policy?: CompactionPolicy;
     readonly max_tool_turns?: number;
     readonly max_wait_turns?: number;
@@ -260,6 +266,9 @@ export declare const DefinitionRecord: Schema.Struct<{
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;
@@ -373,6 +382,9 @@ export declare const DefinitionRevisionRecord: Schema.Struct<{
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;
@@ -484,6 +496,9 @@ export declare const RegisterDefinitionPayload: Schema.Struct<{
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;
@@ -595,6 +610,9 @@ export declare const DefinitionRegistered: Schema.Struct<{
                 readonly fallback?: "allow" | "ask" | "deny";
             };
             readonly turn_policy?: TurnPolicySnapshot;
+            readonly tool_execution?: Schema.Struct.ReadonlySide<{
+                readonly concurrency: Schema.Finite;
+            }, "Encoded">;
             readonly compaction_policy?: {
                 readonly context_window: number;
                 readonly reserve_tokens: number;
@@ -710,6 +728,9 @@ export declare const DefinitionList: Schema.Struct<{
                 readonly fallback?: "allow" | "ask" | "deny";
             };
             readonly turn_policy?: TurnPolicySnapshot;
+            readonly tool_execution?: Schema.Struct.ReadonlySide<{
+                readonly concurrency: Schema.Finite;
+            }, "Encoded">;
             readonly compaction_policy?: {
                 readonly context_window: number;
                 readonly reserve_tokens: number;
@@ -825,6 +846,9 @@ export declare const DefinitionRevisionList: Schema.Struct<{
                 readonly fallback?: "allow" | "ask" | "deny";
             };
             readonly turn_policy?: TurnPolicySnapshot;
+            readonly tool_execution?: Schema.Struct.ReadonlySide<{
+                readonly concurrency: Schema.Finite;
+            }, "Encoded">;
             readonly compaction_policy?: {
                 readonly context_window: number;
                 readonly reserve_tokens: number;

package/dist/types/schema/execution-schema.d.ts

@@ -50,6 +50,9 @@ export declare const Execution: Schema.Struct<{
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: import("./agent-schema").TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;
@@ -382,7 +385,7 @@ export declare const ChildRunAccepted: Schema.Struct<{
 export interface ChildRunAccepted extends Schema.Schema.Type<typeof ChildRunAccepted> {
 }
 export declare const childSessionId: (childExecutionId: ChildExecutionId) => string & import("effect/Brand").Brand<"Relay.SessionId">;
-export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
 export type ExecutionEventType = typeof ExecutionEventType.Type;
 export declare const CompactionCommittedEventData: Schema.Struct<{
     readonly checkpoint_id: Schema.brand<Schema.String, "Relay.SessionEntryId"> & {
@@ -405,7 +408,7 @@ export declare const ExecutionEvent: Schema.Struct<{
     readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
     }>;
-    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
     readonly sequence: Schema.Int;
     readonly cursor: Schema.String;
     readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{

package/dist/types/schema/ids-schema.d.ts

@@ -24,14 +24,14 @@ export declare const WorkflowOperationId: Schema.brand<Schema.String, "Relay.Wor
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
 };
 export type WorkflowOperationId = typeof WorkflowOperationId.Type;
-export declare const EntityKindName: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+export declare const ResidentKindName: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
 };
-export type EntityKindName = typeof EntityKindName.Type;
-export declare const EntityKey: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+export type ResidentKindName = typeof ResidentKindName.Type;
+export declare const ResidentKey: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
 };
-export type EntityKey = typeof EntityKey.Type;
+export type ResidentKey = typeof ResidentKey.Type;
 export declare const SkillDefinitionId: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
 };

package/dist/types/schema/index.d.ts

@@ -3,7 +3,7 @@ export * as Agent from "./agent-schema";
 export * as ChildOrchestration from "./child-orchestration-schema";
 export * as Content from "./content-schema";
 export * as Envelope from "./envelope-schema";
-export * as Entity from "./entity-schema";
+export * as Resident from "./resident-schema";
 export * as Execution from "./execution-schema";
 export * as Ids from "./ids-schema";
 export * as Inbox from "./inbox-schema";

package/dist/types/schema/{entity-schema.d.ts → resident-schema.d.ts}

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 export declare const KindDefinition: Schema.Struct<{
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     };
     readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
@@ -19,11 +19,11 @@ export interface KindDefinition extends Schema.Schema.Type<typeof KindDefinition
 export declare const InstanceStatus: Schema.Literals<readonly ["active", "destroyed"]>;
 export type InstanceStatus = typeof InstanceStatus.Type;
 export declare const Instance: Schema.Struct<{
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
     };
     readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;

package/dist/types/store-sql/envelope/envelope-ready-records.d.ts

@@ -0,0 +1,51 @@
+import { Ids } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { AckReadyInput, ClaimReadyInput, EnvelopeReadyClaimMismatch, EnvelopeReadyNotFound, EnvelopeReadyRecord, EnvelopeRepositoryError, ReleaseReadyInput } from "./envelope-repository";
+export declare const envelopeReadyRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly envelope_id: Schema.String;
+    readonly route_type: Schema.String;
+    readonly route_key: Schema.String;
+    readonly state: Schema.String;
+    readonly available_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly attempt: Schema.Finite;
+    readonly claim_owner: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly claim_expires_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite, Schema.Null]>;
+    readonly last_error: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly idempotency_key: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly claimed_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite, Schema.Null]>;
+    readonly acknowledged_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite, Schema.Null]>;
+}>;
+interface EnvelopeReadyRecordErrors {
+    readonly EnvelopeRepositoryError: {
+        readonly make: (input: {
+            readonly message: string;
+        }) => EnvelopeRepositoryError;
+    };
+    readonly EnvelopeReadyNotFound: {
+        readonly make: (input: {
+            readonly id: Ids.EnvelopeReadyId;
+        }) => EnvelopeReadyNotFound;
+    };
+    readonly EnvelopeReadyClaimMismatch: {
+        readonly make: (input: {
+            readonly id: Ids.EnvelopeReadyId;
+            readonly worker_id: string;
+        }) => EnvelopeReadyClaimMismatch;
+    };
+}
+interface MakeEnvelopeReadyRecordOperationsInput {
+    readonly sql: SqlClient;
+    readonly ts: (millis: number) => Date | number;
+    readonly errors: EnvelopeReadyRecordErrors;
+}
+export declare const makeEnvelopeReadyRecordOperations: ({ sql, ts, errors }: MakeEnvelopeReadyRecordOperationsInput) => {
+    claimReady: (input: ClaimReadyInput) => Effect.Effect<EnvelopeReadyRecord | undefined, EnvelopeRepositoryError, never>;
+    releaseReady: (input: ReleaseReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyClaimMismatch | EnvelopeReadyNotFound | EnvelopeRepositoryError, never>;
+    ackReady: (input: AckReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyClaimMismatch | EnvelopeReadyNotFound | EnvelopeRepositoryError, never>;
+};
+export {};

package/dist/types/store-sql/envelope/envelope-records.d.ts

@@ -0,0 +1,43 @@
+import { Envelope, Ids } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { envelopeReadyRow } from "./envelope-ready-records";
+import type { AcceptEnvelopeInput, EnvelopeReadyClaimMismatch, EnvelopeReadyNotFound, EnvelopeRepositoryError, Interface, WaitNotFound } from "./envelope-repository";
+import { waitRow } from "./wait-records";
+export declare const envelopeRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly from_address_id: Schema.String;
+    readonly to_address_id: Schema.String;
+    readonly content_json: Schema.Unknown;
+    readonly wait_json: Schema.Unknown;
+    readonly correlation_key: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+}>;
+export declare const accepted: (input: AcceptEnvelopeInput) => Envelope.EnvelopeAccepted;
+interface EnvelopeRecordErrors {
+    readonly EnvelopeRepositoryError: {
+        readonly make: (input: {
+            readonly message: string;
+        }) => EnvelopeRepositoryError;
+    };
+    readonly EnvelopeReadyNotFound: {
+        readonly make: (input: {
+            readonly id: Ids.EnvelopeReadyId;
+        }) => EnvelopeReadyNotFound;
+    };
+    readonly EnvelopeReadyClaimMismatch: {
+        readonly make: (input: {
+            readonly id: Ids.EnvelopeReadyId;
+            readonly worker_id: string;
+        }) => EnvelopeReadyClaimMismatch;
+    };
+    readonly WaitNotFound: {
+        readonly make: (input: {
+            readonly id: Ids.WaitId;
+        }) => WaitNotFound;
+    };
+}
+export declare const makeEnvelopeRepository: (errors: EnvelopeRecordErrors) => Effect.Effect<Interface, never, SqlClient>;
+export { envelopeReadyRow, waitRow };

package/dist/types/store-sql/envelope/envelope-repository.d.ts

@@ -1,6 +1,5 @@
 import { Address, Envelope, Ids, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
 export declare const WaitState: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
 export type WaitState = typeof WaitState.Type;
 export declare const EnvelopeReadyState: Schema.Literals<readonly ["ready", "claimed", "acknowledged"]>;
@@ -188,7 +187,7 @@ export declare const EnvelopeReadyRow: Schema.Struct<{
     readonly claimed_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite, Schema.Null]>;
     readonly acknowledged_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite, Schema.Null]>;
 }>;
-export declare const layer: Layer.Layer<Service, never, SqlClient>;
+export declare const layer: Layer.Layer<Service, never, import("effect/unstable/sql/SqlClient").SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const acceptEnvelope: (input: AcceptEnvelopeInput) => Effect.Effect<Envelope.EnvelopeAccepted, EnvelopeRepositoryError, Service>;

package/dist/types/store-sql/envelope/wait-records.d.ts

@@ -0,0 +1,64 @@
+import { Ids, Shared } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { CompleteWaitInput, CreateWaitInput, EnvelopeRepositoryError, ListAllWaitsInput, ListWaitsInput, ResolveWaitInput, WaitNotFound, WaitRecord } from "./envelope-repository";
+export declare const waitRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly envelope_id: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly mode: Schema.String;
+    readonly correlation_key: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly state: Schema.String;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly resolved_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite, Schema.Null]>;
+}>;
+export declare const metadata: (input: Shared.Metadata | undefined) => {
+    readonly [x: string]: Schema.Json;
+};
+export declare const listWaitsLimit: (input: ListWaitsInput) => number;
+declare const compareWaitsDesc: (left: WaitRecord, right: WaitRecord) => number;
+export declare const waitRecordOrdering: {
+    compareWaitsDesc: typeof compareWaitsDesc;
+};
+interface WaitRecordErrors {
+    readonly EnvelopeRepositoryError: {
+        readonly make: (input: {
+            readonly message: string;
+        }) => EnvelopeRepositoryError;
+    };
+    readonly WaitNotFound: {
+        readonly make: (input: {
+            readonly id: Ids.WaitId;
+        }) => WaitNotFound;
+    };
+}
+interface MakeWaitRecordOperationsInput {
+    readonly sql: SqlClient;
+    readonly ts: (millis: number) => Date | number;
+    readonly errors: WaitRecordErrors;
+}
+export declare const makeWaitRecordOperations: ({ sql, ts, errors }: MakeWaitRecordOperationsInput) => {
+    getWaitRow: (tenantId: Ids.TenantId, id: Ids.WaitId) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly id: Schema.String;
+        readonly execution_id: Schema.String;
+        readonly envelope_id: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly mode: Schema.String;
+        readonly correlation_key: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly state: Schema.String;
+        readonly metadata_json: Schema.Unknown;
+        readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+        readonly resolved_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite, Schema.Null]>;
+    }, "Type"> | undefined, EnvelopeRepositoryError, never>;
+    getWait: (id: string & import("effect/Brand").Brand<"Relay.WaitId">) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError, never>;
+    createWait: (input: CreateWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError, never>;
+    listWaits: (input: ListWaitsInput) => Effect.Effect<WaitRecord[], EnvelopeRepositoryError, never>;
+    findOpenByCorrelation: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, correlationKey: string) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError, never>;
+    listAllWaits: (input: ListAllWaitsInput) => Effect.Effect<WaitRecord[], EnvelopeRepositoryError, never>;
+    completeWait: (input: CompleteWaitInput) => Effect.Effect<{
+        wait: WaitRecord;
+        transitioned: boolean;
+    }, EnvelopeRepositoryError | WaitNotFound, never>;
+    resolveWait: (input: ResolveWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError | WaitNotFound, never>;
+};
+export {};

package/dist/types/store-sql/execution/execution-event-repository-memory.d.ts

@@ -0,0 +1,8 @@
+import { Layer } from "effect";
+import type { DuplicateExecutionEvent, ExecutionEventCursorNotFound, ExecutionEventOrderViolation, Service } from "./execution-event-repository";
+export declare const makeMemoryLayer: (repository: {
+    readonly DuplicateExecutionEvent: typeof DuplicateExecutionEvent;
+    readonly ExecutionEventOrderViolation: typeof ExecutionEventOrderViolation;
+    readonly ExecutionEventCursorNotFound: typeof ExecutionEventCursorNotFound;
+    readonly Service: typeof Service;
+}) => Layer.Layer<Service, never, never>;

package/dist/types/store-sql/execution/execution-event-repository-sql.d.ts

@@ -0,0 +1,13 @@
+import { Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Service as NotificationBusService } from "../database/notification-bus";
+import type { DuplicateExecutionEvent, ExecutionEventCursorNotFound, ExecutionEventOrderViolation, ExecutionEventRepositoryError, ExecutionEventRow, Service, executionEventsChannel } from "./execution-event-repository";
+export declare const makeLayer: (repository: {
+    readonly DuplicateExecutionEvent: typeof DuplicateExecutionEvent;
+    readonly ExecutionEventOrderViolation: typeof ExecutionEventOrderViolation;
+    readonly ExecutionEventCursorNotFound: typeof ExecutionEventCursorNotFound;
+    readonly ExecutionEventRepositoryError: typeof ExecutionEventRepositoryError;
+    readonly ExecutionEventRow: typeof ExecutionEventRow;
+    readonly Service: typeof Service;
+    readonly executionEventsChannel: typeof executionEventsChannel;
+}) => Layer.Layer<Service, never, NotificationBusService | SqlClient>;

package/dist/types/store-sql/execution/execution-event-repository.d.ts

@@ -1,7 +1,6 @@
 import { Execution, Ids } from "../../schema/index";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { Service as NotificationBusService, type Transport } from "../database/notification-bus";
+import { type Transport } from "../database/notification-bus";
 export declare const executionEventsChannel = "relay_execution_events";
 declare const DuplicateExecutionEvent_base: Schema.Class<DuplicateExecutionEvent, Schema.TaggedStruct<"DuplicateExecutionEvent", {
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
@@ -39,6 +38,13 @@ export interface ListInput {
     readonly afterCursor?: string;
     readonly limit?: number;
 }
+export interface AppendNextInput extends Omit<Execution.ExecutionEvent, "sequence"> {
+    readonly minimumSequence?: Execution.ExecutionEventSequence;
+}
+export interface AppendNextResult {
+    readonly event: Execution.ExecutionEvent;
+    readonly inserted: boolean;
+}
 export interface FindBySequenceOrCursorInput {
     readonly executionId: Ids.ExecutionId;
     readonly sequence: Execution.ExecutionEventSequence;
@@ -84,6 +90,7 @@ export interface PageResult {
 export interface Interface {
     readonly signalTransport: Transport;
     readonly append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | ExecutionEventRepositoryError>;
+    readonly appendNext: (input: AppendNextInput) => Effect.Effect<AppendNextResult, DuplicateExecutionEvent | ExecutionEventRepositoryError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<Execution.ExecutionEvent>, ExecutionEventCursorNotFound | ExecutionEventRepositoryError>;
     readonly findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
     readonly findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
@@ -110,12 +117,13 @@ export declare const ExecutionEventRow: Schema.Struct<{
     readonly data_json: Schema.Unknown;
     readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
-export declare const layer: Layer.Layer<Service, never, NotificationBusService | SqlClient>;
-export declare const layerWithBus: Layer.Layer<Service, never, SqlClient>;
+export declare const layer: Layer.Layer<Service, never, import("../database/notification-bus").Service | import("effect/unstable/sql/SqlClient").SqlClient>;
+export declare const layerWithBus: Layer.Layer<Service, never, import("effect/unstable/sql/SqlClient").SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
-type TestImplementation = Omit<Interface, "page"> & Partial<Pick<Interface, "page">>;
+export type TestImplementation = Omit<Interface, "appendNext" | "page"> & Partial<Pick<Interface, "appendNext" | "page">>;
 export declare const testLayer: (implementation: TestImplementation) => Layer.Layer<Service, never, never>;
 export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | ExecutionEventRepositoryError, Service>;
+export declare const appendNext: (input: AppendNextInput) => Effect.Effect<AppendNextResult, DuplicateExecutionEvent | ExecutionEventRepositoryError, Service>;
 export declare const list: (input: ListInput) => Effect.Effect<readonly Execution.ExecutionEvent[], ExecutionEventCursorNotFound | ExecutionEventRepositoryError, Service>;
 export declare const page: (input: PageInput) => Effect.Effect<PageResult, ExecutionEventCursorNotFound | ExecutionEventRepositoryError, Service>;
 export declare const findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;

package/dist/types/store-sql/index.d.ts

@@ -8,7 +8,7 @@ export * as CompactionRepository from "./compaction/compaction-repository";
 export * as Database from "./database/database-service";
 export * as SqlDialect from "./database/sql-dialect";
 export * as EnvelopeRepository from "./envelope/envelope-repository";
-export * as EntityRepository from "./entity/entity-repository";
+export * as ResidentRepository from "./resident/resident-repository";
 export * as ExecutionEventRepository from "./execution/execution-event-repository";
 export * as ExecutionRepository from "./execution/execution-repository";
 export * as ExecutionStateRepository from "./state/execution-state-repository";

package/dist/types/store-sql/portable.d.ts

@@ -7,7 +7,7 @@ export * as ClusterRegistryRepository from "./cluster/cluster-registry-repositor
 export * as CompactionRepository from "./compaction/compaction-repository";
 export * as ContextEpochRepository from "./session/context-epoch-repository";
 export * as EnvelopeRepository from "./envelope/envelope-repository";
-export * as EntityRepository from "./entity/entity-repository";
+export * as ResidentRepository from "./resident/resident-repository";
 export * as ExecutionEventRepository from "./execution/execution-event-repository";
 export * as ExecutionRepository from "./execution/execution-repository";
 export * as ExecutionStateRepository from "./state/execution-state-repository";

package/dist/types/store-sql/resident/resident-repository.d.ts

@@ -0,0 +1,36 @@
+import { Ids, Resident } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+declare const ResidentRepositoryError_base: Schema.Class<ResidentRepositoryError, Schema.TaggedStruct<"ResidentRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentRepositoryError extends ResidentRepositoryError_base {
+}
+export interface CreateInstanceInput {
+    readonly kind: Ids.ResidentKindName;
+    readonly key: Ids.ResidentKey;
+    readonly addressId: Ids.AddressId;
+    readonly executionId: (generation: number) => Ids.ExecutionId;
+    readonly createdAt: number;
+}
+export interface Interface {
+    readonly putKind: (definition: Resident.KindDefinition) => Effect.Effect<Resident.KindDefinition, ResidentRepositoryError>;
+    readonly getKind: (kind: Ids.ResidentKindName) => Effect.Effect<Resident.KindDefinition | undefined, ResidentRepositoryError>;
+    readonly listKinds: (_?: never) => Effect.Effect<ReadonlyArray<Resident.KindDefinition>, ResidentRepositoryError>;
+    readonly spawn: (input: CreateInstanceInput) => Effect.Effect<Resident.Instance, ResidentRepositoryError>;
+    readonly get: (kind: Ids.ResidentKindName, key: Ids.ResidentKey) => Effect.Effect<Resident.Instance | undefined, ResidentRepositoryError>;
+    readonly destroy: (kind: Ids.ResidentKindName, key: Ids.ResidentKey, destroyedAt: number) => Effect.Effect<Resident.Instance | undefined, ResidentRepositoryError>;
+    readonly list: (input: {
+        readonly kind?: Ids.ResidentKindName;
+        readonly afterKind?: Ids.ResidentKindName;
+        readonly afterKey?: string;
+        readonly limit?: number;
+    }) => Effect.Effect<ReadonlyArray<Resident.Instance>, ResidentRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/resident/resident-repository/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, SqlClient>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};