@pipeline-builder/pipeline-data 4.1.23 → 4.1.25

package/lib/database/schema/reporting-stakeholder.js

@@ -0,0 +1,251 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Stakeholder reports — scheduled, manager-facing summaries a lead developer
+ * composes, reviews and publishes.
+ *
+ * Four tables, and the reason each exists:
+ *
+ *  - `report_definitions` — the saved "what and when". Reporting was entirely
+ *    on-demand before this: the dashboard picked a from/to and nothing could be
+ *    saved, scheduled or kept.
+ *  - `report_runs` — the FROZEN snapshot of one period's output. This is the load
+ *    bearing table. The retention sweep purges raw `pipeline_events` by tier, so
+ *    without a snapshot last quarter's report cannot be regenerated once its
+ *    events are gone — and a manager who read a number on Monday must see the same
+ *    number on Friday.
+ *  - `report_share_links` — expiring, revocable read-only links, because the
+ *    managers a report is for usually have no platform account.
+ *  - `report_recipients` — per-org delivery addresses, with verification and
+ *    bounce state. Recipient emails are PII and the org owns the list, not the
+ *    definition, so one lead's list is reusable and one unsubscribe is honoured
+ *    everywhere.
+ *
+ * Every table is org-scoped with RLS + soft-delete, mirroring postgres-init.sql
+ * (which is what actually deploys; `schema-reflection.test.ts` keeps the two in
+ * lock-step, name for name).
+ */
+import { sql } from 'drizzle-orm';
+import { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, varchar } from 'drizzle-orm/pg-core';
+/** How often a definition produces a report. */
+export const REPORT_CADENCES = ['weekly', 'monthly', 'quarterly'];
+/** The manager-facing templates. Each is a fixed list of section ids. */
+export const REPORT_TEMPLATES = ['weekly_delivery', 'monthly_health', 'quarterly_review'];
+/**
+ * A run's lifecycle. `drafting` → `ready_for_review` → `published`, with `failed`
+ * as a terminal side branch. Nothing reaches a manager before `published`, which
+ * is what makes the lead's approval the gate.
+ */
+export const REPORT_RUN_STATUSES = ['drafting', 'ready_for_review', 'published', 'failed'];
+/**
+ * Why a definition stopped running. Recorded rather than inferred, because the
+ * three causes need different fixes and the lead sees this string: the add-on
+ * lapsed, the owner was deactivated, or the owner lost the permission that let
+ * them author it.
+ */
+export const REPORT_PAUSE_REASONS = ['entitlement', 'owner_inactive', 'permission_lost'];
+/** What a definition reports on. */
+export const REPORT_SCOPE_KINDS = ['org', 'projects', 'rollup'];
+/**
+ * A saved report: what to compute, how often, in whose timezone, and who receives
+ * it.
+ *
+ * @table report_definitions
+ */
+export const reportDefinition = pgTable('report_definitions', {
+    id: varchar('id', { length: 255 }).primaryKey(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    /**
+     * The lead who owns this definition. Runs re-check THIS user's permissions, not
+     * the caller's, because a scheduled run has no caller — so a lead who loses
+     * access stops producing reports rather than keeping a standing grant.
+     */
+    ownerId: text('owner_id').notNull(),
+    name: varchar('name', { length: 200 }).notNull(),
+    template: varchar('template', { length: 40 }).$type().notNull(),
+    /** Section ids, resolved through the section registry at run time. */
+    sections: jsonb('sections').$type().default([]).notNull(),
+    cadence: varchar('cadence', { length: 20 }).$type().notNull(),
+    /** IANA name. Periods are cut in THIS zone, not the database session's. */
+    timezone: varchar('timezone', { length: 64 }).default('UTC').notNull(),
+    weekStart: varchar('week_start', { length: 10 }).default('monday').notNull(),
+    scope: jsonb('scope').$type().notNull(),
+    /** Recipient ids from `report_recipients`, not raw addresses. */
+    recipients: jsonb('recipients').$type().default([]).notNull(),
+    /**
+     * Publish without the lead reviewing. Off by default: the whole point of the
+     * review step is that the data cannot supply the context a manager needs
+     * ("we paused deploys Tuesday for the migration").
+     */
+    autoSend: boolean('auto_send').default(false).notNull(),
+    isActive: boolean('is_active').default(true).notNull(),
+    pausedReason: varchar('paused_reason', { length: 30 }).$type(),
+    nextRunAt: timestamp('next_run_at', { withTimezone: true }),
+    lastRunAt: timestamp('last_run_at', { withTimezone: true }),
+    createdBy: text('created_by').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedBy: text('updated_by'),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
+}, (table) => ({
+    orgIdx: index('report_definition_org_idx').on(table.orgId).where(sql `deleted_at IS NULL`),
+    ownerIdx: index('report_definition_owner_idx').on(table.ownerId).where(sql `deleted_at IS NULL`),
+    // Drives the scheduler's claim scan: the due, live, unpaused definitions only.
+    dueIdx: index('report_definition_due_idx').on(table.nextRunAt)
+        .where(sql `deleted_at IS NULL AND is_active = true`),
+    purgeIdx: index('report_definition_purge_idx').on(table.purgeAfter).where(sql `deleted_at IS NOT NULL`),
+}));
+/**
+ * One period's frozen output.
+ *
+ * @table report_runs
+ */
+export const reportRun = pgTable('report_runs', {
+    id: varchar('id', { length: 255 }).primaryKey(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    definitionId: varchar('definition_id', { length: 255 }).notNull(),
+    /** Inclusive period start, exclusive end — both instants, in UTC. */
+    periodStart: timestamp('period_start', { withTimezone: true }).notNull(),
+    periodEnd: timestamp('period_end', { withTimezone: true }).notNull(),
+    /** Human label in the definition's timezone: `2026-W38`, `2026-08`, `2026-Q3`. */
+    periodLabel: varchar('period_label', { length: 20 }).notNull(),
+    /**
+     * Regenerating a period produces version N+1 and supersedes the old row rather
+     * than overwriting it. Late events (the ingest redrives its dead-letter queue
+     * hours later) mean a corrected report is normal — and a manager who already
+     * read v1 must still be able to see exactly what they read.
+     */
+    version: integer('version').default(1).notNull(),
+    status: varchar('status', { length: 20 }).$type().default('drafting').notNull(),
+    /** The computed sections. Survives the raw-event purge — that is the point. */
+    snapshot: jsonb('snapshot').$type(),
+    /** AI-generated executive summary, from the snapshot's numbers only. */
+    aiDraft: text('ai_draft'),
+    /** The lead's own words. The context the data cannot supply. */
+    leadNotes: text('lead_notes'),
+    /**
+     * The ASKS: what the lead needs a decision on, from whom, by when.
+     *
+     * Separate from `leadNotes` because they are the only part of a report with a
+     * recipient and a deadline. Buried in a paragraph of narrative, a request for a
+     * decision reads as commentary and gets no answer — which is the most common way
+     * a status report fails to be worth writing.
+     */
+    asks: jsonb('asks').$type().default([]).notNull(),
+    failureReason: text('failure_reason'),
+    /**
+     * What happened when this run was DELIVERED: counts per channel, and the notes a lead
+     * needs to read ("no outbound email is configured, so 12 recipients were not mailed").
+     *
+     * On the run rather than in a log, because the question it answers is asked days later
+     * and about one specific report: "did the board actually get last month's?" A log line
+     * cannot be shown next to the report, and `leadNotes` cannot hold it — that column is
+     * frozen at publish, which is exactly when delivery happens.
+     */
+    delivery: jsonb('delivery').$type(),
+    publishedBy: text('published_by'),
+    publishedAt: timestamp('published_at', { withTimezone: true }),
+    supersededBy: varchar('superseded_by', { length: 255 }),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
+}, (table) => ({
+    // The idempotency key. A retry, a catch-up pass and a manual backfill can all
+    // ask for the same period; without this they would each insert a row.
+    periodUnique: uniqueIndex('report_run_period_unique')
+        .on(table.definitionId, table.periodStart, table.version),
+    definitionIdx: index('report_run_definition_idx').on(table.definitionId, table.periodStart)
+        .where(sql `deleted_at IS NULL`),
+    orgIdx: index('report_run_org_idx').on(table.orgId).where(sql `deleted_at IS NULL`),
+    purgeIdx: index('report_run_purge_idx').on(table.purgeAfter).where(sql `deleted_at IS NOT NULL`),
+}));
+/**
+ * A read-only, expiring link to one published run.
+ *
+ * @table report_share_links
+ */
+export const reportShareLink = pgTable('report_share_links', {
+    id: varchar('id', { length: 255 }).primaryKey(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    runId: varchar('run_id', { length: 255 }).notNull(),
+    /**
+     * SHA-256 of the token, never the token. The raw value is shown once, at
+     * creation — a stored token is a stored credential for org data that anyone
+     * holding the link can read.
+     */
+    tokenHash: varchar('token_hash', { length: 64 }).notNull(),
+    expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+    revokedAt: timestamp('revoked_at', { withTimezone: true }),
+    revokedBy: text('revoked_by'),
+    /** Redact pipeline/project names in the public view — internal names leak intent. */
+    redactNames: boolean('redact_names').default(false).notNull(),
+    viewCount: integer('view_count').default(0).notNull(),
+    lastViewedAt: timestamp('last_viewed_at', { withTimezone: true }),
+    createdBy: text('created_by').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    // The public route's only lookup: by token hash. Unique so a hash collision
+    // cannot resolve to two runs.
+    tokenUnique: uniqueIndex('report_share_link_token_unique').on(table.tokenHash),
+    runIdx: index('report_share_link_run_idx').on(table.runId),
+    orgIdx: index('report_share_link_org_idx').on(table.orgId),
+}));
+/**
+ * A verified delivery address for one org.
+ *
+ * @table report_recipients
+ */
+export const reportRecipient = pgTable('report_recipients', {
+    id: varchar('id', { length: 255 }).primaryKey(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    email: varchar('email', { length: 320 }).notNull(),
+    displayName: varchar('display_name', { length: 200 }),
+    /**
+     * Set when the recipient confirms by email. Nothing is delivered before this:
+     * otherwise a lead could send org data to any address by typing it.
+     */
+    verifiedAt: timestamp('verified_at', { withTimezone: true }),
+    verificationTokenHash: varchar('verification_token_hash', { length: 64 }),
+    /** Honoured across every definition — an unsubscribe is per person, not per report. */
+    unsubscribedAt: timestamp('unsubscribed_at', { withTimezone: true }),
+    /**
+     * The recipient's stable unsubscribe nonce, minted once with the row.
+     *
+     * STORED IN THE CLEAR, unlike every other token in this file, and the difference is
+     * what it authorizes. A share-link token grants READ ACCESS to an org's report, so it
+     * is only ever kept as a hash; this one authorizes exactly one self-limiting action —
+     * "stop emailing this address" — so the worst a database read buys an attacker is the
+     * ability to make the product send less mail.
+     *
+     * It has to be readable because every report email rebuilds the link, and a hash
+     * cannot be turned back into the URL. The alternative, a signed URL, would be
+     * invalidated by the default EPHEMERAL service key on every restart, silently breaking
+     * the unsubscribe link in every report already sitting in a manager's mailbox — which
+     * is the one failure here that has a regulator attached to it.
+     */
+    unsubscribeToken: varchar('unsubscribe_token', { length: 64 }),
+    bounceCount: integer('bounce_count').default(0).notNull(),
+    lastBounceAt: timestamp('last_bounce_at', { withTimezone: true }),
+    /** Set when an admin approved an address outside the allowed domains. */
+    approvedBy: text('approved_by'),
+    createdBy: text('created_by').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
+}, (table) => ({
+    // One row per address per org, so re-adding a recipient reuses its verification
+    // and unsubscribe state rather than resetting them.
+    orgEmailUnique: uniqueIndex('report_recipient_org_email_unique').on(table.orgId, table.email),
+    orgIdx: index('report_recipient_org_idx').on(table.orgId).where(sql `deleted_at IS NULL`),
+    purgeIdx: index('report_recipient_purge_idx').on(table.purgeAfter).where(sql `deleted_at IS NOT NULL`),
+    // The unsubscribe link's only lookup. Unique so one token can never resolve to two
+    // addresses.
+    unsubTokenUnique: uniqueIndex('report_recipient_unsub_token_unique').on(table.unsubscribeToken)
+        .where(sql `unsubscribe_token IS NOT NULL`),
+}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reporting-stakeholder.js","sourceRoot":"","sources":["../../../src/database/schema/reporting-stakeholder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Stakeholder reports — scheduled, manager-facing summaries a lead developer\n * composes, reviews and publishes.\n *\n * Four tables, and the reason each exists:\n *\n *  - `report_definitions` — the saved \"what and when\". Reporting was entirely\n *    on-demand before this: the dashboard picked a from/to and nothing could be\n *    saved, scheduled or kept.\n *  - `report_runs` — the FROZEN snapshot of one period's output. This is the load\n *    bearing table. The retention sweep purges raw `pipeline_events` by tier, so\n *    without a snapshot last quarter's report cannot be regenerated once its\n *    events are gone — and a manager who read a number on Monday must see the same\n *    number on Friday.\n *  - `report_share_links` — expiring, revocable read-only links, because the\n *    managers a report is for usually have no platform account.\n *  - `report_recipients` — per-org delivery addresses, with verification and\n *    bounce state. Recipient emails are PII and the org owns the list, not the\n *    definition, so one lead's list is reusable and one unsubscribe is honoured\n *    everywhere.\n *\n * Every table is org-scoped with RLS + soft-delete, mirroring postgres-init.sql\n * (which is what actually deploys; `schema-reflection.test.ts` keeps the two in\n * lock-step, name for name).\n */\n\nimport { sql } from 'drizzle-orm';\nimport { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, varchar } from 'drizzle-orm/pg-core';\n\n/** How often a definition produces a report. */\nexport const REPORT_CADENCES = ['weekly', 'monthly', 'quarterly'] as const;\nexport type ReportCadence = (typeof REPORT_CADENCES)[number];\n\n/** The manager-facing templates. Each is a fixed list of section ids. */\nexport const REPORT_TEMPLATES = ['weekly_delivery', 'monthly_health', 'quarterly_review'] as const;\nexport type ReportTemplate = (typeof REPORT_TEMPLATES)[number];\n\n/**\n * A run's lifecycle. `drafting` → `ready_for_review` → `published`, with `failed`\n * as a terminal side branch. Nothing reaches a manager before `published`, which\n * is what makes the lead's approval the gate.\n */\nexport const REPORT_RUN_STATUSES = ['drafting', 'ready_for_review', 'published', 'failed'] as const;\nexport type ReportRunStatus = (typeof REPORT_RUN_STATUSES)[number];\n\n/**\n * Why a definition stopped running. Recorded rather than inferred, because the\n * three causes need different fixes and the lead sees this string: the add-on\n * lapsed, the owner was deactivated, or the owner lost the permission that let\n * them author it.\n */\nexport const REPORT_PAUSE_REASONS = ['entitlement', 'owner_inactive', 'permission_lost'] as const;\nexport type ReportPauseReason = (typeof REPORT_PAUSE_REASONS)[number];\n\n/** What a definition reports on. */\nexport const REPORT_SCOPE_KINDS = ['org', 'projects', 'rollup'] as const;\nexport type ReportScopeKind = (typeof REPORT_SCOPE_KINDS)[number];\n\n/**\n * One thing the lead needs from the people reading the report.\n *\n * `decision` is the request in plain words, `from` names who can answer it, and\n * `by` is when an answer stops being useful. All three matter: an ask with no\n * owner is a wish, and one with no date is never urgent.\n */\nexport interface ReportAsk {\n  decision: string;\n  from?: string;\n  /** ISO date. Not a timestamp — a decision deadline is a day, not a moment. */\n  by?: string;\n}\n\n/** The `scope` JSON: which pipelines a run covers. */\nexport interface ReportScope {\n  kind: ReportScopeKind;\n  /** Project names, when `kind === 'projects'`. Empty for org/rollup. */\n  projects?: string[];\n}\n\n/**\n * A saved report: what to compute, how often, in whose timezone, and who receives\n * it.\n *\n * @table report_definitions\n */\nexport const reportDefinition = pgTable('report_definitions', {\n  id: varchar('id', { length: 255 }).primaryKey(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  /**\n   * The lead who owns this definition. Runs re-check THIS user's permissions, not\n   * the caller's, because a scheduled run has no caller — so a lead who loses\n   * access stops producing reports rather than keeping a standing grant.\n   */\n  ownerId: text('owner_id').notNull(),\n  name: varchar('name', { length: 200 }).notNull(),\n  template: varchar('template', { length: 40 }).$type<ReportTemplate>().notNull(),\n  /** Section ids, resolved through the section registry at run time. */\n  sections: jsonb('sections').$type<string[]>().default([]).notNull(),\n  cadence: varchar('cadence', { length: 20 }).$type<ReportCadence>().notNull(),\n  /** IANA name. Periods are cut in THIS zone, not the database session's. */\n  timezone: varchar('timezone', { length: 64 }).default('UTC').notNull(),\n  weekStart: varchar('week_start', { length: 10 }).default('monday').notNull(),\n  scope: jsonb('scope').$type<ReportScope>().notNull(),\n  /** Recipient ids from `report_recipients`, not raw addresses. */\n  recipients: jsonb('recipients').$type<string[]>().default([]).notNull(),\n  /**\n   * Publish without the lead reviewing. Off by default: the whole point of the\n   * review step is that the data cannot supply the context a manager needs\n   * (\"we paused deploys Tuesday for the migration\").\n   */\n  autoSend: boolean('auto_send').default(false).notNull(),\n  isActive: boolean('is_active').default(true).notNull(),\n  pausedReason: varchar('paused_reason', { length: 30 }).$type<ReportPauseReason>(),\n  nextRunAt: timestamp('next_run_at', { withTimezone: true }),\n  lastRunAt: timestamp('last_run_at', { withTimezone: true }),\n  createdBy: text('created_by').notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedBy: text('updated_by'),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  orgIdx: index('report_definition_org_idx').on(table.orgId).where(sql`deleted_at IS NULL`),\n  ownerIdx: index('report_definition_owner_idx').on(table.ownerId).where(sql`deleted_at IS NULL`),\n  // Drives the scheduler's claim scan: the due, live, unpaused definitions only.\n  dueIdx: index('report_definition_due_idx').on(table.nextRunAt)\n    .where(sql`deleted_at IS NULL AND is_active = true`),\n  purgeIdx: index('report_definition_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n}));\n\n/**\n * One period's frozen output.\n *\n * @table report_runs\n */\nexport const reportRun = pgTable('report_runs', {\n  id: varchar('id', { length: 255 }).primaryKey(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  definitionId: varchar('definition_id', { length: 255 }).notNull(),\n  /** Inclusive period start, exclusive end — both instants, in UTC. */\n  periodStart: timestamp('period_start', { withTimezone: true }).notNull(),\n  periodEnd: timestamp('period_end', { withTimezone: true }).notNull(),\n  /** Human label in the definition's timezone: `2026-W38`, `2026-08`, `2026-Q3`. */\n  periodLabel: varchar('period_label', { length: 20 }).notNull(),\n  /**\n   * Regenerating a period produces version N+1 and supersedes the old row rather\n   * than overwriting it. Late events (the ingest redrives its dead-letter queue\n   * hours later) mean a corrected report is normal — and a manager who already\n   * read v1 must still be able to see exactly what they read.\n   */\n  version: integer('version').default(1).notNull(),\n  status: varchar('status', { length: 20 }).$type<ReportRunStatus>().default('drafting').notNull(),\n  /** The computed sections. Survives the raw-event purge — that is the point. */\n  snapshot: jsonb('snapshot').$type<Record<string, unknown>>(),\n  /** AI-generated executive summary, from the snapshot's numbers only. */\n  aiDraft: text('ai_draft'),\n  /** The lead's own words. The context the data cannot supply. */\n  leadNotes: text('lead_notes'),\n  /**\n   * The ASKS: what the lead needs a decision on, from whom, by when.\n   *\n   * Separate from `leadNotes` because they are the only part of a report with a\n   * recipient and a deadline. Buried in a paragraph of narrative, a request for a\n   * decision reads as commentary and gets no answer — which is the most common way\n   * a status report fails to be worth writing.\n   */\n  asks: jsonb('asks').$type<ReportAsk[]>().default([]).notNull(),\n  failureReason: text('failure_reason'),\n  /**\n   * What happened when this run was DELIVERED: counts per channel, and the notes a lead\n   * needs to read (\"no outbound email is configured, so 12 recipients were not mailed\").\n   *\n   * On the run rather than in a log, because the question it answers is asked days later\n   * and about one specific report: \"did the board actually get last month's?\" A log line\n   * cannot be shown next to the report, and `leadNotes` cannot hold it — that column is\n   * frozen at publish, which is exactly when delivery happens.\n   */\n  delivery: jsonb('delivery').$type<Record<string, unknown>>(),\n  publishedBy: text('published_by'),\n  publishedAt: timestamp('published_at', { withTimezone: true }),\n  supersededBy: varchar('superseded_by', { length: 255 }),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // The idempotency key. A retry, a catch-up pass and a manual backfill can all\n  // ask for the same period; without this they would each insert a row.\n  periodUnique: uniqueIndex('report_run_period_unique')\n    .on(table.definitionId, table.periodStart, table.version),\n  definitionIdx: index('report_run_definition_idx').on(table.definitionId, table.periodStart)\n    .where(sql`deleted_at IS NULL`),\n  orgIdx: index('report_run_org_idx').on(table.orgId).where(sql`deleted_at IS NULL`),\n  purgeIdx: index('report_run_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n}));\n\n/**\n * A read-only, expiring link to one published run.\n *\n * @table report_share_links\n */\nexport const reportShareLink = pgTable('report_share_links', {\n  id: varchar('id', { length: 255 }).primaryKey(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  runId: varchar('run_id', { length: 255 }).notNull(),\n  /**\n   * SHA-256 of the token, never the token. The raw value is shown once, at\n   * creation — a stored token is a stored credential for org data that anyone\n   * holding the link can read.\n   */\n  tokenHash: varchar('token_hash', { length: 64 }).notNull(),\n  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),\n  revokedAt: timestamp('revoked_at', { withTimezone: true }),\n  revokedBy: text('revoked_by'),\n  /** Redact pipeline/project names in the public view — internal names leak intent. */\n  redactNames: boolean('redact_names').default(false).notNull(),\n  viewCount: integer('view_count').default(0).notNull(),\n  lastViewedAt: timestamp('last_viewed_at', { withTimezone: true }),\n  createdBy: text('created_by').notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  // The public route's only lookup: by token hash. Unique so a hash collision\n  // cannot resolve to two runs.\n  tokenUnique: uniqueIndex('report_share_link_token_unique').on(table.tokenHash),\n  runIdx: index('report_share_link_run_idx').on(table.runId),\n  orgIdx: index('report_share_link_org_idx').on(table.orgId),\n}));\n\n/**\n * A verified delivery address for one org.\n *\n * @table report_recipients\n */\nexport const reportRecipient = pgTable('report_recipients', {\n  id: varchar('id', { length: 255 }).primaryKey(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  email: varchar('email', { length: 320 }).notNull(),\n  displayName: varchar('display_name', { length: 200 }),\n  /**\n   * Set when the recipient confirms by email. Nothing is delivered before this:\n   * otherwise a lead could send org data to any address by typing it.\n   */\n  verifiedAt: timestamp('verified_at', { withTimezone: true }),\n  verificationTokenHash: varchar('verification_token_hash', { length: 64 }),\n  /** Honoured across every definition — an unsubscribe is per person, not per report. */\n  unsubscribedAt: timestamp('unsubscribed_at', { withTimezone: true }),\n  /**\n   * The recipient's stable unsubscribe nonce, minted once with the row.\n   *\n   * STORED IN THE CLEAR, unlike every other token in this file, and the difference is\n   * what it authorizes. A share-link token grants READ ACCESS to an org's report, so it\n   * is only ever kept as a hash; this one authorizes exactly one self-limiting action —\n   * \"stop emailing this address\" — so the worst a database read buys an attacker is the\n   * ability to make the product send less mail.\n   *\n   * It has to be readable because every report email rebuilds the link, and a hash\n   * cannot be turned back into the URL. The alternative, a signed URL, would be\n   * invalidated by the default EPHEMERAL service key on every restart, silently breaking\n   * the unsubscribe link in every report already sitting in a manager's mailbox — which\n   * is the one failure here that has a regulator attached to it.\n   */\n  unsubscribeToken: varchar('unsubscribe_token', { length: 64 }),\n  bounceCount: integer('bounce_count').default(0).notNull(),\n  lastBounceAt: timestamp('last_bounce_at', { withTimezone: true }),\n  /** Set when an admin approved an address outside the allowed domains. */\n  approvedBy: text('approved_by'),\n  createdBy: text('created_by').notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // One row per address per org, so re-adding a recipient reuses its verification\n  // and unsubscribe state rather than resetting them.\n  orgEmailUnique: uniqueIndex('report_recipient_org_email_unique').on(table.orgId, table.email),\n  orgIdx: index('report_recipient_org_idx').on(table.orgId).where(sql`deleted_at IS NULL`),\n  purgeIdx: index('report_recipient_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n  // The unsubscribe link's only lookup. Unique so one token can never resolve to two\n  // addresses.\n  unsubTokenUnique: uniqueIndex('report_recipient_unsub_token_unique').on(table.unsubscribeToken)\n    .where(sql`unsubscribe_token IS NOT NULL`),\n}));\n\nexport type ReportDefinition = typeof reportDefinition.$inferSelect;\nexport type ReportDefinitionInsert = typeof reportDefinition.$inferInsert;\nexport type ReportRun = typeof reportRun.$inferSelect;\nexport type ReportRunInsert = typeof reportRun.$inferInsert;\nexport type ReportShareLink = typeof reportShareLink.$inferSelect;\nexport type ReportShareLinkInsert = typeof reportShareLink.$inferInsert;\nexport type ReportRecipient = typeof reportRecipient.$inferSelect;\nexport type ReportRecipientInsert = typeof reportRecipient.$inferInsert;\n"]}

package/lib/index.d.ts

@@ -29,9 +29,18 @@ export * from './api/viewer-context.js';
 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 { 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 { 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 IngestMetric, type PluginRuntimeFilter, type PluginRuntimeStats, ReportingService, reportingService, } from './api/reporting-service.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 { 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 { 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';

package/lib/index.js

@@ -33,13 +33,27 @@ export * from './api/viewer-context.js';
 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, DIRECTORY_SORTS, DIRECTORY_TIERS, REVIEW_SORTS, } from './api/public-directory.js';
+export { listEnabledAlertDestinations, } from './api/alert-destinations.js';
 export { policyOf, effectiveConsumptionPolicy, applyPolicyUpdate, 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, } from './api/plugin-resolution.js';
 // `isSoftDeletePurgeEnabled` is the module's own env gate — `runSoftDeletePurge`
 // and the scheduler already apply it, so callers never ask separately.
 export { runSoftDeletePurge, createSoftDeletePurgeScheduler, } from './api/soft-delete-sweep.js';
+export {} from './api/reporting-service.js';
+// The reporting ANALYTICS layer: the per-deploy rollup written at ingest, the
+// daily rollup every section reads, and the failure classifier that labels what
+// broke (see the modules' own headers for why each is written rather than derived).
+export { upsertDeployments, applyDeployOutcome, correlateIncident, isDeployEvent, leadTimeGapOf, } 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, } from './api/reporting/analytics-queries.js';
+export { evaluateNeedsAttention, thresholdsFrom, DEFAULT_THRESHOLDS, } from './api/reporting/needs-attention.js';
+export { replacePipelineResolution, refreshLatestForPlugin, upsertExposures, closeFixedExposures, openExposures, triageExposure, lapsedAcceptances, versionGap, } from './api/reporting/plugin-exposure.js';
+// The stakeholder-report engine: period resolution, section registry, templates
+// and the composer that freezes a period into a snapshot.
+export { resolvePeriod, resolvePeriodByLabel, rejectUnreportablePeriod, nextPeriodBoundary, completePeriodsSince, registerSection, getSection, allSections, sectionIds, REPORT_TEMPLATE_SPECS, getTemplate, composeSnapshot, LOW_SAMPLE_THRESHOLD, REPORT_FEATURE_SUBSTITUTES, renderReportHtml, reportFileName, trendSentence, StakeholderReportStore, stakeholderReportStore, hashToken, mintToken, DEFAULT_SHARE_LINK_TTL_DAYS, MAX_SHARE_LINK_TTL_DAYS, MAX_BOUNCES, VERIFICATION_TTL_MS, } from './api/reporting/stakeholder/index.js';
 export { ReportingService, reportingService, } from './api/reporting-service.js';
 // Filters
 export {} from './core/query-filters.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * @module @pipeline-builder/pipeline-data\n *\n * Database layer: Drizzle ORM schemas, connection management, and query infrastructure.\n *\n * **Database**\n * - db — shared Drizzle database instance\n * - getConnection, closeConnection — PostgreSQL connection lifecycle with retry logic\n * - schema — Drizzle table definitions (plugins, pipelines, messages, compliance, etc.)\n *\n * **Services**\n * - CrudService — generic base class for multi-tenant CRUD with access control and pagination\n * - ReportingService — aggregate query and reporting base class\n *\n * **Query Builders**\n * - buildPluginConditions, buildPipelineConditions, buildMessageConditions — filter-to-SQL condition builders\n * - buildCompliancePolicyConditions, buildComplianceRuleConditions, etc. — compliance query builders\n * - AccessControlBuilder — row-level access control condition builder\n *\n * **Filters**\n * - PluginFilter, PipelineFilter, MessageFilter — typed filter interfaces\n * - CompliancePolicyFilter, ComplianceRuleFilter, etc. — compliance filter interfaces\n * - drizzleRows, drizzleCount — Drizzle result type helpers\n */\n\n// Database\nexport * from './database/index.js';\n\n// Query builders and services\nexport * from './api/query-builders.js';\nexport {\n  type BaseAccessFilter,\n  AccessControlQueryBuilder,\n} from './api/access-control-builder.js';\nexport * from './api/viewer-context.js';\nexport * from './api/crud-service.js';\nexport {\n  parseSemver,\n  compareSemverParts,\n  compareSemver,\n  isVersionRange,\n  satisfiesVersionSpec,\n  semverOrderBy,\n} from './api/semver-range.js';\nexport {\n  normalizeQuery,\n  searchPublicListings,\n  listPublicCategories,\n  getPublicListing,\n  getPublicListedVersion,\n  listPublicReviews,\n  listPublicListingsForSitemap,\n  type DirectoryTrustTier,\n  type DirectorySort,\n  DIRECTORY_SORTS,\n  DIRECTORY_TIERS,\n  type DirectorySearchParams,\n  type ReviewSort,\n  REVIEW_SORTS,\n  type PublicListingRow,\n} from './api/public-directory.js';\nexport {\n  listEnabledAlertDestinations,\n  type NotificationDestination,\n} from './api/alert-destinations.js';\nexport {\n  policyOf,\n  effectiveConsumptionPolicy,\n  applyPolicyUpdate,\n  type ConsumptionPolicy,\n  DEFAULT_CONSUMPTION_POLICY,\n} from './api/plugin-consumption-policy.js';\nexport {\n  advisoryRangeCovers,\n  advisoryRangeProblem,\n  advisoriesCovering,\n  blockingAdvisories,\n} from './api/plugin-advisories.js';\nexport {\n  listingBlock,\n  implicitInstallRange,\n  installAdmits,\n  scopeOrgIds,\n  installModeFor,\n  drizzleListingSource,\n  resolveListingReference,\n  listedVersionWarnings,\n  listedPluginRecord,\n  loadOrgInstallContext,\n  orgListingStates,\n  resolvableListings,\n  type ResolutionRefusal,\n  type ResolutionScope,\n  type ListingDataSource,\n  type ListingResolved,\n  type OrgListingState,\n} from './api/plugin-resolution.js';\n// `isSoftDeletePurgeEnabled` is the module's own env gate — `runSoftDeletePurge`\n// and the scheduler already apply it, so callers never ask separately.\nexport {\n  runSoftDeletePurge,\n  createSoftDeletePurgeScheduler,\n  type PurgeableEntity,\n} from './api/soft-delete-sweep.js';\nexport {\n  type BuildHealth,\n  type DoraLevel,\n  type DoraMetrics,\n  type DoraOptions,\n  type DoraTrendPoint,\n  type IncidentListItem,\n  type ReportingSettings,\n  type IncidentTestResult,\n  type IngestCaller,\n  type IngestMetric,\n  type LastDeployedCommit,\n} from './api/reporting-service.js';\n\n// The reporting ANALYTICS layer: the per-deploy rollup written at ingest, the\n// daily rollup every section reads, and the failure classifier that labels what\n// broke (see the modules' own headers for why each is written rather than derived).\nexport {\n  upsertDeployments,\n  applyDeployOutcome,\n  correlateIncident,\n  isDeployEvent,\n  leadTimeGapOf,\n  type DeployCandidate,\n} from './api/reporting/deploy-rollup.js';\nexport {\n  rebuildDay,\n  runRollupPass,\n  rollupSettleHours,\n  rollupBatchDays,\n  utcDayStart,\n} from './api/reporting/daily-rollup.js';\nexport {\n  classifyFailure,\n  isTeamActionable,\n  FAILURE_CATEGORY_LABELS,\n} from './api/reporting/failure-classifier.js';\nexport {\n  getPipelineBreakdown,\n  getFailureAnalysis,\n  getStagePerformance,\n  getResourceConsumption,\n  getPromotionView,\n  getOutdatedPlugins,\n  getPluginVulnerabilities,\n  getAdoption,\n  type AnalyticsScope,\n  type PipelineBreakdownRow,\n  type FailureCategoryRow,\n  type StagePerformanceRow,\n  type ResourceRow,\n  type PromotionRow,\n  type OutdatedPluginRow,\n  type VulnerabilityRow,\n  type AdoptionSummary,\n} from './api/reporting/analytics-queries.js';\nexport {\n  evaluateNeedsAttention,\n  thresholdsFrom,\n  DEFAULT_THRESHOLDS,\n  type NeedsAttentionThresholds,\n  type AttentionFinding,\n  type AttentionItem,\n  type AttentionInput,\n  type AttentionRuleId,\n} from './api/reporting/needs-attention.js';\nexport {\n  replacePipelineResolution,\n  refreshLatestForPlugin,\n  upsertExposures,\n  closeFixedExposures,\n  openExposures,\n  triageExposure,\n  lapsedAcceptances,\n  versionGap,\n  type ResolvedStep,\n  type ExposureInput,\n  type VersionGap,\n} from './api/reporting/plugin-exposure.js';\n\n// The stakeholder-report engine: period resolution, section registry, templates\n// and the composer that freezes a period into a snapshot.\nexport {\n  resolvePeriod,\n  resolvePeriodByLabel,\n  rejectUnreportablePeriod,\n  nextPeriodBoundary,\n  completePeriodsSince,\n  registerSection,\n  getSection,\n  allSections,\n  sectionIds,\n  REPORT_TEMPLATE_SPECS,\n  getTemplate,\n  composeSnapshot,\n  LOW_SAMPLE_THRESHOLD,\n  REPORT_FEATURE_SUBSTITUTES,\n  renderReportHtml,\n  reportFileName,\n  trendSentence,\n  type ReportHtmlInput,\n  type ResolvedPeriod,\n  type PeriodRejection,\n  type SectionSpec,\n  type SectionContext,\n  type SectionDataSource,\n  type TemplateSpec,\n  type ReportSnapshot,\n  type ComposedSection,\n  type DataQualityNote,\n  type ComposeOptions,\n  type TrendDirection,\n  StakeholderReportStore,\n  stakeholderReportStore,\n  hashToken,\n  mintToken,\n  DEFAULT_SHARE_LINK_TTL_DAYS,\n  MAX_SHARE_LINK_TTL_DAYS,\n  MAX_BOUNCES,\n  VERIFICATION_TTL_MS,\n  type CreateDefinitionInput,\n  type UpdateDefinitionInput,\n  type MintedShareLink,\n  type ResolvedShareLink,\n} from './api/reporting/stakeholder/index.js';\nexport {\n  type PluginRuntimeFilter,\n  type PluginRuntimeStats,\n  ReportingService,\n  reportingService,\n} from './api/reporting-service.js';\n\n// Filters\nexport {\n  type PluginFilter,\n  type PipelineFilter,\n  type PipelineTemplateFilter,\n  type MessageFilter,\n  type CompliancePolicyFilter,\n  type ComplianceRuleFilter,\n  type ComplianceExemptionFilter,\n  type ComplianceAuditFilter,\n  type ComplianceScanFilter,\n} from './core/query-filters.js';\n"]}

package/lib/testing/exports.json

@@ -6,6 +6,8 @@
       "advisoriesCovering": "function",
       "advisoryRangeCovers": "function",
       "advisoryRangeProblem": "function",
+      "allSections": "function",
+      "applyDeployOutcome": "function",
       "applyPolicyUpdate": "function",
       "blockingAdvisories": "function",
       "buildComplianceAuditConditions": "function",
@@ -18,26 +20,28 @@
       "buildPipelineTemplateConditions": "function",
       "buildPluginConditions": "function",
       "buildPublishedRuleCatalogConditions": "function",
+      "classifyFailure": "function",
       "closeConnection": "function",
+      "closeFixedExposures": "function",
       "closePublicReader": "function",
       "COMMUNITY_PUBLISHER_HANDLE": "value",
       "compareSemver": "function",
       "compareSemverParts": "function",
+      "completePeriodsSince": "function",
       "complianceAuditLog": "value",
       "complianceExemption": "value",
       "complianceNotificationLog": "value",
       "complianceNotificationPreference": "value",
       "compliancePolicy": "value",
-      "complianceReport": "value",
-      "complianceReportSchedule": "value",
-      "complianceRole": "value",
       "complianceRule": "value",
       "complianceRuleHistory": "value",
       "complianceRuleSubscription": "value",
       "complianceScan": "value",
       "complianceScanSchedule": "value",
+      "composeSnapshot": "function",
       "Connection": "class",
       "ConnectionRetryStrategy": "class",
+      "correlateIncident": "function",
       "createSoftDeletePurgeScheduler": "function",
       "CrudService": "class",
       "currentViewerUserId": "function",
@@ -45,6 +49,8 @@
       "dashboardPanel": "value",
       "db": "value",
       "DEFAULT_CONSUMPTION_POLICY": "value",
+      "DEFAULT_SHARE_LINK_TTL_DAYS": "value",
+      "DEFAULT_THRESHOLDS": "value",
       "deploymentOutcome": "value",
       "DIRECTORY_SORTS": "value",
       "DIRECTORY_TIERS": "value",
@@ -53,40 +59,63 @@
       "drizzleListingSource": "function",
       "drizzleRows": "function",
       "ecosystemAutoApprovalRule": "value",
-      "ecosystemCollection": "value",
       "ecosystemNotificationQueue": "value",
       "ecosystemReservedName": "value",
       "ecosystemSearchMiss": "value",
       "ecosystemSetting": "value",
       "effectiveConsumptionPolicy": "function",
+      "evaluateNeedsAttention": "function",
       "executeRows": "function",
+      "FAILURE_CATEGORY_LABELS": "value",
+      "getAdoption": "function",
       "getConnection": "function",
+      "getFailureAnalysis": "function",
+      "getOutdatedPlugins": "function",
+      "getPipelineBreakdown": "function",
+      "getPluginVulnerabilities": "function",
+      "getPromotionView": "function",
       "getPublicListedVersion": "function",
       "getPublicListing": "function",
       "getPublicReaderDb": "function",
+      "getResourceConsumption": "function",
+      "getSection": "function",
       "getSslConfig": "function",
+      "getStagePerformance": "function",
+      "getTemplate": "function",
       "getTenantContext": "function",
+      "hashToken": "function",
       "implicitInstallRange": "function",
       "incident": "value",
       "ingestHealth": "value",
       "INSTALL_VERSION_POLICIES": "value",
       "installAdmits": "function",
       "installModeFor": "function",
+      "isDeployEvent": "function",
       "isPublicReaderConfigured": "function",
+      "isTeamActionable": "function",
       "isUniqueViolation": "function",
       "isVersionRange": "function",
+      "lapsedAcceptances": "function",
+      "leadTimeGapOf": "function",
       "listedPluginRecord": "function",
       "listedVersionWarnings": "function",
+      "listEnabledAlertDestinations": "function",
       "listingBlock": "function",
       "listPublicCategories": "function",
       "listPublicListingsForSitemap": "function",
       "listPublicReviews": "function",
       "loadOrgInstallContext": "function",
+      "LOW_SAMPLE_THRESHOLD": "value",
+      "MAX_BOUNCES": "value",
+      "MAX_SHARE_LINK_TTL_DAYS": "value",
       "message": "value",
       "messageAttachment": "value",
+      "mintToken": "function",
+      "nextPeriodBoundary": "function",
       "normalizeQuery": "function",
       "OFFICIAL_PUBLISHER_HANDLE": "value",
       "OPEN_PUBLISH_REQUEST_STATUSES": "value",
+      "openExposures": "function",
       "orgAlertDestination": "value",
       "orgAlertRule": "value",
       "orgListingStates": "function",
@@ -121,23 +150,57 @@
       "publicReviews": "value",
       "publisher": "value",
       "PUBLISHER_TIERS": "value",
+      "rebuildDay": "function",
+      "refreshLatestForPlugin": "function",
+      "registerSection": "function",
+      "rejectUnreportablePeriod": "function",
+      "renderReportHtml": "function",
+      "replacePipelineResolution": "function",
+      "REPORT_CADENCES": "value",
+      "REPORT_FEATURE_SUBSTITUTES": "value",
+      "REPORT_PAUSE_REASONS": "value",
+      "REPORT_RUN_STATUSES": "value",
+      "REPORT_SCOPE_KINDS": "value",
+      "REPORT_TEMPLATE_SPECS": "value",
+      "REPORT_TEMPLATES": "value",
+      "reportDefinition": "value",
+      "reportFileName": "function",
       "reportingService": "value",
       "ReportingService": "class",
+      "reportRecipient": "value",
+      "reportRun": "value",
+      "reportShareLink": "value",
       "resolvableListings": "function",
       "resolveListingReference": "function",
+      "resolvePeriod": "function",
+      "resolvePeriodByLabel": "function",
       "resultRows": "function",
       "REVIEW_REPORT_CATEGORIES": "value",
       "REVIEW_SORTS": "value",
+      "rollupBatchDays": "function",
+      "rollupSettleHours": "function",
+      "runRollupPass": "function",
       "runSoftDeletePurge": "function",
       "runWithTenantContext": "function",
       "satisfiesVersionSpec": "function",
       "schema": "value",
       "scopeOrgIds": "function",
       "searchPublicListings": "function",
+      "sectionIds": "function",
       "semverOrderBy": "function",
       "softDeleteRetentionMs": "function",
+      "stakeholderReportStore": "value",
+      "StakeholderReportStore": "class",
       "tenantContext": "value",
       "testConnection": "function",
+      "thresholdsFrom": "function",
+      "trendSentence": "function",
+      "triageExposure": "function",
+      "upsertDeployments": "function",
+      "upsertExposures": "function",
+      "utcDayStart": "function",
+      "VERIFICATION_TTL_MS": "value",
+      "versionGap": "function",
       "viewerCacheSegment": "function",
       "withTenantTx": "function",
       "withViewerContext": "function"

package/package.json

@@ -26,7 +26,7 @@
   "dependencies": {
     "drizzle-orm": "0.45.3",
     "pg": "8.23.0",
-    "@pipeline-builder/api-core": "4.1.21"
+    "@pipeline-builder/api-core": "5.0.0"
   },
   "keywords": [
     "ci-cd",
@@ -66,7 +66,7 @@
     "cli"
   ],
   "engines": {
-    "node": ">= 24.14.0"
+    "node": ">= 24.21.0"
   },
   "devEngines": {
     "packageManager": {
@@ -82,7 +82,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.1.23",
+  "version": "4.1.25",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },
@@ -150,6 +150,7 @@
       "src/**/*.ts",
       "!src/**/*.d.ts",
       "!src/testing/**",
+      "!src/api/reporting/stakeholder/index.ts",
       "!src/api/reporting/types.ts",
       "!src/core/query-filters.ts",
       "!src/database/index.ts",