@pattern-stack/codegen 0.15.0 → 0.15.2

package/dist/chunk-JWNHNUYL.js

@@ -0,0 +1,96 @@
+import {
+  toBuffer
+} from "./chunk-J6MN42LG.js";
+
+// runtime/subsystems/storage/storage.local-backend.ts
+import {
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, relative, resolve, sep } from "path";
+import { Readable } from "stream";
+var LocalStorageBackend = class {
+  basePath;
+  constructor(basePath = "./storage") {
+    this.basePath = resolve(basePath);
+  }
+  async upload(key, data, contentType) {
+    const filePath = this.resolvePath(key);
+    mkdirSync(dirname(filePath), { recursive: true });
+    const buffer = await toBuffer(data);
+    writeFileSync(filePath, buffer);
+    return key;
+  }
+  async download(key) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    return readFileSync(filePath);
+  }
+  async delete(key) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    unlinkSync(filePath);
+  }
+  async getUrl(key, _expiresInSeconds) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    return `file://${filePath}`;
+  }
+  async exists(key) {
+    try {
+      return existsSync(this.resolvePath(key));
+    } catch {
+      return false;
+    }
+  }
+  async list(prefix) {
+    const keys = this.listRecursive(this.basePath);
+    if (prefix === void 0) return keys;
+    return keys.filter((k) => k.startsWith(prefix));
+  }
+  async downloadStream(key) {
+    const filePath = this.resolvePath(key);
+    if (!existsSync(filePath)) {
+      throw new Error(`Storage: file not found: ${key}`);
+    }
+    const nodeStream = createReadStream(filePath);
+    return Readable.toWeb(nodeStream);
+  }
+  resolvePath(key) {
+    const resolved = resolve(this.basePath, key);
+    if (!resolved.startsWith(this.basePath + sep)) {
+      throw new Error(`Invalid storage key (path traversal attempt): ${key}`);
+    }
+    return resolved;
+  }
+  /** Recursively list all files under dir, returning keys relative to basePath. */
+  listRecursive(dir) {
+    if (!existsSync(dir)) return [];
+    const keys = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        keys.push(...this.listRecursive(full));
+      } else {
+        keys.push(relative(this.basePath, full));
+      }
+    }
+    return keys;
+  }
+};
+
+export {
+  LocalStorageBackend
+};
+//# sourceMappingURL=chunk-JWNHNUYL.js.map

