@pipeline-builder/pipeline-data 4.3.2 → 4.3.4

package/lib/api/soft-delete-sweep.d.ts

@@ -1,27 +1,17 @@
-/**
- * Shared soft-delete retention purge.
- *
- * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a
- * `purge_after` deadline). This orchestrator runs one purge pass across a set
- * of such entities, hard-deleting tombstones whose deadline has passed. It is
- * the `run` callback a service hands to `createScheduler` (leader-locked), so
- * only one pod sweeps at a time.
- *
- * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({
- * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and
- * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant
- * context would see zero rows on those tables — and in production (`strict`
- * mode) `withTenantTx` throws outright — so the scope is established here rather
- * than left to the caller. This is a cross-tenant housekeeping job, not a
- * per-org operation.
- */
-import { type Scheduler } from '@pipeline-builder/api-core';
+import { type Scheduler, type RemoteAuditAction } from '@pipeline-builder/api-core';
 /** The slice of a CrudService the sweep needs, plus a label for logs/metrics. */
 export interface PurgeableEntity {
     /** Table/entity label (e.g. 'pipeline') for per-table logging. */
     name: string;
     /** Hard-delete up to `limit` expired tombstones; returns rows purged. */
     purgeExpired(now: Date, limit?: number): Promise<number>;
+    /**
+     * The entity's manual-purge action (e.g. `pipeline.purge`), reused for the
+     * sweep's hard-deletes with `details.trigger: 'retention'`. Omitted for rows
+     * that are not user-facing records (pending attachment blobs and the like) —
+     * those purge unaudited.
+     */
+    auditAction?: RemoteAuditAction;
 }
 /**
  * The services that run a soft-delete purge. A closed union, not a `string`,

package/lib/api/soft-delete-sweep.js

@@ -16,8 +16,12 @@
  * mode) `withTenantTx` throws outright — so the scope is established here rather
  * than left to the caller. This is a cross-tenant housekeeping job, not a
  * per-org operation.
+ *
+ * Each tick is one audited job run: entities that name an `auditAction` get one
+ * event per tick that purged rows — system actor, the tick's `runId`, the count.
  */
