@pmelab/gtd 58.2.0 → 59.0.1

package/src/workflows/rollout/rollout.test.ts

@@ -1,263 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { CONFIG_SCAFFOLD } from "../../install/index.js"
-import { runsItsScript, testRepo } from "../../testkit/index.js"
-
-const CONFIG = `${CONFIG_SCAFFOLD}export { rollout } from "@pmelab/gtd/workflows"\n`
-
-const REGISTRY = `export const FLAGS = [
-  { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
-  { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
-  { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
-  { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
-] as const
-`
-
-const FLIPPED = REGISTRY.replace(
-  '{ name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" }',
-  '{ name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true }',
-)
-
-const repoWith = () =>
-  testRepo({ workflow: CONFIG, files: { "src/flags/index.ts": REGISTRY, "src/a.ts": "a\n" } })
-
-describe("the rollout workflow", () => {
-  it("lands a flip, checks the suite and ends with no review", async () => {
-    const repo = repoWith()
-    await repo.start("rollout", "--var", "flag=alpha")
-    const rest = await repo.drive({
-      "rollout.flipping": (beat, r) => {
-        expect(beat.content).toContain("alpha")
-        r.write("src/flags/index.ts", FLIPPED)
-      },
-      "rollout.suite.check": () => undefined,
-      "rollout.mentions": runsItsScript,
-    })
-    expect(rest.state).toBe("idle")
-    expect(repo.subjects().slice(-2)).toEqual([
-      "gtd(check): rollout.suite.check → rollout.mentions",
-      "gtd(check): rollout.mentions → idle",
-    ])
-  })
-
-  it("lands a flip when the tree was already dirty at the start", async () => {
-    const repo = repoWith()
-    repo.write("src/other.ts", "dirty\n")
-    await repo.start("rollout", "--var", "flag=alpha")
-    const rest = await repo.drive({
-      "rollout.flipping": (_, r) => r.write("src/flags/index.ts", FLIPPED),
-      "rollout.suite.check": () => undefined,
-      "rollout.mentions": runsItsScript,
-    })
-    expect(rest.state).toBe("idle")
-  })
-
-  it("refuses a turn that also changes a source file, naming it", async () => {
-    const repo = repoWith()
-    await repo.start("rollout", "--var", "flag=alpha")
-    await expect(
-      repo.drive({
-        "rollout.flipping": (_, r) => {
-          r.write("src/flags/index.ts", FLIPPED)
-          r.write("src/a.ts", "changed\n")
-        },
-      }),
-    ).rejects.toThrow(/rollout-only: src\/a\.ts changed/)
-  })
-
-  it("refuses an edit to a second entry", async () => {
-    const repo = repoWith()
-    await repo.start("rollout", "--var", "flag=alpha")
-    await expect(
-      repo.drive({
-        "rollout.flipping": (_, r) =>
-          r.write("src/flags/index.ts", FLIPPED.replace('owner: "b"', 'owner: "z"')),
-      }),
-    ).rejects.toThrow("rollout-only: other edits in src/flags/index.ts")
-  })
-
-  it("refuses a turn that writes defaultOn: false, naming the fault", async () => {
-    const repo = repoWith()
-    await repo.start("rollout", "--var", "flag=alpha")
-    await expect(
-      repo.drive({
-        "rollout.flipping": (_, r) =>
-          r.write("src/flags/index.ts", FLIPPED.replace("defaultOn: true }", "defaultOn: false }")),
-      }),
-    ).rejects.toThrow('"alpha" is not set to defaultOn: true')
-  })
-
-  it("refuses a turn that also writes under .gtd/", async () => {
-    const repo = repoWith()
-    await repo.start("rollout", "--var", "flag=alpha")
-    await expect(
-      repo.drive({
-        "rollout.flipping": (_, r) => {
-          r.write("src/flags/index.ts", FLIPPED)
-          r.write(".gtd/NOTES.md", "planted\n")
-        },
-      }),
-    ).rejects.toThrow(/rollout-only: \.gtd\/NOTES\.md changed/)
-  })
-
-  it.each([
-    [[], "gtd: rollout needs --var flag=<name>"],
-    [["--var", "flag=nope"], 'gtd: rollout: no flag "nope" in src/flags/index.ts'],
-    [["--var", "flag=ops1"], 'gtd: rollout: flag "ops1" is ops, not release'],
-    [["--var", "flag=live"], 'gtd: rollout: flag "live" is already default-on'],
-  ])("refuses %j at start", async (args, message) => {
-    await expect(repoWith().start("rollout", ...args)).rejects.toThrow(message)
-  })
-
-  it("rests at rollout.suite.blocked on a red suite, with no fix turn", async () => {
-    const repo = repoWith()
-    await repo.start("rollout", "--var", "flag=alpha")
-    const rest = await repo.drive({
-      "rollout.flipping": (_, r) => r.write("src/flags/index.ts", FLIPPED),
-      "rollout.suite.check": (_, r) => r.write(".gtd/FEEDBACK.md", "1 failing\n"),
-      "rollout.suite.recheck": (_, r) => r.write(".gtd/FEEDBACK.md", "still 1 failing\n"),
-    })
-    expect(rest).toMatchObject({ state: "rollout.suite.blocked", actor: "human" })
-  })
-
-  describe("the human's fix at rollout.suite.blocked", () => {
-    const blocked = async () => {
-      const repo = repoWith()
-      await repo.start("rollout", "--var", "flag=alpha")
-      await repo.drive({
-        "rollout.flipping": (_, r) => r.write("src/flags/index.ts", FLIPPED),
-        "rollout.suite.check": (_, r) => r.write(".gtd/FEEDBACK.md", "1 failing\n"),
-        "rollout.suite.recheck": (_, r) => r.write(".gtd/FEEDBACK.md", "still 1 failing\n"),
-      })
-      return repo
-    }
-
-    it("refuses a fix that edits a source file, naming it", async () => {
-      const repo = await blocked()
-      await expect(
-        repo.drive({ "rollout.suite.blocked": (_, r) => r.write("src/a.ts", "fixed\n") }),
-      ).rejects.toThrow(/rollout-only: src\/a\.ts changed/)
-    })
-
-    it("refuses a fix that edits a second registry entry", async () => {
-      const repo = await blocked()
-      await expect(
-        repo.drive({
-          "rollout.suite.blocked": (_, r) =>
-            r.write("src/flags/index.ts", FLIPPED.replace('owner: "b"', 'owner: "z"')),
-        }),
-      ).rejects.toThrow("rollout-only: other edits in src/flags/index.ts")
-    })
-
-    it("refuses a fix that rewrites the flipped entry back to defaultOn: false", async () => {
-      const repo = await blocked()
-      await expect(
-        repo.drive({ "rollout.suite.blocked": (_, r) => r.write("src/flags/index.ts", REGISTRY) }),
-      ).rejects.toThrow('"alpha" is not set to defaultOn: true')
-    })
-
-    it("lands a fix that re-wraps the flag's entry and ends with no review", async () => {
-      const repo = await blocked()
-      const rest = await repo.drive({
-        "rollout.suite.blocked": (_, r) =>
-          r.write(
-            "src/flags/index.ts",
-            FLIPPED.replace(
-              '{ name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true }',
-              '{\n    name: "alpha",\n    owner: "a",\n    expiry: "2027-01-01",\n    kind: "release",\n    defaultOn: true,\n  }',
-            ),
-          ),
-        "rollout.suite.check": () => undefined,
-        "rollout.mentions": runsItsScript,
-      })
-      expect(rest.state).toBe("idle")
-    })
-  })
-})
-
-describe("rollout.mentions", () => {
-  const flip = {
-    "rollout.flipping": (_: unknown, r: { write: (p: string, c: string) => void }) =>
-      r.write("src/flags/index.ts", FLIPPED),
-  }
-  const finish = async (
-    files: Record<string, string>,
-    mentions: typeof runsItsScript = runsItsScript,
-  ) => {
-    const repo = testRepo({
-      workflow: CONFIG,
-      files: { "src/flags/index.ts": REGISTRY, "src/a.ts": "a\n", ...files },
-    })
-    await repo.start("rollout", "--var", "flag=alpha")
-    const rest = await repo.drive({
-      ...flip,
-      "rollout.suite.check": () => undefined,
-      "rollout.mentions": mentions,
-    })
-    expect(rest.state).toBe("idle")
-    const marks = (repo.messages().at(-1) ?? "")
-      .split("\n")
-      .filter((l) => l.startsWith("Gtd-Mark: "))
-      .map((l) => l.slice("Gtd-Mark: ".length))
-    return { repo, marks }
-  }
-
-  it("lists mentions outside the registry and under no .gtd/ path", async () => {
-    const { marks } = await finish({
-      "README.md": "intro\non under GTD_FLAG_ALPHA=1\n",
-      "src/help.ts": 'export const h = "alpha help"\n',
-      ".gtd/NOTES.md": "alpha\n",
-    })
-    expect(marks).toEqual([
-      "flag-mentions=2",
-      "flag-mention=README.md:2",
-      "flag-mention=src/help.ts:1",
-    ])
-  })
-
-  it("the mentions script removes a feedback file present at the step; marks list the tree", async () => {
-    const { repo, marks } = await finish({ "README.md": "alpha\n" }, (beat, r) => {
-      r.write(".gtd/FEEDBACK.md", "alpha\n")
-      runsItsScript(beat, r)
-    })
-    expect(repo.read(".gtd/FEEDBACK.md")).toBeUndefined()
-    expect(marks).toEqual(["flag-mentions=1", "flag-mention=README.md:1"])
-  })
-
-  it("refuses a stray file written by the mentions script", async () => {
-    await expect(
-      finish({}, (beat, r) => {
-        runsItsScript(beat, r)
-        r.write("src/stray.ts", "x\n")
-      }),
-    ).rejects.toThrow("gtd land: rollout-only: src/stray.ts changed")
-  })
-
-  it("refuses a registry edit beyond the flip made by the mentions script", async () => {
-    await expect(
-      finish({}, (beat, r) => {
-        runsItsScript(beat, r)
-        r.write("src/flags/index.ts", FLIPPED.replace('owner: "b"', 'owner: "z"'))
-      }),
-    ).rejects.toThrow("rollout-only: other edits in src/flags/index.ts")
-  })
-
-  it("marks 0 when nothing names the flag", async () => {
-    const { marks } = await finish({})
-    expect(marks).toEqual(["flag-mentions=0"])
-  })
-
-  it("marks the total for 60 mentions but only the first 50 lines", async () => {
-    const text = Array.from({ length: 60 }, (_, i) => `alpha ${i}`).join("\n")
-    const { marks } = await finish({ "docs/many.md": `${text}\n` })
-    expect(marks[0]).toBe("flag-mentions=60")
-    expect(marks.filter((m) => m.startsWith("flag-mention="))).toHaveLength(50)
-  })
-
-  it("counts a path the mark grammar rejects without marking it, and never throws", async () => {
-    const { marks } = await finish({
-      "docs/bad\u0001name.md": "alpha\n",
-      "README.md": "alpha\n",
-    })
-    expect(marks).toEqual(["flag-mentions=2", "flag-mention=README.md:1"])
-  })
-})