package/dist/chunk-JWNHNUYL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/storage/storage.local-backend.ts"],"sourcesContent":["/**\n * Storage subsystem — local filesystem backend\n *\n * Writes files to `{basePath}/{key}` on the local filesystem.\n * Suitable for development only — use an S3/GCS backend in production.\n *\n * - Creates intermediate directories automatically (mkdirSync recursive)\n * - getUrl returns a `file://` URI pointing to the absolute path\n * - All methods throw on failure\n * - resolvePath validates against path traversal attacks\n */\nimport {\n  createReadStream,\n  existsSync,\n  mkdirSync,\n  readdirSync,\n  readFileSync,\n  statSync,\n  unlinkSync,\n  writeFileSync,\n} from 'fs';\nimport { dirname, join, relative, resolve, sep } from 'path';\nimport { Readable } from 'stream';\nimport type { IStorageService } from './storage.protocol';\nimport { toBuffer } from './storage.utils';\n\nexport class LocalStorageBackend implements IStorageService {\n  private readonly basePath: string;\n\n  constructor(basePath: string = './storage') {\n    this.basePath = resolve(basePath);\n  }\n\n  async upload(key: string, data: Buffer | ReadableStream, contentType?: string): Promise<string> {\n    const filePath = this.resolvePath(key);\n    mkdirSync(dirname(filePath), { recursive: true });\n\n    const buffer = await toBuffer(data);\n    writeFileSync(filePath, buffer);\n    return key;\n  }\n\n  async download(key: string): Promise<Buffer> {\n    const filePath = this.resolvePath(key);\n    if (!existsSync(filePath)) {\n      throw new Error(`Storage: file not found: ${key}`);\n    }\n    return readFileSync(filePath);\n  }\n\n  async delete(key: string): Promise<void> {\n    const filePath = this.resolvePath(key);\n    if (!existsSync(filePath)) {\n      throw new Error(`Storage: file not found: ${key}`);\n    }\n    unlinkSync(filePath);\n  }\n\n  async getUrl(key: string, _expiresInSeconds?: number): Promise<string> {\n    const filePath = this.resolvePath(key);\n    if (!existsSync(filePath)) {\n      throw new Error(`Storage: file not found: ${key}`);\n    }\n    return `file://${filePath}`;\n  }\n\n  async exists(key: string): Promise<boolean> {\n    try {\n      return existsSync(this.resolvePath(key));\n    } catch {\n      // resolvePath throws on traversal attempt — treat as non-existent\n      return false;\n    }\n  }\n\n  async list(prefix?: string): Promise<string[]> {\n    const keys = this.listRecursive(this.basePath);\n    if (prefix === undefined) return keys;\n    return keys.filter((k) => k.startsWith(prefix));\n  }\n\n  async downloadStream(key: string): Promise<ReadableStream> {\n    const filePath = this.resolvePath(key);\n    if (!existsSync(filePath)) {\n      throw new Error(`Storage: file not found: ${key}`);\n    }\n    const nodeStream = createReadStream(filePath);\n    return Readable.toWeb(nodeStream) as ReadableStream;\n  }\n\n  private resolvePath(key: string): string {\n    const resolved = resolve(this.basePath, key);\n    if (!resolved.startsWith(this.basePath + sep)) {\n      throw new Error(`Invalid storage key (path traversal attempt): ${key}`);\n    }\n    return resolved;\n  }\n\n  /** Recursively list all files under dir, returning keys relative to basePath. */\n  private listRecursive(dir: string): string[] {\n    if (!existsSync(dir)) return [];\n    const keys: string[] = [];\n    for (const entry of readdirSync(dir, { withFileTypes: true })) {\n      const full = join(dir, entry.name);\n      if (entry.isDirectory()) {\n        keys.push(...this.listRecursive(full));\n      } else {\n        keys.push(relative(this.basePath, full));\n      }\n    }\n    return keys;\n  }\n}\n"],"mappings":";;;;;AAWA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AACP,SAAS,SAAS,MAAM,UAAU,SAAS,WAAW;AACtD,SAAS,gBAAgB;AAIlB,IAAM,sBAAN,MAAqD;AAAA,EACzC;AAAA,EAEjB,YAAY,WAAmB,aAAa;AAC1C,SAAK,WAAW,QAAQ,QAAQ;AAAA,EAClC;AAAA,EAEA,MAAM,OAAO,KAAa,MAA+B,aAAuC;AAC9F,UAAM,WAAW,KAAK,YAAY,GAAG;AACrC,cAAU,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAEhD,UAAM,SAAS,MAAM,SAAS,IAAI;AAClC,kBAAc,UAAU,MAAM;AAC9B,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,SAAS,KAA8B;AAC3C,UAAM,WAAW,KAAK,YAAY,GAAG;AACrC,QAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,YAAM,IAAI,MAAM,4BAA4B,GAAG,EAAE;AAAA,IACnD;AACA,WAAO,aAAa,QAAQ;AAAA,EAC9B;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,UAAM,WAAW,KAAK,YAAY,GAAG;AACrC,QAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,YAAM,IAAI,MAAM,4BAA4B,GAAG,EAAE;AAAA,IACnD;AACA,eAAW,QAAQ;AAAA,EACrB;AAAA,EAEA,MAAM,OAAO,KAAa,mBAA6C;AACrE,UAAM,WAAW,KAAK,YAAY,GAAG;AACrC,QAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,YAAM,IAAI,MAAM,4BAA4B,GAAG,EAAE;AAAA,IACnD;AACA,WAAO,UAAU,QAAQ;AAAA,EAC3B;AAAA,EAEA,MAAM,OAAO,KAA+B;AAC1C,QAAI;AACF,aAAO,WAAW,KAAK,YAAY,GAAG,CAAC;AAAA,IACzC,QAAQ;AAEN,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EAEA,MAAM,KAAK,QAAoC;AAC7C,UAAM,OAAO,KAAK,cAAc,KAAK,QAAQ;AAC7C,QAAI,WAAW,OAAW,QAAO;AACjC,WAAO,KAAK,OAAO,CAAC,MAAM,EAAE,WAAW,MAAM,CAAC;AAAA,EAChD;AAAA,EAEA,MAAM,eAAe,KAAsC;AACzD,UAAM,WAAW,KAAK,YAAY,GAAG;AACrC,QAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,YAAM,IAAI,MAAM,4BAA4B,GAAG,EAAE;AAAA,IACnD;AACA,UAAM,aAAa,iBAAiB,QAAQ;AAC5C,WAAO,SAAS,MAAM,UAAU;AAAA,EAClC;AAAA,EAEQ,YAAY,KAAqB;AACvC,UAAM,WAAW,QAAQ,KAAK,UAAU,GAAG;AAC3C,QAAI,CAAC,SAAS,WAAW,KAAK,WAAW,GAAG,GAAG;AAC7C,YAAM,IAAI,MAAM,iDAAiD,GAAG,EAAE;AAAA,IACxE;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGQ,cAAc,KAAuB;AAC3C,QAAI,CAAC,WAAW,GAAG,EAAG,QAAO,CAAC;AAC9B,UAAM,OAAiB,CAAC;AACxB,eAAW,SAAS,YAAY,KAAK,EAAE,eAAe,KAAK,CAAC,GAAG;AAC7D,YAAM,OAAO,KAAK,KAAK,MAAM,IAAI;AACjC,UAAI,MAAM,YAAY,GAAG;AACvB,aAAK,KAAK,GAAG,KAAK,cAAc,IAAI,CAAC;AAAA,MACvC,OAAO;AACL,aAAK,KAAK,SAAS,KAAK,UAAU,IAAI,CAAC;AAAA,MACzC;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-K2I6XIK5.js

@@ -0,0 +1,122 @@
+import {
+  assertTenantId
+} from "./chunk-6DWFJNIK.js";
+import {
+  bridgeDelivery
+} from "./chunk-2TVVBC53.js";
+import {
+  BRIDGE_MULTI_TENANT
+} from "./chunk-4LH67P4U.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/bridge/bridge-delivery.drizzle-backend.ts
+import { Inject, Injectable, Optional } from "@nestjs/common";
+import { eq, and, gte, isNull, sql } from "drizzle-orm";
+var DrizzleBridgeDeliveryRepo = class {
+  constructor(db, multiTenant = false) {
+    this.db = db;
+    this.multiTenant = multiTenant;
+  }
+  db;
+  multiTenant;
+  async insertDelivery(row, tx) {
+    assertTenantId(
+      "DrizzleBridgeDeliveryRepo.insertDelivery",
+      this.multiTenant,
+      row.tenantId
+    );
+    const client = tx ?? this.db;
+    await client.insert(bridgeDelivery).values(row).onConflictDoNothing({
+      target: [bridgeDelivery.eventId, bridgeDelivery.triggerId]
+    });
+  }
+  async findDelivery(eventId, triggerId) {
+    const rows = await this.db.select().from(bridgeDelivery).where(
+      and(
+        eq(bridgeDelivery.eventId, eventId),
+        eq(bridgeDelivery.triggerId, triggerId)
+      )
+    ).limit(1);
+    return rows[0] ?? null;
+  }
+  async findDeliveryById(id) {
+    const rows = await this.db.select().from(bridgeDelivery).where(eq(bridgeDelivery.id, id)).limit(1);
+    return rows[0] ?? null;
+  }
+  async markDelivered(id, userRunId, tx) {
+    const client = tx ?? this.db;
+    await client.update(bridgeDelivery).set({
+      status: "delivered",
+      userRunId,
+      deliveredAt: /* @__PURE__ */ new Date()
+    }).where(eq(bridgeDelivery.id, id));
+  }
+  async markSkipped(id, reason, tx) {
+    const client = tx ?? this.db;
+    await client.update(bridgeDelivery).set({ status: "skipped", skipReason: reason }).where(eq(bridgeDelivery.id, id));
+  }
+  async markFailed(id, error, tx) {
+    const client = tx ?? this.db;
+    await client.update(bridgeDelivery).set({ status: "failed", error }).where(eq(bridgeDelivery.id, id));
+  }
+  /**
+   * Observability read — see `IJobBridge.getStatusHistogram` JSDoc for the
+   * tenant-filter and windowHours contract.
+   *
+   * Tenant-filter note: this method intentionally does NOT call
+   * `assertTenantId`. The write methods on this repo (`insertDelivery`)
+   * treat `tenantId === undefined` as a misconfiguration and fail fast.
+   * Reads are different — `undefined` is the supported "cross-tenant
+   * admin view" mode that OBS-5 uses to render a framework-wide health
+   * panel. Callers that need strict tenant scoping pass an explicit
+   * string or `null`.
+   *
+   * Cast note: `count(*)::int` is applied in SQL so the node-pg driver
+   * returns a `number` instead of the default `bigint → string` for
+   * `count(*)`. Don't relax this cast — consumers (and the protocol)
+   * type the result as `number`.
+   */
+  async getStatusHistogram(windowHours, tenantId) {
+    if (!Number.isFinite(windowHours) || windowHours <= 0) {
+      throw new RangeError("windowHours must be positive");
+    }
+    const cutoff = sql`now() - make_interval(hours => ${windowHours})`;
+    const conditions = [gte(bridgeDelivery.attemptedAt, cutoff)];
+    if (tenantId === null) {
+      conditions.push(isNull(bridgeDelivery.tenantId));
+    } else if (typeof tenantId === "string") {
+      conditions.push(eq(bridgeDelivery.tenantId, tenantId));
+    }
+    const rows = await this.db.select({
+      status: bridgeDelivery.status,
+      count: sql`count(*)::int`
+    }).from(bridgeDelivery).where(and(...conditions)).groupBy(bridgeDelivery.status);
+    const histogram = {
+      pending: 0,
+      delivered: 0,
+      skipped: 0,
+      failed: 0
+    };
+    for (const row of rows) {
+      histogram[row.status] = Number(row.count);
+    }
+    return histogram;
+  }
+};
+DrizzleBridgeDeliveryRepo = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE)),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject(BRIDGE_MULTI_TENANT))
+], DrizzleBridgeDeliveryRepo);
+
+export {
+  DrizzleBridgeDeliveryRepo
+};
+//# sourceMappingURL=chunk-K2I6XIK5.js.map

