@relayfx/sdk 0.0.1

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

@@ -0,0 +1,53 @@
+import { Schema } from "effect";
+export declare const Permission: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Permission extends Schema.Schema.Type<typeof Permission> {
+}
+export declare const RuntimeRequirement: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"workspace">;
+    readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
+}>]>;
+export interface RuntimeRequirement extends Schema.Schema.Type<typeof RuntimeRequirement> {
+}
+export declare const Definition: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly input_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly output_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly permissions: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly requirements: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"workspace">;
+        readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
+    }>]>>>;
+    readonly needs_approval: Schema.optionalKey<Schema.Boolean>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Definition extends Schema.Schema.Type<typeof Definition> {
+}
+export declare const Call: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+    readonly name: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Call extends Schema.Schema.Type<typeof Call> {
+}
+export declare const Result: Schema.Struct<{
+    readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly error: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Result extends Schema.Schema.Type<typeof Result> {
+}

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

@@ -0,0 +1,78 @@
+import { Schema } from "effect";
+export declare const WorkspaceProviderKey: Schema.String;
+export type WorkspaceProviderKey = typeof WorkspaceProviderKey.Type;
+export declare const WorkspaceLeaseStatus: Schema.Literals<readonly ["planned", "running", "suspended", "snapshotted", "archived", "released", "failed"]>;
+export type WorkspaceLeaseStatus = typeof WorkspaceLeaseStatus.Type;
+export declare const WorkspaceResumeStrategy: Schema.Literals<readonly ["reattach", "restore_snapshot"]>;
+export type WorkspaceResumeStrategy = typeof WorkspaceResumeStrategy.Type;
+export declare const WorkspaceCapabilities: Schema.Struct<{
+    readonly can_suspend: Schema.Boolean;
+    readonly can_snapshot: Schema.Boolean;
+    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 reattach_by_ref: Schema.Boolean;
+}>;
+export interface WorkspaceCapabilities extends Schema.Schema.Type<typeof WorkspaceCapabilities> {
+}
+export declare const WorkspaceRequest: Schema.Struct<{
+    readonly provider_key: Schema.optionalKey<Schema.String>;
+    readonly resume_snapshot_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface WorkspaceRequest extends Schema.Schema.Type<typeof WorkspaceRequest> {
+}
+export declare const WorkspaceLeaseRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.WorkspaceLeaseId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
+    };
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly provider_key: Schema.String;
+    readonly sandbox_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
+    }>;
+    readonly latest_snapshot_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+    }>;
+    readonly status: Schema.Literals<readonly ["planned", "running", "suspended", "snapshotted", "archived", "released", "failed"]>;
+    readonly resume_strategy: Schema.Literals<readonly ["reattach", "restore_snapshot"]>;
+    readonly region: Schema.optionalKey<Schema.String>;
+    readonly request: Schema.optionalKey<Schema.Struct<{
+        readonly provider_key: Schema.optionalKey<Schema.String>;
+        readonly resume_snapshot_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+        }>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface WorkspaceLeaseRecord extends Schema.Schema.Type<typeof WorkspaceLeaseRecord> {
+}
+export declare const WorkspaceSnapshotReason: Schema.Literals<readonly ["before_wait", "before_child_fork", "on_complete", "on_failure", "manual"]>;
+export type WorkspaceSnapshotReason = typeof WorkspaceSnapshotReason.Type;
+export declare const WorkspaceSnapshotRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.WorkspaceSnapshotId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceSnapshotId">;
+    };
+    readonly lease_id: Schema.brand<Schema.String, "Relay.WorkspaceLeaseId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
+    };
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly reason: Schema.Literals<readonly ["before_wait", "before_child_fork", "on_complete", "on_failure", "manual"]>;
+    readonly snapshot_ref: Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+    };
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly created_at: Schema.Int;
+}>;
+export interface WorkspaceSnapshotRecord extends Schema.Schema.Type<typeof WorkspaceSnapshotRecord> {
+}

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

