@pattern-stack/codegen 0.15.0 → 0.15.2

package/dist/chunk-OSQRXVG2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/auth/middleware/requester-context.ts"],"sourcesContent":["/**\n * RequesterContext boundary install — bridges authentication to ambient\n * tenant scoping.\n *\n * This is the missing link that makes `BaseRepository`'s ambient scoping\n * (see `base-classes/tenant-context.ts`) actually engage on HTTP requests:\n * it reads the requester off each request (via the consumer-bound\n * `IUserContext`) and runs the rest of the request inside `withRequester(...)`,\n * so every downstream repository read/write is automatically scoped — no\n * threaded `userId`.\n *\n * ## Wiring (one line in your bootstrap)\n *\n * In `main.ts`, after `NestFactory.create`:\n *\n * ```ts\n * import { installRequesterContext } from './shared/subsystems/auth/middleware/requester-context';\n * const app = await NestFactory.create(AppModule);\n * installRequesterContext(app); // no-op + warn if AUTH_USER_CONTEXT is unbound\n * ```\n *\n * `installRequesterContext` resolves `AUTH_USER_CONTEXT` from the root DI\n * container (so it sees the binding the consumer provides in AppModule) and\n * registers a global Express middleware. Pairs with Swagger's `@ApiBearerAuth`\n * \"Authorize\" button: paste a token there and every request it sends now flows\n * through this boundary into a scoped repository call.\n *\n * ## Trust + failure model\n *\n * - The middleware TRUSTS whatever `IUserContext` returns — authentication and\n *   authorization (validating the token, deciding which scope a requester may\n *   claim) are the `IUserContext` implementation's job, exactly as for a\n *   hand-threaded `userId`.\n * - When the requester cannot be resolved (no/invalid credentials — e.g. a\n *   public route, or the OAuth callback itself), the request proceeds WITHOUT\n *   an ambient context (`onUnresolved: 'unscoped'`, the default). A\n *   `userTracking` repo in lenient mode then runs unscoped; in strict mode it\n *   throws downstream — which is correct: unauthenticated callers must not\n *   reach scoped data. Set `onUnresolved: 'reject'` to fail the request at the\n *   boundary instead.\n */\nimport type { INestApplication } from '@nestjs/common';\nimport {\n  withRequester,\n  type RequesterContext,\n} from '../../../base-classes/tenant-context';\nimport { AUTH_USER_CONTEXT } from '../auth.tokens';\nimport type { IUserContext } from '../protocols/user-context';\n\n/** Minimal Express-style middleware signature (avoids an `express` dep). */\ntype NextFn = (err?: unknown) => void;\ntype RequestHandler = (req: unknown, res: unknown, next: NextFn) => void;\n\nexport interface RequesterContextOptions {\n  /**\n   * What to do when `IUserContext` cannot resolve a requester (throws, or\n   * returns no `userId`).\n   * - `'unscoped'` (default): proceed without a context — public routes work;\n   *   scoped repos run unscoped (lenient) or throw downstream (strict).\n   * - `'reject'`: fail the request at the boundary (`next(error)`).\n   */\n  onUnresolved?: 'unscoped' | 'reject';\n}\n\n/**\n * Resolve the ambient context for a request: prefer the richer\n * `resolveRequester` (org/superuser), else derive plain `'user'` scope from\n * `getCurrentUserId`. Returns `undefined` when no requester can be determined.\n */\nexport async function resolveRequesterContext(\n  userContext: IUserContext,\n  req: unknown,\n): Promise<RequesterContext | undefined> {\n  if (typeof userContext.resolveRequester === 'function') {\n    const ctx = await userContext.resolveRequester(req);\n    return ctx?.userId ? ctx : undefined;\n  }\n  const userId = await userContext.getCurrentUserId(req);\n  return userId ? { userId, organizationId: null } : undefined;\n}\n\n/**\n * Build the global middleware. Runs the remainder of the request inside\n * `withRequester(...)` so the ambient context propagates through every `await`\n * to downstream repositories.\n */\nexport function makeRequesterContextMiddleware(\n  userContext: IUserContext,\n  options: RequesterContextOptions = {},\n): RequestHandler {\n  const onUnresolved = options.onUnresolved ?? 'unscoped';\n  return (req, _res, next) => {\n    resolveRequesterContext(userContext, req).then(\n      (ctx) => {\n        if (!ctx) {\n          next();\n          return;\n        }\n        // als.run executes its callback synchronously; Express dispatches the\n        // rest of the pipeline inside next(), so all downstream handlers (and\n        // their awaits) inherit this context.\n        withRequester(ctx, async () => {\n          next();\n        });\n      },\n      (err) => {\n        if (onUnresolved === 'reject') {\n          next(err);\n          return;\n        }\n        next();\n      },\n    );\n  };\n}\n\n/**\n * Register the requester-context boundary on a Nest app. Resolves\n * `AUTH_USER_CONTEXT` from the root container (so it sees the consumer's\n * AppModule binding) and installs the global middleware. No-ops with a warning\n * when `AUTH_USER_CONTEXT` is not bound, so calling it unconditionally in\n * bootstrap is safe.\n */\nexport function installRequesterContext(\n  app: INestApplication,\n  options: RequesterContextOptions = {},\n): void {\n  const userContext = app.get<IUserContext>(AUTH_USER_CONTEXT, {\n    strict: false,\n  });\n  if (!userContext) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      '[auth] installRequesterContext: AUTH_USER_CONTEXT is not bound — ' +\n        'request scoping NOT installed. Provide an IUserContext under ' +\n        'AUTH_USER_CONTEXT in your AppModule to enable ambient tenant scoping.',\n    );\n    return;\n  }\n  app.use(makeRequesterContextMiddleware(userContext, options));\n}\n"],"mappings":";;;;;;;;AAqEA,eAAsB,wBACpB,aACA,KACuC;AACvC,MAAI,OAAO,YAAY,qBAAqB,YAAY;AACtD,UAAM,MAAM,MAAM,YAAY,iBAAiB,GAAG;AAClD,WAAO,KAAK,SAAS,MAAM;AAAA,EAC7B;AACA,QAAM,SAAS,MAAM,YAAY,iBAAiB,GAAG;AACrD,SAAO,SAAS,EAAE,QAAQ,gBAAgB,KAAK,IAAI;AACrD;AAOO,SAAS,+BACd,aACA,UAAmC,CAAC,GACpB;AAChB,QAAM,eAAe,QAAQ,gBAAgB;AAC7C,SAAO,CAAC,KAAK,MAAM,SAAS;AAC1B,4BAAwB,aAAa,GAAG,EAAE;AAAA,MACxC,CAAC,QAAQ;AACP,YAAI,CAAC,KAAK;AACR,eAAK;AACL;AAAA,QACF;AAIA,sBAAc,KAAK,YAAY;AAC7B,eAAK;AAAA,QACP,CAAC;AAAA,MACH;AAAA,MACA,CAAC,QAAQ;AACP,YAAI,iBAAiB,UAAU;AAC7B,eAAK,GAAG;AACR;AAAA,QACF;AACA,aAAK;AAAA,MACP;AAAA,IACF;AAAA,EACF;AACF;AASO,SAAS,wBACd,KACA,UAAmC,CAAC,GAC9B;AACN,QAAM,cAAc,IAAI,IAAkB,mBAAmB;AAAA,IAC3D,QAAQ;AAAA,EACV,CAAC;AACD,MAAI,CAAC,aAAa;AAEhB,YAAQ;AAAA,MACN;AAAA,IAGF;AACA;AAAA,EACF;AACA,MAAI,IAAI,+BAA+B,aAAa,OAAO,CAAC;AAC9D;","names":[]}

package/dist/chunk-OTDN3OUQ.js

@@ -0,0 +1,215 @@
+import {
+  BaseRepository
+} from "./chunk-J6KZS54B.js";
+
+// runtime/base-classes/integrated-entity-repository.ts
+import { and, eq, inArray } from "drizzle-orm";
+var IntegratedEntityRepository = class extends BaseRepository {
+  /**
+   * Find a single entity by its external CRM identifier.
+   */
+  async findByExternalId(externalId) {
+    const rows = await this.baseQuery().where(eq(this.table["externalId"], externalId)).limit(1);
+    return rows[0] ?? null;
+  }
+  /**
+   * Find multiple entities by external CRM identifiers.
+   */
+  async findManyByExternalIds(externalIds) {
+    if (externalIds.length === 0) return [];
+    const rows = await this.baseQuery().where(inArray(this.table["externalId"], externalIds));
+    return rows;
+  }
+  /**
+   * Find all entities owned by a specific user.
+   */
+  async findAllByUserId(userId) {
+    const rows = await this.baseQuery().where(eq(this.table["userId"], userId));
+    return rows;
+  }
+  // ==========================================================================
+  // Inbound integration (#374) — canonical→Drizzle write + provider-scoped FK
+  // resolution + EAV dual-write seam, all inside a SINGLE transaction.
+  // Driven entirely by `this.integrationConfig`; the per-entity shape lives there.
+  // ==========================================================================
+  /**
+   * Upsert ONE entity by its `(provider, externalId)` identity, in a single
+   * transaction:
+   *   1. resolve each `integrationConfig.fkResolvers` FK (provider-scoped). Strict
+   *      resolvers throw on unresolved; non-strict leave the column null.
+   *   2. insert-or-update the canonical columns via `onConflictDoUpdate` on the
+   *      `conflictTarget`. Resolved FKs are only written into `set` when
+   *      non-null this run (no-clobber).
+   *   3. EAV dual-write of `write.fields` via `writeCustomFields` when
+   *      `integrationConfig.eav` and the bag is non-empty (same tx).
+   *
+   * Idempotent: a second call with the same identity updates in place. Returns
+   * the canonical projection (so the orchestrator records `local_id`).
+   *
+   * @param write     canonical fields + parent external ids + custom-field bag
+   * @param provider  adapter/provider label persisted + used to scope 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 run = async (db) => {
+      const resolvedFks = {};
+      for (const fk of cfg.fkResolvers) {
+        resolvedFks[fk.column] = await this.resolveFk(db, fk, w[fk.writeKey], provider);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const copyThrough = {};
+      for (const col of cfg.writeColumns) copyThrough[col] = w[col];
+      const values = {
+        externalId: w["externalId"],
+        provider,
+        ...copyThrough,
+        ...resolvedFks,
+        ...this.behaviors.timestamps ? { updatedAt: now } : {}
+      };
+      const set = {
+        ...copyThrough,
+        ...this.behaviors.timestamps ? { updatedAt: now } : {}
+      };
+      for (const fk of cfg.fkResolvers) {
+        if (resolvedFks[fk.column] !== null) set[fk.column] = resolvedFks[fk.column];
+      }
+      const rows = await db.insert(this.table).values(values).onConflictDoUpdate({
+        target: cfg.conflictTarget.map((c) => this.table[c]),
+        set
+      }).returning();
+      const saved = rows[0];
+      const fields = w["fields"];
+      if (cfg.eav && fields && Object.keys(fields).length > 0) {
+        await this.writeCustomFields(
+          db,
+          saved["id"],
+          w["userId"],
+          fields
+        );
+      }
+      return this.toProjection(saved);
+    };
+    return tx ? run(tx) : this.db.transaction((t) => run(t));
+  }
+  /**
+   * Canonical-projected lookup by external id (differ-ready). Returns `null`
+   * when no local row exists. Provider-scoped so a HubSpot id can't match a
+   * Salesforce row.
+   */
+  async findByExternalIdProjected(externalId, provider) {
+    const rows = await this.db.select().from(this.table).where(
+      and(
+        eq(this.table["provider"], provider),
+        eq(this.table["externalId"], externalId)
+      )
+    ).limit(1);
+    const row = rows[0];
+    return row ? this.toProjection(row) : null;
+  }
+  /**
+   * Integration "delete" by external id, provider-scoped. When `softDelete: true`,
+   * sets `deletedAt`. When `softDelete: false`, tombstone-by-clearing: null out
+   * `external_id`/`provider` so the row no longer matches future inbound
+   * changes while preserving local-id references. Returns `{ id }` or `null`.
+   */
+  async softDeleteByExternalId(externalId, provider, tx) {
+    const db = this.runner(tx);
+    const set = this.integrationConfig.softDelete ? { deletedAt: /* @__PURE__ */ new Date(), updatedAt: /* @__PURE__ */ new Date() } : { externalId: null, provider: null, updatedAt: /* @__PURE__ */ new Date() };
+    const rows = await db.update(this.table).set(set).where(
+      and(
+        eq(this.table["provider"], provider),
+        eq(this.table["externalId"], externalId)
+      )
+    ).returning({ id: this.table["id"] });
+    return rows[0] ? { id: rows[0].id } : null;
+  }
+  /**
+   * Batch integration upsert — concretizes the former abstract stub. Delegates to
+   * `integrationUpsertOne` per input inside one transaction. Inputs are raw partial
+   * rows: provider is read from each input's own `provider` column; rows
+   * missing `externalId`/`provider` are skipped.
+   */
+  async integrationUpsert(inputs) {
+    if (inputs.length === 0) return [];
+    return this.db.transaction(async (tx) => {
+      const out = [];
+      for (const input of inputs) {
+        const rec = input;
+        if (!rec["externalId"] || !rec["provider"]) continue;
+        const proj = await this.integrationUpsertOne(
+          input,
+          rec["provider"],
+          tx
+        );
+        const id = proj["id"];
+        const row = await tx.select().from(this.table).where(eq(this.table["id"], id)).limit(1);
+        out.push(row[0]);
+      }
+      return out;
+    });
+  }
+  /**
+   * Project a raw row to the canonical differ shape — a generic pick over
+   * `integrationConfig.projectionColumns`. Override only for synthesized projections
+   * (e.g. junctions); entities use this verbatim.
+   */
+  toProjection(row) {
+    const r = row;
+    const out = {};
+    for (const col of this.integrationConfig.projectionColumns) out[col] = r[col];
+    return out;
+  }
+  /**
+   * EAV dual-write seam (#374, live path lands in #124). No-op by default;
+   * `eav: true` entities emit a concrete override that injects
+   * `FieldValueService` and delegates to `upsertFieldsTransactional` so the
+   * dual-write joins the same tx (`db`). Kept as an explicit hook so the base
+   * stays portable (the FieldValueService dependency is eav-only).
+   */
+  async writeCustomFields(_db, _entityId, _userId, _fields) {
+  }
+  /**
+   * Resolve one FK from a parent external id (provider-scoped). `self` resolves
+   * against `this.table`. Strict resolvers throw when unresolved; non-strict
+   * return null. A null/absent write value short-circuits to null.
+   */
+  async resolveFk(db, fk, rawExternalId, provider) {
+    const parentExternalId = rawExternalId;
+    if (!parentExternalId) {
+      if (fk.strict) {
+        throw new Error(
+          `${this.constructor.name}.integrationUpsertOne: missing required parent external id for '${fk.column}' (writeKey '${fk.writeKey}')`
+        );
+      }
+      return null;
+    }
+    const refTable = fk.refTable === "self" ? this.table : fk.refTable;
+    const rows = await db.select({ id: refTable["id"] }).from(refTable).where(
+      and(
+        eq(refTable["provider"], provider),
+        eq(refTable["externalId"], parentExternalId)
+      )
+    ).limit(1);
+    const id = rows[0]?.id ?? null;
+    if (id === null && fk.strict) {
+      throw new Error(
+        `${this.constructor.name}.integrationUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${fk.column}' \u2014 parent not integrated yet`
+      );
+    }
+    return id;
+  }
+  /**
+   * Find entities visible to a user (ownership + sharing rules).
+   * Concrete repositories must implement with visibility logic.
+   */
+  async findVisibleByUserId(_userId) {
+    throw new Error("findVisibleByUserId not implemented \u2014 override in concrete repository");
+  }
+};
+
+export {
+  IntegratedEntityRepository
+};
+//# sourceMappingURL=chunk-OTDN3OUQ.js.map

package/dist/chunk-OTDN3OUQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/integrated-entity-repository.ts"],"sourcesContent":["/**\n * IntegratedEntityRepository<TEntity, TIntegrationWrite, TIntegrationProjection>\n *\n * Family-specific base for Integrated entities (contacts, accounts, opportunities).\n * Adds external ID lookups, user-scoped queries, and the generic inbound-integration\n * write surface (canonical→Drizzle upsert + provider-scoped FK resolution +\n * EAV dual-write seam), driven by the concrete repo's `integrationConfig`.\n *\n * The type params default so pre-existing single-param subclasses keep\n * compiling; `pattern: Integrated` repos declare all three plus `integrationConfig`.\n */\nimport { and, eq, inArray } 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';\nimport type { IntegrationUpsertConfig, IntegrationFkResolver } from './integration-upsert-config';\n\nexport abstract class IntegratedEntityRepository<\n  TEntity,\n  TIntegrationWrite = Partial<TEntity>,\n  TIntegrationProjection = TEntity,\n> extends BaseRepository<TEntity> {\n  /**\n   * Declarative integration write surface. Concrete (`pattern: Integrated`) repositories\n   * declare this — the template emits it from the entity's fields + FKs.\n   */\n  protected abstract readonly integrationConfig: IntegrationUpsertConfig;\n\n  /**\n   * Find a single entity by its external CRM identifier.\n   */\n  async findByExternalId(externalId: string): Promise<TEntity | null> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table['externalId'], externalId))\n      .limit(1);\n    return (rows[0] as TEntity) ?? null;\n  }\n\n  /**\n   * Find multiple entities by external CRM identifiers.\n   */\n  async findManyByExternalIds(externalIds: string[]): Promise<TEntity[]> {\n    if (externalIds.length === 0) return [];\n    const rows = await this.baseQuery()\n      .where(inArray(this.table['externalId'], externalIds));\n    return rows as TEntity[];\n  }\n\n  /**\n   * Find all entities owned by a specific user.\n   */\n  async findAllByUserId(userId: string): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table['userId'], userId));\n    return rows as TEntity[];\n  }\n\n  // ==========================================================================\n  // Inbound integration (#374) — canonical→Drizzle write + provider-scoped FK\n  // resolution + EAV dual-write seam, all inside a SINGLE transaction.\n  // Driven entirely by `this.integrationConfig`; the per-entity shape lives there.\n  // ==========================================================================\n\n  /**\n   * Upsert ONE entity by its `(provider, externalId)` identity, in a single\n   * transaction:\n   *   1. resolve each `integrationConfig.fkResolvers` FK (provider-scoped). Strict\n   *      resolvers throw on unresolved; non-strict leave the column null.\n   *   2. insert-or-update the canonical columns via `onConflictDoUpdate` on the\n   *      `conflictTarget`. Resolved FKs are only written into `set` when\n   *      non-null this run (no-clobber).\n   *   3. EAV dual-write of `write.fields` via `writeCustomFields` when\n   *      `integrationConfig.eav` and the bag is non-empty (same tx).\n   *\n   * Idempotent: a second call with the same identity updates in place. Returns\n   * the canonical projection (so the orchestrator records `local_id`).\n   *\n   * @param write     canonical fields + parent external ids + custom-field bag\n   * @param provider  adapter/provider label persisted + used to scope 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\n    const run = async (db: DrizzleTx): Promise<TIntegrationProjection> => {\n      // 1. FK resolution (provider-scoped). Strict → throw; else opportunistic null.\n      const resolvedFks: Record<string, string | null> = {};\n      for (const fk of cfg.fkResolvers) {\n        resolvedFks[fk.column] = await this.resolveFk(db, fk, w[fk.writeKey], provider);\n      }\n\n      // 2. Canonical → Drizzle insert-or-update by the conflict target.\n      const now = new Date();\n      const copyThrough: Record<string, unknown> = {};\n      for (const col of cfg.writeColumns) copyThrough[col] = w[col];\n\n      const values: Record<string, unknown> = {\n        externalId: w['externalId'],\n        provider,\n        ...copyThrough,\n        ...resolvedFks,\n        ...(this.behaviors.timestamps ? { updatedAt: now } : {}),\n      };\n\n      // `set` excludes the identity (externalId/provider). Resolved FKs are\n      // only written when non-null this run — never clobber a previously\n      // resolved parent with null on a later run that dropped the ref.\n      const set: Record<string, unknown> = {\n        ...copyThrough,\n        ...(this.behaviors.timestamps ? { updatedAt: now } : {}),\n      };\n      for (const fk of cfg.fkResolvers) {\n        if (resolvedFks[fk.column] !== null) set[fk.column] = resolvedFks[fk.column];\n      }\n\n      const rows = await db\n        .insert(this.table)\n        .values(values as never)\n        .onConflictDoUpdate({\n          target: cfg.conflictTarget.map((c: string) => this.table[c]),\n          set: set as never,\n        })\n        .returning();\n\n      const saved = rows[0] as Record<string, unknown>;\n\n      // 3. EAV dual-write seam — same tx. No-op unless the entity opts in.\n      const fields = w['fields'] as Record<string, unknown> | undefined;\n      if (cfg.eav && fields && Object.keys(fields).length > 0) {\n        await this.writeCustomFields(\n          db,\n          saved['id'] as string,\n          w['userId'] as string,\n          fields,\n        );\n      }\n\n      return this.toProjection(saved as TEntity);\n    };\n\n    return tx ? run(tx) : this.db.transaction((t) => run(t));\n  }\n\n  /**\n   * Canonical-projected lookup by external id (differ-ready). Returns `null`\n   * when no local row exists. Provider-scoped so a HubSpot id can't match a\n   * Salesforce row.\n   */\n  async findByExternalIdProjected(\n    externalId: string,\n    provider: string,\n  ): Promise<TIntegrationProjection | null> {\n    const rows = await this.db\n      .select()\n      .from(this.table)\n      .where(\n        and(\n          eq(this.table['provider'], provider),\n          eq(this.table['externalId'], externalId),\n        ),\n      )\n      .limit(1);\n    const row = rows[0] as TEntity | undefined;\n    return row ? this.toProjection(row) : null;\n  }\n\n  /**\n   * Integration \"delete\" by external id, provider-scoped. When `softDelete: true`,\n   * sets `deletedAt`. When `softDelete: false`, tombstone-by-clearing: null out\n   * `external_id`/`provider` so the row no longer matches future inbound\n   * changes while preserving local-id references. Returns `{ id }` or `null`.\n   */\n  async softDeleteByExternalId(\n    externalId: string,\n    provider: string,\n    tx?: DrizzleTx,\n  ): Promise<{ id: string } | null> {\n    const db = this.runner(tx);\n    const set = this.integrationConfig.softDelete\n      ? { deletedAt: new Date(), updatedAt: new Date() }\n      : { externalId: null, provider: null, updatedAt: new Date() };\n    const rows = await db\n      .update(this.table)\n      .set(set as never)\n      .where(\n        and(\n          eq(this.table['provider'], provider),\n          eq(this.table['externalId'], externalId),\n        ),\n      )\n      .returning({ id: this.table['id'] });\n    return rows[0] ? { id: rows[0].id as string } : null;\n  }\n\n  /**\n   * Batch integration upsert — concretizes the former abstract stub. Delegates to\n   * `integrationUpsertOne` per input inside one transaction. Inputs are raw partial\n   * rows: provider is read from each input's own `provider` column; rows\n   * missing `externalId`/`provider` are skipped.\n   */\n  async integrationUpsert(inputs: Array<Partial<TEntity>>): Promise<TEntity[]> {\n    if (inputs.length === 0) return [];\n    return this.db.transaction(async (tx) => {\n      const out: TEntity[] = [];\n      for (const input of inputs) {\n        const rec = input as Record<string, unknown>;\n        if (!rec['externalId'] || !rec['provider']) continue;\n        const proj = await this.integrationUpsertOne(\n          input as unknown as TIntegrationWrite,\n          rec['provider'] as string,\n          tx,\n        );\n        const id = (proj as Record<string, unknown>)['id'] as string;\n        const row = await tx\n          .select()\n          .from(this.table)\n          .where(eq(this.table['id'], id))\n          .limit(1);\n        out.push(row[0] as TEntity);\n      }\n      return out;\n    });\n  }\n\n  /**\n   * Project a raw row to the canonical differ shape — a generic pick over\n   * `integrationConfig.projectionColumns`. Override only for synthesized projections\n   * (e.g. junctions); entities use this verbatim.\n   */\n  protected toProjection(row: TEntity): TIntegrationProjection {\n    const r = row as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const col of this.integrationConfig.projectionColumns) out[col] = r[col];\n    return out as TIntegrationProjection;\n  }\n\n  /**\n   * EAV dual-write seam (#374, live path lands in #124). No-op by default;\n   * `eav: true` entities emit a concrete override that injects\n   * `FieldValueService` and delegates to `upsertFieldsTransactional` so the\n   * dual-write joins the same tx (`db`). Kept as an explicit hook so the base\n   * stays portable (the FieldValueService dependency is eav-only).\n   */\n  protected async writeCustomFields(\n    _db: DrizzleTx,\n    _entityId: string,\n    _userId: string,\n    _fields: Record<string, unknown>,\n  ): Promise<void> {\n    // Intentionally empty until the entity opts into EAV.\n  }\n\n  /**\n   * Resolve one FK from a parent external id (provider-scoped). `self` resolves\n   * against `this.table`. Strict resolvers throw when unresolved; non-strict\n   * return null. A null/absent write value short-circuits to null.\n   */\n  private async resolveFk(\n    db: DrizzleTx,\n    fk: IntegrationFkResolver,\n    rawExternalId: unknown,\n    provider: string,\n  ): Promise<string | null> {\n    const parentExternalId = rawExternalId as string | null | undefined;\n    if (!parentExternalId) {\n      if (fk.strict) {\n        throw new Error(\n          `${this.constructor.name}.integrationUpsertOne: missing required parent ` +\n            `external id for '${fk.column}' (writeKey '${fk.writeKey}')`,\n        );\n      }\n      return null;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const refTable: PgTableWithColumns<any> =\n      fk.refTable === 'self' ? this.table : fk.refTable;\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    const id = (rows[0]?.id as string | undefined) ?? null;\n    if (id === null && fk.strict) {\n      throw new Error(\n        `${this.constructor.name}.integrationUpsertOne: unresolved parent ` +\n          `'${parentExternalId}' (provider '${provider}') for '${fk.column}' — ` +\n          `parent not integrated yet`,\n      );\n    }\n    return id;\n  }\n\n  /**\n   * Find entities visible to a user (ownership + sharing rules).\n   * Concrete repositories must implement with visibility logic.\n   */\n  async findVisibleByUserId(_userId: string): Promise<TEntity[]> {\n    throw new Error('findVisibleByUserId not implemented — override in concrete repository');\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-OZZJDRGW.js

