peaks-loop 4.0.54 → 4.1.0

package/dist/services/workspace/workspace-claude-settings-materializer.js

@@ -42,7 +42,9 @@ function readSettingsObject(serialized) {
 /** The `env` object of a serialized settings file, or `undefined`. */
 function readEnvObject(serialized) {
     const env = readSettingsObject(serialized)?.env;
-    return typeof env === 'object' && env !== null && !Array.isArray(env) ? env : undefined;
+    return typeof env === 'object' && env !== null && !Array.isArray(env)
+        ? env
+        : undefined;
 }
 /**
  * The top-level keys this function's template is allowed to DECIDE. Every other
@@ -156,8 +158,8 @@ const PEAKS_GITIGNORE_SNIPPET = [
     '.claude/settings.local.json',
     '# Offline template copy (.peaks/.claude-settings-template.json): written by',
     '# `peaks workspace init` as a manual-recovery anchor. The source-of-truth is',
-    '# peaks-loop\'s own `buildClaudeSettingsLocalJson()` — NOT this committed copy.',
-    '# Gitignored so the init flow\'s drift-driven refresh does not show up as',
+    "# peaks-loop's own `buildClaudeSettingsLocalJson()` — NOT this committed copy.",
+    "# Gitignored so the init flow's drift-driven refresh does not show up as",
     '# "modified" in `git status` on every release bump. Recovery path: re-run',
     '# `peaks workspace init` to regenerate; or copy from peaks-loop source.',
     '# Both patterns below are PROJECT-ROOT-relative, so this snippet must land',
@@ -167,13 +169,13 @@ const PEAKS_GITIGNORE_SNIPPET = [
     '# `repair-exclude` / `repair-index` / pre-dispatch preflight / post-slice',
     '# auto-refresh copies `.codegraph/config.json` here before rewriting it, so',
     '# this file is LOCAL CHURN: a committed one is silently replaced by the next',
-    '# repair. Upstream\'s own `.codegraph/.gitignore` does not cover it (it names',
+    "# repair. Upstream's own `.codegraph/.gitignore` does not cover it (it names",
     '# *.db / *.db-wal / *.db-shm, cache/, *.log and .dirty only) and `.codegraph/`',
     '# is NOT ignored wholesale downstream, so without this line a consumer project',
     '# commits a file peaks-loop rewrites under it.',
     '#',
     '# ONLY the backup, never `config.json` itself: upstream deliberately keeps',
-    '# that config committable (it is a project\'s include/exclude policy, and',
+    "# that config committable (it is a project's include/exclude policy, and",
     '# committing it is how a team shares it), so ignoring it would hide a file',
     '# people mean to commit. A rollback copy is the opposite kind of file.',
     '.codegraph/config.json.bak',

package/dist/services/workspace/workspace-clean-service.js

@@ -28,7 +28,10 @@ export function planRuntimeCleanup(sessions, options) {
             eligible.push(s.sid);
         }
         else {
-            skipped.push({ sid: s.sid, reason: `fresh: age=${s.ageHours.toFixed(1)}h < cutoff=${cutoffHours}h` });
+            skipped.push({
+                sid: s.sid,
+                reason: `fresh: age=${s.ageHours.toFixed(1)}h < cutoff=${cutoffHours}h`
+            });
         }
     }
     return { eligible, skipped };

package/dist/services/workspace/workspace-service.js

@@ -24,7 +24,8 @@ function rebindCurrentCallerBinding(projectRoot, sessionId) {
     try {
         callerId = resolveCallerProjection({ projectRoot, env: process.env }).callerId;
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return false;
     }
     return updateCallerBindingSessionId(projectRoot, callerId, sessionId);
@@ -85,7 +86,14 @@ function isDateStampedSiblingId(name) {
 import { detectMissingProjectStandards } from '../standards/missing-standards-detector.js';
 import { detectLanguage, executeProjectStandardsInit } from '../standards/project-standards-service.js';
 const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
-const PROHIBITED_SUFFIXES = ['session', 'work', 'task', 'test', 'temp', 'tmp'];
+const PROHIBITED_SUFFIXES = [
+    'session',
+    'work',
+    'task',
+    'test',
+    'temp',
+    'tmp'
+];
 // Auto-generated session ID pattern: YYYY-MM-DD-session-<6位hex>
 const AUTO_SESSION_PATTERN = /^\d{4}-\d{2}-\d{2}-session-[a-f0-9]{6}$/;
 /**
@@ -319,7 +327,7 @@ export async function initWorkspace(options) {
         // Refuse to rebind without explicit authorization.
         previousSessionId = existingSessionId;
         const existingSessionDir = join(runtimeRoot, existingSessionId);
-        if (await isDirectory(existingSessionDir) && !options.allowSessionRebind) {
+        if ((await isDirectory(existingSessionDir)) && !options.allowSessionRebind) {
             const { readdirSync } = await import('node:fs');
             const entries = readdirSync(existingSessionDir);
             if (entries.length > 0) {

package/dist/services/workspace/workspace-state-service.js

@@ -11,7 +11,7 @@ import { join, posix } from 'node:path';
  */
 const LEGACY_DOTFILES = [
     '.peaks-init-hooks-decision.json',
-    '.peaks-openspec-opt-in.json',
+    '.peaks-openspec-opt-in.json'
 ];
 const STATE_DIR_NAME = '_state';
 export function isLegacyDecisionDotfile(name) {

package/dist/services/worktree/git-worktree-parser.js

@@ -8,7 +8,7 @@ export function parseGitWorktreePorcelain(raw) {
                 path: current.path,
                 head: current.head,
                 branch: current.branch,
-                prunable: current.prunable,
+                prunable: current.prunable
             });
         }
         current = null;
