@pattern-stack/codegen 0.15.1 → 0.15.3

package/dist/chunk-7B3RYX45.js

@@ -0,0 +1,63 @@
+import {
+  CUBE_API_SECRET,
+  CUBE_API_URL
+} from "./chunk-6I7ULIN6.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/analytics/cube-backend.ts
+import { Inject, Injectable, Logger } from "@nestjs/common";
+var CubeAnalyticsBackend = class {
+  constructor(apiUrl, apiSecret) {
+    this.apiUrl = apiUrl;
+    this.apiSecret = apiSecret;
+  }
+  apiUrl;
+  apiSecret;
+  logger = new Logger(CubeAnalyticsBackend.name);
+  cubejsApi;
+  async onModuleInit() {
+    try {
+      const { default: cubejs } = await import("@cubejs-client/core");
+      this.cubejsApi = cubejs(this.apiSecret, { apiUrl: this.apiUrl });
+    } catch {
+      throw new Error(
+        "CubeAnalyticsBackend requires @cubejs-client/core. Install it: bun add @cubejs-client/core"
+      );
+    }
+  }
+  async execute(cube, measures, dimensions, where, opts) {
+    if (!this.cubejsApi) {
+      this.logger.warn("Cube.js client not initialized \u2014 returning empty result");
+      return [];
+    }
+    const query = {
+      measures: measures.map((m) => cube + "." + m),
+      dimensions: dimensions.map((d) => cube + "." + d)
+    };
+    if (where && Object.keys(where).length > 0) {
+      query.filters = Object.entries(where).map(([member, value]) => ({
+        member: cube + "." + member,
+        operator: "equals",
+        values: Array.isArray(value) ? value : [String(value)]
+      }));
+    }
+    if (opts?.limit) {
+      query.limit = opts.limit;
+    }
+    const resultSet = await this.cubejsApi.load(query);
+    return resultSet.tablePivot();
+  }
+};
+CubeAnalyticsBackend = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(CUBE_API_URL)),
+  __decorateParam(1, Inject(CUBE_API_SECRET))
+], CubeAnalyticsBackend);
+
+export {
+  CubeAnalyticsBackend
+};
+//# sourceMappingURL=chunk-7B3RYX45.js.map

package/dist/chunk-7B3RYX45.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/analytics/cube-backend.ts"],"sourcesContent":["/**\n * CubeAnalyticsBackend — cube.js backend for the analytics query port.\n *\n * Connects to a running cube.js instance via @cubejs-client/core and\n * translates IAnalyticsQuery calls into cube.js query objects.\n *\n * @cubejs-client/core is an optional peer dependency; lazy-imported so\n * the module loads even if the package isn't installed. Consumers who\n * use the cube backend must install it separately:\n *   bun add @cubejs-client/core\n *\n * Provided by AnalyticsModule.forRoot({ backend: 'cube' }).\n */\nimport { Inject, Injectable, OnModuleInit, Logger } from '@nestjs/common';\nimport { CUBE_API_URL, CUBE_API_SECRET } from './analytics.tokens';\nimport type {\n  AnalyticsQueryOpts,\n  IAnalyticsQuery,\n  ResultRow,\n} from './analytics-query.protocol';\n\n@Injectable()\nexport class CubeAnalyticsBackend implements IAnalyticsQuery, OnModuleInit {\n  private readonly logger = new Logger(CubeAnalyticsBackend.name);\n  private cubejsApi: any;\n\n  constructor(\n    @Inject(CUBE_API_URL) private readonly apiUrl: string,\n    @Inject(CUBE_API_SECRET) private readonly apiSecret: string,\n  ) {}\n\n  async onModuleInit(): Promise<void> {\n    try {\n      const { default: cubejs } = await import('@cubejs-client/core');\n      this.cubejsApi = cubejs(this.apiSecret, { apiUrl: this.apiUrl });\n    } catch {\n      throw new Error(\n        'CubeAnalyticsBackend requires @cubejs-client/core. Install it: bun add @cubejs-client/core',\n      );\n    }\n  }\n\n  async execute(\n    cube: string,\n    measures: string[],\n    dimensions: string[],\n    where?: Record<string, any>,\n    opts?: AnalyticsQueryOpts,\n  ): Promise<ResultRow[]> {\n    if (!this.cubejsApi) {\n      this.logger.warn('Cube.js client not initialized — returning empty result');\n      return [];\n    }\n\n    const query: Record<string, any> = {\n      measures: measures.map((m) => cube + '.' + m),\n      dimensions: dimensions.map((d) => cube + '.' + d),\n    };\n\n    if (where && Object.keys(where).length > 0) {\n      query.filters = Object.entries(where).map(([member, value]) => ({\n        member: cube + '.' + member,\n        operator: 'equals',\n        values: Array.isArray(value) ? value : [String(value)],\n      }));\n    }\n\n    if (opts?.limit) {\n      query.limit = opts.limit;\n    }\n\n    const resultSet = await this.cubejsApi.load(query);\n    return resultSet.tablePivot() as ResultRow[];\n  }\n}\n"],"mappings":";;;;;;;;;;AAaA,SAAS,QAAQ,YAA0B,cAAc;AASlD,IAAM,uBAAN,MAAoE;AAAA,EAIzE,YACyC,QACG,WAC1C;AAFuC;AACG;AAAA,EACzC;AAAA,EAFsC;AAAA,EACG;AAAA,EAL3B,SAAS,IAAI,OAAO,qBAAqB,IAAI;AAAA,EACtD;AAAA,EAOR,MAAM,eAA8B;AAClC,QAAI;AACF,YAAM,EAAE,SAAS,OAAO,IAAI,MAAM,OAAO,qBAAqB;AAC9D,WAAK,YAAY,OAAO,KAAK,WAAW,EAAE,QAAQ,KAAK,OAAO,CAAC;AAAA,IACjE,QAAQ;AACN,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,QACJ,MACA,UACA,YACA,OACA,MACsB;AACtB,QAAI,CAAC,KAAK,WAAW;AACnB,WAAK,OAAO,KAAK,8DAAyD;AAC1E,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,QAA6B;AAAA,MACjC,UAAU,SAAS,IAAI,CAAC,MAAM,OAAO,MAAM,CAAC;AAAA,MAC5C,YAAY,WAAW,IAAI,CAAC,MAAM,OAAO,MAAM,CAAC;AAAA,IAClD;AAEA,QAAI,SAAS,OAAO,KAAK,KAAK,EAAE,SAAS,GAAG;AAC1C,YAAM,UAAU,OAAO,QAAQ,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,KAAK,OAAO;AAAA,QAC9D,QAAQ,OAAO,MAAM;AAAA,QACrB,UAAU;AAAA,QACV,QAAQ,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC;AAAA,MACvD,EAAE;AAAA,IACJ;AAEA,QAAI,MAAM,OAAO;AACf,YAAM,QAAQ,KAAK;AAAA,IACrB;AAEA,UAAM,YAAY,MAAM,KAAK,UAAU,KAAK,KAAK;AACjD,WAAO,UAAU,WAAW;AAAA,EAC9B;AACF;AApDa,uBAAN;AAAA,EADN,WAAW;AAAA,EAMP,0BAAO,YAAY;AAAA,EACnB,0BAAO,eAAe;AAAA,GANd;","names":[]}

