@erclx/canon 5.32.0 → 5.34.0

package/src/canvas/arrange.ts

@@ -0,0 +1,66 @@
+import { type Box, FRAME_GAP, type Frame } from '@/canvas/content'
+
+export interface Placement {
+  readonly name: string
+  readonly from: Box
+  readonly to: Box
+}
+
+function boxOf(frame: Frame): Box {
+  return {
+    x: frame.x,
+    y: frame.y,
+    width: frame.width,
+    height: frame.height,
+  }
+}
+
+/**
+ * Boxes whose vertical spans overlap share a row, so a row the operator dragged
+ * stays a row. Reading by overlap rather than by an equal `y` lets a frame a
+ * few pixels off its neighbor still join it.
+ */
+function rowsOf(frames: readonly Frame[]): Frame[][] {
+  const sorted = [...frames].sort((a, b) => a.y - b.y || a.x - b.x)
+  const rows: Frame[][] = []
+  let bottom = Number.NEGATIVE_INFINITY
+  for (const frame of sorted) {
+    const row = rows.at(-1)
+    if (row && frame.y < bottom) {
+      row.push(frame)
+      bottom = Math.max(bottom, frame.y + frame.height)
+    } else {
+      rows.push([frame])
+      bottom = frame.y + frame.height
+    }
+  }
+  return rows.map((row) =>
+    row.sort((a, b) => a.x - b.x || a.name.localeCompare(b.name)),
+  )
+}
+
+/**
+ * Re-lays a page's frames: each row left to right on `FRAME_GAP` from the
+ * page's leftmost edge, rows stacked on their tallest box plus the gap from
+ * the page's top edge. Returns only the frames whose position changes.
+ */
+export function planArrange(frames: readonly Frame[]): Placement[] {
+  if (frames.length === 0) return []
+  const left = Math.min(...frames.map((frame) => frame.x))
+  let top = Math.min(...frames.map((frame) => frame.y))
+
+  const moves: Placement[] = []
+  for (const row of rowsOf(frames)) {
+    let x = left
+    for (const frame of row) {
+      const from = boxOf(frame)
+      const to: Box = { ...from, x, y: top }
+      if (from.x !== to.x || from.y !== to.y) {
+        moves.push({ name: frame.name, from, to })
+      }
+      x += frame.width + FRAME_GAP
+    }
+    top += Math.max(...row.map((frame) => frame.height)) + FRAME_GAP
+  }
+  return moves
+}

package/src/canvas/capture.ts

@@ -157,7 +157,7 @@ export async function captureCanvas(
   })
 }
 
