@bridge-ds/core 0.19.0 → 0.20.0

package/dist/review-gate.d.ts

@@ -247,6 +247,12 @@ export interface BranchVerdictInput {
      * approval was in (/api/ship, decision TV-1). With `tokenValues` and the design approval, it reads `autoShip`.
      */
     autoMerge?: boolean | null | undefined;
+    /**
+     * A lead published this Tier 1 change without review (the app's review starts with TIER1_PUBLISH_HEADING, on the
+     * head commit; docs/GOVERNANCE.md "Tier 1 publish by leads"). With `autoMerge` and the checks not failing, it reads
+     * `autoShip`. A failing check drops it back to review: the status reads as any other change waiting for an approval.
+     */
+    tier1Published?: boolean | null | undefined;
     /**
      * The reviewers to look again (lookAgainReviewers over the reviews and the head sha): the author updated the branch
      * after every changes request. The status stays `changes-requested` and the merge stays blocked; only its words say

package/dist/suggestion-review.d.ts

@@ -1,5 +1,5 @@
-import type { Owners } from './config';
-import { type ApprovalRole, type ApprovalSummary } from './review-gate';
+import type { OverridePolicy, Owners } from './config';
+import { type ApprovalRole, type ApprovalSummary, type MissingApproval } from './review-gate';
 import { type Rights } from './rights';
 import type { RiskTier } from './risk';
 import type { TeamStates } from './teams';
@@ -51,13 +51,54 @@ export interface SuggestionGovernance {
     teams?: TeamStates | null | undefined;
     /** `governance.soloOwnerCanApproveBoth`: the only owner's approval covers design and tech (review-gate summarizeApprovals). */
     soloOwnerCanApproveBoth?: boolean | undefined;
+    /**
+     * `governance.override`: an owner it allows, whom nobody else can review, approves their own suggestion as owner with
+     * a written reason (suggestionOverrideOf, docs/GOVERNANCE.md "Owner override"). Absent: no override.
+     */
+    override?: OverridePolicy | null | undefined;
 }
 export interface SuggestionApprovals extends ApprovalSummary {
     /** People whose latest review is on an older payload: it no longer counts. */
     stale: string[];
     /** People whose review does not count because they are not owners (or not collaborators when no owner is set). */
     ignored: string[];
+    /** Approved with the owner override on this version (suggestionOverrideOf): who, why, and what it went without. */
+    override?: SuggestionOverrideRecord | undefined;
 }