@@ -0,0 +1,122 @@
+import {
+  bridgeRegistry
+} from "./chunk-5A432NZJ.js";
+import {
+  BridgeOutboxDrainHook
+} from "./chunk-L7BNNRGI.js";
+import {
+  EventFlowService
+} from "./chunk-32BMMV4H.js";
+import {
+  BRIDGE_RESERVED_POOLS
+} from "./chunk-EDKJU5BO.js";
+import {
+  BridgeDeliveryHandler
+} from "./chunk-YTN6BKWA.js";
+import {
+  DrizzleBridgeDeliveryRepo
+} from "./chunk-K2I6XIK5.js";
+import {
+  MemoryBridgeDeliveryRepo
+} from "./chunk-4DOJBQTP.js";
+import {
+  BridgeReservedPoolsNotPolledError
+} from "./chunk-NXXDZ6ZF.js";
+import {
+  JOB_WORKER_MODULE_OPTIONS
+} from "./chunk-WPXNN6QS.js";
+import {
+  BRIDGE_DELIVERY_REPO,
+  BRIDGE_MODULE_OPTIONS,
+  BRIDGE_MULTI_TENANT,
+  BRIDGE_OUTBOX_DRAIN_HOOK,
+  BRIDGE_REGISTRY,
+  EVENT_FLOW
+} from "./chunk-4LH67P4U.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/bridge/bridge.module.ts
+import {
+  Inject,
+  Module,
+  Optional
+} from "@nestjs/common";
+var BridgeModule = class {
+  /**
+   * `JOB_WORKER_MODULE_OPTIONS` is declared `@Optional()` so unit tests
+   * that mount `BridgeModule` alone (no `JobWorkerModule`) boot
+   * cleanly — the boot-time check skips when the token is undefined.
+   */
+  constructor(workerOpts) {
+    this.workerOpts = workerOpts;
+  }
+  workerOpts;
+  static forRoot(opts) {
+    const repoProvider = opts.backend === "memory" ? { provide: BRIDGE_DELIVERY_REPO, useClass: MemoryBridgeDeliveryRepo } : { provide: BRIDGE_DELIVERY_REPO, useClass: DrizzleBridgeDeliveryRepo };
+    return {
+      module: BridgeModule,
+      global: true,
+      // BridgeModule consumes EVENT_BUS / JOB_ORCHESTRATOR / DRIZZLE
+      // from sibling subsystems via DI; no `imports` needed here. The
+      // consumer is responsible for wiring EventsModule + JobsDomainModule
+      // (or JobWorkerModule, which transitively imports the latter)
+      // BEFORE BridgeModule.
+      providers: [
+        { provide: BRIDGE_MODULE_OPTIONS, useValue: opts },
+        { provide: BRIDGE_MULTI_TENANT, useValue: opts.multiTenant ?? false },
+        // Package mode threads the consumer's generated registry through
+        // `opts.registry`; vendored mode omits it and we fall back to the
+        // bundled `./generated/registry` (which IS the consumer's generated
+        // file in a vendored tree). See `BridgeModuleOptions.registry`.
+        { provide: BRIDGE_REGISTRY, useValue: opts.registry ?? bridgeRegistry },
+        repoProvider,
+        // Drain hook — always wired; `DrizzleEventBus` consumes it via
+        // `@Optional()`, so non-bridge mounts simply see `undefined`.
+        { provide: BRIDGE_OUTBOX_DRAIN_HOOK, useClass: BridgeOutboxDrainHook },
+        // Facade — class provider + token alias.
+        EventFlowService,
+        { provide: EVENT_FLOW, useExisting: EventFlowService },
+        // Framework handler — provider so DI can construct it. The
+        // `@JobHandler` decorator already auto-registers it in
+        // `JOB_HANDLER_REGISTRY` at module-load time, and its `jobs`
+        // row is upserted at `JobWorkerModule.onModuleInit`. We just
+        // need the class instantiated as a Nest provider so its DI
+        // deps (BRIDGE_DELIVERY_REPO, JOB_ORCHESTRATOR, EVENT_BUS,
+        // BRIDGE_REGISTRY, BRIDGE_MULTI_TENANT) resolve.
+        BridgeDeliveryHandler
+      ],
+      exports: [
+        EVENT_FLOW,
+        BRIDGE_DELIVERY_REPO,
+        BRIDGE_REGISTRY,
+        BRIDGE_MULTI_TENANT,
+        BRIDGE_MODULE_OPTIONS,
+        BRIDGE_OUTBOX_DRAIN_HOOK
+      ]
+    };
+  }
+  async onModuleInit() {
+    if (!this.workerOpts) return;
+    if (this.workerOpts.allPools) return;
+    const activePools = this.workerOpts.pools ?? [];
+    const missing = BRIDGE_RESERVED_POOLS.filter(
+      (p) => !activePools.includes(p)
+    );
+    if (missing.length > 0) {
+      throw new BridgeReservedPoolsNotPolledError(missing);
+    }
+  }
+};
+BridgeModule = __decorateClass([
+  Module({}),
+  __decorateParam(0, Optional()),
+  __decorateParam(0, Inject(JOB_WORKER_MODULE_OPTIONS))
+], BridgeModule);
+
+export {
+  BridgeModule
+};
+//# sourceMappingURL=chunk-OZZJDRGW.js.map