@@ -27,10 +27,20 @@ export function parseGitWorktreePorcelain(raw) {
             current = next;
         }
         else if (current !== null && key === 'HEAD') {
-            current = { path: current.path, head: value, branch: current.branch, prunable: current.prunable };
+            current = {
+                path: current.path,
+                head: value,
+                branch: current.branch,
+                prunable: current.prunable
+            };
         }
         else if (current !== null && key === 'branch') {
-            current = { path: current.path, head: current.head, branch: value.replace(/^refs\/heads\//, ''), prunable: current.prunable };
+            current = {
+                path: current.path,
+                head: current.head,
+                branch: value.replace(/^refs\/heads\//, ''),
+                prunable: current.prunable
+            };
         }
         else if (current !== null && key === 'prunable') {
             current = { path: current.path, head: current.head, branch: current.branch, prunable: true };

package/dist/services/worktree/host-worktree-reconciler.js

@@ -11,7 +11,7 @@ export function reconcileHostWorktrees(input) {
             cwd: input.projectRoot,
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
+            windowsHide: true
         });
         records = parseGitWorktreePorcelain(raw);
     }
@@ -22,7 +22,7 @@ export function reconcileHostWorktrees(input) {
     const leaseResult = listLeasesSync(storeDir, {
         existsSync,
         readdir: (path) => readdirSync(path),
-        readFile: (path) => readFileSync(path, 'utf8'),
+        readFile: (path) => readFileSync(path, 'utf8')
     });
     const leases = leaseResult.kind === 'ok' ? leaseResult.leases : [];
     const leaseByPath = new Map(leases.map((lease) => [resolve(lease.path), lease.leaseId]));
@@ -33,8 +33,12 @@ export function reconcileHostWorktrees(input) {
         return {
             ...record,
             managedLeaseId,
-            state: record.prunable ? 'prunable' : managedLeaseId === null ? 'unleased' : 'managed',
+            state: record.prunable ? 'prunable' : managedLeaseId === null ? 'unleased' : 'managed'
         };
     });
-    return { hostRoot, findings, unmanaged: findings.filter((finding) => finding.state !== 'managed') };
+    return {
+        hostRoot,
+        findings,
+        unmanaged: findings.filter((finding) => finding.state !== 'managed')
+    };
 }

package/dist/services/worktree/long-path-cleanup.js

@@ -14,25 +14,42 @@ export function removeRegisteredWorktree(input) {
         execFileSync('git', ['worktree', 'remove', '--force', input.worktreePath], {
             cwd: input.projectRoot,
             stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
+            windowsHide: true
+        });
+        execFileSync('git', ['worktree', 'prune'], {
+            cwd: input.projectRoot,
+            stdio: 'ignore',
+            windowsHide: true
         });
-        execFileSync('git', ['worktree', 'prune'], { cwd: input.projectRoot, stdio: 'ignore', windowsHide: true });
         return { removed: !existsSync(input.worktreePath), strategy: 'git' };
     }
     catch (error) {
         if (process.platform !== 'win32') {
-            return { removed: false, strategy: 'none', error: error instanceof Error ? error.message : String(error) };
+            return {
+                removed: false,
+                strategy: 'none',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
         try {
-            rmSync(windowsLongPath(input.worktreePath), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-            execFileSync('git', ['worktree', 'prune'], { cwd: input.projectRoot, stdio: 'ignore', windowsHide: true });
+            rmSync(windowsLongPath(input.worktreePath), {
+                recursive: true,
+                force: true,
+                maxRetries: 3,
+                retryDelay: 100
+            });
+            execFileSync('git', ['worktree', 'prune'], {
+                cwd: input.projectRoot,
+                stdio: 'ignore',
+                windowsHide: true
+            });
             return { removed: !existsSync(input.worktreePath), strategy: 'windows-long-path' };
         }
         catch (fallbackError) {
             return {
                 removed: false,
                 strategy: 'none',
-                error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
+                error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
             };
         }
     }

package/dist/services/worktree/worktree-gc-guard.js

@@ -34,5 +34,7 @@ export function findManagedSkillJunctionReferences(input) {
 function isInside(parent, candidate) {
     const normalizedParent = resolve(parent).toLowerCase();
     const normalizedCandidate = resolve(candidate).toLowerCase();
-    return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}\\`) || normalizedCandidate.startsWith(`${normalizedParent}/`);
+    return (normalizedCandidate === normalizedParent ||
+        normalizedCandidate.startsWith(`${normalizedParent}\\`) ||
+        normalizedCandidate.startsWith(`${normalizedParent}/`));
 }

package/dist/services/worktree/worktree-lease-types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * worktree-lease-types — the pure declaration surface of the worktree lease
+ * store (`worktree-lease.ts`).
+ *
+ * Slice 2026-07-29-worktree-l2-extended Part 1 owns the lease behavior; this
+ * module owns only the shapes (lifecycle status, lease record, creation draft,
+ * and the list-read result). `worktree-lease.ts` imports and re-exports every
+ * name here, so importers keep resolving them from the original path.
+ */
+export type WorktreeLeaseStatus = 'active' | 'released' | 'expired' | 'gc';
+export interface WorktreeLease {
+    /** Random 16-hex lease id; emitted to the operator as the lease handle. */
+    readonly leaseId: string;
+    /** The peaks request id (rid) that the lease was spawned for. */
+    readonly rid: string;
+    /** Sub-agent role (rd | qa | ui | sc | prd | general-purpose | ...). */
+    readonly role: string;
+    /** Absolute worktree path on disk (under .peaks/_runtime/<sid>/worktrees/<leaseId>/). */
+    readonly path: string;
+    /** Branch name (one of the worktree's --branch / -b args). */
+    readonly branch: string;
+    /** Unix epoch ms when the lease was created. */
+    readonly createdAt: number;
+    /** Unix epoch ms when the lease expires. */
+    readonly expiresAt: number;
+    /** Operator-supplied purpose text (audit log). */
+    readonly purpose: string;
+    /** Lifecycle status; updated by `releaseLease` / `markExpired`. */
+    readonly status: WorktreeLeaseStatus;
+    /** Sub-agent batch / dispatch ids that have consumed this lease. */
+    readonly consumedBySubAgents: ReadonlyArray<string>;
+}
+/** Subset of WorktreeLease that the CLI writes on creation. Status starts at 'active'. */
+export type WorktreeLeaseDraft = Omit<WorktreeLease, 'status' | 'consumedBySubAgents'>;
+/**
+ * Pure: read every lease file under the session's lease store dir.
+ * Returns leases in the order returned by `fs.readdir` (no sort).
+ * Malformed files are surfaced as `{ file, error }` records so the caller
+ * (the `list` CLI) can warn without aborting the whole list. Missing
+ * directory is not an error — it returns an empty leases array.
+ */
+export interface LeaseReadError {
+    readonly file: string;
+    readonly error: string;
+}
+export type LeaseListResult = {
+    readonly kind: 'ok';
+    readonly leases: ReadonlyArray<WorktreeLease>;
+    readonly errors: ReadonlyArray<LeaseReadError>;
+} | {
+    readonly kind: 'store-missing';
+    readonly storeDir: string;
+};

package/dist/services/worktree/worktree-lease-types.js

@@ -0,0 +1,10 @@
+/**
+ * worktree-lease-types — the pure declaration surface of the worktree lease
+ * store (`worktree-lease.ts`).
+ *
+ * Slice 2026-07-29-worktree-l2-extended Part 1 owns the lease behavior; this
+ * module owns only the shapes (lifecycle status, lease record, creation draft,
+ * and the list-read result). `worktree-lease.ts` imports and re-exports every
+ * name here, so importers keep resolving them from the original path.
+ */
+export {};

package/dist/services/worktree/worktree-lease.d.ts

@@ -24,33 +24,10 @@
  * implicitly authorizes worktree operations on its path (the hook
  * integration is Part 2 of this slice).
  */
+import type { LeaseListResult, WorktreeLease, WorktreeLeaseDraft } from './worktree-lease-types.js';
+export type { LeaseListResult, LeaseReadError, WorktreeLease, WorktreeLeaseDraft, WorktreeLeaseStatus } from './worktree-lease-types.js';
 export declare const DEFAULT_TTL_BY_ROLE: Readonly<Record<string, number>>;
 export declare const DEFAULT_TTL_MS: number | undefined;
-export type WorktreeLeaseStatus = 'active' | 'released' | 'expired' | 'gc';
-export interface WorktreeLease {
-    /** Random 16-hex lease id; emitted to the operator as the lease handle. */
-    readonly leaseId: string;
-    /** The peaks request id (rid) that the lease was spawned for. */
-    readonly rid: string;
-    /** Sub-agent role (rd | qa | ui | sc | prd | general-purpose | ...). */
-    readonly role: string;
-    /** Absolute worktree path on disk (under .peaks/_runtime/<sid>/worktrees/<leaseId>/). */
-    readonly path: string;
-    /** Branch name (one of the worktree's --branch / -b args). */
-    readonly branch: string;
-    /** Unix epoch ms when the lease was created. */
-    readonly createdAt: number;
-    /** Unix epoch ms when the lease expires. */
-    readonly expiresAt: number;
-    /** Operator-supplied purpose text (audit log). */
-    readonly purpose: string;
-    /** Lifecycle status; updated by `releaseLease` / `markExpired`. */
-    readonly status: WorktreeLeaseStatus;
-    /** Sub-agent batch / dispatch ids that have consumed this lease. */
-    readonly consumedBySubAgents: ReadonlyArray<string>;
-}
-/** Subset of WorktreeLease that the CLI writes on creation. Status starts at 'active'. */
-export type WorktreeLeaseDraft = Omit<WorktreeLease, 'status' | 'consumedBySubAgents'>;
 /**
  * Compose a deterministic lease path under the per-session runtime dir.
  * The function is pure: same inputs → same output. The caller passes
@@ -102,25 +79,6 @@ export declare function recordConsumption(lease: WorktreeLease, subAgentId: stri
  * but `isLeaseActive` returns false so consumers skip the lease.
  */
 export declare function isLeaseActive(lease: WorktreeLease, now?: number): boolean;
-/**
- * Pure: read every lease file under the session's lease store dir.
- * Returns leases in the order returned by `fs.readdir` (no sort).
- * Malformed files are surfaced as `{ file, error }` records so the caller
- * (the `list` CLI) can warn without aborting the whole list. Missing
- * directory is not an error — it returns an empty leases array.
- */
-export interface LeaseReadError {
-    readonly file: string;
-    readonly error: string;
-}
-export type LeaseListResult = {
-    readonly kind: 'ok';
-    readonly leases: ReadonlyArray<WorktreeLease>;
-    readonly errors: ReadonlyArray<LeaseReadError>;
-} | {
-    readonly kind: 'store-missing';
-    readonly storeDir: string;
-};
 /**
  * List every lease file under the session's lease store dir.
  *

package/dist/shared/array-guards.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `Array.isArray` written so that it does NOT narrow.
+ *
+ * WHY THIS EXISTS (S10, 2026-09-20). TypeScript declares `Array.isArray` as
+ * `(arg: any) => arg is any[]`. That is right for an `unknown` argument and
+ * WRONG for an already-typed one: applied to a `readonly SliceNode[]`, the
+ * guard narrows the value to `any[]`, so every later element access
+ * (`n.id`, `e.from`, …) is an `any` access. `@typescript-eslint/no-unsafe-*`
+ * then reports the widening, not the caller's intent — and the guard was
+ * measuring "is this an array at runtime?", which it still does below.
+ *
+ * Measured effect of the widening at the S10 census: 107 of the 817 TS
+ * `no-unsafe-*` findings across 7 files (slice-dag, workflow-graph-store,
+ * workflow-inflight-probe, spec-service, contract-store, eslint-runner,
+ * api-diff-openapi). Those files hold values that are ALREADY correctly typed;
+ * `Array.isArray` was the only thing discarding the type.
+ *
+ * Returning plain `boolean` is the honest shape here: it reports the runtime
+ * fact and asserts nothing about the type. A predicate like
+ * `value is readonly T[]` would silence the same findings with an unchecked
+ * assertion — the same offence as a cast — which this slice is explicitly
+ * forbidden from adding.
+ *
+ * Consequence at call sites: after `if (!isArray(x)) throw`, TypeScript does
+ * NOT know `x` is defined, because a `boolean` return cannot narrow. A site
+ * that also needs defined-ness must say so — write
+ * `if (x === undefined || !isArray(x)) throw`, which is what the call sites
+ * below do. That is the price of not asserting, and it is paid in the open.
+ */
+export declare function isArray(value: unknown): boolean;

package/dist/shared/array-guards.js

@@ -0,0 +1,32 @@
+/**
+ * `Array.isArray` written so that it does NOT narrow.
+ *
+ * WHY THIS EXISTS (S10, 2026-09-20). TypeScript declares `Array.isArray` as
+ * `(arg: any) => arg is any[]`. That is right for an `unknown` argument and
+ * WRONG for an already-typed one: applied to a `readonly SliceNode[]`, the
+ * guard narrows the value to `any[]`, so every later element access
+ * (`n.id`, `e.from`, …) is an `any` access. `@typescript-eslint/no-unsafe-*`
+ * then reports the widening, not the caller's intent — and the guard was
+ * measuring "is this an array at runtime?", which it still does below.
+ *
+ * Measured effect of the widening at the S10 census: 107 of the 817 TS
+ * `no-unsafe-*` findings across 7 files (slice-dag, workflow-graph-store,
+ * workflow-inflight-probe, spec-service, contract-store, eslint-runner,
+ * api-diff-openapi). Those files hold values that are ALREADY correctly typed;
+ * `Array.isArray` was the only thing discarding the type.
+ *
+ * Returning plain `boolean` is the honest shape here: it reports the runtime
+ * fact and asserts nothing about the type. A predicate like
+ * `value is readonly T[]` would silence the same findings with an unchecked
+ * assertion — the same offence as a cast — which this slice is explicitly
+ * forbidden from adding.
+ *
+ * Consequence at call sites: after `if (!isArray(x)) throw`, TypeScript does
+ * NOT know `x` is defined, because a `boolean` return cannot narrow. A site
+ * that also needs defined-ness must say so — write
+ * `if (x === undefined || !isArray(x)) throw`, which is what the call sites
+ * below do. That is the price of not asserting, and it is paid in the open.
+ */
+export function isArray(value) {
+    return Array.isArray(value);
+}

package/dist/shared/format-md-compact-internals.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Internal, finding-free building blocks for `format-md-compact.ts`.
+ *
+ * Split verbatim from the main module for the file-size cap campaign; the
+ * public surface (`formatMdCompact` / `FormatMdCompactOptions`) is re-exported
+ * from `format-md-compact.ts`, so importers keep pointing at the same path.
+ * This module is imported by both `src/` and `packages/` through that path.
+ */
+export declare const FENCE_MARKER_RE: RegExp;
+export declare const TABLE_ROW_RE: RegExp;
+export declare const TABLE_ALIGN_ROW_RE: RegExp;
+export declare const ATX_HEADING_RE: RegExp;
+export declare const HEADING_LINE_RE: RegExp;
+export declare const SETEXT_UNDERLINE_RE: RegExp;
+export interface ParsedFrontmatter {
+    raw: string;
+    description: string | null;
+    body: string;
+}
+export declare function splitFrontmatter(input: string): ParsedFrontmatter;
+export declare function isFenceOpenLine(line: string): boolean;
+export declare function isFenceCloseLine(line: string, insideFence: boolean): boolean;
+export declare function isTableLine(line: string): boolean;
+export declare function computeSetextUnderlines(lines: string[]): Set<number>;
+export declare function isDecorativeHorizontalRule(line: string): boolean;
+export declare function collapseMultiBlanks(lines: string[]): string[];

package/dist/shared/format-md-compact-internals.js

@@ -0,0 +1,125 @@
+/**
+ * Internal, finding-free building blocks for `format-md-compact.ts`.
+ *
+ * Split verbatim from the main module for the file-size cap campaign; the
+ * public surface (`formatMdCompact` / `FormatMdCompactOptions`) is re-exported
+ * from `format-md-compact.ts`, so importers keep pointing at the same path.
+ * This module is imported by both `src/` and `packages/` through that path.
+ */
+export const FENCE_MARKER_RE = /^(```+|~~~+)/;
+export const TABLE_ROW_RE = /^\s*\|.*\|\s*$/;
+export const TABLE_ALIGN_ROW_RE = /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)+\|?\s*$/;
+export const ATX_HEADING_RE = /^#{1,6}\s/;
+export const HEADING_LINE_RE = /^\S/;
+export const SETEXT_UNDERLINE_RE = /^=+\s*$|^-{2,}\s*$/;
+export function splitFrontmatter(input) {
+    // Normalize line endings so Windows \r\n doesn't confuse the leading-marker check.
+    const normalized = input.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    if (lines[0] !== '---') {
+        return { raw: '', description: null, body: normalized };
+    }
+    let closeIndex = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        if (lines[index] === '---') {
+            closeIndex = index;
+            break;
+        }
+    }
+    if (closeIndex < 0) {
+        return { raw: '', description: null, body: normalized };
+    }
+    const raw = lines.slice(0, closeIndex + 1).join('\n');
+    // Body = everything after the closing `---` (preserving one optional blank line).
+    const bodyLines = lines.slice(closeIndex + 1);
+    while (bodyLines.length > 0 && bodyLines[0] === '') {
+        bodyLines.shift();
+    }
+    const body = bodyLines.join('\n');
+    // Extract the `description:` field. Walk the YAML block; pull the value
+    // as a single-line string. Multi-line (`|`) or folded (`>`) scalars are
+    // joined with a single space — the description is a short summary, the
+    // exact whitespace inside the block scalar is not preserved.
+    const frontmatterLines = lines.slice(1, closeIndex);
+    const description = extractFrontmatterDescription(frontmatterLines);
+    return { raw, description, body };
+}
+function extractFrontmatterDescription(frontmatterLines) {
+    for (let index = 0; index < frontmatterLines.length; index += 1) {
+        const line = frontmatterLines[index] ?? '';
+        const match = line.match(/^description:\s*(.*)$/);
+        if (match === null)
+            continue;
+        const inline = (match[1] ?? '').trim();
+        if (inline === '|' || inline === '>') {
+            const collected = [];
+            for (let inner = index + 1; inner < frontmatterLines.length; inner += 1) {
+                const innerLine = frontmatterLines[inner] ?? '';
+                if (/^[A-Za-z0-9_-]+:/.test(innerLine))
+                    break;
+                collected.push(innerLine.replace(/^\s{2}/, ''));
+            }
+            return collected.join(' ').trim();
+        }
+        // Strip surrounding quotes if the value is a quoted scalar.
+        return inline.replace(/^['"]|['"]$/g, '');
+    }
+    return null;
+}
+export function isFenceOpenLine(line) {
+    return FENCE_MARKER_RE.test(line);
+}
+export function isFenceCloseLine(line, insideFence) {
+    // The `isFenceOpenLine` already returned true for this line, so it
+    // starts with ``` or ~~~. A "close" line is one that opens a new fence
+    // of the *same* length. We approximate by treating any opener as a close
+    // when we are currently inside a fence.
+    return insideFence;
+}
+export function isTableLine(line) {
+    return TABLE_ROW_RE.test(line) || TABLE_ALIGN_ROW_RE.test(line);
+}
+export function computeSetextUnderlines(lines) {
+    // A `===` or `---` line is a setext heading underline ONLY when it sits
+    // directly under a non-blank, non-ATX text line (no blank line between
+    // them). The presence of a blank line between the text and the rule
+    // disqualifies it (a blank-separated `---` is decoration, not setext).
+    const result = new Set();
+    for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (!SETEXT_UNDERLINE_RE.test(line))
+            continue;
+        const prev = lines[index - 1] ?? '';
+        if (prev === '')
+            continue;
+        if (ATX_HEADING_RE.test(prev))
+            continue;
+        if (!HEADING_LINE_RE.test(prev))
+            continue;
+        result.add(index);
+    }
+    return result;
+}
+export function isDecorativeHorizontalRule(line) {
+    // A line that is exactly `---` (or any number of `-` chars) is a
+    // candidate horizontal rule. The caller has already excluded setext
+    // and table contexts via the `protection` array.
+    return /^-+$/.test(line);
+}
+export function collapseMultiBlanks(lines) {
+    const result = [];
+    let blankRun = 0;
+    for (const line of lines) {
+        if (line === '') {
+            blankRun += 1;
+            // 1 blank line is the cap. Drop the rest.
+            if (blankRun <= 1) {
+                result.push(line);
+            }
+            continue;
+        }
+        blankRun = 0;
+        result.push(line);
+    }
+    return result;
+}