@pattern-stack/codegen 0.4.4 → 0.4.5

package/dist/runtime/subsystems/observability/index.js

@@ -0,0 +1,895 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index5, decorator) => (target, key) => decorator(target, key, index5);
+
+// runtime/constants/tokens.ts
+var DRIZZLE;
+var init_tokens = __esm({
+  "runtime/constants/tokens.ts"() {
+    "use strict";
+    DRIZZLE = "DRIZZLE";
+  }
+});
+
+// runtime/subsystems/jobs/job-orchestration.schema.ts
+import {
+  pgEnum,
+  pgTable,
+  uuid,
+  text,
+  jsonb,
+  integer,
+  timestamp,
+  index,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+var jobRunStatusEnum, jobStepKindEnum, jobStepStatusEnum, collisionModeEnum, replayFromEnum, parentClosePolicyEnum, waitKindEnum, triggerSourceEnum, jobs, jobRuns, jobSteps;
+var init_job_orchestration_schema = __esm({
+  "runtime/subsystems/jobs/job-orchestration.schema.ts"() {
+    "use strict";
+    jobRunStatusEnum = pgEnum("job_run_status", [
+      "pending",
+      "running",
+      "waiting",
+      "completed",
+      "failed",
+      "timed_out",
+      "canceled"
+    ]);
+    jobStepKindEnum = pgEnum("job_step_kind", ["task"]);
+    jobStepStatusEnum = pgEnum("job_step_status", [
+      "pending",
+      "running",
+      "completed",
+      "failed",
+      "skipped"
+    ]);
+    collisionModeEnum = pgEnum("job_collision_mode", [
+      "queue",
+      "reject",
+      "replace"
+    ]);
+    replayFromEnum = pgEnum("job_replay_from", [
+      "scratch",
+      "last_step",
+      "last_checkpoint"
+    ]);
+    parentClosePolicyEnum = pgEnum("job_parent_close_policy", [
+      "terminate",
+      "cancel",
+      "abandon"
+    ]);
+    waitKindEnum = pgEnum("job_wait_kind", ["signal"]);
+    triggerSourceEnum = pgEnum("job_trigger_source", [
+      "manual",
+      "schedule",
+      "event",
+      "parent"
+    ]);
+    jobs = pgTable("job", {
+      type: text("type").primaryKey(),
+      version: integer("version").notNull().default(1),
+      pool: text("pool").notNull(),
+      scopeEntityType: text("scope_entity_type"),
+      retryPolicy: jsonb("retry_policy").notNull().$type(),
+      timeoutMs: integer("timeout_ms"),
+      concurrencyKeyTemplate: text("concurrency_key_template"),
+      collisionMode: collisionModeEnum("collision_mode").notNull().default("queue"),
+      dedupeKeyTemplate: text("dedupe_key_template"),
+      dedupeWindowMs: integer("dedupe_window_ms"),
+      priorityDefault: integer("priority_default").notNull().default(0),
+      replayFrom: replayFromEnum("replay_from").notNull().default("last_checkpoint"),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+    });
+    jobRuns = pgTable(
+      "job_run",
+      {
+        id: uuid("id").primaryKey().defaultRandom(),
+        jobType: text("job_type").notNull().references(() => jobs.type),
+        jobVersion: integer("job_version").notNull(),
+        parentRunId: uuid("parent_run_id").references(() => jobRuns.id),
+        /**
+         * Service generates `id` client-side via randomUUID() and sets
+         * root_run_id = id for root runs (single INSERT, no self-FK race).
+         */
+        rootRunId: uuid("root_run_id").notNull(),
+        parentClosePolicy: parentClosePolicyEnum("parent_close_policy").notNull().default("terminate"),
+        scopeEntityType: text("scope_entity_type"),
+        scopeEntityId: text("scope_entity_id"),
+        tenantId: text("tenant_id"),
+        tags: jsonb("tags").notNull().default({}).$type(),
+        pool: text("pool").notNull(),
+        priority: integer("priority").notNull().default(0),
+        concurrencyKey: text("concurrency_key"),
+        dedupeKey: text("dedupe_key"),
+        status: jobRunStatusEnum("status").notNull().default("pending"),
+        input: jsonb("input").notNull().$type(),
+        output: jsonb("output").$type(),
+        error: jsonb("error").$type(),
+        triggerSource: triggerSourceEnum("trigger_source").notNull(),
+        triggerRef: text("trigger_ref"),
+        runAt: timestamp("run_at", { withTimezone: true }).notNull().defaultNow(),
+        startedAt: timestamp("started_at", { withTimezone: true }),
+        finishedAt: timestamp("finished_at", { withTimezone: true }),
+        claimedAt: timestamp("claimed_at", { withTimezone: true }),
+        attempts: integer("attempts").notNull().default(0),
+        // Phase 3 placeholder — see ADR-025
+        waitKind: waitKindEnum("wait_kind"),
+        // Phase 3 placeholder — see ADR-025
+        resumeToken: text("resume_token"),
+        // Phase 3 placeholder — see ADR-025
+        waitDeadline: timestamp("wait_deadline", { withTimezone: true }),
+        createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+      },
+      (t) => ({
+        /** Claim query: ORDER BY priority DESC, run_at ASC. */
+        idxJobRunClaim: index("idx_job_run_claim").on(t.status, t.pool, t.runAt),
+        /** Tree traversal / cascade cancel. */
+        idxJobRunRoot: index("idx_job_run_root").on(t.rootRunId),
+        /** listForScope query. */
+        idxJobRunScope: index("idx_job_run_scope").on(t.scopeEntityType, t.scopeEntityId),
+        /** Idempotency collapse — partial index. */
+        idxJobRunDedupe: index("idx_job_run_dedupe").on(t.jobType, t.dedupeKey).where(sql`${t.dedupeKey} IS NOT NULL`),
+        /** Collision check — partial index. */
+        idxJobRunConcurrency: index("idx_job_run_concurrency").on(t.concurrencyKey).where(
+          sql`${t.concurrencyKey} IS NOT NULL AND ${t.status} IN ('pending','running')`
+        )
+      })
+    );
+    jobSteps = pgTable(
+      "job_step",
+      {
+        id: uuid("id").primaryKey().defaultRandom(),
+        jobRunId: uuid("job_run_id").notNull().references(() => jobRuns.id),
+        stepId: text("step_id").notNull(),
+        kind: jobStepKindEnum("kind").notNull().default("task"),
+        /**
+         * Monotonic within run. integer (max ~2B per run) is sufficient —
+         * downgraded from ADR-022's bigint; revisit only if a single run
+         * ever exceeds 2 billion steps.
+         */
+        seq: integer("seq").notNull(),
+        status: jobStepStatusEnum("status").notNull().default("pending"),
+        input: jsonb("input").$type(),
+        /** Memoised on success for replay. */
+        output: jsonb("output").$type(),
+        error: jsonb("error").$type(),
+        attempts: integer("attempts").notNull().default(0),
+        startedAt: timestamp("started_at", { withTimezone: true }),
+        finishedAt: timestamp("finished_at", { withTimezone: true })
+      },
+      (t) => ({
+        /** No duplicate step IDs per run. */
+        idxJobStepRunStep: uniqueIndex("idx_job_step_run_step").on(t.jobRunId, t.stepId),
+        /** Ordered timeline reads. */
+        idxJobStepTimeline: index("idx_job_step_timeline").on(t.jobRunId, t.seq)
+      })
+    );
+  }
+});
+
+// runtime/subsystems/events/domain-events.schema.ts
+import {
+  index as index3,
+  jsonb as jsonb3,
+  pgTable as pgTable3,
+  text as text3,
+  timestamp as timestamp3,
+  uuid as uuid3
+} from "drizzle-orm/pg-core";
+var domainEvents;
+var init_domain_events_schema = __esm({
+  "runtime/subsystems/events/domain-events.schema.ts"() {
+    "use strict";
+    domainEvents = pgTable3(
+      "domain_events",
+      {
+        id: uuid3("id").primaryKey(),
+        type: text3("type").notNull(),
+        aggregateId: text3("aggregate_id").notNull(),
+        aggregateType: text3("aggregate_type").notNull(),
+        payload: jsonb3("payload").notNull().$type(),
+        occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull(),
+        processedAt: timestamp3("processed_at", { withTimezone: true }),
+        /** Lifecycle status: pending | processed | failed */
+        status: text3("status").notNull().default("pending"),
+        /** Error message from the last failed dispatch attempt. */
+        error: text3("error"),
+        metadata: jsonb3("metadata").$type(),
+        /** Routing pool (e.g. `events_inbound`, `events_change`, `events_outbound`). Populated by DrizzleEventBus.publish() in EVT-4. */
+        pool: text3("pool"),
+        /** Routing direction: `inbound` | `change` | `outbound`. Populated by DrizzleEventBus.publish() in EVT-4. */
+        direction: text3("direction"),
+        // conditional: emitted only when events.multi_tenant: true
+        tenantId: text3("tenant_id")
+      },
+      (t) => ({
+        /** Polling drain filter (existing — promoted from comment to declaration in EVT-1). */
+        idxDomainEventsStatusOccurredAt: index3("idx_domain_events_status_occurred_at").on(
+          t.status,
+          t.occurredAt
+        ),
+        /** Event replay per aggregate (existing — promoted from comment to declaration in EVT-1). */
+        idxDomainEventsAggregate: index3("idx_domain_events_aggregate").on(
+          t.aggregateId,
+          t.aggregateType
+        ),
+        /** Per-pool drain filter (EVT-1). Enables DrizzleEventBus to drain a single pool without scanning all events. */
+        idxDomainEventsPoolStatusOccurredAt: index3(
+          "idx_domain_events_pool_status_occurred_at"
+        ).on(t.pool, t.status, t.occurredAt)
+      })
+    );
+  }
+});
+
+// runtime/subsystems/bridge/bridge-delivery.schema.ts
+import {
+  index as index4,
+  jsonb as jsonb4,
+  pgEnum as pgEnum3,
+  pgTable as pgTable4,
+  text as text4,
+  timestamp as timestamp4,
+  unique,
+  uuid as uuid4
+} from "drizzle-orm/pg-core";
+import { sql as sql3 } from "drizzle-orm";
+var bridgeDeliveryStatusEnum, bridgeDelivery;
+var init_bridge_delivery_schema = __esm({
+  "runtime/subsystems/bridge/bridge-delivery.schema.ts"() {
+    "use strict";
+    init_domain_events_schema();
+    init_job_orchestration_schema();
+    bridgeDeliveryStatusEnum = pgEnum3("bridge_delivery_status", [
+      "pending",
+      "delivered",
+      "skipped",
+      "failed"
+    ]);
+    bridgeDelivery = pgTable4(
+      "bridge_delivery",
+      {
+        id: uuid4("id").primaryKey().defaultRandom(),
+        /** FK to the source event in the outbox. */
+        eventId: uuid4("event_id").notNull().references(() => domainEvents.id),
+        /**
+         * Stable codegen-emitted identifier for the (job, trigger) pair, of the
+         * form `<job_type>#<triggerIndex>` (BRIDGE-6). Forms the second half of
+         * the UNIQUE idempotency key.
+         */
+        triggerId: text4("trigger_id").notNull(),
+        /**
+         * Wrapper `job_run.id` (the framework `@framework/bridge_delivery` run
+         * that drove this delivery). Nullable: the facade-eager path
+         * (`publishAndStart` Case B) pre-writes a delivered row with no wrapper.
+         */
+        wrapperRunId: uuid4("wrapper_run_id").references(() => jobRuns.id),
+        /**
+         * Spawned user `job_run.id`. Null until status is `delivered`; remains
+         * null for `skipped` and `failed` deliveries.
+         */
+        userRunId: uuid4("user_run_id").references(() => jobRuns.id),
+        status: bridgeDeliveryStatusEnum("status").notNull().default("pending"),
+        /** Populated when status=`skipped` (e.g. `'when_returned_false'`, `'trigger_unregistered'`). */
+        skipReason: text4("skip_reason"),
+        /** Populated when status=`failed`. Mirrors `job_run.error` shape. */
+        error: jsonb4("error").$type(),
+        /**
+         * Emitted unconditionally and nullable (JOB-8 / SYNC-6 precedent).
+         * Enforcement gated on `BRIDGE_MULTI_TENANT` at the service layer
+         * (BRIDGE-8); no DB constraint.
+         */
+        tenantId: text4("tenant_id"),
+        attemptedAt: timestamp4("attempted_at", { withTimezone: true }).notNull().defaultNow(),
+        deliveredAt: timestamp4("delivered_at", { withTimezone: true })
+      },
+      (t) => ({
+        /**
+         * Idempotency ledger. Outbox replays and facade-vs-drain collisions both
+         * dedup through this constraint.
+         */
+        uqBridgeDeliveryEventTrigger: unique("uq_bridge_delivery_event_trigger").on(
+          t.eventId,
+          t.triggerId
+        ),
+        /** Lookup all deliveries for an event (fanout report, debugging). */
+        idxBridgeDeliveryEvent: index4("idx_bridge_delivery_event").on(t.eventId),
+        /**
+         * Ops dashboard filter — only the actionable states. Partial index keeps
+         * it small at scale (the bulk of rows will be `delivered`).
+         */
+        idxBridgeDeliveryStatus: index4("idx_bridge_delivery_status").on(t.status).where(sql3`${t.status} IN ('pending','failed')`),
+        /**
+         * Reverse lookup from a spawned user run back to its delivery row.
+         * Partial — most rows in the bridge ledger but only successful
+         * deliveries have a `user_run_id`.
+         */
+        idxBridgeDeliveryUserRun: index4("idx_bridge_delivery_user_run").on(t.userRunId).where(sql3`${t.userRunId} IS NOT NULL`)
+      })
+    );
+  }
+});
+
+// runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts
+var bridge_metrics_reporter_exports = {};
+__export(bridge_metrics_reporter_exports, {
+  BridgeMetricsReporter: () => BridgeMetricsReporter
+});
+import {
+  Inject as Inject2,
+  Injectable as Injectable3,
+  Logger
+} from "@nestjs/common";
+import { and, eq as eq2, gt, sql as sql4 } from "drizzle-orm";
+var INTERVAL_NAME, DEFAULT_INTERVAL_MS, MIN_INTERVAL_MS, BridgeMetricsReporter;
+var init_bridge_metrics_reporter = __esm({
+  "runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts"() {
+    "use strict";
+    init_tokens();
+    init_bridge_delivery_schema();
+    init_domain_events_schema();
+    INTERVAL_NAME = "bridge-metrics-tick";
+    DEFAULT_INTERVAL_MS = 6e4;
+    MIN_INTERVAL_MS = 1e3;
+    BridgeMetricsReporter = class {
+      constructor(db, scheduler) {
+        this.db = db;
+        this.scheduler = scheduler;
+        this.intervalMs = this.resolveIntervalMs();
+        this.lastTickAt = /* @__PURE__ */ new Date();
+      }
+      db;
+      scheduler;
+      logger = new Logger(BridgeMetricsReporter.name);
+      intervalMs;
+      lastTickAt;
+      onModuleInit() {
+        this.logger.log(
+          `BridgeMetricsReporter starting (intervalMs=${this.intervalMs}).`
+        );
+        const timer = setInterval(() => {
+          void this.tick();
+        }, this.intervalMs);
+        timer.unref?.();
+        this.scheduler.addInterval(INTERVAL_NAME, timer);
+      }
+      onModuleDestroy() {
+        if (this.scheduler.getIntervals().includes(INTERVAL_NAME)) {
+          this.scheduler.deleteInterval(INTERVAL_NAME);
+        }
+      }
+      /**
+       * Run one sampling tick. Public so tests can drive it deterministically
+       * without waiting on the timer.
+       */
+      async tick() {
+        const windowStart = this.lastTickAt;
+        const windowEnd = /* @__PURE__ */ new Date();
+        this.lastTickAt = windowEnd;
+        let rows = [];
+        try {
+          rows = await this.sample(windowStart, windowEnd);
+        } catch (err) {
+          this.logger.error(
+            `bridge metrics sample failed: ${err.message}`
+          );
+          return { windowStart, windowEnd, rows: [] };
+        }
+        this.emit({ windowStart, windowEnd, rows });
+        return { windowStart, windowEnd, rows };
+      }
+      async sample(windowStart, windowEnd) {
+        const lastTransition = sql4`COALESCE(${bridgeDelivery.deliveredAt}, ${bridgeDelivery.attemptedAt})`;
+        const result = await this.db.select({
+          status: bridgeDelivery.status,
+          eventType: domainEvents.type,
+          skipReason: bridgeDelivery.skipReason,
+          count: sql4`COUNT(*)::int`
+        }).from(bridgeDelivery).innerJoin(domainEvents, eq2(bridgeDelivery.eventId, domainEvents.id)).where(
+          and(
+            gt(lastTransition, windowStart),
+            sql4`${lastTransition} <= ${windowEnd}`
+          )
+        ).groupBy(
+          bridgeDelivery.status,
+          domainEvents.type,
+          bridgeDelivery.skipReason
+        );
+        return result.map((r) => ({
+          status: r.status,
+          eventType: r.eventType,
+          skipReason: r.skipReason,
+          count: r.count
+        }));
+      }
+      emit(tick) {
+        if (tick.rows.length === 0) {
+          this.logger.log(
+            `bridge_metrics tick=empty window=[${tick.windowStart.toISOString()}..${tick.windowEnd.toISOString()}]`
+          );
+          return;
+        }
+        const totals = tick.rows.reduce(
+          (acc, r) => {
+            acc[r.status] = (acc[r.status] ?? 0) + r.count;
+            return acc;
+          },
+          {}
+        );
+        const detail = tick.rows.map(
+          (r) => `${r.eventType}|${r.status}${r.skipReason ? `:${r.skipReason}` : ""}=${r.count}`
+        ).join(" ");
+        this.logger.log(
+          `bridge_metrics tick window=[${tick.windowStart.toISOString()}..${tick.windowEnd.toISOString()}] totals=${JSON.stringify(totals)} detail=[${detail}]`
+        );
+      }
+      resolveIntervalMs() {
+        const raw = process.env["BRIDGE_METRICS_INTERVAL_MS"];
+        if (!raw) return DEFAULT_INTERVAL_MS;
+        const parsed = Number.parseInt(raw, 10);
+        if (!Number.isFinite(parsed) || parsed < MIN_INTERVAL_MS) {
+          new Logger(BridgeMetricsReporter.name).warn(
+            `Ignoring BRIDGE_METRICS_INTERVAL_MS='${raw}' (invalid or < ${MIN_INTERVAL_MS}ms); using default ${DEFAULT_INTERVAL_MS}ms.`
+          );
+          return DEFAULT_INTERVAL_MS;
+        }
+        return parsed;
+      }
+    };
+    BridgeMetricsReporter = __decorateClass([
+      Injectable3(),
+      __decorateParam(0, Inject2(DRIZZLE))
+    ], BridgeMetricsReporter);
+  }
+});
+
+// runtime/subsystems/observability/observability.tokens.ts
+var OBSERVABILITY = /* @__PURE__ */ Symbol("OBSERVABILITY");
+var OBSERVABILITY_REPORTERS = /* @__PURE__ */ Symbol("OBSERVABILITY_REPORTERS");
+
+// runtime/subsystems/observability/observability.module.ts
+import { Module } from "@nestjs/common";
+
+// runtime/subsystems/observability/observability.drizzle-backend.ts
+init_tokens();
+init_job_orchestration_schema();
+import { Inject, Injectable } from "@nestjs/common";
+import { desc, eq, sql as sql2 } from "drizzle-orm";
+
+// runtime/subsystems/sync/sync-audit.schema.ts
+import {
+  pgEnum as pgEnum2,
+  pgTable as pgTable2,
+  uuid as uuid2,
+  text as text2,
+  jsonb as jsonb2,
+  integer as integer2,
+  boolean,
+  timestamp as timestamp2,
+  index as index2,
+  uniqueIndex as uniqueIndex2
+} from "drizzle-orm/pg-core";
+var syncRunDirectionEnum = pgEnum2("sync_run_direction", [
+  "inbound",
+  "outbound"
+]);
+var syncRunActionEnum = pgEnum2("sync_run_action", [
+  "poll",
+  "cdc",
+  "webhook",
+  "manual",
+  "writeback"
+]);
+var syncRunStatusEnum = pgEnum2("sync_run_status", [
+  "running",
+  "success",
+  "no_changes",
+  "failed"
+]);
+var syncRunItemOperationEnum = pgEnum2("sync_run_item_operation", [
+  "created",
+  "updated",
+  "deleted",
+  "noop"
+]);
+var syncRunItemStatusEnum = pgEnum2("sync_run_item_status", [
+  "success",
+  "failed",
+  "skipped"
+]);
+var syncSubscriptions = pgTable2(
+  "sync_subscriptions",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    integrationId: text2("integration_id").notNull(),
+    adapter: text2("adapter").notNull(),
+    domain: text2("domain").notNull(),
+    externalRef: text2("external_ref"),
+    enabled: boolean("enabled").notNull().default(true),
+    /**
+     * Per-subscription configuration bag. Strategies type it internally;
+     * e.g. polling strategies stash `{ batchSize, highWatermark }` here.
+     */
+    config: jsonb2("config").notNull().default({}).$type(),
+    /**
+     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first
+     * successful run advances it.
+     */
+    cursor: jsonb2("cursor").$type(),
+    lastSyncAt: timestamp2("last_sync_at", { withTimezone: true }),
+    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text2("tenant_id"),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (t) => ({
+    /**
+     * Composite uniqueness per the epic shape. `external_ref` is nullable;
+     * Postgres treats NULLs as distinct in a UNIQUE constraint, which means
+     * two rows with the same `(integration_id, adapter, domain)` and NULL
+     * external_ref are allowed. That's intentional — a subscription with
+     * NULL external_ref covers the full domain, and duplicates there would
+     * be a consumer-layer modeling issue, not a schema concern.
+     */
+    uqSyncSubscriptionTuple: uniqueIndex2("uq_sync_subscriptions_tuple").on(
+      t.integrationId,
+      t.adapter,
+      t.domain,
+      t.externalRef
+    ),
+    /** Scheduling query: list enabled subscriptions ordered by staleness. */
+    idxSyncSubscriptionsEnabledLastSync: index2(
+      "idx_sync_subscriptions_enabled_last_sync"
+    ).on(t.enabled, t.lastSyncAt)
+  })
+);
+var syncRuns = pgTable2(
+  "sync_runs",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    subscriptionId: uuid2("subscription_id").notNull().references(() => syncSubscriptions.id, { onDelete: "cascade" }),
+    direction: syncRunDirectionEnum("direction").notNull(),
+    action: syncRunActionEnum("action").notNull(),
+    status: syncRunStatusEnum("status").notNull().default("running"),
+    recordsFound: integer2("records_found").notNull().default(0),
+    recordsProcessed: integer2("records_processed").notNull().default(0),
+    cursorBefore: jsonb2("cursor_before").$type(),
+    cursorAfter: jsonb2("cursor_after").$type(),
+    durationMs: integer2("duration_ms"),
+    error: text2("error"),
+    startedAt: timestamp2("started_at", { withTimezone: true }).notNull().defaultNow(),
+    completedAt: timestamp2("completed_at", { withTimezone: true }),
+    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text2("tenant_id")
+  },
+  (t) => ({
+    /** Timeline read: "most recent runs for this subscription". */
+    idxSyncRunsSubscriptionStartedAt: index2(
+      "idx_sync_runs_subscription_started_at"
+    ).on(t.subscriptionId, t.startedAt),
+    /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
+    idxSyncRunsStatusStartedAt: index2("idx_sync_runs_status_started_at").on(
+      t.status,
+      t.startedAt
+    )
+  })
+);
+var syncRunItems = pgTable2(
+  "sync_run_items",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    syncRunId: uuid2("sync_run_id").notNull().references(() => syncRuns.id, { onDelete: "cascade" }),
+    entityType: text2("entity_type").notNull(),
+    externalId: text2("external_id").notNull(),
+    localId: text2("local_id"),
+    operation: syncRunItemOperationEnum("operation").notNull(),
+    status: syncRunItemStatusEnum("status").notNull(),
+    /**
+     * Structured per-field diff — ADR-0003 shape enforced by
+     * `FieldDiffSchema.parse` at the recorder service layer.
+     *
+     * Shape: `{ [fieldName]: { from: unknown, to: unknown } }`.
+     * Empty `{}` for `noop` items; `{ [field]: { from: null, to: <value> } }`
+     * for created items; `{ [field]: { from: <value>, to: null } }` for
+     * deleted items.
+     */
+    changedFields: jsonb2("changed_fields").notNull().default({}).$type(),
+    title: text2("title"),
+    error: text2("error"),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text2("tenant_id")
+  },
+  (t) => ({
+    /** Ordered timeline within a run. */
+    idxSyncRunItemsRunCreatedAt: index2("idx_sync_run_items_run_created_at").on(
+      t.syncRunId,
+      t.createdAt
+    ),
+    /** Per-record history: "every sync that touched opportunity/$extId". */
+    idxSyncRunItemsEntityExternal: index2(
+      "idx_sync_run_items_entity_external"
+    ).on(t.entityType, t.externalId)
+  })
+);
+
+// runtime/subsystems/observability/observability.drizzle-backend.ts
+var DrizzleObservabilityService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async getPoolDepths() {
+    const result = await this.db.execute(sql2`
+      SELECT
+        pool AS name,
+        COUNT(*) FILTER (WHERE status = 'pending')::int AS pending,
+        COUNT(*) FILTER (WHERE status = 'running')::int AS running,
+        (percentile_cont(0.95) WITHIN GROUP (
+          ORDER BY EXTRACT(EPOCH FROM (now() - claimed_at)) * 1000
+        ) FILTER (WHERE status = 'running' AND claimed_at IS NOT NULL))::int
+          AS claimed_age_p95_ms
+      FROM job_run
+      WHERE status IN ('pending','running')
+      GROUP BY pool
+      ORDER BY pool
+    `);
+    const rows = extractRows(result);
+    return rows.map((r) => ({
+      name: r.name,
+      pending: r.pending,
+      running: r.running,
+      claimedAgeP95Ms: r.claimed_age_p95_ms
+    }));
+  }
+  async getRecentSyncRuns(limit, integrationId) {
+    const base = this.db.select({
+      id: syncRuns.id,
+      subscriptionId: syncRuns.subscriptionId,
+      integrationId: syncSubscriptions.integrationId,
+      adapter: syncSubscriptions.adapter,
+      domain: syncSubscriptions.domain,
+      direction: syncRuns.direction,
+      action: syncRuns.action,
+      status: syncRuns.status,
+      recordsFound: syncRuns.recordsFound,
+      recordsProcessed: syncRuns.recordsProcessed,
+      durationMs: syncRuns.durationMs,
+      error: syncRuns.error,
+      startedAt: syncRuns.startedAt,
+      completedAt: syncRuns.completedAt
+    }).from(syncRuns).innerJoin(
+      syncSubscriptions,
+      eq(syncRuns.subscriptionId, syncSubscriptions.id)
+    );
+    const filtered = integrationId !== void 0 ? base.where(eq(syncSubscriptions.integrationId, integrationId)) : base;
+    const rows = await filtered.orderBy(desc(syncRuns.startedAt)).limit(limit);
+    return rows.map((r) => ({
+      id: r.id,
+      subscriptionId: r.subscriptionId,
+      integrationId: r.integrationId,
+      adapter: r.adapter,
+      domain: r.domain,
+      direction: r.direction,
+      action: r.action,
+      status: r.status,
+      recordsFound: r.recordsFound,
+      recordsProcessed: r.recordsProcessed,
+      durationMs: r.durationMs,
+      error: r.error,
+      startedAt: r.startedAt,
+      completedAt: r.completedAt
+    }));
+  }
+  async getBridgeDeliveryHistogram(windowHours) {
+    const result = await this.db.execute(sql2`
+      SELECT status, COUNT(*)::int AS count
+      FROM bridge_delivery
+      WHERE COALESCE(delivered_at, attempted_at) > now() - make_interval(hours => ${windowHours})
+      GROUP BY status
+    `);
+    const rows = extractRows(result);
+    const hist = {};
+    for (const r of rows) hist[r.status] = r.count;
+    return hist;
+  }
+  async getRecentFailedJobs(limit) {
+    const rows = await this.db.select({
+      id: jobRuns.id,
+      jobType: jobRuns.jobType,
+      pool: jobRuns.pool,
+      status: jobRuns.status,
+      error: jobRuns.error,
+      startedAt: jobRuns.startedAt,
+      finishedAt: jobRuns.finishedAt,
+      attempts: jobRuns.attempts
+    }).from(jobRuns).where(eq(jobRuns.status, "failed")).orderBy(desc(jobRuns.finishedAt)).limit(limit);
+    return rows.map((r) => ({
+      id: r.id,
+      jobType: r.jobType,
+      pool: r.pool,
+      status: r.status,
+      error: r.error,
+      startedAt: r.startedAt,
+      finishedAt: r.finishedAt,
+      attempts: r.attempts
+    }));
+  }
+  async getCursors() {
+    const rows = await this.db.select({
+      id: syncSubscriptions.id,
+      integrationId: syncSubscriptions.integrationId,
+      adapter: syncSubscriptions.adapter,
+      domain: syncSubscriptions.domain,
+      cursor: syncSubscriptions.cursor,
+      lastSyncAt: syncSubscriptions.lastSyncAt
+    }).from(syncSubscriptions).where(eq(syncSubscriptions.enabled, true)).orderBy(syncSubscriptions.integrationId, syncSubscriptions.domain);
+    return rows.map((r) => ({
+      subscriptionId: r.id,
+      integrationId: r.integrationId,
+      adapter: r.adapter,
+      domain: r.domain,
+      lastCursor: r.cursor,
+      lastSyncAt: r.lastSyncAt
+    }));
+  }
+};
+DrizzleObservabilityService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE))
+], DrizzleObservabilityService);
+function extractRows(result) {
+  const maybe = result;
+  if (Array.isArray(maybe.rows)) return maybe.rows;
+  if (Array.isArray(result)) return result;
+  return [];
+}
+
+// runtime/subsystems/observability/observability.memory-backend.ts
+import { Injectable as Injectable2 } from "@nestjs/common";
+var MemoryObservabilityService = class {
+  pools = [];
+  syncRuns = [];
+  bridgeHistogram = {};
+  failedJobs = [];
+  cursors = [];
+  // ─── Core contract ─────────────────────────────────────────────────────
+  async getPoolDepths() {
+    return [...this.pools];
+  }
+  async getRecentSyncRuns(limit, integrationId) {
+    const filtered = integrationId !== void 0 ? this.syncRuns.filter((r) => r.integrationId === integrationId) : this.syncRuns;
+    return filtered.slice().sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit);
+  }
+  async getBridgeDeliveryHistogram(_windowHours) {
+    return { ...this.bridgeHistogram };
+  }
+  async getRecentFailedJobs(limit) {
+    return this.failedJobs.slice().sort(
+      (a, b) => (b.finishedAt?.getTime() ?? 0) - (a.finishedAt?.getTime() ?? 0)
+    ).slice(0, limit);
+  }
+  async getCursors() {
+    return [...this.cursors];
+  }
+  // ─── Test seams ────────────────────────────────────────────────────────
+  /** Replace the pool-depth slice. */
+  seedPools(pools) {
+    this.pools = [...pools];
+  }
+  /** Replace the sync-run slice. */
+  seedSyncRuns(runs) {
+    this.syncRuns = [...runs];
+  }
+  /** Replace the bridge-delivery histogram. */
+  seedBridgeHistogram(hist) {
+    this.bridgeHistogram = { ...hist };
+  }
+  /** Replace the failed-jobs slice. */
+  seedFailedJobs(jobs2) {
+    this.failedJobs = [...jobs2];
+  }
+  /** Replace the cursor slice. */
+  seedCursors(cursors) {
+    this.cursors = [...cursors];
+  }
+  /** Reset every slice — for afterEach hooks. */
+  reset() {
+    this.pools = [];
+    this.syncRuns = [];
+    this.bridgeHistogram = {};
+    this.failedJobs = [];
+    this.cursors = [];
+  }
+};
+MemoryObservabilityService = __decorateClass([
+  Injectable2()
+], MemoryObservabilityService);
+
+// runtime/subsystems/observability/observability.module.ts
+var ObservabilityModule = class {
+  static forRoot(options = { backend: "drizzle" }) {
+    const ConcreteClass = options.backend === "drizzle" ? DrizzleObservabilityService : MemoryObservabilityService;
+    const wantsBridgeMetrics = options.reporters?.bridgeMetrics === true;
+    const providers = [
+      // Register the concrete class as the canonical instance.
+      ConcreteClass,
+      // OBSERVABILITY token points at the same instance — no duplicate.
+      { provide: OBSERVABILITY, useExisting: ConcreteClass },
+      // Expose the resolved reporter config for introspection / tests.
+      {
+        provide: OBSERVABILITY_REPORTERS,
+        useValue: options.reporters ?? {}
+      }
+    ];
+    const exports = [OBSERVABILITY];
+    if (wantsBridgeMetrics) {
+      const { BridgeMetricsReporter: BridgeMetricsReporter2 } = (init_bridge_metrics_reporter(), __toCommonJS(bridge_metrics_reporter_exports));
+      providers.push(BridgeMetricsReporter2);
+      exports.push(BridgeMetricsReporter2);
+    }
+    const imports = [];
+    if (wantsBridgeMetrics) {
+      const { ScheduleModule } = __require("@nestjs/schedule");
+      imports.push(ScheduleModule.forRoot());
+    }
+    return {
+      module: ObservabilityModule,
+      global: true,
+      imports,
+      providers,
+      exports
+    };
+  }
+};
+ObservabilityModule = __decorateClass([
+  Module({})
+], ObservabilityModule);
+
+// runtime/subsystems/observability/index.ts
+init_bridge_metrics_reporter();
+export {
+  BridgeMetricsReporter,
+  DrizzleObservabilityService,
+  MemoryObservabilityService,
+  OBSERVABILITY,
+  OBSERVABILITY_REPORTERS,
+  ObservabilityModule
+};
+//# sourceMappingURL=index.js.map