package/dist/chunk-OZZJDRGW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/bridge/bridge.module.ts"],"sourcesContent":["/**\n * BridgeModule — `DynamicModule.forRoot({ backend, multiTenant })`\n * factory that wires the entire bridge subsystem (BRIDGE-8, ADR-023\n * Phase 2).\n *\n * The bridge is the formalized seam between events (ADR-024) and jobs\n * (ADR-022). It is owned by neither subsystem and consumes their tokens\n * via DI. `BridgeModule` is the *combiner* — neither `EventsModule` nor\n * `JobsDomainModule` know about it.\n *\n * Consumer wiring (must be imported AFTER `EventsModule`,\n * `JobsDomainModule`, and `JobWorkerModule`):\n * ```ts\n * @Module({\n *   imports: [\n *     EventsModule.forRoot({ backend: 'drizzle' }),\n *     JobWorkerModule.forRoot({\n *       mode: 'embedded',\n *       backend: 'drizzle',\n *       pools: ['interactive', 'batch', ...BRIDGE_RESERVED_POOLS],\n *     }),\n *     BridgeModule.forRoot({ backend: 'drizzle', multiTenant: false }),\n *   ],\n * })\n * class AppModule {}\n * ```\n *\n * Boot-time check: `onModuleInit` inspects `JobWorkerModule`'s active\n * pools and throws `BridgeReservedPoolsNotPolledError` when any of the\n * three reserved bridge pools isn't being polled. Converts the\n * \"wrappers sit pending forever\" footgun into a fail-fast.\n *\n * Handler registration: ONE `@JobHandler('@framework/bridge_delivery',\n * ...)` decorator on `BridgeDeliveryHandler` auto-registers it in\n * `JOB_HANDLER_REGISTRY` at module-load time. We declare the class as a\n * Nest provider here so DI resolves its constructor deps; per-direction\n * routing happens via `job_run.pool='events_<direction>'` set by\n * `BridgeOutboxDrainHook` (BRIDGE-4) — workers polling each reserved\n * pool independently claim wrappers from their own pool and dispatch to\n * the same handler class. The reserved-pool validator exemption\n * (BRIDGE-5) lets the framework handler legitimately target a reserved\n * pool.\n */\nimport {\n  Inject,\n  Module,\n  Optional,\n  type DynamicModule,\n  type OnModuleInit,\n  type Provider,\n} from '@nestjs/common';\n\nimport {\n  JOB_WORKER_MODULE_OPTIONS,\n  type JobWorkerModuleOptions,\n} from '../jobs/job-worker.module';\n\nimport {\n  BRIDGE_DELIVERY_REPO,\n  BRIDGE_MODULE_OPTIONS,\n  BRIDGE_MULTI_TENANT,\n  BRIDGE_OUTBOX_DRAIN_HOOK,\n  BRIDGE_REGISTRY,\n  EVENT_FLOW,\n} from './bridge.tokens';\nimport { BridgeReservedPoolsNotPolledError } from './bridge-errors';\nimport { MemoryBridgeDeliveryRepo } from './bridge-delivery.memory-backend';\nimport { DrizzleBridgeDeliveryRepo } from './bridge-delivery.drizzle-backend';\nimport { BridgeOutboxDrainHook } from './bridge-outbox-drain-hook';\nimport { EventFlowService } from './event-flow.service';\nimport { BridgeDeliveryHandler } from './bridge-delivery-handler';\nimport { bridgeRegistry } from './generated/registry';\nimport type { BridgeRegistry } from './bridge.protocol';\nimport { BRIDGE_RESERVED_POOLS } from './reserved-pools';\n\nexport interface BridgeModuleOptions {\n  /**\n   * `'memory'` for unit tests (no Postgres), `'drizzle'` for production.\n   * Switches `BRIDGE_DELIVERY_REPO` between\n   * `MemoryBridgeDeliveryRepo` and `DrizzleBridgeDeliveryRepo`.\n   */\n  backend: 'memory' | 'drizzle';\n  /**\n   * Multi-tenancy opt-in. When `true`, the three enforcement sites\n   * (`EventFlowService.publishAndStart`, `BridgeDeliveryHandler.run`,\n   * `DrizzleBridgeDeliveryRepo.insertDelivery`) throw\n   * `MissingTenantIdError` when `tenantId === undefined`. Explicit\n   * `null` always passes (cross-tenant work). Defaults to `false`.\n   */\n  multiTenant?: boolean;\n  /**\n   * The codegen-emitted `Record<EventTypeName, BridgeTriggerEntry[]>` that\n   * drives outbox-drain trigger lookup (BRIDGE-4) and the facade's Case B\n   * dedup (BRIDGE-7).\n   *\n   * **Package mode (ADR-037).** When the runtime is imported from\n   * `@pattern-stack/codegen` (not vendored), the bundled\n   * `./generated/registry` is a frozen empty placeholder (`{}`) — a\n   * consumer's `@JobHandler.triggers` are scanned into a registry that lives\n   * in THEIR `src/generated/bridge-registry.ts`, which the package can't\n   * import. The generated subsystem barrel therefore threads that registry in\n   * here: `BridgeModule.forRoot({ ..., registry: bridgeRegistry })`. Omitted\n   * (vendored mode / tests) ⇒ falls back to the bundled `./generated/registry`,\n   * which in vendored mode IS the consumer's freshly-generated file.\n   *\n   * Without this, package-mode consumers' triggers never bind and the bridge\n   * routes nothing (the \"wrappers sit pending\" footgun's silent twin —\n   * nothing is ever enqueued in the first place).\n   */\n  registry?: BridgeRegistry;\n}\n\n@Module({})\nexport class BridgeModule implements OnModuleInit {\n  static forRoot(opts: BridgeModuleOptions): DynamicModule {\n    const repoProvider: Provider =\n      opts.backend === 'memory'\n        ? { provide: BRIDGE_DELIVERY_REPO, useClass: MemoryBridgeDeliveryRepo }\n        : { provide: BRIDGE_DELIVERY_REPO, useClass: DrizzleBridgeDeliveryRepo };\n\n    return {\n      module: BridgeModule,\n      global: true,\n      // BridgeModule consumes EVENT_BUS / JOB_ORCHESTRATOR / DRIZZLE\n      // from sibling subsystems via DI; no `imports` needed here. The\n      // consumer is responsible for wiring EventsModule + JobsDomainModule\n      // (or JobWorkerModule, which transitively imports the latter)\n      // BEFORE BridgeModule.\n      providers: [\n        { provide: BRIDGE_MODULE_OPTIONS, useValue: opts },\n        { provide: BRIDGE_MULTI_TENANT, useValue: opts.multiTenant ?? false },\n        // Package mode threads the consumer's generated registry through\n        // `opts.registry`; vendored mode omits it and we fall back to the\n        // bundled `./generated/registry` (which IS the consumer's generated\n        // file in a vendored tree). See `BridgeModuleOptions.registry`.\n        { provide: BRIDGE_REGISTRY, useValue: opts.registry ?? bridgeRegistry },\n        repoProvider,\n        // Drain hook — always wired; `DrizzleEventBus` consumes it via\n        // `@Optional()`, so non-bridge mounts simply see `undefined`.\n        { provide: BRIDGE_OUTBOX_DRAIN_HOOK, useClass: BridgeOutboxDrainHook },\n        // Facade — class provider + token alias.\n        EventFlowService,\n        { provide: EVENT_FLOW, useExisting: EventFlowService },\n        // Framework handler — provider so DI can construct it. The\n        // `@JobHandler` decorator already auto-registers it in\n        // `JOB_HANDLER_REGISTRY` at module-load time, and its `jobs`\n        // row is upserted at `JobWorkerModule.onModuleInit`. We just\n        // need the class instantiated as a Nest provider so its DI\n        // deps (BRIDGE_DELIVERY_REPO, JOB_ORCHESTRATOR, EVENT_BUS,\n        // BRIDGE_REGISTRY, BRIDGE_MULTI_TENANT) resolve.\n        BridgeDeliveryHandler,\n      ],\n      exports: [\n        EVENT_FLOW,\n        BRIDGE_DELIVERY_REPO,\n        BRIDGE_REGISTRY,\n        BRIDGE_MULTI_TENANT,\n        BRIDGE_MODULE_OPTIONS,\n        BRIDGE_OUTBOX_DRAIN_HOOK,\n      ],\n    };\n  }\n\n  /**\n   * `JOB_WORKER_MODULE_OPTIONS` is declared `@Optional()` so unit tests\n   * that mount `BridgeModule` alone (no `JobWorkerModule`) boot\n   * cleanly — the boot-time check skips when the token is undefined.\n   */\n  constructor(\n    @Optional()\n    @Inject(JOB_WORKER_MODULE_OPTIONS)\n    private readonly workerOpts?: JobWorkerModuleOptions,\n  ) {}\n\n  async onModuleInit(): Promise<void> {\n    if (!this.workerOpts) return;\n    // BULLMQ-1 Phase 1 — `allPools: true` activates every pool (reserved\n    // `events_*` included), so the reserved-pool guarantee holds by\n    // construction. Short-circuit pass without inspecting the (typically\n    // omitted) explicit `pools` list.\n    if (this.workerOpts.allPools) return;\n    const activePools = this.workerOpts.pools ?? [];\n    const missing = BRIDGE_RESERVED_POOLS.filter(\n      (p) => !activePools.includes(p),\n    );\n    if (missing.length > 0) {\n      throw new BridgeReservedPoolsNotPolledError(missing);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AA+DA,IAAM,eAAN,MAA2C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuDhD,YAGmB,YACjB;AADiB;AAAA,EAChB;AAAA,EADgB;AAAA,EAzDnB,OAAO,QAAQ,MAA0C;AACvD,UAAM,eACJ,KAAK,YAAY,WACb,EAAE,SAAS,sBAAsB,UAAU,yBAAyB,IACpE,EAAE,SAAS,sBAAsB,UAAU,0BAA0B;AAE3E,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAMR,WAAW;AAAA,QACT,EAAE,SAAS,uBAAuB,UAAU,KAAK;AAAA,QACjD,EAAE,SAAS,qBAAqB,UAAU,KAAK,eAAe,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,QAKpE,EAAE,SAAS,iBAAiB,UAAU,KAAK,YAAY,eAAe;AAAA,QACtE;AAAA;AAAA;AAAA,QAGA,EAAE,SAAS,0BAA0B,UAAU,sBAAsB;AAAA;AAAA,QAErE;AAAA,QACA,EAAE,SAAS,YAAY,aAAa,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAQrD;AAAA,MACF;AAAA,MACA,SAAS;AAAA,QACP;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAaA,MAAM,eAA8B;AAClC,QAAI,CAAC,KAAK,WAAY;AAKtB,QAAI,KAAK,WAAW,SAAU;AAC9B,UAAM,cAAc,KAAK,WAAW,SAAS,CAAC;AAC9C,UAAM,UAAU,sBAAsB;AAAA,MACpC,CAAC,MAAM,CAAC,YAAY,SAAS,CAAC;AAAA,IAChC;AACA,QAAI,QAAQ,SAAS,GAAG;AACtB,YAAM,IAAI,kCAAkC,OAAO;AAAA,IACrD;AAAA,EACF;AACF;AA5Ea,eAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,EAyDL,4BAAS;AAAA,EACT,0BAAO,yBAAyB;AAAA,GAzDxB;","names":[]}

package/dist/chunk-PNZSGAB2.js

@@ -0,0 +1,114 @@
+import {
+  MemoryJobStore
+} from "./chunk-SNQ3TOWP.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/jobs/job-step-service.memory-backend.ts
+import { randomUUID } from "crypto";
+import { Inject, Injectable } from "@nestjs/common";
+var MemoryJobStepService = class {
+  // ADR-037 (package-mode DI): explicit `@Inject(MemoryJobStore)` — the
+  // published bundle carries no `design:paramtypes`, so a by-type inject
+  // would resolve to `undefined` in package mode.
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async findStep(runId, stepId) {
+    const rows = this.store.steps.get(runId);
+    if (!rows) return null;
+    const match = rows.find(
+      (r) => r.stepId === stepId && r.status === "completed"
+    );
+    return match ?? null;
+  }
+  async recordStep(input) {
+    const rows = this.getOrCreateRows(input.jobRunId);
+    const existingIdx = rows.findIndex((r) => r.stepId === input.stepId);
+    const normalisedInput = input.input ?? null;
+    const normalisedOutput = input.output ?? null;
+    if (existingIdx >= 0) {
+      const prev = rows[existingIdx];
+      const next = {
+        ...prev,
+        status: input.status,
+        input: normalisedInput ?? prev.input,
+        output: normalisedOutput ?? prev.output,
+        error: input.error ?? prev.error,
+        attempts: input.attempts ?? prev.attempts,
+        startedAt: input.startedAt ?? prev.startedAt,
+        finishedAt: input.finishedAt ?? prev.finishedAt
+      };
+      rows[existingIdx] = next;
+      return next;
+    }
+    const seq = input.seq ?? this.nextSeq(rows);
+    const row = {
+      id: randomUUID(),
+      jobRunId: input.jobRunId,
+      stepId: input.stepId,
+      kind: input.kind,
+      seq,
+      status: input.status,
+      input: normalisedInput,
+      output: normalisedOutput,
+      error: input.error ?? null,
+      attempts: input.attempts ?? 0,
+      startedAt: input.startedAt ?? null,
+      finishedAt: input.finishedAt ?? null
+    };
+    rows.push(row);
+    return row;
+  }
+  /**
+   * Replay helper — wipe every step row for a run. Mirrors the `scratch`
+   * replay mode of the Drizzle backend (`DELETE FROM job_step WHERE job_run_id = …`).
+   */
+  clearStepsForRun(runId) {
+    this.store.steps.delete(runId);
+  }
+  /**
+   * Remove every non-`completed` row for the run. Memoized (`completed`)
+   * rows are preserved — this is the `last_checkpoint` / `last_step`
+   * semantics the Drizzle backend implements via
+   * `DELETE … WHERE status != 'completed'`. Both replay modes route here
+   * (Phase 1 collapses `last_step` onto this behaviour; see JOB-3 notes).
+   */
+  clearIncompleteSteps(runId) {
+    const rows = this.store.steps.get(runId);
+    if (!rows) return;
+    const kept = rows.filter((r) => r.status === "completed");
+    if (kept.length === 0) {
+      this.store.steps.delete(runId);
+    } else {
+      this.store.steps.set(runId, kept);
+    }
+  }
+  getOrCreateRows(runId) {
+    let rows = this.store.steps.get(runId);
+    if (!rows) {
+      rows = [];
+      this.store.steps.set(runId, rows);
+    }
+    return rows;
+  }
+  nextSeq(rows) {
+    let max = 0;
+    for (const r of rows) {
+      if (r.seq > max) max = r.seq;
+    }
+    return max + 1;
+  }
+};
+MemoryJobStepService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(MemoryJobStore))
+], MemoryJobStepService);
+
+export {
+  MemoryJobStepService
+};
+//# sourceMappingURL=chunk-PNZSGAB2.js.map