package/dist/chunk-K2I6XIK5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/bridge/bridge-delivery.drizzle-backend.ts"],"sourcesContent":["/**\n * DrizzleBridgeDeliveryRepo — Postgres implementation of `IJobBridge`\n * (BRIDGE-4, ADR-023 Phase 2).\n *\n * Behavioral twin of `MemoryBridgeDeliveryRepo` (BRIDGE-3). The key\n * difference is `insertDelivery`: where the memory backend throws\n * `UniqueConstraintError` on a duplicate `(event_id, trigger_id)`, the\n * Drizzle backend uses `INSERT … ON CONFLICT (event_id, trigger_id) DO\n * NOTHING` and surfaces the dedup as a silent no-op. This matches the\n * BRIDGE-4 spec recommendation — a thrown error inside the per-event tx\n * would abort sibling triggers, which is exactly the failure mode the\n * facade's Case B pre-write was designed to prevent.\n *\n * Tests that need to assert \"the constraint fired\" use `findDelivery` to\n * confirm the existing row is the facade-eager pre-write (or the prior\n * drain attempt's row), not the one this call tried to insert. The\n * `UniqueConstraintError` branch from BRIDGE-3 is the memory-backend\n * fidelity path; the Drizzle backend models the same idempotency through\n * SQL semantics rather than a thrown error.\n *\n * The other four methods (`findDelivery`, `findDeliveryById`,\n * `mark{Delivered,Skipped,Failed}`) are straightforward\n * `SELECT … LIMIT 1` / `UPDATE … WHERE id = ?` queries.\n */\nimport { Inject, Injectable, Optional } from '@nestjs/common';\nimport { eq, and, gte, isNull, sql } from 'drizzle-orm';\n\nimport { DRIZZLE } from '../../constants/tokens';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport type { DrizzleTransaction } from '../events/event-bus.protocol';\n\nimport { bridgeDelivery } from './bridge-delivery.schema';\nimport type { BridgeDeliveryRecord } from './bridge-delivery.schema';\nimport type {\n  BridgeDeliveryInsert,\n  IJobBridge,\n  StatusHistogram,\n} from './bridge.protocol';\nimport { assertTenantId } from './assert-tenant-id';\nimport { BRIDGE_MULTI_TENANT } from './bridge.tokens';\n\n@Injectable()\nexport class DrizzleBridgeDeliveryRepo implements IJobBridge {\n  constructor(\n    @Inject(DRIZZLE) private readonly db: DrizzleClient,\n    /**\n     * Site (c) of the three ADR-023 §Multi-tenancy enforcement sites.\n     * `@Optional()` so unit tests / non-bridge mounts that don't provide\n     * the token still construct the repo cleanly; defaults to `false`,\n     * which makes `assertTenantId` a no-op.\n     */\n    @Optional()\n    @Inject(BRIDGE_MULTI_TENANT)\n    private readonly multiTenant: boolean = false,\n  ) {}\n\n  async insertDelivery(\n    row: BridgeDeliveryInsert,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    // Multi-tenancy gate — last-line defense. Even if callers skipped\n    // sites (a) `EventFlowService.publishAndStart` and (b)\n    // `BridgeDeliveryHandler.run`, a direct repo call still fails fast\n    // BEFORE any SQL is issued.\n    assertTenantId(\n      'DrizzleBridgeDeliveryRepo.insertDelivery',\n      this.multiTenant,\n      row.tenantId,\n    );\n    const client = (tx ?? this.db) as DrizzleClient;\n    // ON CONFLICT DO NOTHING — surfaces dedup as silent no-op so the\n    // per-event tx stays atomic across sibling triggers. RETURNING is\n    // omitted here: the public IJobBridge contract is `Promise<void>`,\n    // and the drain hook (BRIDGE-4) uses its own\n    // `tx.insert(...).onConflictDoNothing().returning({id})` pattern\n    // when it needs the rowcount discriminator. See class-level JSDoc.\n    await client\n      .insert(bridgeDelivery)\n      .values(row)\n      .onConflictDoNothing({\n        target: [bridgeDelivery.eventId, bridgeDelivery.triggerId],\n      });\n  }\n\n  async findDelivery(\n    eventId: string,\n    triggerId: string,\n  ): Promise<BridgeDeliveryRecord | null> {\n    const rows = await this.db\n      .select()\n      .from(bridgeDelivery)\n      .where(\n        and(\n          eq(bridgeDelivery.eventId, eventId),\n          eq(bridgeDelivery.triggerId, triggerId),\n        ),\n      )\n      .limit(1);\n    return (rows[0] as BridgeDeliveryRecord | undefined) ?? null;\n  }\n\n  async findDeliveryById(id: string): Promise<BridgeDeliveryRecord | null> {\n    const rows = await this.db\n      .select()\n      .from(bridgeDelivery)\n      .where(eq(bridgeDelivery.id, id))\n      .limit(1);\n    return (rows[0] as BridgeDeliveryRecord | undefined) ?? null;\n  }\n\n  async markDelivered(\n    id: string,\n    userRunId: string,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client\n      .update(bridgeDelivery)\n      .set({\n        status: 'delivered',\n        userRunId,\n        deliveredAt: new Date(),\n      })\n      .where(eq(bridgeDelivery.id, id));\n  }\n\n  async markSkipped(\n    id: string,\n    reason: string,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client\n      .update(bridgeDelivery)\n      .set({ status: 'skipped', skipReason: reason })\n      .where(eq(bridgeDelivery.id, id));\n  }\n\n  async markFailed(\n    id: string,\n    error: Record<string, unknown>,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client\n      .update(bridgeDelivery)\n      .set({ status: 'failed', error })\n      .where(eq(bridgeDelivery.id, id));\n  }\n\n  /**\n   * Observability read — see `IJobBridge.getStatusHistogram` JSDoc for the\n   * tenant-filter and windowHours contract.\n   *\n   * Tenant-filter note: this method intentionally does NOT call\n   * `assertTenantId`. The write methods on this repo (`insertDelivery`)\n   * treat `tenantId === undefined` as a misconfiguration and fail fast.\n   * Reads are different — `undefined` is the supported \"cross-tenant\n   * admin view\" mode that OBS-5 uses to render a framework-wide health\n   * panel. Callers that need strict tenant scoping pass an explicit\n   * string or `null`.\n   *\n   * Cast note: `count(*)::int` is applied in SQL so the node-pg driver\n   * returns a `number` instead of the default `bigint → string` for\n   * `count(*)`. Don't relax this cast — consumers (and the protocol)\n   * type the result as `number`.\n   */\n  async getStatusHistogram(\n    windowHours: number,\n    tenantId?: string | null,\n  ): Promise<StatusHistogram> {\n    if (!Number.isFinite(windowHours) || windowHours <= 0) {\n      throw new RangeError('windowHours must be positive');\n    }\n\n    const cutoff = sql<Date>`now() - make_interval(hours => ${windowHours})`;\n\n    const conditions = [gte(bridgeDelivery.attemptedAt, cutoff)];\n    if (tenantId === null) {\n      conditions.push(isNull(bridgeDelivery.tenantId));\n    } else if (typeof tenantId === 'string') {\n      conditions.push(eq(bridgeDelivery.tenantId, tenantId));\n    }\n    // tenantId === undefined → no tenant filter (cross-tenant view).\n\n    const rows = await this.db\n      .select({\n        status: bridgeDelivery.status,\n        count: sql<number>`count(*)::int`,\n      })\n      .from(bridgeDelivery)\n      .where(and(...conditions))\n      .groupBy(bridgeDelivery.status);\n\n    const histogram: StatusHistogram = {\n      pending: 0,\n      delivered: 0,\n      skipped: 0,\n      failed: 0,\n    };\n    for (const row of rows) {\n      // row.status is typed as the enum union; narrow is safe because the\n      // enum values match StatusHistogram keys 1:1 (BRIDGE-1 schema).\n      histogram[row.status as keyof StatusHistogram] = Number(row.count);\n    }\n    return histogram;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-KMZCQASO.js

@@ -0,0 +1,111 @@
+import {
+  DrizzleJobRunService
+} from "./chunk-I6MG4M3F.js";
+import {
+  MemoryJobRunService
+} from "./chunk-JRVNVKN6.js";
+import {
+  DrizzleJobStepService
+} from "./chunk-DV4RV2DC.js";
+import {
+  DrizzleJobOrchestrator
+} from "./chunk-5Y7W3XR6.js";
+import {
+  MemoryJobOrchestrator
+} from "./chunk-4RFHUZXU.js";
+import {
+  MemoryJobStepService
+} from "./chunk-PNZSGAB2.js";
+import {
+  MemoryJobStore
+} from "./chunk-SNQ3TOWP.js";
+import {
+  BULLMQ_CONNECTION,
+  BULLMQ_RESOLVED_CONFIG,
+  resolveBullMqConfig
+} from "./chunk-I6MVCB5A.js";
+import {
+  JOBS_MULTI_TENANT,
+  JOB_ORCHESTRATOR,
+  JOB_RUN_SERVICE,
+  JOB_STEP_SERVICE
+} from "./chunk-BIO6F7YI.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/jobs/jobs-domain.module.ts
+import { Module } from "@nestjs/common";
+var JobsDomainModule = class {
+  static forRoot(opts) {
+    const multiTenant = opts.multiTenant ?? false;
+    const providers = [
+      // JOB-8 — boolean provider consumed by the four service-layer backends.
+      // Always provided (even when `multiTenant === false`) so `@Inject`
+      // always resolves; backends short-circuit the enforcement path when
+      // the value is `false`. See `jobs-domain.tokens.ts` for the claim-loop
+      // cross-tenant-by-design decision.
+      { provide: JOBS_MULTI_TENANT, useValue: multiTenant }
+    ];
+    if (opts.backend === "memory") {
+      const store = new MemoryJobStore();
+      providers.push({ provide: MemoryJobStore, useValue: store });
+      providers.push(MemoryJobStepService);
+      providers.push({ provide: JOB_STEP_SERVICE, useExisting: MemoryJobStepService });
+      providers.push(MemoryJobOrchestrator);
+      providers.push({ provide: JOB_ORCHESTRATOR, useExisting: MemoryJobOrchestrator });
+      providers.push(MemoryJobRunService);
+      providers.push({ provide: JOB_RUN_SERVICE, useExisting: MemoryJobRunService });
+    } else if (opts.backend === "bullmq") {
+      const resolved = resolveBullMqConfig(opts.extensions?.bullmq);
+      providers.push({ provide: BULLMQ_CONNECTION, useValue: resolved.connection });
+      providers.push({ provide: BULLMQ_RESOLVED_CONFIG, useValue: resolved });
+      providers.push({
+        provide: JOB_ORCHESTRATOR,
+        useFactory: async (...args) => {
+          const specifier = "./job-orchestrator.bullmq-backend";
+          const mod = await import(specifier);
+          return new mod.BullMQJobOrchestrator(...args);
+        },
+        // The bullmq orchestrator constructor mirrors DrizzleJobOrchestrator's
+        // injection list: DRIZZLE + JOBS_MULTI_TENANT + the resolved BullMQ
+        // tokens. Importing token references would force a static dep on the
+        // tokens file in this module's import graph; using the existing
+        // symbols already in scope is sufficient.
+        inject: [DRIZZLE, JOBS_MULTI_TENANT, BULLMQ_CONNECTION, BULLMQ_RESOLVED_CONFIG]
+      });
+      providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });
+      providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });
+    } else {
+      providers.push({ provide: JOB_ORCHESTRATOR, useClass: DrizzleJobOrchestrator });
+      providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });
+      providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });
+    }
+    const exports = [
+      JOB_ORCHESTRATOR,
+      JOB_RUN_SERVICE,
+      JOB_STEP_SERVICE,
+      JOBS_MULTI_TENANT
+    ];
+    if (opts.backend === "bullmq") {
+      exports.push(BULLMQ_CONNECTION, BULLMQ_RESOLVED_CONFIG);
+    }
+    return {
+      module: JobsDomainModule,
+      global: true,
+      providers,
+      exports
+    };
+  }
+};
+JobsDomainModule = __decorateClass([
+  Module({})
+], JobsDomainModule);
+
+export {
+  JobsDomainModule
+};
+//# sourceMappingURL=chunk-KMZCQASO.js.map

