@pattern-stack/codegen 0.15.1 → 0.15.3

package/CHANGELOG.md

@@ -4,6 +4,91 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.15.3] — 2026-06-03
+
+Package-mode **inbound webhook drain** — the first real exercise of
+`WebhookChangeSource` by a `runtime: package` consumer (swe-brain's Slack
+inbound pipeline-parity drain, ADR-0009 §6). One latent transposition this path
+exercises; the fix is framework-only.
+
+### Fixed
+
+- **`WebhookChangeSource` (and the identically-shaped `PollChangeSource`) now
+  derive `Change<T>.externalId` from the mapping `source`, not `target`.** Both
+  primitives located the `DetectionConfig` mapping entry with `target ===
+  'external_id'` correctly, then read the emitted record off
+  `mapping.target` — a transposition. Mapping semantics are `{ source: <field on
+  the emitted record>, target: <canonical column> }`, and `fetch()` reads
+  `record[externalIdSourceField]` off the emitted record, so it must use
+  `.source`. The two diverge only when the canonical record is vendor-neutral
+  camelCase (`source: 'externalId'` → `target: 'external_id'`): such a consumer
+  hit `record missing string 'external_id'` and the primitive was unusable. The
+  original unit fixtures masked it by keying records `external_id` (== the
+  target). Regression tests now cover the camelCase consumer shape directly.
+
+### Added
+
+- **Webhook/poll/detection symbols re-exported from
+  `@pattern-stack/codegen/subsystems`.** `WebhookChangeSource`,
+  `WebhookChangeSourceOptions`, `WebhookFetchCallback`, `WebhookFetchContext`,
+  `WebhookCursor`, `buildChangeSource`, `DetectionConfigSchema`,
+  `DetectionConfig` (+ poll equivalents) were previously reachable only via the
+  deep `.../integration/index` path; they now ride the public barrel alongside
+  the curated `IncrementalReadBase` / `ExecuteIntegrationUseCase` forwards.
+
+## [0.15.2] — 2026-06-03
+
+Package-mode **bridge *delivery*** — the first time a `runtime: package` consumer
+(ADR-037) drives a real event→bridge→job round-trip end to end (webhook →
+`domain_events` outbox → `bridge_delivery` → wrapper `@framework/bridge_delivery`
+run → user `@JobHandler`). Three latent defects only this path exercises (codegen's
+own tests are vendored — a single `tsc` compilation, a single in-memory Map, and a
+mocked `tx` that never touches a real FK — so none of them ever surfaced). All three
+fixes are framework-only; vendored mode is unaffected.
+
+### Fixed
+
+- **Stateful module-singletons are no longer duplicated across dist entry
+  chunks** (`tsup.config.ts`: `splitting: false` → `splitting: true`). The
+  published bundle is ESM and multi-entry — `runtime/**/*.ts` each emit a physical
+  `dist/runtime/.../x.js` so the `./runtime/*` wildcard `exports` map resolves 1:1.
+  With splitting off, esbuild INLINED every shared module into each importing entry
+  chunk. Harmless for pure functions, but a correctness bug for a stateful
+  singleton: `runtime/subsystems/jobs/job-handler.base`'s `JOB_HANDLER_REGISTRY`
+  Map (and its `HandlerRegistry` read facade), which the `@JobHandler` decorator
+  mutates at import time, got a **second copy** inlined into the `bridge/*` chunk.
+  The framework's own `@JobHandler('@framework/bridge_delivery')`
+  (`BridgeDeliveryHandler`, bridge chunk) registered into the BRIDGE copy while the
+  jobs `JobWorker` read the JOBS copy → the worker never upserted the wrapper's
+  `job` row → the bridge's outbox-drain couldn't spawn the wrapper `job_run` (its
+  `job_type` FKs `job(type)`), so the `bridge_delivery` insert violated its
+  `wrapper_run_id → job_run` FK and looped forever. `splitting: true` hoists each
+  shared module into a SINGLE shared chunk that every entry imports, collapsing the
+  registry back to one Map. The named per-entry output files are preserved (each
+  entry stays a physical `dist/runtime/.../x.js`), so the wildcard `exports` map and
+  the deep consumer subpaths (`…/subsystems/jobs/index`, `…/bridge/index`,
+  `./subsystems`) still resolve. ESM-only build ⇒ no CJS output to regress. Guarded
+  by a new dist-grep regression test.
+- **`BridgeOutboxDrainHook` now inserts the wrapper `job_run` BEFORE the
+  `bridge_delivery` that references it** (`bridge-outbox-drain-hook.ts`).
+  `bridge_delivery.wrapper_run_id → job_run(id)` is a plain (non-deferrable) FK, so
+  the referenced wrapper run must exist before the delivery row is inserted —
+  otherwise Postgres rejects the delivery insert immediately. The drain previously
+  inserted the delivery (with `wrapper_run_id` set) first, then the wrapper run; the
+  unit tests mocked `tx`, so the ordering was never validated against a real FK.
+  Idempotency is preserved: the delivery keeps its `ON CONFLICT (event_id,
+  trigger_id) DO NOTHING RETURNING`, and when it conflicts (outbox replay or
+  facade-eager Case B) the speculatively-inserted wrapper run is DELETEd in the same
+  tx, so a skipped delivery leaves no orphan `job_run`.
+- **`JobWorker.nextStepSeq` no longer array-destructures the raw `db.execute()`
+  result** (`job-worker.ts`). `db.execute(sql\`…\`)` is driver-shape-dependent and
+  not uniformly array-iterable: `drizzle-orm/node-postgres` returns the pg `Result`
+  OBJECT (`{ rows, rowCount, … }`), so `const [row] = await this.db.execute(...)`
+  threw `TypeError: {} is not iterable`. Every wrapper `@framework/bridge_delivery`
+  run calls `ctx.step` → `nextStepSeq`, so the delivery failed on every attempt. The
+  result is now normalised to a row array before reading, tolerating both the
+  node-postgres `{ rows }` shape and a plain-array shape. Guarded by a new unit test.
+
 ## [0.15.1] — 2026-06-02
 
 Package-mode **bridge/trigger event typing** — the fourth and final package-mode

package/dist/chunk-27ETSJ2X.js