package/src/workflows/rollout/rollout.ts

@@ -1,82 +0,0 @@
-import {
-  agent,
-  changesSince,
-  glob,
-  head,
-  mark,
-  read,
-  refuse,
-  removeScript,
-  run,
-  scope,
-  vars,
-} from "../../flows/index.js"
-import { gate } from "../shared/health.js"
-import { flagShipped } from "../shared/options.js"
-import { flagMentions, flipProblems, requireFlag } from "../shared/registry.js"
-import { coder, FEEDBACK } from "../shared/steps.js"
-
-const flippingPrompt = (name: string, registry: string): string =>
-  `Roll out the release flag "${name}": in ${registry}, set \`defaultOn: true\` on its entry. Change nothing else — no other entry, no other field, no other file, no comments.`
-
-const suiteBlockedMessage = (): string =>
-  "The suite is red after the rollout. Fix it by hand — a rollout may only touch the flag's registry entry — then land."
-
-// Marks past this many are dropped; the summary points at grep for the rest.
-const MARKED_MENTIONS = 50
-
-// Lists, never edits: the human fixes the now-stale prose, or cleanup does. The
-// list rides in marks only: a state file left at idle would be published by
-// ship and read as a failed unwind by the next process.
-const listMentions = async (registry: string, name: string, guard: () => void): Promise<void> => {
-  await run("mentions", removeScript([FEEDBACK]), { label: "Listing flag mentions" })
-  guard()
-  const files = glob("**")
-    .filter((path) => path !== registry && path !== ".gtd" && !path.startsWith(".gtd/"))
-    .sort()
-    .map((path) => ({ path, text: read(path) ?? "" }))
-  const mentions = flagMentions(files, name)
-  mark("flag-mentions", String(mentions.length))
-  for (const m of mentions.slice(0, MARKED_MENTIONS)) {
-    // A path the mark grammar rejects stays counted above, just unlisted here.
-    try {
-      mark("flag-mention", `${m.path}:${m.line}`)
-    } catch {
-      continue
-    }
-  }
-}
-
-// No review gate — a one-field change needs no review lap.
-export const rolloutFlow = async (): Promise<void> => {
-  const registry = vars.flagRegistry ?? ""
-  const name = vars.flag ?? ""
-  // Before the turn, never after: replay re-runs every pre-turn check.
-  requireFlag("rollout", registry, name, false)
-  // Strays count from the same point `before` is read at, not `start()`: the opening commit sweeps in whatever the human left uncommitted.
-  const base = head()
-  const before = read(registry) ?? ""
-  const guard = (): void => {
-    const strays = changesSince(base).paths.filter((path) => path !== registry && path !== FEEDBACK)
-    if (strays.length > 0) {
-      refuse(
-        `gtd land: rollout-only: ${strays.join(", ")} changed — rollout may only set defaultOn: true on "${name}" in ${registry}`,
-      )
-    }
-    const problems = flipProblems(before, read(registry) ?? "", name)
-    if (problems.length > 0) {
-      refuse(`gtd land: rollout-only: other edits in ${registry}: ${problems.join("; ")}`)
-    }
-  }
-  await scope("rollout", async () => {
-    await agent("flipping", flippingPrompt(name, registry), {
-      label: `Rolling out ${name}`,
-      model: coder(),
-    })
-    guard()
-    await gate("suite", suiteBlockedMessage(), guard)
-    await listMentions(registry, name, guard)
-  })
-}
-
-export const rollout = flagShipped(rolloutFlow, "rollout")

