@pipeline-builder/pipeline-data 4.3.2 → 4.3.4

package/lib/database/schema/support.js

@@ -0,0 +1,323 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';
+import { sql } from 'drizzle-orm';
+import { boolean, integer, varchar, pgTable, text, timestamp, uuid, index, uniqueIndex } from 'drizzle-orm/pg-core';
+/**
+ * The WORKFLOW axis of a support case.
+ *
+ * `messages` already carries the conversation — identity, threading, priority,
+ * per-participant read state, attachments and soft-delete. What it has no column
+ * for is workflow: status, ownership, resolution and the response clock. That is
+ * this table, one row per case, joined to the conversation by `threadId`.
+ *
+ * Keeping them apart rather than widening `messages` is deliberate: `messages`
+ * also carries announcements and ordinary conversations, which have no status,
+ * no assignee and no response target. Six nullable columns on every announcement
+ * row to describe a state announcements cannot be in is how a table stops
+ * meaning one thing.
+ *
+ * @table support_cases
+ */
+export const supportCase = pgTable('support_cases', {
+    // Internal key. NOT the case identity — see `threadId`.
+    id: uuid('id').primaryKey().defaultRandom(),
+    /**
+     * The root `messages.id` of the thread, and the CANONICAL case identity.
+     *
+     * The convention already exists: readers walk `threadId === root.id` and
+     * `update-message.ts` uses `updated.threadId ?? updated.id` for exactly this
+     * "the root is the identity" idea. So case identity falls out of threading the
+     * support path rather than being a new concept.
+     */
+    threadId: uuid('thread_id').notNull(),
+    // The TENANT org. Never the system org — a case is always about one tenant,
+    // even though the system org is the other participant in the thread.
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    /**
+     * Per-org, customer-quotable case number (rendered `ACME-1042`).
+     *
+     * A bare UUID is not something anyone reads out on a call or puts in an email
+     * subject, and a GLOBAL sequence would disclose total case volume to every
+     * customer. Allocated from `support_case_counters` in the same transaction as
+     * the insert; `support_case_org_number_uq` is the backstop that turns a
+     * bypassed counter into a failed insert rather than two cases sharing the one
+     * identifier customers quote back.
+     */
+    displayNumber: integer('display_number').notNull(),
+    // open | awaiting_support | awaiting_customer | resolved | closed
+    status: varchar('status', { length: 32 }).default('open').notNull(),
+    // Set by the opener; re-rankable by staff. Self-selected severity is why staff
+    // re-ranking is in v1: otherwise the tenant chooses the target they are owed.
+    severity: varchar('severity', { length: 16 }).default('normal').notNull(),
+    /**
+     * The support level held when the case was OPENED, frozen onto the case.
+     *
+     * Frozen deliberately: a customer who downgrades mid-case should still get the
+     * response they bought when they opened it. Resolving entitlement live would
+     * change an open case's promise underneath the person waiting on it.
+     */
+    level: varchar('level', { length: 32 }).notNull(),
+    /** True when the case was opened by spending a one-time incident rather than
+     *  against a contact seat. Recorded so "how many incidents were actually
+     *  used" is answerable from the cases, not only from a balance delta. */
+    openedWithIncident: boolean('opened_with_incident').default(false).notNull(),
+    // --- the two owners, which move independently. NEITHER is `createdBy`.
+    /** STAFF owner — a system-org actor. `null` is legitimate: it is the unowned
+     *  pool, and how "I cannot take this" is said without a pseudo-assignee. */
+    assignedTo: text('assigned_to'),
+    /** TENANT owner — the designated contact currently responsible. Distinct from
+     *  `createdBy`, which is the immutable audit fact of who raised the case:
+     *  mutating that to express "someone else owns this now" would destroy the
+     *  only record of who actually opened it. */
+    tenantContact: text('tenant_contact'),
+    // --- the response clock
+    /**
+     * When the first response is DUE, computed once at open and never recomputed.
+     *
+     * Frozen for the same reason `level` is: a change to the working week or the
+     * holiday list must not move a promise already made to a customer. Three
+     * things follow from storing it rather than deriving it per read:
+     *   - the staff queue orders by a real deadline with no calendar arithmetic
+     *     per row;
+     *   - the standard/priority breach check becomes CONTRACTUAL, where a
+     *     wall-clock quantile cannot express a business-day target at all (a
+     *     priority case raised at 17:01 on a Friday is not late until Monday
+     *     evening, ~79 wall-clock hours later);
+     *   - a level with no published target, and a case opened while the calendar
+     *     was misconfigured, are both simply NULL — no deadline rather than a
+     *     wrong one.
+     */
+    responseDueAt: timestamp('response_due_at', { withTimezone: true }),
+    /** First staff reply. THE measured number — the response target is sold on it. */
+    firstResponseAt: timestamp('first_response_at', { withTimezone: true }),
+    /**
+     * CSAT, 1–5, set by the TENANT once the case is closed. Null = not rated,
+     * which is the usual state and must stay distinguishable from a bad rating.
+     *
+     * Lives here rather than in its own table because a case has exactly one
+     * rating — a table would buy a join and a uniqueness constraint to enforce
+     * what a column gets for free. First-response latency says whether we
+     * answered fast; this is the only thing that says whether the answer helped,
+     * and a desk can hit every target while being bad at support.
+     */
+    satisfaction: integer('satisfaction'),
+    /** Optional free text with the rating. Capped at the route. */
+    satisfactionComment: text('satisfaction_comment'),
+    satisfactionAt: timestamp('satisfaction_at', { withTimezone: true }),
+    /** Set when status → `awaiting_customer`; the pause anchor. */
+    awaitingSince: timestamp('awaiting_since', { withTimezone: true }),
+    /**
+     * Accumulated seconds spent waiting on the customer.
+     *
+     * Ageing subtracts this. Without it a case we answered in an hour, where the
+     * tenant replied four days later, reads as a four-day case — and the metric
+     * Phase 2b exists to produce reports a number no customer will accept. An
+     * accumulator plus the current anchor survives a case bouncing between states
+     * repeatedly, which replaying status history would not.
+     */
+    awaitingTotalSeconds: integer('awaiting_total_seconds').default(0).notNull(),
+    closedAt: timestamp('closed_at', { withTimezone: true }),
+    closedBy: text('closed_by'),
+    // Audit + soft-delete, same shape as `messages`.
+    createdBy: text('created_by').default(SYSTEM_ORG_ID).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedBy: text('updated_by').default(SYSTEM_ORG_ID).notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+    isActive: boolean('is_active').default(true).notNull(),
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
+}, (table) => ({
+    /**
+     * THE queue query: every open case across ALL tenants, oldest first.
+     *
+     * The one query shape with no org predicate to narrow it, so it is also the
+     * only one that scans. Partial because the queue never asks about closed
+     * cases — which are most of the table within a month. Mirrors
+     * `message_purge_idx`, which is partial for the same reason.
+     */
+    queueIdx: index('support_case_queue_idx')
+        .on(table.createdAt)
+        .where(sql `status IN ('open', 'awaiting_support') AND deleted_at IS NULL`),
+    /**
+     * The on-call sweep's only query: premium cases whose first-response target is
+     * approaching with nothing stamped yet.
+     *
+     * PARTIAL because the tick runs every five minutes forever and the rows it
+     * wants are a tiny, shrinking fraction of the table — unanswered premium
+     * cases. Without it every tick is a scan, and it is the one query with no org
+     * predicate to narrow it.
+     *
+     * `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. The case's own promise is its `level`, so
+     * upgrading a contact later must not move a deadline already published to a
+     * customer.
+     */
+    responseDueIdx: index('support_case_response_due_idx')
+        .on(table.responseDueAt)
+        .where(sql `level = 'support_premium' AND first_response_at IS NULL AND deleted_at IS NULL`),
+    // A tenant listing its own cases.
+    orgStatusIdx: index('support_case_org_status_idx').on(table.orgId, table.status),
+    // The rolling-window case count behind the FAIR-USE allowance: how many cases
+    // this account raised in the last N days. Leading `org_id` because the count
+    // is always scoped to an account subtree, then `created_at` so the window is a
+    // range scan rather than a filter over every case the org ever raised.
+    orgCreatedIdx: index('support_case_org_created_idx').on(table.orgId, table.createdAt),
+    // "What am I on the hook for", one engineer.
+    assigneeIdx: index('support_case_assigned_idx')
+        .on(table.assignedTo, table.status)
+        .where(sql `assigned_to IS NOT NULL`),
+    // "My cases" for a contact, AND the lookup that finds a departing contact's
+    // open cases so they can be reassigned instead of orphaned.
+    tenantContactIdx: index('support_case_tenant_contact_idx')
+        .on(table.tenantContact, table.status)
+        .where(sql `tenant_contact IS NOT NULL`),
+    // Case identity, reached from any message in the thread.
+    threadUq: uniqueIndex('support_case_thread_uq').on(table.threadId),
+    // The customer-quotable number is unique per org, enforced not assumed.
+    displayUq: uniqueIndex('support_case_org_number_uq')
+        .on(table.orgId, table.displayNumber)
+        .where(sql `deleted_at IS NULL`),
+}));
+/**
+ * Per-org allocator for `support_cases.display_number`.
+ *
+ * Postgres sequences are global and cannot be per-org without one sequence per
+ * tenant, so the counter is a row: `UPDATE … SET next_number = next_number + 1
+ * RETURNING next_number` inside the case-insert transaction, where the row lock
+ * serialises concurrent opens within one org.
+ *
+ * @table support_case_counters
+ */
+export const supportCaseCounter = pgTable('support_case_counters', {
+    orgId: varchar('org_id', { length: 255 }).primaryKey(),
+    nextNumber: integer('next_number').default(1).notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+});
+/**
+ * The members authorised to open support cases — what the per-contact price
+ * bills for.
+ *
+ * The COUNT is capped against effective `supportContacts` at designation time,
+ * in the same shape seats are capped at invite time. `supportContacts` has a
+ * tier base of 0 everywhere, so an org with no support add-on has no contacts
+ * and cannot open a case: the paywall is a quota check, not a feature flag.
+ *
+ * @table support_contacts
+ */
+export const supportContact = pgTable('support_contacts', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    userId: text('user_id').notNull(),
+    // Who nominated them. Audit-worthy: a contact is a paid, privileged slot.
+    designatedBy: text('designated_by').notNull(),
+    designatedAt: timestamp('designated_at', { withTimezone: true }).defaultNow().notNull(),
+    /**
+     * Whether this contact is UPGRADED to premium — 24×7 coverage, the 8-hour
+     * any-day target, and the only contacts who may declare `urgent` severity.
+     *
+     * A column on the contact rather than a level on the org, because that is what
+     * the upgrade model means: an account holds one BASELINE level covering every
+     * contact and upgrades a subset. Without this the `supportPremiumContacts` cap
+     * would grant a quota over nothing — there would be no way for any contact to
+     * actually be premium, and the case-open path would have nothing to read.
+     *
+     * The case freezes the OPENING CONTACT's effective level at open
+     * (`support_case.level`), so flipping this later never changes the promise on
+     * a case already raised.
+     */
+    isPremium: boolean('is_premium').default(false).notNull(),
+    isActive: boolean('is_active').default(true).notNull(),
+    revokedAt: timestamp('revoked_at', { withTimezone: true }),
+    revokedBy: text('revoked_by'),
+}, (table) => ({
+    // One live designation per (org, user). Partial so a revoked row does not
+    // block re-designating the same person later.
+    orgUserUq: uniqueIndex('support_contact_org_user_uq')
+        .on(table.orgId, table.userId)
+        .where(sql `is_active = true`),
+    // Counting an org's live contacts against its cap, and listing them for the
+    // tenant-side owner picker.
+    orgActiveIdx: index('support_contact_org_active_idx').on(table.orgId, table.isActive),
+    // The premium SUBSET, counted against `supportPremiumContacts` on every
+    // upgrade. Partial on both flags because that is the only question asked of
+    // it: how many live contacts in this scope are upgraded.
+    orgPremiumIdx: index('support_contact_org_premium_idx')
+        .on(table.orgId, table.userId)
+        .where(sql `is_active = true AND is_premium = true`),
+}));
+/**
+ * Canned staff replies — a shared library of answers the desk reuses.
+ *
+ * SYSTEM-WIDE, not per-tenant, and deliberately so: these are the vendor's own
+ * wording for recurring questions, authored once and used across every
+ * customer. There is no `org_id` because scoping them per tenant would be the
+ * opposite of the point — the value is that the answer to "how do I rotate a
+ * service key" is written well once rather than retyped badly fifty times.
+ *
+ * That also means RLS does not apply: every row is visible to the staff who can
+ * reach the queue, and to nobody else. The routes are system-admin gated on
+ * both read and write for exactly that reason.
+ *
+ * Soft-deleted rather than removed, because a retired template is still the
+ * explanation of what a past reply said.
+ *
+ * @table support_canned_responses
+ */
+export const supportCannedResponse = pgTable('support_canned_responses', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    /** Short label the picker lists. */
+    title: varchar('title', { length: 200 }).notNull(),
+    body: text('body').notNull(),
+    createdBy: text('created_by').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedBy: text('updated_by').notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+    isActive: boolean('is_active').default(true).notNull(),
+}, (table) => ({
+    // The picker's only query: live templates, alphabetical.
+    activeTitleIdx: index('support_canned_active_idx').on(table.isActive, table.title),
+}));
+/**
+ * CSAT: the customer's verdict on a closed case.
+ *
+ * A COLUMN SET on the case rather than its own table, unlike notes. The reason
+ * is cardinality, not convenience: a case has many notes and exactly one
+ * satisfaction rating, so a table would buy an extra join and a uniqueness
+ * constraint to enforce what a column gets for free.
+ *
+ * Why it matters more here than in most products: the thing being SOLD is a
+ * response time, and first-response latency only measures whether we answered
+ * fast — not whether the answer was any good. A desk can hit every target and
+ * still be bad at support, and without this nothing in the system would notice.
+ *
+ * @table support_cases (columns)
+ */
+/**
+ * Staff-only notes on a case.
+ *
+ * A SEPARATE TABLE rather than a flag on `messages`, and the reason is the
+ * failure mode: `messages` is read through one shared visibility predicate
+ * (`buildMessageConditions`), so a flag means every read path that forgets the
+ * extra condition leaks an internal note to the tenant. A separate table cannot
+ * leak by omission — it has to be joined deliberately.
+ *
+ * @table support_case_notes
+ */
+export const supportCaseNote = pgTable('support_case_notes', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    caseId: uuid('case_id').notNull(),
+    // Denormalised so a note can never be served without its tenant scope.
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    content: text('content').notNull(),
+    createdBy: text('created_by').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    isActive: boolean('is_active').default(true).notNull(),
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+}, (table) => ({
+    caseIdx: index('support_case_note_case_idx').on(table.caseId, table.isActive),
+}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"support.js","sourceRoot":"","sources":["../../../src/database/schema/support.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { boolean, integer, varchar, pgTable, text, timestamp, uuid, index, uniqueIndex } from 'drizzle-orm/pg-core';\n\n/**\n * The WORKFLOW axis of a support case.\n *\n * `messages` already carries the conversation — identity, threading, priority,\n * per-participant read state, attachments and soft-delete. What it has no column\n * for is workflow: status, ownership, resolution and the response clock. That is\n * this table, one row per case, joined to the conversation by `threadId`.\n *\n * Keeping them apart rather than widening `messages` is deliberate: `messages`\n * also carries announcements and ordinary conversations, which have no status,\n * no assignee and no response target. Six nullable columns on every announcement\n * row to describe a state announcements cannot be in is how a table stops\n * meaning one thing.\n *\n * @table support_cases\n */\nexport const supportCase = pgTable('support_cases', {\n  // Internal key. NOT the case identity — see `threadId`.\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  /**\n   * The root `messages.id` of the thread, and the CANONICAL case identity.\n   *\n   * The convention already exists: readers walk `threadId === root.id` and\n   * `update-message.ts` uses `updated.threadId ?? updated.id` for exactly this\n   * \"the root is the identity\" idea. So case identity falls out of threading the\n   * support path rather than being a new concept.\n   */\n  threadId: uuid('thread_id').notNull(),\n\n  // The TENANT org. Never the system org — a case is always about one tenant,\n  // even though the system org is the other participant in the thread.\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n\n  /**\n   * Per-org, customer-quotable case number (rendered `ACME-1042`).\n   *\n   * A bare UUID is not something anyone reads out on a call or puts in an email\n   * subject, and a GLOBAL sequence would disclose total case volume to every\n   * customer. Allocated from `support_case_counters` in the same transaction as\n   * the insert; `support_case_org_number_uq` is the backstop that turns a\n   * bypassed counter into a failed insert rather than two cases sharing the one\n   * identifier customers quote back.\n   */\n  displayNumber: integer('display_number').notNull(),\n\n  // open | awaiting_support | awaiting_customer | resolved | closed\n  status: varchar('status', { length: 32 }).default('open').notNull(),\n\n  // Set by the opener; re-rankable by staff. Self-selected severity is why staff\n  // re-ranking is in v1: otherwise the tenant chooses the target they are owed.\n  severity: varchar('severity', { length: 16 }).default('normal').notNull(),\n\n  /**\n   * The support level held when the case was OPENED, frozen onto the case.\n   *\n   * Frozen deliberately: a customer who downgrades mid-case should still get the\n   * response they bought when they opened it. Resolving entitlement live would\n   * change an open case's promise underneath the person waiting on it.\n   */\n  level: varchar('level', { length: 32 }).notNull(),\n\n  /** True when the case was opened by spending a one-time incident rather than\n   *  against a contact seat. Recorded so \"how many incidents were actually\n   *  used\" is answerable from the cases, not only from a balance delta. */\n  openedWithIncident: boolean('opened_with_incident').default(false).notNull(),\n\n  // --- the two owners, which move independently. NEITHER is `createdBy`.\n  /** STAFF owner — a system-org actor. `null` is legitimate: it is the unowned\n   *  pool, and how \"I cannot take this\" is said without a pseudo-assignee. */\n  assignedTo: text('assigned_to'),\n  /** TENANT owner — the designated contact currently responsible. Distinct from\n   *  `createdBy`, which is the immutable audit fact of who raised the case:\n   *  mutating that to express \"someone else owns this now\" would destroy the\n   *  only record of who actually opened it. */\n  tenantContact: text('tenant_contact'),\n\n  // --- the response clock\n  /**\n   * When the first response is DUE, computed once at open and never recomputed.\n   *\n   * Frozen for the same reason `level` is: a change to the working week or the\n   * holiday list must not move a promise already made to a customer. Three\n   * things follow from storing it rather than deriving it per read:\n   *   - the staff queue orders by a real deadline with no calendar arithmetic\n   *     per row;\n   *   - the standard/priority breach check becomes CONTRACTUAL, where a\n   *     wall-clock quantile cannot express a business-day target at all (a\n   *     priority case raised at 17:01 on a Friday is not late until Monday\n   *     evening, ~79 wall-clock hours later);\n   *   - a level with no published target, and a case opened while the calendar\n   *     was misconfigured, are both simply NULL — no deadline rather than a\n   *     wrong one.\n   */\n  responseDueAt: timestamp('response_due_at', { withTimezone: true }),\n  /** First staff reply. THE measured number — the response target is sold on it. */\n  firstResponseAt: timestamp('first_response_at', { withTimezone: true }),\n  /**\n   * CSAT, 1–5, set by the TENANT once the case is closed. Null = not rated,\n   * which is the usual state and must stay distinguishable from a bad rating.\n   *\n   * Lives here rather than in its own table because a case has exactly one\n   * rating — a table would buy a join and a uniqueness constraint to enforce\n   * what a column gets for free. First-response latency says whether we\n   * answered fast; this is the only thing that says whether the answer helped,\n   * and a desk can hit every target while being bad at support.\n   */\n  satisfaction: integer('satisfaction'),\n  /** Optional free text with the rating. Capped at the route. */\n  satisfactionComment: text('satisfaction_comment'),\n  satisfactionAt: timestamp('satisfaction_at', { withTimezone: true }),\n  /** Set when status → `awaiting_customer`; the pause anchor. */\n  awaitingSince: timestamp('awaiting_since', { withTimezone: true }),\n  /**\n   * Accumulated seconds spent waiting on the customer.\n   *\n   * Ageing subtracts this. Without it a case we answered in an hour, where the\n   * tenant replied four days later, reads as a four-day case — and the metric\n   * Phase 2b exists to produce reports a number no customer will accept. An\n   * accumulator plus the current anchor survives a case bouncing between states\n   * repeatedly, which replaying status history would not.\n   */\n  awaitingTotalSeconds: integer('awaiting_total_seconds').default(0).notNull(),\n\n  closedAt: timestamp('closed_at', { withTimezone: true }),\n  closedBy: text('closed_by'),\n\n  // Audit + soft-delete, same shape as `messages`.\n  createdBy: text('created_by').default(SYSTEM_ORG_ID).notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedBy: text('updated_by').default(SYSTEM_ORG_ID).notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n  isActive: boolean('is_active').default(true).notNull(),\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  /**\n   * THE queue query: every open case across ALL tenants, oldest first.\n   *\n   * The one query shape with no org predicate to narrow it, so it is also the\n   * only one that scans. Partial because the queue never asks about closed\n   * cases — which are most of the table within a month. Mirrors\n   * `message_purge_idx`, which is partial for the same reason.\n   */\n  queueIdx: index('support_case_queue_idx')\n    .on(table.createdAt)\n    .where(sql`status IN ('open', 'awaiting_support') AND deleted_at IS NULL`),\n\n  /**\n   * The on-call sweep's only query: premium cases whose first-response target is\n   * approaching with nothing stamped yet.\n   *\n   * PARTIAL because the tick runs every five minutes forever and the rows it\n   * wants are a tiny, shrinking fraction of the table — unanswered premium\n   * cases. Without it every tick is a scan, and it is the one query with no org\n   * predicate to narrow it.\n   *\n   * `level` and NOT `is_premium`: that column lives on support_CONTACTS and\n   * marks an upgraded contact, while a case freezes the opening contact's\n   * effective level at open. The case's own promise is its `level`, so\n   * upgrading a contact later must not move a deadline already published to a\n   * customer.\n   */\n  responseDueIdx: index('support_case_response_due_idx')\n    .on(table.responseDueAt)\n    .where(sql`level = 'support_premium' AND first_response_at IS NULL AND deleted_at IS NULL`),\n\n  // A tenant listing its own cases.\n  orgStatusIdx: index('support_case_org_status_idx').on(table.orgId, table.status),\n  // The rolling-window case count behind the FAIR-USE allowance: how many cases\n  // this account raised in the last N days. Leading `org_id` because the count\n  // is always scoped to an account subtree, then `created_at` so the window is a\n  // range scan rather than a filter over every case the org ever raised.\n  orgCreatedIdx: index('support_case_org_created_idx').on(table.orgId, table.createdAt),\n\n  // \"What am I on the hook for\", one engineer.\n  assigneeIdx: index('support_case_assigned_idx')\n    .on(table.assignedTo, table.status)\n    .where(sql`assigned_to IS NOT NULL`),\n\n  // \"My cases\" for a contact, AND the lookup that finds a departing contact's\n  // open cases so they can be reassigned instead of orphaned.\n  tenantContactIdx: index('support_case_tenant_contact_idx')\n    .on(table.tenantContact, table.status)\n    .where(sql`tenant_contact IS NOT NULL`),\n\n  // Case identity, reached from any message in the thread.\n  threadUq: uniqueIndex('support_case_thread_uq').on(table.threadId),\n\n  // The customer-quotable number is unique per org, enforced not assumed.\n  displayUq: uniqueIndex('support_case_org_number_uq')\n    .on(table.orgId, table.displayNumber)\n    .where(sql`deleted_at IS NULL`),\n}));\n\n/**\n * Per-org allocator for `support_cases.display_number`.\n *\n * Postgres sequences are global and cannot be per-org without one sequence per\n * tenant, so the counter is a row: `UPDATE … SET next_number = next_number + 1\n * RETURNING next_number` inside the case-insert transaction, where the row lock\n * serialises concurrent opens within one org.\n *\n * @table support_case_counters\n */\nexport const supportCaseCounter = pgTable('support_case_counters', {\n  orgId: varchar('org_id', { length: 255 }).primaryKey(),\n  nextNumber: integer('next_number').default(1).notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n});\n\n/**\n * The members authorised to open support cases — what the per-contact price\n * bills for.\n *\n * The COUNT is capped against effective `supportContacts` at designation time,\n * in the same shape seats are capped at invite time. `supportContacts` has a\n * tier base of 0 everywhere, so an org with no support add-on has no contacts\n * and cannot open a case: the paywall is a quota check, not a feature flag.\n *\n * @table support_contacts\n */\nexport const supportContact = pgTable('support_contacts', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  userId: text('user_id').notNull(),\n  // Who nominated them. Audit-worthy: a contact is a paid, privileged slot.\n  designatedBy: text('designated_by').notNull(),\n  designatedAt: timestamp('designated_at', { withTimezone: true }).defaultNow().notNull(),\n  /**\n   * Whether this contact is UPGRADED to premium — 24×7 coverage, the 8-hour\n   * any-day target, and the only contacts who may declare `urgent` severity.\n   *\n   * A column on the contact rather than a level on the org, because that is what\n   * the upgrade model means: an account holds one BASELINE level covering every\n   * contact and upgrades a subset. Without this the `supportPremiumContacts` cap\n   * would grant a quota over nothing — there would be no way for any contact to\n   * actually be premium, and the case-open path would have nothing to read.\n   *\n   * The case freezes the OPENING CONTACT's effective level at open\n   * (`support_case.level`), so flipping this later never changes the promise on\n   * a case already raised.\n   */\n  isPremium: boolean('is_premium').default(false).notNull(),\n  isActive: boolean('is_active').default(true).notNull(),\n  revokedAt: timestamp('revoked_at', { withTimezone: true }),\n  revokedBy: text('revoked_by'),\n}, (table) => ({\n  // One live designation per (org, user). Partial so a revoked row does not\n  // block re-designating the same person later.\n  orgUserUq: uniqueIndex('support_contact_org_user_uq')\n    .on(table.orgId, table.userId)\n    .where(sql`is_active = true`),\n  // Counting an org's live contacts against its cap, and listing them for the\n  // tenant-side owner picker.\n  orgActiveIdx: index('support_contact_org_active_idx').on(table.orgId, table.isActive),\n  // The premium SUBSET, counted against `supportPremiumContacts` on every\n  // upgrade. Partial on both flags because that is the only question asked of\n  // it: how many live contacts in this scope are upgraded.\n  orgPremiumIdx: index('support_contact_org_premium_idx')\n    .on(table.orgId, table.userId)\n    .where(sql`is_active = true AND is_premium = true`),\n}));\n\n/**\n * Canned staff replies — a shared library of answers the desk reuses.\n *\n * SYSTEM-WIDE, not per-tenant, and deliberately so: these are the vendor's own\n * wording for recurring questions, authored once and used across every\n * customer. There is no `org_id` because scoping them per tenant would be the\n * opposite of the point — the value is that the answer to \"how do I rotate a\n * service key\" is written well once rather than retyped badly fifty times.\n *\n * That also means RLS does not apply: every row is visible to the staff who can\n * reach the queue, and to nobody else. The routes are system-admin gated on\n * both read and write for exactly that reason.\n *\n * Soft-deleted rather than removed, because a retired template is still the\n * explanation of what a past reply said.\n *\n * @table support_canned_responses\n */\nexport const supportCannedResponse = pgTable('support_canned_responses', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  /** Short label the picker lists. */\n  title: varchar('title', { length: 200 }).notNull(),\n  body: text('body').notNull(),\n  createdBy: text('created_by').notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedBy: text('updated_by').notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n  isActive: boolean('is_active').default(true).notNull(),\n}, (table) => ({\n  // The picker's only query: live templates, alphabetical.\n  activeTitleIdx: index('support_canned_active_idx').on(table.isActive, table.title),\n}));\n\n/**\n * CSAT: the customer's verdict on a closed case.\n *\n * A COLUMN SET on the case rather than its own table, unlike notes. The reason\n * is cardinality, not convenience: a case has many notes and exactly one\n * satisfaction rating, so a table would buy an extra join and a uniqueness\n * constraint to enforce what a column gets for free.\n *\n * Why it matters more here than in most products: the thing being SOLD is a\n * response time, and first-response latency only measures whether we answered\n * fast — not whether the answer was any good. A desk can hit every target and\n * still be bad at support, and without this nothing in the system would notice.\n *\n * @table support_cases (columns)\n */\n\n/**\n * Staff-only notes on a case.\n *\n * A SEPARATE TABLE rather than a flag on `messages`, and the reason is the\n * failure mode: `messages` is read through one shared visibility predicate\n * (`buildMessageConditions`), so a flag means every read path that forgets the\n * extra condition leaks an internal note to the tenant. A separate table cannot\n * leak by omission — it has to be joined deliberately.\n *\n * @table support_case_notes\n */\nexport const supportCaseNote = pgTable('support_case_notes', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  caseId: uuid('case_id').notNull(),\n  // Denormalised so a note can never be served without its tenant scope.\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  content: text('content').notNull(),\n  createdBy: text('created_by').notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  isActive: boolean('is_active').default(true).notNull(),\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n}, (table) => ({\n  caseIdx: index('support_case_note_case_idx').on(table.caseId, table.isActive),\n}));\n\n/** TypeScript types representing database rows */\nexport type SupportCase = typeof supportCase.$inferSelect;\nexport type SupportCaseInsert = typeof supportCase.$inferInsert;\nexport type SupportCaseUpdate = Partial<Omit<SupportCaseInsert, 'id' | 'createdAt' | 'createdBy' | 'orgId' | 'threadId' | 'displayNumber'>>;\n\nexport type SupportCaseCounter = typeof supportCaseCounter.$inferSelect;\n\nexport type SupportContact = typeof supportContact.$inferSelect;\nexport type SupportContactInsert = typeof supportContact.$inferInsert;\n\nexport type SupportCaseNote = typeof supportCaseNote.$inferSelect;\nexport type SupportCaseNoteInsert = typeof supportCaseNote.$inferInsert;\n"]}

