--- type: Module title: "@effected/github" description: The kit's typed GitHub REST and GraphQL API layer, owning the octokit runtime. status: stable kind: package resource: ../../packages/github tags: [bundle, architecture] generated: by: "claude-code/opus-5.5" at: 2026-11-16T17:04:15Z integrity: generated: body: 297374c232527845 --- # @effected/github `@effected/github` is the kit's typed GitHub API layer: one client over GitHub's REST and GraphQL endpoints, plus the resource services that turn raw endpoints into domain operations. It owns the octokit runtime so that [`@effected/github-actions`](github-actions.md) and the consumer repositories never take an octokit edge themselves. Three properties define the package: 1. **Nothing is `unknown`.** octokit ships a complete, generated, types-only description of every GitHub endpoint. `client.request("GET /repos/{owner}/{repo}", { owner, repo })` types both the parameters and the returned data from the route literal alone — see [the REST client interface](../interfaces/github-rest-client.md). 2. **A light consumer cannot reach a heavy engine.** The client, the repo coordinate and most resource services import only octokit core and its paginator; the JWT signer and the sealed-box primitives are each confined to one module. See [Bundle reachability](#bundle-reachability). 3. **Errors are sized to what consumers read**: a reason string, a status, an operation name and a structural `kind` — see [errors and retry](../interfaces/github-errors-and-retry.md). Scope is closed by the consumer repositories, not by GitHub's API. An endpoint earns a resource method when a consumer needs it typed; everything else is reachable through the typed request surface without a cast, so "not modelled" never means "not usable". The contract lives in five child interfaces: - [The typed REST surface](../interfaces/github-rest-client.md) — the route-is-the-key mechanism, the client shape, the escape hatch for routes outside the generated map, and the pagination model. - [Errors and resilience](../interfaces/github-errors-and-retry.md) — one classification step, the structural `kind`, and the single retry policy driven by GitHub's own headers. - [App authentication](../interfaces/github-app-auth.md) — the JWT engine, the token lifecycle, and the seam `@effected/github-actions` builds its bridge on. - [The resource services](../interfaces/github-resources.md) — what each resource owns: upserts, say-once semantics, projections, the configuration-write half, the check-run bracket, byte budgeting, the permission comparator, and attestation metadata. - [GraphQL](../interfaces/github-graphql.md) — typed documents and which of them this package owns. See also [why `github` owns the octokit runtime](../decisions/github-owns-octokit-runtime.md). ## Tier and dependencies **Integrated tier**, per [the tier taxonomy](../glossary/library-tier.md) — it owns the octokit runtime, which is the whole reason the package exists: interpreting GitHub's API is a concern that should exist once, typed, in a package named for it. | Dependency | Why | | --- | --- | | `@octokit/core` | the `Octokit` class: a route-keyed, fully typed `request`, which carries GraphQL too (`POST /graphql` with a `data` body, never its `graphql` method) | | `@octokit/plugin-paginate-rest` | the composable paginator over a bare core instance, plus the type that statically rejects paginating a non-paginating route | | `@octokit/types` | the generated endpoint map; ships no JavaScript — types only | | `@effected/jwt` (`workspace:^`) | signs the App JWT on core `effect/jose` (the `Signature` service, required in `R` by the App layers); kept as the edge because it accepts PKCS#1 and escaped-newline PEMs, which core's `Jwk.importPkcs8` does not — see [`jwt`](jwt.md) | | `@effected/semver` (`workspace:^`) | semver-aware tag selection; pure tier, so the edge is free | | `@effected/github-references` (`workspace:^`) | the compat re-export of six issue-reference names — see [`github-references`](github-references.md) | | `@effected/crypto` (`workspace:^`) | `HttpRedaction`, which the kept-cause scrubber (`internal/scrub.ts`) builds on: `GitHubError.fromOctokit` and `GitHubGraphQLError.fromThrowable` keep a credential-free copy of octokit's throwable — see [`crypto`](crypto.md); pure, with an `effect` peer only. It pulls core's `effect/http` modules onto the error path | **The sealed box has no third-party dependency, and `node:crypto` is not an alternative.** A sealed box is `crypto_box` under an ephemeral keypair with a nonce derived as `blake2b(ephemeral_pk ‖ recipient_pk, 24)` (`packages/github/src/internal/crypto.ts`); Node ships neither X25519 `crypto_box` nor blake2b. The primitives are in-house copies of audited `@noble` code (`xsalsa20poly1305.ts`, `blake2b.ts`, `x25519.ts` beside `crypto.ts`), each with a provenance header, confined to `RepositorySecret`; `tweetnacl`, `blakejs` and `libsodium-wrappers` are `devDependencies` used as test oracles only, libsodium the authority. The ephemeral secret comes from `globalThis.crypto.getRandomValues`. See [the primitives are copied](../decisions/sealed-box-primitives-copied.md); a second consumer outside this package is its revisit trigger. Treat a third-party crypto dependency added here as a fresh decision. `@octokit/rest` and `@octokit/auth-app` are deliberately absent and must not be reintroduced. `@octokit/rest` bundles a request-log plugin this package would immediately silence, plus megabytes of generated types duplicating `@octokit/types`. `@octokit/auth-app` re-exports an OAuth user-auth factory, making hundreds of kilobytes of OAuth app, user and device-flow machinery reachable from a package that only ever mints installation tokens; what is actually needed — an RS256-signed App JWT plus one typed token-endpoint route — comes from the kit's own [`@effected/jwt`](jwt.md), a thin layer over core `effect/jose` that runs on workerd as well as Node. ## Bundle reachability The tree-shakability invariant is measured: | A consumer that imports… | links | does **not** link | | --- | --- | --- | | the client, the repo coordinate, the route vocabulary, any resource service but `RepositorySecret` | octokit core and the paginator | the JWT signer, the sealed-box primitives | | the App service or any of its client layers | the above plus the JWT signer | the sealed-box primitives | | the Actions OIDC verifier (`ActionsOidc`) | `@effected/oidc` and `@effected/jwt`, nothing else | all octokit, the sealed-box primitives | | the installation token store seam (`InstallationTokenStore`) | nothing but `effect` | the JWT signer, all octokit | | the OAuth user flow (`GitHubUserAuth`) | `effect` and `@effected/crypto` (for `HttpRedaction`) | all octokit, the JWT signer, the sealed-box primitives | | `RepositorySecret` | the above plus the in-house sealed-box primitives (no package) | the JWT signer | | the pure classes | nothing but `effect` (the GraphQL and REST error classes also reach `@effected/crypto`) | all octokit | Three mechanisms carry it: 1. **Module-per-layer-variant.** The token and config client layers live in `GitHubClient.ts`, which imports only octokit core and the paginator; the App-authenticated client layer lives in `GitHubApp.ts`, the only module importing the JWT signer. 2. **No namespace object, anywhere** — see [no barrel re-exports](../conventions/no-barrel-re-exports.md). The entry point re-exports by name only, so referencing one member never retains every member's whole module graph. 3. **The pure surface is genuinely pure.** The permission comparator, bot identity, the repo reference, the comment marker, the check-run output budgeter and the retry policy are schema classes in modules importing nothing but `effect`. The closing-reference grammar is the case that moved out entirely — see [`github-references`](github-references.md) — because hosting a pure vendor rule "in the kit" turned out not to mean "in this package": keeping it here cost nothing to `github`'s own consumers and cost the octokit-free ones the whole client tree. `github` keeps a six-name compat re-export and nothing else. This invariant gets a test rather than a promise: `packages/github/__test__/reachability.test.ts` walks the runtime import graph of `src` statically (type-only imports skipped, since they are erased), asserting the token-only client does not reach the JWT signer and that the App module does, that `GitHubUserAuth` reaches exactly `effect` and `@effected/crypto`, that `ActionsOidc` reaches `@effected/oidc` and `@effected/jwt` but not octokit, that `InstallationTokenStore` reaches nothing but `effect` (neither the signer nor the App module), and that `RepositorySecret` reaches the sealed-box primitives while no other resource service does. Each "does not reach" assertion has a positive control beside it. It constrains the import graph, not the resolver graph: the claim is "no edge exists, so a tree-shaking bundler can drop it," not "it is absent from any particular consumer's bundle." ## Module topology Module-per-concept, no barrels, `src/index.ts` re-exports only. `src/` holds the route vocabulary and the client, the App module, the repo coordinate, resilience, GraphQL, one module per resource service, and the pure permission comparator; `src/internal/` holds the octokit factory, the pagination engine, the crypto leaf, the id funnel and header parsing. Repository settings and topics live on `GitHubRepository`, not in a service of their own, because the endpoint a settings service would want is one `GitHubRepository` already owns — module-per-*concept* deciding it, not a size judgement. A candidate settings module once collided with the `RepositorySettings` type alias the entry point already exported, silently, because `tsc`, the bundler and API Extractor all accept a name collision when a valid export by that name already exists. `packages/github/__test__/reachability.test.ts` now asserts every module in `src/` is re-exported from the entry point, which is the only check that could have caught it, since nearly every per-module test file imports its module path directly rather than through the entry point. `GitHubRepository.setTopics` returns the topic set GitHub stored rather than the names it was given, because GitHub lowercases every topic: a caller that records what it sent sees drift on the next read. `ChangelogInfo` replaces `@changesets/get-github-info` for changelog lines. `commit(sha)` and `pullRequest(n)` return `Option`s of the author login, the associated pull request or commit, and the formatted links. Their query text and link strings match `get-github-info` 1.0.1 exactly. Lookups made concurrently are batched into one aliased GraphQL query per repository, up to 50 at a time, through a `RequestResolver`; calls made one after another are not batched, and nothing is cached. The token and host come from `GitHubClient` (on GitHub Enterprise Server, through its `baseUrl`) and the repository from `Repo`; it never reads `process.env`. It departs from upstream on purpose in three places: - a missing pull request answers `None`, and the batch is sent again without it, where upstream fails the whole batch; - a sha naming a tree or a blob answers `None`; - a missing repository fails with kind `notFound`. `GitCommit.createCommit` and `commitFiles` return the sha. Their `WithUrl` counterparts return a `CreatedCommit` carrying the sha and the `htmlUrl` GitHub replied with, so the host is right on GitHub Enterprise Server; a reply with no `html_url` fails with a `GitHubError` naming the commit already created. The shape has both pairs as required members, so a hand-rolled test double must provide all four or use `GitCommit.makeTest`. `GitHubRepository.applySettings` sends a REST key only when it is in `src/internal/repositoryRestSettingKeys.ts`, a committed file generated by `lib/scripts/generate-rest-setting-keys.ts` from `@octokit/openapi-types` (a devDependency, with `oxc-parser`). Any other key that is not GraphQL-only is reported in `AppliedSettings.ignored` and never sent, because the REST `PATCH` ignores unknown fields and answers 200. The file also carries `REMOVED_BY_PINNED_VERSION`, keys the description still declares mapped to the api-version that removed them; `applySettings` ignores such a key only when `client.apiVersion` is at or past that version. `{ unknownKeys: "send" }` forwards an undescribed key instead and reports it in `AppliedSettings.unverified`; a removed key stays ignored. An octokit request-option name (`baseUrl`, `url`, `headers`, `request`, `mediaType`, `method`, `data`), the route's `owner` / `repo` and `__proto__` are never sent under either mode: both write paths send the settings as octokit's `data` body, so no key in them is read as a request option (the confinement and its source citations are in the REST client interface). The typed escape hatch for the same need is `repositoryPatch(draft, { extra })` — see [the REST client interface](../interfaces/github-rest-client.md). `DeploymentEnvironment.upsert`'s open `config` rides the same way, as the `PUT`'s `data` body, and dies with a `RangeError` on a reserved name; GraphQL calls send `POST /graphql` with `data: { query, variables }` rather than through `octokit.graphql`, which reads a variable named `baseUrl`, `headers`, `request`, `mediaType` or `operationName` as a request option. The audit of every params-building call site behind both is in the REST client interface. `GitHubRelease.uploadAsset` takes its upload host from the client's configured base (`internal/uploads.ts`), never from the release's `uploadUrl`, so a GitHub Enterprise Server client's token stays on that server; the derivation is in the REST client interface too. The upload goes through a private channel the built client carries (the App layers' rotating client carries one too, delegating to its current inner client), because the public raw surface (`request`, `requestDecoded`, `paginate`, `paginateStream`) is confined to the configured API host: it has no `baseUrl` extra, and it refuses a reserved option, an absolute-URL route or a pagination `Link` on another origin with a `rejected` `GitHubError` and nothing sent (`__test__/TokenConfinement.test.ts`). `__test__/repositoryRestSettingKeys.test.ts` regenerates the file in memory and fails on drift, including a header that names `DEFAULT_API_VERSION`; re-run the generator (`pnpm --filter @effected/github exec tsx lib/scripts/generate-rest-setting-keys.ts`) after bumping the octokit types or the default version. ## The OAuth user flow `GitHubUserAuth` (`packages/github/src/GitHubUserAuth.ts`) is the OAuth web flow an app uses to act as a user: `exchange` (code plus PKCE verifier), `refresh` and `revokeGrant`. None of the three fit `GitHubClient`: the token endpoint is on the web host (`https://github.com/login/oauth/access_token`), and the grant revoke (`DELETE /applications/{client_id}/grant`) authenticates as the OAuth client with HTTP Basic. So the service calls an injectable `fetch` directly, with both URLs overridable for GitHub Enterprise Server, and its module imports no octokit. It takes the default api-version from `src/internal/apiVersion.ts`, an import-free module `GitHubClient` reads too, which is what lets it share the constant without linking octokit. The module is a pure core under a thin IO shell. `classifyTokenReply`, `classifyRevokeReply` and `toTokens` decide every outcome from a status and a body; `send` is the only code that touches `fetch`. The classification order is load-bearing: a 5xx, 429 or 408 is temporary whatever its body says; an `error` body is a refusal whatever the status says, because GitHub refuses a code or refresh token with HTTP 200; a 403 whose REST `message` names a rate limit (matched case-insensitively on "rate limit", or on "abuse detection", GitHub's older secondary-limit wording) is temporary, because GitHub's primary REST rate limit answers 403 and its secondary limits answer 403 or 429, and `send` keeps no headers to read `x-ratelimit-remaining` from; any other non-success status with no `error` is a refusal of the app's request; only then is a success read as tokens. Both `classifyTokenReply` and `classifyRevokeReply` apply the 403 rule, and only to a 403: a 401, 404 or 422 whose message mentions a rate limit keeps its own classification. The match follows GitHub's English wording, so a reworded body falls back to the plain 403 refusal. These classifiers are the one recorded exception to the package rule that status codes are classified only through `GitHubError`'s shared `classify`. The OAuth user flow's contract is a final/temporary split with a `remedy`, not `GitHubError`'s `kind`, and its token endpoint refuses with HTTP 200, so `classify` cannot express it. Do not route these replies through `classify`. Failures are two errors, and the split is the reason the service exists. `GitHubUserAuthTemporary` (`network`, `timeout`, `status`, `malformed`) is not a refusal of the grant: retry, keep the tokens. A refresh is the caveat: GitHub refresh tokens are single-use and rotate on success, so a refresh that GitHub processed but whose reply was lost or rejected (a 2xx `malformed`, or a `network` or `timeout` after the request arrived) has already spent the refresh token, and its retry answers `bad_refresh_token` (`reconnect`). `GitHubUserAuthFinal` keeps GitHub's `error` code and description and carries a `remedy`: `"reconnect"` for a dead code, refresh token or grant (`bad_refresh_token`, `bad_verification_code`, `expired_token`, a 422 on revoke), and `"reconfigure"` for the app's own mistakes (`incorrect_client_credentials`, `redirect_uri_mismatch`, an unrecognised code, a 401/403/404 on revoke other than a rate-limited 403). The `remedy` field is what keeps a final failure from signing every user out: silk-app's hand-rolled flow, which this replaces, already refused to treat `incorrect_client_credentials` as a dead grant for exactly that reason, and a handler wiping tokens on the tag alone would reintroduce it. Tokens are absolute instants against `Clock`, like `InstallationToken`, in a two-variant union discriminated by `expiry`: `ExpiringUserTokens` and `NonExpiringUserTokens` (an app with token expiry turned off). An expiring reply missing any of its three expiring fields is `malformed` rather than a non-expiring token, and `refresh` treats a non-expiring answer as `malformed` too, since it leaves the caller unable to refresh again. No credential reaches an error. Every description and every kept cause goes through a scrub that replaces the call's own client secret, code, verifier, tokens and Basic credential, then any GitHub-prefixed token shape (`ghu_`, `ghr_`, `github_pat_`, …), then `HttpRedaction.text`. The cause of a network failure is a rebuilt copy of what `fetch` threw, never the original, because a custom `fetch` can put the request body in its error. Token-reply decoding uses `Schema.decodeUnknownOption` and drops the failure, since a `SchemaError` over a token reply would carry the token. The timeout (ten seconds by default) covers the request and the whole body, aborts the `fetch` through its signal, and fails as `kind: "timeout"`. `send` reads the body inside the same `Effect.tryPromise` as the request on purpose: core aborts a `tryPromise` signal only while that effect is pending, so a second `tryPromise` for `response.text()` would leave a timeout during the body read abandoning the request with its connection open. The `hangingFetch("body")` test pins it. ## The api-version pin Every request carries `x-github-api-version`, set by a `before` hook on the octokit instance in `src/internal/octokit.ts` from `GitHubClientOptions.apiVersion` / `GitHubAppOptions.apiVersion` (default `2026-03-10`). The hook fills the header only when the call did not set one, so `Attestation`'s per-call pin wins. Without it GitHub serves its oldest calendar version and octokit prints an unsuppressable deprecation warning. The option must match `YYYY-MM-DD`; anything else dies at client (or `GitHubApp` layer) construction with a defect naming the option. The resolved version is `GitHubClientShape.apiVersion`, a plain string member, so resources can shape a request for the version it goes out under; calendar versions compare lexically as strings. The version change removed `merge_commit_sha` from REST pull request objects. `PullRequest` fills `PullRequestInfo.mergeCommitSha` from GraphQL `mergeCommit.oid` (verified live: the oid equals the old REST value on a merged pull request and is null on an unmerged one). Single reads (`get`, `update`, `upsert`) always do; `list` and `listAssociatedWithCommit` only with `mergeCommits: true`, in `nodes(ids:)` batches of 100 run four at a time and joined positionally. `WorkflowDispatch.dispatchWithRun` sends `return_run_details: true` only for a client pinned before `2026-03-10`, which removed the flag, and `use_squash_pr_title_as_default` is ignored by `applySettings` from that version on. ## The repo coordinate Every resource method takes `Repo` in its `R` and no method takes owner and repo arguments (`packages/github/src/Repo.ts`), which is what makes a resource call a single expression and what makes a scoped override work: ```ts yield* Effect.forEach(targets, (target) => syncOneRepo.pipe(Repo.provide(target)), { concurrency: 4 }); ``` **Resolving `Repo` per call rather than once at layer construction is load-bearing.** If a resource resolved both the client and the repository at construction, a scoped override would silently do nothing, because the resource would already hold the repository it was built with. The client stays resolved at construction; the coordinate is read per call. The general rule this refines: resolve a dependency once when it is stable, per call when varying it is the point. **The scope of a method follows the API, never the consumer's call pattern.** An org-scoped route still sources its org from `Repo.owner` when the org *is* the repository's owner; only a method needing an org that is not the repository's owner takes an explicit argument. `Repo` is also a deliberate exception to "no non-effectful members on a service shape": its entire shape is one immutable value class, `Layer.succeed` is the correct double for it, and the exception holds only while the shape is entirely one value with no methods. ## Actions decoupling Three places where GitHub-Actions-runtime knowledge could leak into this layer, and what keeps it out instead: | Leak avoided | Replacement | | --- | --- | | rerouting octokit's request log into a workflow command | octokit's log is silenced, and the client logs its own retries with `Effect.logDebug`; `@effected/github-actions` maps Effect logs onto workflow commands through a `Logger` | | reading the repository slug from the environment | [the repo coordinate](#the-repo-coordinate), with the env-driven layer variant named for what it does | | reading the token from the environment | the config-provider client layer, over a redacted config | There is no token masking here (that is an Actions output command), no state persistence (an installation token is merely encodable so `@effected/github-actions` can persist it), and no workflow-command import of any kind. This package reads no environment variable except through a `Config` in a layer variant named for being env-driven, and is otherwise runnable anywhere. ## Shared vocabulary - **One canonical semver model.** `@effected/semver` is pure tier, so the edge is free, and returning a real semver value is what lets a consumer compare tags without re-parsing. - **The repo reference, pull-request info, installation tokens, check-run output and release data are canonical here**, and `@effected/github-actions` consumes rather than duplicates them. - **A digest is a small deliberate duplication.** An attestation subject digest and a lockfile integrity hash are different concepts wearing similar clothes, and taking a dependency edge across a seam to share a branded string is not worth it; this package declares its own. - **The release-tag format authority stays in `@effected/workspaces`.** This package's tag-name-to-version extraction is a parsing convention, not the tag-format authority. ## Testing `@effect/vitest`, `it.effect`, `assert.*` — never `expect`; tests in `__test__/`. There is no `./testing` subpath. - Every service ships `makeTest(overrides?)` and `layerTest(overrides?)`, and an unstubbed member **dies when run**, naming itself: calling it only builds the effect, and the defect sits in that effect's `Exit` rather than escaping the call site as an exception. One internal helper (`src/internal/unstubbed.ts`, mirroring `github-actions`) spells the death once; a value member (`GitHubRepository.settings`, `WorkflowDispatch.list`) holds the dying effect itself and names itself as read, so building the double never dies. - Tests drive the real client through octokit's documented `fetch` option (`packages/github/__test__/fixtures.ts`), not a double of this package's own service, so classification, header capture, retry and link-following pagination are all genuinely exercised. A hand-built response has an empty URL, and octokit's paginator constructs a URL from it for any payload carrying a total count, so the harness must define that property or the failure gets classified as a transport fault instead. octokit percent-encodes path parameters, so assertions run against the recorded decoded path rather than the URL. - `GitHubClient.makeTest` / `layerTest` and `GitHubClient.layerFixture` refuse what the live client refuses (a reserved `baseUrl` / `url` / `request` / `method` parameter, a top-level `url` body field, a route off github.com's REST root) with the same `kind: "rejected"` error, through the shared `src/internal/confinement.ts`; a refused call is not recorded in `requested`. See [the REST client](../interfaces/github-rest-client.md). - One recorded-fixture client double (`GitHubClient.layerFixture`) exists and reimplements nothing: it pages recorded arrays through the same pagination engine the live layer uses and records the page requests it issued (`RecordedCall`, carrying `kind` and params), which is what makes truncation testable and what makes normalising writes testable. - An unstubbed fixture route dies naming the route (`unstubbed: "die"`, the default); a recorded `GitHubError` value is how a suite stubs a 404, a 422 or a rate limit deliberately. A missing fixture is test wiring, not a domain outcome, and a typed failure is only loud in code that does not catch — a consumer catching `GitHubError` per resource turns a missing stub into a different execution path whose failures name no fixture. `"fail"` restores the typed not-found and `"empty"` serves an empty value for a suite whose subject is decisions rather than endpoints; `graphql` ignores the setting and always dies, since no empty payload decodes against a document's schema. `fixtures.requested` records every call as a `RecordedCall` — `kind`, `route` (the document name for `graphql`), the params it was made with, and `perPage` for a paginated read — so a suite can assert what a method *sent*, which is the question a normalising write turns on. - Repairing fixtures after a route moves is where a false green gets manufactured — see [repaired fixtures go green on an impossible state](../gotchas/repaired-fixtures-go-green-on-impossible-state.md). - Pure classes get pure tests, with no layer at all; the byte budgeter gets a property test over multi-byte and four-byte code points. - A pagination-forwarding test exists per paginating method. - The App suite generates a real RSA key and signs for real. - Mutating the edges — the page bound, the byte budget, the already-exists classification, the retry predicate — is expected to turn the suite red. Run subset suites root-relative with coverage disabled. ## Observability and build Named spans on every public fallible boundary, with stable identifiers only in annotations — the route, the coordinate, the resulting status, the page count, the failure kind — and never a token, a private key, a request or response body, or GraphQL variables (which routinely carry node ids and comment bodies). Retries log at debug, one line per retry, and that is the only logging in the package. There are no metrics: the spans are there for a consumer to derive counters from, at whatever cardinality the consumer chooses. Build through `pnpm build --filter @effected/github`. Naming third-party generic types on a public signature is fine — API Extractor resolves a declared dependency's types as externals — so the only suppressed build entries are the synthesized schema-class bases. A `static readonly layer` must wrap its factory in an arrow or it throws an access-before-initialization error at import time while typechecking clean (`packages/github/src/GitHubClient.ts`). ## See also - [`github-references`](github-references.md) — the extracted issue-reference grammar and the compat re-export back into this package. - [why `github` owns the octokit runtime](../decisions/github-owns-octokit-runtime.md) - [the sealed-box primitives are copied into `github`](../decisions/sealed-box-primitives-copied.md) - [the GraphQL schema is not owned here](../limitations/github-graphql-schema-not-owned.md) - [branch reset closes an open pull request](../gotchas/branch-reset-closes-pull-request.md) - [repaired fixtures go green on an impossible state](../gotchas/repaired-fixtures-go-green-on-impossible-state.md) - [the compat re-export is droppable](../decisions/github-compat-re-export-droppable.md) - [the github-split program](../glossary/github-split.md) - [the tier taxonomy](../glossary/library-tier.md)