+export declare const SUGGESTION_OVERRIDE_MARK = "bridge-suggestion-override";
+export interface SuggestionOverrideRecord {
+    login: string;
+    reason: string;
+    missing: string[];
+    /** The version it was approved on (suggestionPayloadSha). */
+    payloadSha: string;
+}
+/** The override comment: the PR override's audit line ("Approved as owner from Bridge."), the version, the record. */
+export declare function composeSuggestionOverrideComment(r: {
+    login: string;
+    reason: string;
+    missing: MissingApproval[];
+    payloadSha: string;
+}): string;
+/** Reads an override comment on a suggestion back; null for any other comment. */
+export declare function parseSuggestionOverrideComment(body: string | null | undefined): SuggestionOverrideRecord | null;
+/**
+ * Who may approve this suggestion as owner, and why not: an owner `governance.override` allows (overrideHolders), on
+ * their own suggestion, when nobody else in the approver lists can review it. Null when they may.
+ */
+export declare function suggestionOverrideProblem(x: {
+    viewer: string | null | undefined;
+    author: string;
+    gov: SuggestionGovernance;
+}): string | null;
+/**
+ * The owner override in force on this version: the latest override comment for `payloadSha`, posted by the person it
+ * names, who may use it (suggestionOverrideProblem) with a reason long enough. Null otherwise.
+ */
+export declare function suggestionOverrideOf(comments: readonly SuggestionCommentLike[], gov: SuggestionGovernance, opts: {
+    payloadSha: string;
+    author?: string | null | undefined;
+}): SuggestionOverrideRecord | null;
 /**
  * Approvals on a suggestion, as summarizeApprovals counts them on a pull request, from the review comments: only
  * comments by people in the approver lists (governance owners and rights) count; with no owner configured at all, only

package/dist/suggestions-github.d.ts

@@ -2,7 +2,7 @@ import { GitHubClient, type IssueSummary, type PullRequestSummary } from './gith
 import { type Requester } from './requester';
 import { type SuggestionAppliedRecord, type SuggestionApprovals, type SuggestionCommentLike, type SuggestionGovernance, type SuggestionReviewEvent } from './suggestion-review';
 import { type ComposeSuggestionOptions, type ParsedSuggestion, type SuggestionKind, type SuggestionPayloadV1, type SuggestionStatus } from './suggestions';
-import type { ApprovalRole } from './review-gate';
+import { type ApprovalRole } from './review-gate';
 import { type BridgeConfig } from './config';
 import { type SuggestionApplyOp, type SuggestionApplyPlan, type SuggestionWorkspace } from './suggestion-apply';
 export interface CreatedSuggestion {
@@ -174,6 +174,17 @@ export declare function reviewSuggestionOnGitHub(gh: GitHubClient, n: number, in
     by?: string | undefined;
     at?: Date | undefined;
 }, gov: SuggestionGovernance): Promise<SuggestionReviewResult>;
+/**
+ * The owner override on a suggestion (docs/GOVERNANCE.md "Owner override"): the owner it allows, whom nobody else can
+ * review, approves their own suggestion as owner with a written reason. Checks the rule (suggestionOverrideProblem),
+ * the reason (overrideReasonProblem), the version, then posts the audit comment and re-syncs the state label. A
+ * developer then applies it as any approved suggestion; the pull request carries the approvals.
+ */
+export declare function overrideSuggestionOnGitHub(gh: GitHubClient, n: number, input: {
+    reason: string;
+    payloadSha?: string | undefined;
+    by?: string | undefined;
+}, gov: SuggestionGovernance): Promise<SuggestionReviewResult>;
 /**
  * Records that a suggestion is being applied (the applied marker comment) and sets its status label: "suggestion:
  * applying" while the pull request is open, "suggestion: applied" (the old labels removed) once it merged or the issue

package/dist/tier1-publish.d.ts

@@ -0,0 +1,48 @@
+import type { Owners } from './config';
+import type { RiskTier } from './risk';
+/** The setting, absent counting as on. */
+export declare const leadsPublishTier1On: (gov: {
+    leadsPublishTier1?: boolean | undefined;
+} | null | undefined) => boolean;
+/** Which reviewers lead a Tier 1 change: tech when it touches stories or tests (code-only Tier 1), else design. */
+export type Tier1Domain = 'design' | 'tech';
+export declare function tier1Domain(paths: readonly string[]): Tier1Domain;
+export interface Tier1PublishInput {
+    /** Login of the person publishing (the pull request's author). */
+    viewer: string | null | undefined;
+    /** classifyRisk over the change. Only Tier 1 publishes without review. */
+    tier: RiskTier | null | undefined;
+    domain: Tier1Domain;
+    /** The approver lists (approverLists: rights applied, teams expanded). */
+    approvers: Owners;
+    /** The viewer is an admin of the team in Bridge. */
+    admin: boolean;
+    /** governance.leadsPublishTier1 (leadsPublishTier1On). */
+    enabled: boolean;
+}
+/** Whether this person may publish this change without review. */
+export declare function canPublishTier1(x: Tier1PublishInput): boolean;
+/** The button that replaces "Send for review" for someone who may publish. */
+export declare const PUBLISH_LABEL = "Publish";
+/** The first line of the app's review on the pull request: how History and the readers recognise it. */
+export declare const TIER1_PUBLISH_HEADING = "**Bridge: published without review (Tier 1)**";
+/** The record, on the pull request and in History. */
+export declare const publishedWithoutReview: (name: string) => string;
+/** The app's review body: the heading, then the record and why it needed no review. */
+export declare function tier1PublishReviewBody(name: string, login: string): string;
+/** Who published it, read back from the app's review body, or null when the body is not one. */
+export declare function tier1PublishedBy(body: string | null | undefined): string | null;
+/**
+ * Who published this pull request without review, read from its reviews: the app's approving review with the heading,
+ * on the head commit when the head is known (an older one was dismissed by the push after it). Null when none.
+ */
+export declare function tier1PublishOf(reviews: readonly {
+    state: string;
+    body?: string | null | undefined;
+    commit_id?: string | null | undefined;
+}[] | null | undefined, headSha?: string | null | undefined): string | null;
+/**
+ * Who may publish without review, in one sentence, for the CLI, the MCP server and Settings. Admins are a Bridge
+ * team role, so the sentence names the role, not people.
+ */
+export declare function tier1PublishSentence(enabled: boolean): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge-ds/core",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "type": "module",
   "description": "Bridge core: bridge.config.json, DTCG token loading (tiers and layered modes), alias resolution, WCAG contrast, diffs, minimal-diff edits, PR body, the shared risk tier classifier, changesets and a fetch-based GitHub client. No Figma API, no DOM; Node-only helpers (git, reading a product folder) under @bridge-ds/core/node; the adoption audit under @bridge-ds/core/audit.",
   "license": "MIT",