@pattern-stack/codegen 0.15.1 → 0.15.2

package/dist/runtime/subsystems/integration/integration.module.js

@@ -1,704 +1,17 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-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 = (index2, decorator) => (target, key) => decorator(target, key, index2);
-
-// runtime/subsystems/integration/integration.module.ts
-import { Module } from "@nestjs/common";
-
-// runtime/subsystems/integration/integration.tokens.ts
-var INTEGRATION_CURSOR_STORE = "INTEGRATION_CURSOR_STORE";
-var INTEGRATION_FIELD_DIFFER = "INTEGRATION_FIELD_DIFFER";
-var INTEGRATION_RUN_RECORDER = "INTEGRATION_RUN_RECORDER";
-var INTEGRATION_MODULE_OPTIONS = "INTEGRATION_MODULE_OPTIONS";
-var INTEGRATION_MULTI_TENANT = "INTEGRATION_MULTI_TENANT";
-
-// runtime/subsystems/integration/integration-cursor-store.memory-backend.ts
-import { Injectable } from "@nestjs/common";
-var MemoryCursorStore = class {
-  /**
-   * Subscription-id → last persisted cursor. Public so tests can inspect
-   * or pre-seed state; production callers MUST go through `get`/`put`.
-   */
-  cursors = /* @__PURE__ */ new Map();
-  /**
-   * Seedable subscription metadata for `listAll` — the memory backend
-   * stores only `subscriptionId → cursor` in its write path, so the
-   * snapshot shape (`connectionId`, `adapter`, `domain`, `externalRef`,
-   * timestamps) has no natural source without test seeding. Tests populate
-   * this map; unseeded entries get empty-string metadata and `new Date(0)`
-   * timestamps so the shape stays stable. Production paths go through the
-   * Drizzle backend.
-   */
-  subscriptions = /* @__PURE__ */ new Map();
-  async get(subscriptionId, _tenantId) {
-    const value = this.cursors.get(subscriptionId);
-    return value === void 0 ? null : value;
-  }
-  async put(subscriptionId, cursor, _tenantId) {
-    this.cursors.set(subscriptionId, cursor);
-  }
-  async listAll(_tenantId) {
-    const snapshots = [];
-    for (const [subscriptionId, cursor] of this.cursors.entries()) {
-      const meta = this.subscriptions.get(subscriptionId);
-      snapshots.push({
-        subscriptionId,
-        connectionId: meta?.connectionId ?? "",
-        adapter: meta?.adapter ?? "",
-        domain: meta?.domain ?? "",
-        externalRef: meta?.externalRef ?? null,
-        cursor: cursor ?? null,
-        lastIntegrationAt: meta?.lastIntegrationAt ?? null,
-        updatedAt: meta?.updatedAt ?? /* @__PURE__ */ new Date(0),
-        tenantId: null
-      });
-    }
-    return snapshots.sort(
-      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
-    );
-  }
-  /** Reset state. Tests call this in `beforeEach`. */
-  clear() {
-    this.cursors.clear();
-    this.subscriptions.clear();
-  }
-};
-MemoryCursorStore = __decorateClass([
-  Injectable()
-], MemoryCursorStore);
-
-// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
-import { Injectable as Injectable2 } from "@nestjs/common";
-
-// runtime/subsystems/integration/integration-field-diff.protocol.ts
-import { z } from "zod";
-var FieldDiffValueSchema = z.object({
-  from: z.unknown(),
-  to: z.unknown()
-});
-var FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);
-
-// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
-var MemoryRunRecorder = class {
-  /**
-   * All started runs keyed by id. Public so tests can inspect lifecycle
-   * transitions without poking through recording methods.
-   */
-  runs = /* @__PURE__ */ new Map();
-  /**
-   * Items keyed by `integration_run_id`, array order matches insertion order —
-   * mirrors the timeline the `(integration_run_id, created_at)` index produces
-   * in Postgres.
-   */
-  items = /* @__PURE__ */ new Map();
-  /**
-   * Seedable subscription metadata — tests populate this to make
-   * `listRecent` return meaningful `connectionId` values. The memory
-   * backend doesn't track subscriptions on its own (only runs + items), so
-   * this map is the intentional extension point: tests write entries for
-   * the subscription ids they use, production code never touches it.
-   */
-  subscriptions = /* @__PURE__ */ new Map();
-  async startRun(input) {
-    const id = crypto.randomUUID();
-    this.runs.set(id, {
-      id,
-      subscriptionId: input.subscriptionId,
-      direction: input.direction,
-      action: input.action,
-      status: "running",
-      cursorBefore: input.cursorBefore ?? null,
-      cursorAfter: null,
-      recordsFound: 0,
-      recordsProcessed: 0,
-      durationMs: null,
-      error: null,
-      tenantId: input.tenantId ?? null,
-      startedAt: /* @__PURE__ */ new Date(),
-      completedAt: null
-    });
-    this.items.set(id, []);
-    return { id };
-  }
-  async recordItem(input) {
-    FieldDiffSchema.parse(input.changedFields);
-    const bucket = this.items.get(input.integrationRunId);
-    if (!bucket) {
-      throw new Error(
-        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. Call startRun(...) first.`
-      );
-    }
-    bucket.push(input);
-  }
-  async completeRun(runId, input) {
-    const run = this.runs.get(runId);
-    if (!run) {
-      throw new Error(
-        `MemoryRunRecorder.completeRun: no run started for id '${runId}'.`
-      );
-    }
-    run.status = input.status;
-    run.recordsFound = input.recordsFound;
-    run.recordsProcessed = input.recordsProcessed;
-    run.cursorAfter = input.cursorAfter ?? null;
-    run.durationMs = input.durationMs;
-    run.error = input.error ?? null;
-    run.completedAt = /* @__PURE__ */ new Date();
-  }
-  async listRecent(limit, subscriptionId, _tenantId) {
-    const all = Array.from(this.runs.values());
-    const filtered = subscriptionId === void 0 ? all : all.filter((r) => r.subscriptionId === subscriptionId);
-    return filtered.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit).map((r) => ({
-      id: r.id,
-      subscriptionId: r.subscriptionId,
-      // connectionId is only knowable if the test seeded subscriptions
-      // metadata; empty string otherwise. The Drizzle backend resolves
-      // it via JOIN, which is the production path.
-      connectionId: this.subscriptions.get(r.subscriptionId)?.connectionId ?? "",
-      status: r.status,
-      startedAt: r.startedAt,
-      completedAt: r.completedAt,
-      recordsProcessed: r.recordsProcessed,
-      tenantId: r.tenantId
-    }));
-  }
-  /** Reset state. Tests call this in `beforeEach`. */
-  clear() {
-    this.runs.clear();
-    this.items.clear();
-    this.subscriptions.clear();
-  }
-  // ─── test ergonomics ─────────────────────────────────────────────────
-  /** All runs for a subscription, newest first. Timeline reads. */
-  getRunsForSubscription(subscriptionId) {
-    return Array.from(this.runs.values()).filter((r) => r.subscriptionId === subscriptionId).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
-  }
-  /** All item rows for a run, insertion-ordered. */
-  getItemsForRun(runId) {
-    return this.items.get(runId) ?? [];
-  }
-};
-MemoryRunRecorder = __decorateClass([
-  Injectable2()
-], MemoryRunRecorder);
-
-// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
-import { Inject, Injectable as Injectable3, Optional } from "@nestjs/common";
-import { and, desc, eq } from "drizzle-orm";
-
-// runtime/constants/tokens.ts
-var DRIZZLE = "DRIZZLE";
-
-// runtime/subsystems/integration/integration-audit.schema.ts
 import {
-  pgEnum,
-  pgTable,
-  uuid,
-  text,
-  jsonb,
-  integer,
-  boolean,
-  timestamp,
-  index,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-var integrationRunDirectionEnum = pgEnum("integration_run_direction", [
-  "inbound",
-  "outbound"
-]);
-var integrationRunActionEnum = pgEnum("integration_run_action", [
-  "poll",
-  "cdc",
-  "webhook",
-  "manual",
-  "writeback"
-]);
-var integrationRunStatusEnum = pgEnum("integration_run_status", [
-  "running",
-  "success",
-  "no_changes",
-  "failed"
-]);
-var integrationRunItemOperationEnum = pgEnum("integration_run_item_operation", [
-  "created",
-  "updated",
-  "deleted",
-  "noop"
-]);
-var integrationRunItemStatusEnum = pgEnum("integration_run_item_status", [
-  "success",
-  "failed",
-  "skipped"
-]);
-var integrationSubscriptions = pgTable(
-  "integration_subscriptions",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    connectionId: text("connection_id").notNull(),
-    adapter: text("adapter").notNull(),
-    domain: text("domain").notNull(),
-    externalRef: text("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: jsonb("config").notNull().default({}).$type(),
-    /**
-     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first
-     * successful run advances it.
-     */
-    cursor: jsonb("cursor").$type(),
-    lastIntegrationAt: timestamp("last_integration_at", { withTimezone: true }),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id"),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp("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 `(connection_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.
-     */
-    uqIntegrationSubscriptionTuple: uniqueIndex("uq_integration_subscriptions_tuple").on(
-      t.connectionId,
-      t.adapter,
-      t.domain,
-      t.externalRef
-    ),
-    /** Scheduling query: list enabled subscriptions ordered by staleness. */
-    idxIntegrationSubscriptionsEnabledLastIntegration: index(
-      "idx_integration_subscriptions_enabled_last_integration"
-    ).on(t.enabled, t.lastIntegrationAt)
-  })
-);
-var integrationRuns = pgTable(
-  "integration_runs",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    subscriptionId: uuid("subscription_id").notNull().references(() => integrationSubscriptions.id, { onDelete: "cascade" }),
-    direction: integrationRunDirectionEnum("direction").notNull(),
-    action: integrationRunActionEnum("action").notNull(),
-    status: integrationRunStatusEnum("status").notNull().default("running"),
-    recordsFound: integer("records_found").notNull().default(0),
-    recordsProcessed: integer("records_processed").notNull().default(0),
-    cursorBefore: jsonb("cursor_before").$type(),
-    cursorAfter: jsonb("cursor_after").$type(),
-    durationMs: integer("duration_ms"),
-    error: text("error"),
-    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
-    completedAt: timestamp("completed_at", { withTimezone: true }),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Timeline read: "most recent runs for this subscription". */
-    idxIntegrationRunsSubscriptionStartedAt: index(
-      "idx_integration_runs_subscription_started_at"
-    ).on(t.subscriptionId, t.startedAt),
-    /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
-    idxIntegrationRunsStatusStartedAt: index("idx_integration_runs_status_started_at").on(
-      t.status,
-      t.startedAt
-    )
-  })
-);
-var integrationRunItems = pgTable(
-  "integration_run_items",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    integrationRunId: uuid("integration_run_id").notNull().references(() => integrationRuns.id, { onDelete: "cascade" }),
-    entityType: text("entity_type").notNull(),
-    externalId: text("external_id").notNull(),
-    localId: text("local_id"),
-    operation: integrationRunItemOperationEnum("operation").notNull(),
-    status: integrationRunItemStatusEnum("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: jsonb("changed_fields").notNull().default({}).$type(),
-    title: text("title"),
-    error: text("error"),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Ordered timeline within a run. */
-    idxIntegrationRunItemsRunCreatedAt: index("idx_integration_run_items_run_created_at").on(
-      t.integrationRunId,
-      t.createdAt
-    ),
-    /** Per-record history: "every integration that touched opportunity/$extId". */
-    idxIntegrationRunItemsEntityExternal: index(
-      "idx_integration_run_items_entity_external"
-    ).on(t.entityType, t.externalId)
-  })
-);
-
-// runtime/subsystems/integration/integration-errors.ts
-var MissingTenantIdError = class extends Error {
-  name = "MissingTenantIdError";
-  constructor(operation) {
-    super(
-      `Missing tenantId for integration operation '${operation}'. IntegrationModule is configured with multiTenant: true \u2014 every call must include a non-null tenantId. Either pass the tenantId or disable multi-tenancy on the module.`
-    );
-  }
-};
-function assertTenantId(tenantId, options) {
-  if (!options.multiTenant) return;
-  if (tenantId === void 0 || tenantId === null) {
-    throw new MissingTenantIdError(options.operation);
-  }
-}
-
-// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
-var PostgresCursorStore = class {
-  constructor(db, multiTenant) {
-    this.db = db;
-    this.multiTenant = multiTenant ?? false;
-  }
-  db;
-  multiTenant;
-  async get(subscriptionId, tenantId) {
-    const where = this.buildWhere(subscriptionId, tenantId, "cursor.get");
-    const rows = await this.db.select({ cursor: integrationSubscriptions.cursor }).from(integrationSubscriptions).where(where).limit(1);
-    if (rows.length === 0) return null;
-    return rows[0]?.cursor ?? null;
-  }
-  async put(subscriptionId, cursor, tenantId) {
-    const where = this.buildWhere(subscriptionId, tenantId, "cursor.put");
-    await this.db.update(integrationSubscriptions).set({
-      cursor,
-      lastIntegrationAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(where);
-  }
-  async listAll(tenantId) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "cursor.listAll"
-    });
-    const where = this.multiTenant ? eq(integrationSubscriptions.tenantId, tenantId) : void 0;
-    const rows = await this.db.select({
-      id: integrationSubscriptions.id,
-      connectionId: integrationSubscriptions.connectionId,
-      adapter: integrationSubscriptions.adapter,
-      domain: integrationSubscriptions.domain,
-      externalRef: integrationSubscriptions.externalRef,
-      cursor: integrationSubscriptions.cursor,
-      lastIntegrationAt: integrationSubscriptions.lastIntegrationAt,
-      updatedAt: integrationSubscriptions.updatedAt,
-      tenantId: integrationSubscriptions.tenantId
-    }).from(integrationSubscriptions).where(where).orderBy(desc(integrationSubscriptions.updatedAt));
-    return rows.map((row) => ({
-      subscriptionId: row.id,
-      connectionId: row.connectionId,
-      adapter: row.adapter,
-      domain: row.domain,
-      externalRef: row.externalRef,
-      cursor: row.cursor ?? null,
-      lastIntegrationAt: row.lastIntegrationAt,
-      updatedAt: row.updatedAt,
-      tenantId: row.tenantId
-    }));
-  }
-  /**
-   * Centralized WHERE clause — `get` and `put` share identical semantics.
-   * Drift here would let a caller read under one tenancy rule and write
-   * under another.
-   */
-  buildWhere(subscriptionId, tenantId, operation) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation
-    });
-    if (this.multiTenant) {
-      return and(
-        eq(integrationSubscriptions.id, subscriptionId),
-        eq(integrationSubscriptions.tenantId, tenantId)
-      );
-    }
-    return eq(integrationSubscriptions.id, subscriptionId);
-  }
-};
-PostgresCursorStore = __decorateClass([
-  Injectable3(),
-  __decorateParam(0, Inject(DRIZZLE)),
-  __decorateParam(1, Optional()),
-  __decorateParam(1, Inject(INTEGRATION_MULTI_TENANT))
-], PostgresCursorStore);
-
-// runtime/subsystems/integration/integration-run-recorder.drizzle-backend.ts
-import { Inject as Inject2, Injectable as Injectable4, Optional as Optional2 } from "@nestjs/common";
-import { and as and2, desc as desc2, eq as eq2 } from "drizzle-orm";
-var DrizzleIntegrationRunRecorder = class {
-  constructor(db, multiTenant) {
-    this.db = db;
-    this.multiTenant = multiTenant ?? false;
-  }
-  db;
-  multiTenant;
-  async startRun(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "startRun"
-    });
-    const rows = await this.db.insert(integrationRuns).values({
-      subscriptionId: input.subscriptionId,
-      direction: input.direction,
-      action: input.action,
-      status: "running",
-      cursorBefore: input.cursorBefore ?? null,
-      tenantId: input.tenantId ?? null
-    }).returning({ id: integrationRuns.id });
-    const id = rows[0]?.id;
-    if (!id) {
-      throw new Error("DrizzleIntegrationRunRecorder: INSERT RETURNING produced no id");
-    }
-    return { id };
-  }
-  async recordItem(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "recordItem"
-    });
-    FieldDiffSchema.parse(input.changedFields);
-    await this.db.insert(integrationRunItems).values({
-      integrationRunId: input.integrationRunId,
-      entityType: input.entityType,
-      externalId: input.externalId,
-      localId: input.localId ?? null,
-      operation: input.operation,
-      status: input.status,
-      changedFields: input.changedFields,
-      title: input.title ?? null,
-      error: input.error ?? null,
-      tenantId: input.tenantId ?? null
-    });
-  }
-  async listRecent(limit, subscriptionId, tenantId) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "listRecent"
-    });
-    const conditions = [];
-    if (subscriptionId !== void 0) {
-      conditions.push(eq2(integrationRuns.subscriptionId, subscriptionId));
-    }
-    if (this.multiTenant) {
-      conditions.push(eq2(integrationRuns.tenantId, tenantId));
-    }
-    const where = conditions.length === 0 ? void 0 : conditions.length === 1 ? conditions[0] : and2(...conditions);
-    const rows = await this.db.select({
-      id: integrationRuns.id,
-      subscriptionId: integrationRuns.subscriptionId,
-      connectionId: integrationSubscriptions.connectionId,
-      status: integrationRuns.status,
-      startedAt: integrationRuns.startedAt,
-      completedAt: integrationRuns.completedAt,
-      recordsProcessed: integrationRuns.recordsProcessed,
-      tenantId: integrationRuns.tenantId
-    }).from(integrationRuns).innerJoin(
-      integrationSubscriptions,
-      eq2(integrationRuns.subscriptionId, integrationSubscriptions.id)
-    ).where(where).orderBy(desc2(integrationRuns.startedAt)).limit(limit);
-    return rows.map((row) => ({
-      id: row.id,
-      subscriptionId: row.subscriptionId,
-      connectionId: row.connectionId,
-      status: row.status,
-      startedAt: row.startedAt,
-      completedAt: row.completedAt,
-      recordsProcessed: row.recordsProcessed,
-      tenantId: row.tenantId
-    }));
-  }
-  async completeRun(runId, input) {
-    await this.db.update(integrationRuns).set({
-      status: input.status,
-      recordsFound: input.recordsFound,
-      recordsProcessed: input.recordsProcessed,
-      cursorAfter: input.cursorAfter ?? null,
-      durationMs: input.durationMs,
-      error: input.error ?? null,
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq2(integrationRuns.id, runId));
-  }
-};
-DrizzleIntegrationRunRecorder = __decorateClass([
-  Injectable4(),
-  __decorateParam(0, Inject2(DRIZZLE)),
-  __decorateParam(1, Optional2()),
-  __decorateParam(1, Inject2(INTEGRATION_MULTI_TENANT))
-], DrizzleIntegrationRunRecorder);
-
-// runtime/subsystems/integration/deep-equal.differ.ts
-import { Injectable as Injectable5 } from "@nestjs/common";
-var DEFAULT_IGNORE_FIELDS = /* @__PURE__ */ new Set([
-  "id",
-  "createdAt",
-  "updatedAt",
-  "deletedAt",
-  "type",
-  "lastModifiedAt",
-  "fields",
-  "external_id",
-  "externalId",
-  "provider",
-  "provider_metadata",
-  "providerMetadata"
-]);
-var DeepEqualDiffer = class {
-  ignore;
-  constructor(opts = {}) {
-    if (opts.ignore && opts.ignore.length > 0) {
-      this.ignore = /* @__PURE__ */ new Set([...DEFAULT_IGNORE_FIELDS, ...opts.ignore]);
-    } else {
-      this.ignore = DEFAULT_IGNORE_FIELDS;
-    }
-  }
-  diff(existing, incoming, providerChangedFields) {
-    if (existing === null) {
-      const out2 = {};
-      for (const key of Object.keys(incoming)) {
-        if (this.ignore.has(key)) continue;
-        const value = incoming[key];
-        if (value === null || value === void 0) continue;
-        out2[key] = { from: null, to: value };
-      }
-      return Object.keys(out2).length === 0 ? "noop" : out2;
-    }
-    const candidates = /* @__PURE__ */ new Set();
-    if (providerChangedFields && providerChangedFields.length > 0) {
-      for (const key of providerChangedFields) {
-        if (!this.ignore.has(key)) candidates.add(key);
-      }
-    } else {
-      for (const key of Object.keys(incoming)) {
-        if (!this.ignore.has(key)) candidates.add(key);
-      }
-      for (const key of Object.keys(existing)) {
-        if (this.ignore.has(key)) continue;
-        if (!(key in incoming)) continue;
-        candidates.add(key);
-      }
-    }
-    const out = {};
-    for (const key of candidates) {
-      const before = existing[key];
-      const after = incoming[key];
-      if (!isEqual(before, after)) {
-        out[key] = { from: before ?? null, to: after ?? null };
-      }
-    }
-    return Object.keys(out).length === 0 ? "noop" : out;
-  }
-};
-DeepEqualDiffer = __decorateClass([
-  Injectable5()
-], DeepEqualDiffer);
-function isEqual(a, b) {
-  if (a === b) return true;
-  const na = normalize(a);
-  const nb = normalize(b);
-  if (na === nb) return true;
-  if (typeof na === "object" && typeof nb === "object" && na !== null && nb !== null) {
-    return deepEqualObject(na, nb);
-  }
-  const numericEqual = maybeNumericEqual(na, nb) || maybeNumericEqual(nb, na);
-  return numericEqual;
-}
-function normalize(value) {
-  if (value instanceof Date) return value.toISOString();
-  return value;
-}
-function maybeNumericEqual(a, b) {
-  if (typeof a !== "string" || typeof b !== "number") return false;
-  if (a.trim() === "") return false;
-  const parsed = Number(a);
-  if (!Number.isFinite(parsed)) return false;
-  return parsed === b;
-}
-function deepEqualObject(a, b) {
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const key of aKeys) {
-    if (!(key in b)) return false;
-    if (!isEqual(a[key], b[key])) return false;
-  }
-  return true;
-}
-
-// runtime/subsystems/integration/integration.module.ts
-var IntegrationModule = class {
-  static forRoot(options) {
-    const multiTenant = options.multiTenant ?? false;
-    const sharedProviders = [
-      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },
-      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
-      // Default differ — consumers can override by binding a different
-      // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.
-      { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
-    ];
-    const backendProviders = options.backend === "memory" ? [
-      // Wired as singletons via `useValue` so tests can pull
-      // them out via `moduleRef.get(MemoryCursorStore)` for
-      // direct assertions. Matches JOB-4 / MemoryJobStore shape.
-      { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },
-      {
-        provide: INTEGRATION_CURSOR_STORE,
-        useExisting: MemoryCursorStore
-      },
-      { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },
-      {
-        provide: INTEGRATION_RUN_RECORDER,
-        useExisting: MemoryRunRecorder
-      }
-    ] : [
-      // Drizzle backends — injected with DRIZZLE (provided by the
-      // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag
-      // we bound above.
-      { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },
-      { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder }
-    ];
-    return {
-      module: IntegrationModule,
-      global: true,
-      providers: [...sharedProviders, ...backendProviders],
-      exports: [
-        INTEGRATION_MODULE_OPTIONS,
-        INTEGRATION_MULTI_TENANT,
-        INTEGRATION_FIELD_DIFFER,
-        INTEGRATION_CURSOR_STORE,
-        INTEGRATION_RUN_RECORDER
-      ]
-    };
-  }
-};
-IntegrationModule = __decorateClass([
-  Module({})
-], IntegrationModule);
+  IntegrationModule
+} from "../../../chunk-WEVWJKOW.js";
+import "../../../chunk-AHV4GDYM.js";
+import "../../../chunk-SR7F3TJY.js";
+import "../../../chunk-EO2QPOKH.js";
+import "../../../chunk-SQDOBLBP.js";
+import "../../../chunk-DCCZB4UC.js";
+import "../../../chunk-MZ6GV4YF.js";
+import "../../../chunk-HNWZFNKP.js";
+import "../../../chunk-36U5UGIO.js";
+import "../../../chunk-S7C6TIIF.js";
+import "../../../chunk-U64T4YZE.js";
+import "../../../chunk-2E224ZSN.js";
 export {
   IntegrationModule
 };