@pipeline-builder/pipeline-data 4.1.24 → 4.1.26

package/lib/api/reporting/stakeholder/store.js

@@ -0,0 +1,981 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Persistence for stakeholder reports: definitions, runs, share links and
+ * recipients.
+ *
+ * Hand-rolled rather than four `CrudService` subclasses because none of these is
+ * a generic listable entity with an `isDefault` slot and project-scoped access
+ * control. What they need instead is a small number of exact operations with
+ * invariants the generic base cannot express:
+ *
+ *  - A RUN IS APPEND-ONLY once published. Regenerating a period inserts version
+ *    N+1 and points the old row at it (`supersededBy`); nothing overwrites a
+ *    snapshot a manager has already read.
+ *  - A SHARE LINK IS RESOLVED WITHOUT A TENANT. The reader has no account, so the
+ *    lookup by token hash is the one read here that deliberately runs as sysadmin
+ *    — see {@link resolveShareLink} for why that is the narrowest safe shape.
+ *  - A RECIPIENT IS UPSERTED, NEVER RE-CREATED. Re-adding an address must keep its
+ *    verification and unsubscribe state, or an unsubscribe could be undone by
+ *    deleting and re-adding the row.
+ *
+ * Everything else runs inside the caller's ambient tenant context (established by
+ * `withTenantContext()` at the request boundary), so RLS is the tenancy gate and
+ * an `orgId` argument is a redundant second check rather than the only one.
+ */
+import { randomUUID, createHash, randomBytes } from 'node:crypto';
+import { NotFoundError, ConflictError, ErrorCode } from '@pipeline-builder/api-core';
+import { and, asc, desc, eq, inArray, isNull, lte, sql } from 'drizzle-orm';
+import { schema } from '../../../database/drizzle-schema.js';
+import { runWithTenantContext, withTenantTx } from '../../../database/tenancy.js';
+import { softDeleteRetentionMs } from '../../crud-service.js';
+/** How long a freshly minted share link lives when the caller names no window. */
+export const DEFAULT_SHARE_LINK_TTL_DAYS = 30;
+/** The longest a share link may live. Beyond this it is a permanent URL. */
+export const MAX_SHARE_LINK_TTL_DAYS = 180;
+/** A recipient's verification link. Short: it is clicked within minutes or never. */
+export const VERIFICATION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Bounces before an address is treated as undeliverable and skipped. Three, not
+ * one: a single bounce is often an out-of-office autoresponder or a full mailbox,
+ * and dropping a manager off the list for one of those is a silent failure.
+ */
+export const MAX_BOUNCES = 3;
+/** SHA-256 hex of a token. The only form any token is ever stored in. */
+export function hashToken(token) {
+    return createHash('sha256').update(token, 'utf8').digest('hex');
+}
+/** A fresh URL-safe token, and its hash. The raw value is returned exactly once. */
+export function mintToken() {
+    const token = randomBytes(32).toString('base64url');
+    return { token, tokenHash: hashToken(token) };
+}
+/** The `purge_after` stamp a soft-delete carries, or `{}` when purging is off. */
+function purgeStamp(now) {
+    const ms = softDeleteRetentionMs();
+    return ms > 0 ? { purgeAfter: new Date(now.getTime() + ms) } : {};
+}
+export class StakeholderReportStore {
+    // ── Definitions ────────────────────────────────────────────────────────────
+    async createDefinition(input) {
+        const id = randomUUID();
+        const rows = await withTenantTx((tx) => tx.insert(schema.reportDefinition).values({
+            id,
+            orgId: input.orgId,
+            ownerId: input.ownerId,
+            name: input.name,
+            template: input.template,
+            sections: input.sections,
+            cadence: input.cadence,
+            timezone: input.timezone,
+            weekStart: input.weekStart,
+            scope: input.scope,
+            recipients: input.recipients,
+            autoSend: input.autoSend,
+            nextRunAt: input.nextRunAt ?? null,
+            createdBy: input.createdBy,
+        }).returning());
+        return rows[0];
+    }
+    async listDefinitions(orgId) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)
+            .where(and(eq(schema.reportDefinition.orgId, orgId), isNull(schema.reportDefinition.deletedAt)))
+            .orderBy(asc(schema.reportDefinition.name)));
+        return rows;
+    }
+    async getDefinition(orgId, id) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)
+            .where(and(eq(schema.reportDefinition.id, id), eq(schema.reportDefinition.orgId, orgId), isNull(schema.reportDefinition.deletedAt)))
+            .limit(1));
+        return rows[0] ?? null;
+    }
+    /** Throws {@link NotFoundError} rather than returning null, for route bodies. */
+    async requireDefinition(orgId, id) {
+        const found = await this.getDefinition(orgId, id);
+        if (!found)
+            throw new NotFoundError('Report definition not found');
+        return found;
+    }
+    async updateDefinition(orgId, id, patch, updatedBy) {
+        const set = { updatedBy, updatedAt: new Date() };
+        for (const [key, value] of Object.entries(patch)) {
+            if (value !== undefined)
+                set[key] = value;
+        }
+        const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition).set(set)
+            .where(and(eq(schema.reportDefinition.id, id), eq(schema.reportDefinition.orgId, orgId), isNull(schema.reportDefinition.deletedAt)))
+            .returning());
+        const updated = rows[0];
+        if (!updated)
+            throw new NotFoundError('Report definition not found');
+        return updated;
+    }
+    /**
+     * Hand a definition to a new owner. The owner is who a scheduled run is
+     * authorized AS, so this is a privilege move, not a metadata edit — the route
+     * checks the new owner is a live member of the org before calling.
+     */
+    async transferOwner(orgId, id, newOwnerId, actorId) {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)
+            .set({
+            ownerId: newOwnerId,
+            updatedBy: actorId,
+            updatedAt: new Date(),
+            // A definition paused because its previous owner lost access is live again
+            // under an owner who has it. The scheduler re-checks every run anyway, so
+            // the worst case is one more paused run, never a standing grant.
+            isActive: true,
+            pausedReason: null,
+        })
+            .where(and(eq(schema.reportDefinition.id, id), eq(schema.reportDefinition.orgId, orgId), isNull(schema.reportDefinition.deletedAt)))
+            .returning());
+        const updated = rows[0];
+        if (!updated)
+            throw new NotFoundError('Report definition not found');
+        return updated;
+    }
+    /**
+     * Pause every definition a user owns, with the reason recorded. Called when the
+     * owner is deactivated or loses `reports:author` — a report must stop when the
+     * person accountable for it can no longer see the data behind it.
+     *
+     * Returns the paused definitions so the caller can notify an org admin: a
+     * silently stopped weekly report is discovered by a manager not receiving it.
+     */
+    async pauseDefinitionsForOwner(orgId, ownerId, reason) {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)
+            .set({ isActive: false, pausedReason: reason, updatedAt: new Date() })
+            .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.ownerId, ownerId), eq(schema.reportDefinition.isActive, true), isNull(schema.reportDefinition.deletedAt)))
+            .returning());
+        return rows;
+    }
+    async deleteDefinition(orgId, id, deletedBy) {
+        const now = new Date();
+        const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)
+            .set({ deletedAt: now, deletedBy, ...purgeStamp(now) })
+            .where(and(eq(schema.reportDefinition.id, id), eq(schema.reportDefinition.orgId, orgId), isNull(schema.reportDefinition.deletedAt)))
+            .returning({ id: schema.reportDefinition.id }));
+        if (rows.length === 0) {
+            throw new NotFoundError('Report definition not found');
+        }
+        // Links to this definition's runs are revoked in the same breath. Deleting a
+        // report while a public URL to last month's numbers keeps working is the kind
+        // of gap nobody notices until it matters.
+        await this.revokeLinksForDefinition(orgId, id, deletedBy);
+    }
+    // ── Runs ───────────────────────────────────────────────────────────────────
+    /**
+     * Insert a run for a period, or return the existing one.
+     *
+     * Idempotent on (definition, periodStart, version): a retry, a catch-up pass
+     * and a manual backfill can all ask for the same period, and without this each
+     * would insert a row and the lead would review three copies. `onConflictDoNothing`
+     * plus a re-read is deliberate — the unique index is the arbiter, so two pods
+     * racing produce one row whichever wins.
+     */
+    async createRun(input) {
+        const version = input.version ?? 1;
+        const id = randomUUID();
+        const rows = await withTenantTx((tx) => tx.insert(schema.reportRun).values({
+            id,
+            orgId: input.orgId,
+            definitionId: input.definitionId,
+            periodStart: input.periodStart,
+            periodEnd: input.periodEnd,
+            periodLabel: input.periodLabel,
+            version,
+            status: input.status ?? 'drafting',
+            snapshot: input.snapshot ?? null,
+            failureReason: input.failureReason ?? null,
+        }).onConflictDoNothing({
+            target: [schema.reportRun.definitionId, schema.reportRun.periodStart, schema.reportRun.version],
+        }).returning());
+        const inserted = rows[0];
+        if (inserted)
+            return { run: inserted, created: true };
+        const existing = await withTenantTx((tx) => tx.select().from(schema.reportRun)
+            .where(and(eq(schema.reportRun.definitionId, input.definitionId), eq(schema.reportRun.periodStart, input.periodStart), eq(schema.reportRun.version, version)))
+            .limit(1));
+        const found = existing[0];
+        if (!found) {
+            // The insert was skipped by the conflict target but nothing is there to
+            // read: the only way is a concurrent delete between the two statements.
+            throw new ConflictError('Report run could not be created', ErrorCode.CONFLICT, {
+                definitionId: input.definitionId,
+                periodLabel: input.periodLabel,
+            });
+        }
+        return { run: found, created: false };
+    }
+    /** The next version number for a period: `max(version) + 1`. */
+    async nextVersion(definitionId, periodStart) {
+        const rows = await withTenantTx((tx) => tx.select({ version: schema.reportRun.version })
+            .from(schema.reportRun)
+            .where(and(eq(schema.reportRun.definitionId, definitionId), eq(schema.reportRun.periodStart, periodStart)))
+            .orderBy(desc(schema.reportRun.version))
+            .limit(1));
+        const top = rows[0];
+        return (top?.version ?? 0) + 1;
+    }
+    /** Point an older run at the version that replaced it. */
+    async supersede(orgId, oldRunId, newRunId) {
+        await withTenantTx((tx) => tx.update(schema.reportRun)
+            .set({ supersededBy: newRunId, updatedAt: new Date() })
+            .where(and(eq(schema.reportRun.id, oldRunId), eq(schema.reportRun.orgId, orgId))));
+    }
+    async listRuns(orgId, definitionId, limit = 50) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportRun)
+            .where(and(eq(schema.reportRun.orgId, orgId), eq(schema.reportRun.definitionId, definitionId), isNull(schema.reportRun.deletedAt)))
+            .orderBy(desc(schema.reportRun.periodStart), desc(schema.reportRun.version))
+            .limit(limit));
+        return rows;
+    }
+    async getRun(orgId, id) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportRun)
+            .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.deletedAt)))
+            .limit(1));
+        return rows[0] ?? null;
+    }
+    async requireRun(orgId, id) {
+        const found = await this.getRun(orgId, id);
+        if (!found)
+            throw new NotFoundError('Report run not found');
+        return found;
+    }
+    /** Store a computed snapshot and move the run to `ready_for_review`. */
+    async completeRun(orgId, id, snapshot, status = 'ready_for_review') {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportRun)
+            .set({ snapshot, status, failureReason: null, updatedAt: new Date() })
+            .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.deletedAt)))
+            .returning());
+        const updated = rows[0];
+        if (!updated)
+            throw new NotFoundError('Report run not found');
+        return updated;
+    }
+    async failRun(orgId, id, failureReason) {
+        await withTenantTx((tx) => tx.update(schema.reportRun)
+            .set({ status: 'failed', failureReason, updatedAt: new Date() })
+            .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId))));
+    }
+    /**
+     * Edit the lead's own words on a run that has NOT been published.
+     *
+     * Refused after publish: the notes are part of what the manager read, and a
+     * report whose narrative can be edited after delivery is a report whose
+     * delivered version cannot be reconstructed. Regenerating produces version N+1,
+     * which is the supported way to correct a published report.
+     */
+    async setRunNotes(orgId, id, patch) {
+        const run = await this.requireRun(orgId, id);
+        if (run.status === 'published') {
+            throw new ConflictError('This report has already been published. Regenerate it to produce a new version with your changes — '
+                + 'the published version stays exactly as the recipients read it.', ErrorCode.CONFLICT, { runId: id, publishedAt: run.publishedAt?.toISOString() });
+        }
+        const set = { updatedAt: new Date() };
+        if (patch.leadNotes !== undefined)
+            set.leadNotes = patch.leadNotes;
+        if (patch.aiDraft !== undefined)
+            set.aiDraft = patch.aiDraft;
+        const rows = await withTenantTx((tx) => tx.update(schema.reportRun).set(set)
+            .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.deletedAt)))
+            .returning());
+        return rows[0];
+    }
+    /**
+     * Record what happened when a run was delivered.
+     *
+     * Deliberately NOT part of {@link setRunNotes}, which refuses a published run: delivery
+     * happens AT publish, so a method that refused published runs could never record it.
+     * This one writes exactly one column and nothing else, which is why it is safe to allow
+     * after publish — it cannot change a number a recipient has read.
+     */
+    async recordDelivery(orgId, id, delivery) {
+        await withTenantTx((tx) => tx.update(schema.reportRun)
+            .set({ delivery, updatedAt: new Date() })
+            .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.deletedAt))));
+    }
+    /**
+     * Publish a run.
+     *
+     * Conditional on the row still being unpublished (`published_at IS NULL`), so
+     * two clicks — or two tabs — produce one publish and one set of deliveries
+     * rather than two. A run with no snapshot cannot be published: there would be
+     * nothing for a recipient to read.
+     */
+    async publishRun(orgId, id, publishedBy) {
+        const run = await this.requireRun(orgId, id);
+        if (run.status === 'failed' || !run.snapshot) {
+            throw new ConflictError('This report has no computed snapshot, so there is nothing to publish. Regenerate it first.', ErrorCode.CONFLICT, { runId: id, status: run.status });
+        }
+        const now = new Date();
+        const rows = await withTenantTx((tx) => tx.update(schema.reportRun)
+            .set({ status: 'published', publishedBy, publishedAt: now, updatedAt: now })
+            .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.publishedAt), isNull(schema.reportRun.deletedAt)))
+            .returning());
+        const published = rows[0];
+        if (published)
+            return { run: published, alreadyPublished: false };
+        // The conditional update matched nothing: someone else published it first.
+        return { run: await this.requireRun(orgId, id), alreadyPublished: true };
+    }
+    // ── Share links ────────────────────────────────────────────────────────────
+    /**
+     * Mint a read-only link to a published run. The raw token is returned here and
+     * nowhere else — only its hash is stored, so a database copy cannot be turned
+     * back into working URLs.
+     */
+    async createShareLink(input) {
+        const run = await this.requireRun(input.orgId, input.runId);
+        if (run.status !== 'published') {
+            throw new ConflictError('Only a published report can be shared. Publish it first — a link to a draft would show numbers the lead has not reviewed.', ErrorCode.CONFLICT, { runId: input.runId, status: run.status });
+        }
+        const days = Math.min(input.ttlDays ?? DEFAULT_SHARE_LINK_TTL_DAYS, MAX_SHARE_LINK_TTL_DAYS);
+        const now = input.now ?? new Date();
+        const { token, tokenHash } = mintToken();
+        const rows = await withTenantTx((tx) => tx.insert(schema.reportShareLink).values({
+            id: randomUUID(),
+            orgId: input.orgId,
+            runId: input.runId,
+            tokenHash,
+            expiresAt: new Date(now.getTime() + days * 24 * 60 * 60 * 1000),
+            redactNames: input.redactNames ?? false,
+            createdBy: input.createdBy,
+        }).returning());
+        return { link: rows[0], token };
+    }
+    async listShareLinks(orgId, runId) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportShareLink)
+            .where(and(eq(schema.reportShareLink.orgId, orgId), eq(schema.reportShareLink.runId, runId)))
+            .orderBy(desc(schema.reportShareLink.createdAt)));
+        return rows;
+    }
+    async revokeShareLink(orgId, id, revokedBy) {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportShareLink)
+            .set({ revokedAt: new Date(), revokedBy })
+            .where(and(eq(schema.reportShareLink.id, id), eq(schema.reportShareLink.orgId, orgId), isNull(schema.reportShareLink.revokedAt)))
+            .returning());
+        const revoked = rows[0];
+        if (!revoked)
+            throw new NotFoundError('Share link not found or already revoked');
+        return revoked;
+    }
+    /** Revoke every live link to any run of a definition. Used on delete. */
+    async revokeLinksForDefinition(orgId, definitionId, revokedBy) {
+        const runs = await withTenantTx((tx) => tx.select({ id: schema.reportRun.id }).from(schema.reportRun)
+            .where(and(eq(schema.reportRun.orgId, orgId), eq(schema.reportRun.definitionId, definitionId))));
+        const runIds = runs.map((r) => r.id);
+        if (runIds.length === 0)
+            return 0;
+        const rows = await withTenantTx((tx) => tx.update(schema.reportShareLink)
+            .set({ revokedAt: new Date(), revokedBy })
+            .where(and(eq(schema.reportShareLink.orgId, orgId), inArray(schema.reportShareLink.runId, runIds), isNull(schema.reportShareLink.revokedAt)))
+            .returning({ id: schema.reportShareLink.id }));
+        return rows.length;
+    }
+    /**
+     * Resolve a share token to its link and run, for the UNAUTHENTICATED public
+     * route.
+     *
+     * This is the one read in this module that runs as sysadmin, and the reason is
+     * structural: the reader holds a token and nothing else — no account, no org,
+     * no JWT — so there is no tenant context for RLS to scope by, and the org can
+     * only be learned FROM the row. The escalation is kept as narrow as the problem:
+     *
+     *  - The sysadmin scope covers the token-hash lookup ONLY. The run is read back
+     *    under the link's OWN org, so a bug in the run query cannot reach another
+     *    tenant's rows.
+     *  - The lookup is by a 256-bit hash on a unique index. It is not a filter a
+     *    caller can widen — there is no other predicate to influence.
+     *  - Expired and revoked links resolve to null here, so the caller cannot
+     *    accidentally serve one by forgetting a check.
+     *
+     * Returns null for every failure — unknown, revoked, expired, or pointing at a
+     * run that is no longer published — so the route answers one indistinguishable
+     * 404 and a holder of a dead link learns nothing about which of those it was.
+     */
+    async resolveShareLink(token, now = new Date()) {
+        const tokenHash = hashToken(token);
+        const links = await runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => tx.select().from(schema.reportShareLink)
+            .where(eq(schema.reportShareLink.tokenHash, tokenHash))
+            .limit(1)));
+        const link = links[0];
+        // No constant-time comparison here on purpose: the lookup is an equality match
+        // on a 256-bit hash over a unique index, so there is no secret-dependent branch
+        // in this function to leak. A hand-rolled compare after the database already
+        // decided it would be theatre.
+        if (!link)
+            return null;
+        if (link.revokedAt)
+            return null;
+        if (link.expiresAt.getTime() <= now.getTime())
+            return null;
+        const runs = await runWithTenantContext({ orgId: link.orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.select().from(schema.reportRun)
+            .where(and(eq(schema.reportRun.id, link.runId), eq(schema.reportRun.orgId, link.orgId), eq(schema.reportRun.status, 'published'), isNull(schema.reportRun.deletedAt)))
+            .limit(1)));
+        const run = runs[0];
+        if (!run)
+            return null;
+        return { link, run };
+    }
+    /**
+     * Count one human view of a shared report.
+     *
+     * Separate from {@link resolveShareLink} so the route can serve a link preview,
+     * a HEAD probe or a mail scanner's fetch WITHOUT counting it — a view count that
+     * jumps the moment a link is pasted into Slack tells the lead their manager read
+     * the report when nobody has.
+     */
+    async recordShareView(link, now = new Date()) {
+        await runWithTenantContext({ orgId: link.orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.update(schema.reportShareLink)
+            .set({ viewCount: sql `${schema.reportShareLink.viewCount} + 1`, lastViewedAt: now })
+            .where(eq(schema.reportShareLink.id, link.id))));
+    }
+    // ── Recipients ─────────────────────────────────────────────────────────────
+    /**
+     * Add (or re-add) a delivery address.
+     *
+     * Upserts on (org, email) and deliberately does NOT reset `unsubscribed_at` or
+     * `verified_at`: a lead must not be able to undo someone's unsubscribe by
+     * removing and re-adding them, and an address already verified should not have
+     * to confirm twice. A verification token is minted only when the address is not
+     * yet verified.
+     */
+    async upsertRecipient(input) {
+        const email = input.email.trim().toLowerCase();
+        const now = input.now ?? new Date();
+        const minted = input.preVerified ? undefined : mintToken();
+        // The unsubscribe token is minted for EVERY recipient, member or not, because every
+        // report email carries the link. Minted once and kept: a link in a report from March
+        // has to keep working.
+        const unsub = mintToken();
+        const rows = await withTenantTx((tx) => tx.insert(schema.reportRecipient).values({
+            id: randomUUID(),
+            orgId: input.orgId,
+            email,
+            displayName: input.displayName ?? null,
+            verifiedAt: input.preVerified ? now : null,
+            verificationTokenHash: minted?.tokenHash ?? null,
+            unsubscribeToken: unsub.token,
+            approvedBy: input.approvedBy ?? null,
+            createdBy: input.createdBy,
+        }).onConflictDoUpdate({
+            target: [schema.reportRecipient.orgId, schema.reportRecipient.email],
+            set: {
+                displayName: input.displayName ?? sql `${schema.reportRecipient.displayName}`,
+                // Re-adding a tombstoned recipient revives the row with its history.
+                deletedAt: null,
+                deletedBy: null,
+                purgeAfter: null,
+                approvedBy: input.approvedBy ?? sql `${schema.reportRecipient.approvedBy}`,
+                // Only mint over an UNVERIFIED row; a verified address keeps its state.
+                verificationTokenHash: sql `CASE WHEN ${schema.reportRecipient.verifiedAt} IS NULL
+          THEN ${minted?.tokenHash ?? null} ELSE ${schema.reportRecipient.verificationTokenHash} END`,
+                verifiedAt: input.preVerified
+                    ? sql `COALESCE(${schema.reportRecipient.verifiedAt}, ${now})`
+                    : sql `${schema.reportRecipient.verifiedAt}`,
+                // COALESCE, never overwrite: re-adding an address must not break the unsubscribe
+                // link in every report already delivered to it.
+                unsubscribeToken: sql `COALESCE(${schema.reportRecipient.unsubscribeToken}, ${unsub.token})`,
+            },
+        }).returning());
+        const recipient = rows[0];
+        // The token is only useful if this row actually took it.
+        const tookToken = minted && recipient.verificationTokenHash === minted.tokenHash;
+        return { recipient, ...(tookToken ? { verificationToken: minted.token } : {}) };
+    }
+    async listRecipients(orgId) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportRecipient)
+            .where(and(eq(schema.reportRecipient.orgId, orgId), isNull(schema.reportRecipient.deletedAt)))
+            .orderBy(asc(schema.reportRecipient.email)));
+        return rows;
+    }
+    async getRecipients(orgId, ids) {
+        if (ids.length === 0)
+            return [];
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportRecipient)
+            .where(and(eq(schema.reportRecipient.orgId, orgId), inArray(schema.reportRecipient.id, ids), isNull(schema.reportRecipient.deletedAt))));
+        return rows;
+    }
+    /** Mint a fresh verification token for a recipient that has not confirmed yet. */
+    async resendVerification(orgId, id) {
+        const { token, tokenHash } = mintToken();
+        const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)
+            .set({ verificationTokenHash: tokenHash })
+            .where(and(eq(schema.reportRecipient.id, id), eq(schema.reportRecipient.orgId, orgId), isNull(schema.reportRecipient.verifiedAt), isNull(schema.reportRecipient.deletedAt)))
+            .returning());
+        const recipient = rows[0];
+        if (!recipient) {
+            throw new ConflictError('This recipient is already verified, or no longer exists.', ErrorCode.CONFLICT, { recipientId: id });
+        }
+        return { recipient, token };
+    }
+    /**
+     * Confirm an address from the emailed token. Cross-org by necessity (the person
+     * clicking has no session), so it runs as sysadmin over a unique 256-bit hash —
+     * the same shape, and the same reasoning, as {@link resolveShareLink}.
+     *
+     * The token is CONSUMED: it is cleared on success, so a forwarded confirmation
+     * link cannot be replayed by whoever the mail was forwarded to.
+     */
+    async verifyRecipientByToken(token, now = new Date()) {
+        const tokenHash = hashToken(token);
+        const rows = await runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => tx.update(schema.reportRecipient)
+            .set({ verifiedAt: now, verificationTokenHash: null })
+            .where(and(eq(schema.reportRecipient.verificationTokenHash, tokenHash), isNull(schema.reportRecipient.verifiedAt), isNull(schema.reportRecipient.deletedAt), 
+        // A token older than the window is not accepted. `created_at` is the
+        // floor for the first token; a resend refreshes the hash, so this bounds
+        // the original mint and is deliberately generous.
+        sql `${schema.reportRecipient.createdAt} > ${new Date(now.getTime() - VERIFICATION_TTL_MS)}`))
+            .returning()));
+        return rows[0] ?? null;
+    }
+    /** Honour an unsubscribe across every definition in the org. */
+    async unsubscribeByEmail(orgId, email, now = new Date()) {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)
+            .set({ unsubscribedAt: now })
+            .where(and(eq(schema.reportRecipient.orgId, orgId), eq(schema.reportRecipient.email, email.trim().toLowerCase()), isNull(schema.reportRecipient.unsubscribedAt)))
+            .returning({ id: schema.reportRecipient.id }));
+        return rows.length > 0;
+    }
+    /**
+     * Honour an unsubscribe from the link in a report email.
+     *
+     * Looked up by TOKEN across orgs, as sysadmin, for the same reason the share-link
+     * resolve is: the person clicking has no account and no tenant, and the token is the
+     * only thing that identifies the row. It is the narrowest possible shape — one indexed
+     * lookup, one column written, nothing returned to the caller but whether a row
+     * matched.
+     *
+     * Idempotent. A mail client that sends the one-click POST twice, or a manager who
+     * clicks again months later, gets the same answer rather than an error page — the
+     * second call finds the row already unsubscribed and reports success, because from the
+     * clicker's point of view it is.
+     */
+    async unsubscribeByToken(token, now = new Date()) {
+        if (token.length < 16)
+            return false;
+        return runWithTenantContext({ isSuperAdmin: true }, async () => {
+            const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)
+                .set({ unsubscribedAt: sql `COALESCE(${schema.reportRecipient.unsubscribedAt}, ${now})` })
+                .where(eq(schema.reportRecipient.unsubscribeToken, token))
+                .returning({ id: schema.reportRecipient.id }));
+            return rows.length > 0;
+        });
+    }
+    /** Record a delivery bounce. At {@link MAX_BOUNCES} the address is skipped. */
+    async recordBounce(orgId, email, now = new Date()) {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)
+            .set({ bounceCount: sql `${schema.reportRecipient.bounceCount} + 1`, lastBounceAt: now })
+            .where(and(eq(schema.reportRecipient.orgId, orgId), eq(schema.reportRecipient.email, email.trim().toLowerCase())))
+            .returning({ bounceCount: schema.reportRecipient.bounceCount }));
+        return rows[0]?.bounceCount ?? 0;
+    }
+    async deleteRecipient(orgId, id, deletedBy) {
+        const now = new Date();
+        const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)
+            .set({ deletedAt: now, deletedBy, ...purgeStamp(now) })
+            .where(and(eq(schema.reportRecipient.id, id), eq(schema.reportRecipient.orgId, orgId), isNull(schema.reportRecipient.deletedAt)))
+            .returning({ id: schema.reportRecipient.id }));
+        if (rows.length === 0) {
+            throw new NotFoundError('Recipient not found');
+        }
+    }
+    /**
+     * Is this address deliverable right now? The single place the delivery rules
+     * live, so the scheduler and the UI agree about why a recipient is being
+     * skipped.
+     */
+    deliverability(recipient) {
+        if (recipient.deletedAt)
+            return { deliverable: false, reason: 'removed' };
+        if (recipient.unsubscribedAt)
+            return { deliverable: false, reason: 'unsubscribed' };
+        if (!recipient.verifiedAt)
+            return { deliverable: false, reason: 'pending_verification' };
+        if (recipient.bounceCount >= MAX_BOUNCES)
+            return { deliverable: false, reason: 'bouncing' };
+        return { deliverable: true };
+    }
+    // ── Recipient policy ───────────────────────────────────────────────────────
+    /**
+     * The org's admin-owned report policy. Read through the reporting settings row,
+     * which may not exist — an org that has never configured anything gets the
+     * closed defaults (no external sharing, no external domains, approval required).
+     */
+    async getReportPolicy(orgId) {
+        const rows = await withTenantTx((tx) => tx.select({
+            externalSharing: schema.doraSettings.reportExternalSharing,
+            recipientDomains: schema.doraSettings.reportRecipientDomains,
+            requireApproval: schema.doraSettings.reportRequireApproval,
+            defaultTimezone: schema.doraSettings.reportDefaultTimezone,
+            defaultWeekStart: schema.doraSettings.reportDefaultWeekStart,
+        }).from(schema.doraSettings).where(eq(schema.doraSettings.orgId, orgId)).limit(1));
+        const row = rows[0];
+        return {
+            externalSharing: row?.externalSharing ?? false,
+            recipientDomains: row?.recipientDomains ?? null,
+            requireApproval: row?.requireApproval ?? true,
+            // NULL rather than a guessed zone: the create form falls back to the BROWSER's zone,
+            // which is a better default than the server's and is visibly the lead's own.
+            defaultTimezone: row?.defaultTimezone ?? null,
+            defaultWeekStart: row?.defaultWeekStart ?? null,
+        };
+    }
+    async setReportPolicy(orgId, patch) {
+        const set = { updatedAt: new Date() };
+        if (patch.externalSharing !== undefined)
+            set.reportExternalSharing = patch.externalSharing;
+        if (patch.recipientDomains !== undefined)
+            set.reportRecipientDomains = patch.recipientDomains;
+        if (patch.requireApproval !== undefined)
+            set.reportRequireApproval = patch.requireApproval;
+        if (patch.defaultTimezone !== undefined)
+            set.reportDefaultTimezone = patch.defaultTimezone;
+        if (patch.defaultWeekStart !== undefined)
+            set.reportDefaultWeekStart = patch.defaultWeekStart;
+        await withTenantTx((tx) => tx.insert(schema.doraSettings).values({
+            orgId,
+            reportExternalSharing: patch.externalSharing ?? false,
+            reportRecipientDomains: patch.recipientDomains ?? null,
+            reportRequireApproval: patch.requireApproval ?? true,
+            reportDefaultTimezone: patch.defaultTimezone ?? null,
+            reportDefaultWeekStart: patch.defaultWeekStart ?? null,
+        }).onConflictDoUpdate({ target: schema.doraSettings.orgId, set }));
+    }
+    /**
+     * Apply a Stakeholder Reports entitlement change from billing: pause everything, or
+     * resume what the lapse paused.
+     *
+     * THE WATERMARK AND THE WORK ARE ONE TRANSACTION, and the watermark update is what
+     * serializes concurrent pushes. Billing's legs are best-effort and retried, so
+     * "lapsed at 10:00" and "renewed at 10:05" can arrive in either order; applying the
+     * older one last would leave a lapsed account producing reports, or a paying one
+     * paused. The conditional update takes a row lock on `dora_settings`, so a second
+     * push waits and then sees the newer watermark — no advisory lock needed.
+     *
+     * RESUME IS SCOPED TO `entitlement`. It must not un-pause a definition whose OWNER was
+     * deactivated or who lost the permission: those are different problems with different
+     * fixes, and resuming one by fixing the other is how a report starts running under
+     * somebody who left.
+     *
+     * `nextRunFor` is a callback because the period arithmetic needs each definition's
+     * cadence, timezone and week start, and that belongs with the period resolver rather
+     * than the store — while the write still has to happen inside this transaction.
+     *
+     * This leg makes the change IMMEDIATE; it is not what makes it safe. Every scheduled
+     * run re-checks the entitlement against platform anyway, so a lost push delays
+     * enforcement to the next run rather than defeating it.
+     */
+    async syncReportEntitlement(orgId, entitled, opts = {}) {
+        const now = opts.now ?? new Date();
+        const occurredAt = opts.occurredAt ?? now;
+        return withTenantTx(async (tx) => {
+            // The claim. A push at or before the last applied change updates zero rows.
+            const claimed = await tx.insert(schema.doraSettings)
+                .values({ orgId, reportEntitlementSyncedAt: occurredAt })
+                .onConflictDoUpdate({
+                target: schema.doraSettings.orgId,
+                set: { reportEntitlementSyncedAt: occurredAt, updatedAt: now },
+                setWhere: sql `${schema.doraSettings.reportEntitlementSyncedAt} IS NULL
+            OR ${schema.doraSettings.reportEntitlementSyncedAt} < ${occurredAt}`,
+            })
+                .returning({ orgId: schema.doraSettings.orgId });
+            if (claimed.length === 0) {
+                return { skipped: true, paused: [], resumed: [] };
+            }
+            if (!entitled) {
+                const rows = await tx.update(schema.reportDefinition)
+                    .set({ isActive: false, pausedReason: 'entitlement', nextRunAt: null, updatedAt: now })
+                    .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.isActive, true), isNull(schema.reportDefinition.deletedAt)))
+                    .returning();
+                return { skipped: false, paused: rows, resumed: [] };
+            }
+            const paused = await tx.select().from(schema.reportDefinition)
+                .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.isActive, false), eq(schema.reportDefinition.pausedReason, 'entitlement'), isNull(schema.reportDefinition.deletedAt)));
+            const resumed = [];
+            for (const definition of paused) {
+                const rows = await tx.update(schema.reportDefinition)
+                    .set({
+                    isActive: true,
+                    pausedReason: null,
+                    nextRunAt: opts.nextRunFor ? opts.nextRunFor(definition) : null,
+                    updatedAt: now,
+                })
+                    .where(eq(schema.reportDefinition.id, definition.id))
+                    .returning();
+                const row = rows[0];
+                if (row)
+                    resumed.push(row);
+            }
+            return { skipped: false, paused: [], resumed };
+        });
+    }
+    // ── The free preview ───────────────────────────────────────────────────────
+    /**
+     * Claim the org's ONE free preview, or report that it is already spent.
+     *
+     * A CONDITIONAL insert-or-update, not read-then-write: two tabs clicking "see a sample"
+     * at the same moment must produce one preview, and a check followed by a separate write
+     * has a window between them wide enough for both to pass. `WHERE report_preview_used_at
+     * IS NULL` on the update, and `onConflictDoUpdate` for the row that may not exist yet,
+     * make the claim itself the guard.
+     *
+     * Returns whether THIS caller won it. A loser is told the preview is spent, which is
+     * the truth and is also the upsell.
+     */
+    async claimReportPreview(orgId, now = new Date()) {
+        const rows = await withTenantTx((tx) => tx.insert(schema.doraSettings)
+            .values({ orgId, reportPreviewUsedAt: now })
+            .onConflictDoUpdate({
+            target: schema.doraSettings.orgId,
+            set: { reportPreviewUsedAt: now, updatedAt: now },
+            // The predicate is what makes this once-ever: an org whose row already carries a
+            // timestamp updates zero rows and returns nothing.
+            setWhere: isNull(schema.doraSettings.reportPreviewUsedAt),
+        })
+            .returning({ orgId: schema.doraSettings.orgId }));
+        return rows.length > 0;
+    }
+    /** Whether the org has already spent its free preview. */
+    async reportPreviewUsed(orgId) {
+        const rows = await withTenantTx((tx) => tx.select({ at: schema.doraSettings.reportPreviewUsedAt })
+            .from(schema.doraSettings)
+            .where(eq(schema.doraSettings.orgId, orgId))
+            .limit(1));
+        return rows[0]?.at != null;
+    }
+    /**
+     * Is `email` admissible as a recipient for this org, and does it need an
+     * admin's approval first?
+     *
+     * `orgMemberEmails` is the set of addresses that already authenticate to this
+     * org — they are always admissible and never need verification, because the org
+     * has already established they belong to it. Everything else is measured against
+     * the allowed-domain list, and a NULL list means "no external addresses at all",
+     * not "any address": the closed reading is the one that cannot leak a report by
+     * an admin forgetting to configure something.
+     */
+    admitRecipient(email, policy, orgMemberEmails) {
+        const normalized = email.trim().toLowerCase();
+        if (orgMemberEmails.has(normalized))
+            return { admitted: true, member: true, needsApproval: false };
+        const at = normalized.lastIndexOf('@');
+        const domain = at >= 0 ? normalized.slice(at + 1) : '';
+        if (!domain)
+            return { admitted: false, reason: 'Not a valid email address.' };
+        const allowed = policy.recipientDomains;
+        if (!allowed || allowed.length === 0) {
+            return {
+                admitted: false,
+                reason: 'This organization only delivers reports to its own members. '
+                    + 'An administrator can allow specific external domains in reporting settings.',
+            };
+        }
+        const ok = allowed.some((d) => {
+            const clean = d.trim().toLowerCase().replace(/^@/, '');
+            return clean.length > 0 && (domain === clean || domain.endsWith(`.${clean}`));
+        });
+        if (!ok) {
+            return {
+                admitted: false,
+                reason: `Reports can only be sent to ${allowed.join(', ')} addresses in this organization.`,
+            };
+        }
+        return { admitted: true, member: false, needsApproval: policy.requireApproval };
+    }
+    // ── Retention ──────────────────────────────────────────────────────────────
+    /**
+     * Hard-delete expired tombstones across every org, for the shared soft-delete
+     * sweep. Runs inside the sweep's own sysadmin scope.
+     *
+     * Runs go first: a purged definition with orphaned runs would leave snapshots
+     * nothing can reach, and share links are deleted with their runs so a purge
+     * cannot leave a live token pointing at a row that no longer exists.
+     */
+    purgeableEntities() {
+        return [
+            { name: 'report_run', purgeExpired: (now, limit) => this.purgeRuns(now, limit) },
+            { name: 'report_definition', purgeExpired: (now, limit) => this.purgeDefinitions(now, limit) },
+            { name: 'report_recipient', purgeExpired: (now, limit) => this.purgeRecipients(now, limit) },
+        ];
+    }
+    async purgeRuns(now, limit = 500) {
+        return withTenantTx(async (tx) => {
+            const due = await tx.select({ id: schema.reportRun.id }).from(schema.reportRun)
+                .where(and(sql `${schema.reportRun.deletedAt} IS NOT NULL`, lte(schema.reportRun.purgeAfter, now)))
+                .limit(limit);
+            const ids = due.map((r) => r.id);
+            if (ids.length === 0)
+                return 0;
+            await tx.delete(schema.reportShareLink).where(inArray(schema.reportShareLink.runId, ids));
+            const gone = await tx.delete(schema.reportRun).where(inArray(schema.reportRun.id, ids))
+                .returning({ id: schema.reportRun.id });
+            return gone.length;
+        });
+    }
+    async purgeDefinitions(now, limit = 500) {
+        return withTenantTx(async (tx) => {
+            const due = await tx.select({ id: schema.reportDefinition.id }).from(schema.reportDefinition)
+                .where(and(sql `${schema.reportDefinition.deletedAt} IS NOT NULL`, lte(schema.reportDefinition.purgeAfter, now)))
+                .limit(limit);
+            const ids = due.map((r) => r.id);
+            if (ids.length === 0)
+                return 0;
+            // The definition's runs (and their links) go with it, tombstoned or not:
+            // a snapshot whose definition is gone can never be listed again.
+            const runs = await tx.select({ id: schema.reportRun.id }).from(schema.reportRun)
+                .where(inArray(schema.reportRun.definitionId, ids));
+            const runIds = runs.map((r) => r.id);
+            if (runIds.length > 0) {
+                await tx.delete(schema.reportShareLink).where(inArray(schema.reportShareLink.runId, runIds));
+                await tx.delete(schema.reportRun).where(inArray(schema.reportRun.id, runIds));
+            }
+            const gone = await tx.delete(schema.reportDefinition).where(inArray(schema.reportDefinition.id, ids))
+                .returning({ id: schema.reportDefinition.id });
+            return gone.length;
+        });
+    }
+    async purgeRecipients(now, limit = 500) {
+        return withTenantTx(async (tx) => {
+            const due = await tx.select({ id: schema.reportRecipient.id }).from(schema.reportRecipient)
+                .where(and(sql `${schema.reportRecipient.deletedAt} IS NOT NULL`, lte(schema.reportRecipient.purgeAfter, now)))
+                .limit(limit);
+            const ids = due.map((r) => r.id);
+            if (ids.length === 0)
+                return 0;
+            const gone = await tx.delete(schema.reportRecipient).where(inArray(schema.reportRecipient.id, ids))
+                .returning({ id: schema.reportRecipient.id });
+            return gone.length;
+        });
+    }
+    /** Every definition the owner must be re-checked for, for the pause sweep. */
+    async listOwnedDefinitions(orgId, ownerId) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)
+            .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.ownerId, ownerId), isNull(schema.reportDefinition.deletedAt))));
+        return rows;
+    }
+    // ── The scheduler's reads and writes ───────────────────────────────────────
+    /**
+     * Definitions whose next run is due, across every org.
+     *
+     * Runs as SYSADMIN, because the scheduler has no tenant: it is looking for work
+     * in orgs it has not been told about. This is the one read here that crosses org
+     * boundaries, and it is kept to the narrowest possible shape — the rows needed to
+     * claim and execute, ordered oldest-due first so a backlog drains in order rather
+     * than starving whichever org sorts last by id.
+     *
+     * `limit` is the per-cycle ceiling: a cycle that tried to drain everything would
+     * hold the leader lock for as long as the slowest org's compose takes, times the
+     * number of definitions.
+     */
+    async dueDefinitions(now, limit) {
+        return runWithTenantContext({ isSuperAdmin: true }, async () => {
+            const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)
+                .where(and(eq(schema.reportDefinition.isActive, true), isNull(schema.reportDefinition.deletedAt), lte(schema.reportDefinition.nextRunAt, now)))
+                .orderBy(asc(schema.reportDefinition.nextRunAt))
+                .limit(limit));
+            return rows;
+        });
+    }
+    /**
+     * Claim a due definition by advancing its `nextRunAt`, but only if it still holds
+     * the value the scan saw.
+     *
+     * THE CONDITIONAL UPDATE IS THE CONCURRENCY GUARD, not the leader lock. The lock
+     * stops two replicas sweeping in the same window; it does not stop a sweep that
+     * outlives its lock TTL from overlapping the next leader's sweep, and both would
+     * then select the same still-due definition. Without the `next_run_at = <seen>`
+     * predicate each would advance the schedule and each would compose and DELIVER a
+     * report — the same manager gets the same report twice, from two pods, which is
+     * the failure everyone notices.
+     *
+     * Runs as sysadmin for the same reason as the scan, and returns whether the claim
+     * won so the caller can simply skip a lost race.
+     */
+    async claimDefinition(id, seenNextRunAt, nextRunAt, now = new Date()) {
+        return runWithTenantContext({ isSuperAdmin: true }, async () => {
+            const claimed = await withTenantTx((tx) => tx.update(schema.reportDefinition)
+                .set({ lastRunAt: now, nextRunAt, updatedAt: now })
+                .where(and(eq(schema.reportDefinition.id, id), eq(schema.reportDefinition.nextRunAt, seenNextRunAt)))
+                .returning({ id: schema.reportDefinition.id }));
+            return claimed.length > 0;
+        });
+    }
+    /**
+     * Set (or clear) a definition's `nextRunAt` without claiming it.
+     *
+     * Used when a definition is created, resumed, or has its cadence/timezone changed
+     * — the schedule has to be re-derived from the calendar rather than left at
+     * whatever the old cadence produced.
+     */
+    async setNextRun(orgId, id, nextRunAt) {
+        await withTenantTx((tx) => tx.update(schema.reportDefinition)
+            .set({ nextRunAt, updatedAt: new Date() })
+            .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.id, id), isNull(schema.reportDefinition.deletedAt))));
+    }
+    /**
+     * Pause ONE definition with the reason, from the scheduler.
+     *
+     * Separate from {@link pauseDefinitionsForOwner} because the trigger is different:
+     * that one is a membership change affecting every definition a person owns, this
+     * one is a per-run recheck that failed. Clears `nextRunAt` so a paused definition
+     * stops appearing in the due scan at all, rather than being re-claimed and
+     * re-rejected every cycle.
+     *
+     * Runs as sysadmin: the caller is the scheduler, which has no tenant, and the id
+     * came from its own cross-org scan.
+     */
+    async pauseDefinition(id, reason) {
+        await runWithTenantContext({ isSuperAdmin: true }, async () => {
+            await withTenantTx((tx) => tx.update(schema.reportDefinition)
+                .set({ isActive: false, pausedReason: reason, nextRunAt: null, updatedAt: new Date() })
+                .where(and(eq(schema.reportDefinition.id, id), isNull(schema.reportDefinition.deletedAt))));
+        });
+    }
+    /**
+     * Resume a paused definition, clearing the reason and re-deriving its schedule.
+     *
+     * `nextRunAt` is supplied by the caller rather than computed here: the period
+     * arithmetic needs the definition's timezone and week start, and that belongs with
+     * the period resolver, not the store.
+     */
+    async resumeDefinition(orgId, id, nextRunAt, actorId) {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)
+            .set({ isActive: true, pausedReason: null, nextRunAt, updatedBy: actorId, updatedAt: new Date() })
+            .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.id, id), isNull(schema.reportDefinition.deletedAt)))
+            .returning());
+        const row = rows[0];
+        if (!row)
+            throw new NotFoundError('Report definition not found');
+        return row;
+    }
+    /**
+     * Pause every ACTIVE definition in an org, with the reason.
+     *
+     * The entitlement lapse leg: billing tells reporting the add-on is gone, and every
+     * definition in the account stops. Returns the rows so the caller can notify.
+     */
+    async pauseDefinitionsForOrg(orgId, reason) {
+        const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)
+            .set({ isActive: false, pausedReason: reason, nextRunAt: null, updatedAt: new Date() })
+            .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.isActive, true), isNull(schema.reportDefinition.deletedAt)))
+            .returning());
+        return rows;
+    }
+    /**
+     * Every definition in an org paused for `reason`, for the resume leg.
+     *
+     * Scoped to the reason on purpose: re-subscribing must not un-pause a definition
+     * whose owner was deactivated. Those are different problems with different fixes,
+     * and resuming one by fixing the other is how a report starts running under a
+     * person who left.
+     */
+    async definitionsPausedFor(orgId, reason) {
+        const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)
+            .where(and(eq(schema.reportDefinition.orgId, orgId), eq(schema.reportDefinition.isActive, false), eq(schema.reportDefinition.pausedReason, reason), isNull(schema.reportDefinition.deletedAt))));
+        return rows;
+    }
+}
+export const stakeholderReportStore = new StakeholderReportStore();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../src/api/reporting/stakeholder/store.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Persistence for stakeholder reports: definitions, runs, share links and\n * recipients.\n *\n * Hand-rolled rather than four `CrudService` subclasses because none of these is\n * a generic listable entity with an `isDefault` slot and project-scoped access\n * control. What they need instead is a small number of exact operations with\n * invariants the generic base cannot express:\n *\n *  - A RUN IS APPEND-ONLY once published. Regenerating a period inserts version\n *    N+1 and points the old row at it (`supersededBy`); nothing overwrites a\n *    snapshot a manager has already read.\n *  - A SHARE LINK IS RESOLVED WITHOUT A TENANT. The reader has no account, so the\n *    lookup by token hash is the one read here that deliberately runs as sysadmin\n *    — see {@link resolveShareLink} for why that is the narrowest safe shape.\n *  - A RECIPIENT IS UPSERTED, NEVER RE-CREATED. Re-adding an address must keep its\n *    verification and unsubscribe state, or an unsubscribe could be undone by\n *    deleting and re-adding the row.\n *\n * Everything else runs inside the caller's ambient tenant context (established by\n * `withTenantContext()` at the request boundary), so RLS is the tenancy gate and\n * an `orgId` argument is a redundant second check rather than the only one.\n */\n\nimport { randomUUID, createHash, randomBytes } from 'node:crypto';\nimport { NotFoundError, ConflictError, ErrorCode } from '@pipeline-builder/api-core';\nimport { and, asc, desc, eq, inArray, isNull, lte, sql } from 'drizzle-orm';\nimport { schema } from '../../../database/drizzle-schema.js';\nimport type {\n  ReportCadence,\n  ReportDefinition,\n  ReportPauseReason,\n  ReportRecipient,\n  ReportRun,\n  ReportRunStatus,\n  ReportScope,\n  ReportShareLink,\n  ReportTemplate,\n} from '../../../database/schema/reporting-stakeholder.js';\nimport { runWithTenantContext, withTenantTx } from '../../../database/tenancy.js';\nimport { softDeleteRetentionMs } from '../../crud-service.js';\n\n/** How long a freshly minted share link lives when the caller names no window. */\nexport const DEFAULT_SHARE_LINK_TTL_DAYS = 30;\n/** The longest a share link may live. Beyond this it is a permanent URL. */\nexport const MAX_SHARE_LINK_TTL_DAYS = 180;\n/** A recipient's verification link. Short: it is clicked within minutes or never. */\nexport const VERIFICATION_TTL_MS = 7 * 24 * 60 * 60 * 1000;\n/**\n * Bounces before an address is treated as undeliverable and skipped. Three, not\n * one: a single bounce is often an out-of-office autoresponder or a full mailbox,\n * and dropping a manager off the list for one of those is a silent failure.\n */\nexport const MAX_BOUNCES = 3;\n\n/** SHA-256 hex of a token. The only form any token is ever stored in. */\nexport function hashToken(token: string): string {\n  return createHash('sha256').update(token, 'utf8').digest('hex');\n}\n\n/** A fresh URL-safe token, and its hash. The raw value is returned exactly once. */\nexport function mintToken(): { token: string; tokenHash: string } {\n  const token = randomBytes(32).toString('base64url');\n  return { token, tokenHash: hashToken(token) };\n}\n\n/** What creating a definition needs. */\nexport interface CreateDefinitionInput {\n  orgId: string;\n  name: string;\n  template: ReportTemplate;\n  sections: string[];\n  cadence: ReportCadence;\n  timezone: string;\n  weekStart: 'monday' | 'sunday';\n  scope: ReportScope;\n  recipients: string[];\n  autoSend: boolean;\n  ownerId: string;\n  createdBy: string;\n  nextRunAt?: Date | null;\n}\n\n/** The mutable half of a definition. */\nexport interface UpdateDefinitionInput {\n  name?: string;\n  template?: ReportTemplate;\n  sections?: string[];\n  cadence?: ReportCadence;\n  timezone?: string;\n  weekStart?: 'monday' | 'sunday';\n  scope?: ReportScope;\n  recipients?: string[];\n  autoSend?: boolean;\n  isActive?: boolean;\n  pausedReason?: ReportPauseReason | null;\n  nextRunAt?: Date | null;\n}\n\n/** A share link plus the one-time token, returned only from the mint call. */\nexport interface MintedShareLink {\n  link: ReportShareLink;\n  /** Shown once. Never stored, never logged, never in a response again. */\n  token: string;\n}\n\n/** What the public route needs: the link, its run, and the owning org. */\nexport interface ResolvedShareLink {\n  link: ReportShareLink;\n  run: ReportRun;\n}\n\n/** The `purge_after` stamp a soft-delete carries, or `{}` when purging is off. */\nfunction purgeStamp(now: Date): { purgeAfter?: Date } {\n  const ms = softDeleteRetentionMs();\n  return ms > 0 ? { purgeAfter: new Date(now.getTime() + ms) } : {};\n}\n\nexport class StakeholderReportStore {\n  // ── Definitions ────────────────────────────────────────────────────────────\n\n  async createDefinition(input: CreateDefinitionInput): Promise<ReportDefinition> {\n    const id = randomUUID();\n    const rows = await withTenantTx((tx) => tx.insert(schema.reportDefinition).values({\n      id,\n      orgId: input.orgId,\n      ownerId: input.ownerId,\n      name: input.name,\n      template: input.template,\n      sections: input.sections,\n      cadence: input.cadence,\n      timezone: input.timezone,\n      weekStart: input.weekStart,\n      scope: input.scope,\n      recipients: input.recipients,\n      autoSend: input.autoSend,\n      nextRunAt: input.nextRunAt ?? null,\n      createdBy: input.createdBy,\n    }).returning());\n    return (rows as ReportDefinition[])[0];\n  }\n\n  async listDefinitions(orgId: string): Promise<ReportDefinition[]> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)\n      .where(and(eq(schema.reportDefinition.orgId, orgId), isNull(schema.reportDefinition.deletedAt)))\n      .orderBy(asc(schema.reportDefinition.name)));\n    return rows as ReportDefinition[];\n  }\n\n  async getDefinition(orgId: string, id: string): Promise<ReportDefinition | null> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)\n      .where(and(\n        eq(schema.reportDefinition.id, id),\n        eq(schema.reportDefinition.orgId, orgId),\n        isNull(schema.reportDefinition.deletedAt),\n      ))\n      .limit(1));\n    return (rows as ReportDefinition[])[0] ?? null;\n  }\n\n  /** Throws {@link NotFoundError} rather than returning null, for route bodies. */\n  async requireDefinition(orgId: string, id: string): Promise<ReportDefinition> {\n    const found = await this.getDefinition(orgId, id);\n    if (!found) throw new NotFoundError('Report definition not found');\n    return found;\n  }\n\n  async updateDefinition(\n    orgId: string,\n    id: string,\n    patch: UpdateDefinitionInput,\n    updatedBy: string,\n  ): Promise<ReportDefinition> {\n    const set: Record<string, unknown> = { updatedBy, updatedAt: new Date() };\n    for (const [key, value] of Object.entries(patch)) {\n      if (value !== undefined) set[key] = value;\n    }\n    const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition).set(set)\n      .where(and(\n        eq(schema.reportDefinition.id, id),\n        eq(schema.reportDefinition.orgId, orgId),\n        isNull(schema.reportDefinition.deletedAt),\n      ))\n      .returning());\n    const updated = (rows as ReportDefinition[])[0];\n    if (!updated) throw new NotFoundError('Report definition not found');\n    return updated;\n  }\n\n  /**\n   * Hand a definition to a new owner. The owner is who a scheduled run is\n   * authorized AS, so this is a privilege move, not a metadata edit — the route\n   * checks the new owner is a live member of the org before calling.\n   */\n  async transferOwner(orgId: string, id: string, newOwnerId: string, actorId: string): Promise<ReportDefinition> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)\n      .set({\n        ownerId: newOwnerId,\n        updatedBy: actorId,\n        updatedAt: new Date(),\n        // A definition paused because its previous owner lost access is live again\n        // under an owner who has it. The scheduler re-checks every run anyway, so\n        // the worst case is one more paused run, never a standing grant.\n        isActive: true,\n        pausedReason: null,\n      })\n      .where(and(\n        eq(schema.reportDefinition.id, id),\n        eq(schema.reportDefinition.orgId, orgId),\n        isNull(schema.reportDefinition.deletedAt),\n      ))\n      .returning());\n    const updated = (rows as ReportDefinition[])[0];\n    if (!updated) throw new NotFoundError('Report definition not found');\n    return updated;\n  }\n\n  /**\n   * Pause every definition a user owns, with the reason recorded. Called when the\n   * owner is deactivated or loses `reports:author` — a report must stop when the\n   * person accountable for it can no longer see the data behind it.\n   *\n   * Returns the paused definitions so the caller can notify an org admin: a\n   * silently stopped weekly report is discovered by a manager not receiving it.\n   */\n  async pauseDefinitionsForOwner(\n    orgId: string,\n    ownerId: string,\n    reason: ReportPauseReason,\n  ): Promise<ReportDefinition[]> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)\n      .set({ isActive: false, pausedReason: reason, updatedAt: new Date() })\n      .where(and(\n        eq(schema.reportDefinition.orgId, orgId),\n        eq(schema.reportDefinition.ownerId, ownerId),\n        eq(schema.reportDefinition.isActive, true),\n        isNull(schema.reportDefinition.deletedAt),\n      ))\n      .returning());\n    return rows as ReportDefinition[];\n  }\n\n  async deleteDefinition(orgId: string, id: string, deletedBy: string): Promise<void> {\n    const now = new Date();\n    const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)\n      .set({ deletedAt: now, deletedBy, ...purgeStamp(now) })\n      .where(and(\n        eq(schema.reportDefinition.id, id),\n        eq(schema.reportDefinition.orgId, orgId),\n        isNull(schema.reportDefinition.deletedAt),\n      ))\n      .returning({ id: schema.reportDefinition.id }));\n    if ((rows as unknown[]).length === 0) {\n      throw new NotFoundError('Report definition not found');\n    }\n    // Links to this definition's runs are revoked in the same breath. Deleting a\n    // report while a public URL to last month's numbers keeps working is the kind\n    // of gap nobody notices until it matters.\n    await this.revokeLinksForDefinition(orgId, id, deletedBy);\n  }\n\n  // ── Runs ───────────────────────────────────────────────────────────────────\n\n  /**\n   * Insert a run for a period, or return the existing one.\n   *\n   * Idempotent on (definition, periodStart, version): a retry, a catch-up pass\n   * and a manual backfill can all ask for the same period, and without this each\n   * would insert a row and the lead would review three copies. `onConflictDoNothing`\n   * plus a re-read is deliberate — the unique index is the arbiter, so two pods\n   * racing produce one row whichever wins.\n   */\n  async createRun(input: {\n    orgId: string;\n    definitionId: string;\n    periodStart: Date;\n    periodEnd: Date;\n    periodLabel: string;\n    version?: number;\n    status?: ReportRunStatus;\n    snapshot?: Record<string, unknown> | null;\n    failureReason?: string | null;\n  }): Promise<{ run: ReportRun; created: boolean }> {\n    const version = input.version ?? 1;\n    const id = randomUUID();\n    const rows = await withTenantTx((tx) => tx.insert(schema.reportRun).values({\n      id,\n      orgId: input.orgId,\n      definitionId: input.definitionId,\n      periodStart: input.periodStart,\n      periodEnd: input.periodEnd,\n      periodLabel: input.periodLabel,\n      version,\n      status: input.status ?? 'drafting',\n      snapshot: input.snapshot ?? null,\n      failureReason: input.failureReason ?? null,\n    }).onConflictDoNothing({\n      target: [schema.reportRun.definitionId, schema.reportRun.periodStart, schema.reportRun.version],\n    }).returning());\n    const inserted = (rows as ReportRun[])[0];\n    if (inserted) return { run: inserted, created: true };\n\n    const existing = await withTenantTx((tx) => tx.select().from(schema.reportRun)\n      .where(and(\n        eq(schema.reportRun.definitionId, input.definitionId),\n        eq(schema.reportRun.periodStart, input.periodStart),\n        eq(schema.reportRun.version, version),\n      ))\n      .limit(1));\n    const found = (existing as ReportRun[])[0];\n    if (!found) {\n      // The insert was skipped by the conflict target but nothing is there to\n      // read: the only way is a concurrent delete between the two statements.\n      throw new ConflictError('Report run could not be created', ErrorCode.CONFLICT, {\n        definitionId: input.definitionId,\n        periodLabel: input.periodLabel,\n      });\n    }\n    return { run: found, created: false };\n  }\n\n  /** The next version number for a period: `max(version) + 1`. */\n  async nextVersion(definitionId: string, periodStart: Date): Promise<number> {\n    const rows = await withTenantTx((tx) => tx.select({ version: schema.reportRun.version })\n      .from(schema.reportRun)\n      .where(and(\n        eq(schema.reportRun.definitionId, definitionId),\n        eq(schema.reportRun.periodStart, periodStart),\n      ))\n      .orderBy(desc(schema.reportRun.version))\n      .limit(1));\n    const top = (rows as Array<{ version: number }>)[0];\n    return (top?.version ?? 0) + 1;\n  }\n\n  /** Point an older run at the version that replaced it. */\n  async supersede(orgId: string, oldRunId: string, newRunId: string): Promise<void> {\n    await withTenantTx((tx) => tx.update(schema.reportRun)\n      .set({ supersededBy: newRunId, updatedAt: new Date() })\n      .where(and(eq(schema.reportRun.id, oldRunId), eq(schema.reportRun.orgId, orgId))));\n  }\n\n  async listRuns(orgId: string, definitionId: string, limit = 50): Promise<ReportRun[]> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportRun)\n      .where(and(\n        eq(schema.reportRun.orgId, orgId),\n        eq(schema.reportRun.definitionId, definitionId),\n        isNull(schema.reportRun.deletedAt),\n      ))\n      .orderBy(desc(schema.reportRun.periodStart), desc(schema.reportRun.version))\n      .limit(limit));\n    return rows as ReportRun[];\n  }\n\n  async getRun(orgId: string, id: string): Promise<ReportRun | null> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportRun)\n      .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.deletedAt)))\n      .limit(1));\n    return (rows as ReportRun[])[0] ?? null;\n  }\n\n  async requireRun(orgId: string, id: string): Promise<ReportRun> {\n    const found = await this.getRun(orgId, id);\n    if (!found) throw new NotFoundError('Report run not found');\n    return found;\n  }\n\n  /** Store a computed snapshot and move the run to `ready_for_review`. */\n  async completeRun(\n    orgId: string,\n    id: string,\n    snapshot: Record<string, unknown>,\n    status: ReportRunStatus = 'ready_for_review',\n  ): Promise<ReportRun> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportRun)\n      .set({ snapshot, status, failureReason: null, updatedAt: new Date() })\n      .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.deletedAt)))\n      .returning());\n    const updated = (rows as ReportRun[])[0];\n    if (!updated) throw new NotFoundError('Report run not found');\n    return updated;\n  }\n\n  async failRun(orgId: string, id: string, failureReason: string): Promise<void> {\n    await withTenantTx((tx) => tx.update(schema.reportRun)\n      .set({ status: 'failed', failureReason, updatedAt: new Date() })\n      .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId))));\n  }\n\n  /**\n   * Edit the lead's own words on a run that has NOT been published.\n   *\n   * Refused after publish: the notes are part of what the manager read, and a\n   * report whose narrative can be edited after delivery is a report whose\n   * delivered version cannot be reconstructed. Regenerating produces version N+1,\n   * which is the supported way to correct a published report.\n   */\n  async setRunNotes(\n    orgId: string,\n    id: string,\n    patch: { leadNotes?: string; aiDraft?: string },\n  ): Promise<ReportRun> {\n    const run = await this.requireRun(orgId, id);\n    if (run.status === 'published') {\n      throw new ConflictError(\n        'This report has already been published. Regenerate it to produce a new version with your changes — '\n        + 'the published version stays exactly as the recipients read it.',\n        ErrorCode.CONFLICT,\n        { runId: id, publishedAt: run.publishedAt?.toISOString() },\n      );\n    }\n    const set: Record<string, unknown> = { updatedAt: new Date() };\n    if (patch.leadNotes !== undefined) set.leadNotes = patch.leadNotes;\n    if (patch.aiDraft !== undefined) set.aiDraft = patch.aiDraft;\n    const rows = await withTenantTx((tx) => tx.update(schema.reportRun).set(set)\n      .where(and(eq(schema.reportRun.id, id), eq(schema.reportRun.orgId, orgId), isNull(schema.reportRun.deletedAt)))\n      .returning());\n    return (rows as ReportRun[])[0];\n  }\n\n  /**\n   * Record what happened when a run was delivered.\n   *\n   * Deliberately NOT part of {@link setRunNotes}, which refuses a published run: delivery\n   * happens AT publish, so a method that refused published runs could never record it.\n   * This one writes exactly one column and nothing else, which is why it is safe to allow\n   * after publish — it cannot change a number a recipient has read.\n   */\n  async recordDelivery(orgId: string, id: string, delivery: Record<string, unknown>): Promise<void> {\n    await withTenantTx((tx) => tx.update(schema.reportRun)\n      .set({ delivery, updatedAt: new Date() })\n      .where(and(\n        eq(schema.reportRun.id, id),\n        eq(schema.reportRun.orgId, orgId),\n        isNull(schema.reportRun.deletedAt),\n      )));\n  }\n\n  /**\n   * Publish a run.\n   *\n   * Conditional on the row still being unpublished (`published_at IS NULL`), so\n   * two clicks — or two tabs — produce one publish and one set of deliveries\n   * rather than two. A run with no snapshot cannot be published: there would be\n   * nothing for a recipient to read.\n   */\n  async publishRun(orgId: string, id: string, publishedBy: string): Promise<{ run: ReportRun; alreadyPublished: boolean }> {\n    const run = await this.requireRun(orgId, id);\n    if (run.status === 'failed' || !run.snapshot) {\n      throw new ConflictError(\n        'This report has no computed snapshot, so there is nothing to publish. Regenerate it first.',\n        ErrorCode.CONFLICT,\n        { runId: id, status: run.status },\n      );\n    }\n    const now = new Date();\n    const rows = await withTenantTx((tx) => tx.update(schema.reportRun)\n      .set({ status: 'published', publishedBy, publishedAt: now, updatedAt: now })\n      .where(and(\n        eq(schema.reportRun.id, id),\n        eq(schema.reportRun.orgId, orgId),\n        isNull(schema.reportRun.publishedAt),\n        isNull(schema.reportRun.deletedAt),\n      ))\n      .returning());\n    const published = (rows as ReportRun[])[0];\n    if (published) return { run: published, alreadyPublished: false };\n    // The conditional update matched nothing: someone else published it first.\n    return { run: await this.requireRun(orgId, id), alreadyPublished: true };\n  }\n\n  // ── Share links ────────────────────────────────────────────────────────────\n\n  /**\n   * Mint a read-only link to a published run. The raw token is returned here and\n   * nowhere else — only its hash is stored, so a database copy cannot be turned\n   * back into working URLs.\n   */\n  async createShareLink(input: {\n    orgId: string;\n    runId: string;\n    createdBy: string;\n    ttlDays?: number;\n    redactNames?: boolean;\n    now?: Date;\n  }): Promise<MintedShareLink> {\n    const run = await this.requireRun(input.orgId, input.runId);\n    if (run.status !== 'published') {\n      throw new ConflictError(\n        'Only a published report can be shared. Publish it first — a link to a draft would show numbers the lead has not reviewed.',\n        ErrorCode.CONFLICT,\n        { runId: input.runId, status: run.status },\n      );\n    }\n    const days = Math.min(input.ttlDays ?? DEFAULT_SHARE_LINK_TTL_DAYS, MAX_SHARE_LINK_TTL_DAYS);\n    const now = input.now ?? new Date();\n    const { token, tokenHash } = mintToken();\n    const rows = await withTenantTx((tx) => tx.insert(schema.reportShareLink).values({\n      id: randomUUID(),\n      orgId: input.orgId,\n      runId: input.runId,\n      tokenHash,\n      expiresAt: new Date(now.getTime() + days * 24 * 60 * 60 * 1000),\n      redactNames: input.redactNames ?? false,\n      createdBy: input.createdBy,\n    }).returning());\n    return { link: (rows as ReportShareLink[])[0], token };\n  }\n\n  async listShareLinks(orgId: string, runId: string): Promise<ReportShareLink[]> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportShareLink)\n      .where(and(eq(schema.reportShareLink.orgId, orgId), eq(schema.reportShareLink.runId, runId)))\n      .orderBy(desc(schema.reportShareLink.createdAt)));\n    return rows as ReportShareLink[];\n  }\n\n  async revokeShareLink(orgId: string, id: string, revokedBy: string): Promise<ReportShareLink> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportShareLink)\n      .set({ revokedAt: new Date(), revokedBy })\n      .where(and(\n        eq(schema.reportShareLink.id, id),\n        eq(schema.reportShareLink.orgId, orgId),\n        isNull(schema.reportShareLink.revokedAt),\n      ))\n      .returning());\n    const revoked = (rows as ReportShareLink[])[0];\n    if (!revoked) throw new NotFoundError('Share link not found or already revoked');\n    return revoked;\n  }\n\n  /** Revoke every live link to any run of a definition. Used on delete. */\n  async revokeLinksForDefinition(orgId: string, definitionId: string, revokedBy: string): Promise<number> {\n    const runs = await withTenantTx((tx) => tx.select({ id: schema.reportRun.id }).from(schema.reportRun)\n      .where(and(eq(schema.reportRun.orgId, orgId), eq(schema.reportRun.definitionId, definitionId))));\n    const runIds = (runs as Array<{ id: string }>).map((r) => r.id);\n    if (runIds.length === 0) return 0;\n    const rows = await withTenantTx((tx) => tx.update(schema.reportShareLink)\n      .set({ revokedAt: new Date(), revokedBy })\n      .where(and(\n        eq(schema.reportShareLink.orgId, orgId),\n        inArray(schema.reportShareLink.runId, runIds),\n        isNull(schema.reportShareLink.revokedAt),\n      ))\n      .returning({ id: schema.reportShareLink.id }));\n    return (rows as unknown[]).length;\n  }\n\n  /**\n   * Resolve a share token to its link and run, for the UNAUTHENTICATED public\n   * route.\n   *\n   * This is the one read in this module that runs as sysadmin, and the reason is\n   * structural: the reader holds a token and nothing else — no account, no org,\n   * no JWT — so there is no tenant context for RLS to scope by, and the org can\n   * only be learned FROM the row. The escalation is kept as narrow as the problem:\n   *\n   *  - The sysadmin scope covers the token-hash lookup ONLY. The run is read back\n   *    under the link's OWN org, so a bug in the run query cannot reach another\n   *    tenant's rows.\n   *  - The lookup is by a 256-bit hash on a unique index. It is not a filter a\n   *    caller can widen — there is no other predicate to influence.\n   *  - Expired and revoked links resolve to null here, so the caller cannot\n   *    accidentally serve one by forgetting a check.\n   *\n   * Returns null for every failure — unknown, revoked, expired, or pointing at a\n   * run that is no longer published — so the route answers one indistinguishable\n   * 404 and a holder of a dead link learns nothing about which of those it was.\n   */\n  async resolveShareLink(token: string, now = new Date()): Promise<ResolvedShareLink | null> {\n    const tokenHash = hashToken(token);\n    const links = await runWithTenantContext({ isSuperAdmin: true }, () =>\n      withTenantTx((tx) => tx.select().from(schema.reportShareLink)\n        .where(eq(schema.reportShareLink.tokenHash, tokenHash))\n        .limit(1)));\n    const link = (links as ReportShareLink[])[0];\n    // No constant-time comparison here on purpose: the lookup is an equality match\n    // on a 256-bit hash over a unique index, so there is no secret-dependent branch\n    // in this function to leak. A hand-rolled compare after the database already\n    // decided it would be theatre.\n    if (!link) return null;\n    if (link.revokedAt) return null;\n    if (link.expiresAt.getTime() <= now.getTime()) return null;\n\n    const runs = await runWithTenantContext({ orgId: link.orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.select().from(schema.reportRun)\n        .where(and(\n          eq(schema.reportRun.id, link.runId),\n          eq(schema.reportRun.orgId, link.orgId),\n          eq(schema.reportRun.status, 'published'),\n          isNull(schema.reportRun.deletedAt),\n        ))\n        .limit(1)));\n    const run = (runs as ReportRun[])[0];\n    if (!run) return null;\n    return { link, run };\n  }\n\n  /**\n   * Count one human view of a shared report.\n   *\n   * Separate from {@link resolveShareLink} so the route can serve a link preview,\n   * a HEAD probe or a mail scanner's fetch WITHOUT counting it — a view count that\n   * jumps the moment a link is pasted into Slack tells the lead their manager read\n   * the report when nobody has.\n   */\n  async recordShareView(link: ReportShareLink, now = new Date()): Promise<void> {\n    await runWithTenantContext({ orgId: link.orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.update(schema.reportShareLink)\n        .set({ viewCount: sql`${schema.reportShareLink.viewCount} + 1`, lastViewedAt: now })\n        .where(eq(schema.reportShareLink.id, link.id))));\n  }\n\n  // ── Recipients ─────────────────────────────────────────────────────────────\n\n  /**\n   * Add (or re-add) a delivery address.\n   *\n   * Upserts on (org, email) and deliberately does NOT reset `unsubscribed_at` or\n   * `verified_at`: a lead must not be able to undo someone's unsubscribe by\n   * removing and re-adding them, and an address already verified should not have\n   * to confirm twice. A verification token is minted only when the address is not\n   * yet verified.\n   */\n  async upsertRecipient(input: {\n    orgId: string;\n    email: string;\n    displayName?: string;\n    createdBy: string;\n    /** Set when an admin pre-approved an out-of-domain address. */\n    approvedBy?: string | null;\n    /** Org members skip verification — they already authenticated to this org. */\n    preVerified?: boolean;\n    now?: Date;\n  }): Promise<{ recipient: ReportRecipient; verificationToken?: string }> {\n    const email = input.email.trim().toLowerCase();\n    const now = input.now ?? new Date();\n    const minted = input.preVerified ? undefined : mintToken();\n    // The unsubscribe token is minted for EVERY recipient, member or not, because every\n    // report email carries the link. Minted once and kept: a link in a report from March\n    // has to keep working.\n    const unsub = mintToken();\n    const rows = await withTenantTx((tx) => tx.insert(schema.reportRecipient).values({\n      id: randomUUID(),\n      orgId: input.orgId,\n      email,\n      displayName: input.displayName ?? null,\n      verifiedAt: input.preVerified ? now : null,\n      verificationTokenHash: minted?.tokenHash ?? null,\n      unsubscribeToken: unsub.token,\n      approvedBy: input.approvedBy ?? null,\n      createdBy: input.createdBy,\n    }).onConflictDoUpdate({\n      target: [schema.reportRecipient.orgId, schema.reportRecipient.email],\n      set: {\n        displayName: input.displayName ?? sql`${schema.reportRecipient.displayName}`,\n        // Re-adding a tombstoned recipient revives the row with its history.\n        deletedAt: null,\n        deletedBy: null,\n        purgeAfter: null,\n        approvedBy: input.approvedBy ?? sql`${schema.reportRecipient.approvedBy}`,\n        // Only mint over an UNVERIFIED row; a verified address keeps its state.\n        verificationTokenHash: sql`CASE WHEN ${schema.reportRecipient.verifiedAt} IS NULL\n          THEN ${minted?.tokenHash ?? null} ELSE ${schema.reportRecipient.verificationTokenHash} END`,\n        verifiedAt: input.preVerified\n          ? sql`COALESCE(${schema.reportRecipient.verifiedAt}, ${now})`\n          : sql`${schema.reportRecipient.verifiedAt}`,\n        // COALESCE, never overwrite: re-adding an address must not break the unsubscribe\n        // link in every report already delivered to it.\n        unsubscribeToken: sql`COALESCE(${schema.reportRecipient.unsubscribeToken}, ${unsub.token})`,\n      },\n    }).returning());\n    const recipient = (rows as ReportRecipient[])[0];\n    // The token is only useful if this row actually took it.\n    const tookToken = minted && recipient.verificationTokenHash === minted.tokenHash;\n    return { recipient, ...(tookToken ? { verificationToken: minted.token } : {}) };\n  }\n\n  async listRecipients(orgId: string): Promise<ReportRecipient[]> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportRecipient)\n      .where(and(eq(schema.reportRecipient.orgId, orgId), isNull(schema.reportRecipient.deletedAt)))\n      .orderBy(asc(schema.reportRecipient.email)));\n    return rows as ReportRecipient[];\n  }\n\n  async getRecipients(orgId: string, ids: string[]): Promise<ReportRecipient[]> {\n    if (ids.length === 0) return [];\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportRecipient)\n      .where(and(\n        eq(schema.reportRecipient.orgId, orgId),\n        inArray(schema.reportRecipient.id, ids),\n        isNull(schema.reportRecipient.deletedAt),\n      )));\n    return rows as ReportRecipient[];\n  }\n\n  /** Mint a fresh verification token for a recipient that has not confirmed yet. */\n  async resendVerification(orgId: string, id: string): Promise<{ recipient: ReportRecipient; token: string }> {\n    const { token, tokenHash } = mintToken();\n    const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)\n      .set({ verificationTokenHash: tokenHash })\n      .where(and(\n        eq(schema.reportRecipient.id, id),\n        eq(schema.reportRecipient.orgId, orgId),\n        isNull(schema.reportRecipient.verifiedAt),\n        isNull(schema.reportRecipient.deletedAt),\n      ))\n      .returning());\n    const recipient = (rows as ReportRecipient[])[0];\n    if (!recipient) {\n      throw new ConflictError(\n        'This recipient is already verified, or no longer exists.',\n        ErrorCode.CONFLICT,\n        { recipientId: id },\n      );\n    }\n    return { recipient, token };\n  }\n\n  /**\n   * Confirm an address from the emailed token. Cross-org by necessity (the person\n   * clicking has no session), so it runs as sysadmin over a unique 256-bit hash —\n   * the same shape, and the same reasoning, as {@link resolveShareLink}.\n   *\n   * The token is CONSUMED: it is cleared on success, so a forwarded confirmation\n   * link cannot be replayed by whoever the mail was forwarded to.\n   */\n  async verifyRecipientByToken(token: string, now = new Date()): Promise<ReportRecipient | null> {\n    const tokenHash = hashToken(token);\n    const rows = await runWithTenantContext({ isSuperAdmin: true }, () =>\n      withTenantTx((tx) => tx.update(schema.reportRecipient)\n        .set({ verifiedAt: now, verificationTokenHash: null })\n        .where(and(\n          eq(schema.reportRecipient.verificationTokenHash, tokenHash),\n          isNull(schema.reportRecipient.verifiedAt),\n          isNull(schema.reportRecipient.deletedAt),\n          // A token older than the window is not accepted. `created_at` is the\n          // floor for the first token; a resend refreshes the hash, so this bounds\n          // the original mint and is deliberately generous.\n          sql`${schema.reportRecipient.createdAt} > ${new Date(now.getTime() - VERIFICATION_TTL_MS)}`,\n        ))\n        .returning()));\n    return (rows as ReportRecipient[])[0] ?? null;\n  }\n\n  /** Honour an unsubscribe across every definition in the org. */\n  async unsubscribeByEmail(orgId: string, email: string, now = new Date()): Promise<boolean> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)\n      .set({ unsubscribedAt: now })\n      .where(and(\n        eq(schema.reportRecipient.orgId, orgId),\n        eq(schema.reportRecipient.email, email.trim().toLowerCase()),\n        isNull(schema.reportRecipient.unsubscribedAt),\n      ))\n      .returning({ id: schema.reportRecipient.id }));\n    return (rows as unknown[]).length > 0;\n  }\n\n  /**\n   * Honour an unsubscribe from the link in a report email.\n   *\n   * Looked up by TOKEN across orgs, as sysadmin, for the same reason the share-link\n   * resolve is: the person clicking has no account and no tenant, and the token is the\n   * only thing that identifies the row. It is the narrowest possible shape — one indexed\n   * lookup, one column written, nothing returned to the caller but whether a row\n   * matched.\n   *\n   * Idempotent. A mail client that sends the one-click POST twice, or a manager who\n   * clicks again months later, gets the same answer rather than an error page — the\n   * second call finds the row already unsubscribed and reports success, because from the\n   * clicker's point of view it is.\n   */\n  async unsubscribeByToken(token: string, now = new Date()): Promise<boolean> {\n    if (token.length < 16) return false;\n    return runWithTenantContext({ isSuperAdmin: true }, async () => {\n      const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)\n        .set({ unsubscribedAt: sql`COALESCE(${schema.reportRecipient.unsubscribedAt}, ${now})` })\n        .where(eq(schema.reportRecipient.unsubscribeToken, token))\n        .returning({ id: schema.reportRecipient.id }));\n      return (rows as unknown[]).length > 0;\n    });\n  }\n\n  /** Record a delivery bounce. At {@link MAX_BOUNCES} the address is skipped. */\n  async recordBounce(orgId: string, email: string, now = new Date()): Promise<number> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)\n      .set({ bounceCount: sql`${schema.reportRecipient.bounceCount} + 1`, lastBounceAt: now })\n      .where(and(\n        eq(schema.reportRecipient.orgId, orgId),\n        eq(schema.reportRecipient.email, email.trim().toLowerCase()),\n      ))\n      .returning({ bounceCount: schema.reportRecipient.bounceCount }));\n    return (rows as Array<{ bounceCount: number }>)[0]?.bounceCount ?? 0;\n  }\n\n  async deleteRecipient(orgId: string, id: string, deletedBy: string): Promise<void> {\n    const now = new Date();\n    const rows = await withTenantTx((tx) => tx.update(schema.reportRecipient)\n      .set({ deletedAt: now, deletedBy, ...purgeStamp(now) })\n      .where(and(\n        eq(schema.reportRecipient.id, id),\n        eq(schema.reportRecipient.orgId, orgId),\n        isNull(schema.reportRecipient.deletedAt),\n      ))\n      .returning({ id: schema.reportRecipient.id }));\n    if ((rows as unknown[]).length === 0) {\n      throw new NotFoundError('Recipient not found');\n    }\n  }\n\n  /**\n   * Is this address deliverable right now? The single place the delivery rules\n   * live, so the scheduler and the UI agree about why a recipient is being\n   * skipped.\n   */\n  deliverability(recipient: ReportRecipient): { deliverable: boolean; reason?: string } {\n    if (recipient.deletedAt) return { deliverable: false, reason: 'removed' };\n    if (recipient.unsubscribedAt) return { deliverable: false, reason: 'unsubscribed' };\n    if (!recipient.verifiedAt) return { deliverable: false, reason: 'pending_verification' };\n    if (recipient.bounceCount >= MAX_BOUNCES) return { deliverable: false, reason: 'bouncing' };\n    return { deliverable: true };\n  }\n\n  // ── Recipient policy ───────────────────────────────────────────────────────\n\n  /**\n   * The org's admin-owned report policy. Read through the reporting settings row,\n   * which may not exist — an org that has never configured anything gets the\n   * closed defaults (no external sharing, no external domains, approval required).\n   */\n  async getReportPolicy(orgId: string): Promise<{\n    externalSharing: boolean;\n    recipientDomains: string[] | null;\n    requireApproval: boolean;\n    defaultTimezone: string | null;\n    defaultWeekStart: string | null;\n  }> {\n    const rows = await withTenantTx((tx) => tx.select({\n      externalSharing: schema.doraSettings.reportExternalSharing,\n      recipientDomains: schema.doraSettings.reportRecipientDomains,\n      requireApproval: schema.doraSettings.reportRequireApproval,\n      defaultTimezone: schema.doraSettings.reportDefaultTimezone,\n      defaultWeekStart: schema.doraSettings.reportDefaultWeekStart,\n    }).from(schema.doraSettings).where(eq(schema.doraSettings.orgId, orgId)).limit(1));\n    const row = (rows as Array<{\n      externalSharing: boolean;\n      recipientDomains: string[] | null;\n      requireApproval: boolean;\n      defaultTimezone: string | null;\n      defaultWeekStart: string | null;\n    }>)[0];\n    return {\n      externalSharing: row?.externalSharing ?? false,\n      recipientDomains: row?.recipientDomains ?? null,\n      requireApproval: row?.requireApproval ?? true,\n      // NULL rather than a guessed zone: the create form falls back to the BROWSER's zone,\n      // which is a better default than the server's and is visibly the lead's own.\n      defaultTimezone: row?.defaultTimezone ?? null,\n      defaultWeekStart: row?.defaultWeekStart ?? null,\n    };\n  }\n\n  async setReportPolicy(orgId: string, patch: {\n    externalSharing?: boolean;\n    recipientDomains?: string[] | null;\n    requireApproval?: boolean;\n    defaultTimezone?: string | null;\n    defaultWeekStart?: string | null;\n  }): Promise<void> {\n    const set: Record<string, unknown> = { updatedAt: new Date() };\n    if (patch.externalSharing !== undefined) set.reportExternalSharing = patch.externalSharing;\n    if (patch.recipientDomains !== undefined) set.reportRecipientDomains = patch.recipientDomains;\n    if (patch.requireApproval !== undefined) set.reportRequireApproval = patch.requireApproval;\n    if (patch.defaultTimezone !== undefined) set.reportDefaultTimezone = patch.defaultTimezone;\n    if (patch.defaultWeekStart !== undefined) set.reportDefaultWeekStart = patch.defaultWeekStart;\n    await withTenantTx((tx) => tx.insert(schema.doraSettings).values({\n      orgId,\n      reportExternalSharing: patch.externalSharing ?? false,\n      reportRecipientDomains: patch.recipientDomains ?? null,\n      reportRequireApproval: patch.requireApproval ?? true,\n      reportDefaultTimezone: patch.defaultTimezone ?? null,\n      reportDefaultWeekStart: patch.defaultWeekStart ?? null,\n    }).onConflictDoUpdate({ target: schema.doraSettings.orgId, set }));\n  }\n\n  /**\n   * Apply a Stakeholder Reports entitlement change from billing: pause everything, or\n   * resume what the lapse paused.\n   *\n   * THE WATERMARK AND THE WORK ARE ONE TRANSACTION, and the watermark update is what\n   * serializes concurrent pushes. Billing's legs are best-effort and retried, so\n   * \"lapsed at 10:00\" and \"renewed at 10:05\" can arrive in either order; applying the\n   * older one last would leave a lapsed account producing reports, or a paying one\n   * paused. The conditional update takes a row lock on `dora_settings`, so a second\n   * push waits and then sees the newer watermark — no advisory lock needed.\n   *\n   * RESUME IS SCOPED TO `entitlement`. It must not un-pause a definition whose OWNER was\n   * deactivated or who lost the permission: those are different problems with different\n   * fixes, and resuming one by fixing the other is how a report starts running under\n   * somebody who left.\n   *\n   * `nextRunFor` is a callback because the period arithmetic needs each definition's\n   * cadence, timezone and week start, and that belongs with the period resolver rather\n   * than the store — while the write still has to happen inside this transaction.\n   *\n   * This leg makes the change IMMEDIATE; it is not what makes it safe. Every scheduled\n   * run re-checks the entitlement against platform anyway, so a lost push delays\n   * enforcement to the next run rather than defeating it.\n   */\n  async syncReportEntitlement(\n    orgId: string,\n    entitled: boolean,\n    opts: { occurredAt?: Date; nextRunFor?: (d: ReportDefinition) => Date; now?: Date } = {},\n  ): Promise<{ skipped: boolean; paused: ReportDefinition[]; resumed: ReportDefinition[] }> {\n    const now = opts.now ?? new Date();\n    const occurredAt = opts.occurredAt ?? now;\n    return withTenantTx(async (tx) => {\n      // The claim. A push at or before the last applied change updates zero rows.\n      const claimed = await tx.insert(schema.doraSettings)\n        .values({ orgId, reportEntitlementSyncedAt: occurredAt })\n        .onConflictDoUpdate({\n          target: schema.doraSettings.orgId,\n          set: { reportEntitlementSyncedAt: occurredAt, updatedAt: now },\n          setWhere: sql`${schema.doraSettings.reportEntitlementSyncedAt} IS NULL\n            OR ${schema.doraSettings.reportEntitlementSyncedAt} < ${occurredAt}`,\n        })\n        .returning({ orgId: schema.doraSettings.orgId });\n      if ((claimed as unknown[]).length === 0) {\n        return { skipped: true, paused: [], resumed: [] };\n      }\n\n      if (!entitled) {\n        const rows = await tx.update(schema.reportDefinition)\n          .set({ isActive: false, pausedReason: 'entitlement', nextRunAt: null, updatedAt: now })\n          .where(and(\n            eq(schema.reportDefinition.orgId, orgId),\n            eq(schema.reportDefinition.isActive, true),\n            isNull(schema.reportDefinition.deletedAt),\n          ))\n          .returning();\n        return { skipped: false, paused: rows as ReportDefinition[], resumed: [] };\n      }\n\n      const paused = await tx.select().from(schema.reportDefinition)\n        .where(and(\n          eq(schema.reportDefinition.orgId, orgId),\n          eq(schema.reportDefinition.isActive, false),\n          eq(schema.reportDefinition.pausedReason, 'entitlement'),\n          isNull(schema.reportDefinition.deletedAt),\n        )) as ReportDefinition[];\n      const resumed: ReportDefinition[] = [];\n      for (const definition of paused) {\n        const rows = await tx.update(schema.reportDefinition)\n          .set({\n            isActive: true,\n            pausedReason: null,\n            nextRunAt: opts.nextRunFor ? opts.nextRunFor(definition) : null,\n            updatedAt: now,\n          })\n          .where(eq(schema.reportDefinition.id, definition.id))\n          .returning();\n        const row = (rows as ReportDefinition[])[0];\n        if (row) resumed.push(row);\n      }\n      return { skipped: false, paused: [], resumed };\n    });\n  }\n\n  // ── The free preview ───────────────────────────────────────────────────────\n\n  /**\n   * Claim the org's ONE free preview, or report that it is already spent.\n   *\n   * A CONDITIONAL insert-or-update, not read-then-write: two tabs clicking \"see a sample\"\n   * at the same moment must produce one preview, and a check followed by a separate write\n   * has a window between them wide enough for both to pass. `WHERE report_preview_used_at\n   * IS NULL` on the update, and `onConflictDoUpdate` for the row that may not exist yet,\n   * make the claim itself the guard.\n   *\n   * Returns whether THIS caller won it. A loser is told the preview is spent, which is\n   * the truth and is also the upsell.\n   */\n  async claimReportPreview(orgId: string, now = new Date()): Promise<boolean> {\n    const rows = await withTenantTx((tx) => tx.insert(schema.doraSettings)\n      .values({ orgId, reportPreviewUsedAt: now })\n      .onConflictDoUpdate({\n        target: schema.doraSettings.orgId,\n        set: { reportPreviewUsedAt: now, updatedAt: now },\n        // The predicate is what makes this once-ever: an org whose row already carries a\n        // timestamp updates zero rows and returns nothing.\n        setWhere: isNull(schema.doraSettings.reportPreviewUsedAt),\n      })\n      .returning({ orgId: schema.doraSettings.orgId }));\n    return (rows as unknown[]).length > 0;\n  }\n\n  /** Whether the org has already spent its free preview. */\n  async reportPreviewUsed(orgId: string): Promise<boolean> {\n    const rows = await withTenantTx((tx) => tx.select({ at: schema.doraSettings.reportPreviewUsedAt })\n      .from(schema.doraSettings)\n      .where(eq(schema.doraSettings.orgId, orgId))\n      .limit(1));\n    return (rows as Array<{ at: Date | null }>)[0]?.at != null;\n  }\n\n  /**\n   * Is `email` admissible as a recipient for this org, and does it need an\n   * admin's approval first?\n   *\n   * `orgMemberEmails` is the set of addresses that already authenticate to this\n   * org — they are always admissible and never need verification, because the org\n   * has already established they belong to it. Everything else is measured against\n   * the allowed-domain list, and a NULL list means \"no external addresses at all\",\n   * not \"any address\": the closed reading is the one that cannot leak a report by\n   * an admin forgetting to configure something.\n   */\n  admitRecipient(\n    email: string,\n    policy: { recipientDomains: string[] | null; requireApproval: boolean },\n    orgMemberEmails: ReadonlySet<string>,\n  ): { admitted: true; member: boolean; needsApproval: boolean } | { admitted: false; reason: string } {\n    const normalized = email.trim().toLowerCase();\n    if (orgMemberEmails.has(normalized)) return { admitted: true, member: true, needsApproval: false };\n\n    const at = normalized.lastIndexOf('@');\n    const domain = at >= 0 ? normalized.slice(at + 1) : '';\n    if (!domain) return { admitted: false, reason: 'Not a valid email address.' };\n\n    const allowed = policy.recipientDomains;\n    if (!allowed || allowed.length === 0) {\n      return {\n        admitted: false,\n        reason: 'This organization only delivers reports to its own members. '\n          + 'An administrator can allow specific external domains in reporting settings.',\n      };\n    }\n    const ok = allowed.some((d) => {\n      const clean = d.trim().toLowerCase().replace(/^@/, '');\n      return clean.length > 0 && (domain === clean || domain.endsWith(`.${clean}`));\n    });\n    if (!ok) {\n      return {\n        admitted: false,\n        reason: `Reports can only be sent to ${allowed.join(', ')} addresses in this organization.`,\n      };\n    }\n    return { admitted: true, member: false, needsApproval: policy.requireApproval };\n  }\n\n  // ── Retention ──────────────────────────────────────────────────────────────\n\n  /**\n   * Hard-delete expired tombstones across every org, for the shared soft-delete\n   * sweep. Runs inside the sweep's own sysadmin scope.\n   *\n   * Runs go first: a purged definition with orphaned runs would leave snapshots\n   * nothing can reach, and share links are deleted with their runs so a purge\n   * cannot leave a live token pointing at a row that no longer exists.\n   */\n  purgeableEntities(): Array<{ name: string; purgeExpired(now: Date, limit?: number): Promise<number> }> {\n    return [\n      { name: 'report_run', purgeExpired: (now, limit) => this.purgeRuns(now, limit) },\n      { name: 'report_definition', purgeExpired: (now, limit) => this.purgeDefinitions(now, limit) },\n      { name: 'report_recipient', purgeExpired: (now, limit) => this.purgeRecipients(now, limit) },\n    ];\n  }\n\n  private async purgeRuns(now: Date, limit = 500): Promise<number> {\n    return withTenantTx(async (tx) => {\n      const due = await tx.select({ id: schema.reportRun.id }).from(schema.reportRun)\n        .where(and(sql`${schema.reportRun.deletedAt} IS NOT NULL`, lte(schema.reportRun.purgeAfter, now)))\n        .limit(limit);\n      const ids = (due as Array<{ id: string }>).map((r) => r.id);\n      if (ids.length === 0) return 0;\n      await tx.delete(schema.reportShareLink).where(inArray(schema.reportShareLink.runId, ids));\n      const gone = await tx.delete(schema.reportRun).where(inArray(schema.reportRun.id, ids))\n        .returning({ id: schema.reportRun.id });\n      return (gone as unknown[]).length;\n    });\n  }\n\n  private async purgeDefinitions(now: Date, limit = 500): Promise<number> {\n    return withTenantTx(async (tx) => {\n      const due = await tx.select({ id: schema.reportDefinition.id }).from(schema.reportDefinition)\n        .where(and(\n          sql`${schema.reportDefinition.deletedAt} IS NOT NULL`,\n          lte(schema.reportDefinition.purgeAfter, now),\n        ))\n        .limit(limit);\n      const ids = (due as Array<{ id: string }>).map((r) => r.id);\n      if (ids.length === 0) return 0;\n      // The definition's runs (and their links) go with it, tombstoned or not:\n      // a snapshot whose definition is gone can never be listed again.\n      const runs = await tx.select({ id: schema.reportRun.id }).from(schema.reportRun)\n        .where(inArray(schema.reportRun.definitionId, ids));\n      const runIds = (runs as Array<{ id: string }>).map((r) => r.id);\n      if (runIds.length > 0) {\n        await tx.delete(schema.reportShareLink).where(inArray(schema.reportShareLink.runId, runIds));\n        await tx.delete(schema.reportRun).where(inArray(schema.reportRun.id, runIds));\n      }\n      const gone = await tx.delete(schema.reportDefinition).where(inArray(schema.reportDefinition.id, ids))\n        .returning({ id: schema.reportDefinition.id });\n      return (gone as unknown[]).length;\n    });\n  }\n\n  private async purgeRecipients(now: Date, limit = 500): Promise<number> {\n    return withTenantTx(async (tx) => {\n      const due = await tx.select({ id: schema.reportRecipient.id }).from(schema.reportRecipient)\n        .where(and(\n          sql`${schema.reportRecipient.deletedAt} IS NOT NULL`,\n          lte(schema.reportRecipient.purgeAfter, now),\n        ))\n        .limit(limit);\n      const ids = (due as Array<{ id: string }>).map((r) => r.id);\n      if (ids.length === 0) return 0;\n      const gone = await tx.delete(schema.reportRecipient).where(inArray(schema.reportRecipient.id, ids))\n        .returning({ id: schema.reportRecipient.id });\n      return (gone as unknown[]).length;\n    });\n  }\n\n  /** Every definition the owner must be re-checked for, for the pause sweep. */\n  async listOwnedDefinitions(orgId: string, ownerId: string): Promise<ReportDefinition[]> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)\n      .where(and(\n        eq(schema.reportDefinition.orgId, orgId),\n        eq(schema.reportDefinition.ownerId, ownerId),\n        isNull(schema.reportDefinition.deletedAt),\n      )));\n    return rows as ReportDefinition[];\n  }\n\n  // ── The scheduler's reads and writes ───────────────────────────────────────\n\n  /**\n   * Definitions whose next run is due, across every org.\n   *\n   * Runs as SYSADMIN, because the scheduler has no tenant: it is looking for work\n   * in orgs it has not been told about. This is the one read here that crosses org\n   * boundaries, and it is kept to the narrowest possible shape — the rows needed to\n   * claim and execute, ordered oldest-due first so a backlog drains in order rather\n   * than starving whichever org sorts last by id.\n   *\n   * `limit` is the per-cycle ceiling: a cycle that tried to drain everything would\n   * hold the leader lock for as long as the slowest org's compose takes, times the\n   * number of definitions.\n   */\n  async dueDefinitions(now: Date, limit: number): Promise<ReportDefinition[]> {\n    return runWithTenantContext({ isSuperAdmin: true }, async () => {\n      const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)\n        .where(and(\n          eq(schema.reportDefinition.isActive, true),\n          isNull(schema.reportDefinition.deletedAt),\n          lte(schema.reportDefinition.nextRunAt, now),\n        ))\n        .orderBy(asc(schema.reportDefinition.nextRunAt))\n        .limit(limit));\n      return rows as ReportDefinition[];\n    });\n  }\n\n  /**\n   * Claim a due definition by advancing its `nextRunAt`, but only if it still holds\n   * the value the scan saw.\n   *\n   * THE CONDITIONAL UPDATE IS THE CONCURRENCY GUARD, not the leader lock. The lock\n   * stops two replicas sweeping in the same window; it does not stop a sweep that\n   * outlives its lock TTL from overlapping the next leader's sweep, and both would\n   * then select the same still-due definition. Without the `next_run_at = <seen>`\n   * predicate each would advance the schedule and each would compose and DELIVER a\n   * report — the same manager gets the same report twice, from two pods, which is\n   * the failure everyone notices.\n   *\n   * Runs as sysadmin for the same reason as the scan, and returns whether the claim\n   * won so the caller can simply skip a lost race.\n   */\n  async claimDefinition(id: string, seenNextRunAt: Date, nextRunAt: Date, now = new Date()): Promise<boolean> {\n    return runWithTenantContext({ isSuperAdmin: true }, async () => {\n      const claimed = await withTenantTx((tx) => tx.update(schema.reportDefinition)\n        .set({ lastRunAt: now, nextRunAt, updatedAt: now })\n        .where(and(\n          eq(schema.reportDefinition.id, id),\n          eq(schema.reportDefinition.nextRunAt, seenNextRunAt),\n        ))\n        .returning({ id: schema.reportDefinition.id }));\n      return (claimed as unknown[]).length > 0;\n    });\n  }\n\n  /**\n   * Set (or clear) a definition's `nextRunAt` without claiming it.\n   *\n   * Used when a definition is created, resumed, or has its cadence/timezone changed\n   * — the schedule has to be re-derived from the calendar rather than left at\n   * whatever the old cadence produced.\n   */\n  async setNextRun(orgId: string, id: string, nextRunAt: Date | null): Promise<void> {\n    await withTenantTx((tx) => tx.update(schema.reportDefinition)\n      .set({ nextRunAt, updatedAt: new Date() })\n      .where(and(\n        eq(schema.reportDefinition.orgId, orgId),\n        eq(schema.reportDefinition.id, id),\n        isNull(schema.reportDefinition.deletedAt),\n      )));\n  }\n\n  /**\n   * Pause ONE definition with the reason, from the scheduler.\n   *\n   * Separate from {@link pauseDefinitionsForOwner} because the trigger is different:\n   * that one is a membership change affecting every definition a person owns, this\n   * one is a per-run recheck that failed. Clears `nextRunAt` so a paused definition\n   * stops appearing in the due scan at all, rather than being re-claimed and\n   * re-rejected every cycle.\n   *\n   * Runs as sysadmin: the caller is the scheduler, which has no tenant, and the id\n   * came from its own cross-org scan.\n   */\n  async pauseDefinition(id: string, reason: ReportPauseReason): Promise<void> {\n    await runWithTenantContext({ isSuperAdmin: true }, async () => {\n      await withTenantTx((tx) => tx.update(schema.reportDefinition)\n        .set({ isActive: false, pausedReason: reason, nextRunAt: null, updatedAt: new Date() })\n        .where(and(\n          eq(schema.reportDefinition.id, id),\n          isNull(schema.reportDefinition.deletedAt),\n        )));\n    });\n  }\n\n  /**\n   * Resume a paused definition, clearing the reason and re-deriving its schedule.\n   *\n   * `nextRunAt` is supplied by the caller rather than computed here: the period\n   * arithmetic needs the definition's timezone and week start, and that belongs with\n   * the period resolver, not the store.\n   */\n  async resumeDefinition(orgId: string, id: string, nextRunAt: Date, actorId: string): Promise<ReportDefinition> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)\n      .set({ isActive: true, pausedReason: null, nextRunAt, updatedBy: actorId, updatedAt: new Date() })\n      .where(and(\n        eq(schema.reportDefinition.orgId, orgId),\n        eq(schema.reportDefinition.id, id),\n        isNull(schema.reportDefinition.deletedAt),\n      ))\n      .returning());\n    const row = (rows as ReportDefinition[])[0];\n    if (!row) throw new NotFoundError('Report definition not found');\n    return row;\n  }\n\n  /**\n   * Pause every ACTIVE definition in an org, with the reason.\n   *\n   * The entitlement lapse leg: billing tells reporting the add-on is gone, and every\n   * definition in the account stops. Returns the rows so the caller can notify.\n   */\n  async pauseDefinitionsForOrg(orgId: string, reason: ReportPauseReason): Promise<ReportDefinition[]> {\n    const rows = await withTenantTx((tx) => tx.update(schema.reportDefinition)\n      .set({ isActive: false, pausedReason: reason, nextRunAt: null, updatedAt: new Date() })\n      .where(and(\n        eq(schema.reportDefinition.orgId, orgId),\n        eq(schema.reportDefinition.isActive, true),\n        isNull(schema.reportDefinition.deletedAt),\n      ))\n      .returning());\n    return rows as ReportDefinition[];\n  }\n\n  /**\n   * Every definition in an org paused for `reason`, for the resume leg.\n   *\n   * Scoped to the reason on purpose: re-subscribing must not un-pause a definition\n   * whose owner was deactivated. Those are different problems with different fixes,\n   * and resuming one by fixing the other is how a report starts running under a\n   * person who left.\n   */\n  async definitionsPausedFor(orgId: string, reason: ReportPauseReason): Promise<ReportDefinition[]> {\n    const rows = await withTenantTx((tx) => tx.select().from(schema.reportDefinition)\n      .where(and(\n        eq(schema.reportDefinition.orgId, orgId),\n        eq(schema.reportDefinition.isActive, false),\n        eq(schema.reportDefinition.pausedReason, reason),\n        isNull(schema.reportDefinition.deletedAt),\n      )));\n    return rows as ReportDefinition[];\n  }\n}\n\nexport const stakeholderReportStore = new StakeholderReportStore();\n"]}