@relayfx/sdk 0.2.15 → 0.3.0

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

@@ -11,7 +11,7 @@ export declare const WorkspaceCapabilities: Schema.Struct<{
     readonly can_fork: Schema.Boolean;
     readonly persistent_by_default: Schema.Boolean;
     readonly suspend_granularity: Schema.Literals<readonly ["memory", "filesystem", "none"]>;
-    readonly max_suspend_duration_ms: Schema.optionalKey<Schema.Number>;
+    readonly max_suspend_duration_ms: Schema.optionalKey<Schema.Finite>;
     readonly reattach_by_ref: Schema.Boolean;
 }>;
 export interface WorkspaceCapabilities extends Schema.Schema.Type<typeof WorkspaceCapabilities> {

package/dist/types/store-sql/address/address-book-repository.d.ts

@@ -34,9 +34,9 @@ export interface UpsertAddressBookEntryInput {
 export interface Interface {
     readonly upsert: (input: UpsertAddressBookEntryInput) => Effect.Effect<AddressBookEntry, AddressBookRepositoryError>;
     readonly resolve: (addressId: Ids.AddressId) => Effect.Effect<AddressBookEntry, AddressNotFound | AddressBookRepositoryError>;
-    readonly list: () => Effect.Effect<ReadonlyArray<AddressBookEntry>, AddressBookRepositoryError>;
+    readonly list: (_?: never) => Effect.Effect<ReadonlyArray<AddressBookEntry>, AddressBookRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AddressBookRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/address/address-book-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const AddressBookRow: Schema.Struct<{
@@ -45,13 +45,13 @@ export declare const AddressBookRow: Schema.Struct<{
     readonly route_kind: Schema.String;
     readonly route_key: Schema.String;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 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 declare const upsert: (input: UpsertAddressBookEntryInput) => Effect.Effect<AddressBookEntry, AddressBookRepositoryError, Service>;
-export declare const resolve: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<AddressBookEntry, AddressNotFound | AddressBookRepositoryError, Service>;
+export declare const resolve: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<AddressBookEntry, AddressBookRepositoryError | AddressNotFound, Service>;
 export declare const list: () => Effect.Effect<readonly AddressBookEntry[], AddressBookRepositoryError, Service>;
 export {};

package/dist/types/store-sql/agent/agent-definition-repository.d.ts

@@ -35,26 +35,26 @@ export interface Interface {
     readonly put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError>;
     readonly get: (id: Ids.AgentId) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError>;
     readonly getRevision: (input: GetAgentDefinitionRevisionInput) => Effect.Effect<AgentDefinitionRevisionRecord | undefined, AgentDefinitionRepositoryError>;
-    readonly list: () => Effect.Effect<ReadonlyArray<AgentDefinitionRecord>, AgentDefinitionRepositoryError>;
+    readonly list: (_?: never) => Effect.Effect<ReadonlyArray<AgentDefinitionRecord>, AgentDefinitionRepositoryError>;
     readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<ReadonlyArray<AgentDefinitionRevisionRecord>, AgentDefinitionRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AgentDefinitionRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/agent/agent-definition-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const AgentDefinitionRow: Schema.Struct<{
     readonly id: Schema.String;
-    readonly current_revision: Schema.Number;
+    readonly current_revision: Schema.Finite;
     readonly definition_json: Schema.Unknown;
     readonly tool_input_schema_digests_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const AgentDefinitionRevisionRow: Schema.Struct<{
     readonly agent_id: Schema.String;
-    readonly revision: Schema.Number;
+    readonly revision: Schema.Finite;
     readonly definition_json: Schema.Unknown;
     readonly tool_input_schema_digests_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

package/dist/types/store-sql/chat/agent-chat-repository.d.ts

@@ -20,13 +20,13 @@ export interface Interface {
     readonly save: (input: SaveInput) => Effect.Effect<AgentChatRecord, AgentChatRepositoryError>;
     readonly get: (executionId: Ids.ExecutionId) => Effect.Effect<AgentChatRecord | undefined, AgentChatRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AgentChatRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/chat/agent-chat-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const AgentChatRow: Schema.Struct<{
     readonly execution_id: Schema.String;
     readonly export_json: Schema.Unknown;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

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

@@ -49,7 +49,7 @@ export interface Interface {
     readonly listByExecution: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<ChildExecutionRecord>, ChildExecutionRepositoryError>;
     readonly updateStatus: (input: UpdateChildExecutionStatusInput) => Effect.Effect<ChildExecutionRecord, ChildExecutionNotFound | ChildExecutionRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ChildExecutionRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/child/child-execution-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const ChildExecutionRow: Schema.Struct<{
@@ -58,8 +58,8 @@ export declare const ChildExecutionRow: Schema.Struct<{
     readonly address_id: Schema.String;
     readonly status: Schema.String;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
@@ -67,5 +67,5 @@ export declare const testLayer: (implementation: Interface) => Layer.Layer<Servi
 export declare const create: (input: CreateChildExecutionInput) => Effect.Effect<ChildExecutionRecord, ChildExecutionRepositoryError | DuplicateChildExecution, Service>;
 export declare const get: (id: string & import("effect/Brand").Brand<"Relay.ChildExecutionId">) => Effect.Effect<ChildExecutionRecord | undefined, ChildExecutionRepositoryError, Service>;
 export declare const listByExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<readonly ChildExecutionRecord[], ChildExecutionRepositoryError, Service>;
-export declare const updateStatus: (input: UpdateChildExecutionStatusInput) => Effect.Effect<ChildExecutionRecord, ChildExecutionRepositoryError | ChildExecutionNotFound, Service>;
+export declare const updateStatus: (input: UpdateChildExecutionStatusInput) => Effect.Effect<ChildExecutionRecord, ChildExecutionNotFound | ChildExecutionRepositoryError, Service>;
 export {};

package/dist/types/store-sql/child/child-fan-out-repository.d.ts

@@ -39,12 +39,12 @@ export interface CancelResult {
     readonly transitioned: boolean;
     readonly activeChildExecutionIds: ReadonlyArray<Ids.ChildExecutionId>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ChildFanOutRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/child/child-fan-out-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 create: (definition: ChildOrchestration.FanOutDefinition) => Effect.Effect<ChildOrchestration.FanOutState, ChildFanOutRepositoryError | ChildFanOutConflict, Service>;
+export declare const create: (definition: ChildOrchestration.FanOutDefinition) => Effect.Effect<ChildOrchestration.FanOutState, ChildFanOutConflict | ChildFanOutRepositoryError, Service>;
 export declare const get: (id: string & import("effect/Brand").Brand<"Relay.ChildFanOutId">) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRepositoryError, Service>;
 export declare const claimAdmissions: (id: string & import("effect/Brand").Brand<"Relay.ChildFanOutId">) => Effect.Effect<readonly ChildOrchestration.FanOutChild[], ChildFanOutRepositoryError, Service>;
 export declare const recordTerminal: (input: RecordTerminalInput) => Effect.Effect<RecordTerminalResult | undefined, ChildFanOutRepositoryError, Service>;

package/dist/types/store-sql/cluster/cluster-registry-repository.d.ts

@@ -12,17 +12,17 @@ export interface RunnerRecord {
     readonly ownedShards: number;
 }
 export interface Interface {
-    readonly listRunners: () => Effect.Effect<ReadonlyArray<RunnerRecord>, ClusterRegistryError>;
+    readonly listRunners: (_?: never) => Effect.Effect<ReadonlyArray<RunnerRecord>, ClusterRegistryError>;
     readonly lockOwner: (shardId: string) => Effect.Effect<string | undefined, ClusterRegistryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ClusterRegistryRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/cluster/cluster-registry-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const RunnerRow: Schema.Struct<{
     readonly address: Schema.String;
-    readonly healthy: Schema.Union<readonly [Schema.Boolean, Schema.Number, Schema.String]>;
-    readonly last_heartbeat: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly owned_shards: Schema.Union<readonly [Schema.Number, Schema.String, Schema.BigInt]>;
+    readonly healthy: Schema.Union<readonly [Schema.Boolean, Schema.Finite, Schema.String]>;
+    readonly last_heartbeat: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly owned_shards: Schema.Union<readonly [Schema.Finite, Schema.String, Schema.BigInt]>;
 }>;
 export declare const LockRow: Schema.Struct<{
     readonly address: Schema.String;

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

@@ -25,7 +25,7 @@ export interface Interface {
     readonly record: (input: RecordInput) => Effect.Effect<CompactionCheckpointRecord, CompactionRepositoryError>;
     readonly list: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<CompactionCheckpointRecord>, CompactionRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/CompactionRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/compaction/compaction-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const CompactionCheckpointRow: Schema.Struct<{
@@ -33,8 +33,8 @@ export declare const CompactionCheckpointRow: Schema.Struct<{
     readonly checkpoint_id: Schema.String;
     readonly summary: Schema.String;
     readonly first_kept_entry_id: Schema.String;
-    readonly turn: Schema.Number;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly turn: Schema.Finite;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

package/dist/types/store-sql/database/database-service.d.ts

@@ -8,16 +8,16 @@ export type Drizzle = EffectPgDatabase & {
 };
 export type PgTimestamp = Date | string | number;
 export type DatabaseError = EffectDrizzleQueryError | SqlError;
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/Database", Drizzle>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/database/database-service/Service", Drizzle>;
 export declare class Service extends Service_base {
 }
 export { fromDbTimestamp as fromPgDate, fromNullableDbTimestamp as fromNullablePgDate } from "./sql-dialect";
 export declare const pgTypeParsers: {
     getTypeParser: (typeId: number, format?: "text" | "binary") => any;
 };
-export declare const PgClientLive: Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | PgClient, SqlError | Config.ConfigError, never>;
+export declare const PgClientLive: Layer.Layer<PgClient | import("effect/unstable/sql/SqlClient").SqlClient, Config.ConfigError | SqlError, never>;
 export declare const layerFromPgClient: Layer.Layer<Service, never, PgClient>;
-export declare const layer: Layer.Layer<Service, SqlError | Config.ConfigError, never>;
+export declare const layer: Layer.Layer<Service, Config.ConfigError | SqlError, never>;
 export declare const testLayer: (db: Drizzle) => Layer.Layer<Service, never, never>;
 export declare const check: () => Effect.Effect<void, EffectDrizzleQueryError, Service>;
 export { Dialect, decodeBool, decodeJson, dialect, encodeJson, fromDbTimestamp, fromNullableDbTimestamp, timestampParam, } from "./sql-dialect";

package/dist/types/store-sql/database/notification-bus.d.ts

@@ -7,7 +7,7 @@ export interface Interface {
     readonly publish: (channel: string, payload: string) => Effect.Effect<void, SqlError>;
     readonly subscribe: (channel: string) => Stream.Stream<string, SqlError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/NotificationBus", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/database/notification-bus/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const pgLayer: Layer.Layer<Service, never, SqlClient>;

package/dist/types/store-sql/database/sql-dialect.d.ts

@@ -7,7 +7,10 @@ export declare const dialect: Effect.Effect<Dialect, never, SqlClient>;
 export declare const toDbDate: (timestamp: number) => Date;
 export declare const fromDbTimestamp: (timestamp: DbTimestamp) => number;
 export declare const fromNullableDbTimestamp: (timestamp: DbTimestamp | null | undefined) => number | undefined;
-export declare const timestampParam: (client: SqlClient, millis: number) => Date | number;
+export declare const timestampParam: {
+    (client: SqlClient, millis: number): Date | number;
+    (millis: number): (client: SqlClient) => Date | number;
+};
 export declare const encodeJson: (value: unknown) => string;
 export declare const decodeJson: (value: unknown) => unknown;
 export declare const decodeBool: (value: unknown) => boolean;

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

@@ -16,7 +16,7 @@ export interface CreateInstanceInput {
 export interface Interface {
     readonly putKind: (definition: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, EntityRepositoryError>;
     readonly getKind: (kind: Ids.EntityKindName) => Effect.Effect<Entity.KindDefinition | undefined, EntityRepositoryError>;
-    readonly listKinds: () => Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRepositoryError>;
+    readonly listKinds: (_?: never) => Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRepositoryError>;
     readonly getOrCreate: (input: CreateInstanceInput) => Effect.Effect<Entity.Instance, EntityRepositoryError>;
     readonly get: (kind: Ids.EntityKindName, key: Ids.EntityKey) => Effect.Effect<Entity.Instance | undefined, EntityRepositoryError>;
     readonly destroy: (kind: Ids.EntityKindName, key: Ids.EntityKey, destroyedAt: number) => Effect.Effect<Entity.Instance | undefined, EntityRepositoryError>;
@@ -27,7 +27,7 @@ export interface Interface {
         readonly limit?: number;
     }) => Effect.Effect<ReadonlyArray<Entity.Instance>, EntityRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/EntityRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/entity/entity-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, SqlClient>;

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

@@ -145,7 +145,7 @@ export interface Interface {
     readonly completeWait: (input: CompleteWaitInput) => Effect.Effect<CompleteWaitResult, WaitNotFound | EnvelopeRepositoryError>;
     readonly resolveWait: (input: ResolveWaitInput) => Effect.Effect<WaitRecord, WaitNotFound | EnvelopeRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/EnvelopeRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/envelope/envelope-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const EnvelopeRow: Schema.Struct<{
@@ -157,7 +157,7 @@ export declare const EnvelopeRow: Schema.Struct<{
     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.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const WaitRow: Schema.Struct<{
     readonly id: Schema.String;
@@ -167,8 +167,8 @@ export declare const WaitRow: Schema.Struct<{
     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.Number]>;
-    readonly resolved_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number, Schema.Null]>;
+    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 EnvelopeReadyRow: Schema.Struct<{
     readonly id: Schema.String;
@@ -176,17 +176,17 @@ export declare const EnvelopeReadyRow: Schema.Struct<{
     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.Number]>;
-    readonly attempt: Schema.Number;
+    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.Number, 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.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly claimed_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number, Schema.Null]>;
-    readonly acknowledged_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number, Schema.Null]>;
+    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]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
@@ -198,8 +198,8 @@ export declare const createWait: (input: CreateWaitInput) => Effect.Effect<WaitR
 export declare const listWaits: (input: ListWaitsInput) => Effect.Effect<readonly WaitRecord[], EnvelopeRepositoryError, Service>;
 export declare const listAllWaits: (input: ListAllWaitsInput) => Effect.Effect<readonly WaitRecord[], EnvelopeRepositoryError, Service>;
 export declare const claimReady: (input: ClaimReadyInput) => Effect.Effect<EnvelopeReadyRecord | undefined, EnvelopeRepositoryError, Service>;
-export declare const releaseReady: (input: ReleaseReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeRepositoryError | EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch, Service>;
-export declare const ackReady: (input: AckReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeRepositoryError | EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch, Service>;
+export declare const releaseReady: (input: ReleaseReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyClaimMismatch | EnvelopeReadyNotFound | EnvelopeRepositoryError, Service>;
+export declare const ackReady: (input: AckReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyClaimMismatch | EnvelopeReadyNotFound | EnvelopeRepositoryError, Service>;
 export declare const completeWait: (input: CompleteWaitInput) => Effect.Effect<CompleteWaitResult, EnvelopeRepositoryError | WaitNotFound, Service>;
 export declare const resolveWait: (input: ResolveWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError | WaitNotFound, Service>;
 export {};

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

@@ -62,6 +62,25 @@ export interface ListAfterSequenceInput {
     readonly afterSequence: Execution.ExecutionEventSequence | undefined;
     readonly limit: number;
 }
+export type PageInput = {
+    readonly executionId: Ids.ExecutionId;
+    readonly direction: "forward";
+    readonly afterCursor?: string;
+    readonly beforeCursor?: never;
+    readonly limit?: number;
+} | {
+    readonly executionId: Ids.ExecutionId;
+    readonly direction: "backward";
+    readonly afterCursor?: never;
+    readonly beforeCursor?: string;
+    readonly limit?: number;
+};
+export interface PageResult {
+    readonly events: ReadonlyArray<Execution.ExecutionEvent>;
+    readonly hasMore: boolean;
+    readonly oldestCursor?: string;
+    readonly newestCursor?: string;
+}
 export interface Interface {
     readonly signalTransport: Transport;
     readonly append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | ExecutionEventRepositoryError>;
@@ -75,8 +94,9 @@ export interface Interface {
     readonly notifyAppended: (event: Execution.ExecutionEvent) => Effect.Effect<void, ExecutionEventRepositoryError>;
     readonly appendedSignals: (executionId: Ids.ExecutionId) => Stream.Stream<Execution.ExecutionEventSequence, ExecutionEventRepositoryError>;
     readonly listAfterSequence: (input: ListAfterSequenceInput) => Effect.Effect<ReadonlyArray<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
+    readonly page: (input: PageInput) => Effect.Effect<PageResult, ExecutionEventCursorNotFound | ExecutionEventRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionEventRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/execution/execution-event-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const ExecutionEventRow: Schema.Struct<{
@@ -84,18 +104,20 @@ export declare const ExecutionEventRow: Schema.Struct<{
     readonly execution_id: Schema.String;
     readonly child_execution_id: Schema.NullishOr<Schema.String>;
     readonly type: Schema.String;
-    readonly sequence: Schema.Union<readonly [Schema.Number, Schema.String]>;
+    readonly sequence: Schema.Union<readonly [Schema.Finite, Schema.String]>;
     readonly cursor: Schema.String;
     readonly content_json: Schema.NullishOr<Schema.Unknown>;
     readonly data_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
-export declare const layer: Layer.Layer<Service, never, SqlClient | NotificationBusService>;
+export declare const layer: Layer.Layer<Service, never, NotificationBusService | SqlClient>;
 export declare const layerWithBus: 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>;
+type TestImplementation = Omit<Interface, "page"> & Partial<Pick<Interface, "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 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>;
 export declare const findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;
 export declare const findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;

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

@@ -78,10 +78,10 @@ export interface Interface {
     readonly list: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ExecutionRepositoryError>;
     readonly transition: (input: TransitionExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionNotFound | ExecutionRepositoryError>;
     readonly notifyChanged: (record: ExecutionRecord) => Effect.Effect<void, ExecutionRepositoryError>;
-    readonly changedSignals: () => Stream.Stream<Ids.ExecutionId, ExecutionRepositoryError>;
+    readonly changedSignals: (_?: never) => Stream.Stream<Ids.ExecutionId, ExecutionRepositoryError>;
     readonly listChangedSince: (input: ListChangedSinceInput) => Effect.Effect<ReadonlyArray<ExecutionRecord>, ExecutionRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/execution/execution-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const ExecutionRow: Schema.Struct<{
@@ -90,19 +90,19 @@ export declare const ExecutionRow: Schema.Struct<{
     readonly session_id: Schema.NullishOr<Schema.String>;
     readonly status: Schema.String;
     readonly agent_id: Schema.NullishOr<Schema.String>;
-    readonly agent_revision: Schema.NullishOr<Schema.Number>;
+    readonly agent_revision: Schema.NullishOr<Schema.Finite>;
     readonly agent_snapshot_json: Schema.NullishOr<Schema.Unknown>;
     readonly agent_tool_input_schema_digests_json: Schema.Unknown;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
-export declare const layerWithoutBus: Layer.Layer<Service, never, SqlClient | NotificationBusService>;
+export declare const layerWithoutBus: Layer.Layer<Service, never, NotificationBusService | SqlClient>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Omit<Interface, "notifyChanged" | "changedSignals" | "listChangedSince"> & Partial<Pick<Interface, "notifyChanged" | "changedSignals" | "listChangedSince">>) => Layer.Layer<Service, never, never>;
-export declare const create: (input: CreateExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionRepositoryError | DuplicateExecution, Service>;
+export declare const create: (input: CreateExecutionInput) => Effect.Effect<ExecutionRecord, DuplicateExecution | ExecutionRepositoryError, Service>;
 export declare const get: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<ExecutionRecord | undefined, ExecutionRepositoryError, Service>;
 export declare const list: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ExecutionRepositoryError, Service>;
-export declare const transition: (input: TransitionExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionRepositoryError | ExecutionNotFound, Service>;
+export declare const transition: (input: TransitionExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionNotFound | ExecutionRepositoryError, Service>;
 export {};

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

@@ -31,7 +31,7 @@ export interface Interface {
     readonly runOnce: <R>(input: OperationInput, create: Effect.Effect<Shared.JsonValue, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, R>;
     readonly transaction: <A, R>(effect: Effect.Effect<A, IdempotencyRepositoryError, R>) => Effect.Effect<A, IdempotencyRepositoryError, R>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/IdempotencyRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/idempotency/idempotency-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const IdempotencyRow: Schema.Struct<{
@@ -40,12 +40,12 @@ export declare const IdempotencyRow: Schema.Struct<{
     readonly key: Schema.String;
     readonly result_json: Schema.NullishOr<Schema.Unknown>;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
 }>;
 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 declare const runOnce: <R>(input: OperationInput, create: Effect.Effect<Schema.Json, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, Service | R>;
-export declare const transaction: <A, R>(effect: Effect.Effect<A, IdempotencyRepositoryError, R>) => Effect.Effect<A, IdempotencyRepositoryError, Service | R>;
+export declare const runOnce: <R>(input: OperationInput, create: Effect.Effect<Schema.Json, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, R | Service>;
+export declare const transaction: <A, R>(effect: Effect.Effect<A, IdempotencyRepositoryError, R>) => Effect.Effect<A, IdempotencyRepositoryError, R | Service>;
 export {};

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

@@ -43,7 +43,7 @@ export interface Interface {
     readonly countUndrained: (executionId: Ids.ExecutionId) => Effect.Effect<number, InboxRepositoryError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, InboxRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/InboxRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/inbox/inbox-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, SqlClient>;

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

@@ -45,7 +45,7 @@ export interface Interface {
     readonly query: (input: QueryInput) => Effect.Effect<ReadonlyArray<MemoryMatch>, MemoryRepositoryError>;
     readonly forget: (input: ForgetInput) => Effect.Effect<void, MemoryRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/MemoryRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/memory/memory-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const recallCandidateCap = 1000;
@@ -53,10 +53,10 @@ export declare const MemoryRow: Schema.Struct<{
     readonly id: Schema.String;
     readonly agent: Schema.String;
     readonly subject: Schema.String;
-    readonly embedding: Schema.Union<readonly [Schema.$Array<Schema.Number>, Schema.String]>;
+    readonly embedding: Schema.Union<readonly [Schema.$Array<Schema.Finite>, Schema.String]>;
     readonly parts_json: Schema.Unknown;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

package/dist/types/store-sql/permission/permission-rule-repository.d.ts

@@ -26,14 +26,14 @@ export interface Interface {
     readonly remember: (input: RememberInput) => Effect.Effect<PermissionRuleRecord, PermissionRuleRepositoryError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<PermissionRuleRecord>, PermissionRuleRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/PermissionRuleRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/permission/permission-rule-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const PermissionRuleRow: Schema.Struct<{
     readonly agent: Schema.String;
     readonly scope: Schema.String;
     readonly rule_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

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

@@ -37,10 +37,10 @@ export interface Interface {
     readonly notifyChanged: (scope: ScopeInput) => Effect.Effect<void, PresenceRepositoryError>;
     readonly changedSignals: (scope: ScopeInput) => Stream.Stream<void, PresenceRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/PresenceRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/presence/presence-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, SqlClient | NotificationBusService>;
+export declare const layer: Layer.Layer<Service, never, NotificationBusService | SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const upsertHeartbeat: (input: HeartbeatInput) => Effect.Effect<void, PresenceRepositoryError, Service>;

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

@@ -67,7 +67,7 @@ export interface Interface {
     readonly ack: (input: AckScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleNotFound | ScheduleClaimMismatch | ScheduleRepositoryError>;
     readonly release: (input: ReleaseScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleNotFound | ScheduleClaimMismatch | ScheduleRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ScheduleRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/schedule/schedule-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const ScheduleRow: Schema.Struct<{
@@ -79,15 +79,15 @@ export declare const ScheduleRow: Schema.Struct<{
     readonly cron_expr: Schema.NullishOr<Schema.String>;
     readonly input_json: Schema.NullishOr<Schema.Unknown>;
     readonly state: Schema.String;
-    readonly next_run_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly attempt: Schema.Union<readonly [Schema.Number, Schema.String, Schema.BigInt]>;
+    readonly next_run_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly attempt: Schema.Union<readonly [Schema.Finite, Schema.String, Schema.BigInt]>;
     readonly claim_owner: Schema.NullishOr<Schema.String>;
-    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
+    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
     readonly last_error: Schema.NullishOr<Schema.String>;
     readonly idempotency_key: Schema.NullishOr<Schema.String>;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
@@ -95,8 +95,8 @@ export declare const testLayer: (implementation: Interface) => Layer.Layer<Servi
 export declare const create: (input: CreateScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError, Service>;
 export declare const get: (id: string & import("effect/Brand").Brand<"Relay.ScheduleId">) => Effect.Effect<Schedule.ScheduleRecord | undefined, ScheduleRepositoryError, Service>;
 export declare const list: (input: ListSchedulesInput) => Effect.Effect<readonly Schedule.ScheduleRecord[], ScheduleRepositoryError, Service>;
-export declare const cancel: (input: CancelScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError | ScheduleNotFound, Service>;
+export declare const cancel: (input: CancelScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleNotFound | ScheduleRepositoryError, Service>;
 export declare const claimDue: (input: ClaimDueInput) => Effect.Effect<Schedule.ScheduleRecord | undefined, ScheduleRepositoryError, Service>;
-export declare const ack: (input: AckScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError | ScheduleNotFound | ScheduleClaimMismatch, Service>;
-export declare const release: (input: ReleaseScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError | ScheduleNotFound | ScheduleClaimMismatch, Service>;
+export declare const ack: (input: AckScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleClaimMismatch | ScheduleNotFound | ScheduleRepositoryError, Service>;
+export declare const release: (input: ReleaseScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleClaimMismatch | ScheduleNotFound | ScheduleRepositoryError, Service>;
 export {};