package/src/workflows/shared/__fixtures__/feature-collecting-prompt.txt

@@ -1,98 +0,0 @@
-- A deliverable, not a chat reply — size follows the work; cut padding
-- Lead with the answer; never circle back to restate it
-- Flat, commanding sentences — commit to the claim, never hedge
-- Everyday words; define an unavoidable term in five words or fewer, on
-  first use
-- Bold carries the load: bold the claim, not the sentence around it —
-  the bold text alone must yield the full point and every risk
-- **Never trim a risk, a number, a threshold, or a scoped condition to
-  save space — this outranks every other rule here**
-- Ship the artifact bare — no lead-in, no sign-off
-- Compressing is not dropping: three load-bearing parts ship as three,
-  each shorter, never as two
-- One idea per block; break when the idea shifts
-- Flag risk in one blunt line, never hedged prose; never narrate — do it
-
-- Machine-read: its format contract outranks every style rule above —
-  keep every `##`/`###` heading, checkbox row, and marker line exactly
-  as specified. Never renumber or rename a heading; a parser reads
-  these literally and a violation refuses the turn
-- Voice rules above govern only the prose between these elements
-
-You are judging and classifying a round of review feedback.
-
-- You are an autonomous coding agent
-- This workflow's own state files are its private scratchpad, never
-  project code or documentation
-- A footnote (`[^name]` plus its `[^name]:` definition) is a comment on
-  its exact anchor — fold it in as a mandatory concern described
-  against that anchor's hunk or paragraph, never flattened into a
-  whole-file remark
-- A one-shot footnote needs no reply: fold it in and DELETE it in this
-  same turn — marker and definition together. Never re-read a footnote
-  already acted on. A one-shot footnote that asks a question becomes a
-  thread instead: rewrite its definition as `- H: <its body>` then
-  `- A: <your reply>`, keeping the marker
-- A thread is a definition whose body is a list of `- H:`/`- A:`
-  entries. Handle each by its last entry:
-  - last is `- H:` and asks something — reply with exactly one
-    `- A: <reply>` entry and change nothing else for it
-  - last concludes or advises — fold it in like a one-shot footnote,
-    then delete marker and definition
-  - last is `- A:` — it waits on the human; leave it alone
-- Never start a thread yourself, and never leave a thread whose last
-  entry is `- H:` — a turn that does is refused
-- This turn writes `.gtd/REQUIREMENTS.md` (the folded concerns) and
-  replies inside `.gtd/REVIEW.md` (thread replies only; the file stays
-  in the tree) — you classify, you do not build
-- Fold every concluded thread and hand-edit — and each `edit` note
-  the capture lists, no other note — into `.gtd/REQUIREMENTS.md` and
-  delete the folded threads from `.gtd/REVIEW.md`; append one `- A:`
-  reply to each thread whose last entry is a `- H:` question
-- Never fold a note's ticked answer box the capture does not list: gtd
-  routes those itself
-- When the capture names an answering commit, carry each answered
-  question into `.gtd/REQUIREMENTS.md`'s `## Answered Questions` as
-  `### <the note>` plus its answer — the lap replaces `.gtd/REVIEW.md`
-- Keep capture order, and carry each note's `(tier: reason)`
-  label into the concern folded from it
-- Nit notes were already fixed: never re-raise a fixed nit as a concern
-- Finish by running `gtd check review .gtd/REVIEW.md` and fix
-  what it reports
-
-The raw review material is:
-
-capture-text
-It names a commit. Work from what you already reviewed if you
-wrote today's review earlier this conversation; otherwise read
-that commit's diff yourself first.
-
-The round is actionable if any of these hold:
-
-- The human left a note on `.gtd/REVIEW.md`. A note is a mandatory
-  concern below
-- The human added a code comment this round. A comment run whose
-  first line starts `H:` is a THREAD: when its last entry is an
-  `H:` question, write exactly one `A:` comment line, same token
-  and indentation, directly below it — no fold-in; a concluded
-  thread is folded into the requirements and its comment lines
-  deleted. Any other comment, even a plain-prose one, is a one-shot
-  concern — describe it, and note the comment line itself is
-  transient: it must not survive the lap that satisfies it
-- The human hand-edited non-comment code this round — no longer
-  a committed intent to build on, but a sketch like the entry
-  commit's own diff. Describe what it was reaching for; expect
-  the next lap to re-derive it from scratch, never call it final
-
-Not actionable only when none of the above holds — nothing but an
-approving remark, no code edit, no substantive note. Never invent
-actionability, and never dismiss a real note or edit as approval.
-
-- If actionable: write `.gtd/REQUIREMENTS.md` with an ordered
-  list of concerns, each PRODUCT or TECHNICAL — the shape
-  `design.triage` builds, one `## <heading>` per concern in
-  build order. Fold every note, comment, and hand-edit in under
-  its concern. Raise no open questions here — `design.triage`
-  owns that later. Then finish
-- If not: finish without writing anything — changing nothing is
-  the sign-off