@@ -0,0 +1,84 @@
+import {
+  DrizzleCacheService
+} from "./chunk-7YGORYZD.js";
+import {
+  MemoryCacheService
+} from "./chunk-IF5I3DAA.js";
+import {
+  CACHE,
+  CACHE_DEFAULT_TTL
+} from "./chunk-L6FTY45T.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/cache/cache.module.ts
+import { Module } from "@nestjs/common";
+var CACHE_MODULE_OPTIONS = "CACHE_MODULE_OPTIONS";
+function buildCacheAsync(options, db) {
+  const defaultTtl = options.defaultTtl ?? null;
+  if (options.backend === "drizzle") {
+    if (!db) {
+      throw new Error(
+        "CacheModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before CacheModule.forRootAsync."
+      );
+    }
+    return new DrizzleCacheService(db, defaultTtl);
+  }
+  return new MemoryCacheService(defaultTtl);
+}
+var CacheModule = class {
+  static forRootAsync(asyncOptions) {
+    return {
+      module: CacheModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        {
+          provide: CACHE_MODULE_OPTIONS,
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        },
+        {
+          provide: CACHE,
+          useFactory: (options, db) => buildCacheAsync(options, db),
+          inject: [CACHE_MODULE_OPTIONS, { token: DRIZZLE, optional: true }]
+        },
+        // Alias the concrete classes to CACHE for typed injection.
+        { provide: DrizzleCacheService, useExisting: CACHE },
+        { provide: MemoryCacheService, useExisting: CACHE }
+      ],
+      exports: [CACHE]
+    };
+  }
+  static forRoot(options = { backend: "drizzle" }) {
+    const ConcreteClass = options.backend === "drizzle" ? DrizzleCacheService : MemoryCacheService;
+    const providers = options.defaultTtl !== void 0 ? [
+      // Register the concrete class as the canonical instance
+      ConcreteClass,
+      { provide: CACHE_DEFAULT_TTL, useValue: options.defaultTtl },
+      // CACHE token points to the same instance — no duplicate
+      { provide: CACHE, useExisting: ConcreteClass }
+    ] : [
+      ConcreteClass,
+      { provide: CACHE, useExisting: ConcreteClass }
+    ];
+    return {
+      module: CacheModule,
+      global: true,
+      providers,
+      exports: [CACHE]
+    };
+  }
+};
+CacheModule = __decorateClass([
+  Module({})
+], CacheModule);
+
+export {
+  CacheModule
+};
+//# sourceMappingURL=chunk-27ETSJ2X.js.map

