@bridge-ds/core 0.13.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
 
@@ -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."
@@ -678,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-BeWNSjPk.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-BeWNSjPk.js";
-import { p as pieceId, a as proposedTokenPath, t as tokenLabel } from "../prod-branch-6ftQWwdu.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[];
@@ -176,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;
@@ -198,6 +207,7 @@ export interface BridgeConfigInput {
             files: string;
             optional?: boolean;
         })[];
+        usage?: string;
     };
     modes?: (Partial<Omit<ModeConfig, 'defaults'>> & {
         defaults?: ModeConfig['defaults'];
@@ -240,6 +250,7 @@ export interface BridgeConfigInput {
     storybook?: {
         url: string;
     };
+    library?: LibraryConfig;
 }
 export declare const DEFAULT_TOKEN_PATHS: TokenPaths;
 export declare const DEFAULT_GOVERNANCE: GovernanceConfig;
@@ -264,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';