package/src/workflows/shared/access.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { access } from "./access.js"
-import * as workflow from "../index.js"
-
-const { defaults } = workflow
-
-const bundled = access(defaults)
-
-describe("the bundled workflow's access export", () => {
-  it("restricts writes on planning, review and lens scopes only", () => {
-    expect(bundled).toEqual({
-      design: { write: [] },
-      "build.review": { write: [".gtd/REVIEW.md"] },
-      "build.review.fix.nits": {},
-      "build.review.fix.risks": {},
-      "build.quality.correctness": { write: [] },
-      "build.quality.owasp-security": { write: [] },
-      "build.quality.ponytail-review": { write: [] },
-      "build.quality.test-audit": { write: [] },
-      "build.quality.conventions": { write: [] },
-      "build.quality.spec-challenge": { write: [] },
-      "build.quality.criteria-coverage": { write: [] },
-      "refactor.build.review": { write: [".gtd/REVIEW.md"] },
-      "refactor.build.quality.correctness": { write: [] },
-      "refactor.build.quality.ponytail-review": { write: [] },
-      "refactor.build.quality.conventions": { write: [] },
-    })
-  })
-
-  it("leaves the refactor review's fix scopes to the refactor's own scope option", () => {
-    expect(bundled).not.toHaveProperty(["refactor.build.review.fix.nits"])
-    expect(bundled).not.toHaveProperty(["refactor.build.review.fix.risks"])
-    expect(bundled["refactor.build.review"]).toEqual({ write: [".gtd/REVIEW.md"] })
-  })
-
-  it("keys one lens scope per qualityReviews entry", () => {
-    const custom = access({ ...defaults, qualityReviews: " my-lens ,, correctness" })
-    expect(
-      Object.keys(custom)
-        .filter((k) => k.startsWith("build.quality."))
-        .sort(),
-    ).toEqual(["build.quality.correctness", "build.quality.my-lens"])
-  })
-
-  it("keys one refactor lens scope per refactorQualityReviews entry beside the refactor review's own", () => {
-    const custom = access({ ...defaults, refactorQualityReviews: " my-lens ,, correctness" })
-    expect(
-      Object.keys(custom)
-        .filter((k) => k.startsWith("refactor."))
-        .sort(),
-    ).toEqual([
-      "refactor.build.quality.correctness",
-      "refactor.build.quality.my-lens",
-      "refactor.build.review",
-    ])
-  })
-
-  it("keys only turn scopes", () => {
-    const known = Object.keys(workflow.skills(defaults))
-    for (const key of Object.keys(bundled)) expect(known).toContain(key)
-  })
-})