package/dist/chunk-27ETSJ2X.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/cache/cache.module.ts"],"sourcesContent":["/**\n * CacheModule — DynamicModule factory for the cache subsystem.\n *\n * Usage in AppModule:\n * ```typescript\n * CacheModule.forRoot({ backend: 'drizzle', defaultTtl: 300 })\n * ```\n *\n * Usage in tests:\n * ```typescript\n * CacheModule.forRoot({ backend: 'memory' })\n * ```\n *\n * `global: true` means any module that needs ICacheService can inject CACHE\n * directly without importing CacheModule. Register once in AppModule.\n *\n * The drizzle backend requires DRIZZLE to be provided globally (e.g., via DatabaseModule).\n *\n * Async configuration (`forRootAsync`):\n * The async factory returns `CacheModuleOptions`; the CACHE provider then\n * receives DRIZZLE (for the drizzle backend) through Nest DI rather than\n * hand-constructing with `null` — see issue #108 which flagged the same\n * shape in `EventsModule.forRootAsync`. DRIZZLE is injected as optional\n * so memory-backend consumers are not required to wire DatabaseModule.\n */\nimport { Module, type DynamicModule } from '@nestjs/common';\nimport { CACHE, CACHE_DEFAULT_TTL } from './cache.tokens';\nimport { DRIZZLE } from '../../constants/tokens';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DrizzleCacheService } from './cache.drizzle-backend';\nimport { MemoryCacheService } from './cache.memory-backend';\n\nexport interface CacheModuleOptions {\n  backend: 'drizzle' | 'memory';\n  /** Default TTL in seconds for entries that don't specify their own TTL. Null = no expiry. */\n  defaultTtl?: number;\n}\n\nexport interface CacheModuleAsyncOptions {\n  useFactory: (...args: unknown[]) => Promise<CacheModuleOptions> | CacheModuleOptions;\n  inject?: unknown[];\n  imports?: unknown[];\n}\n\n/** String token for the resolved CacheModuleOptions in the async path. */\nconst CACHE_MODULE_OPTIONS = 'CACHE_MODULE_OPTIONS' as const;\n\nfunction buildCacheAsync(\n  options: CacheModuleOptions,\n  db: DrizzleClient | null,\n): DrizzleCacheService | MemoryCacheService {\n  const defaultTtl = options.defaultTtl ?? null;\n  if (options.backend === 'drizzle') {\n    if (!db) {\n      throw new Error(\n        \"CacheModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. \" +\n          'Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before CacheModule.forRootAsync.',\n      );\n    }\n    return new DrizzleCacheService(db, defaultTtl);\n  }\n  return new MemoryCacheService(defaultTtl);\n}\n\n@Module({})\nexport class CacheModule {\n  static forRootAsync(asyncOptions: CacheModuleAsyncOptions): DynamicModule {\n    return {\n      module: CacheModule,\n      global: true,\n      imports: (asyncOptions.imports ?? []) as Parameters<typeof Module>[0]['imports'],\n      providers: [\n        {\n          provide: CACHE_MODULE_OPTIONS,\n          useFactory: asyncOptions.useFactory,\n          inject: (asyncOptions.inject ?? []) as (string | symbol | Function)[],\n        },\n        {\n          provide: CACHE,\n          useFactory: (options: CacheModuleOptions, db: DrizzleClient | null) =>\n            buildCacheAsync(options, db),\n          inject: [CACHE_MODULE_OPTIONS, { token: DRIZZLE, optional: true }],\n        },\n        // Alias the concrete classes to CACHE for typed injection.\n        { provide: DrizzleCacheService, useExisting: CACHE },\n        { provide: MemoryCacheService, useExisting: CACHE },\n      ],\n      exports: [CACHE],\n    };\n  }\n\n  static forRoot(options: CacheModuleOptions = { backend: 'drizzle' }): DynamicModule {\n    const ConcreteClass = options.backend === 'drizzle' ? DrizzleCacheService : MemoryCacheService;\n\n    const providers = options.defaultTtl !== undefined\n      ? [\n          // Register the concrete class as the canonical instance\n          ConcreteClass,\n          { provide: CACHE_DEFAULT_TTL, useValue: options.defaultTtl },\n          // CACHE token points to the same instance — no duplicate\n          { provide: CACHE, useExisting: ConcreteClass },\n        ]\n      : [\n          ConcreteClass,\n          { provide: CACHE, useExisting: ConcreteClass },\n        ];\n\n    return {\n      module: CacheModule,\n      global: true,\n      providers,\n      exports: [CACHE],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,SAAS,cAAkC;AAoB3C,IAAM,uBAAuB;AAE7B,SAAS,gBACP,SACA,IAC0C;AAC1C,QAAM,aAAa,QAAQ,cAAc;AACzC,MAAI,QAAQ,YAAY,WAAW;AACjC,QAAI,CAAC,IAAI;AACP,YAAM,IAAI;AAAA,QACR;AAAA,MAEF;AAAA,IACF;AACA,WAAO,IAAI,oBAAoB,IAAI,UAAU;AAAA,EAC/C;AACA,SAAO,IAAI,mBAAmB,UAAU;AAC1C;AAGO,IAAM,cAAN,MAAkB;AAAA,EACvB,OAAO,aAAa,cAAsD;AACxE,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,SAAU,aAAa,WAAW,CAAC;AAAA,MACnC,WAAW;AAAA,QACT;AAAA,UACE,SAAS;AAAA,UACT,YAAY,aAAa;AAAA,UACzB,QAAS,aAAa,UAAU,CAAC;AAAA,QACnC;AAAA,QACA;AAAA,UACE,SAAS;AAAA,UACT,YAAY,CAAC,SAA6B,OACxC,gBAAgB,SAAS,EAAE;AAAA,UAC7B,QAAQ,CAAC,sBAAsB,EAAE,OAAO,SAAS,UAAU,KAAK,CAAC;AAAA,QACnE;AAAA;AAAA,QAEA,EAAE,SAAS,qBAAqB,aAAa,MAAM;AAAA,QACnD,EAAE,SAAS,oBAAoB,aAAa,MAAM;AAAA,MACpD;AAAA,MACA,SAAS,CAAC,KAAK;AAAA,IACjB;AAAA,EACF;AAAA,EAEA,OAAO,QAAQ,UAA8B,EAAE,SAAS,UAAU,GAAkB;AAClF,UAAM,gBAAgB,QAAQ,YAAY,YAAY,sBAAsB;AAE5E,UAAM,YAAY,QAAQ,eAAe,SACrC;AAAA;AAAA,MAEE;AAAA,MACA,EAAE,SAAS,mBAAmB,UAAU,QAAQ,WAAW;AAAA;AAAA,MAE3D,EAAE,SAAS,OAAO,aAAa,cAAc;AAAA,IAC/C,IACA;AAAA,MACE;AAAA,MACA,EAAE,SAAS,OAAO,aAAa,cAAc;AAAA,IAC/C;AAEJ,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR;AAAA,MACA,SAAS,CAAC,KAAK;AAAA,IACjB;AAAA,EACF;AACF;AAjDa,cAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,GACG;","names":[]}

package/dist/chunk-2E224ZSN.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 = (index, decorator) => (target, key) => decorator(target, key, index);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __decorateClass,
+  __decorateParam,
+  __publicField
+};
+//# sourceMappingURL=chunk-2E224ZSN.js.map

package/dist/chunk-2E224ZSN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-2FTZLDBP.js

@@ -0,0 +1,179 @@
+import {
+  BaseRepository
+} from "./chunk-J6KZS54B.js";
+
+// runtime/base-classes/junction-integration-repository.ts
+import { and, eq } from "drizzle-orm";
+var JunctionIntegrationRepository = class extends BaseRepository {
+  /**
+   * Upsert ONE junction row by its composite identity, in a single transaction:
+   *   1. resolve the REQUIRED left FK (provider-scoped) — STRICT: missing → throws;
+   *   2. resolve the REQUIRED right FK (provider-scoped) — STRICT: missing → throws;
+   *   3. insert-or-update on the `(left, right[, role])` conflict target.
+   *
+   * Idempotent. Returns the composite externalId as the projection `id`.
+   *
+   * @param write     parent external ids (`<left>ExternalId`/`<right>ExternalId`)
+   *                  + optional `role` + `userId`
+   * @param provider  adapter/provider label used to scope the parent lookups
+   * @param tx        optional outer transaction; when omitted we open our own
+   */
+  async integrationUpsertOne(write, provider, tx) {
+    const cfg = this.integrationConfig;
+    const w = write;
+    const leftWriteKey = `${cfg.left.column.replace(/Id$/, "")}ExternalId`;
+    const rightWriteKey = `${cfg.right.column.replace(/Id$/, "")}ExternalId`;
+    const run = async (db) => {
+      const leftId = await this.resolveStrict(
+        db,
+        cfg.left.refTable,
+        w[leftWriteKey],
+        provider,
+        cfg.left.column
+      );
+      const rightId = await this.resolveStrict(
+        db,
+        cfg.right.refTable,
+        w[rightWriteKey],
+        provider,
+        cfg.right.column
+      );
+      const now = /* @__PURE__ */ new Date();
+      const role = cfg.roleColumn ? w["role"] : void 0;
+      const values = {
+        [cfg.left.column]: leftId,
+        [cfg.right.column]: rightId,
+        ...cfg.roleColumn ? { [cfg.roleColumn]: role } : {},
+        ...this.behaviors.timestamps ? { updatedAt: now } : {}
+      };
+      const target = cfg.roleColumn ? [this.table[cfg.left.column], this.table[cfg.right.column], this.table[cfg.roleColumn]] : [this.table[cfg.left.column], this.table[cfg.right.column]];
+      const rows = await db.insert(this.table).values(values).onConflictDoUpdate({
+        target,
+        set: { ...this.behaviors.timestamps ? { updatedAt: now } : {} }
+      }).returning();
+      const saved = rows[0];
+      return this.toProjection(saved, w, provider);
+    };
+    return tx ? run(tx) : this.db.transaction((t) => run(t));
+  }
+  /**
+   * Canonical-projected lookup by the COMPOSITE externalId, differ-ready. Parses
+   * the composite, resolves BOTH parents NON-throwing (→ null), then selects by
+   * the identity tuple. Returns `null` on malformed composite / unresolved
+   * parent / no row (a missing "before" side is a create from the differ's view).
+   */
+  async findByExternalIdProjected(externalId, provider) {
+    const cfg = this.integrationConfig;
+    const parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);
+    if (!parsed) return null;
+    const leftId = await this.resolveLoose(this.db, cfg.left.refTable, parsed.left, provider);
+    if (leftId === null) return null;
+    const rightId = await this.resolveLoose(this.db, cfg.right.refTable, parsed.right, provider);
+    if (rightId === null) return null;
+    const rows = await this.db.select().from(this.table).where(this.identityWhere(leftId, rightId, parsed.role)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    const w = {
+      [`${cfg.left.column.replace(/Id$/, "")}ExternalId`]: parsed.left,
+      [`${cfg.right.column.replace(/Id$/, "")}ExternalId`]: parsed.right,
+      ...cfg.roleColumn ? { role: parsed.role } : {},
+      userId: ""
+    };
+    return this.toProjection(row, w, provider);
+  }
+  /**
+   * Hard-delete the junction by composite externalId. Junctions have no
+   * `deleted_at` and no external-linkage columns to clear, so a integration "delete"
+   * removes the row. Resolves both parents NON-throwing, then deletes by the
+   * identity tuple. Returns the composite id, or `null` when nothing matched.
+   */
+  async softDeleteByExternalId(externalId, provider, tx) {
+    const cfg = this.integrationConfig;
+    const parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);
+    if (!parsed) return null;
+    const db = this.runner(tx);
+    const leftId = await this.resolveLoose(db, cfg.left.refTable, parsed.left, provider);
+    if (leftId === null) return null;
+    const rightId = await this.resolveLoose(db, cfg.right.refTable, parsed.right, provider);
+    if (rightId === null) return null;
+    const rows = await db.delete(this.table).where(this.identityWhere(leftId, rightId, parsed.role)).returning({ id: this.table[cfg.left.column] });
+    return rows[0] ? { id: externalId } : null;
+  }
+  /**
+   * Project a raw junction row to the differ shape: the COMPOSITE externalId
+   * `id` (junctions have no surrogate id) plus the local FK columns, role (when
+   * role-bearing) and timestamps — matching the emitted
+   * `<Junction>IntegrationProjection` interface (id + leftId + rightId + role? +
+   * createdAt + updatedAt). Junction projections are purely structural, so this
+   * is fully generic over `integrationConfig` — no per-junction override is emitted.
+   */
+  toProjection(row, write, _provider) {
+    const cfg = this.integrationConfig;
+    const r = row;
+    const leftExt = write[`${cfg.left.column.replace(/Id$/, "")}ExternalId`];
+    const rightExt = write[`${cfg.right.column.replace(/Id$/, "")}ExternalId`];
+    const role = cfg.roleColumn ? r[cfg.roleColumn] : void 0;
+    const out = {
+      id: buildCompositeExternalId(leftExt, rightExt, role),
+      [cfg.left.column]: r[cfg.left.column],
+      [cfg.right.column]: r[cfg.right.column]
+    };
+    if (cfg.roleColumn) out[cfg.roleColumn] = r[cfg.roleColumn];
+    out["createdAt"] = r["createdAt"];
+    out["updatedAt"] = r["updatedAt"];
+    return out;
+  }
+  /** Build the identity WHERE clause `(left, right[, role])`. */
+  identityWhere(leftId, rightId, role) {
+    const cfg = this.integrationConfig;
+    const conds = [
+      eq(this.table[cfg.left.column], leftId),
+      eq(this.table[cfg.right.column], rightId)
+    ];
+    if (cfg.roleColumn && role !== void 0) {
+      conds.push(eq(this.table[cfg.roleColumn], role));
+    }
+    return and(...conds);
+  }
+  /** Resolve a parent id (provider-scoped), throwing when unresolved. */
+  async resolveStrict(db, refTable, parentExternalId, provider, column) {
+    const id = await this.resolveLoose(db, refTable, parentExternalId, provider);
+    if (!id) {
+      throw new Error(
+        `${this.constructor.name}.integrationUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${column}' \u2014 parent not integrated yet`
+      );
+    }
+    return id;
+  }
+  /** Resolve a parent id (provider-scoped), returning null when unresolved. */
+  async resolveLoose(db, refTable, parentExternalId, provider) {
+    if (!parentExternalId) return null;
+    const rows = await db.select({ id: refTable["id"] }).from(refTable).where(
+      and(
+        eq(refTable["provider"], provider),
+        eq(refTable["externalId"], parentExternalId)
+      )
+    ).limit(1);
+    return rows[0]?.id ?? null;
+  }
+};
+function buildCompositeExternalId(leftExternalId, rightExternalId, role) {
+  return role !== void 0 ? `${leftExternalId}::${rightExternalId}::${role}` : `${leftExternalId}::${rightExternalId}`;
+}
+function parseCompositeExternalId(externalId, withRole) {
+  const parts = externalId.split("::");
+  const expected = withRole ? 3 : 2;
+  if (parts.length !== expected || parts.some((p) => p.length === 0)) return null;
+  return {
+    left: parts[0],
+    right: parts[1],
+    role: withRole ? parts[2] : void 0
+  };
+}
+
+export {
+  JunctionIntegrationRepository,
+  buildCompositeExternalId,
+  parseCompositeExternalId
+};
+//# sourceMappingURL=chunk-2FTZLDBP.js.map

package/dist/chunk-2FTZLDBP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/junction-integration-repository.ts"],"sourcesContent":["/**\n * JunctionIntegrationRepository<TEntity, TIntegrationWrite, TIntegrationProjection>\n *\n * Base for junction repos that participate in inbound integration (#374). A junction's\n * integration identity is the tuple `(leftId, rightId[, role])` — there is no native\n * `external_id`/`provider` column, so the integration seam's externalId is a COMPOSITE\n * string `<leftExternalId>::<rightExternalId>[::<role>]` (see the static\n * build/parse helpers below).\n *\n * Both parent FKs are resolved STRICTLY in the write path (a missing parent\n * throws → the orchestrator records a failed item and continues). As of #372\n * role-bearing junctions carry a unique constraint over `(left, right, role)`,\n * so the upsert uses `onConflictDoUpdate` (not the legacy select-then-write).\n * Role-less junctions conflict on `(left, right)`.\n */\nimport { and, eq } from 'drizzle-orm';\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nimport type { PgTableWithColumns } from 'drizzle-orm/pg-core';\nimport type { DrizzleTx } from '../types/drizzle';\nimport { BaseRepository } from './base-repository';\n\nexport interface JunctionIntegrationConfig {\n  /** Left endpoint: local FK column (camel) + strict parent table. */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  left: { column: string; refTable: PgTableWithColumns<any> };\n  /** Right endpoint: local FK column (camel) + strict parent table. */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  right: { column: string; refTable: PgTableWithColumns<any> };\n  /** Role column (camel), or null for a role-less (2-part composite) junction. */\n  roleColumn: string | null;\n}\n\nexport abstract class JunctionIntegrationRepository<\n  TEntity,\n  TIntegrationWrite,\n  TIntegrationProjection,\n> extends BaseRepository<TEntity> {\n  /**\n   * Declarative junction integration surface. Concrete repos declare this — the\n   * template emits it with live parent-table handles.\n   */\n  protected abstract readonly integrationConfig: JunctionIntegrationConfig;\n\n  /**\n   * Upsert ONE junction row by its composite identity, in a single transaction:\n   *   1. resolve the REQUIRED left FK (provider-scoped) — STRICT: missing → throws;\n   *   2. resolve the REQUIRED right FK (provider-scoped) — STRICT: missing → throws;\n   *   3. insert-or-update on the `(left, right[, role])` conflict target.\n   *\n   * Idempotent. Returns the composite externalId as the projection `id`.\n   *\n   * @param write     parent external ids (`<left>ExternalId`/`<right>ExternalId`)\n   *                  + optional `role` + `userId`\n   * @param provider  adapter/provider label used to scope the parent lookups\n   * @param tx        optional outer transaction; when omitted we open our own\n   */\n  async integrationUpsertOne(\n    write: TIntegrationWrite,\n    provider: string,\n    tx?: DrizzleTx,\n  ): Promise<TIntegrationProjection> {\n    const cfg = this.integrationConfig;\n    const w = write as Record<string, unknown>;\n    const leftWriteKey = `${cfg.left.column.replace(/Id$/, '')}ExternalId`;\n    const rightWriteKey = `${cfg.right.column.replace(/Id$/, '')}ExternalId`;\n\n    const run = async (db: DrizzleTx): Promise<TIntegrationProjection> => {\n      const leftId = await this.resolveStrict(\n        db, cfg.left.refTable, w[leftWriteKey] as string, provider, cfg.left.column,\n      );\n      const rightId = await this.resolveStrict(\n        db, cfg.right.refTable, w[rightWriteKey] as string, provider, cfg.right.column,\n      );\n\n      const now = new Date();\n      const role = cfg.roleColumn ? (w['role'] as unknown) : undefined;\n      const values: Record<string, unknown> = {\n        [cfg.left.column]: leftId,\n        [cfg.right.column]: rightId,\n        ...(cfg.roleColumn ? { [cfg.roleColumn]: role } : {}),\n        ...(this.behaviors.timestamps ? { updatedAt: now } : {}),\n      };\n      const target = cfg.roleColumn\n        ? [this.table[cfg.left.column], this.table[cfg.right.column], this.table[cfg.roleColumn]]\n        : [this.table[cfg.left.column], this.table[cfg.right.column]];\n\n      const rows = await db\n        .insert(this.table)\n        .values(values as never)\n        .onConflictDoUpdate({\n          target,\n          set: { ...(this.behaviors.timestamps ? { updatedAt: now } : {}) } as never,\n        })\n        .returning();\n\n      const saved = rows[0] as Record<string, unknown>;\n      return this.toProjection(saved as TEntity, w, provider);\n    };\n\n    return tx ? run(tx) : this.db.transaction((t) => run(t));\n  }\n\n  /**\n   * Canonical-projected lookup by the COMPOSITE externalId, differ-ready. Parses\n   * the composite, resolves BOTH parents NON-throwing (→ null), then selects by\n   * the identity tuple. Returns `null` on malformed composite / unresolved\n   * parent / no row (a missing \"before\" side is a create from the differ's view).\n   */\n  async findByExternalIdProjected(\n    externalId: string,\n    provider: string,\n  ): Promise<TIntegrationProjection | null> {\n    const cfg = this.integrationConfig;\n    const parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);\n    if (!parsed) return null;\n\n    const leftId = await this.resolveLoose(this.db, cfg.left.refTable, parsed.left, provider);\n    if (leftId === null) return null;\n    const rightId = await this.resolveLoose(this.db, cfg.right.refTable, parsed.right, provider);\n    if (rightId === null) return null;\n\n    const rows = await this.db\n      .select()\n      .from(this.table)\n      .where(this.identityWhere(leftId, rightId, parsed.role))\n      .limit(1);\n    const row = rows[0] as TEntity | undefined;\n    if (!row) return null;\n\n    const w: Record<string, unknown> = {\n      [`${cfg.left.column.replace(/Id$/, '')}ExternalId`]: parsed.left,\n      [`${cfg.right.column.replace(/Id$/, '')}ExternalId`]: parsed.right,\n      ...(cfg.roleColumn ? { role: parsed.role } : {}),\n      userId: '',\n    };\n    return this.toProjection(row, w, provider);\n  }\n\n  /**\n   * Hard-delete the junction by composite externalId. Junctions have no\n   * `deleted_at` and no external-linkage columns to clear, so a integration \"delete\"\n   * removes the row. Resolves both parents NON-throwing, then deletes by the\n   * identity tuple. Returns the composite id, or `null` when nothing matched.\n   */\n  async softDeleteByExternalId(\n    externalId: string,\n    provider: string,\n    tx?: DrizzleTx,\n  ): Promise<{ id: string } | null> {\n    const cfg = this.integrationConfig;\n    const parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);\n    if (!parsed) return null;\n    const db = this.runner(tx);\n\n    const leftId = await this.resolveLoose(db, cfg.left.refTable, parsed.left, provider);\n    if (leftId === null) return null;\n    const rightId = await this.resolveLoose(db, cfg.right.refTable, parsed.right, provider);\n    if (rightId === null) return null;\n\n    const rows = await db\n      .delete(this.table)\n      .where(this.identityWhere(leftId, rightId, parsed.role))\n      .returning({ id: this.table[cfg.left.column] });\n    return rows[0] ? { id: externalId } : null;\n  }\n\n  /**\n   * Project a raw junction row to the differ shape: the COMPOSITE externalId\n   * `id` (junctions have no surrogate id) plus the local FK columns, role (when\n   * role-bearing) and timestamps — matching the emitted\n   * `<Junction>IntegrationProjection` interface (id + leftId + rightId + role? +\n   * createdAt + updatedAt). Junction projections are purely structural, so this\n   * is fully generic over `integrationConfig` — no per-junction override is emitted.\n   */\n  protected toProjection(\n    row: TEntity,\n    write: Record<string, unknown>,\n    _provider: string,\n  ): TIntegrationProjection {\n    const cfg = this.integrationConfig;\n    const r = row as Record<string, unknown>;\n    const leftExt = write[`${cfg.left.column.replace(/Id$/, '')}ExternalId`] as string;\n    const rightExt = write[`${cfg.right.column.replace(/Id$/, '')}ExternalId`] as string;\n    const role = cfg.roleColumn ? (r[cfg.roleColumn] as string | undefined) : undefined;\n    const out: Record<string, unknown> = {\n      id: buildCompositeExternalId(leftExt, rightExt, role),\n      [cfg.left.column]: r[cfg.left.column],\n      [cfg.right.column]: r[cfg.right.column],\n    };\n    if (cfg.roleColumn) out[cfg.roleColumn] = r[cfg.roleColumn];\n    out['createdAt'] = r['createdAt'];\n    out['updatedAt'] = r['updatedAt'];\n    return out as TIntegrationProjection;\n  }\n\n  /** Build the identity WHERE clause `(left, right[, role])`. */\n  private identityWhere(leftId: string, rightId: string, role: string | undefined) {\n    const cfg = this.integrationConfig;\n    const conds = [\n      eq(this.table[cfg.left.column], leftId),\n      eq(this.table[cfg.right.column], rightId),\n    ];\n    if (cfg.roleColumn && role !== undefined) {\n      conds.push(eq(this.table[cfg.roleColumn], role));\n    }\n    return and(...conds);\n  }\n\n  /** Resolve a parent id (provider-scoped), throwing when unresolved. */\n  private async resolveStrict(\n    db: DrizzleTx,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    refTable: PgTableWithColumns<any>,\n    parentExternalId: string,\n    provider: string,\n    column: string,\n  ): Promise<string> {\n    const id = await this.resolveLoose(db, refTable, parentExternalId, provider);\n    if (!id) {\n      throw new Error(\n        `${this.constructor.name}.integrationUpsertOne: unresolved parent ` +\n          `'${parentExternalId}' (provider '${provider}') for '${column}' — ` +\n          `parent not integrated yet`,\n      );\n    }\n    return id;\n  }\n\n  /** Resolve a parent id (provider-scoped), returning null when unresolved. */\n  private async resolveLoose(\n    db: DrizzleTx,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    refTable: PgTableWithColumns<any>,\n    parentExternalId: string | null | undefined,\n    provider: string,\n  ): Promise<string | null> {\n    if (!parentExternalId) return null;\n    const rows = await db\n      .select({ id: refTable['id'] })\n      .from(refTable)\n      .where(\n        and(\n          eq(refTable['provider'], provider),\n          eq(refTable['externalId'], parentExternalId),\n        ),\n      )\n      .limit(1);\n    return (rows[0]?.id as string | undefined) ?? null;\n  }\n}\n\n// ============================================================================\n// Composite externalId — the junction integration seam's deterministic identity.\n//\n// Format: `<leftExternalId>::<rightExternalId>[::<role>]`\n//   e.g. `hubspot:42::hubspot:99::employee`  (role-bearing)\n//        `hubspot:42::hubspot:99`            (role-less)\n//\n// Vendor-prefixed ids use a SINGLE colon, so `::` is an unambiguous delimiter.\n// Kept static in the base (replacing the per-repo free functions) so every\n// junction's lookups + its ChangeSource share one definition.\n// ============================================================================\n\n/**\n * Build the composite externalId from the two parent external ids (+ role when\n * the junction is role-bearing).\n */\nexport function buildCompositeExternalId(\n  leftExternalId: string,\n  rightExternalId: string,\n  role?: string,\n): string {\n  return role !== undefined\n    ? `${leftExternalId}::${rightExternalId}::${role}`\n    : `${leftExternalId}::${rightExternalId}`;\n}\n\n/**\n * Parse a composite externalId. `withRole` selects the expected part count\n * (3 when role-bearing, else 2). Returns `null` when the shape doesn't match\n * or any part is empty.\n */\nexport function parseCompositeExternalId(\n  externalId: string,\n  withRole: boolean,\n): { left: string; right: string; role: string | undefined } | null {\n  const parts = externalId.split('::');\n  const expected = withRole ? 3 : 2;\n  if (parts.length !== expected || parts.some((p) => p.length === 0)) return null;\n  return {\n    left: parts[0] as string,\n    right: parts[1] as string,\n    role: withRole ? (parts[2] as string) : undefined,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-2N4UG4VD.js