package/dist/chunk-KMZCQASO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/jobs-domain.module.ts"],"sourcesContent":["/**\n * JobsDomainModule — `DynamicModule.forRoot({ backend })` factory wiring\n * the three jobs-domain protocol tokens to a backend implementation\n * (ADR-022, JOB-5).\n *\n * Mirrors `EventsModule.forRoot()` exactly:\n *   - `global: true` so consumer entity modules don't have to import this\n *     individually — `JOB_ORCHESTRATOR` / `JOB_RUN_SERVICE` /\n *     `JOB_STEP_SERVICE` are available project-wide.\n *   - One backend at a time (Drizzle for production, Memory for tests).\n *\n * Backend swappability follows the core/extension protocol from CLAUDE.md:\n * the three tokens are the **core contract**; backend-specific tunables\n * live under `extensions.<backend>` so opting into a feature is explicit\n * and the type system reserves the slot.\n */\nimport { Module, type DynamicModule, type Provider } from '@nestjs/common';\nimport { DRIZZLE } from '../../constants/tokens';\nimport {\n  JOB_ORCHESTRATOR,\n  JOB_RUN_SERVICE,\n  JOB_STEP_SERVICE,\n  JOBS_MULTI_TENANT,\n} from './jobs-domain.tokens';\nimport { DrizzleJobOrchestrator } from './job-orchestrator.drizzle-backend';\nimport { DrizzleJobRunService } from './job-run-service.drizzle-backend';\nimport { DrizzleJobStepService } from './job-step-service.drizzle-backend';\n// #6 — `BullMQJobOrchestrator` is lazy-loaded only when `backend: 'bullmq'`\n// is selected. The backend file is filtered out of drizzle/memory installs\n// (see `backendFileFilter`); a non-literal dynamic import below sidesteps\n// consumer-side tsc resolution of an absent file.\nimport { MemoryJobOrchestrator } from './job-orchestrator.memory-backend';\nimport { MemoryJobRunService } from './job-run-service.memory-backend';\nimport { MemoryJobStepService } from './job-step-service.memory-backend';\nimport { MemoryJobStore } from './memory-job-store';\nimport {\n  BULLMQ_CONNECTION,\n  BULLMQ_RESOLVED_CONFIG,\n  resolveBullMqConfig,\n  type BullMqExtensionsConfig,\n} from './bullmq.config';\n\n/**\n * Drizzle backend extensions surface. None are wired into the Drizzle\n * orchestrator yet — this is the **typed reservation** for the LISTEN/NOTIFY\n * + tunable poll-interval extensions called out in ADR-022. App code\n * passing these today is parsed but not yet dispatched; when the\n * Drizzle orchestrator grows the consumer hooks, opt-in code paths will\n * read directly from these fields.\n */\nexport interface DrizzleBackendExtensions {\n  /** Use Postgres LISTEN/NOTIFY to wake the polling loop. Default false. */\n  listenNotify?: boolean;\n  /** Polling interval when LISTEN/NOTIFY is off (ms). Default 1000. */\n  pollIntervalMs?: number;\n}\n\nexport interface JobsDomainModuleOptions {\n  backend: 'drizzle' | 'memory' | 'bullmq';\n  /**\n   * Backend-specific extensions. Only the matching backend's extensions\n   * are read at boot; non-matching keys are ignored. This is the\n   * core/extension protocol surface — see CLAUDE.md.\n   */\n  extensions?: {\n    drizzle?: DrizzleBackendExtensions;\n    /**\n     * BullMQ backend extensions (BULLMQ-1). Snake_case mirrors the YAML\n     * under `jobs.extensions.bullmq`. `redis_url` falls back to\n     * `process.env.REDIS_URL` then `redis://localhost:6379`.\n     */\n    bullmq?: BullMqExtensionsConfig;\n  };\n  /** Multi-tenancy opt-in. Wired by JOB-8; module signature stays stable. */\n  multiTenant?: boolean;\n}\n\n@Module({})\nexport class JobsDomainModule {\n  static forRoot(opts: JobsDomainModuleOptions): DynamicModule {\n    const multiTenant = opts.multiTenant ?? false;\n\n    const providers: Provider[] = [\n      // JOB-8 — boolean provider consumed by the four service-layer backends.\n      // Always provided (even when `multiTenant === false`) so `@Inject`\n      // always resolves; backends short-circuit the enforcement path when\n      // the value is `false`. See `jobs-domain.tokens.ts` for the claim-loop\n      // cross-tenant-by-design decision.\n      { provide: JOBS_MULTI_TENANT, useValue: multiTenant },\n    ];\n\n    if (opts.backend === 'memory') {\n      // The store is a plain class — wired as a singleton `useValue` so\n      // unit tests can pull it out via `.get(MemoryJobStore)` for direct\n      // assertions (matches the access pattern in JOB-4 specs).\n      const store = new MemoryJobStore();\n      providers.push({ provide: MemoryJobStore, useValue: store });\n      providers.push(MemoryJobStepService);\n      providers.push({ provide: JOB_STEP_SERVICE, useExisting: MemoryJobStepService });\n      providers.push(MemoryJobOrchestrator);\n      providers.push({ provide: JOB_ORCHESTRATOR, useExisting: MemoryJobOrchestrator });\n      providers.push(MemoryJobRunService);\n      providers.push({ provide: JOB_RUN_SERVICE, useExisting: MemoryJobRunService });\n    } else if (opts.backend === 'bullmq') {\n      // BULLMQ-1 — BullMQ orchestrator over a Postgres source of truth. The\n      // run/step services stay Drizzle (domain reads + `listForScope` are\n      // Postgres queries, unchanged per spec). Only the orchestrator's\n      // claim/dispatch half swaps to BullMQ.\n      //\n      // #6 — the bullmq backend module is filtered out of drizzle/memory\n      // installs (no `bullmq` peer dep, no consumer-side tsc compile of an\n      // unused file). The factory below dynamic-imports it via a non-literal\n      // specifier so TS treats the module type as `any` and never tries to\n      // resolve the absent file on a drizzle/memory consumer.\n      const resolved = resolveBullMqConfig(opts.extensions?.bullmq);\n      providers.push({ provide: BULLMQ_CONNECTION, useValue: resolved.connection });\n      providers.push({ provide: BULLMQ_RESOLVED_CONFIG, useValue: resolved });\n      providers.push({\n        provide: JOB_ORCHESTRATOR,\n        useFactory: async (...args: unknown[]): Promise<object> => {\n          const specifier = './job-orchestrator.bullmq-backend';\n          const mod = (await import(specifier)) as {\n            BullMQJobOrchestrator: new (...args: unknown[]) => object;\n          };\n          return new mod.BullMQJobOrchestrator(...args);\n        },\n        // The bullmq orchestrator constructor mirrors DrizzleJobOrchestrator's\n        // injection list: DRIZZLE + JOBS_MULTI_TENANT + the resolved BullMQ\n        // tokens. Importing token references would force a static dep on the\n        // tokens file in this module's import graph; using the existing\n        // symbols already in scope is sufficient.\n        inject: [DRIZZLE, JOBS_MULTI_TENANT, BULLMQ_CONNECTION, BULLMQ_RESOLVED_CONFIG],\n      });\n      providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });\n      providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });\n    } else {\n      providers.push({ provide: JOB_ORCHESTRATOR, useClass: DrizzleJobOrchestrator });\n      providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });\n      providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });\n    }\n\n    const exports = [\n      JOB_ORCHESTRATOR,\n      JOB_RUN_SERVICE,\n      JOB_STEP_SERVICE,\n      JOBS_MULTI_TENANT,\n    ];\n    // BULLMQ-1 — only export the BullMQ tokens when they were actually\n    // provided. Nest throws \"exported but not provided\" otherwise. Exported so\n    // JobWorkerModule (which imports this module) can read the resolved\n    // connection/config to spawn BullMQ workers.\n    if (opts.backend === 'bullmq') {\n      exports.push(BULLMQ_CONNECTION, BULLMQ_RESOLVED_CONFIG);\n    }\n\n    return {\n      module: JobsDomainModule,\n      global: true,\n      providers,\n      exports,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,SAAS,cAAiD;AA8DnD,IAAM,mBAAN,MAAuB;AAAA,EAC5B,OAAO,QAAQ,MAA8C;AAC3D,UAAM,cAAc,KAAK,eAAe;AAExC,UAAM,YAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAM5B,EAAE,SAAS,mBAAmB,UAAU,YAAY;AAAA,IACtD;AAEA,QAAI,KAAK,YAAY,UAAU;AAI7B,YAAM,QAAQ,IAAI,eAAe;AACjC,gBAAU,KAAK,EAAE,SAAS,gBAAgB,UAAU,MAAM,CAAC;AAC3D,gBAAU,KAAK,oBAAoB;AACnC,gBAAU,KAAK,EAAE,SAAS,kBAAkB,aAAa,qBAAqB,CAAC;AAC/E,gBAAU,KAAK,qBAAqB;AACpC,gBAAU,KAAK,EAAE,SAAS,kBAAkB,aAAa,sBAAsB,CAAC;AAChF,gBAAU,KAAK,mBAAmB;AAClC,gBAAU,KAAK,EAAE,SAAS,iBAAiB,aAAa,oBAAoB,CAAC;AAAA,IAC/E,WAAW,KAAK,YAAY,UAAU;AAWpC,YAAM,WAAW,oBAAoB,KAAK,YAAY,MAAM;AAC5D,gBAAU,KAAK,EAAE,SAAS,mBAAmB,UAAU,SAAS,WAAW,CAAC;AAC5E,gBAAU,KAAK,EAAE,SAAS,wBAAwB,UAAU,SAAS,CAAC;AACtE,gBAAU,KAAK;AAAA,QACb,SAAS;AAAA,QACT,YAAY,UAAU,SAAqC;AACzD,gBAAM,YAAY;AAClB,gBAAM,MAAO,MAAM,OAAO;AAG1B,iBAAO,IAAI,IAAI,sBAAsB,GAAG,IAAI;AAAA,QAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAMA,QAAQ,CAAC,SAAS,mBAAmB,mBAAmB,sBAAsB;AAAA,MAChF,CAAC;AACD,gBAAU,KAAK,EAAE,SAAS,iBAAiB,UAAU,qBAAqB,CAAC;AAC3E,gBAAU,KAAK,EAAE,SAAS,kBAAkB,UAAU,sBAAsB,CAAC;AAAA,IAC/E,OAAO;AACL,gBAAU,KAAK,EAAE,SAAS,kBAAkB,UAAU,uBAAuB,CAAC;AAC9E,gBAAU,KAAK,EAAE,SAAS,iBAAiB,UAAU,qBAAqB,CAAC;AAC3E,gBAAU,KAAK,EAAE,SAAS,kBAAkB,UAAU,sBAAsB,CAAC;AAAA,IAC/E;AAEA,UAAM,UAAU;AAAA,MACd;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAKA,QAAI,KAAK,YAAY,UAAU;AAC7B,cAAQ,KAAK,mBAAmB,sBAAsB;AAAA,IACxD;AAEA,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AApFa,mBAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,GACG;","names":[]}