package/src/workflows/shared/access.ts

@@ -1,24 +0,0 @@
-import type { ScopeAccess } from "../../flows/index.js"
-import { lensesOf, lensScopes } from "../../workflow-kit/index.js"
-
-// The bundled workflow's default file access, keyed by scope full name — the
-// name a `config.access` entry addresses. Only planning and review scopes
-// are restricted, and only on writes; no scope restricts reads. `refactor`'s
-// write restriction lives in its own `scope()` option, not here. A step's own
-// steering file is folded in per step, so it is not listed here. Build and fix
-// scopes carry no entry: no project layout is assumed. `refactor.build.review`'s
-// fix scopes carry none either: `reviewedRefactor` sets their write limit at run time.
-export const access = (
-  vars: Readonly<Record<string, string>>,
-): Readonly<Record<string, ScopeAccess>> => ({
-  design: { write: [] },
-  "build.review": { write: [".gtd/REVIEW.md"] },
-  // `{}` reopens what `build.review` restricted: the fixes edit code.
-  "build.review.fix.nits": {},
-  "build.review.fix.risks": {},
-  "refactor.build.review": { write: [".gtd/REVIEW.md"] },
-  ...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), () => ({ write: [] })),
-  ...lensScopes("refactor.build.quality", lensesOf(vars.refactorQualityReviews ?? ""), () => ({
-    write: [],
-  })),
-})

