@relayfx/sdk 0.0.50 → 0.2.0

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

@@ -1,7 +1,7 @@
 import { Ids, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-export declare const RouteKind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+export declare const RouteKind: Schema.Literals<readonly ["local-agent", "local-execution", "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"> & {

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

@@ -0,0 +1,53 @@
+import { ChildOrchestration, Content, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+declare const ChildFanOutRepositoryError_base: Schema.Class<ChildFanOutRepositoryError, Schema.TaggedStruct<"ChildFanOutRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ChildFanOutRepositoryError extends ChildFanOutRepositoryError_base {
+}
+declare const ChildFanOutConflict_base: Schema.Class<ChildFanOutConflict, Schema.TaggedStruct<"ChildFanOutConflict", {
+    readonly fan_out_id: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ChildFanOutConflict extends ChildFanOutConflict_base {
+}
+export interface Interface {
+    readonly create: (definition: ChildOrchestration.FanOutDefinition) => Effect.Effect<ChildOrchestration.FanOutState, ChildFanOutConflict | ChildFanOutRepositoryError>;
+    readonly get: (id: Ids.ChildFanOutId) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRepositoryError>;
+    readonly claimAdmissions: (id: Ids.ChildFanOutId) => Effect.Effect<ReadonlyArray<ChildOrchestration.FanOutChild>, ChildFanOutRepositoryError>;
+    readonly recordTerminal: (input: RecordTerminalInput) => Effect.Effect<RecordTerminalResult | undefined, ChildFanOutRepositoryError>;
+    readonly cancel: (id: Ids.ChildFanOutId, cancelledAt: number) => Effect.Effect<CancelResult | undefined, ChildFanOutRepositoryError>;
+    readonly listNonTerminal: (parentExecutionId?: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<ChildOrchestration.FanOutState>, ChildFanOutRepositoryError>;
+}
+export interface RecordTerminalInput {
+    readonly childExecutionId: Ids.ChildExecutionId;
+    readonly state: "completed" | "failed" | "cancelled";
+    readonly output: ReadonlyArray<Content.Part>;
+    readonly error?: string;
+    readonly completedAt: number;
+}
+export interface RecordTerminalResult {
+    readonly fanOut: ChildOrchestration.FanOutState;
+    readonly memberTransitioned: boolean;
+    readonly aggregateTransitioned: boolean;
+    readonly admitted: ReadonlyArray<ChildOrchestration.FanOutChild>;
+}
+export interface CancelResult {
+    readonly fanOut: ChildOrchestration.FanOutState;
+    readonly transitioned: boolean;
+    readonly activeChildExecutionIds: ReadonlyArray<Ids.ChildExecutionId>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ChildFanOutRepository", 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 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>;
+export declare const cancel: (id: string & import("effect/Brand").Brand<"Relay.ChildFanOutId">, cancelledAt: number) => Effect.Effect<CancelResult | undefined, ChildFanOutRepositoryError, Service>;
+export declare const listNonTerminal: (parentExecutionId?: (string & import("effect/Brand").Brand<"Relay.ExecutionId">) | undefined) => Effect.Effect<readonly ChildOrchestration.FanOutState[], ChildFanOutRepositoryError, Service>;
+export {};

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

@@ -1,8 +1,7 @@
 import { PgClient } from "@effect/sql-pg/PgClient";
 import { EffectPgDatabase } from "drizzle-orm/effect-postgres";
 import type { EffectDrizzleQueryError } from "drizzle-orm/effect-core/errors";
-import { Config, Context, Effect, Layer, Schema } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Config, Context, Effect, Layer } from "effect";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 export type Drizzle = EffectPgDatabase & {
     readonly $client: PgClient;
@@ -12,26 +11,13 @@ 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 { 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<PgClient | SqlClient, SqlError | Config.ConfigError, never>;
+export declare const PgClientLive: Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | PgClient, SqlError | Config.ConfigError, never>;
 export declare const layerFromPgClient: Layer.Layer<Service, never, 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 declare const Dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
-export type Dialect = typeof Dialect.Type;
-export declare const dialect: Effect.Effect<Dialect, never, SqlClient>;
-export declare const MysqlClientLive: Layer.Layer<SqlClient | import("@effect/sql-mysql2/MysqlClient").MysqlClient, SqlError | Config.ConfigError, never>;
-export declare const SqliteClientLive: Layer.Layer<SqlClient | import("@effect/sql-sqlite-bun/SqliteClient").SqliteClient, Config.ConfigError, never>;
-export declare const timestampParam: (client: SqlClient, millis: number) => Date | number;
-export declare const fromDbTimestamp: (timestamp: PgTimestamp) => number;
-export declare const fromNullableDbTimestamp: (timestamp: PgTimestamp | null | undefined) => number | undefined;
-export declare const encodeJson: (value: unknown) => string;
-export declare const decodeJson: (value: unknown) => unknown;
-export declare const decodeBool: (value: unknown) => boolean;
-export {};
+export { Dialect, decodeBool, decodeJson, dialect, encodeJson, fromDbTimestamp, fromNullableDbTimestamp, timestampParam, } from "./sql-dialect";

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

@@ -1,7 +1,9 @@
 import { Context, Effect, Layer, Stream } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 import type { SqlError } from "effect/unstable/sql/SqlError";
+export type Transport = "pg" | "in-process";
 export interface Interface {
+    readonly transport: Transport;
     readonly publish: (channel: string, payload: string) => Effect.Effect<void, SqlError>;
     readonly subscribe: (channel: string) => Stream.Stream<string, SqlError>;
 }

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

@@ -0,0 +1,13 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+export type DbTimestamp = Date | string | number;
+export declare const Dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
+export type Dialect = typeof Dialect.Type;
+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 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

@@ -0,0 +1,36 @@
+import { Entity, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+declare const EntityRepositoryError_base: Schema.Class<EntityRepositoryError, Schema.TaggedStruct<"EntityRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityRepositoryError extends EntityRepositoryError_base {
+}
+export interface CreateInstanceInput {
+    readonly kind: Ids.EntityKindName;
+    readonly key: Ids.EntityKey;
+    readonly addressId: Ids.AddressId;
+    readonly executionId: (generation: number) => Ids.ExecutionId;
+    readonly createdAt: number;
+}
+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 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>;
+    readonly list: (input: {
+        readonly kind?: Ids.EntityKindName;
+        readonly afterKind?: Ids.EntityKindName;
+        readonly afterKey?: string;
+        readonly limit?: number;
+    }) => Effect.Effect<ReadonlyArray<Entity.Instance>, EntityRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/EntityRepository", 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 {};

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

@@ -135,6 +135,7 @@ 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 findOpenByCorrelation?: (executionId: Ids.ExecutionId, correlationKey: string) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError>;
     readonly createWait: (input: CreateWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError>;
     readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitRecord>, EnvelopeRepositoryError>;
     readonly listAllWaits: (input: ListAllWaitsInput) => Effect.Effect<ReadonlyArray<WaitRecord>, EnvelopeRepositoryError>;

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

@@ -1,7 +1,7 @@
 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 } from "../database/notification-bus";
+import { Service as NotificationBusService, 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"> & {
@@ -63,6 +63,7 @@ export interface ListAfterSequenceInput {
     readonly limit: number;
 }
 export interface Interface {
+    readonly signalTransport: Transport;
     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>;

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

@@ -1,6 +1,7 @@
 import { Agent, Execution, Ids, Shared } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Service as NotificationBusService } from "../database/notification-bus";
 declare const ExecutionRepositoryError_base: Schema.Class<ExecutionRepositoryError, Schema.TaggedStruct<"ExecutionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -66,11 +67,19 @@ export interface ListExecutionsResult {
     readonly records: ReadonlyArray<ExecutionRecord>;
     readonly nextCursor?: ExecutionCursor;
 }
+export declare const executionsChangedChannel = "relay_executions_changed";
+export interface ListChangedSinceInput {
+    readonly updatedAtAfter: number;
+    readonly limit?: number;
+}
 export interface Interface {
     readonly create: (input: CreateExecutionInput) => Effect.Effect<ExecutionRecord, DuplicateExecution | ExecutionRepositoryError>;
     readonly get: (id: Ids.ExecutionId) => Effect.Effect<ExecutionRecord | undefined, ExecutionRepositoryError>;
     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 listChangedSince: (input: ListChangedSinceInput) => Effect.Effect<ReadonlyArray<ExecutionRecord>, ExecutionRepositoryError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionRepository", Interface>;
 export declare class Service extends Service_base {
@@ -88,9 +97,10 @@ export declare const ExecutionRow: Schema.Struct<{
     readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
     readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
 }>;
+export declare const layerWithoutBus: Layer.Layer<Service, never, SqlClient | NotificationBusService>;
 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 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 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>;

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

@@ -0,0 +1,56 @@
+import { Ids, Inbox, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { AcceptEnvelopeInput } from "../envelope/envelope-repository";
+declare const InboxRepositoryError_base: Schema.Class<InboxRepositoryError, Schema.TaggedStruct<"InboxRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InboxRepositoryError extends InboxRepositoryError_base {
+}
+export interface DeliverInput {
+    readonly acceptance?: AcceptEnvelopeInput;
+    readonly executionId: Ids.ExecutionId;
+    readonly from: Ids.AddressId;
+    readonly envelopeId?: Ids.EnvelopeId;
+    readonly content: Inbox.Message["content"];
+    readonly replyWaitId?: Ids.WaitId;
+    readonly correlationKey?: string;
+    readonly idempotencyKey?: string;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface DeliverResult {
+    readonly message: Inbox.Message;
+    readonly deduplicated: boolean;
+    readonly eventSequence?: number;
+}
+export interface DrainInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly drainId: string;
+    readonly maxBatch?: number;
+    readonly consumedAt: number;
+    readonly createdAt: number;
+}
+export interface ListInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly includeConsumed?: boolean;
+    readonly afterSequence?: number;
+    readonly limit?: number;
+}
+export interface Interface {
+    readonly deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxRepositoryError>;
+    readonly drain: (input: DrainInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, InboxRepositoryError>;
+    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>;
+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 declare const deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxRepositoryError, Service>;
+export declare const drain: (input: DrainInput) => Effect.Effect<readonly Inbox.Message[], InboxRepositoryError, Service>;
+export declare const countUndrained: (id: Ids.ExecutionId) => Effect.Effect<number, InboxRepositoryError, Service>;
+export declare const list: (input: ListInput) => Effect.Effect<readonly Inbox.Message[], InboxRepositoryError, Service>;
+export {};

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

@@ -2,16 +2,23 @@ export * as AddressBookRepository from "./address/address-book-repository";
 export * as AgentChatRepository from "./chat/agent-chat-repository";
 export * as AgentDefinitionRepository from "./agent/agent-definition-repository";
 export * as ChildExecutionRepository from "./child/child-execution-repository";
+export * as ChildFanOutRepository from "./child/child-fan-out-repository";
 export * as ClusterRegistryRepository from "./cluster/cluster-registry-repository";
 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 ExecutionEventRepository from "./execution/execution-event-repository";
 export * as ExecutionRepository from "./execution/execution-repository";
+export * as ExecutionStateRepository from "./state/execution-state-repository";
 export * as IdempotencyRepository from "./idempotency/idempotency-repository";
+export * as InboxRepository from "./inbox/inbox-repository";
+export * as TopicRepository from "./topic/topic-repository";
 export * as MemoryRepository from "./memory/memory-repository";
 export * as NotificationBus from "./database/notification-bus";
 export * as PermissionRuleRepository from "./permission/permission-rule-repository";
+export * as PresenceRepository from "./presence/presence-repository";
 export * as ContextEpochRepository from "./session/context-epoch-repository";
 export * as RelaySchema from "./schema/relay-schema";
 export * as ScheduleRepository from "./schedule/schedule-repository";
@@ -21,4 +28,5 @@ export * as SteeringRepository from "./steering/steering-repository";
 export * as ToolCallRepository from "./tool/tool-call-repository";
 export * as TenantId from "./tenant/tenant-id";
 export * as WorkspaceLeaseRepository from "./workspace/workspace-lease-repository";
+export * as WorkflowDefinitionRepository from "./workflow/workflow-definition-repository";
 export declare const storeSqlPackage = "./index";

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

@@ -0,0 +1,29 @@
+export * as AddressBookRepository from "./address/address-book-repository";
+export * as AgentChatRepository from "./chat/agent-chat-repository";
+export * as AgentDefinitionRepository from "./agent/agent-definition-repository";
+export * as ChildExecutionRepository from "./child/child-execution-repository";
+export * as ChildFanOutRepository from "./child/child-fan-out-repository";
+export * as ClusterRegistryRepository from "./cluster/cluster-registry-repository";
+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 ExecutionEventRepository from "./execution/execution-event-repository";
+export * as ExecutionRepository from "./execution/execution-repository";
+export * as ExecutionStateRepository from "./state/execution-state-repository";
+export * as IdempotencyRepository from "./idempotency/idempotency-repository";
+export * as InboxRepository from "./inbox/inbox-repository";
+export * as TopicRepository from "./topic/topic-repository";
+export * as MemoryRepository from "./memory/memory-repository";
+export * as NotificationBus from "./database/notification-bus";
+export * as PermissionRuleRepository from "./permission/permission-rule-repository";
+export * as PresenceRepository from "./presence/presence-repository";
+export * as ScheduleRepository from "./schedule/schedule-repository";
+export * as SessionRepository from "./session/session-repository";
+export * as SkillDefinitionRepository from "./skill/skill-definition-repository";
+export * as SqlDialect from "./database/sql-dialect";
+export * as SteeringRepository from "./steering/steering-repository";
+export * as TenantId from "./tenant/tenant-id";
+export * as ToolCallRepository from "./tool/tool-call-repository";
+export * as WorkspaceLeaseRepository from "./workspace/workspace-lease-repository";
+export * as WorkflowDefinitionRepository from "./workflow/workflow-definition-repository";

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

@@ -0,0 +1,51 @@
+import { Presence, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Service as NotificationBusService } from "../database/notification-bus";
+export declare const presenceChangedChannel = "relay_presence";
+declare const PresenceRepositoryError_base: Schema.Class<PresenceRepositoryError, Schema.TaggedStruct<"PresenceRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PresenceRepositoryError extends PresenceRepositoryError_base {
+}
+export interface HeartbeatInput {
+    readonly id: string;
+    readonly scope: Presence.Scope;
+    readonly metadata?: Shared.Metadata;
+    readonly connectedAt: number;
+    readonly expiresAt: number;
+}
+export interface RemoveInput {
+    readonly id: string;
+    readonly scope: Presence.Scope;
+}
+export interface ScopeInput {
+    readonly kind: Presence.Scope["kind"];
+    readonly id: string;
+}
+export interface PresenceRecord {
+    readonly id: string;
+    readonly scope: Presence.Scope;
+    readonly metadata: Shared.Metadata;
+    readonly connectedAt: number;
+    readonly expiresAt: number;
+}
+export interface Interface {
+    readonly upsertHeartbeat: (input: HeartbeatInput) => Effect.Effect<void, PresenceRepositoryError>;
+    readonly remove: (input: RemoveInput) => Effect.Effect<void, PresenceRepositoryError>;
+    readonly listByScope: (scope: ScopeInput) => Effect.Effect<ReadonlyArray<PresenceRecord>, PresenceRepositoryError>;
+    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>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, SqlClient | NotificationBusService>;
+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>;
+export declare const remove: (input: RemoveInput) => Effect.Effect<void, PresenceRepositoryError, Service>;
+export declare const listByScope: (scope: ScopeInput) => Effect.Effect<readonly PresenceRecord[], PresenceRepositoryError, Service>;
+export declare const notifyChanged: (scope: ScopeInput) => Effect.Effect<void, PresenceRepositoryError, Service>;
+export declare const changedSignals: (scope: ScopeInput) => Stream.Stream<void, PresenceRepositoryError, Service>;
+export {};