package/dist/chunk-KVOWSC5S.js

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

package/dist/chunk-KVOWSC5S.js.map

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

package/dist/chunk-KYR3B3OW.js

@@ -0,0 +1,79 @@
+// runtime/base-classes/lifecycle-events.ts
+import { randomUUID } from "crypto";
+var SYSTEM_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "createdAt",
+  "updatedAt",
+  "deletedAt"
+]);
+function entitySnapshot(entity) {
+  const snap = {};
+  for (const [key, value] of Object.entries(entity)) {
+    if (!SYSTEM_FIELDS.has(key)) {
+      snap[key] = value;
+    }
+  }
+  return snap;
+}
+function diffSnapshots(before, after) {
+  const changes = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of allKeys) {
+    if (SYSTEM_FIELDS.has(key)) continue;
+    const oldVal = before[key];
+    const newVal = after[key];
+    if (oldVal !== newVal && JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+      changes.push({ field: key, oldValue: oldVal, newValue: newVal });
+    }
+  }
+  return changes;
+}
+function buildLifecycleEvent(entityName, action, entityId, snapshot) {
+  return {
+    id: randomUUID(),
+    type: `${entityName}.${action}`,
+    aggregateId: entityId,
+    aggregateType: entityName,
+    payload: snapshot ? { snapshot } : {},
+    occurredAt: /* @__PURE__ */ new Date(),
+    metadata: { category: "lifecycle" }
+  };
+}
+function buildChangeEvents(entityName, entityId, changes) {
+  return changes.map((c) => ({
+    id: randomUUID(),
+    type: `${entityName}.field_changed`,
+    aggregateId: entityId,
+    aggregateType: entityName,
+    payload: {
+      fieldName: c.field,
+      oldValue: c.oldValue,
+      newValue: c.newValue
+    },
+    occurredAt: /* @__PURE__ */ new Date(),
+    metadata: { category: "change" }
+  }));
+}
+async function emitSafely(eventBus, events) {
+  if (!eventBus || events.length === 0) return;
+  try {
+    if (events.length === 1) {
+      const only = events[0];
+      if (!only) return;
+      await eventBus.publish(only);
+    } else {
+      await eventBus.publishMany(events);
+    }
+  } catch {
+    console.warn(`[lifecycle-events] failed to emit ${events.length} event(s)`);
+  }
+}
+
+export {
+  entitySnapshot,
+  diffSnapshots,
+  buildLifecycleEvent,
+  buildChangeEvents,
+  emitSafely
+};
+//# sourceMappingURL=chunk-KYR3B3OW.js.map