package/src/workflows/shared/config.fixture.ts

@@ -1,12 +0,0 @@
-/** A `.gtd/REVIEW.md` on the fixture calculator, one hunk per note. */
-export const reviewDoc = (...notes: string[]): string =>
-  [
-    "# Review: abc1234",
-    "",
-    "<!-- base: 0000000 -->",
-    "",
-    "## calc",
-    "",
-    ...notes.flatMap((note, i) => [`- [ ] ./src/calc.ts#${i + 1}-${i + 1}`, `  ${note}`]),
-    "",
-  ].join("\n")

package/src/workflows/shared/fences.ts

@@ -1,24 +0,0 @@
-// An unclosed fence runs to end of file. A backtick
-// opener with a backtick in its info string still counts as a fence: deviates from CommonMark,
-// worst case is `high`.
-export const markFenced = (text: string): readonly { line: string; fenced: boolean }[] => {
-  let fence: string | undefined // the opener run, e.g. "````"
-  return text.split(/\r?\n/).map((line) => {
-    const run = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1]
-    const fenced = fence !== undefined || run !== undefined
-    if (fence === undefined) fence = run
-    else if (
-      run !== undefined &&
-      run[0] === fence[0] &&
-      run.length >= fence.length &&
-      /^ {0,3}(`+|~+)[ \t]*$/.test(line)
-    )
-      fence = undefined
-    return { line, fenced }
-  })
-}
-
-/** A markdown heading: its `#` run, then its text. */
-export const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/
-/** A list item, its checkbox dropped: its text. */
-export const ITEM = /^ ?(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/