@bridge-ds/core 0.12.0 → 0.15.0

package/README.md

@@ -83,7 +83,8 @@ function composeProposalBody(input); function changeTable(changes); function con
 ```
 
 `@bridge-ds/core/node` (Node only): `git`, `isGitRepo`, `currentBranch`, `branchExists`, `showFile`, `listFilesAt`,
-`originRepo`, `commitToNewLocalBranch` (plumbing commit on a new branch; working tree, index and checkout untouched).
+`originRepo`, `commitToNewLocalBranch` (plumbing commit on a new branch; working tree, index and checkout untouched),
+`fsSource(root, ref?)` and `localRepoRef(root)` (a `RepoSource` over a checkout, see repo model).
 
 ## types
 
@@ -275,7 +276,7 @@ parseSuggestionIssue(body, { comments?, author? }): { ok: true; payload; sha; ma
 suggestionPayloadSha(payload); canonicalJson(value); sha256Hex(text); gitBlobSha(text);
 suggestionLabels(payload, { state?, labels? }); suggestionIssueTitle(payload); suggestionStatus({ state, stateReason?, linkedPrs?, review?, applied?, outdated? });
 suggestionPathProblems(payload, config): string[];    unsafePathProblem(path): string | null;
-summarizeSuggestionApprovals(comments, { owners, rights?, teams? }, { payloadSha, author? }); suggestionReviewState(tier, approvals);
+summarizeSuggestionApprovals(comments, { owners, rights?, teams?, soloOwnerCanApproveBoth? }, { payloadSha, author? }); suggestionReviewState(tier, approvals);
 composeSuggestionReviewComment(record); parseSuggestionReviewComment(body); composeSuggestionAppliedComment(record); parseSuggestionAppliedComment(body);
 // GitHub (Issues read and write only)
 createSuggestionOnGitHub(gh, payload, opts); listSuggestionsOnGitHub(gh, { state? }); getSuggestionOnGitHub(gh, n, gov, { outdated? });
@@ -299,6 +300,29 @@ normalizeStorybookUrl(pasted): string;   // https only (http on localhost), drop
 storybookIframeUrl(base, id, { viewMode?, globals?, args? }); storybookManagerUrl(base, id, viewMode?); storybookIndexUrls(base);
 ```
 
+## repo model (repo-source.ts, repo-model.ts, token-rows.ts, contrast-model.ts, component-scan.ts)
+
+Everything the docs site and Studio read from a design system repo, from one `RepoSource`, so the build (a local
+checkout) and the browser (any team's repo on GitHub) run the same code. `bridge.config.json` is parsed once; every
+folder comes from it (`tokens.root` and tier folders, `contrast.path`, `components.dir|index|specs`,
+`tokens.usage`), with this repo's former paths as defaults (`REPO_MODEL_DEFAULTS`). Repo content never throws: a bad
+config, docs.json or alias, or a file the source refuses as too large (413), lands in `problems`; a rate limit or
+network error still throws so the caller can retry.
+
+```ts
+interface RepoSource { ref: { owner; repo; sha }; list(prefix?): Promise<string[]>; text(path): Promise<string | null> }
+memorySource(files, ref?); readRepoTexts(source, paths, concurrency?, onError?);   // fsSource(root, ref?) in @bridge-ds/core/node
+// gitHubSource(client, sha, opts?) (repo-source-github.ts) is the same RepoSource over GitHub; every list() is sorted.
+loadRepoModel(source, { components?, href?, concurrency? }): Promise<RepoModel>;
+// RepoModel: { ref, configText, config, site: SiteRepo, problems, tokens: { root, files, rows, usage },
+//              contrast: { path, specs, pairs }, components: { dir, index, families, list } | null, specs: { path, file, coverage } }
+siteRepoFromConfig(config, raw?, fallback?); parseModelConfig(text);
+buildTokenRows(config, readText, listFiles); tokenRowIndex(rows); tokenRowAxes(config, readText?); tokenRowFiles(config);
+parseContrastSpecs(text); evaluateContrastPairs(specs, rows); hexContrastRatio(a, b);
+scanComponents(input); parseComponentTsx(name, src); parseComponentCss(src, labels, describeVar);
+parseComponentStories(src); parseComponentFamilies(indexSrc, componentsRel?); resolveInheritedTokens(list);
+```
+
 ## history (history.ts, history-github.ts, history-demo.ts)
 
 What changed in the tokens, when, who changed it and why, and how to undo it safely.

package/bridge.config.schema.json

@@ -129,6 +129,11 @@
             ]
           }
         },