package/dist/chunk-PNZSGAB2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-step-service.memory-backend.ts"],"sourcesContent":["/**\n * MemoryJobStepService — in-memory implementation of `IJobStepService`\n * (ADR-022, JOB-4).\n *\n * Mirrors `DrizzleJobStepService` but against plain Maps. `findStep` only\n * returns `completed` rows (memoization cache hit); anything non-completed\n * is invisible so the ctx.step fn re-runs on replay / retry exactly like\n * the Drizzle backend (which deletes non-completed rows on replay).\n */\nimport { randomUUID } from 'node:crypto';\nimport { Inject, Injectable } from '@nestjs/common';\nimport type { JobStepRow } from './job-orchestration.schema';\nimport type {\n  IJobStepService,\n  JobStep,\n  RecordStepInput,\n} from './job-step-service.protocol';\nimport { MemoryJobStore } from './memory-job-store';\n\n@Injectable()\nexport class MemoryJobStepService implements IJobStepService {\n  // ADR-037 (package-mode DI): explicit `@Inject(MemoryJobStore)` — the\n  // published bundle carries no `design:paramtypes`, so a by-type inject\n  // would resolve to `undefined` in package mode.\n  constructor(\n    @Inject(MemoryJobStore) private readonly store: MemoryJobStore,\n  ) {}\n\n  async findStep(runId: string, stepId: string): Promise<JobStep | null> {\n    const rows = this.store.steps.get(runId);\n    if (!rows) return null;\n    const match = rows.find(\n      (r) => r.stepId === stepId && r.status === 'completed',\n    );\n    return (match ?? null) as JobStep | null;\n  }\n\n  async recordStep(input: RecordStepInput): Promise<JobStep> {\n    const rows = this.getOrCreateRows(input.jobRunId);\n    const existingIdx = rows.findIndex((r) => r.stepId === input.stepId);\n\n    const normalisedInput =\n      (input.input ?? null) as Record<string, unknown> | null;\n    const normalisedOutput =\n      (input.output ?? null) as Record<string, unknown> | null;\n\n    if (existingIdx >= 0) {\n      const prev = rows[existingIdx]!;\n      const next: JobStepRow = {\n        ...prev,\n        status: input.status,\n        input: normalisedInput ?? prev.input,\n        output: normalisedOutput ?? prev.output,\n        error: input.error ?? prev.error,\n        attempts: input.attempts ?? prev.attempts,\n        startedAt: input.startedAt ?? prev.startedAt,\n        finishedAt: input.finishedAt ?? prev.finishedAt,\n      };\n      rows[existingIdx] = next;\n      return next as JobStep;\n    }\n\n    const seq = input.seq ?? this.nextSeq(rows);\n    const row: JobStepRow = {\n      id: randomUUID(),\n      jobRunId: input.jobRunId,\n      stepId: input.stepId,\n      kind: input.kind,\n      seq,\n      status: input.status,\n      input: normalisedInput,\n      output: normalisedOutput,\n      error: input.error ?? null,\n      attempts: input.attempts ?? 0,\n      startedAt: input.startedAt ?? null,\n      finishedAt: input.finishedAt ?? null,\n    };\n    rows.push(row);\n    return row as JobStep;\n  }\n\n  /**\n   * Replay helper — wipe every step row for a run. Mirrors the `scratch`\n   * replay mode of the Drizzle backend (`DELETE FROM job_step WHERE job_run_id = …`).\n   */\n  clearStepsForRun(runId: string): void {\n    this.store.steps.delete(runId);\n  }\n\n  /**\n   * Remove every non-`completed` row for the run. Memoized (`completed`)\n   * rows are preserved — this is the `last_checkpoint` / `last_step`\n   * semantics the Drizzle backend implements via\n   * `DELETE … WHERE status != 'completed'`. Both replay modes route here\n   * (Phase 1 collapses `last_step` onto this behaviour; see JOB-3 notes).\n   */\n  clearIncompleteSteps(runId: string): void {\n    const rows = this.store.steps.get(runId);\n    if (!rows) return;\n    const kept = rows.filter((r) => r.status === 'completed');\n    if (kept.length === 0) {\n      this.store.steps.delete(runId);\n    } else {\n      this.store.steps.set(runId, kept);\n    }\n  }\n\n  private getOrCreateRows(runId: string): JobStepRow[] {\n    let rows = this.store.steps.get(runId);\n    if (!rows) {\n      rows = [];\n      this.store.steps.set(runId, rows);\n    }\n    return rows;\n  }\n\n  private nextSeq(rows: JobStepRow[]): number {\n    let max = 0;\n    for (const r of rows) {\n      if (r.seq > max) max = r.seq;\n    }\n    return max + 1;\n  }\n}\n"],"mappings":";;;;;;;;;AASA,SAAS,kBAAkB;AAC3B,SAAS,QAAQ,kBAAkB;AAU5B,IAAM,uBAAN,MAAsD;AAAA;AAAA;AAAA;AAAA,EAI3D,YAC2C,OACzC;AADyC;AAAA,EACxC;AAAA,EADwC;AAAA,EAG3C,MAAM,SAAS,OAAe,QAAyC;AACrE,UAAM,OAAO,KAAK,MAAM,MAAM,IAAI,KAAK;AACvC,QAAI,CAAC,KAAM,QAAO;AAClB,UAAM,QAAQ,KAAK;AAAA,MACjB,CAAC,MAAM,EAAE,WAAW,UAAU,EAAE,WAAW;AAAA,IAC7C;AACA,WAAQ,SAAS;AAAA,EACnB;AAAA,EAEA,MAAM,WAAW,OAA0C;AACzD,UAAM,OAAO,KAAK,gBAAgB,MAAM,QAAQ;AAChD,UAAM,cAAc,KAAK,UAAU,CAAC,MAAM,EAAE,WAAW,MAAM,MAAM;AAEnE,UAAM,kBACH,MAAM,SAAS;AAClB,UAAM,mBACH,MAAM,UAAU;AAEnB,QAAI,eAAe,GAAG;AACpB,YAAM,OAAO,KAAK,WAAW;AAC7B,YAAM,OAAmB;AAAA,QACvB,GAAG;AAAA,QACH,QAAQ,MAAM;AAAA,QACd,OAAO,mBAAmB,KAAK;AAAA,QAC/B,QAAQ,oBAAoB,KAAK;AAAA,QACjC,OAAO,MAAM,SAAS,KAAK;AAAA,QAC3B,UAAU,MAAM,YAAY,KAAK;AAAA,QACjC,WAAW,MAAM,aAAa,KAAK;AAAA,QACnC,YAAY,MAAM,cAAc,KAAK;AAAA,MACvC;AACA,WAAK,WAAW,IAAI;AACpB,aAAO;AAAA,IACT;AAEA,UAAM,MAAM,MAAM,OAAO,KAAK,QAAQ,IAAI;AAC1C,UAAM,MAAkB;AAAA,MACtB,IAAI,WAAW;AAAA,MACf,UAAU,MAAM;AAAA,MAChB,QAAQ,MAAM;AAAA,MACd,MAAM,MAAM;AAAA,MACZ;AAAA,MACA,QAAQ,MAAM;AAAA,MACd,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,OAAO,MAAM,SAAS;AAAA,MACtB,UAAU,MAAM,YAAY;AAAA,MAC5B,WAAW,MAAM,aAAa;AAAA,MAC9B,YAAY,MAAM,cAAc;AAAA,IAClC;AACA,SAAK,KAAK,GAAG;AACb,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,iBAAiB,OAAqB;AACpC,SAAK,MAAM,MAAM,OAAO,KAAK;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,qBAAqB,OAAqB;AACxC,UAAM,OAAO,KAAK,MAAM,MAAM,IAAI,KAAK;AACvC,QAAI,CAAC,KAAM;AACX,UAAM,OAAO,KAAK,OAAO,CAAC,MAAM,EAAE,WAAW,WAAW;AACxD,QAAI,KAAK,WAAW,GAAG;AACrB,WAAK,MAAM,MAAM,OAAO,KAAK;AAAA,IAC/B,OAAO;AACL,WAAK,MAAM,MAAM,IAAI,OAAO,IAAI;AAAA,IAClC;AAAA,EACF;AAAA,EAEQ,gBAAgB,OAA6B;AACnD,QAAI,OAAO,KAAK,MAAM,MAAM,IAAI,KAAK;AACrC,QAAI,CAAC,MAAM;AACT,aAAO,CAAC;AACR,WAAK,MAAM,MAAM,IAAI,OAAO,IAAI;AAAA,IAClC;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,QAAQ,MAA4B;AAC1C,QAAI,MAAM;AACV,eAAW,KAAK,MAAM;AACpB,UAAI,EAAE,MAAM,IAAK,OAAM,EAAE;AAAA,IAC3B;AACA,WAAO,MAAM;AAAA,EACf;AACF;AAvGa,uBAAN;AAAA,EADN,WAAW;AAAA,EAMP,0BAAO,cAAc;AAAA,GALb;","names":[]}

package/dist/chunk-PRWIX6UW.js

@@ -0,0 +1,21 @@
+// runtime/subsystems/integration/loopback.middleware.ts
+function createLoopbackMiddleware(store) {
+  return (next) => {
+    return async function* (subscription, cursor) {
+      for await (const change of next(subscription, cursor)) {
+        const isEcho = await store.isEchoOfOwnWrite(
+          subscription.domain,
+          change.externalId,
+          change.record
+        );
+        if (isEcho) continue;
+        yield change;
+      }
+    };
+  };
+}
+
+export {
+  createLoopbackMiddleware
+};
+//# sourceMappingURL=chunk-PRWIX6UW.js.map

package/dist/chunk-PRWIX6UW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/loopback.middleware.ts"],"sourcesContent":["/**\n * Integration subsystem — loopback `ChangeMiddleware` factory (#226-5, ADR-033).\n *\n * Replaces the prior orchestrator-side `@Optional() INTEGRATION_LOOPBACK_FINGERPRINT_STORE`\n * branch. Consumers that need to suppress echoes of their own outbound\n * writes compose `createLoopbackMiddleware(store)` into a primitive's\n * middleware chain — typically alongside `PollChangeSource<T>` — instead\n * of injecting a store into the orchestrator.\n *\n * Why middleware, not orchestrator branch:\n *   - keeps the orchestrator port-agnostic (no per-mode special cases);\n *   - lets primitives compose loopback with redaction / throttling /\n *     other cross-cutting wrappers in a single chain;\n *   - lets consumers pick per-source whether loopback is wired (some\n *     entities have outbound writeback, others don't) without DI gymnastics.\n *\n * Behavior:\n *   - For every change yielded by the inner iterator, call\n *     `store.isEchoOfOwnWrite(subscription.domain, change.externalId, change.record)`.\n *   - If the store returns `true`, the change is dropped (not yielded).\n *   - Otherwise the change is passed through untouched.\n *\n * The middleware does not record audit rows for suppressed changes —\n * the orchestrator no longer learns about them. This is the deliberate\n * trade: loopback echoes are noise, not signal; their prior `skipped+noop`\n * audit rows existed only because the orchestrator was the suppression\n * site. Consumers wanting visibility into suppression counts can wrap\n * their store or layer a counting middleware alongside this one.\n */\n\nimport type { Change } from './integration-change-source.protocol';\nimport type {\n  ChangeIterator,\n  ChangeMiddleware,\n} from './integration-middleware.protocol';\nimport type { ILoopbackFingerprintStore } from './integration-loopback.protocol';\n\n/**\n * Build a `ChangeMiddleware<T>` that suppresses changes whose fingerprint\n * matches a recent local write according to the supplied store.\n *\n * Composition — first middleware in the array is outermost. Consumers\n * typically place loopback as the outermost layer so suppressed changes\n * never reach downstream middleware (redaction, transforms, etc.).\n */\nexport function createLoopbackMiddleware<T>(\n  store: ILoopbackFingerprintStore<T>,\n): ChangeMiddleware<T> {\n  return (next: ChangeIterator<T>): ChangeIterator<T> => {\n    return async function* (subscription, cursor): AsyncIterable<Change<T>> {\n      for await (const change of next(subscription, cursor)) {\n        const isEcho = await store.isEchoOfOwnWrite(\n          subscription.domain,\n          change.externalId,\n          change.record,\n        );\n        if (isEcho) continue;\n        yield change;\n      }\n    };\n  };\n}\n"],"mappings":";AA6CO,SAAS,yBACd,OACqB;AACrB,SAAO,CAAC,SAA+C;AACrD,WAAO,iBAAiB,cAAc,QAAkC;AACtE,uBAAiB,UAAU,KAAK,cAAc,MAAM,GAAG;AACrD,cAAM,SAAS,MAAM,MAAM;AAAA,UACzB,aAAa;AAAA,UACb,OAAO;AAAA,UACP,OAAO;AAAA,QACT;AACA,YAAI,OAAQ;AACZ,cAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-PSXUNOVU.js

@@ -0,0 +1,7 @@
+// runtime/shared/openapi/registry.tokens.ts
+var OPENAPI_REGISTRY = "OPENAPI_REGISTRY";
+
+export {
+  OPENAPI_REGISTRY
+};
+//# sourceMappingURL=chunk-PSXUNOVU.js.map

package/dist/chunk-PSXUNOVU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/shared/openapi/registry.tokens.ts"],"sourcesContent":["/**\n * Injection token for the OpenAPI registry (OPENAPI-1).\n *\n * String constant (not a Symbol) so it matches by value across import\n * boundaries — same convention as `ANALYTICS_QUERY` in analytics and\n * `EVENT_BUS` / `BRIDGE_DELIVERY_REPO` in events / bridge. The OPENAPI-1\n * spec sketched a Symbol, but the repo-wide convention wins — codebase\n * consistency matters more than the spec's initial guess.\n *\n * Consumed by generated DTO providers (OPENAPI-2), controllers\n * (OPENAPI-3), and the Swagger bootstrap (OPENAPI-4).\n */\nexport const OPENAPI_REGISTRY = 'OPENAPI_REGISTRY' as const;\n"],"mappings":";AAYO,IAAM,mBAAmB;","names":[]}

package/dist/chunk-QLTJSCE6.js

@@ -0,0 +1,44 @@
+import {
+  OAuthStateError
+} from "./chunk-BPARRK6F.js";
+
+// runtime/subsystems/auth/backends/state-store.memory-backend.ts
+import { randomBytes } from "crypto";
+var MemoryOAuthStateStore = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  now;
+  generateToken;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? 10 * 60 * 1e3;
+    this.now = opts.now ?? (() => Date.now());
+    this.generateToken = opts.generateToken ?? (() => randomBytes(32).toString("base64url"));
+  }
+  async generate(record) {
+    const state = this.generateToken();
+    this.store.set(state, {
+      record: { ...record },
+      expiresAt: this.now() + this.ttlMs
+    });
+    return state;
+  }
+  async consume(state) {
+    const slot = this.store.get(state);
+    if (!slot) {
+      throw new OAuthStateError(
+        `OAuth state token unknown or already consumed`,
+        "missing"
+      );
+    }
+    this.store.delete(state);
+    if (slot.expiresAt <= this.now()) {
+      throw new OAuthStateError(`OAuth state token expired`, "expired");
+    }
+    return slot.record;
+  }
+};
+
+export {
+  MemoryOAuthStateStore
+};
+//# sourceMappingURL=chunk-QLTJSCE6.js.map