package/dist/chunk-7C3FOSDI.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-7C3FOSDI.js.map

package/dist/chunk-7C3FOSDI.js.map

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

package/dist/chunk-7KOW6PU6.js

@@ -0,0 +1,59 @@
+import {
+  BaseRepository
+} from "./chunk-J6KZS54B.js";
+
+// runtime/base-classes/metadata-entity-repository.ts
+import { eq, and, desc } from "drizzle-orm";
+var MetadataEntityRepository = class extends BaseRepository {
+  /**
+   * Bulk upsert with a caller-specified conflict target.
+   * Uses Drizzle's onConflictDoUpdate to merge records.
+   */
+  async upsertMany(inputs, tx, options) {
+    if (inputs.length === 0) return [];
+    const conflictTarget = options?.conflictTarget;
+    if (!conflictTarget) {
+      return super.upsertMany(inputs, tx);
+    }
+    const data = inputs.map(
+      (input) => this.withTimestamps(input, "create")
+    );
+    const rows = await this.runner(tx).insert(this.table).values(data).onConflictDoUpdate({
+      target: this.table[conflictTarget],
+      set: data[0]
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+    }).returning();
+    return rows;
+  }
+  /**
+   * Find metadata by entity ID and entity type (compound lookup).
+   */
+  async findByEntityIdAndType(entityId, entityType) {
+    const rows = await this.baseQuery().where(
+      and(
+        eq(this.table["entityId"], entityId),
+        eq(this.table["entityType"], entityType)
+      )
+    );
+    return rows;
+  }
+  /**
+   * List all metadata records for an entity.
+   */
+  async listByEntityId(entityId) {
+    const rows = await this.baseQuery().where(eq(this.table["entityId"], entityId));
+    return rows;
+  }
+  /**
+   * List metadata history for an entity, ordered by validFrom descending.
+   */
+  async listHistoryByEntityId(entityId) {
+    const rows = await this.baseQuery().where(eq(this.table["entityId"], entityId)).orderBy(desc(this.table["validFrom"]));
+    return rows;
+  }
+};
+
+export {
+  MetadataEntityRepository
+};
+//# sourceMappingURL=chunk-7KOW6PU6.js.map