-import { createLogger, createScheduler, envBool, envInt, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS } from '@pipeline-builder/api-core';
+import { randomUUID } from 'node:crypto';
+import { createLogger, createScheduler, envBool, envInt, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS, recordAudit, runWithAuditContext, SYSTEM_ACTOR_ID, SYSTEM_ORG_ID, } from '@pipeline-builder/api-core';
 import { runWithTenantContext } from '../database/tenancy.js';
 const logger = createLogger('soft-delete-sweep');
 /** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging
@@ -37,6 +41,9 @@ export async function runSoftDeletePurge(entities, opts = {}, run) {
         logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');
         return counts;
     }
+    // One id per tick: every audit event this run records carries it (as the
+    // job context's `runId` and in `details`), so a reviewer can regroup a sweep.
+    const runId = randomUUID();
     const batchSize = opts.batchSize ?? 500;
     const maxBatches = opts.maxBatchesPerEntity ?? 20;
     // One `now` for the whole tick — rows that expire mid-sweep wait for the next.
@@ -44,7 +51,7 @@ export async function runSoftDeletePurge(entities, opts = {}, run) {
     // Establish a sysadmin scope so every `purgeExpired` (which routes through
     // `withTenantTx`) bypasses RLS and spans all orgs. Without this, FORCE'd
     // tables return zero rows and production `strict` mode throws.
-    return runWithTenantContext({ isSuperAdmin: true }, async () => {
+    return runWithAuditContext({ job: { jobId: 'soft-delete-purge', runId, trigger: 'schedule' } }, () => runWithTenantContext({ isSuperAdmin: true }, async () => {
         for (const entity of entities) {
             // Between entities: the leader lock was lost (another pod is taking over) or
             // we are shutting down. The remaining entities are picked up next tick —
@@ -76,12 +83,35 @@ export async function runSoftDeletePurge(entities, opts = {}, run) {
                     });
                 }
             }
-            if (total > 0)
+            if (total > 0) {
                 logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });
+                if (entity.auditAction)
+                    auditRetentionPurge(entity.auditAction, entity.name, total, runId);
+            }
             counts[entity.name] = total;
         }
         return counts;
-    });
+    }));
+}
+/**
+ * The audit event for one entity's hard-deletes in one tick. A cross-tenant
+ * system job, so it is attributed to the system actor in the system org;
+ * `targetType` is the entity and there is no single `targetId`. Never throws —
+ * an unbound audit client (a wiring bug) is logged, and the sweep carries on.
+ */
+function auditRetentionPurge(action, entity, count, runId) {
+    try {
+        recordAudit({
+            action,
+            actorId: SYSTEM_ACTOR_ID,
+            orgId: SYSTEM_ORG_ID,
+            targetType: entity,
+            details: { trigger: 'retention', runId, count },
+        });
+    }
+    catch (err) {
+        logger.error('Retention purge audit not recorded', { entity, count, error: String(err) });
+    }
 }
 /**
  * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete
@@ -120,4 +150,4 @@ export function createSoftDeletePurgeScheduler(opts) {
         lock: { key: leaderLockKey(opts.service, 'soft-delete-purge'), ttlMs: lockTtlMs },
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"soft-delete-sweep.js","sourceRoot":"","sources":["../../src/api/soft-delete-sweep.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared soft-delete retention purge.\n *\n * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a\n * `purge_after` deadline). This orchestrator runs one purge pass across a set\n * of such entities, hard-deleting tombstones whose deadline has passed. It is\n * the `run` callback a service hands to `createScheduler` (leader-locked), so\n * only one pod sweeps at a time.\n *\n * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({\n * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and\n * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant\n * context would see zero rows on those tables — and in production (`strict`\n * mode) `withTenantTx` throws outright — so the scope is established here rather\n * than left to the caller. This is a cross-tenant housekeeping job, not a\n * per-org operation.\n */\n\nimport { createLogger, createScheduler, envBool, envInt, type Scheduler, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS } from '@pipeline-builder/api-core';\nimport { runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('soft-delete-sweep');\n\n/** The slice of a CrudService the sweep needs, plus a label for logs/metrics. */\nexport interface PurgeableEntity {\n  /** Table/entity label (e.g. 'pipeline') for per-table logging. */\n  name: string;\n  /** Hard-delete up to `limit` expired tombstones; returns rows purged. */\n  purgeExpired(now: Date, limit?: number): Promise<number>;\n}\n\n/**\n * The services that run a soft-delete purge. A closed union, not a `string`,\n * because the value becomes the LOCK KEY: two services passing the same string\n * would silently share one lock, and whichever lost it would simply never sweep —\n * a typo that stops a purge with no error anywhere.\n */\nexport type SoftDeleteSweepService = 'pipeline' | 'plugin' | 'message' | 'compliance' | 'platform' | 'reporting';\n\nexport interface SoftDeletePurgeOptions {\n  /** Rows per batch per table (default 500). */\n  batchSize?: number;\n  /** Max batches per table per tick (default 20 → ≤ 10k/table/tick); the rest\n   *  is deferred to the next tick so a huge backlog can't blow the lock TTL. */\n  maxBatchesPerEntity?: number;\n}\n\n/** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging\n *  (tombstones still accumulate + stay restorable; nothing is destroyed). */\nexport function isSoftDeletePurgeEnabled(): boolean {\n  return envBool('SOFT_DELETE_PURGE_ENABLED', true);\n}\n\n/**\n * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in\n * batches until a batch returns `< batchSize` (drained) or the per-tick cap is\n * hit (logged; continued next tick). Never throws — a failing entity is logged\n * and the sweep moves on. Returns per-entity purged counts (also logged).\n */\nexport async function runSoftDeletePurge(\n  entities: PurgeableEntity[],\n  opts: SoftDeletePurgeOptions = {},\n  run?: { signal: AbortSignal },\n): Promise<Record<string, number>> {\n  const counts: Record<string, number> = {};\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');\n    return counts;\n  }\n\n  const batchSize = opts.batchSize ?? 500;\n  const maxBatches = opts.maxBatchesPerEntity ?? 20;\n  // One `now` for the whole tick — rows that expire mid-sweep wait for the next.\n  const now = new Date();\n\n  // Establish a sysadmin scope so every `purgeExpired` (which routes through\n  // `withTenantTx`) bypasses RLS and spans all orgs. Without this, FORCE'd\n  // tables return zero rows and production `strict` mode throws.\n  return runWithTenantContext({ isSuperAdmin: true }, async () => {\n    for (const entity of entities) {\n      // Between entities: the leader lock was lost (another pod is taking over) or\n      // we are shutting down. The remaining entities are picked up next tick —\n      // their tombstones are still expired — and stopping lets the lock go.\n      if (run?.signal.aborted) {\n        logger.info('Soft-delete purge stopping early', { reason: String(run.signal.reason ?? 'aborted'), atEntity: entity.name });\n        break;\n      }\n      let total = 0;\n      for (let i = 0; i < maxBatches; i++) {\n        // Also between BATCHES: one entity with a large backlog can run for many\n        // batches, which is exactly the case a TTL used to have to cover.\n        if (run?.signal.aborted) break;\n        let purged: number;\n        try {\n          purged = await entity.purgeExpired(now, batchSize);\n        } catch (err) {\n          logger.error('Purge batch failed', { entity: entity.name, error: String(err) });\n          break;\n        }\n        total += purged;\n        if (purged < batchSize) break; // drained\n        if (i === maxBatches - 1) {\n          logger.warn('Purge hit per-tick cap; remaining tombstones deferred to next tick', {\n            entity: entity.name, purgedThisTick: total,\n          });\n        }\n      }\n      if (total > 0) logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });\n      counts[entity.name] = total;\n    }\n\n    return counts;\n  });\n}\n\n// -- Scheduler factory --------------------------------------------------------\n\nexport interface SoftDeletePurgeSchedulerOptions extends SoftDeletePurgeOptions {\n  /** Service label for logs + the leader-lock key (e.g. 'pipeline', 'plugin'). */\n  service: SoftDeleteSweepService;\n  /** Entities to sweep — usually the service's own CrudService singletons. */\n  entities: PurgeableEntity[];\n}\n\n/**\n * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete\n * purge sweep for `entities` on a cadence. The caller `.start()`s it and wires\n * `stop()` to SIGTERM. Returns null when purging is disabled.\n *\n * Env config:\n *   SOFT_DELETE_PURGE_ENABLED           (default true; false ⇒ null, no sweep)\n *   SOFT_DELETE_PURGE_INTERVAL_HOURS    (default 6)\n *   SOFT_DELETE_PURGE_STARTUP_DELAY_MS  (default 120000 — 2 min settle)\n *   SOFT_DELETE_PURGE_LOCK_TTL_MS       (default 900000 — 15 min; outlasts a\n *                                        sweep, stays under the interval)\n *\n * A cross-pod leader lock (when Redis is configured) means only one replica\n * sweeps per window; without Redis it runs on every pod — still safe, since the\n * purge is a batched idempotent DELETE, just redundant.\n */\nexport function createSoftDeletePurgeScheduler(opts: SoftDeletePurgeSchedulerOptions): Scheduler | null {\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.info('Soft-delete purge scheduler disabled (SOFT_DELETE_PURGE_ENABLED=false)', { service: opts.service });\n    return null;\n  }\n\n  const intervalMs = envInt('SOFT_DELETE_PURGE_INTERVAL_HOURS', 6, { min: 1 }) * 60 * 60 * 1000;\n  const startupDelayMs = envInt('SOFT_DELETE_PURGE_STARTUP_DELAY_MS', 120_000, { min: 0 });\n  const lockTtlMs = envInt('SOFT_DELETE_PURGE_LOCK_TTL_MS', DEFAULT_LEADER_LOCK_TTL_MS, { min: 1000 });\n\n  logger.info('Soft-delete purge scheduler starting', {\n    service: opts.service,\n    entities: opts.entities.map((e) => e.name),\n    intervalHours: intervalMs / 3_600_000,\n  });\n\n  return createScheduler({\n    name: `soft-delete-purge:${opts.service}`,\n    intervalMs,\n    startupDelayMs,\n    run: async (run) => { await runSoftDeletePurge(opts.entities, opts, run); },\n    lock: { key: leaderLockKey(opts.service, 'soft-delete-purge'), ttlMs: lockTtlMs },\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"soft-delete-sweep.js","sourceRoot":"","sources":["../../src/api/soft-delete-sweep.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared soft-delete retention purge.\n *\n * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a\n * `purge_after` deadline). This orchestrator runs one purge pass across a set\n * of such entities, hard-deleting tombstones whose deadline has passed. It is\n * the `run` callback a service hands to `createScheduler` (leader-locked), so\n * only one pod sweeps at a time.\n *\n * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({\n * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and\n * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant\n * context would see zero rows on those tables — and in production (`strict`\n * mode) `withTenantTx` throws outright — so the scope is established here rather\n * than left to the caller. This is a cross-tenant housekeeping job, not a\n * per-org operation.\n *\n * Each tick is one audited job run: entities that name an `auditAction` get one\n * event per tick that purged rows — system actor, the tick's `runId`, the count.\n */\n\nimport { randomUUID } from 'node:crypto';\nimport {\n  createLogger, createScheduler, envBool, envInt, type Scheduler, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS,\n  recordAudit, runWithAuditContext, SYSTEM_ACTOR_ID, SYSTEM_ORG_ID, type RemoteAuditAction,\n} from '@pipeline-builder/api-core';\nimport { runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('soft-delete-sweep');\n\n/** The slice of a CrudService the sweep needs, plus a label for logs/metrics. */\nexport interface PurgeableEntity {\n  /** Table/entity label (e.g. 'pipeline') for per-table logging. */\n  name: string;\n  /** Hard-delete up to `limit` expired tombstones; returns rows purged. */\n  purgeExpired(now: Date, limit?: number): Promise<number>;\n  /**\n   * The entity's manual-purge action (e.g. `pipeline.purge`), reused for the\n   * sweep's hard-deletes with `details.trigger: 'retention'`. Omitted for rows\n   * that are not user-facing records (pending attachment blobs and the like) —\n   * those purge unaudited.\n   */\n  auditAction?: RemoteAuditAction;\n}\n\n/**\n * The services that run a soft-delete purge. A closed union, not a `string`,\n * because the value becomes the LOCK KEY: two services passing the same string\n * would silently share one lock, and whichever lost it would simply never sweep —\n * a typo that stops a purge with no error anywhere.\n */\nexport type SoftDeleteSweepService = 'pipeline' | 'plugin' | 'message' | 'compliance' | 'platform' | 'reporting';\n\nexport interface SoftDeletePurgeOptions {\n  /** Rows per batch per table (default 500). */\n  batchSize?: number;\n  /** Max batches per table per tick (default 20 → ≤ 10k/table/tick); the rest\n   *  is deferred to the next tick so a huge backlog can't blow the lock TTL. */\n  maxBatchesPerEntity?: number;\n}\n\n/** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging\n *  (tombstones still accumulate + stay restorable; nothing is destroyed). */\nexport function isSoftDeletePurgeEnabled(): boolean {\n  return envBool('SOFT_DELETE_PURGE_ENABLED', true);\n}\n\n/**\n * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in\n * batches until a batch returns `< batchSize` (drained) or the per-tick cap is\n * hit (logged; continued next tick). Never throws — a failing entity is logged\n * and the sweep moves on. Returns per-entity purged counts (also logged).\n */\nexport async function runSoftDeletePurge(\n  entities: PurgeableEntity[],\n  opts: SoftDeletePurgeOptions = {},\n  run?: { signal: AbortSignal },\n): Promise<Record<string, number>> {\n  const counts: Record<string, number> = {};\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');\n    return counts;\n  }\n\n  // One id per tick: every audit event this run records carries it (as the\n  // job context's `runId` and in `details`), so a reviewer can regroup a sweep.\n  const runId = randomUUID();\n  const batchSize = opts.batchSize ?? 500;\n  const maxBatches = opts.maxBatchesPerEntity ?? 20;\n  // One `now` for the whole tick — rows that expire mid-sweep wait for the next.\n  const now = new Date();\n\n  // Establish a sysadmin scope so every `purgeExpired` (which routes through\n  // `withTenantTx`) bypasses RLS and spans all orgs. Without this, FORCE'd\n  // tables return zero rows and production `strict` mode throws.\n  return runWithAuditContext({ job: { jobId: 'soft-delete-purge', runId, trigger: 'schedule' } }, () => runWithTenantContext({ isSuperAdmin: true }, async () => {\n    for (const entity of entities) {\n      // Between entities: the leader lock was lost (another pod is taking over) or\n      // we are shutting down. The remaining entities are picked up next tick —\n      // their tombstones are still expired — and stopping lets the lock go.\n      if (run?.signal.aborted) {\n        logger.info('Soft-delete purge stopping early', { reason: String(run.signal.reason ?? 'aborted'), atEntity: entity.name });\n        break;\n      }\n      let total = 0;\n      for (let i = 0; i < maxBatches; i++) {\n        // Also between BATCHES: one entity with a large backlog can run for many\n        // batches, which is exactly the case a TTL used to have to cover.\n        if (run?.signal.aborted) break;\n        let purged: number;\n        try {\n          purged = await entity.purgeExpired(now, batchSize);\n        } catch (err) {\n          logger.error('Purge batch failed', { entity: entity.name, error: String(err) });\n          break;\n        }\n        total += purged;\n        if (purged < batchSize) break; // drained\n        if (i === maxBatches - 1) {\n          logger.warn('Purge hit per-tick cap; remaining tombstones deferred to next tick', {\n            entity: entity.name, purgedThisTick: total,\n          });\n        }\n      }\n      if (total > 0) {\n        logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });\n        if (entity.auditAction) auditRetentionPurge(entity.auditAction, entity.name, total, runId);\n      }\n      counts[entity.name] = total;\n    }\n\n    return counts;\n  }));\n}\n\n/**\n * The audit event for one entity's hard-deletes in one tick. A cross-tenant\n * system job, so it is attributed to the system actor in the system org;\n * `targetType` is the entity and there is no single `targetId`. Never throws —\n * an unbound audit client (a wiring bug) is logged, and the sweep carries on.\n */\nfunction auditRetentionPurge(action: RemoteAuditAction, entity: string, count: number, runId: string): void {\n  try {\n    recordAudit({\n      action,\n      actorId: SYSTEM_ACTOR_ID,\n      orgId: SYSTEM_ORG_ID,\n      targetType: entity,\n      details: { trigger: 'retention', runId, count },\n    });\n  } catch (err) {\n    logger.error('Retention purge audit not recorded', { entity, count, error: String(err) });\n  }\n}\n\n// -- Scheduler factory --------------------------------------------------------\n\nexport interface SoftDeletePurgeSchedulerOptions extends SoftDeletePurgeOptions {\n  /** Service label for logs + the leader-lock key (e.g. 'pipeline', 'plugin'). */\n  service: SoftDeleteSweepService;\n  /** Entities to sweep — usually the service's own CrudService singletons. */\n  entities: PurgeableEntity[];\n}\n\n/**\n * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete\n * purge sweep for `entities` on a cadence. The caller `.start()`s it and wires\n * `stop()` to SIGTERM. Returns null when purging is disabled.\n *\n * Env config:\n *   SOFT_DELETE_PURGE_ENABLED           (default true; false ⇒ null, no sweep)\n *   SOFT_DELETE_PURGE_INTERVAL_HOURS    (default 6)\n *   SOFT_DELETE_PURGE_STARTUP_DELAY_MS  (default 120000 — 2 min settle)\n *   SOFT_DELETE_PURGE_LOCK_TTL_MS       (default 900000 — 15 min; outlasts a\n *                                        sweep, stays under the interval)\n *\n * A cross-pod leader lock (when Redis is configured) means only one replica\n * sweeps per window; without Redis it runs on every pod — still safe, since the\n * purge is a batched idempotent DELETE, just redundant.\n */\nexport function createSoftDeletePurgeScheduler(opts: SoftDeletePurgeSchedulerOptions): Scheduler | null {\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.info('Soft-delete purge scheduler disabled (SOFT_DELETE_PURGE_ENABLED=false)', { service: opts.service });\n    return null;\n  }\n\n  const intervalMs = envInt('SOFT_DELETE_PURGE_INTERVAL_HOURS', 6, { min: 1 }) * 60 * 60 * 1000;\n  const startupDelayMs = envInt('SOFT_DELETE_PURGE_STARTUP_DELAY_MS', 120_000, { min: 0 });\n  const lockTtlMs = envInt('SOFT_DELETE_PURGE_LOCK_TTL_MS', DEFAULT_LEADER_LOCK_TTL_MS, { min: 1000 });\n\n  logger.info('Soft-delete purge scheduler starting', {\n    service: opts.service,\n    entities: opts.entities.map((e) => e.name),\n    intervalHours: intervalMs / 3_600_000,\n  });\n\n  return createScheduler({\n    name: `soft-delete-purge:${opts.service}`,\n    intervalMs,\n    startupDelayMs,\n    run: async (run) => { await runSoftDeletePurge(opts.entities, opts, run); },\n    lock: { key: leaderLockKey(opts.service, 'soft-delete-purge'), ttlMs: lockTtlMs },\n  });\n}\n"]}

package/lib/api/support-cases.d.ts

@@ -0,0 +1,380 @@
+/**
+ * Support-case persistence: the workflow half of a support thread.
+ *
+ * Here rather than in a service because two callers need it — platform owns the
+ * entitlement check and the writes, and the message service owns the thread the
+ * case points at — and neither should grow its own copy of the allocator.
+ *
+ * `messages` keeps carrying the conversation. These functions only ever touch
+ * the workflow axis: identity, status, ownership and the response clock.
+ */
+import type { SupportCase } from '../database/schema/support.js';
+/** Statuses a case can be in. `awaiting_customer` is what stops the clock. */
+export declare const SUPPORT_CASE_STATUSES: readonly ['open', 'awaiting_support', 'awaiting_customer', 'resolved', 'closed'];
+export type SupportCaseStatus = (typeof SUPPORT_CASE_STATUSES)[number];
+/** The statuses the staff queue asks about — the ones still on us. */
+export declare const QUEUE_STATUSES: readonly SupportCaseStatus[];
+/** What opening a case needs. `level` is frozen onto the row at open. */
+export interface OpenCaseInput {
+    /** The root `messages.id`. Becomes the canonical case identity. */
+    threadId: string;
+    orgId: string;
+    /** The support level HELD AT OPEN, frozen so a mid-case downgrade cannot
+     *  change the promise underneath someone already waiting. */
+    level: string;
+    severity: string;
+    /** The opener. Also the initial tenant owner when they are a contact. */
+    openedBy: string;
+    /** True when the case was opened by spending a one-time incident rather than
+     *  against a contact seat, so incident usage is answerable from the cases
+     *  themselves and not only from a balance delta. */
+    openedWithIncident?: boolean;
+    /**
+     * When the first response is due, already computed by the caller.
+     *
+     * Passed IN rather than derived here: the business calendar is deployment
+     * config (`SUPPORT_BUSINESS_HOURS_*`) read by api-core's `responseDueAt`, and
+     * this module must not reach for env to answer a product question. Null is a
+     * legitimate value — a level with no published target, or a calendar too
+     * broken to derive one — and is stored as "no deadline" rather than guessed.
+     */
+    responseDueAt?: Date | null;
+}
+/**
+ * Open a case for an existing thread, allocating its display number.
+ *
+ * One transaction on purpose: the number and the row commit together or neither
+ * does. `support_case_org_number_uq` is the backstop — if the allocator is ever
+ * bypassed, the insert fails rather than issuing two cases the one identifier
+ * customers quote back.
+ */
+export declare function openSupportCase(input: OpenCaseInput): Promise<SupportCase>;
+/** The case for a thread, or null. The thread root id IS the case identity. */
+export declare function findCaseByThread(threadId: string): Promise<SupportCase | null>;
+/**
+ * The staff queue: open cases across ALL tenants, oldest first.
+ *
+ * The one read with no org predicate, so it runs under sysadmin scope and is
+ * served by the partial `support_case_queue_idx`.
+ *
+ * Ordered by `response_due_at` ASCENDING, NULLS LAST — soonest deadline first,
+ * which is what "most at risk" actually means. Arrival order was the earlier
+ * proxy for it and is a poor one: a standard case opened on Monday is owed
+ * Wednesday's close while a priority case opened on Tuesday is owed Wednesday's
+ * close too, so arrival order puts them in the wrong sequence whenever levels
+ * are mixed. Cases with no deadline (an unrecognised level, or one opened while
+ * the calendar was misconfigured) sort last rather than first, since a missing
+ * deadline is not an urgent one; `createdAt` breaks ties so the order is stable.
+ */
+export declare function listQueue(limit?: number): Promise<SupportCase[]>;
+/**
+ * Premium cases whose response target is approaching with no first response yet.
+ *
+ * THE on-call sweep's only query, and the reason the pager is worth owning the
+ * trigger for: this is an EXACT per-case deadline, where the fleet alert
+ * (`SupportPremiumFirstResponseAtRisk`) is a p90 over six hours that can only
+ * say the distribution already drifted — never which case is about to breach.
+ *
+ * The predicate matches `support_case_response_due_idx` exactly, which is a
+ * PARTIAL index on `(response_due_at) WHERE level = 'support_premium' AND
+ * first_response_at IS NULL AND deleted_at IS NULL`. Note `level` and not
+ * `is_premium`: that column lives on support_CONTACTS and marks an upgraded
+ * contact, while a case freezes the opening contact's effective level at open —
+ * so the case's own promise is its `level`, and flipping the contact later must
+ * not change a deadline already published to a customer. That matters because this runs on a timer
+ * forever: the rows it wants are a tiny and shrinking fraction of the table, so
+ * the index stays small while the table grows, and without it every tick is a
+ * scan.
+ *
+ * Deliberately NOT filtered on status. A case that is `awaiting_support` and one
+ * that is `open` both owe a first response, and reading the status here would
+ * duplicate a rule that `first_response_at IS NULL` already states exactly.
+ */
+export declare function listCasesDueForPage(leadMs: number, limit?: number): Promise<SupportCase[]>;
+/** An org's own cases, newest first. */
+export declare function listOrgCases(orgId: string, limit?: number): Promise<SupportCase[]>;
+/**
+ * Stamp the first staff response, once.
+ *
+ * `first_response_at IS NULL` is in the WHERE clause rather than checked by the
+ * caller: this is THE number the response target is sold on, so a second reply
+ * must not be able to move it. Returns whether this call was the one that
+ * stamped it.
+ */
+export declare function stampFirstResponse(caseId: string, at?: Date): Promise<boolean>;
+/**
+ * Move a case's status, maintaining the response clock.
+ *
+ * Entering `awaiting_customer` anchors `awaitingSince`; leaving it folds the
+ * elapsed span into `awaitingTotalSeconds` and clears the anchor. Ageing then
+ * subtracts the accumulator, so a case we answered in an hour and the tenant
+ * replied to four days later does not read as a four-day case — which is the
+ * number no customer would accept.
+ *
+ * The arithmetic is done in SQL against the stored anchor rather than from a
+ * caller-supplied duration, so a clock skew or a lost round trip cannot inflate
+ * or erase paused time.
+ */
+export declare function setCaseStatus(caseId: string, status: SupportCaseStatus, actorId: string): Promise<SupportCase | null>;
+/**
+ * Re-rank a case's severity.
+ *
+ * STAFF ONLY at the route layer, and that is the governance point rather than a
+ * permission detail: the tenant chooses severity when opening, so if they could
+ * also change it afterwards they would unilaterally pick the response target
+ * they are owed. Severity decides which target applies, so re-ranking has to be
+ * ours.
+ */
+export declare function setCaseSeverity(caseId: string, severity: string, actorId: string): Promise<string | null>;
+/**
+ * Set or clear the STAFF owner.
+ *
+ * `null` is a legitimate value: it is the unowned pool, and how "I cannot take
+ * this" is expressed without inventing a pseudo-assignee.
+ */
+export declare function assignCase(caseId: string, assignedTo: string | null, actorId: string): Promise<SupportCase | null>;
+/**
+ * Assign or release MANY cases at once.
+ *
+ * One statement rather than a loop, which is the point: a staff member clearing
+ * a queue of thirty selects thirty and acts once, and thirty round trips would
+ * make the obvious interaction the slow one. It also makes the write ATOMIC — a
+ * partial bulk assign leaves the queue in a state nobody chose, and the operator
+ * cannot tell which half took.
+ *
+ * Returns the ids that actually moved rather than a count, so a caller can
+ * report precisely what happened when the selection included something stale:
+ * a case closed or reassigned by somebody else between the read and the click.
+ * That is the normal case on a shared queue, not an edge one.
+ */
+export declare function assignCases(caseIds: readonly string[], assignedTo: string | null, actorId: string): Promise<string[]>;
+/**
+ * Close MANY cases at once.
+ *
+ * Separate from {@link assignCases} rather than a generic bulk-update, because
+ * closing maintains the response clock — it folds the open awaiting span into
+ * the accumulator and stamps `closedAt` — and a generic setter would quietly
+ * skip that. The arithmetic is the same SQL `setCaseStatus` uses, for the same
+ * reason: done against the STORED anchor so a clock skew cannot inflate paused
+ * time.
+ *
+ * Only ever used to CLOSE. Bulk REOPENING is deliberately not offered: reopening
+ * is staff-only and case-by-case by design, and a bulk reopen is how a queue
+ * someone has finished with comes back all at once.
+ */
+export declare function closeCases(caseIds: readonly string[], actorId: string): Promise<string[]>;
+/**
+ * Hand the case to another tenant contact.
+ *
+ * Note what this does NOT touch: `createdBy`. That is the immutable audit fact
+ * of who raised the case — mutating it to express "someone else owns this now"
+ * would destroy the only record of who actually opened it. The caller must have
+ * already checked that the target is a live designated contact; this function
+ * will not infer entitlement from a user id.
+ */
+export declare function transferCaseToContact(caseId: string, tenantContact: string, actorId: string): Promise<SupportCase | null>;
+/**
+ * A departing contact's open cases, so removal reassigns rather than orphans.
+ *
+ * Served by the partial `support_case_tenant_contact_idx`.
+ */
+export declare function openCasesForContact(orgId: string, userId: string): Promise<SupportCase[]>;
+/**
+ * Cases raised across a scope within the last `windowDays` — the FAIR-USE count.
+ *
+ * WHAT IT IS FOR. Support is priced per CONTACT, and that unit assumes contacts
+ * proxy for case volume. At ten seats they do; at a hundred they do not — three
+ * named contacts become an internal help desk FORWARDING tickets, so the price
+ * buys the interface rather than the load. This is the measurement that notices.
+ *
+ * WHY NOT THE QUOTA SERVICE. `QUOTA_RESET_DAYS` makes every tracked quota a
+ * 3-day period, and a support allowance is monthly-shaped: five a month does not
+ * divide into three days without rounding to something either far too loose or
+ * useless. This table IS the counter — one range scan on
+ * `support_case_org_created_idx`, no period mismatch, and nothing to drift out
+ * of sync with reality.
+ *
+ * COUNTS EVERY CASE, INCLUDING CLOSED AND SOFT-DELETED. The question is how much
+ * support was CONSUMED in the window, and a case that was answered and closed
+ * consumed it just as much as an open one. Excluding closed cases would make the
+ * allowance trivially evadable by closing promptly — the opposite of the
+ * behaviour anyone wants to discourage.
+ */
+export declare function countCasesInWindow(orgIds: readonly string[], windowDays: number): Promise<number>;
+/**
+ * Record the customer's verdict on a case.
+ *
+ * ONLY ON A TERMINAL CASE, enforced in the WHERE clause rather than by the
+ * caller: rating a case still being worked would measure an answer nobody has
+ * finished giving, and putting the condition in SQL means no route can forget
+ * it.
+ *
+ * RE-RATEABLE on purpose. A customer who rates in frustration and comes back a
+ * day later should be able to change it; freezing the first number would make
+ * the metric measure how people felt at their worst moment. `satisfaction_at`
+ * moves with it, so the ANSWER and WHEN it was given stay together.
+ *
+ * Returns whether a row moved — false means the case is missing, soft-deleted,
+ * or not closed yet, which the caller must distinguish from a stored zero.
+ */
+export declare function rateCase(caseId: string, satisfaction: number, comment: string | null): Promise<boolean>;
+/** One staff note, as the queue UI renders it. */
+export interface SupportCaseNote {
+    id: string;
+    caseId: string;
+    content: string;
+    createdBy: string;
+    createdAt: Date;
+}
+/**
+ * Add a staff-only note to a case.
+ *
+ * `orgId` is denormalised onto the row from the CASE, not taken from the author:
+ * a note belongs to the tenant whose case it annotates, and sourcing it from
+ * the staff author's own org (the system org) would put every note outside the
+ * tenant scope that is supposed to contain it.
+ *
+ * STAFF ONLY at the route layer, and the separate table is the reason that is
+ * safe: `messages` is read through one shared visibility predicate, so a flag
+ * there would leak an internal note from any read path that forgot the extra
+ * condition. A separate table cannot leak by omission — it has to be joined
+ * deliberately.
+ */
+export declare function addCaseNote(caseId: string, orgId: string, content: string, createdBy: string): Promise<SupportCaseNote>;
+/** Live notes on a case, oldest first — they read as a running commentary. */
+export declare function listCaseNotes(caseId: string): Promise<SupportCaseNote[]>;
+/**
+ * Soft-delete a note.
+ *
+ * Soft because a note is a record of what the desk believed at the time, and a
+ * dispute may turn on it. Returns whether a row moved, so a second delete is a
+ * reported no-op rather than a silent success.
+ */
+export declare function deleteCaseNote(noteId: string, deletedBy: string): Promise<boolean>;
+/** A reusable staff reply template. */
+export interface CannedResponse {
+    id: string;
+    title: string;
+    body: string;
+}
+/**
+ * Live templates, alphabetical — the picker's only query.
+ *
+ * No org scope because the table has none: these are the vendor's own wording
+ * for recurring questions, authored once and reused across every customer.
+ * Scoping them per tenant would be the opposite of the point.
+ */
+export declare function listCannedResponses(): Promise<CannedResponse[]>;
+/** Create a template. */
+export declare function createCannedResponse(title: string, body: string, actorId: string): Promise<CannedResponse>;
+/**
+ * Edit a live template.
+ *
+ * Guarded on `is_active` so a retired template cannot be edited back into
+ * circulation — a resurrection should be a deliberate new row, not a side
+ * effect of fixing a typo.
+ */
+export declare function updateCannedResponse(id: string, fields: {
+    title?: string;
+    body?: string;
+}, actorId: string): Promise<boolean>;
+/**
+ * Retire a template.
+ *
+ * SOFT, because a retired template is still the explanation of what a past
+ * reply said — deleting the row would leave old correspondence unaccountable
+ * for its own wording.
+ */
+export declare function deleteCannedResponse(id: string, actorId: string): Promise<boolean>;
+/**
+ * Live designated contacts across a set of orgs (an account subtree).
+ *
+ * Takes the whole scope in one query rather than per-org because the allowance
+ * POOLS at the root: a person designated on a team spends the account's
+ * allowance, so counting team-by-team and summing would be the same number by
+ * accident and the wrong shape the moment pooling changes.
+ */
+export declare function countActiveSupportContacts(orgIds: readonly string[]): Promise<number>;
+/**
+ * Live contacts for the tenant owner picker.
+ *
+ * SCOPE IS THE CALLER'S CHOICE, and the default is ONE ORG. The allowance pools
+ * subtree-wide, but ownership does not: a team reassigns a case only among its
+ * OWN contacts, so a pooled allowance never turns into one team's cases being
+ * readable by a sibling. Pass a single org id for the picker; pass the expanded
+ * subtree only where the pooled CAP is the question (see
+ * `countActiveSupportContacts`).
+ *
+ * Taking a list rather than a single id keeps that decision at the call site
+ * instead of hiding it here — the two scopes answer differently and the wrong
+ * one leaks cases across teams.
+ */
+export declare function listActiveSupportContacts(orgIds: readonly string[]): Promise<{
+    orgId: string;
+    userId: string;
+    isPremium: boolean;
+}[]>;
+/**
+ * Whether this user is a live designated contact in any org of the scope.
+ *
+ * Transfer validation must pass the case's OWN org, not the subtree: accepting a
+ * sibling team's contact as a valid transfer target is exactly the cross-team
+ * leak the own-org ownership rule exists to prevent.
+ */
+export declare function isSupportContact(orgIds: readonly string[], userId: string): Promise<boolean>;
+/**
+ * Designate a support contact.
+ *
+ * The CAP is not enforced here — the caller holds it, because the limit lives on
+ * the Mongo org doc and this module only reaches Postgres. Mirrors how seats are
+ * capped in platform rather than in the row writer.
+ *
+ * `support_contact_org_user_uq` is partial on `is_active = true`, so
+ * re-designating someone previously revoked inserts a fresh row rather than
+ * colliding — the revoked row stays as the record that they once held it.
+ */
+export declare function designateSupportContact(orgId: string, userId: string, designatedBy: string, isPremium?: boolean): Promise<void>;
+/**
+ * Live contacts in a scope that are UPGRADED to premium — the cap's counterpart.
+ *
+ * Counted separately from the baseline total because the two caps are separate:
+ * an account holds N contacts (`supportContacts`) and upgrades M of them
+ * (`supportPremiumContacts`), M ≤ N. Pooled over whatever scope the caller
+ * passes, exactly like {@link countActiveSupportContacts} — subtree for the cap,
+ * one org for an ownership question.
+ */
+export declare function countPremiumSupportContacts(orgIds: readonly string[]): Promise<number>;
+/**
+ * Whether this user is a live PREMIUM contact in the scope.
+ *
+ * The case-open path reads this to decide which level to freeze onto a new case:
+ * premium when the opener is upgraded, the account's baseline otherwise. Pass the
+ * case's OWN org — the upgrade follows the person in the org that nominated
+ * them, and a sibling team's upgrade is not this org's to spend.
+ */
+export declare function isPremiumSupportContact(orgIds: readonly string[], userId: string): Promise<boolean>;
+/**
+ * Upgrade or downgrade a LIVE contact.
+ *
+ * Guarded on `is_active` so a revoked row cannot be upgraded back into
+ * relevance, and returns whether a row actually moved — the caller counts
+ * against the premium cap before calling, and a silent no-op would let that
+ * count drift from reality.
+ *
+ * Deliberately does NOT touch the case rows: `support_case.level` is frozen at
+ * open, so downgrading somebody never weakens a promise already made on a case
+ * they raised while upgraded.
+ */
+export declare function setSupportContactPremium(orgId: string, userId: string, isPremium: boolean): Promise<boolean>;
+/**
+ * Revoke a designation, freeing the slot.
+ *
+ * Returns the user's still-open cases so the caller can reassign them instead of
+ * orphaning — scope C4's answer. Revoking is deliberately not blocked on them:
+ * refusing to remove a departed employee because they still own cases would be
+ * worse than handing the cases on.
+ */
+export declare function revokeSupportContact(orgId: string, userId: string, revokedBy: string): Promise<{
+    revoked: boolean;
+    openCases: SupportCase[];
+}>;