@@ -0,0 +1,48 @@
+import { Ids, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+export declare const RouteKind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+export type RouteKind = typeof RouteKind.Type;
+declare const AddressNotFound_base: Schema.Class<AddressNotFound, Schema.TaggedStruct<"AddressNotFound", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressNotFound extends AddressNotFound_base {
+}
+declare const AddressBookRepositoryError_base: Schema.Class<AddressBookRepositoryError, Schema.TaggedStruct<"AddressBookRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressBookRepositoryError extends AddressBookRepositoryError_base {
+}
+export interface AddressBookEntry {
+    readonly id: Ids.AddressBookEntryId;
+    readonly addressId: Ids.AddressId;
+    readonly routeKind: RouteKind;
+    readonly routeKey: string;
+    readonly metadata: Shared.Metadata;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface UpsertAddressBookEntryInput {
+    readonly id: Ids.AddressBookEntryId;
+    readonly addressId: Ids.AddressId;
+    readonly routeKind: RouteKind;
+    readonly routeKey: string;
+    readonly metadata?: Shared.Metadata;
+}
+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>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AddressBookRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+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 list: () => Effect.Effect<readonly AddressBookEntry[], AddressBookRepositoryError, Service>;
+export {};

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

@@ -0,0 +1,49 @@
+import { Agent, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const AgentDefinitionRepositoryError_base: Schema.Class<AgentDefinitionRepositoryError, Schema.TaggedStruct<"AgentDefinitionRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentDefinitionRepositoryError extends AgentDefinitionRepositoryError_base {
+}
+export interface AgentDefinitionRecord {
+    readonly id: Ids.AgentDefinitionId;
+    readonly currentRevision: Agent.DefinitionRevision;
+    readonly definition: Agent.Definition;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface AgentDefinitionRevisionRecord {
+    readonly id: Ids.AgentDefinitionId;
+    readonly revision: Agent.DefinitionRevision;
+    readonly definition: Agent.Definition;
+    readonly createdAt: number;
+}
+export interface PutAgentDefinitionInput {
+    readonly id: Ids.AgentDefinitionId;
+    readonly definition: Agent.Definition;
+    readonly now: number;
+}
+export interface GetAgentDefinitionRevisionInput {
+    readonly id: Ids.AgentDefinitionId;
+    readonly revision: Agent.DefinitionRevision;
+}
+export interface Interface {
+    readonly put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError>;
+    readonly get: (id: Ids.AgentDefinitionId) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError>;
+    readonly getRevision: (input: GetAgentDefinitionRevisionInput) => Effect.Effect<AgentDefinitionRevisionRecord | undefined, AgentDefinitionRepositoryError>;
+    readonly list: () => Effect.Effect<ReadonlyArray<AgentDefinitionRecord>, AgentDefinitionRepositoryError>;
+    readonly listRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<ReadonlyArray<AgentDefinitionRevisionRecord>, AgentDefinitionRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AgentDefinitionRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError, Service>;
+export declare const getRevision: (input: GetAgentDefinitionRevisionInput) => Effect.Effect<AgentDefinitionRevisionRecord | undefined, AgentDefinitionRepositoryError, Service>;
+export declare const list: () => Effect.Effect<readonly AgentDefinitionRecord[], AgentDefinitionRepositoryError, Service>;
+export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<readonly AgentDefinitionRevisionRecord[], AgentDefinitionRepositoryError, Service>;
+export {};

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

@@ -0,0 +1,31 @@
+import { Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const AgentChatRepositoryError_base: Schema.Class<AgentChatRepositoryError, Schema.TaggedStruct<"AgentChatRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentChatRepositoryError extends AgentChatRepositoryError_base {
+}
+export interface AgentChatRecord {
+    readonly executionId: Ids.ExecutionId;
+    readonly exportData: unknown;
+    readonly updatedAt: number;
+}
+export interface SaveInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly exportData: unknown;
+    readonly updatedAt: number;
+}
+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>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const save: (input: SaveInput) => Effect.Effect<AgentChatRecord, AgentChatRepositoryError, Service>;
+export declare const get: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<AgentChatRecord | undefined, AgentChatRepositoryError, Service>;
+export {};

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

@@ -0,0 +1,61 @@
+import { Execution, Ids, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const ChildExecutionRepositoryError_base: Schema.Class<ChildExecutionRepositoryError, Schema.TaggedStruct<"ChildExecutionRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ChildExecutionRepositoryError extends ChildExecutionRepositoryError_base {
+}
+declare const DuplicateChildExecution_base: Schema.Class<DuplicateChildExecution, Schema.TaggedStruct<"DuplicateChildExecution", {
+    readonly id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateChildExecution extends DuplicateChildExecution_base {
+}
+declare const ChildExecutionNotFound_base: Schema.Class<ChildExecutionNotFound, Schema.TaggedStruct<"ChildExecutionNotFound", {
+    readonly id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ChildExecutionNotFound extends ChildExecutionNotFound_base {
+}
+export interface ChildExecutionRecord {
+    readonly id: Ids.ChildExecutionId;
+    readonly executionId: Ids.ExecutionId;
+    readonly addressId: Ids.AddressId;
+    readonly status: Execution.ExecutionStatus;
+    readonly metadata: Shared.Metadata;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface CreateChildExecutionInput {
+    readonly id: Ids.ChildExecutionId;
+    readonly executionId: Ids.ExecutionId;
+    readonly addressId: Ids.AddressId;
+    readonly status: Execution.ExecutionStatus;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface UpdateChildExecutionStatusInput {
+    readonly id: Ids.ChildExecutionId;
+    readonly status: Execution.ExecutionStatus;
+    readonly updatedAt: number;
+}
+export interface Interface {
+    readonly create: (input: CreateChildExecutionInput) => Effect.Effect<ChildExecutionRecord, DuplicateChildExecution | ChildExecutionRepositoryError>;
+    readonly get: (id: Ids.ChildExecutionId) => Effect.Effect<ChildExecutionRecord | undefined, ChildExecutionRepositoryError>;
+    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>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+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 {};

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

@@ -0,0 +1,35 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+declare const ClusterRegistryError_base: Schema.Class<ClusterRegistryError, Schema.TaggedStruct<"ClusterRegistryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ClusterRegistryError extends ClusterRegistryError_base {
+}
+export interface RunnerRecord {
+    readonly address: string;
+    readonly healthy: boolean;
+    readonly lastHeartbeat: number;
+    readonly ownedShards: number;
+}
+export interface Interface {
+    readonly listRunners: () => 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>;
+export declare class Service extends Service_base {
+}
+export declare const RunnerRow: Schema.Struct<{
+    readonly address: Schema.String;
+    readonly healthy: Schema.Boolean;
+    readonly last_heartbeat: Schema.Union<readonly [Schema.Date, Schema.DateFromString]>;
+    readonly owned_shards: Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>;
+}>;
+export declare const LockRow: Schema.Struct<{
+    readonly address: Schema.String;
+}>;
+export declare const layer: Layer.Layer<Service, never, 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 listRunners: () => Effect.Effect<readonly RunnerRecord[], ClusterRegistryError, Service>;
+export declare const lockOwner: (shardId: string) => Effect.Effect<string | undefined, ClusterRegistryError, Service>;
+export {};

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

@@ -0,0 +1,25 @@
+import * as PgClient from "@effect/sql-pg/PgClient";
+import * as PgDrizzle from "drizzle-orm/effect-postgres";
+import type { EffectDrizzleQueryError } from "drizzle-orm/effect-core/errors";
+import { Config, Context, Effect, Layer } from "effect";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+export type Drizzle = PgDrizzle.EffectPgDatabase & {
+    readonly $client: PgClient.PgClient;
+};
+export type PgTimestamp = Date | string | number;
+export type DatabaseError = EffectDrizzleQueryError | SqlError;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/Database", Drizzle>;
+export declare class Service extends Service_base {
+}
+export declare const toPgDate: (timestamp: number) => Date;
+export declare const fromPgDate: (timestamp: PgTimestamp) => number;
+export declare const fromNullablePgDate: (timestamp: PgTimestamp | null | undefined) => number | undefined;
+export declare const pgTypeParsers: {
+    getTypeParser: (typeId: number, format?: "text" | "binary") => any;
+};
+export declare const PgClientLive: Layer.Layer<PgClient.PgClient | import("effect/unstable/sql/SqlClient").SqlClient, SqlError | Config.ConfigError, never>;
+export declare const layerFromPgClient: Layer.Layer<Service, never, PgClient.PgClient>;
+export declare const layer: Layer.Layer<Service, SqlError | Config.ConfigError, never>;
+export declare const testLayer: (db: Drizzle) => Layer.Layer<Service, never, never>;
+export declare const check: () => Effect.Effect<void, EffectDrizzleQueryError, Service>;
+export {};

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

@@ -0,0 +1,158 @@
+import { Address, Envelope, Ids, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+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"]>;
+export type EnvelopeReadyState = typeof EnvelopeReadyState.Type;
+declare const EnvelopeRepositoryError_base: Schema.Class<EnvelopeRepositoryError, Schema.TaggedStruct<"EnvelopeRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeRepositoryError extends EnvelopeRepositoryError_base {
+}
+declare const EnvelopeNotFound_base: Schema.Class<EnvelopeNotFound, Schema.TaggedStruct<"EnvelopeNotFound", {
+    readonly id: Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeNotFound extends EnvelopeNotFound_base {
+}
+declare const WaitNotFound_base: Schema.Class<WaitNotFound, Schema.TaggedStruct<"WaitNotFound", {
+    readonly id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class WaitNotFound extends WaitNotFound_base {
+}
+declare const EnvelopeReadyNotFound_base: Schema.Class<EnvelopeReadyNotFound, Schema.TaggedStruct<"EnvelopeReadyNotFound", {
+    readonly id: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeReadyNotFound extends EnvelopeReadyNotFound_base {
+}
+declare const EnvelopeReadyClaimMismatch_base: Schema.Class<EnvelopeReadyClaimMismatch, Schema.TaggedStruct<"EnvelopeReadyClaimMismatch", {
+    readonly id: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+    };
+    readonly worker_id: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeReadyClaimMismatch extends EnvelopeReadyClaimMismatch_base {
+}
+export interface CreateEnvelopeReadyInput {
+    readonly id: Ids.EnvelopeReadyId;
+    readonly routeType: Address.RouteKind;
+    readonly routeKey: string;
+    readonly availableAt: number;
+    readonly idempotencyKey?: string;
+    readonly metadata?: Shared.Metadata;
+}
+export interface AcceptEnvelopeInput {
+    readonly envelope: Envelope.Envelope;
+    readonly waitId?: Ids.WaitId;
+    readonly ready?: CreateEnvelopeReadyInput;
+}
+export interface WaitRecord {
+    readonly id: Ids.WaitId;
+    readonly executionId: Ids.ExecutionId;
+    readonly envelopeId?: Ids.EnvelopeId;
+    readonly mode: Envelope.WaitMode;
+    readonly correlationKey?: string;
+    readonly state: WaitState;
+    readonly metadata: Shared.Metadata;
+    readonly createdAt: number;
+    readonly resolvedAt?: number;
+}
+export interface EnvelopeReadyRecord {
+    readonly id: Ids.EnvelopeReadyId;
+    readonly envelopeId: Ids.EnvelopeId;
+    readonly routeType: Address.RouteKind;
+    readonly routeKey: string;
+    readonly state: EnvelopeReadyState;
+    readonly availableAt: number;
+    readonly attempt: number;
+    readonly claimOwner?: string;
+    readonly claimExpiresAt?: number;
+    readonly lastError?: string;
+    readonly idempotencyKey?: string;
+    readonly metadata: Shared.Metadata;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly claimedAt?: number;
+    readonly acknowledgedAt?: number;
+}
+export interface ClaimReadyInput {
+    readonly routeType: Address.RouteKind;
+    readonly routeKey?: string;
+    readonly workerId: string;
+    readonly now: number;
+    readonly claimExpiresAt: number;
+}
+export interface ReleaseReadyInput {
+    readonly id: Ids.EnvelopeReadyId;
+    readonly workerId: string;
+    readonly nextAvailableAt: number;
+    readonly error?: string;
+}
+export interface AckReadyInput {
+    readonly id: Ids.EnvelopeReadyId;
+    readonly workerId: string;
+    readonly now: number;
+}
+export interface ResolveWaitInput {
+    readonly waitId: Ids.WaitId;
+    readonly resolvedAt: number;
+    readonly metadata?: Shared.Metadata;
+}
+export interface CreateWaitInput {
+    readonly waitId: Ids.WaitId;
+    readonly executionId: Ids.ExecutionId;
+    readonly mode: Envelope.WaitMode;
+    readonly correlationKey?: string;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface ListWaitsInput {
+    readonly state?: WaitState;
+    readonly executionId?: Ids.ExecutionId;
+    readonly limit?: number;
+}
+export interface CompleteWaitInput {
+    readonly waitId: Ids.WaitId;
+    readonly state: Exclude<WaitState, "open">;
+    readonly completedAt: number;
+    readonly metadata?: Shared.Metadata;
+}
+export interface CompleteWaitResult {
+    readonly wait: WaitRecord;
+    readonly transitioned: boolean;
+}
+export interface Interface {
+    readonly acceptEnvelope: (input: AcceptEnvelopeInput) => Effect.Effect<Envelope.EnvelopeAccepted, EnvelopeRepositoryError>;
+    readonly getEnvelope: (id: Ids.EnvelopeId) => Effect.Effect<Envelope.Envelope | undefined, EnvelopeRepositoryError>;
+    readonly getWait: (id: Ids.WaitId) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError>;
+    readonly createWait: (input: CreateWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError>;
+    readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitRecord>, EnvelopeRepositoryError>;
+    readonly claimReady: (input: ClaimReadyInput) => Effect.Effect<EnvelopeReadyRecord | undefined, EnvelopeRepositoryError>;
+    readonly releaseReady: (input: ReleaseReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch | EnvelopeRepositoryError>;
+    readonly ackReady: (input: AckReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch | EnvelopeRepositoryError>;
+    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>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+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>;
+export declare const getEnvelope: (id: string & import("effect/Brand").Brand<"Relay.EnvelopeId">) => Effect.Effect<Envelope.Envelope | undefined, EnvelopeRepositoryError, Service>;
+export declare const getWait: (id: string & import("effect/Brand").Brand<"Relay.WaitId">) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError, Service>;
+export declare const createWait: (input: CreateWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError, Service>;
+export declare const listWaits: (input: ListWaitsInput) => 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 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

@@ -0,0 +1,86 @@
+import { Execution, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
+import * as Database from "../database/database-service";
+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"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly sequence: Schema.Int;
+    readonly cursor: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateExecutionEvent extends DuplicateExecutionEvent_base {
+}
+declare const ExecutionEventOrderViolation_base: Schema.Class<ExecutionEventOrderViolation, Schema.TaggedStruct<"ExecutionEventOrderViolation", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly sequence: Schema.Int;
+    readonly previous_sequence: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionEventOrderViolation extends ExecutionEventOrderViolation_base {
+}
+declare const ExecutionEventCursorNotFound_base: Schema.Class<ExecutionEventCursorNotFound, Schema.TaggedStruct<"ExecutionEventCursorNotFound", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly cursor: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionEventCursorNotFound extends ExecutionEventCursorNotFound_base {
+}
+declare const ExecutionEventRepositoryError_base: Schema.Class<ExecutionEventRepositoryError, Schema.TaggedStruct<"ExecutionEventRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionEventRepositoryError extends ExecutionEventRepositoryError_base {
+}
+export interface ListInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly afterCursor?: string;
+    readonly limit?: number;
+}
+export interface FindBySequenceOrCursorInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sequence: Execution.ExecutionEventSequence;
+    readonly cursor: string;
+}
+export interface FindByCursorInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly cursor: string;
+}
+export interface FindFirstByTypeAfterSequenceInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly type: Execution.ExecutionEventType;
+    readonly afterSequence: Execution.ExecutionEventSequence;
+}
+export interface ListAfterSequenceInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly afterSequence: Execution.ExecutionEventSequence | undefined;
+    readonly limit: number;
+}
+export interface Interface {
+    readonly append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | 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>;
+    readonly findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
+    readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, ExecutionEventRepositoryError>;
+    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>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionEventRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => 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 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 findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;
+export declare const maxSequence: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number | undefined, ExecutionEventRepositoryError, Service>;
+export declare const notifyAppended: (event: Execution.ExecutionEvent) => Effect.Effect<void, ExecutionEventRepositoryError, Service>;
+export declare const appendedSignals: (executionId: Ids.ExecutionId) => Stream.Stream<number, ExecutionEventRepositoryError, Service>;
+export declare const listAfterSequence: (input: ListAfterSequenceInput) => Effect.Effect<readonly Execution.ExecutionEvent[], ExecutionEventRepositoryError, Service>;
+export {};