@relayfx/sdk 0.3.1 → 0.3.3

package/dist/postgres.js

@@ -1,22 +1,722 @@
 // @bun
 import {
-  normalizeClientLayer,
-  normalizeMigrationCause,
-  runtimeDatabaseLayer
-} from "./index-3sv8mmz5.js";
+  database,
+  normalizeMigrationCause
+} from "./index-49fm2rdv.js";
 import {
+  Dialect,
   RuntimeMigrationError,
-  SqlFailure
-} from "./index-9k4k3wq1.js";
-import"./index-c2skef55.js";
+  SqlFailure,
+  decodeBool,
+  decodeJson,
+  dialect,
+  encodeJson,
+  fromDbTimestamp,
+  fromNullableDbTimestamp,
+  timestampParam
+} from "./index-8pa5e2yn.js";
+import"./index-25gwk9tj.js";
+import {
+  exports_ids_schema
+} from "./index-cphmds30.js";
+import {
+  __export
+} from "./index-nb39b5ae.js";
 
 // src/postgres.ts
-import { PgClient } from "@effect/sql-pg/PgClient";
-import { makeWithDefaults } from "drizzle-orm/effect-postgres";
+import { PgClient as PgClient2 } from "@effect/sql-pg/PgClient";
+import { makeWithDefaults as makeWithDefaults2 } from "drizzle-orm/effect-postgres";
 import { migrate as runDrizzleMigrator } from "drizzle-orm/effect-postgres/migrator";