package/dist/chunk-KYR3B3OW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/lifecycle-events.ts"],"sourcesContent":["/**\n * Lifecycle event emission for BaseService.\n *\n * Ported from pattern-stack/atoms/patterns/services/base.py — the Python\n * BaseService emits LIFECYCLE and CHANGE events on every CRUD operation.\n * This module provides the same capability for the TypeScript codegen stack.\n *\n * Design:\n *   - Fire-and-forget: event emission never fails the CRUD operation.\n *   - IEventBus is optional: if no EVENT_BUS is injected, emission is silently\n *     skipped. This means base classes work in projects that haven't installed\n *     the events subsystem.\n *   - LIFECYCLE events carry an entity snapshot in payload.\n *   - CHANGE events carry per-field old/new diffs.\n *   - Controlled per-entity via `emitLifecycleEvents` flag (default: true).\n *\n * @deprecated EVT-7 — Lifecycle events are untyped and emit outside of the\n *   CRUD transaction. New work should declare an `emits:` block on the entity\n *   and publish typed domain events from use-cases via TYPED_EVENT_BUS inside\n *   the same Drizzle transaction. See `docs/specs/EVT-7.md`. This helper is\n *   retained for BaseService backward compatibility until all entities have\n *   migrated to typed emits.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { IEventBus, DomainEvent } from '../subsystems/events/event-bus.protocol';\n\n// ============================================================================\n// Event categories (subset of pattern-stack's EventCategory)\n// ============================================================================\n\nexport type EventCategory = 'lifecycle' | 'change';\n\n// ============================================================================\n// Helpers\n// ============================================================================\n\n/** System fields excluded from entity snapshots and change diffs. */\nconst SYSTEM_FIELDS = new Set([\n\t'id',\n\t'createdAt',\n\t'updatedAt',\n\t'deletedAt',\n]);\n\n/**\n * Snapshot an entity's field values, excluding system fields.\n * Mirrors pattern-stack's `_get_entity_snapshot()`.\n */\nexport function entitySnapshot(entity: Record<string, unknown>): Record<string, unknown> {\n\tconst snap: Record<string, unknown> = {};\n\tfor (const [key, value] of Object.entries(entity)) {\n\t\tif (!SYSTEM_FIELDS.has(key)) {\n\t\t\tsnap[key] = value;\n\t\t}\n\t}\n\treturn snap;\n}\n\n/**\n * Diff two entity snapshots, returning per-field old/new pairs.\n * Only includes fields that actually changed.\n */\nexport function diffSnapshots(\n\tbefore: Record<string, unknown>,\n\tafter: Record<string, unknown>,\n): Array<{ field: string; oldValue: unknown; newValue: unknown }> {\n\tconst changes: Array<{ field: string; oldValue: unknown; newValue: unknown }> = [];\n\tconst allKeys = new Set([...Object.keys(before), ...Object.keys(after)]);\n\n\tfor (const key of allKeys) {\n\t\tif (SYSTEM_FIELDS.has(key)) continue;\n\t\tconst oldVal = before[key];\n\t\tconst newVal = after[key];\n\t\t// Simple equality — good enough for primitives and nulls.\n\t\t// For deep objects, JSON.stringify comparison.\n\t\tif (oldVal !== newVal && JSON.stringify(oldVal) !== JSON.stringify(newVal)) {\n\t\t\tchanges.push({ field: key, oldValue: oldVal, newValue: newVal });\n\t\t}\n\t}\n\n\treturn changes;\n}\n\n// ============================================================================\n// Event builders\n// ============================================================================\n\nexport function buildLifecycleEvent(\n\tentityName: string,\n\taction: 'created' | 'updated' | 'deleted',\n\tentityId: string,\n\tsnapshot?: Record<string, unknown>,\n): DomainEvent {\n\treturn {\n\t\tid: randomUUID(),\n\t\ttype: `${entityName}.${action}`,\n\t\taggregateId: entityId,\n\t\taggregateType: entityName,\n\t\tpayload: snapshot ? { snapshot } : {},\n\t\toccurredAt: new Date(),\n\t\tmetadata: { category: 'lifecycle' as EventCategory },\n\t};\n}\n\nexport function buildChangeEvents(\n\tentityName: string,\n\tentityId: string,\n\tchanges: Array<{ field: string; oldValue: unknown; newValue: unknown }>,\n): DomainEvent[] {\n\treturn changes.map((c) => ({\n\t\tid: randomUUID(),\n\t\ttype: `${entityName}.field_changed`,\n\t\taggregateId: entityId,\n\t\taggregateType: entityName,\n\t\tpayload: {\n\t\t\tfieldName: c.field,\n\t\t\toldValue: c.oldValue,\n\t\t\tnewValue: c.newValue,\n\t\t},\n\t\toccurredAt: new Date(),\n\t\tmetadata: { category: 'change' as EventCategory },\n\t}));\n}\n\n// ============================================================================\n// Emission helper (fire-and-forget)\n// ============================================================================\n\n/**\n * Emit events to the bus, swallowing errors.\n * Mirrors pattern-stack's `_emit_lifecycle_event()` try/except.\n */\nexport async function emitSafely(\n\teventBus: IEventBus | undefined,\n\tevents: DomainEvent[],\n): Promise<void> {\n\tif (!eventBus || events.length === 0) return;\n\ttry {\n\t\tif (events.length === 1) {\n\t\t\tconst only = events[0];\n\t\t\tif (!only) return;\n\t\t\tawait eventBus.publish(only);\n\t\t} else {\n\t\t\tawait eventBus.publishMany(events);\n\t\t}\n\t} catch {\n\t\t// Log but never fail the CRUD operation.\n\t\t// In production, this would use a structured logger.\n\t\tconsole.warn(`[lifecycle-events] failed to emit ${events.length} event(s)`);\n\t}\n}\n"],"mappings":";AAwBA,SAAS,kBAAkB;AAc3B,IAAM,gBAAgB,oBAAI,IAAI;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD,CAAC;AAMM,SAAS,eAAe,QAA0D;AACxF,QAAM,OAAgC,CAAC;AACvC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AAClD,QAAI,CAAC,cAAc,IAAI,GAAG,GAAG;AAC5B,WAAK,GAAG,IAAI;AAAA,IACb;AAAA,EACD;AACA,SAAO;AACR;AAMO,SAAS,cACf,QACA,OACiE;AACjE,QAAM,UAA0E,CAAC;AACjF,QAAM,UAAU,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,MAAM,GAAG,GAAG,OAAO,KAAK,KAAK,CAAC,CAAC;AAEvE,aAAW,OAAO,SAAS;AAC1B,QAAI,cAAc,IAAI,GAAG,EAAG;AAC5B,UAAM,SAAS,OAAO,GAAG;AACzB,UAAM,SAAS,MAAM,GAAG;AAGxB,QAAI,WAAW,UAAU,KAAK,UAAU,MAAM,MAAM,KAAK,UAAU,MAAM,GAAG;AAC3E,cAAQ,KAAK,EAAE,OAAO,KAAK,UAAU,QAAQ,UAAU,OAAO,CAAC;AAAA,IAChE;AAAA,EACD;AAEA,SAAO;AACR;AAMO,SAAS,oBACf,YACA,QACA,UACA,UACc;AACd,SAAO;AAAA,IACN,IAAI,WAAW;AAAA,IACf,MAAM,GAAG,UAAU,IAAI,MAAM;AAAA,IAC7B,aAAa;AAAA,IACb,eAAe;AAAA,IACf,SAAS,WAAW,EAAE,SAAS,IAAI,CAAC;AAAA,IACpC,YAAY,oBAAI,KAAK;AAAA,IACrB,UAAU,EAAE,UAAU,YAA6B;AAAA,EACpD;AACD;AAEO,SAAS,kBACf,YACA,UACA,SACgB;AAChB,SAAO,QAAQ,IAAI,CAAC,OAAO;AAAA,IAC1B,IAAI,WAAW;AAAA,IACf,MAAM,GAAG,UAAU;AAAA,IACnB,aAAa;AAAA,IACb,eAAe;AAAA,IACf,SAAS;AAAA,MACR,WAAW,EAAE;AAAA,MACb,UAAU,EAAE;AAAA,MACZ,UAAU,EAAE;AAAA,IACb;AAAA,IACA,YAAY,oBAAI,KAAK;AAAA,IACrB,UAAU,EAAE,UAAU,SAA0B;AAAA,EACjD,EAAE;AACH;AAUA,eAAsB,WACrB,UACA,QACgB;AAChB,MAAI,CAAC,YAAY,OAAO,WAAW,EAAG;AACtC,MAAI;AACH,QAAI,OAAO,WAAW,GAAG;AACxB,YAAM,OAAO,OAAO,CAAC;AACrB,UAAI,CAAC,KAAM;AACX,YAAM,SAAS,QAAQ,IAAI;AAAA,IAC5B,OAAO;AACN,YAAM,SAAS,YAAY,MAAM;AAAA,IAClC;AAAA,EACD,QAAQ;AAGP,YAAQ,KAAK,qCAAqC,OAAO,MAAM,WAAW;AAAA,EAC3E;AACD;","names":[]}

package/dist/chunk-L3LZWWSX.js

@@ -0,0 +1,61 @@
+// runtime/subsystems/jobs/job-run-keyset-cursor.ts
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 200;
+function clampLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_LIST_LIMIT;
+  }
+  const floored = Math.floor(limit);
+  if (floored < 1) return 1;
+  if (floored > MAX_LIST_LIMIT) return MAX_LIST_LIMIT;
+  return floored;
+}
+function encodeKeysetCursor(keyset) {
+  const tuple = [keyset.createdAt.toISOString(), keyset.id];
+  return Buffer.from(JSON.stringify(tuple), "utf8").toString("base64url");
+}
+function decodeKeysetCursor(cursor) {
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf8");
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed) || parsed.length !== 2) return null;
+    const [iso, id] = parsed;
+    if (typeof iso !== "string" || typeof id !== "string") return null;
+    const createdAt = new Date(iso);
+    if (Number.isNaN(createdAt.getTime())) return null;
+    return { createdAt, id };
+  } catch {
+    return null;
+  }
+}
+function toJobRunSummary(r) {
+  return {
+    runId: r.id,
+    rootRunId: r.rootRunId,
+    parentRunId: r.parentRunId,
+    triggerSource: r.triggerSource,
+    triggerRef: r.triggerRef,
+    jobType: r.jobType,
+    pool: r.pool,
+    status: r.status,
+    scopeEntityType: r.scopeEntityType,
+    scopeEntityId: r.scopeEntityId,
+    tenantId: r.tenantId,
+    attempts: r.attempts,
+    errorMessage: r.error?.message ?? null,
+    runAt: r.runAt,
+    startedAt: r.startedAt,
+    finishedAt: r.finishedAt,
+    createdAt: r.createdAt
+  };
+}
+
+export {
+  DEFAULT_LIST_LIMIT,
+  MAX_LIST_LIMIT,
+  clampLimit,
+  encodeKeysetCursor,
+  decodeKeysetCursor,
+  toJobRunSummary
+};
+//# sourceMappingURL=chunk-L3LZWWSX.js.map