package/lib/database/tenancy.d.ts

@@ -64,11 +64,13 @@ export interface TenantContext {
      * the AsyncLocalStorage store — the store is per-request, so this cannot leak
      * between requests.
      *
-     * SCOPE: this covers reads AFTER a write IN THE SAME REQUEST. It does NOT
-     * cover the next request (POST then a page reload issuing GET). That needs
-     * shared state — see the cross-request section of
-     * docs/plans/postgres-read-write-split.md — and must be settled before call
-     * sites are migrated in bulk.
+     * SCOPE: this flag covers reads AFTER a write IN THE SAME REQUEST. The
+     * next-request case (POST, then a page reload issuing GET) needs shared state
+     * and is handled by api-server's `write-pin.ts`, which remembers in Redis
+     * that an org wrote recently and PRE-SETS this same flag on the next
+     * request's context — one mechanism and one code path rather than two. It
+     * fails closed (no Redis, or an unreachable one, routes reads to the primary)
+     * and short-circuits entirely when no read replica is configured.
      */
     mayHaveWritten?: boolean;
 }

package/lib/database/tenancy.js

@@ -247,4 +247,4 @@ export async function withTenantTxRead(fn) {
         return fn(tx);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenancy.js","sourceRoot":"","sources":["../../src/database/tenancy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Tenant-context plumbing for Postgres row-level security.\n *\n * Background: postgres-init.sql installs RLS policies on every user-data\n * table that consult two session GUCs — `app.org_id` and `app.is_sysadmin`.\n * Every tenant table is `FORCE ROW LEVEL SECURITY`, so the policies enforce\n * even for the (owning) connection user — a query against one must run inside a\n * transaction that has SET LOCAL'd both GUCs or it returns zero rows for\n * non-sysadmins (and may fail to write for any caller). The cross-org plugin\n * ecosystem catalog tables carry a permissive app-role policy instead.\n *\n * This module is the seam.\n *\n *   1. `tenantContext` (AsyncLocalStorage) carries `{orgId, isSuperAdmin}`\n *      down the call chain without prop-drilling. Set once at the request\n *      boundary; readable from anywhere.\n *\n *   2. `withTenantTx(fn)` opens a transaction, SET LOCAL's both GUCs from\n *      the surrounding context, then invokes `fn(tx)`. Services migrate one\n *      at a time by wrapping their existing drizzle calls in this helper —\n *      `db.select().from(...)` becomes `withTenantTx(tx => tx.select().from(...))`.\n *\n *   3. `runWithTenantContext(ctx, fn)` is the Express-middleware-side\n *      bookend that establishes the AsyncLocalStorage scope for the request.\n *\n * Migration order:\n *   - First adopters: newly-written services (dashboard, alert-destination)\n *     where the change is mechanical.\n *   - Then high-write services (plugin, pipeline). Soak each one before\n *     flipping the underlying table to FORCE.\n *   - admin_audit_log uses a sysadmin-only policy — sysadmin paths must\n *     also set `app.is_sysadmin = 'true'` or they'll lose access to it.\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport { createLogger, emitCounter, envInt } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { db } from './postgres-connection.js';\nimport { getReadDb, getReadPool } from './read-connection.js';\nimport { lagVerdict, maybeSampleLag, type LagVerdict } from './read-lag.js';\n\nconst logger = createLogger('tenant-context');\n\n/**\n * Behavior when `withTenantTx` is invoked outside any `runWithTenantContext`\n * scope. The effective default is fail-fast ('strict') in production so a\n * missing tenant scope surfaces at the bad call site instead of silently\n * running with empty RLS GUCs; outside production it defaults to 'warn' so\n * un-audited dev/test paths keep working but log an actionable trace. An\n * explicit RLS_CONTEXT_MODE env override always wins.\n *\n * 'silent' is kept for tests and scripts that intentionally enter the DB\n * without context (e.g. integration test setup that runs as the connection\n * owner before any tenant is provisioned).\n */\ntype ContextMode = 'silent' | 'warn' | 'strict';\nfunction getContextMode(): ContextMode {\n  const raw = process.env.RLS_CONTEXT_MODE?.toLowerCase();\n  if (raw === 'silent' || raw === 'warn' || raw === 'strict') return raw;\n  // No explicit override: fail-fast in production, warn everywhere else.\n  return process.env.NODE_ENV === 'production' ? 'strict' : 'warn';\n}\n\n/**\n * Per-statement server-side timeout (ms) applied INSIDE every `withTenantTx`\n * transaction, next to the RLS GUCs. `withTenantTx` is the real query path for\n * all RLS/CRUD reads and writes, so this is where the DB-side guard belongs (the\n * old `Connection.transaction` wrapper that set it is dead — see\n * postgres-connection.ts). Bounds a runaway query so it can't hold a pooled\n * connection open indefinitely. Env-configurable via `DB_STATEMENT_TIMEOUT_MS`\n * (default 30s); set to `0` to disable the timeout.\n */\nfunction getStatementTimeoutMs(): number {\n  const ms = envInt('DB_STATEMENT_TIMEOUT_MS', 30_000);\n  return ms >= 0 ? ms : 30_000;\n}\n\nexport interface TenantContext {\n  /** Caller's org. Undefined for un-authenticated / system jobs. */\n  orgId?: string;\n  /** Caller's user id. Not used for RLS — Postgres policies are org-grained,\n   *  with no per-user session GUC — but carried so app-layer predicates with a\n   *  PER-USER rung (pipeline templates' `private` visibility) can resolve \"who\n   *  is asking\" on paths that have nowhere to pass it, notably CrudService's\n   *  `writeConditions`. Absent for system jobs, which is the fail-closed case:\n   *  no viewer ⇒ no private rows. */\n  userId?: string;\n  /** True when the caller is a sysadmin (system-org admin). Bypasses RLS\n   *  policies via the sysadmin-bypass branch in `current_is_sysadmin()`. */\n  isSuperAdmin: boolean;\n  /** Org → team hierarchy: the caller's active-org parent (present only when the\n   *  active org is a team). Not used for RLS; carried so downstream side-effects\n   *  (e.g. entity-event compliance eval) can honor parent `propagateToChildren`\n   *  rules without a request in scope. */\n  parentOrgId?: string;\n  /**\n   * Set once this request has opened a PRIMARY transaction, i.e. may have\n   * written. Subsequent `withTenantTxRead` calls in the same request then go to\n   * the primary too, so a handler cannot read its own write off a replica that\n   * has not replayed it yet.\n   *\n   * Deliberately set by `withTenantTx` rather than by write call sites: that\n   * path is the one that can write, it needs no per-call-site discipline, and\n   * being wrong in this direction only costs a replica hit. Mutated in place on\n   * the AsyncLocalStorage store — the store is per-request, so this cannot leak\n   * between requests.\n   *\n   * SCOPE: this covers reads AFTER a write IN THE SAME REQUEST. It does NOT\n   * cover the next request (POST then a page reload issuing GET). That needs\n   * shared state — see the cross-request section of\n   * docs/plans/postgres-read-write-split.md — and must be settled before call\n   * sites are migrated in bulk.\n   */\n  mayHaveWritten?: boolean;\n}\n\n/**\n * Per-request tenant context. Populated by Express middleware once the JWT\n * is validated; consumed by `withTenantTx` and any helper that needs to\n * know \"who is the caller\" without re-deriving from the request object.\n */\nexport const tenantContext = new AsyncLocalStorage<TenantContext>();\n\n/**\n * Run `fn` inside the given tenant scope. The AsyncLocalStorage scope\n * survives across async boundaries (Promises, setTimeout, etc.), so any\n * `withTenantTx` call inside `fn` — directly or through any depth of\n * async helpers — picks up `ctx`.\n *\n * Wrap `next()` from an Express middleware to establish per-request scope:\n *\n *     app.use((req, res, next) => {\n *       runWithTenantContext({ orgId, isSuperAdmin }, () => next());\n *     });\n */\nexport function runWithTenantContext<T>(ctx: TenantContext, fn: () => T): T {\n  return tenantContext.run(ctx, fn);\n}\n\n/** Read the current tenant context. Returns undefined outside an\n *  `runWithTenantContext` scope (e.g. background workers, migrations). */\nexport function getTenantContext(): TenantContext | undefined {\n  return tenantContext.getStore();\n}\n\n/**\n * Open a transaction with RLS GUCs SET LOCAL from the current\n * AsyncLocalStorage tenant context, then invoke `fn(tx)`.\n *\n * - When called outside a tenant scope (e.g. from a background job that\n *   doesn't have a caller identity), the transaction is opened with both\n *   GUCs cleared — RLS policies will return zero rows on FORCE'd tables.\n *   Callers that need a sysadmin-equivalent scope should wrap themselves in\n *   `runWithTenantContext({ isSuperAdmin: true }, …)` explicitly.\n *\n * - Uses `set_config(key, value, true)` (the boolean = `is_local`, i.e.\n *   transaction-scoped). Equivalent to `SET LOCAL` but takes the value as\n *   a parameter, which is what we want — Drizzle's `sql` template binds the\n *   value safely so an attacker-controlled `orgId` can't escape the quoting.\n *\n * - Returns whatever `fn` returns; throws whatever `fn` throws (Drizzle\n *   handles the COMMIT/ROLLBACK for us).\n */\nexport async function withTenantTx<T>(\n  fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>,\n  /**\n   * INTERNAL. Whether this transaction should mark the request as possibly\n   * having written. Always true for a real caller; only withTenantTxRead's\n   * primary-fallback path passes false, because a read that lands on the\n   * primary has not written. See the comment at the assignment below.\n   */\n  markWritten = true,\n): Promise<T> {\n  const ctx = tenantContext.getStore();\n\n  if (!ctx) {\n    // Surface the bug instead of silently SET'ing empty GUCs. The default\n    // mode ('warn') logs an actionable trace so the bad call site is easy\n    // to find; production deployments that have finished the audit can set\n    // RLS_CONTEXT_MODE=strict to fail-fast at the call site (better stack\n    // trace than the Postgres \"permission denied\" that would otherwise\n    // surface from FORCE'd RLS).\n    const mode = getContextMode();\n    if (mode === 'strict') {\n      throw new Error(\n        'withTenantTx called outside a tenant scope. Wrap your handler/worker '\n        + 'in runWithTenantContext({ orgId, isSuperAdmin }, ...) before invoking '\n        + 'any service that touches RLS-enforced tables.',\n      );\n    }\n    if (mode === 'warn') {\n      // Include a synthetic stack so the offending call site is in the log.\n      logger.warn('withTenantTx called outside a tenant scope; RLS GUCs will be empty', {\n        stack: new Error('tenant-context missing').stack,\n      });\n    }\n  }\n\n  const orgId = ctx?.orgId ?? '';\n  const isSuperAdmin = ctx?.isSuperAdmin ? 'true' : 'false';\n\n  const statementTimeoutMs = getStatementTimeoutMs();\n\n  // This transaction runs on the PRIMARY and may write, so any later read in\n  // this request must stay on the primary too. Set before the transaction opens\n  // rather than after it commits: a read issued concurrently from the same\n  // handler would otherwise race the flag.\n  //\n  // `markWritten: false` is passed ONLY by withTenantTxRead's fallback path,\n  // and it is not an optimisation — without it the feature defeats itself. That\n  // path runs on the primary, so it would set this flag, which api-server's\n  // middleware reads after the response to set the Redis write pin. A purely\n  // READ-ONLY request would therefore pin its whole org to the primary for the\n  // pin TTL, every time, and since reads fall back whenever no replica is\n  // configured (the shipping default) every org would be permanently pinned.\n  // The flag means \"this request may have WRITTEN\", not \"this request touched\n  // the primary\", and the difference is the whole read-offload benefit.\n  if (ctx && markWritten) ctx.mayHaveWritten = true;\n\n  return db.transaction(async (tx) => {\n    // Set every transaction-scoped GUC in a SINGLE round-trip. `set_config()`\n    // returns its value, so multiple calls compose in one SELECT rather than a\n    // round-trip per GUC — each a network hop that taxes the shared PgBouncer\n    // pool on the hot path. `true`\n    // = is_local (SET LOCAL semantics: auto-released on COMMIT/ROLLBACK). The\n    // driver binds the values as parameters, so a hostile org_id can't break out\n    // of the GUC syntax.\n    //\n    // The statement_timeout GUC bounds a runaway query so it can't hold a pooled\n    // connection open indefinitely (`SET LOCAL statement_timeout = $1` is rejected\n    // by Postgres, hence set_config with a bound ms value). Included in the same\n    // statement when enabled (>0), dropped entirely when disabled (0).\n    if (statementTimeoutMs > 0) {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`,\n      );\n    } else {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true)`,\n      );\n    }\n    return fn(tx);\n  });\n}\n\n/**\n * Why a read was or was not sent to the replica. Returned by\n * {@link chooseReadTarget} so the decision is inspectable — and testable\n * without a replica, which matters because the test substrate (PGlite) has no\n * replication at all.\n */\nexport type ReadTargetReason =\n  /** No replica configured, or DB_READ_ENABLED=false. */\n  | 'no-replica'\n  /** This request already opened a primary transaction and may have written. */\n  | 'may-have-written'\n  /**\n   * No tenant context. A caller outside `runWithTenantContext` has no org to\n   * scope RLS by and no watermark to compare, so it goes to the primary — where\n   * `withTenantTx`'s RLS_CONTEXT_MODE guard logs or throws. Routed to a replica\n   * instead, the same call would set `app.org_id = ''` with no diagnostic at all.\n   */\n  | 'no-context'\n  /**\n   * A replica exists but its replay lag is beyond `DB_READ_MAX_LAG_SECONDS`,\n   * or is UNKNOWN (no sample yet, the sample failed, or the cached sample has\n   * gone stale). Unknown and lagging are the same decision on purpose: the\n   * circuit fails closed.\n   */\n  | 'replica-lagging'\n  /** Routed to the replica. */\n  | 'replica';\n\nexport interface ReadTarget {\n  useReplica: boolean;\n  reason: ReadTargetReason;\n}\n\n/**\n * Decide where a read-only transaction should run.\n *\n * Pure and side-effect free on purpose: this is the whole of the routing\n * policy, and it is the part worth testing. Replication itself cannot be\n * reproduced locally, so the testable unit is the DECISION, not the lag.\n *\n * The bias is deliberate: anything uncertain resolves to the primary. A read\n * served by the primary is merely less efficient; a read served by a stale\n * replica is a user-visible bug nobody can reproduce.\n */\n/** Everything about the replica that is not request-specific. */\nexport interface ReadReplicaHealth {\n  /** A replica pool exists AND `DB_READ_ENABLED` is not false. */\n  available: boolean;\n  /** The lag circuit's verdict. `unknown` is treated exactly like `lagging`. */\n  lag: LagVerdict;\n}\n\n/**\n * Where a read goes, and why.\n *\n * SYSTEM gates are checked before REQUEST gates, which matters only for the\n * explanation — but the explanation is what an operator reads when asking why\n * the replica is idle, and \"my request wrote\" is a far less useful answer than\n * \"the standby is 40 seconds behind\".\n */\nexport function chooseReadTarget(ctx: TenantContext | undefined, health: ReadReplicaHealth): ReadTarget {\n  if (!health.available) return { useReplica: false, reason: 'no-replica' };\n  if (health.lag !== 'ok') return { useReplica: false, reason: 'replica-lagging' };\n  if (!ctx) return { useReplica: false, reason: 'no-context' };\n  if (ctx.mayHaveWritten) return { useReplica: false, reason: 'may-have-written' };\n  return { useReplica: true, reason: 'replica' };\n}\n\n/**\n * Open a READ-ONLY transaction with the same RLS GUCs `withTenantTx` sets,\n * routed to the replica when {@link chooseReadTarget} allows it.\n *\n * `SET TRANSACTION READ ONLY` is the guardrail, not decoration. Several queries\n * in this codebase look like reads at the call site and are not —\n * `SELECT … FOR UPDATE` in crud-service's setDefault, `pg_advisory_xact_lock`\n * in pipeline-service and compliance's subscription-service. Routed to a\n * standby those fail anyway; declaring the transaction read-only makes them\n * fail HERE, with a clear message, including on the primary where they would\n * otherwise succeed and quietly acquire a lock the caller did not intend.\n *\n * Falls back to the primary transparently, so a caller never has to ask\n * whether a replica exists.\n */\nexport async function withTenantTxRead<T>(\n  fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>,\n): Promise<T> {\n  const ctx = tenantContext.getStore();\n  const readDb = getReadDb();\n  const readPool = getReadPool();\n\n  // Keep the lag sample warm. Fire-and-forget by design: it is debounced to\n  // DB_READ_LAG_SAMPLE_MS, never throws, and must not add a round-trip to this\n  // read. The first read of a process therefore routes to the primary (no\n  // sample yet) and warms the circuit for the ones after it.\n  if (readPool) void maybeSampleLag(readPool);\n\n  const target = chooseReadTarget(ctx, { available: readDb !== null, lag: lagVerdict() });\n  emitCounter('postgres_read_routed_total', { target: target.useReplica ? 'replica' : 'primary', reason: target.reason });\n\n  if (!target.useReplica) {\n    // Primary path: identical semantics to withTenantTx, plus the read-only\n    // declaration so an accidental write is caught on every target — including\n    // the ones that will never have a replica.\n    return withTenantTx(async (tx) => {\n      await tx.execute(sql`SET TRANSACTION READ ONLY`);\n      return fn(tx);\n    }, /* markWritten */ false);\n  }\n\n  // Non-null by construction: chooseReadTarget only returns useReplica for a\n  // ctx that exists. Read the GUCs off it directly rather than defaulting to\n  // '' — a default here would silently re-open the hole that 'no-context'\n  // closes, because an empty app.org_id is a VALID-looking RLS scope.\n  const { orgId } = ctx!;\n  const isSuperAdmin = ctx!.isSuperAdmin ? 'true' : 'false';\n  const statementTimeoutMs = getStatementTimeoutMs();\n\n  return readDb!.transaction(async (tx) => {\n    await tx.execute(sql`SET TRANSACTION READ ONLY`);\n    if (statementTimeoutMs > 0) {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`,\n      );\n    } else {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true)`,\n      );\n    }\n    return fn(tx);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenancy.js","sourceRoot":"","sources":["../../src/database/tenancy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Tenant-context plumbing for Postgres row-level security.\n *\n * Background: postgres-init.sql installs RLS policies on every user-data\n * table that consult two session GUCs — `app.org_id` and `app.is_sysadmin`.\n * Every tenant table is `FORCE ROW LEVEL SECURITY`, so the policies enforce\n * even for the (owning) connection user — a query against one must run inside a\n * transaction that has SET LOCAL'd both GUCs or it returns zero rows for\n * non-sysadmins (and may fail to write for any caller). The cross-org plugin\n * ecosystem catalog tables carry a permissive app-role policy instead.\n *\n * This module is the seam.\n *\n *   1. `tenantContext` (AsyncLocalStorage) carries `{orgId, isSuperAdmin}`\n *      down the call chain without prop-drilling. Set once at the request\n *      boundary; readable from anywhere.\n *\n *   2. `withTenantTx(fn)` opens a transaction, SET LOCAL's both GUCs from\n *      the surrounding context, then invokes `fn(tx)`. Services migrate one\n *      at a time by wrapping their existing drizzle calls in this helper —\n *      `db.select().from(...)` becomes `withTenantTx(tx => tx.select().from(...))`.\n *\n *   3. `runWithTenantContext(ctx, fn)` is the Express-middleware-side\n *      bookend that establishes the AsyncLocalStorage scope for the request.\n *\n * Migration order:\n *   - First adopters: newly-written services (dashboard, alert-destination)\n *     where the change is mechanical.\n *   - Then high-write services (plugin, pipeline). Soak each one before\n *     flipping the underlying table to FORCE.\n *   - admin_audit_log uses a sysadmin-only policy — sysadmin paths must\n *     also set `app.is_sysadmin = 'true'` or they'll lose access to it.\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport { createLogger, emitCounter, envInt } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { db } from './postgres-connection.js';\nimport { getReadDb, getReadPool } from './read-connection.js';\nimport { lagVerdict, maybeSampleLag, type LagVerdict } from './read-lag.js';\n\nconst logger = createLogger('tenant-context');\n\n/**\n * Behavior when `withTenantTx` is invoked outside any `runWithTenantContext`\n * scope. The effective default is fail-fast ('strict') in production so a\n * missing tenant scope surfaces at the bad call site instead of silently\n * running with empty RLS GUCs; outside production it defaults to 'warn' so\n * un-audited dev/test paths keep working but log an actionable trace. An\n * explicit RLS_CONTEXT_MODE env override always wins.\n *\n * 'silent' is kept for tests and scripts that intentionally enter the DB\n * without context (e.g. integration test setup that runs as the connection\n * owner before any tenant is provisioned).\n */\ntype ContextMode = 'silent' | 'warn' | 'strict';\nfunction getContextMode(): ContextMode {\n  const raw = process.env.RLS_CONTEXT_MODE?.toLowerCase();\n  if (raw === 'silent' || raw === 'warn' || raw === 'strict') return raw;\n  // No explicit override: fail-fast in production, warn everywhere else.\n  return process.env.NODE_ENV === 'production' ? 'strict' : 'warn';\n}\n\n/**\n * Per-statement server-side timeout (ms) applied INSIDE every `withTenantTx`\n * transaction, next to the RLS GUCs. `withTenantTx` is the real query path for\n * all RLS/CRUD reads and writes, so this is where the DB-side guard belongs (the\n * old `Connection.transaction` wrapper that set it is dead — see\n * postgres-connection.ts). Bounds a runaway query so it can't hold a pooled\n * connection open indefinitely. Env-configurable via `DB_STATEMENT_TIMEOUT_MS`\n * (default 30s); set to `0` to disable the timeout.\n */\nfunction getStatementTimeoutMs(): number {\n  const ms = envInt('DB_STATEMENT_TIMEOUT_MS', 30_000);\n  return ms >= 0 ? ms : 30_000;\n}\n\nexport interface TenantContext {\n  /** Caller's org. Undefined for un-authenticated / system jobs. */\n  orgId?: string;\n  /** Caller's user id. Not used for RLS — Postgres policies are org-grained,\n   *  with no per-user session GUC — but carried so app-layer predicates with a\n   *  PER-USER rung (pipeline templates' `private` visibility) can resolve \"who\n   *  is asking\" on paths that have nowhere to pass it, notably CrudService's\n   *  `writeConditions`. Absent for system jobs, which is the fail-closed case:\n   *  no viewer ⇒ no private rows. */\n  userId?: string;\n  /** True when the caller is a sysadmin (system-org admin). Bypasses RLS\n   *  policies via the sysadmin-bypass branch in `current_is_sysadmin()`. */\n  isSuperAdmin: boolean;\n  /** Org → team hierarchy: the caller's active-org parent (present only when the\n   *  active org is a team). Not used for RLS; carried so downstream side-effects\n   *  (e.g. entity-event compliance eval) can honor parent `propagateToChildren`\n   *  rules without a request in scope. */\n  parentOrgId?: string;\n  /**\n   * Set once this request has opened a PRIMARY transaction, i.e. may have\n   * written. Subsequent `withTenantTxRead` calls in the same request then go to\n   * the primary too, so a handler cannot read its own write off a replica that\n   * has not replayed it yet.\n   *\n   * Deliberately set by `withTenantTx` rather than by write call sites: that\n   * path is the one that can write, it needs no per-call-site discipline, and\n   * being wrong in this direction only costs a replica hit. Mutated in place on\n   * the AsyncLocalStorage store — the store is per-request, so this cannot leak\n   * between requests.\n   *\n   * SCOPE: this flag covers reads AFTER a write IN THE SAME REQUEST. The\n   * next-request case (POST, then a page reload issuing GET) needs shared state\n   * and is handled by api-server's `write-pin.ts`, which remembers in Redis\n   * that an org wrote recently and PRE-SETS this same flag on the next\n   * request's context — one mechanism and one code path rather than two. It\n   * fails closed (no Redis, or an unreachable one, routes reads to the primary)\n   * and short-circuits entirely when no read replica is configured.\n   */\n  mayHaveWritten?: boolean;\n}\n\n/**\n * Per-request tenant context. Populated by Express middleware once the JWT\n * is validated; consumed by `withTenantTx` and any helper that needs to\n * know \"who is the caller\" without re-deriving from the request object.\n */\nexport const tenantContext = new AsyncLocalStorage<TenantContext>();\n\n/**\n * Run `fn` inside the given tenant scope. The AsyncLocalStorage scope\n * survives across async boundaries (Promises, setTimeout, etc.), so any\n * `withTenantTx` call inside `fn` — directly or through any depth of\n * async helpers — picks up `ctx`.\n *\n * Wrap `next()` from an Express middleware to establish per-request scope:\n *\n *     app.use((req, res, next) => {\n *       runWithTenantContext({ orgId, isSuperAdmin }, () => next());\n *     });\n */\nexport function runWithTenantContext<T>(ctx: TenantContext, fn: () => T): T {\n  return tenantContext.run(ctx, fn);\n}\n\n/** Read the current tenant context. Returns undefined outside an\n *  `runWithTenantContext` scope (e.g. background workers, migrations). */\nexport function getTenantContext(): TenantContext | undefined {\n  return tenantContext.getStore();\n}\n\n/**\n * Open a transaction with RLS GUCs SET LOCAL from the current\n * AsyncLocalStorage tenant context, then invoke `fn(tx)`.\n *\n * - When called outside a tenant scope (e.g. from a background job that\n *   doesn't have a caller identity), the transaction is opened with both\n *   GUCs cleared — RLS policies will return zero rows on FORCE'd tables.\n *   Callers that need a sysadmin-equivalent scope should wrap themselves in\n *   `runWithTenantContext({ isSuperAdmin: true }, …)` explicitly.\n *\n * - Uses `set_config(key, value, true)` (the boolean = `is_local`, i.e.\n *   transaction-scoped). Equivalent to `SET LOCAL` but takes the value as\n *   a parameter, which is what we want — Drizzle's `sql` template binds the\n *   value safely so an attacker-controlled `orgId` can't escape the quoting.\n *\n * - Returns whatever `fn` returns; throws whatever `fn` throws (Drizzle\n *   handles the COMMIT/ROLLBACK for us).\n */\nexport async function withTenantTx<T>(\n  fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>,\n  /**\n   * INTERNAL. Whether this transaction should mark the request as possibly\n   * having written. Always true for a real caller; only withTenantTxRead's\n   * primary-fallback path passes false, because a read that lands on the\n   * primary has not written. See the comment at the assignment below.\n   */\n  markWritten = true,\n): Promise<T> {\n  const ctx = tenantContext.getStore();\n\n  if (!ctx) {\n    // Surface the bug instead of silently SET'ing empty GUCs. The default\n    // mode ('warn') logs an actionable trace so the bad call site is easy\n    // to find; production deployments that have finished the audit can set\n    // RLS_CONTEXT_MODE=strict to fail-fast at the call site (better stack\n    // trace than the Postgres \"permission denied\" that would otherwise\n    // surface from FORCE'd RLS).\n    const mode = getContextMode();\n    if (mode === 'strict') {\n      throw new Error(\n        'withTenantTx called outside a tenant scope. Wrap your handler/worker '\n        + 'in runWithTenantContext({ orgId, isSuperAdmin }, ...) before invoking '\n        + 'any service that touches RLS-enforced tables.',\n      );\n    }\n    if (mode === 'warn') {\n      // Include a synthetic stack so the offending call site is in the log.\n      logger.warn('withTenantTx called outside a tenant scope; RLS GUCs will be empty', {\n        stack: new Error('tenant-context missing').stack,\n      });\n    }\n  }\n\n  const orgId = ctx?.orgId ?? '';\n  const isSuperAdmin = ctx?.isSuperAdmin ? 'true' : 'false';\n\n  const statementTimeoutMs = getStatementTimeoutMs();\n\n  // This transaction runs on the PRIMARY and may write, so any later read in\n  // this request must stay on the primary too. Set before the transaction opens\n  // rather than after it commits: a read issued concurrently from the same\n  // handler would otherwise race the flag.\n  //\n  // `markWritten: false` is passed ONLY by withTenantTxRead's fallback path,\n  // and it is not an optimisation — without it the feature defeats itself. That\n  // path runs on the primary, so it would set this flag, which api-server's\n  // middleware reads after the response to set the Redis write pin. A purely\n  // READ-ONLY request would therefore pin its whole org to the primary for the\n  // pin TTL, every time, and since reads fall back whenever no replica is\n  // configured (the shipping default) every org would be permanently pinned.\n  // The flag means \"this request may have WRITTEN\", not \"this request touched\n  // the primary\", and the difference is the whole read-offload benefit.\n  if (ctx && markWritten) ctx.mayHaveWritten = true;\n\n  return db.transaction(async (tx) => {\n    // Set every transaction-scoped GUC in a SINGLE round-trip. `set_config()`\n    // returns its value, so multiple calls compose in one SELECT rather than a\n    // round-trip per GUC — each a network hop that taxes the shared PgBouncer\n    // pool on the hot path. `true`\n    // = is_local (SET LOCAL semantics: auto-released on COMMIT/ROLLBACK). The\n    // driver binds the values as parameters, so a hostile org_id can't break out\n    // of the GUC syntax.\n    //\n    // The statement_timeout GUC bounds a runaway query so it can't hold a pooled\n    // connection open indefinitely (`SET LOCAL statement_timeout = $1` is rejected\n    // by Postgres, hence set_config with a bound ms value). Included in the same\n    // statement when enabled (>0), dropped entirely when disabled (0).\n    if (statementTimeoutMs > 0) {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`,\n      );\n    } else {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true)`,\n      );\n    }\n    return fn(tx);\n  });\n}\n\n/**\n * Why a read was or was not sent to the replica. Returned by\n * {@link chooseReadTarget} so the decision is inspectable — and testable\n * without a replica, which matters because the test substrate (PGlite) has no\n * replication at all.\n */\nexport type ReadTargetReason =\n  /** No replica configured, or DB_READ_ENABLED=false. */\n  | 'no-replica'\n  /** This request already opened a primary transaction and may have written. */\n  | 'may-have-written'\n  /**\n   * No tenant context. A caller outside `runWithTenantContext` has no org to\n   * scope RLS by and no watermark to compare, so it goes to the primary — where\n   * `withTenantTx`'s RLS_CONTEXT_MODE guard logs or throws. Routed to a replica\n   * instead, the same call would set `app.org_id = ''` with no diagnostic at all.\n   */\n  | 'no-context'\n  /**\n   * A replica exists but its replay lag is beyond `DB_READ_MAX_LAG_SECONDS`,\n   * or is UNKNOWN (no sample yet, the sample failed, or the cached sample has\n   * gone stale). Unknown and lagging are the same decision on purpose: the\n   * circuit fails closed.\n   */\n  | 'replica-lagging'\n  /** Routed to the replica. */\n  | 'replica';\n\nexport interface ReadTarget {\n  useReplica: boolean;\n  reason: ReadTargetReason;\n}\n\n/**\n * Decide where a read-only transaction should run.\n *\n * Pure and side-effect free on purpose: this is the whole of the routing\n * policy, and it is the part worth testing. Replication itself cannot be\n * reproduced locally, so the testable unit is the DECISION, not the lag.\n *\n * The bias is deliberate: anything uncertain resolves to the primary. A read\n * served by the primary is merely less efficient; a read served by a stale\n * replica is a user-visible bug nobody can reproduce.\n */\n/** Everything about the replica that is not request-specific. */\nexport interface ReadReplicaHealth {\n  /** A replica pool exists AND `DB_READ_ENABLED` is not false. */\n  available: boolean;\n  /** The lag circuit's verdict. `unknown` is treated exactly like `lagging`. */\n  lag: LagVerdict;\n}\n\n/**\n * Where a read goes, and why.\n *\n * SYSTEM gates are checked before REQUEST gates, which matters only for the\n * explanation — but the explanation is what an operator reads when asking why\n * the replica is idle, and \"my request wrote\" is a far less useful answer than\n * \"the standby is 40 seconds behind\".\n */\nexport function chooseReadTarget(ctx: TenantContext | undefined, health: ReadReplicaHealth): ReadTarget {\n  if (!health.available) return { useReplica: false, reason: 'no-replica' };\n  if (health.lag !== 'ok') return { useReplica: false, reason: 'replica-lagging' };\n  if (!ctx) return { useReplica: false, reason: 'no-context' };\n  if (ctx.mayHaveWritten) return { useReplica: false, reason: 'may-have-written' };\n  return { useReplica: true, reason: 'replica' };\n}\n\n/**\n * Open a READ-ONLY transaction with the same RLS GUCs `withTenantTx` sets,\n * routed to the replica when {@link chooseReadTarget} allows it.\n *\n * `SET TRANSACTION READ ONLY` is the guardrail, not decoration. Several queries\n * in this codebase look like reads at the call site and are not —\n * `SELECT … FOR UPDATE` in crud-service's setDefault, `pg_advisory_xact_lock`\n * in pipeline-service and compliance's subscription-service. Routed to a\n * standby those fail anyway; declaring the transaction read-only makes them\n * fail HERE, with a clear message, including on the primary where they would\n * otherwise succeed and quietly acquire a lock the caller did not intend.\n *\n * Falls back to the primary transparently, so a caller never has to ask\n * whether a replica exists.\n */\nexport async function withTenantTxRead<T>(\n  fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>,\n): Promise<T> {\n  const ctx = tenantContext.getStore();\n  const readDb = getReadDb();\n  const readPool = getReadPool();\n\n  // Keep the lag sample warm. Fire-and-forget by design: it is debounced to\n  // DB_READ_LAG_SAMPLE_MS, never throws, and must not add a round-trip to this\n  // read. The first read of a process therefore routes to the primary (no\n  // sample yet) and warms the circuit for the ones after it.\n  if (readPool) void maybeSampleLag(readPool);\n\n  const target = chooseReadTarget(ctx, { available: readDb !== null, lag: lagVerdict() });\n  emitCounter('postgres_read_routed_total', { target: target.useReplica ? 'replica' : 'primary', reason: target.reason });\n\n  if (!target.useReplica) {\n    // Primary path: identical semantics to withTenantTx, plus the read-only\n    // declaration so an accidental write is caught on every target — including\n    // the ones that will never have a replica.\n    return withTenantTx(async (tx) => {\n      await tx.execute(sql`SET TRANSACTION READ ONLY`);\n      return fn(tx);\n    }, /* markWritten */ false);\n  }\n\n  // Non-null by construction: chooseReadTarget only returns useReplica for a\n  // ctx that exists. Read the GUCs off it directly rather than defaulting to\n  // '' — a default here would silently re-open the hole that 'no-context'\n  // closes, because an empty app.org_id is a VALID-looking RLS scope.\n  const { orgId } = ctx!;\n  const isSuperAdmin = ctx!.isSuperAdmin ? 'true' : 'false';\n  const statementTimeoutMs = getStatementTimeoutMs();\n\n  return readDb!.transaction(async (tx) => {\n    await tx.execute(sql`SET TRANSACTION READ ONLY`);\n    if (statementTimeoutMs > 0) {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`,\n      );\n    } else {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true)`,\n      );\n    }\n    return fn(tx);\n  });\n}\n"]}

package/lib/index.d.ts

@@ -30,17 +30,21 @@ export * from './api/crud-service.js';
 export { parseSemver, compareSemverParts, compareSemver, isVersionRange, satisfiesVersionSpec, semverOrderBy, } from './api/semver-range.js';
 export { normalizeQuery, searchPublicListings, listPublicCategories, getPublicListing, getPublicListedVersion, listPublicReviews, listPublicListingsForSitemap, type DirectoryTrustTier, type DirectorySort, DIRECTORY_SORTS, DIRECTORY_TIERS, type DirectorySearchParams, type ReviewSort, REVIEW_SORTS, type PublicListingRow, } from './api/public-directory.js';
 export { listEnabledAlertDestinations, type NotificationDestination, } from './api/alert-destinations.js';
+export { anonymizeReviewsByAuthor } from './api/ecosystem-privacy.js';
+export { openSupportCase, findCaseByThread, listQueue, listOrgCases, stampFirstResponse, setCaseStatus, setCaseSeverity, assignCase, assignCases, closeCases, transferCaseToContact, openCasesForContact, SUPPORT_CASE_STATUSES, QUEUE_STATUSES, type SupportCaseStatus, type OpenCaseInput, countActiveSupportContacts, listActiveSupportContacts, isSupportContact, designateSupportContact, revokeSupportContact, countPremiumSupportContacts, isPremiumSupportContact, setSupportContactPremium, countCasesInWindow, rateCase, addCaseNote, listCaseNotes, deleteCaseNote, type SupportCaseNote, listCannedResponses, createCannedResponse, updateCannedResponse, deleteCannedResponse, type CannedResponse, listCasesDueForPage, } from './api/support-cases.js';
 export { policyOf, effectiveConsumptionPolicy, applyPolicyUpdate, type ConsumptionPolicy, DEFAULT_CONSUMPTION_POLICY, } from './api/plugin-consumption-policy.js';
 export { advisoryRangeCovers, advisoryRangeProblem, advisoriesCovering, blockingAdvisories, } from './api/plugin-advisories.js';
-export { listingBlock, implicitInstallRange, installAdmits, scopeOrgIds, installModeFor, drizzleListingSource, resolveListingReference, listedVersionWarnings, listedPluginRecord, loadOrgInstallContext, orgListingStates, resolvableListings, type ResolutionRefusal, type ResolutionScope, type ListingDataSource, type ListingResolved, type OrgListingState, } from './api/plugin-resolution.js';
+export { listingBlock, implicitInstallRange, installAdmits, scopeOrgIds, installModeFor, drizzleListingSource, resolveListingReference, listedVersionWarnings, listedPluginRecord, loadOrgInstallContext, orgListingStates, resolvableListings, type ResolutionRefusal, type ResolutionScope, type ListingDataSource, type ListingResolved, type OrgListingState, vulnUpgradeAvailableWarning, type VulnUpgradeAvailableWarning, } from './api/plugin-resolution.js';
+export { findVersionReferences, distinctPipelines, versionReferencedPredicate, orgImageDigestsInUse, type VersionReferenceTarget, type VersionReference, } from './api/version-references.js';
+export { declaredResolution, recordStepLookup, pipelineStepLookups, declaredPipelinesForPlugin, stageAndStep, stepLabelOf, type DeclaredStepInput, type DeclaredStepPlugin, type DeclaredStepResolution, type StepLookupRecord, type DeclaredPipelineRef, } from './api/pipeline-step-resolution.js';
 export { runSoftDeletePurge, createSoftDeletePurgeScheduler, type PurgeableEntity, } from './api/soft-delete-sweep.js';
-export { type BuildHealth, type DoraLevel, type DoraMetrics, type DoraOptions, type DoraTrendPoint, type IncidentListItem, type ReportingSettings, type IncidentTestResult, type IngestCaller, type IngestMetric, type LastDeployedCommit, } from './api/reporting-service.js';
+export { type BuildHealth, type DoraLevel, type DoraMetrics, type DoraOptions, type DoraTrendPoint, type DeploymentOutcomeWrite, type IncidentListItem, type IncidentState, type IncidentWrite, type ReportingSettings, type IncidentTestResult, type IngestCaller, type IngestMetric, type LastDeployedCommit, } from './api/reporting-service.js';
 export { upsertDeployments, applyDeployOutcome, correlateIncident, isDeployEvent, leadTimeGapOf, type DeployCandidate, } from './api/reporting/deploy-rollup.js';
 export { rebuildDay, runRollupPass, rollupSettleHours, rollupBatchDays, utcDayStart, } from './api/reporting/daily-rollup.js';
 export { classifyFailure, isTeamActionable, FAILURE_CATEGORY_LABELS, } from './api/reporting/failure-classifier.js';
 export { getPipelineBreakdown, getFailureAnalysis, getStagePerformance, getResourceConsumption, getPromotionView, getOutdatedPlugins, getPluginVulnerabilities, getAdoption, type AnalyticsScope, type PipelineBreakdownRow, type FailureCategoryRow, type StagePerformanceRow, type ResourceRow, type PromotionRow, type OutdatedPluginRow, type VulnerabilityRow, type AdoptionSummary, } from './api/reporting/analytics-queries.js';
 export { evaluateNeedsAttention, thresholdsFrom, DEFAULT_THRESHOLDS, type NeedsAttentionThresholds, type AttentionFinding, type AttentionItem, type AttentionInput, type AttentionRuleId, } from './api/reporting/needs-attention.js';
-export { replacePipelineResolution, refreshLatestForPlugin, upsertExposures, closeFixedExposures, openExposures, triageExposure, lapsedAcceptances, versionGap, type ResolvedStep, type ExposureInput, type VersionGap, } from './api/reporting/plugin-exposure.js';
+export { replacePipelineResolution, refreshLatestForPlugin, upsertExposures, closeFixedExposures, closePipelineExposures, closeVersionExposures, reconcilePipelineExposures, syncVersionExposures, pipelinesOnVersion, exposureFromScan, liveExposurePredicate, openExposures, triageExposure, lapsedAcceptances, pipelineExposures, exposureById, activeAcceptances, acceptanceKey, reopenLapsedAcceptances, versionGap, type PipelineExposure, type TriageDecision, type PipelineAcceptances, type LapsedAcceptance, type ResolvedStep, type ExposureInput, type ExposureStep, type ExposureCounts, type LiveVersion, type PipelineOnVersion, type PluginVersionRef, type ScanState, type VersionGap, } from './api/reporting/plugin-exposure.js';
 export { resolvePeriod, resolvePeriodByLabel, rejectUnreportablePeriod, nextPeriodBoundary, completePeriodsSince, registerSection, getSection, allSections, sectionIds, REPORT_TEMPLATE_SPECS, getTemplate, composeSnapshot, LOW_SAMPLE_THRESHOLD, REPORT_FEATURE_SUBSTITUTES, renderReportHtml, reportFileName, trendSentence, type ReportHtmlInput, type ResolvedPeriod, type PeriodRejection, type SectionSpec, type SectionContext, type SectionDataSource, type TemplateSpec, type ReportSnapshot, type ComposedSection, type DataQualityNote, type ComposeOptions, type TrendDirection, StakeholderReportStore, stakeholderReportStore, hashToken, mintToken, DEFAULT_SHARE_LINK_TTL_DAYS, MAX_SHARE_LINK_TTL_DAYS, MAX_BOUNCES, VERIFICATION_TTL_MS, type CreateDefinitionInput, type UpdateDefinitionInput, type MintedShareLink, type ResolvedShareLink, } from './api/reporting/stakeholder/index.js';
 export { type PluginRuntimeFilter, type PluginRuntimeStats, ReportingService, reportingService, } from './api/reporting-service.js';
 export { type PluginFilter, type PipelineFilter, type PipelineTemplateFilter, type MessageFilter, type CompliancePolicyFilter, type ComplianceRuleFilter, type ComplianceExemptionFilter, type ComplianceAuditFilter, type ComplianceScanFilter, } from './core/query-filters.js';