package/dist/chunk-QLTJSCE6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/auth/backends/state-store.memory-backend.ts"],"sourcesContent":["/**\n * In-memory `IOAuthStateStore` backend.\n *\n * Single-process store — Map<state, { record, expiresAt }>. Suitable for\n * tests and single-worker dev. Production deployments select the drizzle\n * backend so state survives restarts and is shared across workers.\n *\n * Single-use semantics:\n *   - `generate(record)` mints a 256-bit random token (base64url, opaque).\n *   - `consume(state)` deletes the entry on read. A second call with the\n *     same state throws `OAuthStateError('replay')`.\n *   - Expired entries also throw (`'expired'`); the entry is deleted as a\n *     side effect so a later replay still surfaces correctly.\n *\n * TTL defaults to 10 minutes — long enough for a user to complete the\n * provider's consent screen, short enough that abandoned states age out.\n */\nimport { randomBytes } from 'node:crypto';\nimport {\n  type IOAuthStateStore,\n  type OAuthStateRecord,\n  OAuthStateError,\n} from '../protocols/oauth-state-store';\n\nexport interface MemoryOAuthStateStoreOptions {\n  /** TTL in ms. Default 10 minutes. */\n  ttlMs?: number;\n  /** Injectable clock for tests. Default `Date.now`. */\n  now?: () => number;\n  /** Injectable token generator for tests. Default 32-byte base64url. */\n  generateToken?: () => string;\n}\n\ninterface Slot {\n  record: OAuthStateRecord;\n  expiresAt: number;\n}\n\nexport class MemoryOAuthStateStore implements IOAuthStateStore {\n  private readonly store = new Map<string, Slot>();\n  private readonly ttlMs: number;\n  private readonly now: () => number;\n  private readonly generateToken: () => string;\n\n  constructor(opts: MemoryOAuthStateStoreOptions = {}) {\n    this.ttlMs = opts.ttlMs ?? 10 * 60 * 1000;\n    this.now = opts.now ?? (() => Date.now());\n    this.generateToken =\n      opts.generateToken ?? (() => randomBytes(32).toString('base64url'));\n  }\n\n  async generate(record: OAuthStateRecord): Promise<string> {\n    const state = this.generateToken();\n    this.store.set(state, {\n      record: { ...record },\n      expiresAt: this.now() + this.ttlMs,\n    });\n    return state;\n  }\n\n  async consume(state: string): Promise<OAuthStateRecord> {\n    const slot = this.store.get(state);\n    if (!slot) {\n      throw new OAuthStateError(\n        `OAuth state token unknown or already consumed`,\n        'missing',\n      );\n    }\n    // Delete first so a concurrent consume can't replay.\n    this.store.delete(state);\n    if (slot.expiresAt <= this.now()) {\n      throw new OAuthStateError(`OAuth state token expired`, 'expired');\n    }\n    return slot.record;\n  }\n}\n"],"mappings":";;;;;AAiBA,SAAS,mBAAmB;AAqBrB,IAAM,wBAAN,MAAwD;AAAA,EAC5C,QAAQ,oBAAI,IAAkB;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EAEjB,YAAY,OAAqC,CAAC,GAAG;AACnD,SAAK,QAAQ,KAAK,SAAS,KAAK,KAAK;AACrC,SAAK,MAAM,KAAK,QAAQ,MAAM,KAAK,IAAI;AACvC,SAAK,gBACH,KAAK,kBAAkB,MAAM,YAAY,EAAE,EAAE,SAAS,WAAW;AAAA,EACrE;AAAA,EAEA,MAAM,SAAS,QAA2C;AACxD,UAAM,QAAQ,KAAK,cAAc;AACjC,SAAK,MAAM,IAAI,OAAO;AAAA,MACpB,QAAQ,EAAE,GAAG,OAAO;AAAA,MACpB,WAAW,KAAK,IAAI,IAAI,KAAK;AAAA,IAC/B,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,QAAQ,OAA0C;AACtD,UAAM,OAAO,KAAK,MAAM,IAAI,KAAK;AACjC,QAAI,CAAC,MAAM;AACT,YAAM,IAAI;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,SAAK,MAAM,OAAO,KAAK;AACvB,QAAI,KAAK,aAAa,KAAK,IAAI,GAAG;AAChC,YAAM,IAAI,gBAAgB,6BAA6B,SAAS;AAAA,IAClE;AACA,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}