@osdlc/typed-gh 0.9.6 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @osdlc/typed-gh
 
+## 0.12.0
+
+### Minor Changes
+
+- a4ca07d: New `@osdlc/typed-gh/testing` entry point with builders for faking `gh` in tests. `prRow`, `issueRow`, `repoRow`, `searchPrRow`, `labelRow`, `checkRunRow`, `statusContextRow`, `commentRow` and `reviewRow` return gh's raw `--json` rows, with defaults that fill every field the parsers require (a pull request's `number`, a repository's `nameWithOwner`, the `headRefName` that `prList({ head })` filters on), and take typed overrides merged shallowly. `ghResult(payload)` wraps rows in a successful `CommandResult` for a fake runner. The main entry point does not import it.
+  
+  Fixed: `searchPrs` reads gh's zero time (`0001-01-01T00:00:00Z`), which gh prints for a hit that isn't closed, as `closedAt: null`. Before, an open hit had a year-0001 close date.
+
+## 0.11.1
+
+### Patch Changes
+
+- 272da7a: A list that goes through GitHub search reports `truncated: true` when 1000 rows come back. Search returns at most 1000 results whatever the `limit`, so before, a `limit` of 1000 or more read as complete (`truncated: false`) while more matched. gh uses search for `searchPrs`, for `prList` with a non-empty `search` or an `author`, and for `issueList` with a `label`. A list that does not search is unchanged. `searchPrs` now asks gh for at most 1000 rows: a `limit` of 1000 or more used to fail, because gh refuses a larger search limit.
+
+## 0.11.0
+
+### Minor Changes
+
+- da5e6a3: `parseOwnerRepo` is now `@osdlc/typed-git`'s `parseRemoteRepo` without the host. Behaviour change: a remote that `parseGitUrl` recognises but names no owner and repository for is read host-agnostically (`host/owner/repo`) instead of answering null; every other remote reads as before.
+  `settle`, `runCheckedGh`, `runCheckedGhAsync`, `gh.try`, `gh.soft`, `classifyGhFailure` and the leading-dash guard now use `@osdlc/command-seam`'s `runFailed`, `tryMethods`, `methodFacade`, `classifyFailed` and `notAnOption`, with no change a caller sees: the same failures, and the same `RangeError` and message for an argument that starts with `-`. `repoView` and every `--repo` verb build `[host/]owner/name` through one helper.
+
+### Patch Changes
+
+- Updated dependencies [da5e6a3]
+- Updated dependencies [da5e6a3]
+  - @osdlc/command-seam@0.14.0
+  - @osdlc/typed-git@0.10.0
+
+## 0.10.0
+
+### Minor Changes
+
+- b835ae4: Behaviour change: output that the runner cut short (`outputIncomplete`, at the output cap or a timeout) now fails as `CommandFailed` for every verb but a probe, and in `runCheckedGh`/`runCheckedGhAsync`, instead of being parsed as whole. Behaviour change: every `AsyncGh` method that builds a verb now rejects its Promise on a bad argument (a verb's `RangeError`) instead of throwing at the call site.
+  `parseOwnerRepo` now reads a GitHub Enterprise remote (a host `parseGitUrl` does not know) through `parseRemoteUrl` instead of answering null. `graphql` refuses a document holding a mutation or subscription anywhere (after a fragment, a leading `,`, or a second operation), and a variable named `query` or `operationName`. `prView` passes a scheme-less PR URL (`github.com/o/r/pull/7`) to gh with `https://`, so gh no longer takes it for a branch name. `repoView` treats a hostname of `''` as not set. `createLabel` and `editLabel` refuse a name that starts with `-`. `openPrFor` takes `timeoutMs`.
+
+### Patch Changes
+
+- Updated dependencies [b835ae4]
+- Updated dependencies [b835ae4]
+- Updated dependencies [fdef74f]
+  - @osdlc/command-seam@0.13.0
+  - @osdlc/typed-git@0.9.0
+
 ## 0.9.6
 
 ### Patch Changes

package/README.md

@@ -116,8 +116,9 @@ stderr and stdout, as the classifier does.
 
 Setup checks return their failure as a value. `installed()`, `authenticated()`,
 `authStatus()`, `ready()` and `api()` return their failure as part of their
-value, in all three call styles. For them, "gh is not installed" is the answer
-to the question they ask.
+value, from the plain method and from `try`. They have no soft form:
+`gh.soft.api(...)` throws a `TypeError`. For them, "gh is not installed" is the
+answer to the question they ask.
 
 ```ts
 import { describe } from '@osdlc/result'
@@ -169,6 +170,13 @@ if (page.truncated) console.warn('more than 50 open PRs; raise the limit')
 `prList`, `issueList`, `labelList`, `repoList` and `searchPrs` all work this
 way. A `limit` that is not a positive integer throws `RangeError`.
 
+GitHub search returns at most 1000 results, whatever the `limit`. gh uses
+search for `searchPrs`, for `prList` with a non-empty `search` or an `author`,
+and for `issueList` with a `label`. Those report `truncated: true` when 1000
+rows come back: there may be more that search would not return. Narrow the
+query to see them. `searchPrs` asks gh for at most 1000 rows, since gh refuses
+a larger search limit.
+
 ## A repository without a clone
 
 By default a client talks to the repository of the clone at its directory.
@@ -375,7 +383,8 @@ const repos = await runVerbAsync(repoList('acme', {}, { hostname: 'ghe.example.c
 })
 ```
 
-They take a `CommandRunner`. A plain `(binary, argv, opts) => result` function is wrapped as
+`runVerb` takes a `CommandRunner` and `runVerbAsync` an `AsyncCommandRunner`. A plain
+`(binary, argv, opts) => result` function is not a runner; wrap it yourself as
 `{ run: (argv, opts) => fn('gh', argv, opts) }`.
 
 ## `AsyncGh`
@@ -440,7 +449,7 @@ const prs = nodesAt(pages, ['repository', 'pullRequests'])
 ```
 
 With `paginate`, the query must take `$endCursor` and page one connection. gh follows only that
-one. `graphql` refuses a mutation with `RangeError`. Send one through `raw`.
+one. `graphql` refuses a document holding a mutation or subscription with `RangeError`. Send one through `raw`.
 
 ## Repositories and search
 
@@ -479,6 +488,36 @@ Import the runners themselves, such as `spawnRunner` and `spawnRunnerAsync`, fro
 named `gh` in the working directory cannot run in its place. Pass `{ absolutePathOnly: true }` when
 you build a real runner yourself.
 
+## Testing
+
+`@osdlc/typed-gh/testing` builds the rows a fake runner answers with. Each builder returns gh's raw
+`--json` shape, so the real parsers read it. Its defaults fill every field a parser requires, such
+as a pull request's `number`, a repository's `nameWithOwner` and the `headRefName` that
+`prList({ head })` filters on. Without them a row is dropped with no error.
+
+- `prRow`, `issueRow`, `repoRow`, `searchPrRow` and `labelRow`: one row of `gh pr`, `gh issue`,
+  `gh repo`, `gh search prs` and `gh label` output.
+- `checkRunRow`, `statusContextRow`, `commentRow` and `reviewRow`: entries of a pull request's
+  `statusCheckRollup`, `comments` and `reviews`.
+- `ghResult(payload)`: a `CommandResult` with exit code 0 and the payload as JSON on stdout.
+- Row types: `GhPrJson`, `GhIssueJson`, `GhRepoJson`, `GhSearchPrJson`, `GhLabelJson`,
+  `GhCheckRunJson`, `GhStatusContextJson`, `GhCommentJson`, `GhReviewJson` and `GhActorJson`, and
+  `RowOverrides<T>`, what a builder takes.
+
+Each builder takes typed overrides, merged shallowly. Pass a field as `undefined` to leave it out.
+A pull request's `url` follows its `number`, and a repository's its `nameWithOwner`. Assert on what
+you set: a default value may change in a minor release.
+
+```ts
+import { ghResult, prRow } from '@osdlc/typed-gh/testing'
+
+const runner: CommandRunner = {
+  run: () => ghResult([prRow({ number: 7, headRefName: 'task/foo' }), prRow({ number: 8 })]),
+}
+
+new Gh('/repo', { runner }).openPrFor('task/foo')?.number // 7
+```
+
 ## API
 
 Everything below is exported from `@osdlc/typed-gh`. The Stability section says which items are
@@ -547,7 +586,9 @@ Each verb takes an optional `GhTarget` last. Each client method has a verb of th
 - `parsePullRequest`: reads a `gh --json` payload into a `PullRequest`, or `null`.
 - `anyCheckFailed`: true if any check in a list failed.
 - `normalizeAuthorLogin`: drops a `[bot]` suffix from a login.
-- `parseOwnerRepo`: reads a remote URL into `{ owner, repo }`, or `null`.
+- `parseOwnerRepo`: reads a remote URL into `{ owner, repo }`, or `null`. It is
+  `@osdlc/typed-git`'s `parseRemoteRepo` without the host, so any host's remote reads, not only
+  GitHub's. Use `parseRemoteRepo` when you need the host too.
 - `ownerRepoSlug`: writes `{ owner, repo }` as `owner/repo`.
 - `parsePrUrl`: reads a pull request URL on any GitHub host into its host, owner, repository and
   number, or `null`.
@@ -588,7 +629,8 @@ The experimental items:
 - `GraphqlOptions`
 - `GraphqlVariable`
 
-Every other export and method is stable, `prDiff` included.
+Every other export and method is stable, `prDiff` included. So is `@osdlc/typed-gh/testing`: its
+builders and their row types. Their default values may change in any minor release.
 
 ## Platforms
 

package/SECURITY.md

@@ -42,9 +42,10 @@ not intend are in scope.
   value into a REST path. Pass endpoints you built, not text from a user.
   `issueCommentEdit(commentId)` accepts only digits and throws `RangeError`
   for anything else, so its id cannot change the path.
-- **`gh` chooses the repository.** It reads the working directory's git
-  remotes, or `GH_REPO`. A checkout whose `.git/config` points `origin` at
-  another repository sends mutations there. `ownerRepo` only parses a URL you
+- **Without a `repo` option, `gh` chooses the repository.** It reads the
+  working directory's git remotes, or `GH_REPO`. A checkout whose
+  `.git/config` points `origin` at another repository sends mutations there.
+  Pass `repo` (and `hostname`) to name the target in argv. `ownerRepo` only parses a URL you
   give it. It does not check where `gh` will act.
 - **`raw` and `rawChecked` run any `gh` command.** They have no allow list.
 - **`CommandFailed` carries the full argv.** Its message quotes the arguments,

package/dist/async.js

@@ -79,12 +79,15 @@ export class AsyncGh {
         return (await this.exec(verb, call));
     }
     // ── queries ───────────────────────────────────────────────────────────────
+    //
+    // Every method that builds a verb is `async`, so a bad argument (a verb's
+    // RangeError) rejects the Promise instead of throwing at the call site.
     /** Pull requests matching `opts`. Rejects when gh fails. `soft.prList` resolves null instead. */
-    prList(opts = {}) {
+    async prList(opts = {}) {
         return this.read(v.prList(opts, this.target), opts);
     }
     /** One PR by number, branch or URL, with the heavy fields, or null. See `Gh.prView`. */
-    prView(ref, opts = {}) {
+    async prView(ref, opts = {}) {
         return this.exec(v.prView(ref, opts.fields ?? v.PR_VIEW_FIELDS, this.target), opts);
     }
     /** The one PR that `input` names, or null. See `Gh.prFind`. */
@@ -127,11 +130,11 @@ export class AsyncGh {
         return last;
     }
     /** A PR's body text. Rejects when gh fails. */
-    prBody(number, opts = {}) {
+    async prBody(number, opts = {}) {
         return this.read(v.prBody(number, this.target), opts);
     }
     /** A REST GET through `gh api`. Failure is `ok: false`, never a rejection. */
-    api(endpoint, opts = {}) {
+    async api(endpoint, opts = {}) {
         return this.exec(v.api(endpoint, opts, this.target), opts);
     }
     /**
@@ -139,41 +142,41 @@ export class AsyncGh {
      *
      * @experimental
      */
-    graphql(query, variables = {}, opts = {}) {
+    async graphql(query, variables = {}, opts = {}) {
         return this.read(v.graphql(query, variables, opts, this.target), opts);
     }
     /** Every label on the repository (up to `opts.limit`, default 1000). Rejects when gh fails. */
-    labelList(opts = {}) {
+    async labelList(opts = {}) {
         return this.read(v.labelList(opts, this.target), opts);
     }
     /** Issues matching `opts`. Rejects when gh fails. */
-    issueList(opts = {}) {
+    async issueList(opts = {}) {
         return this.read(v.issueList(opts, this.target), opts);
     }
     /** One issue with its labels, or null when there is no such issue. */
-    issueView(number, opts = {}) {
+    async issueView(number, opts = {}) {
         return this.exec(v.issueView(number, this.target), opts);
     }
     /**
      * An owner's repositories. Rejects when gh fails. Each row's `owner` is in
      * GitHub's casing, not as passed. See `Gh.repoList`.
      */
-    repoList(owner, opts = {}) {
+    async repoList(owner, opts = {}) {
         return this.read(v.repoList(owner, opts, this.target), opts);
     }
     /**
      * One repository, or null when there is no such repository. `owner` and
      * `name` are in GitHub's casing, not as passed. See `Gh.repoView`.
      */
-    repoView(repo, opts = {}) {
+    async repoView(repo, opts = {}) {
         return this.exec(v.repoView(repo, opts.fields ?? v.REPO_FIELDS, this.target), opts);
     }
     /** Pull requests across repositories matching a search query. Rejects when gh fails. See `Gh.searchPrs`. */
-    searchPrs(query, opts = {}) {
+    async searchPrs(query, opts = {}) {
         return this.read(v.searchPrs(query, opts, this.target), opts);
     }
     /** True iff the `gh` binary is on PATH and runs. */
-    installed() {
+    async installed() {
         return this.exec(v.installed());
     }
     /** True iff `gh` holds credentials. */
@@ -181,7 +184,7 @@ export class AsyncGh {
         return (await this.authStatus()).ok;
     }
     /** Login state and what `gh auth status` printed. */
-    authStatus() {
+    async authStatus() {
         return this.exec(v.authStatus(this.target));
     }
     /** True iff `gh` is installed and authenticated. Skips the auth check when `gh` is not installed. */
@@ -197,23 +200,23 @@ export class AsyncGh {
     }
     // ── mutations (checked) ───────────────────────────────────────────────────
     /** Open a PR and resolve to its URL ('' if gh printed none). */
-    createPr(opts) {
+    async createPr(opts) {
         return this.exec(v.createPr(opts, this.target));
     }
     /** Retitle or rewrite a PR body. */
-    editPr(number, opts) {
+    async editPr(number, opts) {
         return this.exec(v.editPr(number, opts, this.target));
     }
     /** Rewrite just a PR's body. */
-    editPrBody(number, body) {
+    async editPrBody(number, body) {
         return this.exec(v.editPrBody(number, body, this.target));
     }
     /** The PR's unified diff. Rejects with the classified failure when gh cannot produce it. */
-    prDiff(number) {
+    async prDiff(number) {
         return this.exec(v.prDiff(number, this.target));
     }
     /** Post one conversation comment on a PR. Resolves to its URL ('' if gh printed none). */
-    prComment(number, body) {
+    async prComment(number, body) {
         return this.exec(v.prComment(number, body, this.target));
     }
     /**
@@ -221,15 +224,15 @@ export class AsyncGh {
      *
      * @experimental
      */
-    createReview(number, opts) {
+    async createReview(number, opts) {
         return this.exec(v.createReview(number, opts, this.target));
     }
     /** Bring a PR's head branch up to date with its base. */
-    prUpdateBranch(number, style = 'merge') {
+    async prUpdateBranch(number, style = 'merge') {
         return this.exec(v.prUpdateBranch(number, style, this.target));
     }
     /** Mark a PR ready for review (`draft: false`) or convert it to a draft (`draft: true`). */
-    prSetDraft(number, draft) {
+    async prSetDraft(number, draft) {
         return this.exec(v.prSetDraft(number, draft, this.target));
     }
     /**
@@ -238,27 +241,26 @@ export class AsyncGh {
      * @experimental
      */
     async issueCommentEdit(commentId, body) {
-        // async, so a bad id rejects the Promise instead of throwing at the call site.
         return this.exec(v.issueCommentEdit(commentId, body, this.target));
     }
     /** Merge a PR. GitHub refuses when its head is no longer `opts.headSha`. */
-    prMerge(number, opts) {
+    async prMerge(number, opts) {
         return this.exec(v.prMerge(number, opts, this.target));
     }
     /** A PR's review threads. Rejects when they could not be read completely. `soft.prReviewThreads` resolves null instead. */
-    prReviewThreads(number) {
+    async prReviewThreads(number) {
         return this.read(v.prReviewThreads(number, this.target));
     }
     /** Create a label (or force it to `opts`'s color/description if it exists). */
-    createLabel(opts) {
+    async createLabel(opts) {
         return this.exec(v.createLabel(opts, this.target));
     }
     /** Recolor and/or redescribe an existing label. */
-    editLabel(name, opts) {
+    async editLabel(name, opts) {
         return this.exec(v.editLabel(name, opts, this.target));
     }
     /** Swap an issue's label in a single `gh issue edit` call. */
-    setIssueLabel(number, currentLabel, newLabel) {
+    async setIssueLabel(number, currentLabel, newLabel) {
         return this.exec(v.setIssueLabel(number, currentLabel, newLabel, this.target));
     }
 }

package/dist/doors.d.ts

@@ -27,12 +27,17 @@ import type { GhVerb } from './verbs.ts';
  * Read the result of running `verb` as the methods that throw do.
  *
  * A checked verb has already thrown on a non-zero exit (the runner is
- * `runChecked`). A probe (`installed`, `authStatus`, `api`) carries its
+ * {@link runCheckedGh}). A probe (`installed`, `authStatus`, `api`) carries its
  * failure in its value. A read that exited non-zero throws the classified
  * failure, unless the verb's `absent` says gh's answer was "there is no such
  * thing", which `parse` turns into `null`. A read that exited 0 but parsed to `null`
  * could not be read completely, and throws.
  *
+ * A result flagged `outputIncomplete` throws for every verb but a probe, as
+ * typed-git's `gate` does: gh exited, but the runner stopped reading at the
+ * output cap or a timeout, so a parse would take cut-short output as whole.
+ * Both read a result through command-seam's `runFailed`.
+ *
  * @throws `FailureError` carrying the classified {@link GhFailure} for a failed run.
  * @throws `FailureError` carrying an `unreadable` {@link GhFailure}.
  */
@@ -43,9 +48,14 @@ export declare function settle<T>(verb: GhVerb<T>, result: CommandResult, binary
  * `CommandFailed` as its `cause`. Anything else is returned as it is.
  */
 export declare function ghFailureError(error: unknown): unknown;
-/** {@link runChecked}, throwing {@link ghFailureError}'s classified failure. */
+/**
+ * Run `argv` and throw {@link ghFailureError}'s classified failure unless gh
+ * exited 0 with its whole output. Output cut short (`outputIncomplete`) is a
+ * failure too, which `runChecked` alone would not catch: it checks only the
+ * exit code.
+ */
 export declare function runCheckedGh(runner: CommandRunner, argv: string[], opts: CommandRunOptions): CommandResult;
-/** {@link runCheckedAsync}, rejecting with {@link ghFailureError}'s classified failure. */
+/** {@link runCheckedGh} for an awaitable runner, rejecting with the classified failure. */
 export declare function runCheckedGhAsync(runner: AsyncCommandRunner, argv: string[], opts: AsyncCommandRunOptions): Promise<CommandResult>;
 /** The members `try` and `soft` leave out: `raw`, `rawChecked`, helpers that run nothing, and properties. */
 type Triable<C> = Omit<C, 'raw' | 'rawChecked' | 'at' | 'withRepo' | 'ownerRepo' | 'try' | 'soft' | 'cwd' | 'repo' | 'hostname'>;
@@ -73,7 +83,10 @@ export type Soft<C> = {
 export declare function failureOf(error: {
     failure: Failure;
 }): GhFailure;
-/** Wrap a synchronous client so every method returns a `Result<T, GhFailure>`. */
+/**
+ * Wrap a synchronous client so every method returns a `Result<T, GhFailure>`.
+ * The proxy is command-seam's `tryMethods`, so a new method needs no entry.
+ */
 export declare function triedSync<C extends object>(client: C): TriedSync<C>;
 /** Wrap an awaitable client so every method promises a `Result<T, GhFailure>`. */
 export declare function triedAsync<C extends object>(client: C): TriedAsync<C>;

package/dist/doors.js

@@ -19,30 +19,39 @@
  * `try` and `soft` are proxies over the whole client, so a new method needs no
  * change here.
  */
-import { CommandFailed, isCommandFailed, runChecked, runCheckedAsync, } from '@osdlc/command-seam';
-import { err, FailureError, isFailure, ok } from '@osdlc/result';
+import { CommandFailed, isCommandFailed, methodFacade, runFailed, tryMethods, tryMethodsAsync, } from '@osdlc/command-seam';
+import { FailureError, isFailure } from '@osdlc/result';
 import { classifyGhFailure, unreadableFailure } from "./failure.js";
 /**
  * Read the result of running `verb` as the methods that throw do.
  *
  * A checked verb has already thrown on a non-zero exit (the runner is
- * `runChecked`). A probe (`installed`, `authStatus`, `api`) carries its
+ * {@link runCheckedGh}). A probe (`installed`, `authStatus`, `api`) carries its
  * failure in its value. A read that exited non-zero throws the classified
  * failure, unless the verb's `absent` says gh's answer was "there is no such
  * thing", which `parse` turns into `null`. A read that exited 0 but parsed to `null`
  * could not be read completely, and throws.
  *
+ * A result flagged `outputIncomplete` throws for every verb but a probe, as
+ * typed-git's `gate` does: gh exited, but the runner stopped reading at the
+ * output cap or a timeout, so a parse would take cut-short output as whole.
+ * Both read a result through command-seam's `runFailed`.
+ *
  * @throws `FailureError` carrying the classified {@link GhFailure} for a failed run.
  * @throws `FailureError` carrying an `unreadable` {@link GhFailure}.
  */
 export function settle(verb, result, binary) {
-    if (verb.checked || verb.probe === true)
+    if (verb.probe === true)
         return verb.parse(result);
-    if (result.neverExited === true || result.exitCode !== 0) {
-        if (result.neverExited !== true && verb.absent?.(result) === true)
-            return verb.parse(result);
+    // A checked verb's runner has already thrown on a non-zero exit.
+    const failed = verb.checked
+        ? result.outputIncomplete === true
+        : runFailed(result, (r) => verb.absent?.(r) === true);
+    if (failed)
         throw ghFailureError(new CommandFailed(verb.argv, result, binary));
-    }
+    // A non-zero exit that got this far is gh's "there is no such thing".
+    if (verb.checked || result.exitCode !== 0)
+        return verb.parse(result);
     const value = verb.parse(result);
     if (value === null) {
         throw new FailureError(unreadableFailure(verb.argv, result.stdout, binary));
@@ -57,24 +66,35 @@ export function settle(verb, result, binary) {
 export function ghFailureError(error) {
     return isCommandFailed(error) ? new FailureError(classifyGhFailure(error)) : error;
 }
-/** {@link runChecked}, throwing {@link ghFailureError}'s classified failure. */
+/**
+ * Run `argv` and throw {@link ghFailureError}'s classified failure unless gh
+ * exited 0 with its whole output. Output cut short (`outputIncomplete`) is a
+ * failure too, which `runChecked` alone would not catch: it checks only the
+ * exit code.
+ */
 export function runCheckedGh(runner, argv, opts) {
     try {
-        return runChecked(runner, argv, opts);
+        return whole(runner.run(argv, opts), argv, runner.binary);
     }
     catch (error) {
         throw ghFailureError(error);
     }
 }
-/** {@link runCheckedAsync}, rejecting with {@link ghFailureError}'s classified failure. */
+/** {@link runCheckedGh} for an awaitable runner, rejecting with the classified failure. */
 export async function runCheckedGhAsync(runner, argv, opts) {
     try {
-        return await runCheckedAsync(runner, argv, opts);
+        return whole(await runner.run(argv, opts), argv, runner.binary);
     }
     catch (error) {
         throw ghFailureError(error);
     }
 }
+/** `result`, or a `CommandFailed` thrown when it is a failure (command-seam's `runFailed`). */
+function whole(result, argv, binary) {
+    if (runFailed(result))
+        throw new CommandFailed(argv, result, binary);
+    return result;
+}
 /**
  * The queries that have a soft form. A mutation has none. If a write's failure
  * were dropped, the caller would believe the write worked.
@@ -110,45 +130,20 @@ export function failureOf(error) {
     const thrown = error;
     return isCommandFailed(thrown) ? classifyGhFailure(thrown) : error.failure;
 }
-function facade(client, wrap) {
-    return new Proxy(client, {
-        get(target, prop) {
-            // Read from the target, not the proxy. A getter (`try` itself) must run
-            // against the real client, not recurse through the proxy.
-            const value = Reflect.get(target, prop);
-            if (typeof value !== 'function')
-                return value;
-            const method = value;
-            const name = String(prop);
-            return (...args) => wrap(() => method.apply(target, args), name);
-        },
-    });
+/** The failure a thrown value carries, or `null` for a bug to rethrow. */
+function recognize(error) {
+    return isGhFailure(error) ? failureOf(error) : null;
 }
-/** Wrap a synchronous client so every method returns a `Result<T, GhFailure>`. */
+/**
+ * Wrap a synchronous client so every method returns a `Result<T, GhFailure>`.
+ * The proxy is command-seam's `tryMethods`, so a new method needs no entry.
+ */
 export function triedSync(client) {
-    return facade(client, (call) => {
-        try {
-            return ok(call());
-        }
-        catch (error) {
-            if (isGhFailure(error))
-                return err(failureOf(error));
-            throw error;
-        }
-    });
+    return tryMethods(client, recognize);
 }
 /** Wrap an awaitable client so every method promises a `Result<T, GhFailure>`. */
 export function triedAsync(client) {
-    return facade(client, async (call) => {
-        try {
-            return ok(await call());
-        }
-        catch (error) {
-            if (isGhFailure(error))
-                return err(failureOf(error));
-            throw error;
-        }
-    });
+    return tryMethodsAsync(client, recognize);
 }
 function checkSoft(name) {
     if (!SOFT_METHODS.includes(name)) {
@@ -157,7 +152,7 @@ function checkSoft(name) {
 }
 /** Wrap a synchronous client so a failed query returns `null`. */
 export function softSync(client) {
-    return facade(client, (call, name) => {
+    return methodFacade(client, (call, name) => {
         checkSoft(name);
         try {
             return call();
@@ -171,7 +166,7 @@ export function softSync(client) {
 }
 /** Wrap an awaitable client so a failed query resolves to `null`. */
 export function softAsync(client) {
-    return facade(client, async (call, name) => {
+    return methodFacade(client, async (call, name) => {
         checkSoft(name);
         try {
             return await call();

package/dist/failure.js

@@ -7,7 +7,7 @@
  * in English. A message that matches none stays the subprocess layer's `exit`
  * with `gh`'s first stderr line, never a wrong kind.
  */
-import { classifyFailure } from '@osdlc/command-seam';
+import { classifyFailed } from '@osdlc/command-seam';
 import {} from '@osdlc/result';
 const INSTALL_HINT = 'Install it from https://cli.github.com, then run `gh auth login`.';
 const RATE_LIMITED = /API rate limit exceeded|secondary rate limit|rate limit exceeded|HTTP 429/i;
@@ -37,13 +37,8 @@ export function isAbsent(thing, text) {
 export function classifyGhFailure(failed) {
     // The client's runner may not name its binary. It is gh either way, so the
     // messages say `gh` rather than "The command".
-    const f = failed.binary === undefined
-        ? (classifyFailure(failed.result, { binary: 'gh', argv: failed.argv }) ?? failed.failure)
-        : failed.failure;
-    const base = { ...f, cause: failed };
-    if (f.kind === 'not-installed')
-        return { ...base, hint: INSTALL_HINT };
-    if (f.kind !== 'exit')
+    const base = classifyFailed(failed, { binary: 'gh', installHint: INSTALL_HINT });
+    if (base.kind !== 'exit')
         return base;
     const text = `${failed.result.stderr}\n${failed.result.stdout}`;
     if (RATE_LIMITED.test(text)) {

package/dist/parse.js

@@ -266,6 +266,14 @@ export function parsePrSearchHit(raw) {
         labels: parseLabels(raw['labels']),
         createdAt: strOrNull(raw['createdAt']),
         updatedAt: strOrNull(raw['updatedAt']),
-        closedAt: strOrNull(raw['closedAt']),
+        closedAt: searchTime(raw['closedAt']),
     };
 }
+/**
+ * gh search prints Go's zero time (`0001-01-01T00:00:00Z`) for a time that is
+ * not set, such as `closedAt` on an open pull request. That is no time.
+ */
+function searchTime(x) {
+    const s = strOrNull(x);
+    return s === null || s.startsWith('0001-01-01') ? null : s;
+}

package/dist/repo.d.ts

@@ -2,15 +2,20 @@
  * Reading the GitHub owner and repository from a git remote, and a pull
  * request from a URL or what a person typed.
  *
- * `parseOwnerRepo` uses `@osdlc/typed-git`'s `parseGitUrl`. It lives here so
- * callers do not each write a regex over `remote.origin.url`. Such a regex
- * usually misses a URL form: scp-style, a trailing `.git`, an `ssh://` port,
- * or a bare `owner/repo`.
+ * `parseOwnerRepo` is `@osdlc/typed-git`'s `parseRemoteRepo` without the
+ * host, so it reads every remote form typed-git reads (scp-style, a trailing
+ * `.git`, an `ssh://` port, a bare `owner/repo`, an Enterprise host) and no
+ * caller writes its own regex over `remote.origin.url`.
  */
 import type { OwnerRepo } from './types.ts';
 /**
  * `{owner, repo}` from any git remote reference, or null when it names no
  * project. Handles https, ssh, scp-style, and bare `owner/repo`.
+ *
+ * It is typed-git's `parseRemoteRepo` without the host: a clone URL on a host
+ * `parseGitUrl` does not know, such as a GitHub Enterprise host or another
+ * forge's `host/owner/repo`, is read host-agnostically. It does not check
+ * that the host is GitHub; read `parseRemoteRepo(url).host` for that.
  */
 export declare function parseOwnerRepo(remoteUrl: string): OwnerRepo | null;
 /** `owner/repo`, the form `gh api` paths and `--repo` both take. */

package/dist/repo.js

@@ -2,24 +2,24 @@
  * Reading the GitHub owner and repository from a git remote, and a pull
  * request from a URL or what a person typed.
  *
- * `parseOwnerRepo` uses `@osdlc/typed-git`'s `parseGitUrl`. It lives here so
- * callers do not each write a regex over `remote.origin.url`. Such a regex
- * usually misses a URL form: scp-style, a trailing `.git`, an `ssh://` port,
- * or a bare `owner/repo`.
+ * `parseOwnerRepo` is `@osdlc/typed-git`'s `parseRemoteRepo` without the
+ * host, so it reads every remote form typed-git reads (scp-style, a trailing
+ * `.git`, an `ssh://` port, a bare `owner/repo`, an Enterprise host) and no
+ * caller writes its own regex over `remote.origin.url`.
  */
-import { parseGitUrl } from '@osdlc/typed-git';
+import { parseRemoteRepo } from '@osdlc/typed-git';
 /**
  * `{owner, repo}` from any git remote reference, or null when it names no
  * project. Handles https, ssh, scp-style, and bare `owner/repo`.
+ *
+ * It is typed-git's `parseRemoteRepo` without the host: a clone URL on a host
+ * `parseGitUrl` does not know, such as a GitHub Enterprise host or another
+ * forge's `host/owner/repo`, is read host-agnostically. It does not check
+ * that the host is GitHub; read `parseRemoteRepo(url).host` for that.
  */
 export function parseOwnerRepo(remoteUrl) {
-    const info = parseGitUrl(remoteUrl);
-    if (info === null)
-        return null;
-    const { user, project } = info;
-    if (!user || !project)
-        return null;
-    return { owner: user, repo: project };
+    const remote = parseRemoteRepo(remoteUrl);
+    return remote === null ? null : { owner: remote.owner, repo: remote.repo };
 }
 /** `owner/repo`, the form `gh api` paths and `--repo` both take. */
 export function ownerRepoSlug(r) {