-import { Effect, Layer } from "effect";
+import { Effect as Effect2 } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 import { fileURLToPath } from "url";
+// ../store-sql/src/database/database-service.ts
+var exports_database_service = {};
+__export(exports_database_service, {
+  timestampParam: () => timestampParam,
+  testLayer: () => testLayer,
+  pgTypeParsers: () => pgTypeParsers,
+  layerFromPgClient: () => layerFromPgClient,
+  layer: () => layer,
+  fromPgDate: () => fromDbTimestamp,
+  fromNullablePgDate: () => fromNullableDbTimestamp,
+  fromNullableDbTimestamp: () => fromNullableDbTimestamp,
+  fromDbTimestamp: () => fromDbTimestamp,
+  encodeJson: () => encodeJson,
+  dialect: () => dialect,
+  decodeJson: () => decodeJson,
+  decodeBool: () => decodeBool,
+  check: () => check,
+  Service: () => Service,
+  PgClientLive: () => PgClientLive,
+  Dialect: () => Dialect
+});
+import { layerConfig as PgClientLayerConfig } from "@effect/sql-pg/PgClient";
+import { makeWithDefaults } from "drizzle-orm/effect-postgres";
+import { sql } from "drizzle-orm";
+import { Config, Context, Effect, Layer, Redacted } from "effect";
+import { types } from "pg";
+
+class Service extends Context.Service()("@relayfx/store-sql/database/database-service/Service") {
+}
+var pgTypeParsers = {
+  getTypeParser: (typeId, format) => {
+    if ([1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182].includes(typeId)) {
+      return (value) => value;
+    }
+    return types.getTypeParser(typeId, format);
+  }
+};
+var PgClientLive = PgClientLayerConfig({
+  url: Config.redacted("DATABASE_URL").pipe(Config.withDefault(Redacted.make("postgres://relay:relay@localhost:5545/relay"))),
+  maxConnections: Config.int("RELAY_SQL_MAX_CONNECTIONS").pipe(Config.withDefault(8)),
+  applicationName: Config.string("RELAY_SQL_APPLICATION_NAME").pipe(Config.withDefault("relay")),
+  types: Config.succeed(pgTypeParsers)
+});
+var layerFromPgClient = Layer.effect(Service, makeWithDefaults());
+var layer = layerFromPgClient.pipe(Layer.provide(PgClientLive));
+var testLayer = (db) => Layer.succeed(Service, db);
+var check = Effect.fn("Database.check")(function* () {
+  const db = yield* Service;
+  yield* db.execute(sql`select 1 as ok`).pipe(Effect.asVoid);
+});
+// ../store-sql/src/schema/relay-schema.ts
+import {
+  boolean,
+  doublePrecision,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+import { sql as sql2 } from "drizzle-orm";
+var tenantId = () => text("tenant_id").$type().notNull().default(exports_ids_schema.SystemTenantId);
+var relayWorkflowDefinitionRevisions = pgTable("relay_workflow_definition_revisions", {
+  tenantId: tenantId(),
+  workflowDefinitionId: text("workflow_definition_id").$type().notNull(),
+  revision: integer("revision").$type().notNull(),
+  digest: text("digest").$type().notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.workflowDefinitionId, table.revision] }),
+  uniqueIndex("uq_relay_workflow_definition_digest").on(table.tenantId, table.workflowDefinitionId, table.digest)
+]);
+var relayWorkflowRuns = pgTable("relay_workflow_runs", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  workflowDefinitionId: text("workflow_definition_id").$type().notNull(),
+  workflowDefinitionRevision: integer("workflow_definition_revision").$type().notNull(),
+  workflowDefinitionDigest: text("workflow_definition_digest").$type().notNull(),
+  status: text("status").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId] })]);
+var relayWorkflowOperationStates = pgTable("relay_workflow_operation_states", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  operationId: text("operation_id").$type().notNull(),
+  status: text("status").notNull(),
+  fanOutId: text("fan_out_id"),
+  decision: boolean("decision"),
+  outputJson: jsonb("output_json"),
+  attempt: integer("attempt"),
+  backoffUntil: timestamp("backoff_until", { withTimezone: true }),
+  compensationOperationId: text("compensation_operation_id"),
+  startedAt: timestamp("started_at", { withTimezone: true }),
+  completedAt: timestamp("completed_at", { withTimezone: true }),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId, table.operationId] })]);
+var relayWorkflowLifecycleEvents = pgTable("relay_workflow_lifecycle_events", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  sequence: integer("sequence").notNull(),
+  eventType: text("event_type").notNull(),
+  operationId: text("operation_id"),
+  dataJson: jsonb("data_json"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId, table.sequence] })]);
+var relayEntityKinds = pgTable("relay_entity_kinds", {
+  tenantId: tenantId(),
+  kind: text("kind").$type().notNull(),
+  agentId: text("agent_id").$type().notNull(),
+  inboxPolicyJson: jsonb("inbox_policy_json").$type(),
+  stateEnabled: integer("state_enabled").$type(),
+  continueAsNewAfterTurns: integer("continue_as_new_after_turns"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.kind], name: "pk_relay_entity_kinds" })]);
+var relayEntityInstances = pgTable("relay_entity_instances", {
+  tenantId: tenantId(),
+  kind: text("kind").$type().notNull(),
+  key: text("key").$type().notNull(),
+  addressId: text("address_id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  generation: integer("generation").notNull(),
+  status: text("status").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  destroyedAt: timestamp("destroyed_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.kind, table.key], name: "pk_relay_entity_instances" }),
+  index("idx_relay_entity_instances_kind_status").on(table.tenantId, table.kind, table.status)
+]);
+var relayAddressBookEntries = pgTable("relay_address_book_entries", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  addressId: text("address_id").$type().notNull(),
+  routeKind: text("route_kind").notNull(),
+  routeKey: text("route_key").notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_address_book_entries" }),
+  uniqueIndex("uq_relay_address_book_address").on(table.tenantId, table.addressId)
+]);
+var relayAgentDefinitions = pgTable("relay_agent_definitions", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  name: text("name").notNull(),
+  currentRevision: integer("current_revision").$type().notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_agent_definitions" }),
+  index("idx_relay_agent_definitions_name").on(table.tenantId, table.name)
+]);
+var relayAgentDefinitionRevisions = pgTable("relay_agent_revisions", {
+  tenantId: tenantId(),
+  agentId: text("agent_id").$type().notNull(),
+  revision: integer("revision").$type().notNull(),
+  name: text("name").notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.agentId, table.revision],
+    name: "pk_relay_agent_revisions"
+  }),
+  index("idx_relay_agent_revisions_definition").on(table.tenantId, table.agentId, table.revision)
+]);
+var relaySkillDefinitions = pgTable("relay_skill_definitions", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  name: text("name").notNull(),
+  currentRevision: integer("current_revision").$type().notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_skill_definitions" }),
+  index("idx_relay_skill_definitions_name").on(table.tenantId, table.name)
+]);
+var relaySkillDefinitionRevisions = pgTable("relay_skill_definition_revisions", {
+  tenantId: tenantId(),
+  skillDefinitionId: text("skill_definition_id").notNull().$type(),
+  revision: integer("revision").notNull().$type(),
+  name: text("name").notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.skillDefinitionId, table.revision],
+    name: "pk_relay_skill_definition_revisions"
+  }),
+  index("idx_relay_skill_definition_revisions_definition").on(table.tenantId, table.skillDefinitionId, table.revision)
+]);
+var relayExecutionSkillPins = pgTable("relay_execution_skill_pins", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").notNull().$type(),
+  skillDefinitionId: text("skill_definition_id").notNull().$type(),
+  skillDefinitionRevision: integer("skill_definition_revision").notNull().$type(),
+  skillDefinitionSnapshotJson: jsonb("skill_definition_snapshot_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.skillDefinitionId],
+    name: "pk_relay_execution_skill_pins"
+  }),
+  index("idx_relay_execution_skill_pins_execution").on(table.tenantId, table.executionId)
+]);
+var relayAgentChats = pgTable("relay_agent_chats", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  exportJson: jsonb("export_json").notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_agent_chats" })]);
+var relayExecutionState = pgTable("relay_execution_state", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  key: text("state_key").notNull(),
+  valueJson: jsonb("value_json").$type().notNull(),
+  version: integer("version").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.executionId, table.key], name: "pk_relay_execution_state" })
+]);
+var relayExecutionStateOps = pgTable("relay_execution_state_ops", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  idempotencyKey: text("idempotency_key").notNull(),
+  key: text("state_key").notNull(),
+  version: integer("version").notNull(),
+  op: text("op").notNull(),
+  resultPresent: boolean("result_present").notNull(),
+  resultValueJson: jsonb("result_value_json").$type(),
+  resultCreatedAt: timestamp("result_created_at", { withTimezone: true }),
+  resultUpdatedAt: timestamp("result_updated_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.idempotencyKey],
+    name: "pk_relay_execution_state_ops"
+  }),
+  index("idx_relay_execution_state_ops_version").on(table.tenantId, table.executionId, table.key, table.version)
+]);
+var relayAgentCompactions = pgTable("relay_agent_compactions", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").notNull().$type(),
+  checkpointId: text("checkpoint_id").notNull(),
+  summary: text("summary").notNull(),
+  firstKeptEntryId: text("first_kept_entry_id").$type().notNull(),
+  turn: integer("turn").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.checkpointId],
+    name: "pk_relay_agent_compactions"
+  }),
+  index("idx_relay_agent_compactions_execution_turn").on(table.tenantId, table.executionId, table.turn)
+]);
+var relayMemoryRecords = pgTable("relay_memory_records", {
+  tenantId: tenantId(),
+  id: text("id").notNull(),
+  agent: text("agent").notNull(),
+  subject: text("subject").$type().notNull(),
+  embedding: doublePrecision("embedding").array().notNull(),
+  partsJson: jsonb("parts_json").$type().notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_memory_records" }),
+  index("idx_relay_memory_records_agent_subject").on(table.tenantId, table.agent, table.subject)
+]);
+var relayPermissionRules = pgTable("relay_permission_rules", {
+  tenantId: tenantId(),
+  agent: text("agent").notNull(),
+  scope: text("scope").notNull(),
+  pattern: text("pattern").notNull(),
+  ruleJson: jsonb("rule_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.agent, table.scope, table.pattern],
+    name: "pk_relay_permission_rules"
+  }),
+  index("idx_relay_permission_rules_agent_scope").on(table.tenantId, table.agent, table.scope)
+]);
+var relaySteeringMessages = pgTable("relay_steering_messages", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").notNull(),
+  kind: text("kind").notNull(),
+  sequence: integer("sequence").notNull(),
+  contentJson: jsonb("content_json").$type().notNull(),
+  drainId: text("drain_id"),
+  consumedAt: timestamp("consumed_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.kind, table.sequence],
+    name: "pk_relay_steering_messages"
+  }),
+  index("idx_relay_steering_messages_unconsumed").on(table.tenantId, table.executionId, table.kind, table.consumedAt, table.sequence),
+  index("idx_relay_steering_messages_drain").on(table.tenantId, table.executionId, table.kind, table.drainId, table.sequence)
+]);
+var relaySteeringDrains = pgTable("relay_steering_drains", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").notNull(),
+  kind: text("kind").notNull(),
+  drainId: text("drain_id").notNull(),
+  messageSequencesJson: jsonb("message_sequences_json").$type().notNull().default([]),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.kind, table.drainId],
+    name: "pk_relay_steering_drains"
+  })
+]);
+var relayInboxMessages = pgTable("relay_inbox_messages", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  sequence: integer("sequence").notNull(),
+  fromAddressId: text("from_address_id").$type().notNull(),
+  envelopeId: text("envelope_id").$type(),
+  contentJson: jsonb("content_json").$type().notNull(),
+  replyWaitId: text("reply_wait_id").$type(),
+  correlationKey: text("correlation_key"),
+  idempotencyKey: text("idempotency_key"),
+  drainId: text("drain_id"),
+  consumedAt: timestamp("consumed_at", { withTimezone: true }),
+  metadataJson: jsonb("metadata_json").$type(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.executionId, table.sequence], name: "pk_relay_inbox_messages" }),
+  uniqueIndex("uq_relay_inbox_messages_idempotency").on(table.tenantId, table.executionId, table.idempotencyKey),
+  index("idx_relay_inbox_messages_unconsumed").on(table.tenantId, table.executionId, table.consumedAt, table.sequence),
+  index("idx_relay_inbox_messages_drain").on(table.tenantId, table.executionId, table.drainId, table.sequence)
+]);
+var relayInboxDrains = pgTable("relay_inbox_drains", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  drainId: text("drain_id").notNull(),
+  messageSequencesJson: jsonb("message_sequences_json").$type().notNull().default([]),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.executionId, table.drainId], name: "pk_relay_inbox_drains" })
+]);
+var relayTopicSubscriptions = pgTable("relay_topic_subscriptions", {
+  tenantId: tenantId(),
+  topicAddressId: text("topic_address_id").$type().notNull(),
+  subscriberExecutionId: text("subscriber_execution_id").$type().notNull(),
+  metadataJson: jsonb("metadata_json").$type(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.topicAddressId, table.subscriberExecutionId],
+    name: "pk_relay_topic_subscriptions"
+  }),
+  index("idx_relay_topic_subscriptions_subscriber").on(table.tenantId, table.subscriberExecutionId)
+]);
+var relaySessions = pgTable("relay_sessions", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  rootAddressId: text("root_address_id").$type().notNull(),
+  leafEntryId: text("leaf_entry_id").$type(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_sessions" }),
+  index("idx_relay_sessions_updated_id").on(table.tenantId, table.updatedAt, table.id),
+  index("idx_relay_sessions_root_updated_id").on(table.tenantId, table.rootAddressId, table.updatedAt, table.id)
+]);
+var relaySessionEntries = pgTable("relay_session_entries", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  sessionId: text("session_id").$type().notNull(),
+  parentId: text("parent_id").$type(),
+  tag: text("tag").notNull(),
+  payloadJson: jsonb("payload_json").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_session_entries" }),
+  index("idx_relay_session_entries_session_created").on(table.tenantId, table.sessionId, table.createdAt, table.id),
+  index("idx_relay_session_entries_session_parent").on(table.tenantId, table.sessionId, table.parentId)
+]);
+var relayExecutionContextEpochs = pgTable("relay_execution_context_epochs", {
+  tenantId: tenantId(),
+  executionId: text("execution_id").$type().notNull(),
+  baseline: text("baseline").notNull(),
+  dynamicSourceIdsJson: jsonb("dynamic_source_ids_json").$type().notNull().default([]),
+  openedAt: timestamp("opened_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_execution_context_epochs" })]);
+var relayExecutions = pgTable("relay_executions", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  rootAddressId: text("root_address_id").$type().notNull(),
+  sessionId: text("session_id").$type(),
+  status: text("status").$type().notNull(),
+  agentId: text("agent_id").$type(),
+  agentRevision: integer("agent_revision").$type(),
+  agentSnapshotJson: jsonb("agent_snapshot_json").$type(),
+  agentToolInputSchemaDigestsJson: jsonb("agent_tool_input_schema_digests_json").$type().notNull().default({}),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_executions" }),
+  index("idx_relay_executions_root_status").on(table.tenantId, table.rootAddressId, table.status),
+  index("idx_relay_executions_session_updated_id").on(table.tenantId, table.sessionId, table.updatedAt, table.id),
+  index("idx_relay_executions_updated_id").on(table.tenantId, table.updatedAt, table.id),
+  index("idx_relay_executions_root_status_updated_id").on(table.tenantId, table.rootAddressId, table.status, table.updatedAt, table.id)
+]);
+var relayChildExecutions = pgTable("relay_child_executions", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  addressId: text("address_id").$type().notNull(),
+  status: text("status").$type().notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_child_executions" }),
+  index("idx_relay_child_executions_parent").on(table.tenantId, table.executionId)
+]);
+var relayChildFanOuts = pgTable("relay_child_fan_outs", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  parentExecutionId: text("parent_execution_id").$type().notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  state: text("state").$type().notNull().default("joining"),
+  satisfiedAt: timestamp("satisfied_at", { withTimezone: true }),
+  failedAt: timestamp("failed_at", { withTimezone: true }),
+  cancelledAt: timestamp("cancelled_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_child_fan_outs" }),
+  index("idx_relay_child_fan_outs_parent").on(table.tenantId, table.parentExecutionId)
+]);
+var relayChildFanOutMembers = pgTable("relay_child_fan_out_members", {
+  tenantId: tenantId(),
+  fanOutId: text("fan_out_id").$type().notNull(),
+  childExecutionId: text("child_execution_id").$type().notNull(),
+  ordinal: integer("ordinal").notNull(),
+  state: text("state").$type().notNull().default("queued"),
+  outputJson: jsonb("output_json").$type(),
+  error: text("error"),
+  completedAt: timestamp("completed_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.fanOutId, table.childExecutionId],
+    name: "pk_relay_child_fan_out_members"
+  }),
+  uniqueIndex("uq_relay_child_fan_out_member_ordinal").on(table.tenantId, table.fanOutId, table.ordinal)
+]);
+var relayEnvelopes = pgTable("relay_envelopes", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  fromAddressId: text("from_address_id").$type().notNull(),
+  toAddressId: text("to_address_id").$type().notNull(),
+  contentJson: jsonb("content_json").$type().notNull(),
+  waitJson: jsonb("wait_json").$type(),
+  correlationKey: text("correlation_key"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelopes" }),
+  index("idx_relay_envelopes_execution").on(table.tenantId, table.executionId, table.createdAt),
+  index("idx_relay_envelopes_to_address").on(table.tenantId, table.toAddressId, table.createdAt)
+]);
+var relayWaits = pgTable("relay_waits", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  envelopeId: text("envelope_id").$type(),
+  mode: text("mode").$type().notNull(),
+  correlationKey: text("correlation_key"),
+  state: text("state").notNull().default("open"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  resolvedAt: timestamp("resolved_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_waits" }),
+  index("idx_relay_waits_execution_state").on(table.tenantId, table.executionId, table.state)
+]);
+var relayWorkspaceLeases = pgTable("relay_workspace_leases", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  providerKey: text("provider_key").$type().notNull(),
+  sandboxRef: text("sandbox_ref").$type(),
+  latestSnapshotRef: text("latest_snapshot_ref").$type(),
+  status: text("status").$type().notNull(),
+  resumeStrategy: text("resume_strategy").$type().notNull(),
+  region: text("region"),
+  requestJson: jsonb("request_json").$type(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_leases" }),
+  uniqueIndex("uq_relay_workspace_leases_active_execution").on(table.tenantId, table.executionId).where(sql2`${table.status} not in ('released', 'failed')`),
+  index("idx_relay_workspace_leases_execution").on(table.tenantId, table.executionId),
+  index("idx_relay_workspace_leases_status_updated").on(table.tenantId, table.status, table.updatedAt)
+]);
+var relayWorkspaceSnapshots = pgTable("relay_workspace_snapshots", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  leaseId: text("lease_id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  reason: text("reason").$type().notNull(),
+  snapshotRef: text("snapshot_ref").$type().notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_snapshots" }),
+  index("idx_relay_workspace_snapshots_lease").on(table.tenantId, table.leaseId, table.createdAt),
+  index("idx_relay_workspace_snapshots_execution").on(table.tenantId, table.executionId, table.createdAt)
+]);
+var relayEnvelopeReady = pgTable("relay_envelope_ready", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  envelopeId: text("envelope_id").$type().notNull(),
+  routeType: text("route_type").notNull(),
+  routeKey: text("route_key").notNull(),
+  state: text("state").notNull().default("ready"),
+  availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
+  attempt: integer("attempt").notNull().default(0),
+  claimOwner: text("claim_owner"),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  lastError: text("last_error"),
+  idempotencyKey: text("idempotency_key"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  claimedAt: timestamp("claimed_at", { withTimezone: true }),
+  acknowledgedAt: timestamp("acknowledged_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelope_ready" }),
+  index("idx_relay_envelope_ready_state_available").on(table.tenantId, table.state, table.availableAt),
+  index("idx_relay_envelope_ready_claim_expires").on(table.tenantId, table.claimExpiresAt),
+  uniqueIndex("uq_relay_envelope_ready_idempotency").on(table.tenantId, table.idempotencyKey)
+]);
+var relaySchedules = pgTable("relay_schedules", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  kind: text("kind").notNull(),
+  targetKind: text("target_kind").notNull(),
+  addressId: text("address_id").$type(),
+  waitId: text("wait_id").$type(),
+  cronExpr: text("cron_expr"),
+  inputJson: jsonb("input_json").$type(),
+  state: text("state").notNull().default("active"),
+  nextRunAt: timestamp("next_run_at", { withTimezone: true }).notNull(),
+  attempt: integer("attempt").notNull().default(0),
+  claimOwner: text("claim_owner"),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  lastError: text("last_error"),
+  idempotencyKey: text("idempotency_key"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_schedules" }),
+  index("idx_relay_schedules_state_next_run").on(table.tenantId, table.state, table.nextRunAt),
+  index("idx_relay_schedules_claim_expires").on(table.tenantId, table.claimExpiresAt),
+  index("idx_relay_schedules_wait").on(table.tenantId, table.waitId),
+  uniqueIndex("uq_relay_schedules_idempotency").on(table.tenantId, table.idempotencyKey)
+]);
+var relayExecutionEvents = pgTable("relay_execution_events", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  childExecutionId: text("child_execution_id").$type(),
+  type: text("type").notNull(),
+  sequence: integer("sequence").notNull(),
+  cursor: text("cursor").notNull(),
+  contentJson: jsonb("content_json").$type(),
+  dataJson: jsonb("data_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_execution_events" }),
+  index("idx_relay_execution_events_execution").on(table.tenantId, table.executionId, table.createdAt),
+  uniqueIndex("uq_relay_execution_events_sequence").on(table.tenantId, table.executionId, table.sequence),
+  uniqueIndex("uq_relay_execution_events_cursor").on(table.tenantId, table.cursor)
+]);
+var relayPresence = pgTable("relay_presence", {
+  tenantId: tenantId(),
+  id: text("id").notNull(),
+  scopeKind: text("scope_kind").$type().notNull(),
+  scopeId: text("scope_id").notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  connectedAt: timestamp("connected_at", { withTimezone: true }).notNull().defaultNow(),
+  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id, table.scopeKind, table.scopeId], name: "pk_relay_presence" }),
+  index("idx_relay_presence_scope_expires").on(table.tenantId, table.scopeKind, table.scopeId, table.expiresAt)
+]);
+var relayToolCalls = pgTable("relay_tool_calls", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  executionId: text("execution_id").$type().notNull(),
+  name: text("name").notNull(),
+  inputJson: jsonb("input_json").notNull(),
+  definitionJson: jsonb("definition_json").$type(),
+  placementKind: text("placement_kind").$type().notNull().default("local"),
+  placementKey: text("placement_key"),
+  state: text("state").$type().notNull().default("requested"),
+  waitId: text("wait_id").$type(),
+  idempotencyKey: text("idempotency_key").notNull(),
+  availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
+  activeAttemptId: text("active_attempt_id").$type(),
+  claimOwner: text("claim_owner"),
+  claimedAt: timestamp("claimed_at", { withTimezone: true }),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  externalOutcomeJson: jsonb("external_outcome_json").$type(),
+  externalOutcomeAt: timestamp("external_outcome_at", { withTimezone: true }),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_tool_calls" }),
+  index("idx_relay_tool_calls_execution").on(table.tenantId, table.executionId, table.createdAt),
+  index("idx_relay_tool_calls_remote_claim").on(table.tenantId, table.placementKind, table.placementKey, table.state, table.availableAt, table.createdAt, table.id),
+  index("idx_relay_tool_calls_stale_claim").on(table.tenantId, table.state, table.claimExpiresAt),
+  index("idx_relay_tool_calls_client_pending").on(table.tenantId, table.placementKind, table.state, table.createdAt, table.id)
+]);
+var relayToolAttempts = pgTable("relay_tool_attempts", {
+  tenantId: tenantId(),
+  id: text("id").$type().notNull(),
+  toolCallId: text("tool_call_id").$type().notNull(),
+  attemptNumber: integer("attempt_number").notNull(),
+  state: text("state").$type().notNull(),
+  workerId: text("worker_id"),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  error: text("error"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  completedAt: timestamp("completed_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.toolCallId, table.id], name: "pk_relay_tool_attempts" }),
+  uniqueIndex("uq_relay_tool_attempts_number").on(table.tenantId, table.toolCallId, table.attemptNumber),
+  index("idx_relay_tool_attempts_call").on(table.tenantId, table.toolCallId, table.attemptNumber)
+]);
+var relayToolResults = pgTable("relay_tool_results", {
+  tenantId: tenantId(),
+  toolCallId: text("tool_call_id").$type().notNull(),
+  outputJson: jsonb("output_json").notNull(),
+  error: text("error"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.toolCallId], name: "pk_relay_tool_results" })]);
+var relayRouteAttempts = pgTable("relay_route_attempts", {
+  tenantId: tenantId(),
+  id: text("id").notNull(),
+  envelopeReadyId: text("envelope_ready_id").$type().notNull(),
+  routeKey: text("route_key").notNull(),
+  state: text("state").notNull(),
+  detail: text("detail"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_route_attempts" }),
+  index("idx_relay_route_attempts_ready").on(table.tenantId, table.envelopeReadyId, table.createdAt)
+]);
+var relayIdempotencyKeys = pgTable("relay_idempotency_keys", {
+  tenantId: tenantId(),
+  id: text("id").notNull(),
+  scope: text("scope").notNull(),
+  operation: text("operation").notNull(),
+  key: text("key").notNull(),
+  resultJson: jsonb("result_json").$type(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  expiresAt: timestamp("expires_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_idempotency_keys" }),
+  uniqueIndex("uq_relay_idempotency_scope_operation_key").on(table.tenantId, table.scope, table.operation, table.key)
+]);
+// src/postgres.ts
 var schemaHead = "20260712200000_workflow_runtime";
 var migrationNames = [
   "20260701002839_sour_cerebro",
@@ -47,9 +747,9 @@ var migrationNames = [
 ];
 var migrationsFolderUrl = import.meta.url.endsWith("/src/postgres.ts") ? new URL("../../../migrations/pg", import.meta.url) : new URL("./migrations/pg", import.meta.url);
 var migrationsFolder = fileURLToPath(migrationsFolderUrl);
-var verifySchema = Effect.gen(function* () {
-  const sql = yield* SqlClient;
-  const rows = yield* sql`SELECT name FROM drizzle.__drizzle_migrations ORDER BY id`;
+var verifySchema = Effect2.gen(function* () {
+  const sql3 = yield* SqlClient;
+  const rows = yield* sql3`SELECT name FROM drizzle.__drizzle_migrations ORDER BY id`;
   const actual = rows.map((row) => row.name).join(",");
   const expected = migrationNames.join(",");
   if (actual !== expected) {
@@ -61,22 +761,22 @@ var verifySchema = Effect.gen(function* () {
     });
   }
 }).pipe((effect) => normalizeMigrationCause(effect, "pg", "verify"));
-var runtimeDatabaseLayer2 = (options) => runtimeDatabaseLayer({
+var runMigrations = normalizeMigrationCause(Effect2.gen(function* () {
+  const sql3 = yield* SqlClient;
+  const pg = sql3;
+  const database2 = yield* makeWithDefaults2().pipe(Effect2.provideService(PgClient2, pg));
+  yield* runDrizzleMigrator(database2, { migrationsFolder });
+}), "pg", "apply");
+var database2 = (options) => database({
   ...options,
   dialect: "pg",
   ownership: "shared-multi-node",
   schemaHead,
-  schema: verifySchema
+  acquire: verifySchema,
+  verify: verifySchema,
+  migrate: runMigrations.pipe(Effect2.andThen(verifySchema))
 });
-var migrate = (options) => Effect.scoped(Layer.build(normalizeClientLayer(options.clientLayer)).pipe(Effect.flatMap((context) => Effect.provide(normalizeMigrationCause(Effect.gen(function* () {
-  const sql = yield* SqlClient;
-  const pg = sql;
-  const database = yield* makeWithDefaults().pipe(Effect.provideService(PgClient, pg));
-  yield* runDrizzleMigrator(database, { migrationsFolder });
-}), "pg", "apply").pipe(Effect.andThen(normalizeMigrationCause(verifySchema, "pg", "verify"))), context)))).pipe(Effect.asVoid);
-var Postgres = { runtimeDatabaseLayer: runtimeDatabaseLayer2, migrate };
+var Postgres = { database: database2, pgTypeParsers: exports_database_service.pgTypeParsers };
 export {
-  runtimeDatabaseLayer2 as runtimeDatabaseLayer,
-  migrate,
   Postgres
 };