@pmelab/gtd 64.1.0 → 64.1.2

package/dist/wire.mjs

@@ -1,2 +1 @@
-import { A as UNATTRIBUTED_MODEL, C as EXIT_RUNTIME_ERROR, D as EXIT_USAGE_ERROR, E as EXIT_STRAYS_FOUND, M as renderFormat, O as ACCESS_REFUSAL, S as EXIT_OK, T as EXIT_SIGTERM, _ as BEAT_KINDS, a as renderScriptJson, b as stallDiagnosis, c as landProseText, d as renderLandPlain, f as DEMAND_BRIEFING, g as statusOf, h as renderBeatJson, i as judgeJson, j as WIRE_SCHEMA, k as PIN_PATH, l as noopText, m as beatDocument, n as resolveSession, o as scriptFields, p as renderBeatPlain, r as selectPath, s as landFields, t as globMatches, u as renderLandJson, v as beatKindOf, w as EXIT_SIGINT, x as EXIT_CODES, y as demandOf } from "./chunks/wire-CPNSm_9N.mjs";
-export { ACCESS_REFUSAL, BEAT_KINDS, DEMAND_BRIEFING, EXIT_CODES, EXIT_OK, EXIT_RUNTIME_ERROR, EXIT_SIGINT, EXIT_SIGTERM, EXIT_STRAYS_FOUND, EXIT_USAGE_ERROR, PIN_PATH, UNATTRIBUTED_MODEL, WIRE_SCHEMA, beatDocument, beatKindOf, demandOf, globMatches, judgeJson, landFields, landProseText, noopText, renderBeatJson, renderBeatPlain, renderFormat, renderLandJson, renderLandPlain, renderScriptJson, resolveSession, scriptFields, selectPath, stallDiagnosis, statusOf };
+export { O as ACCESS_REFUSAL, _ as BEAT_KINDS, f as DEMAND_BRIEFING, x as EXIT_CODES, S as EXIT_OK, C as EXIT_RUNTIME_ERROR, w as EXIT_SIGINT, T as EXIT_SIGTERM, E as EXIT_STRAYS_FOUND, D as EXIT_USAGE_ERROR, k as PIN_PATH, A as UNATTRIBUTED_MODEL, j as WIRE_SCHEMA, m as beatDocument, v as beatKindOf, y as demandOf, t as globMatches, i as judgeJson, s as landFields, c as landProseText, l as noopText, h as renderBeatJson, p as renderBeatPlain, M as renderFormat, u as renderLandJson, d as renderLandPlain, a as renderScriptJson, n as resolveSession, o as scriptFields, r as selectPath, b as stallDiagnosis, g as statusOf } from "./chunks/wire-CaPJ9Tme.mjs";

package/dist/workflow-kit.mjs

