pi-code 1.0.5 → 1.0.6

package/extensions/internal/command-file.ts

@@ -16,6 +16,9 @@ import { parseFrontmatter } from '@earendil-works/pi-coding-agent'
 
 import { splitSegments } from './shell-split.js'
 
+/** The pi file tools a Claude path rule can govern. */
+export type PathRuleTool = 'read' | 'edit' | 'write'
+
 export interface ParsedCommand {
   description: string
   argumentHint?: string
@@ -23,7 +26,7 @@ export interface ParsedCommand {
   /** Claude `Bash(...)` specifiers, present only when every bash grant is scoped. */
   bashRules?: string[]
   /** Claude path rules per pi file tool, from Read(...)/Edit(...)/Write(...) grants. */
-  pathRules?: Partial<Record<'read' | 'edit' | 'write', string[]>>
+  pathRules?: Partial<Record<PathRuleTool, string[]>>
   /** Names from the `arguments:` frontmatter list, mapped to positions in order. */
   argumentNames?: string[]
   /** Tools removed from the pool while the command's turn runs. */
@@ -66,6 +69,10 @@ const CLAUDE_TOOL_MAP: Record<string, string> = {
   task: 'subagent',
   askuserquestion: 'question',
   exitplanmode: 'plan_mode_complete',
+  // Claude's name for the tool this package registers so the model can run user slash
+  // commands; without it `allowed-tools: SlashCommand` matched nothing and the grant
+  // could neither keep nor drop the tool.
+  slashcommand: 'slash_command',
 }
 
 /**
@@ -118,18 +125,78 @@ export interface ToolGrants {
   /** Claude path rules per pi file tool, absent for a tool with an unscoped grant.
    * Edit scopes govern writes too, as Claude documents; Write scopes are honored
    * rather than Claude's accept-and-warn-then-ignore, which would fail open here. */
-  pathRules?: Partial<Record<'read' | 'edit' | 'write', string[]>>
+  pathRules?: Partial<Record<PathRuleTool, string[]>>
   /** Entries that carried an argument scope, in their original spelling. */
   scopedEntries: string[]
 }
 
 /** The pi file tools one Claude path-ruled entry governs. */
-const PATH_RULE_TOOLS: Record<string, Array<'read' | 'edit' | 'write'>> = {
+const PATH_RULE_TOOLS: Record<string, Array<PathRuleTool>> = {
   read: ['read'],
   edit: ['edit', 'write'],
   write: ['write'],
 }
 
+/** The tools, scopes, and path rules accumulated while scanning one grant list. */
+interface GrantAccumulator {
+  tools: string[]
+  scopedEntries: string[]
+  bashRules: string[]
+  bashUnscoped: boolean
+  pathScopes: Record<PathRuleTool, string[]>
+  pathUnscoped: Set<PathRuleTool>
+}
+
+function createGrantAccumulator(): GrantAccumulator {
+  return { tools: [], scopedEntries: [], bashRules: [], bashUnscoped: false, pathScopes: { read: [], edit: [], write: [] }, pathUnscoped: new Set() }
+}
+
+/** Coerce a raw grant value to its string entries: a YAML list stays a list, a
+ * comma-separated string is split, and anything else (or a list with a non-string
+ * member) is rejected as undefined, the same "not a grant" signal as an absent field. */
+function coerceGrantItems(raw: unknown): string[] | undefined {
+  let items: unknown[]
+  if (Array.isArray(raw)) items = raw
+  else if (typeof raw === 'string') items = toolEntries(raw)
+  else return undefined
+  if (items.some((item) => typeof item !== 'string')) return undefined
+  return items as string[]
+}
+
+/** Fold one grant entry into the accumulator: the base tool is granted, an unscoped
+ * entry marks its tools wide, and a scoped entry records the scope for bash and the
+ * file tools it governs. */
+function addGrantEntry(acc: GrantAccumulator, item: string): void {
+  const entry = item.trim()
+  const name = normalizeToolName(entry)
+  if (!name) return
+  if (!acc.tools.includes(name)) acc.tools.push(name)
+  const open = entry.indexOf('(')
+  if (open === -1) {
+    if (name === 'bash') acc.bashUnscoped = true
+    for (const tool of PATH_RULE_TOOLS[name] ?? []) acc.pathUnscoped.add(tool)
+    return
+  }
+  acc.scopedEntries.push(entry)
+  const scope = entry.slice(open + 1, entry.endsWith(')') ? -1 : undefined).trim()
+  // An empty specifier (`Bash()`, `Read()`) matches nothing and must not read as
+  // the unscoped grant it explicitly is not: it is recorded so the tool stays
+  // restricted, and the matchers treat an empty rule as matching no input.
+  if (name === 'bash') acc.bashRules.push(scope)
+  for (const tool of PATH_RULE_TOOLS[name] ?? []) acc.pathScopes[tool].push(scope)
+}
+
+/** The per-tool path rules from a scan: a tool with any unscoped grant is omitted
+ * (it is wide), one with only scoped grants keeps them, and the whole map is absent
+ * when no tool carries a rule. */
+function buildPathRules(acc: GrantAccumulator): ToolGrants['pathRules'] {
+  const pathRules: NonNullable<ToolGrants['pathRules']> = {}
+  for (const tool of ['read', 'edit', 'write'] as const) {
+    if (!acc.pathUnscoped.has(tool) && acc.pathScopes[tool].length > 0) pathRules[tool] = acc.pathScopes[tool]
+  }
+  return Object.keys(pathRules).length > 0 ? pathRules : undefined
+}
+
 /**
  * A tool grant is either a comma-separated string or a YAML list, and the two mean the
  * same thing. An empty list is not the same as an absent one: it says no tools, so it
@@ -143,47 +210,15 @@ const PATH_RULE_TOOLS: Record<string, Array<'read' | 'edit' | 'write'>> = {
  * whose widening reaches everything, so it is the one enforced.
  */
 export function parseToolGrants(raw: unknown): ToolGrants | undefined {
-  if (raw === undefined || raw === null) return undefined
-  let items: unknown[]
-  if (Array.isArray(raw)) items = raw
-  else if (typeof raw === 'string') items = toolEntries(raw)
-  else return undefined
-  if (items.some((item) => typeof item !== 'string')) return undefined
-
-  const tools: string[] = []
-  const scopedEntries: string[] = []
-  const bashRules: string[] = []
-  let bashUnscoped = false
-  const pathScopes: Record<'read' | 'edit' | 'write', string[]> = { read: [], edit: [], write: [] }
-  const pathUnscoped = new Set<'read' | 'edit' | 'write'>()
-  for (const item of items as string[]) {
-    const entry = item.trim()
-    const name = normalizeToolName(entry)
-    if (!name) continue
-    if (!tools.includes(name)) tools.push(name)
-    const open = entry.indexOf('(')
-    if (open === -1) {
-      if (name === 'bash') bashUnscoped = true
-      for (const tool of PATH_RULE_TOOLS[name] ?? []) pathUnscoped.add(tool)
-      continue
-    }
-    scopedEntries.push(entry)
-    const scope = entry.slice(open + 1, entry.endsWith(')') ? -1 : undefined).trim()
-    // An empty specifier (`Bash()`, `Read()`) matches nothing and must not read as
-    // the unscoped grant it explicitly is not: it is recorded so the tool stays
-    // restricted, and the matchers treat an empty rule as matching no input.
-    if (name === 'bash') bashRules.push(scope)
-    for (const tool of PATH_RULE_TOOLS[name] ?? []) pathScopes[tool].push(scope)
-  }
-  const pathRules: ToolGrants['pathRules'] = {}
-  for (const tool of ['read', 'edit', 'write'] as const) {
-    if (!pathUnscoped.has(tool) && pathScopes[tool].length > 0) pathRules[tool] = pathScopes[tool]
-  }
+  const items = coerceGrantItems(raw)
+  if (items === undefined) return undefined
+  const acc = createGrantAccumulator()
+  for (const item of items) addGrantEntry(acc, item)
   return {
-    tools,
-    scopedEntries,
-    bashRules: !bashUnscoped && bashRules.length > 0 ? bashRules : undefined,
-    pathRules: Object.keys(pathRules).length > 0 ? pathRules : undefined,
+    tools: acc.tools,
+    scopedEntries: acc.scopedEntries,
+    bashRules: !acc.bashUnscoped && acc.bashRules.length > 0 ? acc.bashRules : undefined,
+    pathRules: buildPathRules(acc),
   }
 }
 
@@ -193,17 +228,25 @@ const text = (value: unknown): string => {
   return typeof value === 'number' || typeof value === 'boolean' ? String(value) : ''
 }
 
+/** YAML's affirmative boolean spellings. Claude documents `disable-model-invocation:
+ * true`, but a command file is hand-written YAML where `yes`, `on`, and `1` are all
+ * ordinary spellings of true, and pi's parser hands those back as the raw string or
+ * number rather than a boolean. A flag that gates a command off from the model has to
+ * honor them, or a command the user marked off-limits is silently offered to it. */
+const YAML_TRUE = new Set(['true', 'yes', 'on', 'y', '1'])
+const isFlagEnabled = (value: unknown): boolean => value === true || YAML_TRUE.has(text(value).toLowerCase())
+
 /** Claude writes `argument-hint: [pr]`, which YAML reads as a list; render it back. */
 const hint = (value: unknown): string => (Array.isArray(value) ? `[${value.join(', ')}]` : text(value))
 
-const ARGUMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/
+const ARGUMENT_NAME = /^[A-Za-z_]\w*$/
 
 /** The `arguments:` frontmatter: a YAML list or a space- or comma-separated string
  * of names mapping to positions in order. Invalid names are dropped, and ARGUMENTS
  * itself is reserved by the built-in placeholder. */
 function parseArgumentNames(raw: unknown): string[] | undefined {
   let items: string[]
-  if (Array.isArray(raw)) items = raw.map((entry) => String(entry))
+  if (Array.isArray(raw)) items = raw.map(String)
   else if (typeof raw === 'string') items = raw.split(/[\s,]+/)
   else return undefined
   const names = items.map((name) => name.trim()).filter((name) => ARGUMENT_NAME.test(name) && name !== 'ARGUMENTS')
@@ -233,7 +276,7 @@ export function parseCommandFile(content: string): ParsedCommand {
     disallowedTools: parseToolGrants(frontmatter['disallowed-tools'])?.tools,
     shell: SHELLS.has(shell) ? shell : undefined,
     model: text(frontmatter.model) || undefined,
-    disableModelInvocation: disable === true || text(disable) === 'true',
+    disableModelInvocation: isFlagEnabled(disable),
     body,
   }
 }
@@ -300,8 +343,8 @@ export function substituteArgsDetailed(body: string, args: string, names: string
     return value
   }
   const text = body.replaceAll(argPattern(names), (token, bracketIdx?: string, defIdx?: string, defVal?: string, argsDefault?: string, shorthandIdx?: string, name?: string) => {
-    if (token === '\\\\') return token
-    if (token === '\\$') return '$'
+    if (token === String.raw`\\`) return token
+    if (token === String.raw`\$`) return '$'
     if (bracketIdx !== undefined) return fill(parts[Number(bracketIdx)], token)
     if (defIdx !== undefined) return fill(parts[Number(defIdx)], defVal ?? '')
     if (argsDefault !== undefined) {

package/extensions/internal/html-markdown.ts

@@ -20,6 +20,16 @@ function decodeAllEntities(text: string): string {
 
 const stripInnerTags = (html: string): string => html.replace(/<[^<>]*>/g, '')
 
+// Strip leading and trailing newline runs in linear time. The equivalent
+// /^\n+|\n+$/g backtracks super-linearly on a long run of newlines (S8786).
+const trimNewlines = (value: string): string => {
+  let start = 0
+  let end = value.length
+  while (start < end && value[start] === '\n') start++
+  while (end > start && value[end - 1] === '\n') end--
+  return value.slice(start, end)
+}
+
 export function htmlToMarkdown(html: string): string {
   // Pre blocks are lifted out first so no later transform touches their content.
   const preBodies: string[] = []
@@ -27,7 +37,7 @@ export function htmlToMarkdown(html: string): string {
     .replace(/<!--[\s\S]*?-->/g, ' ')
     .replace(/<(script|style|noscript|head|svg)\b[^<>]*>[\s\S]*?<\/\1[^<>]*>/gi, ' ')
     .replace(/<pre\b[^<>]*>([\s\S]*?)<\/pre>/gi, (_whole, inner: string) => {
-      preBodies.push(decodeAllEntities(stripInnerTags(inner)).replace(/^\n+|\n+$/g, ''))
+      preBodies.push(trimNewlines(decodeAllEntities(stripInnerTags(inner))))
       return `\n\n\uE000PRE${preBodies.length - 1}\uE000\n\n`
     })
 

package/extensions/internal/instruction-events.ts

@@ -15,7 +15,7 @@ export const INSTRUCTIONS_CHANNEL = 'pi-code:instructions'
 /** Claude's memory_type vocabulary for InstructionsLoaded payloads. */
 export type InstructionMemoryType = 'User' | 'Project' | 'Local' | 'Managed'
 
-const MEMORY_TYPES: readonly string[] = ['User', 'Project', 'Local', 'Managed']
+const MEMORY_TYPES: ReadonlySet<string> = new Set(['User', 'Project', 'Local', 'Managed'])
 
 export interface InstructionLoadEvent {
   /** Absolute path of the instruction file that entered context. */
@@ -35,7 +35,7 @@ export function isInstructionLoadEvent(data: unknown): data is InstructionLoadEv
   const event = data as InstructionLoadEvent | null
   if (event === null || typeof event !== 'object') return false
   if (typeof event.file_path !== 'string' || typeof event.load_reason !== 'string') return false
-  if (!MEMORY_TYPES.includes(event.memory_type)) return false
+  if (!MEMORY_TYPES.has(event.memory_type)) return false
   if (event.globs !== undefined && !(Array.isArray(event.globs) && event.globs.every((glob) => typeof glob === 'string'))) return false
   if (event.trigger_file_path !== undefined && typeof event.trigger_file_path !== 'string') return false
   if (event.parent_file_path !== undefined && typeof event.parent_file_path !== 'string') return false

package/extensions/internal/managed-settings.ts

@@ -15,7 +15,7 @@ import * as fs from 'node:fs'
 export function managedSettingsPath(platform: NodeJS.Platform = process.platform): string {
   if (platform === 'darwin') return '/Library/Application Support/ClaudeCode/managed-settings.json'
   // The legacy C:\ProgramData\ClaudeCode path was dropped in Claude Code v2.1.75.
-  if (platform === 'win32') return 'C:\\Program Files\\ClaudeCode\\managed-settings.json'
+  if (platform === 'win32') return String.raw`C:\Program Files\ClaudeCode\managed-settings.json`
   return '/etc/claude-code/managed-settings.json'
 }
 

package/extensions/internal/mcp-oauth.ts

@@ -32,17 +32,21 @@ interface StoredAuth {
  * the store directory and distinct names from colliding after sanitization. */
 function storeFileFor(serverName: string): string {
   const digest = crypto.createHash('sha256').update(serverName).digest('hex').slice(0, 8)
-  const safe =
-    serverName
-      .replace(/[^A-Za-z0-9_-]+/g, '-')
-      .replace(/^-+|-+$/g, '')
-      .slice(0, 40) || 'server'
+  // Collapse disallowed runs to a single hyphen, then strip leading and trailing
+  // hyphens by index. The old /^-+|-+$/g trim rescanned on every hyphen of a long run
+  // (its trailing-anchored branch backtracks per start position), which is quadratic.
+  const collapsed = serverName.replace(/[^A-Za-z0-9_-]+/g, '-')
+  let start = 0
+  let end = collapsed.length
+  while (start < end && collapsed[start] === '-') start++
+  while (end > start && collapsed[end - 1] === '-') end--
+  const safe = collapsed.slice(start, end).slice(0, 40) || 'server'
   return path.join(getAgentDir(), 'mcp-oauth', `${safe}-${digest}.json`)
 }
 
 export class FileOAuthProvider implements OAuthClientProvider {
   private readonly storePath: string
-  private data: StoredAuth
+  private readonly data: StoredAuth
   private port = 0
   private readonly onRedirect: (authorizationUrl: URL) => void
 
@@ -161,7 +165,9 @@ export function waitForAuthCode(server: http.Server, timeoutMs: number): Promise
 
 /** Best-effort browser launch; the caller also surfaces the URL as text. */
 export function openBrowser(url: string): void {
-  const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open'
+  let command = 'xdg-open'
+  if (process.platform === 'darwin') command = 'open'
+  else if (process.platform === 'win32') command = 'cmd'
   const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url]
   try {
     spawn(command, args, { stdio: 'ignore', detached: true }).unref()

package/extensions/internal/plugins.ts

@@ -64,6 +64,15 @@ function enabledMap(settingsFiles: string[]): Record<string, boolean> {
   return merged
 }
 
+/** Copy one plugin config's `options` into `target`, coercing scalars to strings and
+ * ignoring the rest, later keys winning. */
+function mergeOptionValues(target: Record<string, string>, options: object): void {
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === 'string') target[key] = value
+    else if (typeof value === 'number' || typeof value === 'boolean') target[key] = String(value)
+  }
+}
+
 /** `pluginConfigs[id].options` per plugin id, later files winning per key. */
 function pluginConfigsMap(settingsFiles: string[]): Record<string, Record<string, string>> {
   const merged: Record<string, Record<string, string>> = {}
@@ -74,10 +83,7 @@ function pluginConfigsMap(settingsFiles: string[]): Record<string, Record<string
       const options = (config as Record<string, unknown>)?.options
       if (options === null || typeof options !== 'object') continue
       const values = merged[id] ?? {}
-      for (const [key, value] of Object.entries(options)) {
-        if (typeof value === 'string') values[key] = value
-        else if (typeof value === 'number' || typeof value === 'boolean') values[key] = String(value)
-      }
+      mergeOptionValues(values, options)
       merged[id] = values
     }
   }
@@ -99,27 +105,34 @@ export function installedPlugins(home: string, extraSettingsFiles: string[] = []
   const plugins: InstalledPlugin[] = []
   for (const marketplace of listDirs(cacheDir)) {
     for (const pluginDir of listDirs(path.join(cacheDir, marketplace))) {
-      const qualified = `${pluginDir}@${marketplace}`
-      const state = enabled[qualified] ?? enabled[pluginDir]
-      if (state !== true) continue
-      const version = newestVersion(listDirs(path.join(cacheDir, marketplace, pluginDir)))
-      if (!version) continue
-      const root = path.join(cacheDir, marketplace, pluginDir, version)
-      const manifest = readJson(path.join(root, '.claude-plugin', 'plugin.json'))
-      const name = typeof manifest.name === 'string' && manifest.name.length > 0 ? manifest.name : pluginDir
-      const id = qualified.replace(/[^A-Za-z0-9]+/g, '-')
-      const userConfig = configs[qualified] ?? configs[pluginDir] ?? configs[name]
-      plugins.push({ name, root, dataDir: path.join(home, '.claude', 'plugins', 'data', id), manifest, ...(userConfig ? { userConfig } : {}) })
+      const plugin = resolvePlugin(home, cacheDir, marketplace, pluginDir, enabled, configs)
+      if (plugin) plugins.push(plugin)
     }
   }
   return plugins
 }
 
+/** Resolve one cached plugin directory into an enabled InstalledPlugin, or null to skip
+ * it: not turned on in settings, or no version directory on disk yet. */
+function resolvePlugin(home: string, cacheDir: string, marketplace: string, pluginDir: string, enabled: Record<string, boolean>, configs: Record<string, Record<string, string>>): InstalledPlugin | null {
+  const qualified = `${pluginDir}@${marketplace}`
+  const state = enabled[qualified] ?? enabled[pluginDir]
+  if (state !== true) return null
+  const version = newestVersion(listDirs(path.join(cacheDir, marketplace, pluginDir)))
+  if (!version) return null
+  const root = path.join(cacheDir, marketplace, pluginDir, version)
+  const manifest = readJson(path.join(root, '.claude-plugin', 'plugin.json'))
+  const name = typeof manifest.name === 'string' && manifest.name.length > 0 ? manifest.name : pluginDir
+  const id = qualified.replace(/[^A-Za-z0-9]+/g, '-')
+  const userConfig = configs[qualified] ?? configs[pluginDir] ?? configs[name]
+  return { name, root, dataDir: path.join(home, '.claude', 'plugins', 'data', id), manifest, ...(userConfig ? { userConfig } : {}) }
+}
+
 /** The two plugin path variables, textually substituted into plugin-shipped
  * config (hook commands, MCP server definitions, command bodies). */
 export function substitutePluginVars(value: string, plugin: InstalledPlugin): string {
   return value
     .replaceAll('${CLAUDE_PLUGIN_ROOT}', plugin.root)
     .replaceAll('${CLAUDE_PLUGIN_DATA}', plugin.dataDir)
-    .replace(/\$\{user_config\.([A-Za-z0-9_]+)\}/g, (_, key: string) => plugin.userConfig?.[key] ?? '')
+    .replace(/\$\{user_config\.(\w+)\}/g, (_, key: string) => plugin.userConfig?.[key] ?? '')
 }

package/extensions/internal/strip-comments.ts

@@ -25,51 +25,74 @@ function fenceLength(lineStart: string, marker: string): number {
   return length
 }
 
+// CommonMark closes a fenced block only with a fence of the same character that
+// is at least as long as the opener, so both are tracked: a shorter same-char
+// fence line (the classic 3-backtick block quoted inside a 4-backtick one) is
+// content, not a closer.
+interface Fence {
+  marker: string
+  length: number
+}
+
+/** The fence state after a line, plus whether the line is fenced code (opener,
+ * body, or closer) and so emitted verbatim rather than scanned for comments. */
+function stepFence(fence: Fence | null, trimmed: string, marker: string | null): { fence: Fence | null; fenced: boolean } {
+  if (marker !== null && fence === null) {
+    return { fence: { marker, length: fenceLength(trimmed, marker) }, fenced: true }
+  }
+  if (fence !== null) {
+    const closes = marker === fence.marker && fenceLength(trimmed, marker) >= fence.length
+    return { fence: closes ? null : fence, fenced: true } // closer included: comments are content, not maintainer notes
+  }
+  return { fence, fenced: false }
+}
+
+/** Advance a line while inside an open multi-line comment. Emits any content that
+ * trails the closer onto its own line; returns whether the comment stays open. */
+function continueOpenComment(out: string[], line: string): boolean {
+  const close = line.indexOf('-->')
+  if (close === -1) return true // still inside the comment: the line goes with it
+  const rest = line.slice(close + 3)
+  // Content trailing the closer keeps its line; a bare closer line is dropped.
+  if (rest.trim().length > 0) out.push(rest.trimStart())
+  return false
+}
+
+/** Fold line-starting HTML comments off `trimmed`; several may share one line.
+ * `allComment` means the line held nothing but comments and whitespace, so it is
+ * dropped; `opensBlock` means the last comment opened a multi-line block. */
+function consumeLineComments(trimmed: string): { allComment: boolean; opensBlock: boolean } {
+  let rest = trimmed
+  let sawComment = false
+  while (rest.startsWith('<!--')) {
+    sawComment = true
+    const close = rest.indexOf('-->')
+    if (close === -1) return { allComment: true, opensBlock: true } // opens a multi-line comment
+    rest = rest.slice(close + 3).trimStart()
+  }
+  return { allComment: sawComment && rest.length === 0, opensBlock: false }
+}
+
 /** Remove whole-line HTML comments, keeping fenced code and inline comments. */
 export function stripBlockComments(text: string): string {
   const out: string[] = []
-  // CommonMark closes a fenced block only with a fence of the same character
-  // that is at least as long as the opener, so both are tracked: a shorter
-  // same-char fence line (the classic 3-backtick block quoted inside a
-  // 4-backtick one) is content, not a closer.
-  let fence: { marker: string; length: number } | null = null
+  let fence: Fence | null = null
   let inComment = false
   for (const line of text.split('\n')) {
     if (inComment) {
-      const close = line.indexOf('-->')
-      if (close === -1) continue // still inside the comment: the line goes with it
-      inComment = false
-      const rest = line.slice(close + 3)
-      // Content trailing the closer keeps its line; a bare closer line is dropped.
-      if (rest.trim().length > 0) out.push(rest.trimStart())
+      inComment = continueOpenComment(out, line)
       continue
     }
     const trimmed = line.trimStart()
-    const marker = fenceMarker(trimmed)
-    if (marker !== null && fence === null) {
-      fence = { marker, length: fenceLength(trimmed, marker) }
+    const step = stepFence(fence, trimmed, fenceMarker(trimmed))
+    fence = step.fence
+    if (step.fenced) {
       out.push(line)
       continue
     }
-    if (fence !== null) {
-      if (marker === fence.marker && fenceLength(trimmed, marker) >= fence.length) fence = null
-      out.push(line) // fenced code, closer included: comments are content, not maintainer notes
-      continue
-    }
-    // Consume comments anchored at the line start; several may share one line.
-    let rest = trimmed
-    let sawComment = false
-    while (rest.startsWith('<!--')) {
-      sawComment = true
-      const close = rest.indexOf('-->')
-      if (close === -1) {
-        inComment = true // opens a multi-line comment
-        rest = ''
-        break
-      }
-      rest = rest.slice(close + 3).trimStart()
-    }
-    if (sawComment && rest.length === 0) continue // the whole line was comment
+    const { allComment, opensBlock } = consumeLineComments(trimmed)
+    if (opensBlock) inComment = true
+    if (allComment) continue // the whole line was comment
     // No comment, or a line-starting comment followed by content: inline, verbatim.
     out.push(line)
   }