package/dist/chunk-7KOW6PU6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/metadata-entity-repository.ts"],"sourcesContent":["/**\n * MetadataEntityRepository<TEntity>\n *\n * Family-specific base for metadata entities (field values, field history, tags).\n * Adds entity-scoped lookups, type filtering, history ordering, and bulk upsert.\n *\n * Concrete repos extend this and declare their table + behaviors.\n */\nimport { eq, and, desc } from 'drizzle-orm';\nimport type { PgTableWithColumns } from 'drizzle-orm/pg-core';\nimport { BaseRepository } from './base-repository';\nimport type { DrizzleTx } from '../types/drizzle';\n\nexport abstract class MetadataEntityRepository<TEntity> extends BaseRepository<TEntity> {\n  /**\n   * Bulk upsert with a caller-specified conflict target.\n   * Uses Drizzle's onConflictDoUpdate to merge records.\n   */\n  override async upsertMany(\n    inputs: Array<Partial<TEntity>>,\n    tx?: DrizzleTx,\n    options?: { conflictTarget?: keyof PgTableWithColumns<any>['_']['columns'] }, // eslint-disable-line @typescript-eslint/no-explicit-any\n  ): Promise<TEntity[]> {\n    if (inputs.length === 0) return [];\n    const conflictTarget = options?.conflictTarget;\n\n    // Fall back to base class naive upsert when no conflict target provided.\n    if (!conflictTarget) {\n      return super.upsertMany(inputs, tx);\n    }\n\n    const data = inputs.map((input) =>\n      this.withTimestamps(input as Record<string, unknown>, 'create'),\n    );\n\n    const rows = await this.runner(tx)\n      .insert(this.table)\n      .values(data as any) // eslint-disable-line @typescript-eslint/no-explicit-any\n      .onConflictDoUpdate({\n        target: this.table[conflictTarget as string],\n        set: data[0] as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n      })\n      .returning();\n\n    return rows as TEntity[];\n  }\n\n  /**\n   * Find metadata by entity ID and entity type (compound lookup).\n   */\n  async findByEntityIdAndType(entityId: string, entityType: string): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(\n        and(\n          eq(this.table['entityId'], entityId),\n          eq(this.table['entityType'], entityType),\n        ),\n      );\n    return rows as TEntity[];\n  }\n\n  /**\n   * List all metadata records for an entity.\n   */\n  async listByEntityId(entityId: string): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table['entityId'], entityId));\n    return rows as TEntity[];\n  }\n\n  /**\n   * List metadata history for an entity, ordered by validFrom descending.\n   */\n  async listHistoryByEntityId(entityId: string): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table['entityId'], entityId))\n      .orderBy(desc(this.table['validFrom']));\n    return rows as TEntity[];\n  }\n}\n"],"mappings":";;;;;AAQA,SAAS,IAAI,KAAK,YAAY;AAKvB,IAAe,2BAAf,cAAyD,eAAwB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtF,MAAe,WACb,QACA,IACA,SACoB;AACpB,QAAI,OAAO,WAAW,EAAG,QAAO,CAAC;AACjC,UAAM,iBAAiB,SAAS;AAGhC,QAAI,CAAC,gBAAgB;AACnB,aAAO,MAAM,WAAW,QAAQ,EAAE;AAAA,IACpC;AAEA,UAAM,OAAO,OAAO;AAAA,MAAI,CAAC,UACvB,KAAK,eAAe,OAAkC,QAAQ;AAAA,IAChE;AAEA,UAAM,OAAO,MAAM,KAAK,OAAO,EAAE,EAC9B,OAAO,KAAK,KAAK,EACjB,OAAO,IAAW,EAClB,mBAAmB;AAAA,MAClB,QAAQ,KAAK,MAAM,cAAwB;AAAA,MAC3C,KAAK,KAAK,CAAC;AAAA;AAAA,IACb,CAAC,EACA,UAAU;AAEb,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,sBAAsB,UAAkB,YAAwC;AACpF,UAAM,OAAO,MAAM,KAAK,UAAU,EAC/B;AAAA,MACC;AAAA,QACE,GAAG,KAAK,MAAM,UAAU,GAAG,QAAQ;AAAA,QACnC,GAAG,KAAK,MAAM,YAAY,GAAG,UAAU;AAAA,MACzC;AAAA,IACF;AACF,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,eAAe,UAAsC;AACzD,UAAM,OAAO,MAAM,KAAK,UAAU,EAC/B,MAAM,GAAG,KAAK,MAAM,UAAU,GAAG,QAAQ,CAAC;AAC7C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,sBAAsB,UAAsC;AAChE,UAAM,OAAO,MAAM,KAAK,UAAU,EAC/B,MAAM,GAAG,KAAK,MAAM,UAAU,GAAG,QAAQ,CAAC,EAC1C,QAAQ,KAAK,KAAK,MAAM,WAAW,CAAC,CAAC;AACxC,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-7RELQJIN.js

@@ -0,0 +1,22 @@
+// runtime/subsystems/auth/runtime/session-expired.error.ts
+var SessionExpiredError = class extends Error {
+  /** Duck-type marker — works across package boundaries where `instanceof` fails. */
+  isSessionExpired = true;
+  constructor(message = "Access token rejected by provider") {
+    super(message);
+    this.name = "SessionExpiredError";
+  }
+};
+function isSessionExpiredError(err) {
+  if (err instanceof SessionExpiredError) return true;
+  if (err !== null && typeof err === "object" && "isSessionExpired" in err) {
+    return err.isSessionExpired === true;
+  }
+  return false;
+}
+
+export {
+  SessionExpiredError,
+  isSessionExpiredError
+};
+//# sourceMappingURL=chunk-7RELQJIN.js.map

package/dist/chunk-7RELQJIN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/auth/runtime/session-expired.error.ts"],"sourcesContent":["/**\n * Provider-agnostic marker for \"the access token was rejected; a forced\n * refresh may recover.\"\n *\n * Concrete provider error classes (e.g. SalesforceSessionExpiredError,\n * HubSpotUnauthorizedError) either extend `SessionExpiredError` directly or\n * set `isSessionExpired === true` on their instances. `withAuthRetry` uses\n * the `isSessionExpiredError` predicate to decide whether to force-refresh\n * and retry once.\n *\n * This discriminator replaces the SFDC-only `instanceof` check from the\n * extraction-source app's original `withAuthRetry`. See\n * `docs/gate-1-auth-extraction-findings.md` (recommendation 4).\n */\nexport class SessionExpiredError extends Error {\n  /** Duck-type marker — works across package boundaries where `instanceof` fails. */\n  readonly isSessionExpired = true as const;\n\n  constructor(message = 'Access token rejected by provider') {\n    super(message);\n    this.name = 'SessionExpiredError';\n  }\n}\n\n/**\n * Predicate used by `withAuthRetry` by default.\n *\n * Matches any error that either `instanceof SessionExpiredError` or carries\n * the `isSessionExpired === true` marker property. Provider adapters that\n * want their existing error classes to participate can simply add the\n * marker property without touching the class hierarchy.\n */\nexport function isSessionExpiredError(err: unknown): boolean {\n  if (err instanceof SessionExpiredError) return true;\n  if (err !== null && typeof err === 'object' && 'isSessionExpired' in err) {\n    return (err as { isSessionExpired?: unknown }).isSessionExpired === true;\n  }\n  return false;\n}\n"],"mappings":";AAcO,IAAM,sBAAN,cAAkC,MAAM;AAAA;AAAA,EAEpC,mBAAmB;AAAA,EAE5B,YAAY,UAAU,qCAAqC;AACzD,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAUO,SAAS,sBAAsB,KAAuB;AAC3D,MAAI,eAAe,oBAAqB,QAAO;AAC/C,MAAI,QAAQ,QAAQ,OAAO,QAAQ,YAAY,sBAAsB,KAAK;AACxE,WAAQ,IAAuC,qBAAqB;AAAA,EACtE;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-7YGORYZD.js

@@ -0,0 +1,112 @@
+import {
+  CACHE_DEFAULT_TTL
+} from "./chunk-L6FTY45T.js";
+import {
+  cacheEntries
+} from "./chunk-FASRXRX5.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/cache/cache.drizzle-backend.ts
+import { Injectable, Inject, Optional } from "@nestjs/common";
+import { gt, or, like, sql, eq } from "drizzle-orm";
+var CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
+var DrizzleCacheService = class {
+  constructor(db, defaultTtl = null) {
+    this.db = db;
+    this.defaultTtl = defaultTtl;
+  }
+  db;
+  defaultTtl;
+  cleanupTimer = null;
+  /** In-flight getOrSet promises — keyed by cache key to deduplicate stampedes. */
+  inflight = /* @__PURE__ */ new Map();
+  async onModuleInit() {
+    this.cleanupTimer = setInterval(() => {
+      void this.deleteExpired();
+    }, CLEANUP_INTERVAL_MS);
+  }
+  async onModuleDestroy() {
+    if (this.cleanupTimer !== null) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  async get(key) {
+    try {
+      const rows = await this.db.select().from(cacheEntries).where(
+        sql`${cacheEntries.key} = ${key} AND (${cacheEntries.expiresAt} IS NULL OR ${cacheEntries.expiresAt} > now())`
+      ).limit(1);
+      if (rows.length === 0) return null;
+      return rows[0].value;
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    const effectiveTtl = ttlSeconds ?? this.defaultTtl ?? null;
+    const expiresAt = effectiveTtl !== null ? new Date(Date.now() + effectiveTtl * 1e3) : null;
+    const jsonValue = value;
+    await this.db.insert(cacheEntries).values({ key, value: jsonValue, expiresAt }).onConflictDoUpdate({
+      target: cacheEntries.key,
+      set: { value: jsonValue, expiresAt }
+    });
+  }
+  async delete(key) {
+    await this.db.delete(cacheEntries).where(eq(cacheEntries.key, key));
+  }
+  async invalidateByPrefix(prefix) {
+    const escaped = prefix.replace(/%/g, "\\%").replace(/_/g, "\\_");
+    const result = await this.db.delete(cacheEntries).where(like(cacheEntries.key, `${escaped}%`)).returning({ key: cacheEntries.key });
+    return result.length;
+  }
+  async has(key) {
+    try {
+      const result = await this.get(key);
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+  async getOrSet(key, factory, ttlSeconds) {
+    const cached = await this.get(key);
+    if (cached !== null) return cached;
+    const existing = this.inflight.get(key);
+    if (existing !== void 0) return existing;
+    const promise = factory().then(async (value) => {
+      await this.set(key, value, ttlSeconds);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /** Remove all expired entries. Called by the cleanup timer. */
+  async deleteExpired() {
+    try {
+      await this.db.delete(cacheEntries).where(
+        or(
+          gt(sql`now()`, cacheEntries.expiresAt)
+        )
+      );
+    } catch {
+    }
+  }
+};
+DrizzleCacheService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE)),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject(CACHE_DEFAULT_TTL))
+], DrizzleCacheService);
+
+export {
+  DrizzleCacheService
+};
+//# sourceMappingURL=chunk-7YGORYZD.js.map

package/dist/chunk-7YGORYZD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/cache/cache.drizzle-backend.ts"],"sourcesContent":["/**\n * DrizzleCacheService — Postgres-backed ICacheService via Drizzle ORM.\n *\n * Storage: `cache_entries` table with key (text pk), value (jsonb), expiresAt (timestamp).\n * TTL enforcement: reads filter by `expiresAt > now() OR expiresAt IS NULL`.\n * Prefix invalidation: `DELETE WHERE key LIKE 'escaped_prefix%'`.\n *\n * Lifecycle:\n * - OnModuleInit: starts periodic cleanup of expired entries.\n *   Uses the Jobs subsystem if available (optional injection); falls back to setInterval.\n * - OnModuleDestroy: clears the setInterval timer if used.\n *\n * Error behavior per ADR-008:\n * - get() / has() return null/false on any error (never throw for reads).\n * - set() / delete() / invalidateByPrefix() throw on failure.\n */\nimport { Injectable, Inject, Optional, type OnModuleInit, type OnModuleDestroy } from '@nestjs/common';\nimport { gt, or, like, sql, eq } from 'drizzle-orm';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport type { ICacheService } from './cache.protocol';\nimport { cacheEntries } from './cache.schema';\nimport { DRIZZLE } from '../../constants/tokens';\nimport { CACHE_DEFAULT_TTL } from './cache.tokens';\n\n// Re-export for backward compatibility\nexport { CACHE_DEFAULT_TTL } from './cache.tokens';\n\n/** Cleanup interval in milliseconds when jobs subsystem is unavailable. */\nconst CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes\n\n@Injectable()\nexport class DrizzleCacheService implements ICacheService, OnModuleInit, OnModuleDestroy {\n  private cleanupTimer: ReturnType<typeof setInterval> | null = null;\n  /** In-flight getOrSet promises — keyed by cache key to deduplicate stampedes. */\n  private readonly inflight = new Map<string, Promise<unknown>>();\n\n  constructor(\n    @Inject(DRIZZLE) private readonly db: DrizzleClient,\n    @Optional() @Inject(CACHE_DEFAULT_TTL) private readonly defaultTtl: number | null = null,\n  ) {}\n\n  async onModuleInit(): Promise<void> {\n    this.cleanupTimer = setInterval(() => {\n      void this.deleteExpired();\n    }, CLEANUP_INTERVAL_MS);\n  }\n\n  async onModuleDestroy(): Promise<void> {\n    if (this.cleanupTimer !== null) {\n      clearInterval(this.cleanupTimer);\n      this.cleanupTimer = null;\n    }\n  }\n\n  async get<T = unknown>(key: string): Promise<T | null> {\n    try {\n      const rows = await this.db\n        .select()\n        .from(cacheEntries)\n        .where(\n          sql`${cacheEntries.key} = ${key} AND (${cacheEntries.expiresAt} IS NULL OR ${cacheEntries.expiresAt} > now())`,\n        )\n        .limit(1);\n\n      if (rows.length === 0) return null;\n      return rows[0]!.value as T;\n    } catch {\n      return null;\n    }\n  }\n\n  async set<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const effectiveTtl = ttlSeconds ?? this.defaultTtl ?? null;\n    const expiresAt =\n      effectiveTtl !== null\n        ? new Date(Date.now() + effectiveTtl * 1000)\n        : null;\n\n    const jsonValue = value as Parameters<typeof cacheEntries.value.mapFromDriverValue>[0];\n    await this.db\n      .insert(cacheEntries)\n      .values({ key, value: jsonValue, expiresAt })\n      .onConflictDoUpdate({\n        target: cacheEntries.key,\n        set: { value: jsonValue, expiresAt },\n      });\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.db.delete(cacheEntries).where(eq(cacheEntries.key, key));\n  }\n\n  async invalidateByPrefix(prefix: string): Promise<number> {\n    // Escape LIKE wildcards to prevent prefix characters from matching unintended entries\n    const escaped = prefix.replace(/%/g, '\\\\%').replace(/_/g, '\\\\_');\n    const result = await this.db\n      .delete(cacheEntries)\n      .where(like(cacheEntries.key, `${escaped}%`))\n      .returning({ key: cacheEntries.key });\n    return result.length;\n  }\n\n  async has(key: string): Promise<boolean> {\n    try {\n      const result = await this.get(key);\n      return result !== null;\n    } catch {\n      return false;\n    }\n  }\n\n  async getOrSet<T = unknown>(\n    key: string,\n    factory: () => Promise<T>,\n    ttlSeconds?: number,\n  ): Promise<T> {\n    // Fast path: cache hit\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    // Stampede protection: if another call is already computing this key, reuse its promise\n    const existing = this.inflight.get(key) as Promise<T> | undefined;\n    if (existing !== undefined) return existing;\n\n    const promise = factory().then(async (value) => {\n      await this.set(key, value, ttlSeconds);\n      return value;\n    }).finally(() => {\n      this.inflight.delete(key);\n    });\n\n    this.inflight.set(key, promise as Promise<unknown>);\n    return promise;\n  }\n\n  /** Remove all expired entries. Called by the cleanup timer. */\n  private async deleteExpired(): Promise<void> {\n    try {\n      await this.db\n        .delete(cacheEntries)\n        .where(\n          or(\n            gt(sql`now()`, cacheEntries.expiresAt),\n          ),\n        );\n    } catch {\n      // Cleanup failures are non-fatal — stale rows are filtered at read time\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-AHV4GDYM.js

@@ -0,0 +1,63 @@
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/integration/integration-cursor-store.memory-backend.ts
+import { Injectable } from "@nestjs/common";
+var MemoryCursorStore = class {
+  /**
+   * Subscription-id → last persisted cursor. Public so tests can inspect
+   * or pre-seed state; production callers MUST go through `get`/`put`.
+   */
+  cursors = /* @__PURE__ */ new Map();
+  /**
+   * Seedable subscription metadata for `listAll` — the memory backend
+   * stores only `subscriptionId → cursor` in its write path, so the
+   * snapshot shape (`connectionId`, `adapter`, `domain`, `externalRef`,
+   * timestamps) has no natural source without test seeding. Tests populate
+   * this map; unseeded entries get empty-string metadata and `new Date(0)`
+   * timestamps so the shape stays stable. Production paths go through the
+   * Drizzle backend.
+   */
+  subscriptions = /* @__PURE__ */ new Map();
+  async get(subscriptionId, _tenantId) {
+    const value = this.cursors.get(subscriptionId);
+    return value === void 0 ? null : value;
+  }
+  async put(subscriptionId, cursor, _tenantId) {
+    this.cursors.set(subscriptionId, cursor);
+  }
+  async listAll(_tenantId) {
+    const snapshots = [];
+    for (const [subscriptionId, cursor] of this.cursors.entries()) {
+      const meta = this.subscriptions.get(subscriptionId);
+      snapshots.push({
+        subscriptionId,
+        connectionId: meta?.connectionId ?? "",
+        adapter: meta?.adapter ?? "",
+        domain: meta?.domain ?? "",
+        externalRef: meta?.externalRef ?? null,
+        cursor: cursor ?? null,
+        lastIntegrationAt: meta?.lastIntegrationAt ?? null,
+        updatedAt: meta?.updatedAt ?? /* @__PURE__ */ new Date(0),
+        tenantId: null
+      });
+    }
+    return snapshots.sort(
+      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
+    );
+  }
+  /** Reset state. Tests call this in `beforeEach`. */
+  clear() {
+    this.cursors.clear();
+    this.subscriptions.clear();
+  }
+};
+MemoryCursorStore = __decorateClass([
+  Injectable()
+], MemoryCursorStore);
+
+export {
+  MemoryCursorStore
+};
+//# sourceMappingURL=chunk-AHV4GDYM.js.map

package/dist/chunk-AHV4GDYM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/integration-cursor-store.memory-backend.ts"],"sourcesContent":["/**\n * MemoryCursorStore — in-memory backend for `ICursorStore` (SYNC-3).\n *\n * Test double that lets consumers exercise `ExecuteIntegrationUseCase` (SYNC-5) and\n * other cursor-consuming code paths without Postgres. Mirrors the role of\n * `MemoryEventBus` and `MemoryJobStore`: plain keyed state, tests take a\n * direct reference for `beforeEach` resets.\n *\n * Cursor values are stored by reference — the port's `get`/`put` contract\n * treats them as opaque `unknown`. Callers that want durable value-equality\n * semantics should snapshot via JSON before `put` and reparse after `get`;\n * this is what the Drizzle backend (SYNC-4) does implicitly via jsonb\n * round-trip. The memory backend intentionally does not simulate the\n * serialize/deserialize cycle — consumers who care should test against\n * Postgres.\n *\n * ## Multi-tenancy\n *\n * `tenantId` is accepted but ignored. The memory backend's state is\n * process-local — there's no durable storage where a cross-tenant leak\n * could occur. Tests that want to assert per-tenant isolation should\n * target the Drizzle backend.\n *\n * Not shipped in the upstream consumer; this is a subsystem-first addition for the\n * test surface. Consumed by:\n *   - SYNC-5 unit tests (`ExecuteIntegrationUseCase` against synthetic sources)\n *   - SYNC-6 module tests (`IntegrationModule.forRoot({ backend: 'memory' })`)\n */\nimport { Injectable } from '@nestjs/common';\nimport type {\n  CursorSnapshot,\n  ICursorStore,\n} from './integration-cursor-store.protocol';\nimport type { MemoryIntegrationSubscription } from './integration-run-recorder.memory-backend';\n\n@Injectable()\nexport class MemoryCursorStore implements ICursorStore {\n  /**\n   * Subscription-id → last persisted cursor. Public so tests can inspect\n   * or pre-seed state; production callers MUST go through `get`/`put`.\n   */\n  readonly cursors: Map<string, unknown> = new Map();\n\n  /**\n   * Seedable subscription metadata for `listAll` — the memory backend\n   * stores only `subscriptionId → cursor` in its write path, so the\n   * snapshot shape (`connectionId`, `adapter`, `domain`, `externalRef`,\n   * timestamps) has no natural source without test seeding. Tests populate\n   * this map; unseeded entries get empty-string metadata and `new Date(0)`\n   * timestamps so the shape stays stable. Production paths go through the\n   * Drizzle backend.\n   */\n  readonly subscriptions: Map<string, MemoryIntegrationSubscription> = new Map();\n\n  async get(\n    subscriptionId: string,\n    _tenantId?: string | null,\n  ): Promise<unknown | null> {\n    // `Map.get` returns `undefined` for missing keys; the port contract\n    // returns `null`. Normalize here so callers can `=== null`-check.\n    const value = this.cursors.get(subscriptionId);\n    return value === undefined ? null : value;\n  }\n\n  async put(\n    subscriptionId: string,\n    cursor: unknown,\n    _tenantId?: string | null,\n  ): Promise<void> {\n    // Overwrite semantics — matches the port contract and the Drizzle\n    // backend's `ON CONFLICT DO UPDATE` behavior.\n    this.cursors.set(subscriptionId, cursor);\n  }\n\n  async listAll(_tenantId?: string | null): Promise<CursorSnapshot[]> {\n    // Accepts tenantId for contract symmetry but does not filter on it —\n    // the memory backend never enforces tenancy (see class-level comment).\n    const snapshots: CursorSnapshot[] = [];\n    for (const [subscriptionId, cursor] of this.cursors.entries()) {\n      const meta = this.subscriptions.get(subscriptionId);\n      snapshots.push({\n        subscriptionId,\n        connectionId: meta?.connectionId ?? '',\n        adapter: meta?.adapter ?? '',\n        domain: meta?.domain ?? '',\n        externalRef: meta?.externalRef ?? null,\n        cursor: cursor ?? null,\n        lastIntegrationAt: meta?.lastIntegrationAt ?? null,\n        updatedAt: meta?.updatedAt ?? new Date(0),\n        tenantId: null,\n      });\n    }\n    return snapshots.sort(\n      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime(),\n    );\n  }\n\n  /** Reset state. Tests call this in `beforeEach`. */\n  clear(): void {\n    this.cursors.clear();\n    this.subscriptions.clear();\n  }\n}\n"],"mappings":";;;;;AA4BA,SAAS,kBAAkB;AAQpB,IAAM,oBAAN,MAAgD;AAAA;AAAA;AAAA;AAAA;AAAA,EAK5C,UAAgC,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWxC,gBAA4D,oBAAI,IAAI;AAAA,EAE7E,MAAM,IACJ,gBACA,WACyB;AAGzB,UAAM,QAAQ,KAAK,QAAQ,IAAI,cAAc;AAC7C,WAAO,UAAU,SAAY,OAAO;AAAA,EACtC;AAAA,EAEA,MAAM,IACJ,gBACA,QACA,WACe;AAGf,SAAK,QAAQ,IAAI,gBAAgB,MAAM;AAAA,EACzC;AAAA,EAEA,MAAM,QAAQ,WAAsD;AAGlE,UAAM,YAA8B,CAAC;AACrC,eAAW,CAAC,gBAAgB,MAAM,KAAK,KAAK,QAAQ,QAAQ,GAAG;AAC7D,YAAM,OAAO,KAAK,cAAc,IAAI,cAAc;AAClD,gBAAU,KAAK;AAAA,QACb;AAAA,QACA,cAAc,MAAM,gBAAgB;AAAA,QACpC,SAAS,MAAM,WAAW;AAAA,QAC1B,QAAQ,MAAM,UAAU;AAAA,QACxB,aAAa,MAAM,eAAe;AAAA,QAClC,QAAQ,UAAU;AAAA,QAClB,mBAAmB,MAAM,qBAAqB;AAAA,QAC9C,WAAW,MAAM,aAAa,oBAAI,KAAK,CAAC;AAAA,QACxC,UAAU;AAAA,MACZ,CAAC;AAAA,IACH;AACA,WAAO,UAAU;AAAA,MACf,CAAC,GAAG,MAAM,EAAE,UAAU,QAAQ,IAAI,EAAE,UAAU,QAAQ;AAAA,IACxD;AAAA,EACF;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,QAAQ,MAAM;AACnB,SAAK,cAAc,MAAM;AAAA,EAC3B;AACF;AAlEa,oBAAN;AAAA,EADN,WAAW;AAAA,GACC;","names":[]}

package/dist/chunk-AQFQ4BYM.js

@@ -0,0 +1,81 @@
+import {
+  OBSERVABILITY,
+  OBSERVABILITY_MODULE_OPTIONS
+} from "./chunk-Y7RRSEOC.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts
+import {
+  Inject,
+  Injectable,
+  Logger
+} from "@nestjs/common";
+var BridgeMetricsReporter = class {
+  constructor(observability, options) {
+    this.observability = observability;
+    this.config = options.reporters?.bridgeMetrics;
+  }
+  observability;
+  logger = new Logger(BridgeMetricsReporter.name);
+  handle = null;
+  config;
+  onModuleInit() {
+    if (!this.config || !this.config.enabled) {
+      this.logger.log("BridgeMetricsReporter disabled");
+      return;
+    }
+    if (this.config.intervalMs <= 0 || this.config.windowHours <= 0) {
+      this.logger.warn(
+        `invalid config; not starting: intervalMs=${this.config.intervalMs} windowHours=${this.config.windowHours}`
+      );
+      return;
+    }
+    void this.runOnce();
+    this.handle = setInterval(() => {
+      void this.runOnce();
+    }, this.config.intervalMs);
+    if (typeof this.handle.unref === "function") this.handle.unref();
+  }
+  onModuleDestroy() {
+    if (this.handle !== null) {
+      clearInterval(this.handle);
+      this.handle = null;
+    }
+  }
+  /**
+   * Single sample. Public so tests and future ops tooling can trigger a
+   * sample on demand without waiting for the interval. Errors are caught
+   * and logged here — never rethrown — so a transient sibling failure
+   * does not kill subsequent ticks.
+   */
+  async runOnce() {
+    if (!this.config || !this.config.enabled) return;
+    try {
+      const h = await this.observability.getBridgeDeliveryHistogram(
+        this.config.windowHours,
+        this.config.tenantId
+      );
+      this.logger.log(
+        `bridge-delivery window=${this.config.windowHours}h tenant=${this.config.tenantId ?? "default"} pending=${h.pending} delivered=${h.delivered} skipped=${h.skipped} failed=${h.failed}`
+      );
+    } catch (err) {
+      this.logger.error(
+        "BridgeMetricsReporter runOnce failed",
+        err instanceof Error ? err.stack : String(err)
+      );
+    }
+  }
+};
+BridgeMetricsReporter = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(OBSERVABILITY)),
+  __decorateParam(1, Inject(OBSERVABILITY_MODULE_OPTIONS))
+], BridgeMetricsReporter);
+
+export {
+  BridgeMetricsReporter
+};
+//# sourceMappingURL=chunk-AQFQ4BYM.js.map

package/dist/chunk-AQFQ4BYM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts"],"sourcesContent":["/**\n * BridgeMetricsReporter — internal consumer of `IObservability`\n * (ADR-025, OBS-6).\n *\n * Periodically samples `getBridgeDeliveryHistogram` from the observability\n * facade and emits one log line per tick. Auto-registered by\n * `ObservabilityModule.forRoot()` when\n * `options.reporters.bridgeMetrics.enabled === true`. Consumers configure\n * via options; they never import this class. Not exported from the\n * module's `exports` array — internal.\n *\n * # Invariants (enforced by skill + ADR-025)\n *\n *   - Injects ONLY `OBSERVABILITY` + `OBSERVABILITY_MODULE_OPTIONS`. Never\n *     `BRIDGE_DELIVERY_REPO` or any other sibling token. Reporters are\n *     consumers of the composed facade, not parallel composers.\n *   - Never reaches into sibling tables or extends `IObservability`.\n *   - Errors isolated per-tick (logged, never rethrown) so a transient\n *     sibling failure does not kill the interval.\n *   - `tenantId` passes VERBATIM to the facade — observability owns tenant\n *     semantics, reporters don't re-implement them.\n *\n * # Lifecycle\n *\n *   - `onModuleInit` — eager first-tick, then `setInterval`. Handle is\n *     `.unref()`-ed when supported so the loop never blocks node shutdown.\n *   - `onModuleDestroy` — `clearInterval` + null the handle. Idempotent.\n *\n * No `@nestjs/schedule` dependency — raw `setInterval` keeps the runtime\n * footprint minimal and avoids pulling a decorator framework in for a\n * single loop.\n */\nimport {\n  Inject,\n  Injectable,\n  Logger,\n  type OnModuleDestroy,\n  type OnModuleInit,\n} from '@nestjs/common';\n\nimport type { IObservability } from '../observability.protocol';\nimport {\n  OBSERVABILITY,\n  OBSERVABILITY_MODULE_OPTIONS,\n} from '../observability.tokens';\n// Type-only imports — the module imports this file as a value for DI\n// registration, and this file imports config types back. Keeping the\n// back-edge type-only prevents a runtime circular-import.\nimport type {\n  BridgeMetricsReporterConfig,\n  ObservabilityModuleOptions,\n} from '../observability.module';\n\n@Injectable()\nexport class BridgeMetricsReporter implements OnModuleInit, OnModuleDestroy {\n  private readonly logger = new Logger(BridgeMetricsReporter.name);\n  private handle: ReturnType<typeof setInterval> | null = null;\n  private readonly config: BridgeMetricsReporterConfig | undefined;\n\n  constructor(\n    @Inject(OBSERVABILITY) private readonly observability: IObservability,\n    @Inject(OBSERVABILITY_MODULE_OPTIONS) options: ObservabilityModuleOptions,\n  ) {\n    this.config = options.reporters?.bridgeMetrics;\n  }\n\n  onModuleInit(): void {\n    if (!this.config || !this.config.enabled) {\n      this.logger.log('BridgeMetricsReporter disabled');\n      return;\n    }\n    if (this.config.intervalMs <= 0 || this.config.windowHours <= 0) {\n      this.logger.warn(\n        `invalid config; not starting: intervalMs=${this.config.intervalMs} windowHours=${this.config.windowHours}`,\n      );\n      return;\n    }\n    // Eager first-tick so consumers see data immediately on boot, without\n    // waiting `intervalMs` for the first sample.\n    void this.runOnce();\n    this.handle = setInterval(() => {\n      void this.runOnce();\n    }, this.config.intervalMs);\n    // `.unref()` lets the node process exit even if the interval is still\n    // scheduled — important in short-lived CLI/test contexts. Guarded\n    // because browser-shimmed timers may not expose it.\n    if (typeof this.handle.unref === 'function') this.handle.unref();\n  }\n\n  onModuleDestroy(): void {\n    if (this.handle !== null) {\n      clearInterval(this.handle);\n      this.handle = null;\n    }\n  }\n\n  /**\n   * Single sample. Public so tests and future ops tooling can trigger a\n   * sample on demand without waiting for the interval. Errors are caught\n   * and logged here — never rethrown — so a transient sibling failure\n   * does not kill subsequent ticks.\n   */\n  async runOnce(): Promise<void> {\n    if (!this.config || !this.config.enabled) return;\n    try {\n      const h = await this.observability.getBridgeDeliveryHistogram(\n        this.config.windowHours,\n        this.config.tenantId,\n      );\n      this.logger.log(\n        `bridge-delivery window=${this.config.windowHours}h tenant=${this.config.tenantId ?? 'default'} pending=${h.pending} delivered=${h.delivered} skipped=${h.skipped} failed=${h.failed}`,\n      );\n    } catch (err) {\n      this.logger.error(\n        'BridgeMetricsReporter runOnce failed',\n        err instanceof Error ? err.stack : String(err),\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAgCA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AAgBA,IAAM,wBAAN,MAAqE;AAAA,EAK1E,YAC0C,eACF,SACtC;AAFwC;AAGxC,SAAK,SAAS,QAAQ,WAAW;AAAA,EACnC;AAAA,EAJ0C;AAAA,EALzB,SAAS,IAAI,OAAO,sBAAsB,IAAI;AAAA,EACvD,SAAgD;AAAA,EACvC;AAAA,EASjB,eAAqB;AACnB,QAAI,CAAC,KAAK,UAAU,CAAC,KAAK,OAAO,SAAS;AACxC,WAAK,OAAO,IAAI,gCAAgC;AAChD;AAAA,IACF;AACA,QAAI,KAAK,OAAO,cAAc,KAAK,KAAK,OAAO,eAAe,GAAG;AAC/D,WAAK,OAAO;AAAA,QACV,4CAA4C,KAAK,OAAO,UAAU,gBAAgB,KAAK,OAAO,WAAW;AAAA,MAC3G;AACA;AAAA,IACF;AAGA,SAAK,KAAK,QAAQ;AAClB,SAAK,SAAS,YAAY,MAAM;AAC9B,WAAK,KAAK,QAAQ;AAAA,IACpB,GAAG,KAAK,OAAO,UAAU;AAIzB,QAAI,OAAO,KAAK,OAAO,UAAU,WAAY,MAAK,OAAO,MAAM;AAAA,EACjE;AAAA,EAEA,kBAAwB;AACtB,QAAI,KAAK,WAAW,MAAM;AACxB,oBAAc,KAAK,MAAM;AACzB,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,UAAyB;AAC7B,QAAI,CAAC,KAAK,UAAU,CAAC,KAAK,OAAO,QAAS;AAC1C,QAAI;AACF,YAAM,IAAI,MAAM,KAAK,cAAc;AAAA,QACjC,KAAK,OAAO;AAAA,QACZ,KAAK,OAAO;AAAA,MACd;AACA,WAAK,OAAO;AAAA,QACV,0BAA0B,KAAK,OAAO,WAAW,YAAY,KAAK,OAAO,YAAY,SAAS,YAAY,EAAE,OAAO,cAAc,EAAE,SAAS,YAAY,EAAE,OAAO,WAAW,EAAE,MAAM;AAAA,MACtL;AAAA,IACF,SAAS,KAAK;AACZ,WAAK,OAAO;AAAA,QACV;AAAA,QACA,eAAe,QAAQ,IAAI,QAAQ,OAAO,GAAG;AAAA,MAC/C;AAAA,IACF;AAAA,EACF;AACF;AAjEa,wBAAN;AAAA,EADN,WAAW;AAAA,EAOP,0BAAO,aAAa;AAAA,EACpB,0BAAO,4BAA4B;AAAA,GAP3B;","names":[]}

package/dist/chunk-AS3NAZB6.js

@@ -0,0 +1,14 @@
+import {
+  BaseService
+} from "./chunk-W72PRNJY.js";
+
+// runtime/base-classes/knowledge-entity-service.ts
+var KnowledgeEntityService = class extends BaseService {
+  // pgvector-dependent methods will be added when the extension is available:
+  //   semanticSearch, findPendingByOpportunityId, updateStatus, updateStatusBatch
+};
+
+export {
+  KnowledgeEntityService
+};
+//# sourceMappingURL=chunk-AS3NAZB6.js.map

package/dist/chunk-AS3NAZB6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/knowledge-entity-service.ts"],"sourcesContent":["/**\n * KnowledgeEntityService<TRepo, TEntity>\n *\n * Stub for the knowledge family (requires pgvector — parked for now).\n */\nimport { BaseService, type IBaseRepository } from './base-service';\n\nexport abstract class KnowledgeEntityService<\n  TRepo extends IBaseRepository<TEntity>,\n  TEntity,\n> extends BaseService<TRepo, TEntity> {\n  // pgvector-dependent methods will be added when the extension is available:\n  //   semanticSearch, findPendingByOpportunityId, updateStatus, updateStatusBatch\n}\n"],"mappings":";;;;;AAOO,IAAe,yBAAf,cAGG,YAA4B;AAAA;AAAA;AAGtC;","names":[]}

package/dist/chunk-BGULBWKJ.js

@@ -0,0 +1,88 @@
+// runtime/subsystems/events/generated/registry.ts
+var eventRegistry = {
+  "contact_created": {
+    type: "contact_created",
+    tier: "domain",
+    direction: "change",
+    pool: "events_change",
+    aggregate: "contact",
+    version: 1,
+    retry: { attempts: 3, backoff: "exponential" }
+  },
+  "contact_marked_champion": {
+    type: "contact_marked_champion",
+    tier: "domain",
+    direction: "change",
+    pool: "events_change",
+    aggregate: "contact",
+    version: 1,
+    retry: { attempts: 3, backoff: "exponential" }
+  },
+  "contact_merged": {
+    type: "contact_merged",
+    tier: "domain",
+    direction: "change",
+    pool: "events_change",
+    aggregate: "contact",
+    version: 1,
+    retry: { attempts: 3, backoff: "exponential" }
+  },
+  "crm_sync_started": {
+    type: "crm_sync_started",
+    tier: "audit",
+    direction: null,
+    pool: null,
+    version: 1,
+    retry: { attempts: 3, backoff: "exponential" }
+  },
+  "deal_created": {
+    type: "deal_created",
+    tier: "domain",
+    direction: "change",
+    pool: "events_change",
+    aggregate: "deal",
+    version: 1,
+    retry: { attempts: 3, backoff: "exponential" }
+  },
+  "deal_stage_changed": {
+    type: "deal_stage_changed",
+    tier: "domain",
+    direction: "change",
+    pool: "events_change",
+    aggregate: "deal",
+    version: 1,
+    retry: { attempts: 3, backoff: "exponential" }
+  },
+  "stripe_payment_received": {
+    type: "stripe_payment_received",
+    tier: "domain",
+    direction: "inbound",
+    pool: "events_inbound",
+    source: "stripe",
+    version: 1,
+    retry: { attempts: 5, backoff: "exponential" }
+  },
+  "webhook_outbound_contact_sync": {
+    type: "webhook_outbound_contact_sync",
+    tier: "domain",
+    direction: "outbound",
+    pool: "events_outbound",
+    aggregate: "contact",
+    destination: "crm",
+    version: 1,
+    retry: { attempts: 3, backoff: "exponential" }
+  }
+};
+function getEventMetadata(type) {
+  const meta = eventRegistry[type];
+  if (!meta) {
+    throw new Error(`No registry entry for event type '${String(type)}' \u2014 declare events under events/*.yaml and re-run \`codegen entity new --all\`.`);
+  }
+  return meta;
+}
+
+export {
+  eventRegistry,
+  getEventMetadata
+};
+//# sourceMappingURL=chunk-BGULBWKJ.js.map

package/dist/chunk-BGULBWKJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/generated/registry.ts"],"sourcesContent":["// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.\n// Run `codegen entity new --all` to refresh.\n\n\nimport type { EventTypeName } from './types';\n\nexport interface EventMetadata {\n\ttype: EventTypeName;\n\ttier: 'domain' | 'audit';\n\tdirection: 'inbound' | 'change' | 'outbound' | null;\n\tpool: 'events_inbound' | 'events_change' | 'events_outbound' | null;\n\taggregate?: string;\n\tsource?: string;\n\tdestination?: string;\n\tversion: number;\n\tretry: { attempts: number; backoff: 'linear' | 'exponential' };\n}\n\nexport const eventRegistry = {\n\t'contact_created': {\n\t\ttype: 'contact_created',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'contact',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'contact_marked_champion': {\n\t\ttype: 'contact_marked_champion',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'contact',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'contact_merged': {\n\t\ttype: 'contact_merged',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'contact',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'crm_sync_started': {\n\t\ttype: 'crm_sync_started',\n\t\ttier: 'audit',\n\t\tdirection: null,\n\t\tpool: null,\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'deal_created': {\n\t\ttype: 'deal_created',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'deal',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'deal_stage_changed': {\n\t\ttype: 'deal_stage_changed',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'deal',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'stripe_payment_received': {\n\t\ttype: 'stripe_payment_received',\n\t\ttier: 'domain',\n\t\tdirection: 'inbound',\n\t\tpool: 'events_inbound',\n\t\tsource: 'stripe',\n\t\tversion: 1,\n\t\tretry: { attempts: 5, backoff: 'exponential' },\n\t},\n\t'webhook_outbound_contact_sync': {\n\t\ttype: 'webhook_outbound_contact_sync',\n\t\ttier: 'domain',\n\t\tdirection: 'outbound',\n\t\tpool: 'events_outbound',\n\t\taggregate: 'contact',\n\t\tdestination: 'crm',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n} as const satisfies Record<EventTypeName, EventMetadata>;\n\nexport function getEventMetadata<T extends EventTypeName>(type: T): EventMetadata {\n\tconst meta = eventRegistry[type];\n\tif (!meta) {\n\t\tthrow new Error(`No registry entry for event type '${String(type)}' — declare events under events/*.yaml and re-run \\`codegen entity new --all\\`.`);\n\t}\n\treturn meta;\n}\n"],"mappings":";AAkBO,IAAM,gBAAgB;AAAA,EAC5B,mBAAmB;AAAA,IAClB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,2BAA2B;AAAA,IAC1B,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,kBAAkB;AAAA,IACjB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,oBAAoB;AAAA,IACnB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,gBAAgB;AAAA,IACf,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,sBAAsB;AAAA,IACrB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,2BAA2B;AAAA,IAC1B,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,iCAAiC;AAAA,IAChC,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,aAAa;AAAA,IACb,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AACD;AAEO,SAAS,iBAA0C,MAAwB;AACjF,QAAM,OAAO,cAAc,IAAI;AAC/B,MAAI,CAAC,MAAM;AACV,UAAM,IAAI,MAAM,qCAAqC,OAAO,IAAI,CAAC,sFAAiF;AAAA,EACnJ;AACA,SAAO;AACR;","names":[]}

package/dist/chunk-BIO6F7YI.js

@@ -0,0 +1,17 @@
+import {
+  tokenKey
+} from "./chunk-GYGNEQSC.js";
+
+// runtime/subsystems/jobs/jobs-domain.tokens.ts
+var JOB_ORCHESTRATOR = Symbol.for(tokenKey("jobs", "orchestrator"));
+var JOB_RUN_SERVICE = Symbol.for(tokenKey("jobs", "run-service"));
+var JOB_STEP_SERVICE = Symbol.for(tokenKey("jobs", "step-service"));
+var JOBS_MULTI_TENANT = Symbol.for(tokenKey("jobs", "multi-tenant"));
+
+export {
+  JOB_ORCHESTRATOR,
+  JOB_RUN_SERVICE,
+  JOB_STEP_SERVICE,
+  JOBS_MULTI_TENANT
+};
+//# sourceMappingURL=chunk-BIO6F7YI.js.map

package/dist/chunk-BIO6F7YI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/jobs-domain.tokens.ts"],"sourcesContent":["/**\n * Injection tokens for the job orchestration domain layer (ADR-022, JOB-2).\n *\n * Consumer code injects these symbols via `@Inject(JOB_ORCHESTRATOR)` etc.;\n * concrete backends (JOB-3 Drizzle, JOB-4 Memory) provide the implementations\n * through `JobsDomainModule.forRoot({ backend })` in JOB-5.\n *\n * Each token is a namespaced `Symbol.for(...)` (ADR-037, via `tokenKey()`) —\n * distinct per key, so Nest's DI lookup is unambiguous, AND matching by VALUE\n * across import boundaries so the package and a (legacy) vendored runtime copy\n * resolve to the same symbol.\n */\nimport { tokenKey } from '../token-key';\n\nexport const JOB_ORCHESTRATOR = Symbol.for(tokenKey('jobs', 'orchestrator'));\nexport const JOB_RUN_SERVICE = Symbol.for(tokenKey('jobs', 'run-service'));\nexport const JOB_STEP_SERVICE = Symbol.for(tokenKey('jobs', 'step-service'));\n\n/**\n * Multi-tenancy opt-in flag (JOB-8). Bound to the boolean passed in via\n * `JobsDomainModule.forRoot({ multiTenant })`, defaulting to `false`.\n *\n * When `true`, the four service-layer backends (Drizzle + Memory orchestrator\n * and run-service) enforce `tenantId` on every mutating / targeted-read call:\n * `start`, `cancel`, `listForScope`, `cancelForScope`, `rescheduleForScope`.\n * Missing (`undefined`) `tenantId` throws `MissingTenantIdError`; explicit\n * `null` opts into cross-tenant background work and passes through.\n *\n * The JobWorker claim loop is **cross-tenant by design** — the worker has no\n * tenant context; `tenantId` is populated at write time and enforced on\n * targeted reads. See docs/specs/JOB-8.md.\n */\nexport const JOBS_MULTI_TENANT = Symbol.for(tokenKey('jobs', 'multi-tenant'));\n"],"mappings":";;;;;AAcO,IAAM,mBAAmB,OAAO,IAAI,SAAS,QAAQ,cAAc,CAAC;AACpE,IAAM,kBAAkB,OAAO,IAAI,SAAS,QAAQ,aAAa,CAAC;AAClE,IAAM,mBAAmB,OAAO,IAAI,SAAS,QAAQ,cAAc,CAAC;AAgBpE,IAAM,oBAAoB,OAAO,IAAI,SAAS,QAAQ,cAAc,CAAC;","names":[]}