@@ -1,6 +1,6 @@
-import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-B7ZRCe-B.mjs";
-import { C as reviewRisks, N as parseThreads, S as reviewNotes, T as unansweredNotes, n as stripCodeThreads, x as reviewDecisions } from "./chunks/steering-Cem5i6Xl.mjs";
-//#region src/workflow-kit/health.ts
+import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-dnIE_qbe.mjs";
+import { C as reviewRisks, N as parseThreads, S as reviewNotes, T as unansweredNotes, n as stripCodeThreads, x as reviewDecisions } from "./chunks/steering-CQzL-lX1.mjs";
+// src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
 const escalation = async (count, steps) => {
 	if (count.rounds >= steps.limit) return steps.exhausted();
@@ -74,8 +74,7 @@ const healthy = async (fix, health) => {
 const gate = (name, passes, blocked) => scope(name, async () => {
 	while (!await passes()) await blocked();
 });
-//#endregion
-//#region src/workflow-kit/quality.ts
+// src/workflow-kit/quality.ts
 const lensOf = (entry) => {
 	const at = entry.indexOf("=");
 	return at < 0 ? {
@@ -106,8 +105,7 @@ const fixFindings = async (f) => {
 	await f.escalate();
 	return false;
 };
-//#endregion
-//#region src/workflow-kit/scenarios.ts
+// src/workflow-kit/scenarios.ts
 const DOC_STRING = /^("""|```)/;
 const THEN = /^Then\s/;
 const CONTINUATION = /^(And|But|\*)\s/;
@@ -161,8 +159,7 @@ const removedAssertions = (changes) => changes.filter((c) => c.path.endsWith(".f
 		lines
 	};
 }).filter((r) => r.lines.length > 0);
-//#endregion
-//#region src/workflow-kit/review.ts
+// src/workflow-kit/review.ts
 const collect = async (p, capture, round, requested) => {
 	await p.collecting(capture, round);
 	if (read(p.feedback) !== void 0) return "feedback";
@@ -426,5 +423,4 @@ const reviewToHandOff = async (base, p) => {
 		return;
 	}
 };
-//#endregion
 export { assertionLines, escalation, fixFindings, gate, healthy, lensEntriesOf, lensOf, lensScopes, lensesOf, qualityLap, removedAssertions, review, reviewToHandOff, untilSettled };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "64.1.0",
+  "version": "64.1.2",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -83,33 +83,17 @@
   "scripts": {
     "prepare": "husky",
     "dev": "node dev/run.mjs",
-    "build": "tsdown --filter web && npx @tailwindcss/cli -i src/web/styles.css -o dist/web/main.css --minify && node scripts/inline-web-client.mjs && tsdown --filter gtd --filter core && tsdown --filter entrypoints",
-    "postbuild": "node scripts/assert-no-test-doubles.mjs",
-    "watch": "tsdown --watch",
+    "watch": "vp pack --watch",
     "bench:replay": "node scripts/bench-replay.mjs",
     "test": "jiti scripts/test-states.main.ts",
-    "test:unit": "vitest run --project unit",
-    "test:workflows": "vitest run --project workflows",
     "test:watch": "vitest",
     "test:changed": "vitest run --project unit --project e2e-inmem --project workflows --changed HEAD",
-    "test:e2e": "npm run test:e2e:inmem && npm run test:e2e:live",
-    "typecheck": "tsc --noEmit && tsc --noEmit -p src/web/tsconfig.json",
-    "lint": "oxlint .",
-    "lint:sh": "jiti scripts/generate-shell-corpus.ts --check && shellcheck -s sh tests/shell/corpus/*.sh",
-    "lint:boundaries": "depcruise src tests claude",
-    "format": "oxfmt --write .",
-    "format:check": "oxfmt --check .",
+    "test:e2e": "vp run test:e2e:inmem && vp run test:e2e:live",
+    "format": "vp fmt",
     "test:mutation": "stryker run",
-    "test:e2e:inmem": "vitest run --project e2e-inmem",
-    "test:e2e:live": "vitest run --project e2e-live --no-file-parallelism",
-    "analyze": "fallow --summary --quiet",
-    "test:web": "vitest run --project storybook",
     "storybook": "storybook dev --host 0.0.0.0",
     "coverage": "vitest run --project unit --coverage"
   },
-  "lint-staged": {
-    "*": "oxfmt --no-error-on-unmatched-pattern --write"
-  },
   "devDependencies": {
     "@commitlint/cli": "^21.2.3",
     "@commitlint/config-conventional": "^21.2.3",
@@ -119,8 +103,8 @@
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^12.0.8",
     "@semantic-release/npm": "^12.0.0",
-    "@storybook/addon-vitest": "^10.6.0",
-    "@storybook/react-vite": "^10.6.0",
+    "@storybook/addon-vitest": "^10.6.5",
+    "@storybook/react-vite": "^10.6.5",
     "@stryker-mutator/core": "^9.6.1",
     "@stryker-mutator/typescript-checker": "^9.6.1",
     "@stryker-mutator/vitest-runner": "^9.6.1",
@@ -134,29 +118,27 @@
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.2.0",
-    "@vitest/browser": "^4.1.12",
-    "@vitest/browser-playwright": "^4.1.12",
-    "@vitest/coverage-v8": "^4.1.12",
+    "@vitest/browser": "5.0.5",
+    "@vitest/browser-playwright": "5.0.5",
+    "@vitest/coverage-v8": "5.0.5",
     "dependency-cruiser": "^18.3.1",
     "fallow": "3.25.0",
     "fast-check": "^4.8.0",
     "husky": "^9.1.7",
     "jiti": "^2.7.0",
-    "lint-staged": "^17.0.8",
-    "oxfmt": "^0.59.0",
-    "oxlint": "^1.74.0",
+    "oxfmt": "0.59.0",
+    "oxlint": "1.74.0",
     "playwright": "^1.62.1",
     "prettier": "^3.8.1",
     "quickpickle": "1.11.2",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "semantic-release": "^25.0.5",
-    "storybook": "^10.6.0",
+    "storybook": "^10.6.5",
     "tailwind-merge": "^3.7.0",
     "tailwindcss": "^4.3.3",
-    "tsdown": "^0.22.8",
-    "turbo": "^2.10.9",
-    "vitest": "^4.1.12",
+    "vite-plus": "1.4.0",
+    "vitest": "5.0.5",
     "yaml": "^2.8.2",
     "zustand": "^5.0.15"
   },
@@ -190,5 +172,10 @@
     "rolldown": "^1.1.5",
     "vscode-languageserver": "^10.1.0",
     "vscode-languageserver-textdocument": "^1.0.13"
+  },
+  "overrides": {
+    "storybook": {
+      "vite-plus": "$vite-plus"
+    }
   }
 }

package/src/edge/Edge.test.ts

@@ -757,7 +757,7 @@ describe("restAt", () => {
         `--model=${model}`,
       )
       expect(exitCode).toBe(0)
-      await applied(repo, (JSON.parse(stdout) as { readonly script: string }).script)
+      applied(repo, (JSON.parse(stdout) as { readonly script: string }).script)
       await takePinBeat(repo, "add")
     }
     const { cost } = await provide(currentRest, repo)

package/src/edge/Edge.ts

@@ -238,7 +238,7 @@ const historyFormatFault = (history: History, location: EpisodeLocation): string
 const runOf = (
   history: History,
   location: EpisodeLocation,
-  closingHash: string | undefined = undefined,
+  closingHash?: string,
 ): Effect.Effect<ProcessRun, Error> => {
   const fault = historyFormatFault(history, location)
   return fault === undefined

package/src/emit/GitScript.test.ts

@@ -234,7 +234,7 @@ describe("shellQuote", () => {
   })
 
   // 500 samples through 500 bash spawns starved the 30s test timeout whenever
-  // the suite ran under turbo's parallel task load. The property is unchanged;
+  // the suite ran under `npm test`'s parallel task load. The property is unchanged;
   // all samples now round-trip through a SINGLE bash, NUL-delimited on the way
   // back out (NUL is filtered from the inputs, so it can't collide).
   it("round-trips arbitrary strings — including newlines and non-ASCII — through a real bash printf", () => {

package/src/flows/runtime.test.ts

@@ -146,7 +146,7 @@ describe("kept()", () => {
 })
 
 /** A context that records every step request and resolves it with `reply`. */
-const recording = (reply: unknown = undefined) => {
+const recording = (reply?: unknown) => {
   const requests: StepRequest[] = []
   installContext({
     step: async (request: StepRequest) => {

package/src/replay/Replay.test.ts

@@ -370,7 +370,9 @@ describe("replay", () => {
     })
 
     it("is reported when history continues past the end of the flow", async () => {
-      const short = async () => void (await human("only"))
+      const short = async () => {
+        await human("only")
+      }
       const h = new History().land("human", "only", 1, "only").land("human", "only", 2, "only")
       expect((await replayOf(short, h)).kind).toBe("divergence")
     })
@@ -606,7 +608,9 @@ describe("replay", () => {
   })
 
   it("ends the episode on return and on restart", async () => {
-    const returning = async () => void (await human("only"))
+    const returning = async () => {
+      await human("only")
+    }
     const h = new History().land("human", "only", 1, "only")
     expect(await replayOf(returning, h)).toMatchObject({ kind: "ended", via: "return" })
 
@@ -1337,7 +1341,9 @@ describe("replay: a repin's anchor", () => {
   })
 
   it("diverges when the flow ends where it names a step", async () => {
-    const outcome = await replayOf(async () => void (await human("idle")), anchoredHistory())
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, anchoredHistory())
     expect(outcome).toMatchObject({ kind: "divergence", at: hashOf(3), reached: undefined })
   })
 
@@ -1346,7 +1352,9 @@ describe("replay: a repin's anchor", () => {
       .land("human", "idle", 1, "build", { "a.txt": "a" })
       .land("agent", "build", 1, "old")
       .raw(anchorTo("gtd:unpin", 1))
-    const outcome = await replayOf(async () => void (await human("idle")), h)
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, h)
     expect(outcome.kind).toBe("ended")
   })
 
@@ -1355,13 +1363,17 @@ describe("replay: a repin's anchor", () => {
       .land("human", "idle", 1, "build", { "a.txt": "a" })
       .land("agent", "build", 1, "old")
       .raw(`gtd(check): pin → unpin\n\nGtd-Pin: add\nGtd-Anchor: ${hashOf(1)}\nGtd-Format: 3`)
-    const outcome = await replayOf(async () => void (await human("idle")), h)
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, h)
     expect(outcome.kind).toBe("ended")
   })
 
   it("reads a format 4 anchor naming unpin as a step", async () => {
     const outcome = await replayOf(
-      async () => void (await human("idle")),
+      async () => {
+        await human("idle")
+      },
       new History()
         .land("human", "idle", 1, "build", { "a.txt": "a" })
         .land("agent", "build", 1, "old")
@@ -1372,7 +1384,9 @@ describe("replay: a repin's anchor", () => {
 
   it("fails when it names no commit replay reads", async () => {
     const h = anchoredHistory().raw(anchorTo("build", 2))
-    const outcome = await replayOf(async () => void (await human("idle")), h)
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, h)
     expect(outcome.kind === "failed" && outcome.message).toContain(
       "which is no commit replay reads",
     )

package/src/steering/Blocks.test.ts

@@ -35,7 +35,9 @@ describe("blockRunInline — spec-feedback regression: a nested list item's own
     const nodes = blockNodesOf(content, tree)
     const topItem = nodes[0]?.block?.items?.[0]
     expect(topItem?.inline).toEqual([{ kind: "text", value: "outer" }])
-    expect(topItem?.items).toEqual([{ text: "inner", inline: [{ kind: "text", value: "inner" }] }])
+    expect(topItem?.items).toEqual([
+      { text: "inner", inline: [{ kind: "text", value: "inner" }], line: 1 },
+    ])
   })
 })
 

package/src/steering/Blocks.ts

@@ -128,21 +128,28 @@ const nodeInline = (
   return title.length > 0 ? [{ kind: "text", value: title }] : []
 }
 
+type NoteAt = ReturnType<typeof noteLookup>
+
 /** One list item as a `BlockListItem`, recursing into a nested `list` child (there is at most one, CommonMark's own shape) as its own `items`. */
-const blockListItemOf = (content: string, item: ListItem): BlockListItem => {
+const blockListItemOf = (content: string, item: ListItem, noteAt: NoteAt): BlockListItem => {
   const nested = item.children.filter((c): c is List => c.type === "list")
-  const items = nested.flatMap((list) => blockListItemsOf(content, list.children))
+  const items = nested.flatMap((list) => blockListItemsOf(content, list.children, noteAt))
+  const line = item.position === undefined ? undefined : toLspPosition(item.position.start).line
   return {
     text: listItemText(content, item),
     inline: listItemInline(content, item),
     ...(item.checked === true || item.checked === false ? { checked: item.checked } : {}),
     ...(items.length > 0 ? { items } : {}),
+    ...(line === undefined ? {} : { line, ...noteAt(line) }),
   }
 }
 
 /** Every item of a `list` node's own `children`, as `BlockListItem`s, in document order. */
-const blockListItemsOf = (content: string, items: readonly ListItem[]): readonly BlockListItem[] =>
-  items.map((item) => blockListItemOf(content, item))
+const blockListItemsOf = (
+  content: string,
+  items: readonly ListItem[],
+  noteAt: NoteAt,
+): readonly BlockListItem[] => items.map((item) => blockListItemOf(content, item, noteAt))
 
 /** The `title` an empty fenced code block (a `` ``` ``/`` ``` `` pair with nothing between them) falls back to — its real body is `""`, and every node still carries a non-empty title. */
 const EMPTY_CODE_BLOCK_TITLE = "(empty code block)"
@@ -184,6 +191,7 @@ const blockTitle = (content: string, node: RootContent, options?: BlockWalkOptio
 const blockOf = (
   content: string,
   node: RootContent,
+  noteAt: NoteAt,
   options?: BlockWalkOptions,
 ): SteeringViewNode["block"] | undefined => {
   switch (node.type) {
@@ -197,7 +205,7 @@ const blockOf = (
       return {
         kind: "list",
         ordered: node.ordered === true,
-        items: blockListItemsOf(content, visibleListItems(node, options)),
+        items: blockListItemsOf(content, visibleListItems(node, options), noteAt),
       }
     case "code":
       return {
@@ -285,7 +293,7 @@ export const blockNodesOfRun = (
   const noteAt = noteLookup(content, options?.footnotes)
   return visibleNodes(content, nodes, options).map((node) => {
     const startLine = toLspPosition(node.position!.start).line
-    const block = blockOf(content, node, options)
+    const block = blockOf(content, node, noteAt, options)
     return {
       title: blockTitle(content, node, options),
       anchor: { kind: "paragraph" as const, line: startLine },

package/src/steering/SteeringFormat.ts

@@ -89,6 +89,11 @@ export interface BlockListItem {
   readonly items?: readonly BlockListItem[]
   /** `text`'s own inline structure — the shared renderer walks this instead of `text` when present. Populated at every nesting depth. */
   readonly inline?: readonly InlineNode[]
+  /** The item's own 0-based source line: a `paragraph` anchor at it notes this item alone. */
+  readonly line?: number
+  /** The note or thread whose marker sits on `line`, as on a view node. */
+  readonly note?: string
+  readonly thread?: SteeringViewThread
 }
 
 export interface SteeringViewThread {

package/src/steering/qa.test.ts

@@ -1172,7 +1172,7 @@ describe("qa.view — block nodes (package 02, T1/T2)", () => {
     expect(topItem?.text).not.toContain("Nested")
     expect(topItem?.text).not.toContain("-")
     expect(topItem?.items).toEqual([
-      { text: "Nested", inline: [{ kind: "text", value: "Nested" }] },
+      { text: "Nested", inline: [{ kind: "text", value: "Nested" }], line: 2 },
     ])
   })
 
@@ -1180,8 +1180,8 @@ describe("qa.view — block nodes (package 02, T1/T2)", () => {
     const content = ["- [ ] Not done", "- [x] Done", ""].join("\n")
     const view = qa.view(content)
     expect(view.nodes[0]?.block?.items).toEqual([
-      { text: "Not done", checked: false, inline: [{ kind: "text", value: "Not done" }] },
-      { text: "Done", checked: true, inline: [{ kind: "text", value: "Done" }] },
+      { text: "Not done", checked: false, inline: [{ kind: "text", value: "Not done" }], line: 0 },
+      { text: "Done", checked: true, inline: [{ kind: "text", value: "Done" }], line: 1 },
     ])
   })
 

package/src/steering/qa.ts

@@ -822,7 +822,7 @@ const replaceOptionTextEdit = (
  * Collapses a typed answer to the single-line shape a list-item label must
  * be. A raw textarea value's interior newlines would break `.gtd/`'s oxfmt
  * fixed point the moment they are spliced onto a `- [x] ` line, and every
- * steering file — server-written ones included — is covered by `format:check`.
+ * steering file — server-written ones included — is covered by the `check` task.
  */
 /**
  * Empty normalizes to `FREE_TEXT_PLACEHOLDER`, never `""`: an empty label

package/src/steering/review.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { FOOTNOTE_ACTION_TITLE, steeringFormatFor, viewOf } from "./internal.js"
+import { applySteeringEdits, FOOTNOTE_ACTION_TITLE, steeringFormatFor, viewOf } from "./internal.js"
 import { parseReviewDoc, unansweredNotes } from "./review.js"
 import { getParseCount } from "./internal.js"
 
@@ -1370,6 +1370,31 @@ describe("review.annotate", () => {
     expect(result.ok).toBe(true)
   })
 
+  it("a paragraph anchor on one item of a chunk's list notes that item alone", () => {
+    const summary = [
+      "# Review: abc1234",
+      "<!-- base: abc1234def5678901234567890123456789abcd -->",
+      "",
+      "## Quality lap",
+      "",
+      "Fixed automatically:",
+      "",
+      "- Rounds wrong (lens correctness)",
+      "- Missing test (lens tests)",
+      "",
+    ].join("\n")
+    const before = review.view(summary).nodes[0]!.body![1]!.block!.items!
+    expect(before.map((item) => item.line)).toEqual([7, 8])
+    const result = review.annotate(summary, { kind: "paragraph", line: 8 }, "reopen it")
+    if (!result.ok) throw new Error(result.reason)
+    const after = applySteeringEdits(summary, result.edits)
+    expect(review.validate(after)).toEqual([])
+    const items = review.view(after).nodes[0]!.body![1]!.block!.items!
+    expect(items[0]).not.toHaveProperty("thread")
+    expect(items[0]).not.toHaveProperty("note")
+    expect(items[1]!.thread?.entries).toEqual([{ author: "me", text: "reopen it" }])
+  })
+
   it("accepts a paragraph anchor in a prose-only document", () => {
     const result = review.annotate(
       "Just some prose.\n",

package/src/step/LandStep.ts

@@ -16,7 +16,7 @@ export type GitWrite =
 /** A landed step's trailing report, rendered by `GitScript.ts` into a `printf` line. */
 export type Outcome =
   | { readonly kind: "transition"; readonly from: StateName; readonly to: StateName }
-  | { readonly kind: "commit"; readonly subject: StateName | string }
+  | { readonly kind: "commit"; readonly subject: string }
   | { readonly kind: "note"; readonly text: string }
 
 /**

package/src/twins/GitTiers.ts

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os"
 import { execFileSync, execSync, spawnSync } from "node:child_process"
 // Imported directly (not just from *.test.ts) — a leak of this module into
 // the shipped CLI bundle would try to inline `vitest` and fail the build
-// loudly (`deps.alwaysBundle` in `tsdown.config.ts`), a guard alongside the
+// loudly (`deps.alwaysBundle` in `vite.config.ts`), a guard alongside the
 // `TEST_DOUBLE_SENTINEL` check.
 import { afterEach, beforeEach, describe, expect, it } from "vitest"
 import { Effect, Exit, Option } from "effect"

package/src/wire/BeatPlain.ts

@@ -32,9 +32,9 @@ const nextStatusLine = (next: BeatDocument["next"]): string =>
 
 /** Builds `{[key]: value}` for each entry whose value isn't `undefined` — the shared "omit absent optional fields" shape the header uses. */
 const definedFields = (
-  entries: readonly (readonly [string, unknown])[],
-): Record<string, unknown> => {
-  const result: Record<string, unknown> = {}
+  entries: readonly (readonly [string, string | undefined])[],
+): Record<string, string> => {
+  const result: Record<string, string> = {}
   for (const [key, value] of entries) if (value !== undefined) result[key] = value
   return result
 }

package/src/wire/Select.ts

@@ -18,7 +18,7 @@ const toSelection = (value: unknown): Selection => {
   if (typeof value === "object") {
     return { kind: "value", text: JSON.stringify(value) }
   }
-  return { kind: "value", text: String(value) }
+  return { kind: "value", text: String(value as string | number | boolean | bigint | undefined) }
 }
 
 /** A segment that resolves to no key at all (missing from an object, out-of-range or non-numeric against an array) — distinct from a present key holding `undefined`. */