+        "usage": {
+          "type": "string",
+          "description": "Optional notes per token group ({ \"color.action\": \"Buttons and links\" }), relative to root. Bridge reads usage.json under root when this is not set.",
+          "minLength": 1
+        },
         "primitives": {
           "type": "string",
           "description": "Flat form: primitive tier directory."
@@ -437,6 +442,11 @@
             }
           }
         },
+        "soloOwnerCanApproveBoth": {
+          "type": "boolean",
+          "description": "For a design system run by one person. When true and the owners resolve to exactly one person who holds both roles, that person's approval counts as the design and the tech approval, so Tier 2 and Tier 3 changes can be approved. The author of a change still never approves it. Default false: one person never covers both approvals alone.",
+          "default": false
+        },
         "rights": {
           "type": "object",
           "additionalProperties": false,
@@ -673,6 +683,18 @@
         }
       }
     },
+    "library": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "The team's hosted Bridge Library (/library/<owner>/<repo>/), read from the bridge-data snapshot.",
+      "properties": {
+        "public": {
+          "type": "boolean",
+          "default": false,
+          "description": "true lets search engines index the hosted Library of a public repository. Default false: every Library page says noindex."
+        }
+      }
+    },
     "visualImpact": {
       "type": "object",
       "additionalProperties": false,

package/dist/audit/index.js

@@ -1,6 +1,6 @@
-import { i as isAuditable, a as auditFile } from "../report-DOnKUw8G.js";
-import { A, b, c, C, D, d, F, I, L, e, M, N, f, g, h, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, B, E, G, H, J, K, O, P, Q, R, S, T, U, V, W, X, Y, Z } from "../report-DOnKUw8G.js";
-import { p as pieceId, a as proposedTokenPath, t as tokenLabel } from "../prod-branch-BdMPKffE.js";
+import { i as isAuditable, a as auditFile } from "../report-DCPfvvoq.js";
+import { A, b, c, C, D, d, F, I, L, e, M, N, f, g, h, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, B, E, G, H, J, K, O, P, Q, R, S, T, U, V, W, X, Y, Z } from "../report-DCPfvvoq.js";
+import { p as pieceId, a as proposedTokenPath, t as tokenLabel } from "../prod-branch-BjXFIz74.js";
 const lines = (text) => text.split(/\r?\n/);
 function lineBag(text) {
   const bag = /* @__PURE__ */ new Map();

package/dist/component-scan.d.ts

@@ -0,0 +1,158 @@
+import type { ProseKey } from './docs-draft';
+import type { TokenRowTier } from './token-rows';
+export type ExampleNode = string | {
+    c: string;
+    p?: Record<string, unknown>;
+    children?: ExampleNode[];
+};
+export interface GuidanceItem {
+    title: string;
+    text: string;
+    example?: ExampleNode;
+}
+/** <Name>.docs.json. */
+export interface ComponentDocs {
+    summary: string;
+    /** Navigation group. Optional; components without one are listed under "Core". */
+    category?: string;
+    /** Lifecycle shown on the component page and in the nav: stable (default), beta, deprecated. */
+    status?: 'stable' | 'beta' | 'deprecated';
+    preview?: ExampleNode;
+    whenToUse: string[];
+    whenNotToUse: string[];
+    dos: GuidanceItem[];
+    donts: GuidanceItem[];
+    accessibility: string[];
+    contentGuidelines?: string[];
+    anatomy?: Record<string, string>;
+    /** "claude" when an AI drafted the prose (docs-draft Action, bridge_draft_docs). */
+    draftedBy?: string;
+    /** Prose sections Claude drafted that wait for review, when a draft covered only some (missing: the whole file). */
+    draftedSections?: ProseKey[];
+    /** True while drafted prose waits for a reviewer. */
+    needsReview?: boolean;
+}
+export interface ComponentProp {
+    name: string;
+    type: string;
+    required: boolean;
+    defaultValue?: string;
+    description?: string;
+}
+/** What the scan knows about a CSS variable: the token it is, and an optional docs link (the caller's routing). */
+export interface ComponentVar {
+    name: string;
+    href?: string;
+    known: boolean;
+    path?: string;
+    kind?: TokenRowTier;
+}
+export interface ComponentCssRule {
+    selector: string;
+    /** First class in the selector, used for the anatomy label. */
+    className: string;
+    label: string;
+    vars: ComponentVar[];
+}
+export interface ScannedComponent {
+    name: string;
+    slug: string;
+    /** Repo-relative folder. */
+    dir: string;
+    /** Repo-relative files (they may not all exist). */
+    files: {
+        tsx: string;
+        css: string;
+        stories: string;
+        docs: string;
+    };
+    description?: string;
+    props: ComponentProp[];
+    inherits?: string;
+    omitted: string[];
+    subcomponents: string[];
+    rules: ComponentCssRule[];
+    tokensUsed: {
+        name: string;
+        href?: string;
+        known: boolean;
+        kind?: string;
+    }[];
+    /** Paths of the tokens its own stylesheet reads, in every tier. */
+    tokenPaths: string[];
+    /**
+     * Tokens it reads through another component's stylesheet it imports (IconButton imports Button.module.css), by
+     * that component, without the ones its own stylesheet already reads. Followed transitively.
+     */
+    inherited: {
+        from: string;
+        slug: string;
+        paths: string[];
+    }[];
+    /** Own and inherited token paths: what the component actually paints with. */
+    allTokenPaths: string[];
+    stories: {
+        name: string;
+        id: string;
+    }[];
+    docs: ComponentDocs | null;
+    /** Family from docs.json `category`, else from the grouped exports of the barrel file. */
+    category: string;
+}
+/** "IconButton" -> "icon-button". */
+export declare const componentSlug: (s: string) => string;
+/**
+ * Families in the order the barrel file lists them ("// Actions" then its exports). `componentsRel` is the components
+ * folder relative to the barrel's folder ("components"); exports from elsewhere are not members.
+ */
+export declare function parseComponentFamilies(indexSrc: string, componentsRel?: string): {
+    name: string;
+    members: string[];
+}[];
+/** Props (with defaults and JSDoc), the native element it extends, its description and sub-components, from <Name>.tsx. */
+export declare function parseComponentTsx(name: string, src: string): {
+    props: ComponentProp[];
+    inherits: string | undefined;
+    omitted: string[];
+    description: string | undefined;
+    subcomponents: string[];
+};
+/**
+ * Minimal CSS reader: selector -> var(--*) list, labelled with the docs.json anatomy. Skips @keyframes, flattens
+ * @media. `describe` says what a variable is (token path, tier, docs link); undefined: not a token.
+ */
+export declare function parseComponentCss(src: string, labels: Record<string, string>, describe: (cssVar: string) => Omit<ComponentVar, 'name' | 'known'> | undefined): ComponentCssRule[];
+/** Story names and Storybook ids of a <Name>.stories.tsx (CSF with a `title`). */
+export declare function parseComponentStories(src: string): {
+    name: string;
+    id: string;
+}[];
+/**
+ * Fills `inherited` and `allTokenPaths` from the stylesheets each component imports from another component,
+ * transitively (A imports B's stylesheet, B imports C's: A inherits from B and C). Removes `reuses`.
+ */
+export declare function resolveInheritedTokens(list: (Pick<ScannedComponent, 'name' | 'slug' | 'tokenPaths' | 'inherited' | 'allTokenPaths'> & {
+    reuses?: string[];
+})[]): void;
+export interface ComponentScanInput {
+    /** Components folder, repo-relative (bridge.config.json components.dir). */
+    dir: string;
+    /** Every repo-relative file under `dir` (RepoSource.list(dir)). */
+    files: string[];
+    /** Body of a repo-relative file, undefined when missing. */
+    readText: (path: string) => string | undefined;
+    /** Barrel file body (components.index), for families. Undefined: no families. */
+    indexText?: string | undefined;
+    /** Components folder relative to the barrel's folder. Default "components". */
+    indexRel?: string;
+    docsSuffix?: string;
+    styleSuffix?: string;
+    /** What a CSS variable is (token path, tier, docs link). Undefined: not a token. */
+    describeVar: (cssVar: string) => Omit<ComponentVar, 'name' | 'known'> | undefined;
+    /** Problems found (a docs.json that does not parse) are reported here instead of failing the scan. */
+    problems?: string[];
+}
+/**
+ * Every component of the folder: a sub-folder <Name> holding <Name>.tsx. Sorted by family (barrel order), then name.
+ */
+export declare function scanComponents(input: ComponentScanInput): ScannedComponent[];

package/dist/config.d.ts

@@ -17,6 +17,11 @@ export interface StorybookConfig {
     /** Root URL (where index.json and iframe.html are served), https only, no trailing slash. */
     url: string;
 }
+/** The team's hosted Library (/library/<owner>/<repo>/). */
+export interface LibraryConfig {
+    /** True lets search engines index the hosted Library of a public repository. Default false: noindex. */
+    public?: boolean;
+}
 export interface RepoRef {
     owner: string;
     name: string;
@@ -48,6 +53,8 @@ export interface TokenConfig extends TokenPaths {
     /** Tier name -> directories or files relative to root. First match wins. */
     tiers: Record<string, string[]>;
     layers: TokenLayer[];
+    /** Optional notes per token group ({ "color.action": "Buttons and links" }), relative to root. Default usage.json when present. */
+    usage?: string | undefined;
 }
 export interface ModeAxis {
     values: string[];
@@ -114,6 +121,11 @@ export interface GovernanceConfig {
      * and anyone with write access may ship, as before the field existed.
      */
     rights?: Rights | undefined;
+    /**
+     * A design system run by one person: when the owners resolve to exactly one person holding both roles, that
+     * person's approval counts for design and tech. Default false: one person never covers both approvals alone.
+     */
+    soloOwnerCanApproveBoth?: boolean | undefined;
 }
 /** `bridge audit` settings: how product code that consumes the design system is measured. */
 export interface AuditConfig {
@@ -171,6 +183,8 @@ export interface BridgeConfig {
     changes: ChangesMode;
     /** The Storybook set in the file. Read it through storybookUrl(), which falls back to previews.production.storybook. */
     storybook?: StorybookConfig | undefined;
+    /** The hosted Library. Read it through libraryIsPublic(). */
+    library?: LibraryConfig | undefined;
 }
 type Partialish<T> = {
     [K in keyof T]?: T[K] | undefined;
@@ -193,6 +207,7 @@ export interface BridgeConfigInput {
             files: string;
             optional?: boolean;
         })[];
+        usage?: string;
     };
     modes?: (Partial<Omit<ModeConfig, 'defaults'>> & {
         defaults?: ModeConfig['defaults'];
@@ -235,6 +250,7 @@ export interface BridgeConfigInput {
     storybook?: {
         url: string;
     };
+    library?: LibraryConfig;
 }
 export declare const DEFAULT_TOKEN_PATHS: TokenPaths;
 export declare const DEFAULT_GOVERNANCE: GovernanceConfig;
@@ -259,6 +275,12 @@ export declare const changesMode: (config: Pick<BridgeConfig, "changes"> | null
  * when neither is set. No trailing slash.
  */
 export declare function storybookUrl(config: Pick<BridgeConfig, 'storybook' | 'previews'> | null | undefined): string | undefined;
+/**
+ * True when the team opted in to search engines for its hosted Library (`"library": { "public": true }`). Off by
+ * default: a Library page under the Bridge domain shows content Bridge does not control, so it is noindex unless the
+ * team asks.
+ */
+export declare const libraryIsPublic: (config: Pick<BridgeConfig, "library"> | null | undefined) => boolean;
 /** Plain-JSON form of a config, in the canonical shape (what `bridge init` writes). */
 export declare function toConfigJson(config: BridgeConfig, schema?: string): Record<string, unknown>;
 export {};

package/dist/contrast-model.d.ts

@@ -0,0 +1,43 @@
+import type { TokenRow, TokenRows } from './token-rows';
+export interface ContrastPairSpec {
+    fg: string;
+    bg: string;
+    usage: 'text' | 'ui';
+    /** Minimum ratio the build enforces for this pair. */
+    min: number;
+}
+export interface ContrastModeResult {
+    fgHex: string;
+    bgHex: string;
+    /** Rounded down to 2 decimals, so 4.496 never displays as a passing 4.50. */
+    ratio: number;
+    aa: boolean;
+    /** null when AAA is not defined (non-text UI). */
+    aaa: boolean | null;
+}
+export interface ContrastPairResult extends ContrastPairSpec {
+    fgToken: TokenRow;
+    bgToken: TokenRow;
+    /** Default brand, per theme. */
+    modes: Record<string, ContrastModeResult>;
+    brands: Record<string, Record<string, ContrastModeResult>>;
+}
+/** WCAG thresholds: body text 4.5:1 (AA) and 7:1 (AAA); UI parts and graphics 3:1 (AA, 1.4.11). */
+export declare const CONTRAST_THRESHOLDS: {
+    readonly text: {
+        readonly aa: 4.5;
+        readonly aaa: 7;
+    };
+    readonly ui: {
+        readonly aa: 3;
+        readonly aaa: null;
+    };
+};
+/** Relative luminance of a #rrggbb color. */
+export declare function hexLuminance(hex: string): number;
+/** Contrast ratio of two opaque #rrggbb colors. */
+export declare function hexContrastRatio(a: string, b: string): number;
+/** The pairs of a contrast checks file ({ "pairs": [[fg, bg, min] | { fg, bg, min }] }). Empty when there is no file. */
+export declare function parseContrastSpecs(text: string | null | undefined): ContrastPairSpec[];
+/** Resolves pair specs against the token rows in every brand and theme. Throws on a pair naming a missing token. */
+export declare function evaluateContrastPairs(specs: ContrastPairSpec[], rows: Pick<TokenRows, 'all' | 'brands' | 'themes' | 'defaultBrand'>): ContrastPairResult[];

package/dist/github-client.d.ts

@@ -60,7 +60,9 @@ export interface RepoInfo {
     private: boolean;
     permissions: {
         admin?: boolean;
+        maintain?: boolean;
         push?: boolean;
+        triage?: boolean;
         pull?: boolean;
     } | undefined;
 }
@@ -69,6 +71,8 @@ export interface TreeEntry {
     type: 'blob' | 'tree' | 'commit';
     sha: string;
     mode: string;
+    /** Bytes, for blobs (GitHub sends it in tree listings). */
+    size?: number | undefined;
 }
 export interface CompareResult {
     status: string;
@@ -123,7 +127,119 @@ export interface ClientOptions {
      * the MCP server config"). Default: "add a GitHub token".
      */
     tokenHint?: string;
+    /**
+     * Where conditional GET responses are kept (ETag + body). Default: one in-memory store shared by every client in
+     * this process or page, keyed by the token's fingerprint, so two accounts never share an entry. `false` turns
+     * conditional requests off. A 304 answer does not count against GitHub's primary rate limit.
+     */
+    etags?: EtagStore | false;
+    /**
+     * Who the cached responses belong to, when a stable name is known (the signed-in login). Default: a fingerprint of
+     * the token, which changes when the token is refreshed.
+     */
+    etagScope?: string;
+    /**
+     * When GitHub's hourly limit is used up and a cached response exists for that request, return it instead of
+     * throwing. Off by default: the caller then knows the data may be stale only from `rateLimit`.
+     */
+    serveStaleOnRateLimit?: boolean;
+}
+/** One cached conditional response: what GitHub sent with this ETag. */
+export interface EtagEntry {
+    etag: string;
+    body: unknown;
+    /** When it was stored or last confirmed by a 304 (ms since epoch). */
+    at: number;
+}
+/** Storage for conditional requests. Keys never contain the token. */
+export interface EtagStore {
+    get(key: string): EtagEntry | undefined;
+    set(key: string, entry: EtagEntry): void;
+    /** Forgets every entry (sign-out). */
+    clear(): void;
+}
+/** An in-memory ETag store that keeps the `max` most recently used entries. */
+export declare function memoryEtagStore(max?: number): EtagStore;
+/** The subset of the Web Storage API (localStorage, sessionStorage) an ETag store needs. */
+export interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    key(index: number): string | null;
+    readonly length: number;
+}
+/**
+ * An ETag store over Web Storage, so conditional requests survive a page load. Every access is guarded: private
+ * windows, quota errors and blocked storage turn into cache misses, never into failures. Entries live under
+ * `prefix` (default "bridge.gh.etag:"); `clear()` removes only those. Bodies of private repositories land here
+ * too, so a sign-out must call `clear()`.
+ */
+export declare function webStorageEtagStore(storage: StorageLike, opts?: {
+    prefix?: string;
+    maxEntryBytes?: number;
+}): EtagStore;
+/** Clears the default in-memory ETag store every client shares (sign-out, account switch). */
+export declare function clearSharedEtags(): void;
+/** A short, non-reversible name for a token, used in cache keys instead of the token itself (two FNV-1a passes). */
+export declare function tokenFingerprint(token: string): string;
+/** GitHub's rate-limit headers from the last API response. */
+export interface RateLimitInfo {
+    limit: number | undefined;
+    remaining: number | undefined;
+    resetsAt: Date | undefined;
+    /** "core", "search", "graphql"... */
+    resource: string | undefined;
+}
+/** What the conditional request cache did, for tests and diagnostics. */
+export interface EtagStats {
+    /** Requests sent with If-None-Match. */
+    conditional: number;
+    /** 304 answers served from the cache (free for the primary rate limit). */
+    notModified: number;
+    /** Cached bodies returned because the hourly limit was used up (serveStaleOnRateLimit). */
+    stale: number;
+}
+/** An installation of a GitHub App the signed-in user can reach (GET /user/installations). */
+export interface Installation {
+    id: number;
+    account: {
+        login: string;
+        type: string;
+    } | null;
+    /** "all" repositories of the account, or "selected" ones. */
+    repositorySelection: 'all' | 'selected' | string;
+    appSlug: string | undefined;
+}
+/** One repository of an installation (GET /user/installations/{id}/repositories). */
+export interface InstallationRepo {
+    owner: string;
+    name: string;
+    fullName: string;
+    private: boolean;
+}
+/** One installation of the GitHub App, as GET /user/installations lists it (raw or mapped). */
+export interface InstallationLike {
+    id: number;
+    account?: {
+        login?: string;
+    } | null;
+    repository_selection?: 'all' | 'selected' | string;
+    repositorySelection?: 'all' | 'selected' | string;
 }
+/**
+ * Whether the signed-in account reaches a repository of `owner` through the app: 'yes' when an installation on the
+ * owner covers all its repositories, 'check' (with its id) when it covers selected ones (list them to know), 'no'
+ * when there is none. Same contract as the site's `installationFor` (lib/github-signin.ts).
+ */
+export declare function installationFor(list: InstallationLike[], owner: string): {
+    reach: 'yes';
+    id: number;
+} | {
+    reach: 'check';
+    id: number;
+} | {
+    reach: 'no';
+};
 /**
  * The sentence for GitHub's exhausted hourly limit. With a token, the token's own limit is used up: wait. Without one,
  * the shared limit for anonymous reads is (60 an hour per address): say how to get a higher one.
@@ -199,7 +315,14 @@ export declare class GitHubClient {
     private readonly blobCache;
     private readonly api;
     private readonly protectedBranches;
+    private readonly etags;
+    private readonly etagScope;
+    private rate;
+    /** What the conditional request cache did for this client. */
+    readonly etagStats: EtagStats;
     constructor(repo: string, token: string, fetchImpl?: FetchLike, retry?: RetryPolicy, options?: ClientOptions);
+    /** GitHub's rate-limit headers from the last API response, or undefined before any response carried them. */
+    get rateLimit(): RateLimitInfo | undefined;
     /** "owner/name". */
     get fullName(): string;
     /** Whether a token was given (without one, every write is refused before any request). */
@@ -209,7 +332,13 @@ export declare class GitHubClient {
     private assertToken;
     private get repoPath();
     private request;
+    private noteRateLimit;
     private once;
+    /**
+     * Every item of a paged listing (`per_page=100`), at most 10 pages. `pick` takes the items out of one page (the
+     * installation endpoints wrap them in an object with `total_count`).
+     */
+    private paged;
     getRepo(): Promise<RepoInfo>;
     /** Commit sha a branch points to, or undefined when the branch does not exist. */
     getBranchSha(branch: string): Promise<string | undefined>;
@@ -408,6 +537,43 @@ export declare class GitHubClient {
      * hourly API limit); with one, through the contents API (private repos work).
      */
     readFile(path: string, ref: string): Promise<string | undefined>;
+    /**
+     * Text of a file from the raw host (raw.githubusercontent.com), sent without any header so the browser makes a
+     * simple CORS request (no preflight) and nothing counts against the API limit. Works for public repositories only:
+     * a private file answers 404 there, like a missing one. Undefined on 404.
+     */
+    readRawFile(path: string, ref: string): Promise<string | undefined>;
+    /**
+     * Text of a file at a ref through the contents API with the raw media type: the way to read a private file (the raw
+     * host cannot take the token without a preflight). Counts against the API limit; conditional when cached.
+     * Undefined when the file does not exist.
+     */
+    getRawText(path: string, ref: string): Promise<string | undefined>;
+    /**
+     * Text of a blob by its sha through the git blobs API with the raw media type: how a signed-in reader loads a file
+     * listed by a tree (the raw host refuses any request that carries a token). A blob sha names its content, so the
+     * answer is cached for the client's life and never revalidated. Undefined on 404.
+     */
+    getBlobRaw(sha: string): Promise<string | undefined>;
+    /**
+     * Installations of the signing-in GitHub App that the signed-in user can reach (GET /user/installations, every
+     * page). Needs a user-to-server token of that same App: a personal or OAuth token is refused (403), and each App
+     * sees only its own installations. GitHub lists only installations on accounts and repositories the user has
+     * explicit permission on: a public repository where the user is not a collaborator is never listed, installed or
+     * not. (GET /repos/{o}/{r}/installation would say, but it needs the App's private key, which Bridge never holds.)
+     */
+    listUserInstallations(): Promise<Installation[]>;
+    /** Repositories of one installation the signed-in user can reach (GET /user/installations/{id}/repositories, every page). */
+    listInstallationRepos(installationId: number): Promise<InstallationRepo[]>;
+    /**
+     * The App installation that gives the signed-in user this repository (this client's by default): its id, or null
+     * when the App is not installed there or the user cannot reach it. One call when the installation covers all of
+     * the owner's repositories, two (paged) when it covers selected ones.
+     */
+    findInstallation(owner?: string, repo?: string): Promise<{
+        id: number;
+        selection: 'all' | 'selected';
+    } | null>;
     /** The repository's default branch. */
     getDefaultBranch(): Promise<string>;
     /** Every file path at a ref (branch, tag or sha), one API call. */

package/dist/index.d.ts

@@ -64,3 +64,11 @@ export * from './suggestion-review';
 export * from './suggestions-github';
 export * from './suggestion-apply';
 export * from './storybook';
+export * from './repo-source';
+export * from './token-rows';
+export * from './contrast-model';
+export * from './component-scan';
+export * from './repo-model';
+export * from './repo-source-github';
+export * from './repo-access';
+export * from './snapshot';