@@ -0,0 +1,20 @@
+// runtime/subsystems/auth/runtime/connection-broken.error.ts
+var ConnectionBrokenError = class extends Error {
+  constructor(connectionId, errorCode, errorDescription) {
+    super(
+      `Connection ${connectionId} broken: ${errorCode} - ${errorDescription}`
+    );
+    this.connectionId = connectionId;
+    this.errorCode = errorCode;
+    this.errorDescription = errorDescription;
+    this.name = "ConnectionBrokenError";
+  }
+  connectionId;
+  errorCode;
+  errorDescription;
+};
+
+export {
+  ConnectionBrokenError
+};
+//# sourceMappingURL=chunk-2N4UG4VD.js.map

package/dist/chunk-2N4UG4VD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/auth/runtime/connection-broken.error.ts"],"sourcesContent":["/**\n * Thrown when an OAuth2 provider returns `400 invalid_grant`/`invalid_token`\n * on refresh — the refresh token itself is dead (user revoked, org\n * deactivated, token expired beyond the provider's rotation window). The\n * connection should be marked broken so background sync stops picking it\n * up; the user re-initiates OAuth.\n *\n * Shared across every OAuth2 strategy.\n */\nexport class ConnectionBrokenError extends Error {\n  constructor(\n    readonly connectionId: string,\n    readonly errorCode: string,\n    readonly errorDescription: string,\n  ) {\n    super(\n      `Connection ${connectionId} broken: ${errorCode} - ${errorDescription}`,\n    );\n    this.name = 'ConnectionBrokenError';\n  }\n}\n"],"mappings":";AASO,IAAM,wBAAN,cAAoC,MAAM;AAAA,EAC/C,YACW,cACA,WACA,kBACT;AACA;AAAA,MACE,cAAc,YAAY,YAAY,SAAS,MAAM,gBAAgB;AAAA,IACvE;AANS;AACA;AACA;AAKT,SAAK,OAAO;AAAA,EACd;AAAA,EARW;AAAA,EACA;AAAA,EACA;AAOb;","names":[]}

