@lmzhen/dsh-evolution-core 0.26.15 → 0.27.0

package/lib/types/curator.js

@@ -0,0 +1,346 @@
+/**
+ * Deterministic skill curator: active → stale → archived transitions.
+ * Pure function with one deliberate side effect: records in the passed
+ * `usage` map are MUTATED (state/archived_at) to carry the transition — the
+ * caller owns the map and decides whether to clone first (dry-run) or persist
+ * after. File moves are performed by SkillLibrary.
+ */
+import { daysSinceIso, idleDays } from "./usage.js";
+import { createGateSet } from "./gates.js";
+import { PROTECTED_BUILTIN_SKILLS, SKILL_NAME_RE } from "./constants.js";
+export { PROTECTED_BUILTIN_SKILLS } from "./constants.js";
+export function buildCuratorRunReport(input) {
+    return {
+        schemaVersion: 1,
+        runId: input.runId,
+        startedAt: input.startedAt,
+        finishedAt: input.finishedAt,
+        staleCandidates: [...input.staleCandidates],
+        llmNominations: [...input.llmNominations],
+        archiveCandidates: [...input.archiveCandidates],
+        archived: [...input.archived],
+        failed: [...input.failed],
+        ...input.aborted === undefined ? {} : { aborted: input.aborted },
+        ...input.unattributed === undefined || input.unattributed.length === 0 ? {} : { unattributed: [...input.unattributed] },
+        ...input.consolidated === undefined ? {} : { consolidated: [...input.consolidated] },
+        ...input.snapshotPath === undefined ? {} : { snapshotPath: input.snapshotPath },
+        ...input.llmReviewEnabled === undefined ? {} : { llmReviewEnabled: input.llmReviewEnabled },
+        ...input.nominationsWarnings === undefined ? {} : { nominationsWarnings: [...input.nominationsWarnings] },
+        ...input.scanWarnings === undefined ? {} : { scanWarnings: [...input.scanWarnings] },
+        ...input.wouldPrune === undefined ? {} : { wouldPrune: input.wouldPrune === null ? null : [...input.wouldPrune] },
+    };
+}
+/**
+ * Render a curator run report as a compact human-readable markdown digest
+ * (G6): run metadata first, then the notable sections (archived / failed /
+ * stale candidates / LLM nominations).
+ */
+export function renderCuratorReportMarkdown(report) {
+    const lines = [
+        `# Curator run ${report.runId}`,
+        '',
+        `- **Started** ${report.startedAt}`,
+        `- **Finished** ${report.finishedAt}`,
+        `- **Stale candidates**: ${report.staleCandidates.length}`,
+        `- **LLM nominations**: ${report.llmNominations.length}`,
+        `- **Archived**: ${report.archived.length}`,
+        `- **Failed**: ${report.failed.length}`,
+        // V27 CUR-2: an aborted run says so on the summary line — the digest is the
+        // only artefact an operator reads, and "Failed: 0" over a run that was cut
+        // short is the false-clean signal the audit flagged.
+        ...report.aborted === undefined ? [] : [`- **Aborted**: ${report.aborted}`],
+        ...report.unattributed === undefined || report.unattributed.length === 0
+            ? []
+            : [`- **Unattributed errors**: ${report.unattributed.length}`],
+        ...report.snapshotPath === undefined ? [] : [`- **Snapshot**: ${report.snapshotPath}`],
+        ...report.routeStubs === undefined ? [] : [`- **Stale route stubs**: ${report.routeStubs.stubs}`],
+        ...report.llmReviewEnabled === undefined ? [] : [`- **llmReview**: ${report.llmReviewEnabled}`],
+        ...report.wouldPrune === undefined ? [] : [report.wouldPrune === null
+                ? '- **Would prune (archiveRetention=report)**: unknown (archive listing unreadable)'
+                : `- **Would prune (archiveRetention=report)**: ${report.wouldPrune.length}`],
+        ...report.nominationsWarnings === undefined || report.nominationsWarnings.length === 0 ? [] : [`- **Nomination warnings**: ${report.nominationsWarnings.join('; ')}`],
+        ...report.scanWarnings === undefined || report.scanWarnings.length === 0 ? [] : report.scanWarnings.map((warning) => '- **Dedup scan**: ' + warning),
+    ];
+    const section = (title, items) => items.length === 0 ? [] : ['', `## ${title}`, '', ...items.map(item => `- ${item}`)];
+    return [
+        ...lines,
+        ...section('Archived', report.archived.map(item => `${item.name} (${item.reason})`)),
+        ...section('Failed', report.failed.map(item => `${item.name}: ${item.reason}`)),
+        ...section('Unattributed', report.unattributed ?? []),
+        ...section('Stale route stubs', (report.routeStubs?.detail ?? []).map(stub => stub.skill + ' v' + String(stub.v) + ' -> ' + stub.owner + ' (' + stub.reason + ')')),
+        ...section('Stale candidates', report.staleCandidates),
+        ...section('LLM nominations', report.llmNominations),
+        ...section('Retention (kept, not deleted)', report.wouldPrune ?? []),
+        '',
+    ].join('\n');
+}
+// C-12 (v10 audit): NOMINATION_NAME_RE was byte-identical to SKILL_NAME_RE —
+// the constant is the single source now, so a future shape change (length
+// ceiling, underscore policy) cannot fork curator parsing from the stores.
+const NOMINATION_NAME_RE = SKILL_NAME_RE;
+/**
+ * Parse the curator LLM's YAML nomination block (consolidations + prunings).
+ * Line-oriented and lenient by design: the LLM output is advisory, every name
+ * is re-validated against the tree before any file move happens downstream.
+ */
+export function parseCuratorNominations(text) {
+    const prunings = [];
+    const consolidations = [];
+    const warnings = [];
+    let section = null;
+    let currentFrom = '';
+    let currentMode;
+    // S1-C4: an `into:` line (usable or not) already "accounts for" the open
+    // entry — a usable one closes it, an unusable one gets its own P1-9 warning.
+    // The dangling-entry warning below must stay silent in that case.
+    let currentIntoSpoken = false;
+    for (const line of text.split('\n')) {
+        // V6-35: the YAML section HEADERS are tracked so a `- name:` under the
+        // prunings header (the normal shape) is not mistaken for a misplaced one.
+        const header = /^\s*(consolidations|prunings)\s*:\s*$/.exec(line);
+        if (header) {
+            section = header[1] === 'consolidations' ? 'consolidations' : 'prunings';
+            continue;
+        }
+        const consolidated = /^\s*-\s*from:\s*([a-z0-9][a-z0-9-]*)(?:\s*#.*)?\s*$/.exec(line);
+        if (consolidated) {
+            // S1-C4: an unfinished previous entry (a `- from:` that never reached an
+            // `into:`) is silently replaced here — and the same silent drop happens
+            // when the output ends mid-entry (maxTokens truncation, the exact
+            // V6-35 case the warnings channel was built for). Warn on both paths;
+            // the drop itself stays (safe side: fewer merges, no content loss).
+            if (currentFrom !== '' && !currentIntoSpoken)
+                warnings.push(`"- from: ${currentFrom}" dropped — no "into:" arrived before the next entry`);
+            section = 'consolidations';
+            currentFrom = consolidated[1] ?? '';
+            currentMode = undefined;
+            currentIntoSpoken = false;
+            continue;
+        }
+        const mode = /^\s*mode:\s*(append|reference)(?:\s*#.*)?\s*$/.exec(line);
+        if (mode) {
+            if (currentFrom !== '')
+                currentMode = mode[1] === 'reference' ? 'reference' : 'append';
+            // V6-35: a `mode:` with no preceding `- from:` (or after the `into:` that
+            // closed it) is silently dropped — the consolidation stays 'append'.
+            // Warn instead so a mis-formed `mode: reference` (demote intent) is
+            // visible in the run report instead of degrading to an append.
+            else
+                warnings.push(`mode: ${mode[1]} ignored — no preceding "- from:" entry (the consolidation falls back to append)`);
+            continue;
+        }
+        const into = /^\s*into:\s*([a-z0-9][a-z0-9-]*)(?:\s*#.*)?\s*$/.exec(line);
+        if (into) {
+            const intoName = into[1] ?? '';
+            if (section === 'consolidations' && currentFrom !== '' && currentFrom !== intoName) {
+                consolidations.push({
+                    from: currentFrom,
+                    into: intoName,
+                    ...currentMode === undefined ? {} : { mode: currentMode },
+                });
+            }
+            currentFrom = '';
+            currentMode = undefined;
+            currentIntoSpoken = false;
+            continue;
+        }
+        const pruned = /^\s*-\s*name:\s*([a-z0-9][a-z0-9-]*)(?:\s*#.*)?\s*$/.exec(line);
+        if (pruned) {
+            // V6-35: a `- name:` inside the consolidations section flips the parse
+            // to prunings — every later entry is re-read as a pruning. Warn so the
+            // mis-placement is visible; parsing stays lenient.
+            if (section === 'consolidations')
+                warnings.push('"- name:" inside the consolidations section flips the parse to prunings');
+            section = 'prunings';
+            const name = pruned[1];
+            if (name)
+                prunings.push(name);
+            continue;
+        }
+        // P1-9 (v38): an anchor KEY with an unusable value (a name outside the
+        // charset, an unknown mode) used to vanish without a trace - and `- name:`
+        // is the LLM channel's only archive path. Say it instead.
+        if (/^\s*(?:-\s*(?:from|name)\s*:|(?:into|mode)\s*:)/.test(line)) {
+            // S1-C4: an unusable `into:` line still ACCOUNTS for the open entry (the
+            // attempted close is visible via this warning), so the dangling-entry
+            // warning below stays silent for it.
+            if (currentFrom !== '' && /^\s*into\s*:/.test(line))
+                currentIntoSpoken = true;
+            warnings.push(`"${line.trim()}" ignored - not a usable nomination line (names are lowercase letters, digits and hyphens; one optional trailing "# comment" is allowed)`);
+        }
+    }
+    // S1-C4: output ended mid-entry (maxTokens truncation or a dropped tail) —
+    // the pending consolidation never reached an `into:` and would otherwise
+    // vanish without a trace in the run report. An `into:` line that already
+    // spoke for the entry (usable closes it; unusable warned via P1-9) does not
+    // warn twice.
+    if (currentFrom !== '' && !currentIntoSpoken)
+        warnings.push(`"- from: ${currentFrom}" dropped — the nomination output ended before its "into:"`);
+    const valid = (name) => NOMINATION_NAME_RE.test(name);
+    return {
+        prunings: prunings.filter(valid),
+        consolidations: consolidations.filter(item => valid(item.from) && valid(item.into)),
+        warnings,
+    };
+}
+/**
+ * The lifecycle-candidate gate, shared by the transition engine and the scope
+ * view so the two can never disagree: records failing ANY of these gates are
+ * outside the managed scope.
+ */
+export function lifecycleCandidate(name, record, config, bundled, gates = createGateSet(config), 
+// V8-14 (0.3.47): marker-protected names are NOT candidates — the scope view
+// bucketed them as protected but the transition engine still treated an
+// agent-created marker skill as managed (it appeared in managed[] and
+// protected[] at once, and the engine produced a failed archive step that
+// deleteProtection then refused).
+protectedNames) {
+    if (record.pinned)
+        return false;
+    if (protectedNames?.has(name) === true)
+        return false;
+    // One shared GateSet answers exclude / referenced / suppressed and the
+    // protected-builtin list (decision B) - identical verdicts to the former
+    // three inline set checks plus the builtin check.
+    if (gates.isBlocked(name))
+        return false;
+    const managed = record.created_by === 'agent' || config.manageUnmanaged === true;
+    if (!managed && !(config.pruneBuiltins === true && bundled))
+        return false;
+    if (record.state === 'archived')
+        return false;
+    return true;
+}
+/**
+ * Read-only scope classification, derived from the SAME gate the transition
+ * engine uses (`lifecycleCandidate`), so the view always predicts what a
+ * curator pass may touch. `protectedNames` carries the marker info the usage
+ * records lack (bundled / hub-installed / pinned from `SkillLibrary.list()`).
+ */
+export function computeScopeView(usage, config, protectedNames, gates) {
+    const managed = [];
+    const watched = [];
+    const qualityWarned = [];
+    const exempted = [];
+    const protectedSet = new Set();
+    const gateSet = gates ?? createGateSet(config);
+    for (const [name, record] of usage) {
+        // Bucket semantics are view-specific and unchanged: exclude/referenced
+        // read as exempted, suppressed as protected (decision B shares the SETS,
+        // not the presentation).
+        if (gateSet.exclude.has(name) || gateSet.referenced.has(name)) {
+            exempted.push(name);
+            continue;
+        }
+        const bundled = config.bundledNames?.has(name) === true;
+        const suppressed = gateSet.suppressed.has(name);
+        // V6-36 (0.3.36): a builtin (PROTECTED_BUILTIN_SKILLS — e.g. 'plan') is
+        // blocked by the shared gate, so it lands in NO bucket — the view lost an
+        // explanation dimension for the skills it must never touch. Bucket it as
+        // protected so the view always predicts what a curator pass may touch.
+        const isBuiltin = PROTECTED_BUILTIN_SKILLS.has(name);
+        if (record.pinned || bundled || suppressed || protectedNames?.has(name) === true || isBuiltin)
+            protectedSet.add(name);
+        if (lifecycleCandidate(name, record, config, bundled, gateSet, protectedNames)) {
+            managed.push(name);
+            // P1-1 (v15): the warn buckets read the UNION of the curator six-factor
+            // pair and the feedback pair (same union as the lifecycle engine's
+            // stale-window decision, so the view predicts the engine).
+            const warned = record.quality_warn === true || record.feedback_warn === true;
+            if (record.state === 'stale' || warned)
+                watched.push(name);
+            if (warned)
+                qualityWarned.push(name);
+        }
+    }
+    return {
+        managed: managed.sort(),
+        watched: watched.sort(),
+        qualityWarned: qualityWarned.sort(),
+        exempted: exempted.sort(),
+        protected: [...protectedSet].sort(),
+    };
+}
+export function computeLifecycleTransitions(usage, config, now = new Date(), gates, 
+// V8-14 (0.3.47): marker-protected names (bundled / hub-installed / pinned
+// markers from SkillLibrary.list()) never enter the transition engine — the
+// scope view already buckets them as protected; passing the same set keeps
+// the two derivations in agreement.
+protectedNames) {
+    const result = { transitions: [], archive: [], reactivate: [], markStale: [] };
+    // One GateSet per run (decision B): callers holding a shared instance pass
+    // it in so the lifecycle engine and the merge gates can never disagree.
+    const gateSet = gates ?? createGateSet(config);
+    for (const [name, record] of usage) {
+        const bundled = config.bundledNames?.has(name) === true;
+        if (!lifecycleCandidate(name, record, config, bundled, gateSet, protectedNames))
+            continue;
+        const age = daysSinceIso(null, record.created_at, now.getTime());
+        // P1-1 (v15): the warn state is the UNION of the curator-owned six-factor
+        // pair and the feedback-owned pair — negative feedback must shorten the
+        // stale window (that is the feedback package's entire advertised purpose).
+        // Field ownership: see `UsageRecord` in usage.ts.
+        const qualityWarn = record.quality_warn === true || record.feedback_warn === true;
+        // P2-12/E-2 (v18): "never used" means never LOADED — `view_count` is the
+        // in-tree signal (the platform `skill` tool) and `use_count` an external
+        // host signal, so the guard reads both. It used to read `use_count` alone
+        // and therefore deferred EVERY skill younger than staleAfterDays,
+        // including a quality/feedback-warned one whose short window is exactly
+        // what the union read exists for. Warned skills skip the deferral and enter
+        // the normal (short-window) decision; the scope view lists them as watched.
+        if (record.use_count + record.view_count === 0 && !qualityWarn && age < config.staleAfterDays)
+            continue;
+        const idle = idleDays(record, now);
+        const staleAfterDays = qualityWarn && config.qualityWarnStaleAfterDays !== undefined
+            ? config.qualityWarnStaleAfterDays
+            : config.staleAfterDays;
+        if (record.state === 'active') {
+            if (idle >= config.archiveAfterDays) {
+                record.state = 'archived';
+                record.archived_at = now.toISOString();
+                result.transitions.push({ name, from: 'active', to: 'archived', reason: `idle ${Math.round(idle)}d >= ${config.archiveAfterDays}d` });
+                result.archive.push(name);
+            }
+            else if (idle >= staleAfterDays) {
+                record.state = 'stale';
+                // P3 (v16/v17): attribute the warn source so a curator report can tell
+                // a user's negative feedback apart from the six-factor score. Tie-break
+                // (both flags true): FEEDBACK wins — it is the more informative,
+                // user-visible signal; both sources apply the same short window, so
+                // this is report attribution only.
+                const warnSource = record.feedback_warn === true
+                    ? 'feedback-warn stale'
+                    : 'quality-warn stale';
+                const reason = qualityWarn
+                    ? `idle ${Math.round(idle)}d >= ${warnSource} ${staleAfterDays}d`
+                    : `idle ${Math.round(idle)}d >= ${staleAfterDays}d`;
+                result.transitions.push({ name, from: 'active', to: 'stale', reason });
+                result.markStale.push(name);
+            }
+        }
+        else {
+            // V27 CC-4: the archive bound is checked FIRST here, mirroring the active
+            // branch above. The old order tested `idle < staleAfterDays` first, so a
+            // contradictory configuration (warn window longer than the archive
+            // window, e.g. qualityWarnStaleAfterDays=60 with archiveAfterDays=45)
+            // REACTIVATED a stale skill at idle=50d instead of archiving it — the two
+            // branches disagreed about the same idle value, and the pair is not
+            // validated anywhere. With the archive bound first, the harder bound
+            // always wins, and the behavior is otherwise unchanged (for
+            // archiveAfterDays >= staleAfterDays the two orders are equivalent).
+            if (idle >= config.archiveAfterDays) {
+                record.state = 'archived';
+                record.archived_at = now.toISOString();
+                result.transitions.push({ name, from: 'stale', to: 'archived', reason: `idle ${Math.round(idle)}d >= ${config.archiveAfterDays}d` });
+                result.archive.push(name);
+            }
+            else if (idle < staleAfterDays) {
+                record.state = 'active';
+                result.transitions.push({ name, from: 'stale', to: 'active', reason: `recent activity ${Math.round(idle)}d` });
+                result.reactivate.push(name);
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=curator.js.map

package/lib/types/diagnostics.d.ts

@@ -0,0 +1,26 @@
+export declare const DIAGNOSTICS_VIEW_SCHEMA_VERSION: 2;
+export declare const DIAGNOSTICS_FACT_KEYS: readonly ["platform-line", "family-version", "install-form", "preset-ids", "readonly-contract", "upgrade-order", "fallback-map"];
+export declare const DIAGNOSTICS_RUNTIME_KEYS: readonly ["subagent-channel", "restricted-preset", "host-surface", "session-fold", "platform-services", "runs", "platform-pairing", "install-form-detected"];
+export type DiagnosticsFactKey = (typeof DIAGNOSTICS_FACT_KEYS)[number];
+export type DiagnosticsRuntimeKey = (typeof DIAGNOSTICS_RUNTIME_KEYS)[number];
+export type DiagnosticStatus = 'ok' | 'warn' | 'fail' | 'unknown';
+export interface DocFactRow {
+    readonly key: DiagnosticsFactKey;
+    readonly label: string;
+    readonly value: string;
+    readonly home: string;
+}
+export interface DiagnosticRow {
+    readonly key: DiagnosticsRuntimeKey;
+    readonly label: string;
+    readonly status: DiagnosticStatus;
+    readonly detail?: string;
+    readonly remedy?: string;
+}
+export interface DiagnosticsView {
+    readonly schemaVersion: typeof DIAGNOSTICS_VIEW_SCHEMA_VERSION;
+    readonly generatedAt: string;
+    readonly facts: readonly DocFactRow[];
+    readonly runtime: readonly DiagnosticRow[];
+}
+//# sourceMappingURL=diagnostics.d.ts.map

package/lib/types/diagnostics.js

@@ -0,0 +1,23 @@
+// DiagnosticsView contract: the ONE home of the doctor key set (W8 builds the view, W7 mirrors
+// it type-only into clients, CLI and panels read the same keys).
+export const DIAGNOSTICS_VIEW_SCHEMA_VERSION = 2;
+export const DIAGNOSTICS_FACT_KEYS = [
+    'platform-line',
+    'family-version',
+    'install-form',
+    'preset-ids',
+    'readonly-contract',
+    'upgrade-order',
+    'fallback-map',
+];
+export const DIAGNOSTICS_RUNTIME_KEYS = [
+    'subagent-channel',
+    'restricted-preset',
+    'host-surface',
+    'session-fold',
+    'platform-services',
+    'runs',
+    'platform-pairing',
+    'install-form-detected',
+];
+//# sourceMappingURL=diagnostics.js.map

package/lib/types/document-body.js

@@ -0,0 +1,91 @@
+/**
+ * What the panel shows when it renders one version as a document.
+ *
+ * Two decisions, both made here so the preview and the rendered diff cannot drift apart:
+ *
+ *  - FRONTMATTER IS NOT DOCUMENT TEXT. A SKILL.md opens with a YAML block; the renderer read its
+ *    closing `---` as a setext underline, so the metadata line became the document's biggest heading
+ *    and the real title sat below it (measured on the installed panel 2026-09-28). The block is
+ *    stripped for DISPLAY only: the raw view and the body route still carry every byte, and the
+ *    panel already shows the name and description on the row and in the left column.
+ *  - STRIPPING FAILS OPEN. Only a block that the family's own reader accepts is removed. A document
+ *    whose text merely starts with a thematic break, a block with no closing line, or a frontmatter
+ *    whose body is empty is returned UNCHANGED — showing a document's first line is always better
+ *    than showing nothing.
+ *
+ * `readingStats` exists for the other half of the reader's honesty: a preview that stops early has
+ * to be able to say HOW much it is not showing.
+ * @module @lmzhen/dsh-evolution-core/document-body
+ */
+import { frontmatterBlock, parseFrontmatter } from "./frontmatter.js";
+/**
+ * The document a reader sees: the body without its leading frontmatter block.
+ * @param content - the stored bytes of one version.
+ * @returns the text to render; unchanged when there is no frontmatter the reader accepts.
+ */
+export function displayBodyOf(content) {
+    const block = frontmatterBlock(content);
+    if (block === null)
+        return content;
+    // The reader's verdict, not a second parser: a block it refuses is left alone.
+    if (parseFrontmatter(content) === null)
+        return content;
+    const body = block.lines.slice(block.end + 1).join('\n');
+    // One leading blank line separates the block from the body; the document starts at its text.
+    return body.replace(/^\s*\n/, '');
+}
+/**
+ * How much of a version the panel is showing.
+ * @param full - the whole stored text.
+ * @param shown - the part the route handed over.
+ * @returns the counts, so the panel can say what it is not showing.
+ */
+export function readingStats(full, shown) {
+    return { totalChars: full.length, shownChars: shown.length, truncated: shown.length < full.length };
+}
+/**
+ * The H2 sections of a body, in document order — the ONE scan (G3).
+ *
+ * Both the restructure candidate list and the store anchor validation call this function, so a
+ * candidate can only name a heading that exists EXACTLY ONCE and has content: the two rejections a
+ * hand-written anchor used to hit ("no such heading", "ambiguous anchor") stop being reachable.
+ * H2 is the section boundary (a section spans to the next H2 or EOF), matching the store.
+ * @param body - the markdown after the frontmatter block.
+ * @returns one row per H2 heading, with `count` filled in a second pass.
+ */
+export function h2Sections(body) {
+    const lines = body.split(String.fromCharCode(10));
+    const rows = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const match = /^#{2}\s+(.+?)\s*$/.exec(lines[i] ?? '');
+        if (match === null)
+            continue;
+        const title = (match[1] ?? '').trim();
+        let end = lines.length;
+        for (let j = i + 1; j < lines.length; j += 1) {
+            if (/^#{2}\s/.test(lines[j] ?? '')) {
+                end = j;
+                break;
+            }
+        }
+        rows.push({ title, start: i, end, count: 0 });
+    }
+    for (const row of rows)
+        row.count = rows.filter(other => other.title === row.title).length;
+    return rows;
+}
+/**
+ * The sections a restructure proposal may name: heading unique, section non-empty. Derived from
+ * `h2Sections`, i.e. from the SAME scan the store validates against.
+ * @param body - the markdown after the frontmatter block.
+ * @returns move-ready pairs in document order; empty when nothing qualifies.
+ */
+export function restructureCandidates(body) {
+    return h2Sections(body)
+        .filter(section => section.count === 1 && section.end > section.start + 1)
+        .map(section => ({
+        heading: section.title,
+        toFile: 'references/' + section.title.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-').replace(/^-+|-+$/g, '') + '.md',
+    }));
+}
+//# sourceMappingURL=document-body.js.map