-type ServeRefused = {
+export type ServeRefused = {
   readonly ok: false
   readonly reason: 'no-server' | 'capture-failed'
   readonly detail: string
@@ -168,20 +168,34 @@ async function serveFor<T>(
   deps: CaptureDeps,
   run: (base: string, capture: CaptureEngine) => Promise<T>,
 ): Promise<T | ServeRefused> {
-  const start = deps.start ?? startCanvas
+  return serveCanvas(root, deps.start, async (base) => {
+    const capture =
+      deps.capture ?? (await import('@/capture/render')).captureSources
+    return run(base, capture)
+  })
+}
+
+/**
+ * Runs a call against a canvas served on a free port for its length, so a verb
+ * that renders frames reads the same address the board shows.
+ */
+export async function serveCanvas<T>(
+  root: string,
+  startOverride: CaptureDeps['start'],
+  run: (base: string) => Promise<T>,
+): Promise<T | ServeRefused> {
+  const start = startOverride ?? startCanvas
   const server = start(root, { port: 0, shell: new Response('') })
   if (!server.ok) {
     return {
       ok: false,
       reason: 'no-server',
-      detail: `${server.detail}, so run canon canvas serve and capture again`,
+      detail: `${server.detail}, so run canon canvas serve and try again`,
     }
   }
 
   try {
-    const capture =
-      deps.capture ?? (await import('@/capture/render')).captureSources
-    return await run(server.url, capture)
+    return await run(server.url)
   } catch (error) {
     return {
       ok: false,

package/src/canvas/content.ts

@@ -578,6 +578,45 @@ export function restoreBox(
   })
 }
 
+export type PruneOutcome =
+  | { readonly ok: true; readonly dropped: readonly string[] }
+  | ContentRefused
+
+/**
+ * Lists the layout entries whose frame file is gone, and removes them under
+ * the layout lock unless `write` is false. `readPage` never reports them, so
+ * this is the one place an entry outliving its frame is seen.
+ */
+export function pruneLayout(
+  root: string,
+  page: string,
+  write: boolean,
+): PruneOutcome {
+  if (!isValidName(page)) {
+    return refuse('invalid-name', `${page} is not a valid page name`)
+  }
+  const dir = pagePath(root, page)
+  if (!isDirectory(dir)) return refuse('no-page', `page ${page} does not exist`)
+
+  const prune = (): PruneOutcome => {
+    const { boxes, malformed } = readLayout(dir)
+    if (malformed) {
+      return refuse('malformed-layout', `${page}/${LAYOUT_FILE} does not parse`)
+    }
+    const present = new Set(frameNames(dir))
+    const dropped = [...boxes.keys()].filter((name) => !present.has(name))
+    if (write && dropped.length > 0) {
+      writeLayout(
+        dir,
+        new Map([...boxes].filter(([name]) => present.has(name))),
+      )
+    }
+    return { ok: true, dropped }
+  }
+
+  return write ? withFileLock(join(dir, LAYOUT_FILE), prune) : prune()
+}
+
 export interface Selection {
   readonly page: string
   readonly frame: string

package/src/canvas/fit.ts

@@ -0,0 +1,238 @@
+import {
+  type Box,
+  type ContentRefused,
+  readPage,
+  resizeFrame,
+} from '@/canvas/content'
+import {
+  type CaptureDeps,
+  resolveCaptureTargets,
+  type ServeRefused,
+  serveCanvas,
+} from '@/canvas/capture'
+import { resolveFrameTokens, servedFamilies } from '@/canvas/tokens'
+
+/** What the capture browser read off one frame at its box width. */
+export interface Measured {
+  readonly page: string
+  readonly frame: string
+  readonly box: Box
+  readonly contentHeight: number
+  readonly contentWidth: number
+  /**
+   * The lowest edge of any element in the body moved when the viewport
+   * height changed, so a viewport unit is sizing something and the content
+   * measure is not the height a viewer draws.
+   */
+  readonly viewportBound: boolean
+  /** The first family of the body text, unquoted. */
+  readonly family: string
+}
+
+export interface FitRow {
+  readonly page: string
+  readonly frame: string
+  /** The box height now. */
+  readonly height: number
+  /** The content's height, which is what the box should be. */
+  readonly fitted: number
+  /** The content is wider than the box, which fit reports and never widens. */
+  readonly wide: boolean
+  /** The first family is not one the canvas serves, so the height may not hold. */
+  readonly font: boolean
+  /**
+   * The document height depends on the viewport, as a height in `vh` does, so
+   * the content measure is not the height a viewer draws and nothing is written.
+   */
+  readonly viewport: boolean
+  readonly family: string
+}
+
+/**
+ * Turns measurements into rows. The box width is the frame's declared render
+ * width, so an overflow in it is a finding and never a resize. `served` is the
+ * set of families the served sheet carries a face for.
+ *
+ * A frame whose elements moved with the viewport height is sized by a unit
+ * such as `vh`, so the row keeps its height and reports `viewport`. Scroll
+ * height cannot show it alone, since a single `100vh` section reads as short
+ * content drawn in a taller viewport.
+ */
+export function planFit(
+  measured: readonly Measured[],
+  served: ReadonlySet<string>,
+): FitRow[] {
+  return measured.map((item) => {
+    const content = Math.max(1, Math.ceil(item.contentHeight))
+    const viewport = item.viewportBound
+    return {
+      page: item.page,
+      frame: item.frame,
+      height: item.box.height,
+      fitted: viewport ? item.box.height : content,
+      wide: item.contentWidth > item.box.width,
+      font: !served.has(item.family),
+      viewport,
+      family: item.family,
+    }
+  })
+}
+
+/** Whether a row asks anything of the operator or the session. */
+export function isOwed(row: FitRow): boolean {
+  return row.fitted !== row.height || row.wide || row.font || row.viewport
+}
+
+export type FitOutcome =
+  | {
+      readonly ok: true
+      readonly rows: readonly FitRow[]
+      /** Whether heights were written, which is false under a check. */
+      readonly written: boolean
+    }
+  | ContentRefused
+  | ServeRefused
+
+export interface FitDeps extends Pick<CaptureDeps, 'start'> {
+  /** What a test stands in for, which the command never passes. */
+  readonly measure?: (targets: readonly MeasureTarget[]) => Promise<Measured[]>
+}
+
+export interface MeasureTarget {
+  readonly page: string
+  readonly frame: string
+  readonly url: string
+  readonly box: Box
+}
+
+/**
+ * Loads each frame at its box width through the served address, which is what
+ * injects the tokens and the faces, and reads the document once fonts and the
+ * load event have settled, the moment a capture waits for. The content is read
+ * at a one pixel tall viewport, since a document shorter than the viewport
+ * reports the viewport and a frame could then never shrink. The lowest element
+ * edge is then read at the box height and at twice it, and an edge that moved
+ * is a height set in viewport units.
+ */
+async function measureInBrowser(
+  targets: readonly MeasureTarget[],
+): Promise<Measured[]> {
+  const { chromium } = await import('playwright-core')
+  const browser = await chromium.launch()
+  try {
+    const measured: Measured[] = []
+    for (const target of targets) {
+      const page = await browser.newPage({
+        viewport: { width: target.box.width, height: 1 },
+      })
+      try {
+        await page.goto(target.url, { waitUntil: 'load' })
+        const read = await page.evaluate(async () => {
+          await document.fonts.ready
+          const root = document.documentElement
+          const family = getComputedStyle(document.body).fontFamily
+          return {
+            contentHeight: root.scrollHeight,
+            contentWidth: root.scrollWidth,
+            family,
+          }
+        })
+        const lowestEdge = () =>
+          page.evaluate(() => {
+            let bottom = 0
+            for (const element of document.body.querySelectorAll('*')) {
+              bottom = Math.max(
+                bottom,
+                element.getBoundingClientRect().bottom + window.scrollY,
+              )
+            }
+            return Math.ceil(bottom)
+          })
+        const heights = [target.box.height, target.box.height * 2]
+        const edges: number[] = []
+        for (const height of heights) {
+          await page.setViewportSize({ width: target.box.width, height })
+          edges.push(await lowestEdge())
+        }
+        measured.push({
+          page: target.page,
+          frame: target.frame,
+          box: target.box,
+          contentHeight: read.contentHeight,
+          contentWidth: read.contentWidth,
+          viewportBound: edges[0] !== edges[1],
+          family: firstFamily(read.family),
+        })
+      } finally {
+        await page.close()
+      }
+    }
+    return measured
+  } finally {
+    await browser.close()
+  }
+}
+
+/** The first entry of a computed `font-family` list, without its quotes. */
+export function firstFamily(list: string): string {
+  const first = list.split(',')[0] ?? ''
+  return first.trim().replace(/^["']|["']$/g, '')
+}
+
+/**
+ * Measures the frames `spec` names and, unless `write` is false, sets each
+ * box's height to its content through `resizeFrame`, the writer the operator's
+ * drags share. Serves the canvas for the call, so it needs no running board.
+ */
+export async function fitCanvas(
+  root: string,
+  spec: string,
+  write: boolean,
+  deps: FitDeps = {},
+): Promise<FitOutcome> {
+  const early = resolveCaptureTargets(root, spec, '')
+  if (!early.ok) return early
+
+  const served = await serveCanvas(root, deps.start, async (base) => {
+    const resolved = resolveCaptureTargets(root, spec, base)
+    if (!resolved.ok) return resolved
+    const frames = readPage(root, resolved.targets[0]?.page ?? '')?.frames ?? []
+
+    const targets: MeasureTarget[] = []
+    for (const item of resolved.targets) {
+      const frame = frames.find((candidate) => candidate.name === item.frame)
+      if (!frame) continue
+      targets.push({
+        page: item.page,
+        frame: item.frame,
+        url: item.url,
+        box: {
+          x: frame.x,
+          y: frame.y,
+          width: frame.width,
+          height: frame.height,
+        },
+      })
+    }
+    const measure = deps.measure ?? measureInBrowser
+    return { ok: true as const, targets, measured: await measure(targets) }
+  })
+  if (!served.ok) return served
+
+  const rows = planFit(
+    served.measured,
+    servedFamilies(resolveFrameTokens(root).css),
+  )
+  if (!write) return { ok: true, rows, written: false }
+
+  for (const row of rows.filter((item) => item.fitted !== item.height)) {
+    const target = served.targets.find((item) => item.frame === row.frame)
+    if (!target) continue
+    const outcome = resizeFrame(root, row.page, row.frame, {
+      ...target.box,
+      height: row.fitted,
+    })
+    if (!outcome.ok) return outcome
+  }
+  return { ok: true, rows, written: true }
+}

package/src/canvas/tokens.ts

@@ -10,7 +10,6 @@ import {
 import {
   type DroppedFace,
   inlineProjectFaces,
-  namedFamilies,
   projectSheets,
 } from '@/design/project-fonts'
 import { isOwnCheckout } from '@/roots/project'
@@ -31,7 +30,7 @@ export type FrameTokens =
       /** Project faces left out of the sheet, present only when one was. */
       readonly dropped?: readonly DroppedFace[]
     }
-  | { readonly source: 'none'; readonly css: ''; readonly notice: string }
+  | { readonly source: 'none'; readonly css: string; readonly notice: string }
 
 export interface TokenOptions {
   /** Overrides the checkout test, which reads this package's own name. */
@@ -124,6 +123,21 @@ export function tokenGroups(css: string): TokenGroup[] {
   })
 }
 
+/**
+ * The families a served sheet declares a face for, so a caller reads what the
+ * frames carry from the same sheet the server builds rather than from a list
+ * of its own.
+ */
+export function servedFamilies(css: string): Set<string> {
+  const families = new Set<string>()
+  for (const [, family] of css.matchAll(
+    /@font-face\s*{[^}]*?font-family:\s*["']?([^"';}]+)/g,
+  )) {
+    if (family) families.add(family.trim())
+  }
+  return families
+}
+
 /** The installed files in cascade order: the base first, then each override. */
 function installedFiles(root: string): string[] {
   const base = join(DESIGN_INSTALL_DIR, BASE_FILE)
@@ -134,14 +148,14 @@ function installedFiles(root: string): string[] {
 }
 
 /**
- * The vendored faces the installed sheets name and no project rule already
- * declares, so a target renders the base's families on a machine that never
- * installed them, and a project face of the same family wins outright.
+ * The vendored faces no project rule already declares, so a frame naming
+ * `Geist Variable` renders the same face in the capture and in any browser
+ * whether or not a sheet names it, and a project face of the same family wins
+ * outright.
  */
-function toolkitFaces(css: string, declared: ReadonlySet<string>): FontFace[] {
-  const named = namedFamilies(css)
+function toolkitFaces(declared: ReadonlySet<string>): FontFace[] {
   return [...FONT_FACES, ...HAND_DRAWN_FONT_FACES].filter(
-    (face) => named.has(face.family) && !declared.has(face.family),
+    (face) => !declared.has(face.family),
   )
 }
 
@@ -190,7 +204,7 @@ export function resolveFrameTokens(
   const files = installedFiles(root)
   if (files.length > 0) {
     const { css, dropped, declared } = installedSheets(root, files)
-    const faces = toolkitFaces(css, declared)
+    const faces = toolkitFaces(declared)
     return {
       source: 'installed',
       css: faces.length > 0 ? `${fontFaceBlock(faces)}\n${css}` : css,
@@ -199,5 +213,9 @@ export function resolveFrameTokens(
     }
   }
 
-  return { source: 'none', css: '', notice: NONE_NOTICE }
+  return {
+    source: 'none',
+    css: fontFaceBlock(toolkitFaces(new Set())),
+    notice: NONE_NOTICE,
+  }
 }

package/src/capture/frame-values.ts

@@ -31,15 +31,9 @@ const GLOB_WIDTH = 44
 /** A refusal the script prints as `regen-hero: <message>` and exits 1 on. */
 export class FrameError extends Error {}
 
-export interface StandardRow {
-  readonly name: string
-  readonly appliesTo?: readonly string[]
-}
-
 export interface FrameCatalogs {
   readonly skills: readonly string[]
   readonly gov: GovCatalog
-  readonly standards: readonly StandardRow[]
   readonly toolingStacks: readonly StackSummary[]
   readonly commandCount: number
   readonly tokenCss: string
@@ -63,7 +57,7 @@ const escape = (value: string): string =>
 /**
  * Even spacing across the sorted catalog rather than its first N, so a column
  * whose names share a prefix does not read as a narrower catalog than the one
- * that ships. Rules and standards sample. Skills do not, because the even step
+ * that ships. Rules sample. Skills do not, because the even step
  * lands on the entries closest to commodity and on none of the workflow the
  * toolkit exists to carry.
  */
@@ -186,7 +180,7 @@ function faviconUri(markSvg: string, tokenCss: string): string {
  * rather than shipping a frame claiming the domain has nothing in it.
  */
 export function buildFrameValues(catalogs: FrameCatalogs): FrameValues {
-  const { gov, toolingStacks, standards, skills } = catalogs
+  const { gov, toolingStacks, skills } = catalogs
   const markSvg = catalogs.markSvg.trim()
   if (!markSvg) {
     throw new FrameError(
@@ -207,12 +201,10 @@ export function buildFrameValues(catalogs: FrameCatalogs): FrameValues {
   const stacked = new Set(gov.stacks.flatMap((stack) => stack.rules))
   const deliveredEntries = gov.rules.filter((entry) => stacked.has(entry.name))
   const deliveredRules = deliveredEntries.map((entry) => slug(entry.name))
-  const standardNames = standards.map((entry) => entry.name)
 
   for (const [label, list] of [
     ['skills', skills],
     ['rules', rules],
-    ['standards', standardNames],
     ['tooling stacks', toolingStacks],
     ['gov stacks', gov.stacks],
     ['stack-delivered rules', deliveredRules],
@@ -251,23 +243,6 @@ export function buildFrameValues(catalogs: FrameCatalogs): FrameValues {
     })
     .join('\n')
 
-  // A standard either governs an artifact by path or is opened by name when a
-  // session decides it needs it. Naming the second is the contrast, since
-  // nothing else tells a reader the corpus installs into no project.
-  const standardRows = sample(standards)
-    .map((entry) => {
-      const applies = entry.appliesTo ?? []
-      const governs =
-        applies.length > 0
-          ? clip(applies.join(' '), GLOB_WIDTH)
-          : 'read by name'
-      return frameRow(
-        `<span class="name">${escape(pad(entry.name, 18))}</span>` +
-          `<span class="muted">${escape(governs)}</span>`,
-      )
-    })
-    .join('\n')
-
   // A tooling stack is counted rather than listed, because what it lays down is
   // dev dependencies, run scripts, and ignore groups rather than named entries.
   // The inheritance is the part worth showing, since it is why a stack carrying
@@ -286,7 +261,6 @@ export function buildFrameValues(catalogs: FrameCatalogs): FrameValues {
   for (const [label, rows] of [
     ['governance stack rows', govStackRows],
     ['governance rule rows', govRuleRows],
-    ['standard rows', standardRows],
     ['tooling stack rows', toolingStackRows],
   ] as const) {
     if (rows === '') {
@@ -300,11 +274,9 @@ export function buildFrameValues(catalogs: FrameCatalogs): FrameValues {
     TOKENS: tokenCss,
     GOV_STACK_ROWS: govStackRows,
     GOV_RULE_ROWS: govRuleRows,
-    STANDARD_ROWS: standardRows,
     TOOLING_STACK_ROWS: toolingStackRows,
     SKILL_COUNT: String(skills.length),
     RULE_COUNT: String(rules.length),
-    STANDARD_COUNT: String(standardNames.length),
     GOV_STACK_COUNT: String(gov.stacks.length),
     TOOLING_STACK_COUNT: String(toolingStacks.length),
     COMMAND_COUNT: String(catalogs.commandCount),
@@ -312,10 +284,8 @@ export function buildFrameValues(catalogs: FrameCatalogs): FrameValues {
     FAVICON: faviconUri(markSvg, tokenCss),
     SKILL_ENTRIES: markup(featured(skills, FEATURED_SKILLS)),
     RULE_ENTRIES: markup(sample(deliveredRules)),
-    STANDARD_ENTRIES: markup(sample(standardNames)),
     SKILL_MORE: remaining(skills),
     RULE_MORE: remaining(rules),
-    STANDARD_MORE: remaining(standardNames),
   }
 
   const light = lightTokens(tokenCss)

package/src/claude/cases/misc.ts

@@ -25,7 +25,7 @@ export const MISC_CASES: readonly SkillCase[] = [
   {
     prompt:
       'Draw the signup screen as a frame on the canvas, then restyle the element I just selected there.',
-    expect: 'canvas',
+    expect: 'canvas-board',
   },
   {
     prompt:

package/src/claude/cases/setup.ts

@@ -40,6 +40,10 @@ export const SETUP_CASES: readonly SkillCase[] = [
       "Before I run this sync, tell me exactly what it's going to overwrite.",
     expect: 'canon-cli',
   },
+  {
+    prompt: 'Which canon command tells me if my markdown breaks the rules?',
+    expect: 'canon-cli',
+  },
   {
     prompt:
       'Something about the toolkit itself is broken, write it up and send it back to the maintainers.',

package/src/claude/cases/workflow.ts

@@ -31,7 +31,7 @@ export const WORKFLOW_CASES: readonly SkillCase[] = [
   },
   {
     prompt:
-      'Fold what we decided this session into the context entries and mark off what shipped on the task board.',
+      'Fold what we decided this session into the context entries before this branch goes out.',
     expect: 'context-fold',
   },
   {
@@ -127,6 +127,11 @@ export const WORKFLOW_CASES: readonly SkillCase[] = [
     prompt: 'Open a new entry on the task board for this piece of work.',
     expect: 'task-board',
   },
+  {
+    prompt:
+      'This branch finished the pagination work, so tick off whichever board outcomes it actually delivered.',
+    expect: 'task-complete',
+  },
   {
     prompt: 'Open a learning workspace so I can study this topic properly.',
     expect: 'teach-workspace',

package/src/claude/seeds.ts

@@ -17,7 +17,7 @@ const HOOKS = 'hooks'
  * stem in an older layout, which is what `@/sync/layout` pairs a target against
  * to find a superseded artifact.
  */
-export const SUBDIRS: readonly string[] = [HOOKS, 'context', 'memory', 'tasks']
+export const SUBDIRS: readonly string[] = [HOOKS, 'context', 'tasks']
 
 export type SeedScope = 'claude' | 'root'
 

package/src/claude/skills-audit.ts

@@ -7,7 +7,7 @@ import { bodyLines, maskDisplayed } from '@/markdown/scan'
 /** Returned when a skill folder carries no `REQUIREMENT.md`, the gating check. */
 export const EXIT_MISSING_REQUIREMENT = 2
 
-/** The description ceiling stated in the frontmatter rules of `standards/skill.md`. */
+/** The description ceiling stated in the frontmatter rules of `claude/skills/create-skill/references/skill.md`. */
 export const DESCRIPTION_LIMIT = 1024
 
 /** The two headings the requirement template declares, matched at any level. */
@@ -160,7 +160,7 @@ interface SkillText {
 }
 
 /**
- * Measures both skill corpora against the rules `standards/skill.md` states
+ * Measures both skill corpora against the rules `claude/skills/create-skill/references/skill.md` states
  * mechanically. A corpus the project does not carry is skipped rather than
  * reported, so a target holding only `.claude/skills/` reads as in scope.
  *

package/src/cli/help.ts

@@ -10,6 +10,8 @@ type HelpStream = { isTTY?: boolean }
 
 // The grouping mirrors the README's domain table and has no other source, so a
 // command added to the program needs a row here or help-option.test.ts fails.
+// A row here also needs a `canon <verb>` line in claude/skills/canon-cli, or a
+// name in TOOLKIT_ONLY in canon-cli-skill.test.ts, which reads this list.
 export const COMMAND_GROUPS: { title: string; rows: CommandRow[] }[] = [
   {
     title: 'Project',
@@ -25,7 +27,7 @@ export const COMMAND_GROUPS: { title: string; rows: CommandRow[] }[] = [
     title: 'Domains',
     rows: [
       ['gov [cmd]', 'Governance rules (install, sync, list)'],
-      ['standards [cmd]', 'Standards (install, sync, list, <name>)'],
+      ['standards [cmd]', 'Standards (list, <name>)'],
       ['tooling [cmd]', 'Tooling stacks (sync, ref, create)'],
       ['claude [cmd]', 'Claude workflow (init, sync, setup)'],
       ['wiki [cmd]', 'Wiki pages (init)'],

package/src/cli/ui.ts

@@ -154,9 +154,8 @@ export function isNonInteractive(): boolean {
 }
 
 /**
- * `nonInteractiveDefault` opts a prompt into the `select_option` behavior from
- * `scripts/lib/ui.sh`, where `CANON_NON_INTERACTIVE=1` resolves to the first
- * option instead of failing. Callers that would rather fail loudly than pick
+ * `nonInteractiveDefault` opts a prompt into resolving to its first option
+ * under `CANON_NON_INTERACTIVE=1` instead of failing. Callers that would rather fail loudly than pick
  * for the user leave it off.
  */
 export async function select<Value>(opts: {