package/dist/chunk-L3LZWWSX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-run-keyset-cursor.ts"],"sourcesContent":["/**\n * Keyset (seek) cursor codec for `IJobRunService.listJobRuns` (OBS-LIST-1).\n *\n * The list is ordered `created_at DESC, id DESC`. The cursor encodes the\n * `(createdAt, id)` of the last row on the previous page so the next page\n * can seek with `WHERE (created_at, id) < (cursorCreatedAt, cursorId)`\n * rather than an `OFFSET`. Keyset pagination stays O(log n) on deep pages\n * and is stable as new rows arrive at the head.\n *\n * The cursor is opaque to consumers: a base64url-encoded JSON tuple. Shape\n * is an implementation detail — never parse it outside this module.\n *\n * Also hosts `toJobRunSummary`, the single `JobRunRow → JobRunSummary`\n * projection shared by both backends so the narrow shape stays in sync.\n */\nimport type { JobRunRow } from './job-orchestration.schema';\nimport type { JobRunSummary } from './job-run-service.protocol';\n\nexport interface JobRunKeyset {\n  /** `created_at` of the last row on the previous page. */\n  createdAt: Date;\n  /** `id` (UUID) tie-break of the last row on the previous page. */\n  id: string;\n}\n\n/** Default page size when `limit` is omitted. */\nexport const DEFAULT_LIST_LIMIT = 50;\n/** Hard upper bound on page size to keep a single read bounded. */\nexport const MAX_LIST_LIMIT = 200;\n\n/** Clamp a caller-supplied `limit` into `[1, MAX_LIST_LIMIT]`. */\nexport function clampLimit(limit: number | undefined): number {\n  if (typeof limit !== 'number' || !Number.isFinite(limit)) {\n    return DEFAULT_LIST_LIMIT;\n  }\n  const floored = Math.floor(limit);\n  if (floored < 1) return 1;\n  if (floored > MAX_LIST_LIMIT) return MAX_LIST_LIMIT;\n  return floored;\n}\n\nexport function encodeKeysetCursor(keyset: JobRunKeyset): string {\n  const tuple = [keyset.createdAt.toISOString(), keyset.id];\n  return Buffer.from(JSON.stringify(tuple), 'utf8').toString('base64url');\n}\n\n/**\n * Decode an opaque cursor back into its `(createdAt, id)` keyset. Returns\n * `null` for a malformed cursor so callers can treat garbage input as\n * \"start from the beginning\" rather than throwing on user-supplied data.\n */\nexport function decodeKeysetCursor(cursor: string): JobRunKeyset | null {\n  try {\n    const json = Buffer.from(cursor, 'base64url').toString('utf8');\n    const parsed = JSON.parse(json) as unknown;\n    if (!Array.isArray(parsed) || parsed.length !== 2) return null;\n    const [iso, id] = parsed;\n    if (typeof iso !== 'string' || typeof id !== 'string') return null;\n    const createdAt = new Date(iso);\n    if (Number.isNaN(createdAt.getTime())) return null;\n    return { createdAt, id };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Project a raw `job_run` row into the narrow `JobRunSummary` shape exposed\n * by `listJobRuns`. `errorMessage` is pulled from the jsonb `error.message`.\n */\nexport function toJobRunSummary(r: JobRunRow): JobRunSummary {\n  return {\n    runId: r.id,\n    rootRunId: r.rootRunId,\n    parentRunId: r.parentRunId,\n    triggerSource: r.triggerSource,\n    triggerRef: r.triggerRef,\n    jobType: r.jobType,\n    pool: r.pool,\n    status: r.status,\n    scopeEntityType: r.scopeEntityType,\n    scopeEntityId: r.scopeEntityId,\n    tenantId: r.tenantId,\n    attempts: r.attempts,\n    errorMessage: r.error?.message ?? null,\n    runAt: r.runAt,\n    startedAt: r.startedAt,\n    finishedAt: r.finishedAt,\n    createdAt: r.createdAt,\n  };\n}\n"],"mappings":";AA0BO,IAAM,qBAAqB;AAE3B,IAAM,iBAAiB;AAGvB,SAAS,WAAW,OAAmC;AAC5D,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,GAAG;AACxD,WAAO;AAAA,EACT;AACA,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,MAAI,UAAU,EAAG,QAAO;AACxB,MAAI,UAAU,eAAgB,QAAO;AACrC,SAAO;AACT;AAEO,SAAS,mBAAmB,QAA8B;AAC/D,QAAM,QAAQ,CAAC,OAAO,UAAU,YAAY,GAAG,OAAO,EAAE;AACxD,SAAO,OAAO,KAAK,KAAK,UAAU,KAAK,GAAG,MAAM,EAAE,SAAS,WAAW;AACxE;AAOO,SAAS,mBAAmB,QAAqC;AACtE,MAAI;AACF,UAAM,OAAO,OAAO,KAAK,QAAQ,WAAW,EAAE,SAAS,MAAM;AAC7D,UAAM,SAAS,KAAK,MAAM,IAAI;AAC9B,QAAI,CAAC,MAAM,QAAQ,MAAM,KAAK,OAAO,WAAW,EAAG,QAAO;AAC1D,UAAM,CAAC,KAAK,EAAE,IAAI;AAClB,QAAI,OAAO,QAAQ,YAAY,OAAO,OAAO,SAAU,QAAO;AAC9D,UAAM,YAAY,IAAI,KAAK,GAAG;AAC9B,QAAI,OAAO,MAAM,UAAU,QAAQ,CAAC,EAAG,QAAO;AAC9C,WAAO,EAAE,WAAW,GAAG;AAAA,EACzB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAMO,SAAS,gBAAgB,GAA6B;AAC3D,SAAO;AAAA,IACL,OAAO,EAAE;AAAA,IACT,WAAW,EAAE;AAAA,IACb,aAAa,EAAE;AAAA,IACf,eAAe,EAAE;AAAA,IACjB,YAAY,EAAE;AAAA,IACd,SAAS,EAAE;AAAA,IACX,MAAM,EAAE;AAAA,IACR,QAAQ,EAAE;AAAA,IACV,iBAAiB,EAAE;AAAA,IACnB,eAAe,EAAE;AAAA,IACjB,UAAU,EAAE;AAAA,IACZ,UAAU,EAAE;AAAA,IACZ,cAAc,EAAE,OAAO,WAAW;AAAA,IAClC,OAAO,EAAE;AAAA,IACT,WAAW,EAAE;AAAA,IACb,YAAY,EAAE;AAAA,IACd,WAAW,EAAE;AAAA,EACf;AACF;","names":[]}

package/dist/chunk-L4SDDEEU.js

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

package/dist/chunk-L4SDDEEU.js.map

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

package/dist/chunk-L6FTY45T.js

@@ -0,0 +1,13 @@
+import {
+  tokenKey
+} from "./chunk-GYGNEQSC.js";
+
+// runtime/subsystems/cache/cache.tokens.ts
+var CACHE = Symbol.for(tokenKey("cache", "cache"));
+var CACHE_DEFAULT_TTL = Symbol.for(tokenKey("cache", "default-ttl"));
+
+export {
+  CACHE,
+  CACHE_DEFAULT_TTL
+};
+//# sourceMappingURL=chunk-L6FTY45T.js.map

package/dist/chunk-L6FTY45T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/cache/cache.tokens.ts"],"sourcesContent":["/**\n * Injection token for the cache service.\n *\n * Usage in use cases:\n * ```typescript\n * constructor(@Inject(CACHE) private readonly cache: ICacheService) {}\n * ```\n *\n * Services may also inject CACHE for reads (get, has) per ADR-003.\n *\n * ADR-037: namespaced `Symbol.for(...)` key (via `tokenKey()`) so the token matches\n * by value across import boundaries (package vs vendored runtime copy).\n */\nimport { tokenKey } from '../token-key';\n\nexport const CACHE = Symbol.for(tokenKey('cache', 'cache'));\n\n/**\n * Injection token for the default TTL (in seconds) passed from CacheModule.forRoot().\n * Optional — omit for no-expiry behavior.\n */\nexport const CACHE_DEFAULT_TTL = Symbol.for(tokenKey('cache', 'default-ttl'));\n"],"mappings":";;;;;AAeO,IAAM,QAAQ,OAAO,IAAI,SAAS,SAAS,OAAO,CAAC;AAMnD,IAAM,oBAAoB,OAAO,IAAI,SAAS,SAAS,aAAa,CAAC;","names":[]}