package/dist/chunk-2TVVBC53.js

@@ -0,0 +1,92 @@
+import {
+  jobRuns
+} from "./chunk-OKXZ63IA.js";
+import {
+  domainEvents
+} from "./chunk-OFRRBC7M.js";
+
+// runtime/subsystems/bridge/bridge-delivery.schema.ts
+import {
+  index,
+  jsonb,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  unique,
+  uuid
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+var bridgeDeliveryStatusEnum = pgEnum("bridge_delivery_status", [
+  "pending",
+  "delivered",
+  "skipped",
+  "failed"
+]);
+var bridgeDelivery = pgTable(
+  "bridge_delivery",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** FK to the source event in the outbox. */
+    eventId: uuid("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: text("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: uuid("wrapper_run_id").references(() => jobRuns.id),
+    /**
+     * Spawned user `job_run.id`. Null until status is `delivered`; remains
+     * null for `skipped` and `failed` deliveries.
+     */
+    userRunId: uuid("user_run_id").references(() => jobRuns.id),
+    status: bridgeDeliveryStatusEnum("status").notNull().default("pending"),
+    /** Populated when status=`skipped` (e.g. `'when_returned_false'`, `'trigger_unregistered'`). */
+    skipReason: text("skip_reason"),
+    /** Populated when status=`failed`. Mirrors `job_run.error` shape. */
+    error: jsonb("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: text("tenant_id"),
+    attemptedAt: timestamp("attempted_at", { withTimezone: true }).notNull().defaultNow(),
+    deliveredAt: timestamp("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: index("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: index("idx_bridge_delivery_status").on(t.status).where(sql`${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: index("idx_bridge_delivery_user_run").on(t.userRunId).where(sql`${t.userRunId} IS NOT NULL`)
+  })
+);
+
+export {
+  bridgeDeliveryStatusEnum,
+  bridgeDelivery
+};
+//# sourceMappingURL=chunk-2TVVBC53.js.map

package/dist/chunk-2TVVBC53.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/bridge/bridge-delivery.schema.ts"],"sourcesContent":["/**\n * Drizzle schema for the `bridge_delivery` ledger (ADR-023 Phase 2, BRIDGE-1).\n *\n * The `bridge_delivery` table is the idempotency ledger for the event-to-job\n * bridge. Every (event, trigger) pair the bridge is asked to spawn produces\n * exactly one row; the `UNIQUE (event_id, trigger_id)` constraint guarantees\n * that:\n *\n *   1. Outbox replays of an event do not double-spawn user job runs — the\n *      drain attempts to insert the duplicate, the constraint trips, and the\n *      drain skips that trigger.\n *   2. The `IEventFlow.publishAndStart` facade can pre-write a\n *      `(status='delivered')` row before the drain runs (Case B from ADR-023\n *      §`publishAndStart` + existing `triggers:` collision); the drain then\n *      hits UNIQUE on that trigger and skips it while still spawning any\n *      other triggers for the same event normally.\n *\n * Status values:\n *   - `pending`   — wrapper run exists; user job not yet started.\n *   - `delivered` — user job started; `user_run_id` populated.\n *   - `skipped`   — intentional no-op (`when:` returned false, or\n *                   facade-eager path pre-empted the bridge spawn).\n *   - `failed`    — wrapper exhausted retry policy; no auto-retry past that\n *                   (mirrors events outbox stance — ops eyes only).\n *\n * `wrapper_run_id` is **nullable**: the facade-eager path (Case B) pre-writes\n * `bridge_delivery` with no wrapper. The bridge-drain path always populates\n * it.\n *\n * `tenant_id` is emitted **unconditionally and nullable** (per JOB-8\n * 2026-04-20 reversal); enforcement is service-layer (BRIDGE-8) gated on the\n * `BRIDGE_MULTI_TENANT` DI token, not a DB constraint.\n *\n * Indexes:\n *   - `bridge_delivery_event_idx` — lookup all deliveries for an event.\n *   - `bridge_delivery_status_idx` — partial; ops dashboards filter by\n *     `pending | failed`.\n *   - `bridge_delivery_user_run_idx` — partial; reverse lookup from a\n *     spawned user run back to its delivery row.\n *\n * No service logic, no DI wiring — this is the schema foundation. Backends\n * (memory + drizzle) and the framework handler land in BRIDGE-3 / BRIDGE-4 /\n * BRIDGE-5.\n */\nimport {\n  index,\n  jsonb,\n  pgEnum,\n  pgTable,\n  text,\n  timestamp,\n  unique,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport { sql } from 'drizzle-orm';\nimport type { InferSelectModel } from 'drizzle-orm';\n\nimport { domainEvents } from '../events/domain-events.schema';\nimport { jobRuns } from '../jobs/job-orchestration.schema';\n\n// ─── Enum ───────────────────────────────────────────────────────────────────\n\nexport const bridgeDeliveryStatusEnum = pgEnum('bridge_delivery_status', [\n  'pending',\n  'delivered',\n  'skipped',\n  'failed',\n]);\n\n// ─── Table ──────────────────────────────────────────────────────────────────\n\nexport const bridgeDelivery = pgTable(\n  'bridge_delivery',\n  {\n    id: uuid('id').primaryKey().defaultRandom(),\n    /** FK to the source event in the outbox. */\n    eventId: uuid('event_id')\n      .notNull()\n      .references(() => domainEvents.id),\n    /**\n     * Stable codegen-emitted identifier for the (job, trigger) pair, of the\n     * form `<job_type>#<triggerIndex>` (BRIDGE-6). Forms the second half of\n     * the UNIQUE idempotency key.\n     */\n    triggerId: text('trigger_id').notNull(),\n    /**\n     * Wrapper `job_run.id` (the framework `@framework/bridge_delivery` run\n     * that drove this delivery). Nullable: the facade-eager path\n     * (`publishAndStart` Case B) pre-writes a delivered row with no wrapper.\n     */\n    wrapperRunId: uuid('wrapper_run_id').references(() => jobRuns.id),\n    /**\n     * Spawned user `job_run.id`. Null until status is `delivered`; remains\n     * null for `skipped` and `failed` deliveries.\n     */\n    userRunId: uuid('user_run_id').references(() => jobRuns.id),\n    status: bridgeDeliveryStatusEnum('status').notNull().default('pending'),\n    /** Populated when status=`skipped` (e.g. `'when_returned_false'`, `'trigger_unregistered'`). */\n    skipReason: text('skip_reason'),\n    /** Populated when status=`failed`. Mirrors `job_run.error` shape. */\n    error: jsonb('error').$type<Record<string, unknown>>(),\n    /**\n     * Emitted unconditionally and nullable (JOB-8 / SYNC-6 precedent).\n     * Enforcement gated on `BRIDGE_MULTI_TENANT` at the service layer\n     * (BRIDGE-8); no DB constraint.\n     */\n    tenantId: text('tenant_id'),\n    attemptedAt: timestamp('attempted_at', { withTimezone: true })\n      .notNull()\n      .defaultNow(),\n    deliveredAt: timestamp('delivered_at', { withTimezone: true }),\n  },\n  (t) => ({\n    /**\n     * Idempotency ledger. Outbox replays and facade-vs-drain collisions both\n     * dedup through this constraint.\n     */\n    uqBridgeDeliveryEventTrigger: unique('uq_bridge_delivery_event_trigger').on(\n      t.eventId,\n      t.triggerId,\n    ),\n    /** Lookup all deliveries for an event (fanout report, debugging). */\n    idxBridgeDeliveryEvent: index('idx_bridge_delivery_event').on(t.eventId),\n    /**\n     * Ops dashboard filter — only the actionable states. Partial index keeps\n     * it small at scale (the bulk of rows will be `delivered`).\n     */\n    idxBridgeDeliveryStatus: index('idx_bridge_delivery_status')\n      .on(t.status)\n      .where(sql`${t.status} IN ('pending','failed')`),\n    /**\n     * Reverse lookup from a spawned user run back to its delivery row.\n     * Partial — most rows in the bridge ledger but only successful\n     * deliveries have a `user_run_id`.\n     */\n    idxBridgeDeliveryUserRun: index('idx_bridge_delivery_user_run')\n      .on(t.userRunId)\n      .where(sql`${t.userRunId} IS NOT NULL`),\n  }),\n);\n\nexport type BridgeDeliveryRecord = InferSelectModel<typeof bridgeDelivery>;\n"],"mappings":";;;;;;;;AA4CA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AAQb,IAAM,2BAA2B,OAAO,0BAA0B;AAAA,EACvE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAIM,IAAM,iBAAiB;AAAA,EAC5B;AAAA,EACA;AAAA,IACE,IAAI,KAAK,IAAI,EAAE,WAAW,EAAE,cAAc;AAAA;AAAA,IAE1C,SAAS,KAAK,UAAU,EACrB,QAAQ,EACR,WAAW,MAAM,aAAa,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMnC,WAAW,KAAK,YAAY,EAAE,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMtC,cAAc,KAAK,gBAAgB,EAAE,WAAW,MAAM,QAAQ,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA,IAKhE,WAAW,KAAK,aAAa,EAAE,WAAW,MAAM,QAAQ,EAAE;AAAA,IAC1D,QAAQ,yBAAyB,QAAQ,EAAE,QAAQ,EAAE,QAAQ,SAAS;AAAA;AAAA,IAEtE,YAAY,KAAK,aAAa;AAAA;AAAA,IAE9B,OAAO,MAAM,OAAO,EAAE,MAA+B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMrD,UAAU,KAAK,WAAW;AAAA,IAC1B,aAAa,UAAU,gBAAgB,EAAE,cAAc,KAAK,CAAC,EAC1D,QAAQ,EACR,WAAW;AAAA,IACd,aAAa,UAAU,gBAAgB,EAAE,cAAc,KAAK,CAAC;AAAA,EAC/D;AAAA,EACA,CAAC,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,IAKN,8BAA8B,OAAO,kCAAkC,EAAE;AAAA,MACvE,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA;AAAA,IAEA,wBAAwB,MAAM,2BAA2B,EAAE,GAAG,EAAE,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,IAKvE,yBAAyB,MAAM,4BAA4B,EACxD,GAAG,EAAE,MAAM,EACX,MAAM,MAAM,EAAE,MAAM,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMjD,0BAA0B,MAAM,8BAA8B,EAC3D,GAAG,EAAE,SAAS,EACd,MAAM,MAAM,EAAE,SAAS,cAAc;AAAA,EAC1C;AACF;","names":[]}

package/dist/chunk-2VHZ7EKC.js

@@ -0,0 +1,37 @@
+import {
+  BaseService
+} from "./chunk-W72PRNJY.js";
+
+// runtime/base-classes/integrated-entity-service.ts
+var IntegratedEntityService = class extends BaseService {
+  /**
+   * Find a single entity by its external CRM identifier.
+   */
+  findByExternalId(externalId) {
+    return this.repository.findByExternalId(externalId);
+  }
+  /**
+   * Find multiple entities by external CRM identifiers.
+   */
+  findManyByExternalIds(externalIds) {
+    return this.repository.findManyByExternalIds(externalIds);
+  }
+  /**
+   * Find all entities owned by a specific user.
+   */
+  findAllByUser(userId) {
+    return this.repository.findAllByUserId(userId);
+  }
+  /**
+   * Find entities visible to a user (ownership + sharing rules).
+   * Concrete services may override with domain-specific visibility logic.
+   */
+  findVisibleByUser(userId) {
+    return this.repository.findVisibleByUserId(userId);
+  }
+};
+
+export {
+  IntegratedEntityService
+};
+//# sourceMappingURL=chunk-2VHZ7EKC.js.map

package/dist/chunk-2VHZ7EKC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/integrated-entity-service.ts"],"sourcesContent":["/**\n * IntegratedEntityService<TRepo, TEntity>\n *\n * Family-specific base service for Integrated entities.\n * Delegates to a CRM repository that provides external ID lookups\n * and user-scoped queries.\n */\nimport { BaseService, type IBaseRepository } from './base-service';\n\nexport interface IIntegratedEntityRepository<TEntity> extends IBaseRepository<TEntity> {\n  findByExternalId(externalId: string): Promise<TEntity | null>;\n  findManyByExternalIds(externalIds: string[]): Promise<TEntity[]>;\n  findAllByUserId(userId: string): Promise<TEntity[]>;\n  findVisibleByUserId(userId: string): Promise<TEntity[]>;\n  integrationUpsert(inputs: Array<Partial<TEntity>>): Promise<TEntity[]>;\n}\n\nexport abstract class IntegratedEntityService<\n  TRepo extends IIntegratedEntityRepository<TEntity>,\n  TEntity,\n> extends BaseService<TRepo, TEntity> {\n  /**\n   * Find a single entity by its external CRM identifier.\n   */\n  findByExternalId(externalId: string): Promise<TEntity | null> {\n    return this.repository.findByExternalId(externalId);\n  }\n\n  /**\n   * Find multiple entities by external CRM identifiers.\n   */\n  findManyByExternalIds(externalIds: string[]): Promise<TEntity[]> {\n    return this.repository.findManyByExternalIds(externalIds);\n  }\n\n  /**\n   * Find all entities owned by a specific user.\n   */\n  findAllByUser(userId: string): Promise<TEntity[]> {\n    return this.repository.findAllByUserId(userId);\n  }\n\n  /**\n   * Find entities visible to a user (ownership + sharing rules).\n   * Concrete services may override with domain-specific visibility logic.\n   */\n  findVisibleByUser(userId: string): Promise<TEntity[]> {\n    return this.repository.findVisibleByUserId(userId);\n  }\n}\n"],"mappings":";;;;;AAiBO,IAAe,0BAAf,cAGG,YAA4B;AAAA;AAAA;AAAA;AAAA,EAIpC,iBAAiB,YAA6C;AAC5D,WAAO,KAAK,WAAW,iBAAiB,UAAU;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA,EAKA,sBAAsB,aAA2C;AAC/D,WAAO,KAAK,WAAW,sBAAsB,WAAW;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc,QAAoC;AAChD,WAAO,KAAK,WAAW,gBAAgB,MAAM;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,kBAAkB,QAAoC;AACpD,WAAO,KAAK,WAAW,oBAAoB,MAAM;AAAA,EACnD;AACF;","names":[]}