@mulmoclaude/core 0.2.16 → 0.4.0

package/dist/slug-CdN-pQX1.js

@@ -0,0 +1,37 @@
+//#region src/wiki/slug.ts
+/** Reject slugs that would escape `data/wiki/pages/` once
+*  joined back into a path, or that are otherwise invalid as
+*  page filenames. The chokepoint must defend itself even when
+*  callers derive the slug from a trusted source — a typo or
+*  future caller mistake should fail loud, not silently write
+*  outside the wiki tree.
+*
+*  The rule is intentionally narrow — separators / `..` / NUL /
+*  empty — so it only rejects unambiguous violations. Aesthetic
+*  concerns (e.g. dot-prefixed filenames) are out of scope: a
+*  pre-existing `data/wiki/pages/.foo.md` should remain writable
+*  through the chokepoint (codex review iter-2 #883). */
+function isSafeSlug(slug) {
+	if (slug.length === 0) return false;
+	if (slug === "." || slug === "..") return false;
+	if (slug.includes("/") || slug.includes("\\")) return false;
+	if (slug.includes("\0")) return false;
+	return true;
+}
+/** Slug rules for `[[wiki link]]` text → slug derivation:
+*  lowercase, spaces collapsed to hyphens, every non-ASCII /
+*  non-alphanumeric / non-hyphen character stripped.
+*
+*  Pure: no normalisation, no transliteration — this is the
+*  same shape the index parser, page resolver, and frontend
+*  renderer all need to agree on. Non-ASCII titles (e.g.
+*  Japanese) collapse to an empty string here; callers fall back
+*  to other strategies (title-match in the index, or the agent
+*  pre-resolving to a slug-form target via `[[slug|display]]`). */
+function wikiSlugify(text) {
+	return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+//#endregion
+export { wikiSlugify as n, isSafeSlug as t };
+
+//# sourceMappingURL=slug-CdN-pQX1.js.map

package/dist/slug-CdN-pQX1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug-CdN-pQX1.js","names":[],"sources":["../src/wiki/slug.ts"],"sourcesContent":["// Pure wiki-page slug helpers — string-only, no Node / browser\n// dependencies, importable from any bundle.\n//\n// Used by:\n//   - server/workspace/wiki-pages/io.ts (the write chokepoint)\n//   - server/workspace/hooks/handlers/wikiSnapshot.ts (the\n//     PostToolUse handler that fires on Write/Edit of a wiki page)\n//   - server/api/routes/wiki.ts (page resolver + lint)\n//   - server/api/routes/wiki/history.ts (history slug guard)\n//   - src/plugins/wiki/route.ts (router slug guard — replaces the\n//     local `isSafeWikiSlug` duplicate that existed before the\n//     pure-lib refactor)\n//   - src/plugins/wiki/helpers.ts (renderer slugify for [[…]] links)\n//\n// Any helper that needs `node:path` lives in `./paths.ts` so that\n// importing this file from frontend code never pulls in Node\n// builtins.\n\n/** Reject slugs that would escape `data/wiki/pages/` once\n *  joined back into a path, or that are otherwise invalid as\n *  page filenames. The chokepoint must defend itself even when\n *  callers derive the slug from a trusted source — a typo or\n *  future caller mistake should fail loud, not silently write\n *  outside the wiki tree.\n *\n *  The rule is intentionally narrow — separators / `..` / NUL /\n *  empty — so it only rejects unambiguous violations. Aesthetic\n *  concerns (e.g. dot-prefixed filenames) are out of scope: a\n *  pre-existing `data/wiki/pages/.foo.md` should remain writable\n *  through the chokepoint (codex review iter-2 #883). */\nexport function isSafeSlug(slug: string): boolean {\n  if (slug.length === 0) return false;\n  if (slug === \".\" || slug === \"..\") return false;\n  if (slug.includes(\"/\") || slug.includes(\"\\\\\")) return false;\n  if (slug.includes(\"\\0\")) return false;\n  return true;\n}\n\n/** Slug rules for `[[wiki link]]` text → slug derivation:\n *  lowercase, spaces collapsed to hyphens, every non-ASCII /\n *  non-alphanumeric / non-hyphen character stripped.\n *\n *  Pure: no normalisation, no transliteration — this is the\n *  same shape the index parser, page resolver, and frontend\n *  renderer all need to agree on. Non-ASCII titles (e.g.\n *  Japanese) collapse to an empty string here; callers fall back\n *  to other strategies (title-match in the index, or the agent\n *  pre-resolving to a slug-form target via `[[slug|display]]`). */\nexport function wikiSlugify(text: string): string {\n  return text\n    .toLowerCase()\n    .replace(/\\s+/g, \"-\")\n    .replace(/[^a-z0-9-]/g, \"\");\n}\n"],"mappings":";;;;;;;;;;;;;AA8BA,SAAgB,WAAW,MAAuB;CAChD,IAAI,KAAK,WAAW,GAAG,OAAO;CAC9B,IAAI,SAAS,OAAO,SAAS,MAAM,OAAO;CAC1C,IAAI,KAAK,SAAS,GAAG,KAAK,KAAK,SAAS,IAAI,GAAG,OAAO;CACtD,IAAI,KAAK,SAAS,IAAI,GAAG,OAAO;CAChC,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,YAAY,MAAsB;CAChD,OAAO,KACJ,YAAY,CAAC,CACb,QAAQ,QAAQ,GAAG,CAAC,CACpB,QAAQ,eAAe,EAAE;AAC9B"}

package/dist/slug-DbwORN9z.cjs

@@ -0,0 +1,48 @@
+//#region src/wiki/slug.ts
+/** Reject slugs that would escape `data/wiki/pages/` once
+*  joined back into a path, or that are otherwise invalid as
+*  page filenames. The chokepoint must defend itself even when
+*  callers derive the slug from a trusted source — a typo or
+*  future caller mistake should fail loud, not silently write
+*  outside the wiki tree.
+*
+*  The rule is intentionally narrow — separators / `..` / NUL /
+*  empty — so it only rejects unambiguous violations. Aesthetic
+*  concerns (e.g. dot-prefixed filenames) are out of scope: a
+*  pre-existing `data/wiki/pages/.foo.md` should remain writable
+*  through the chokepoint (codex review iter-2 #883). */
+function isSafeSlug(slug) {
+	if (slug.length === 0) return false;
+	if (slug === "." || slug === "..") return false;
+	if (slug.includes("/") || slug.includes("\\")) return false;
+	if (slug.includes("\0")) return false;
+	return true;
+}
+/** Slug rules for `[[wiki link]]` text → slug derivation:
+*  lowercase, spaces collapsed to hyphens, every non-ASCII /
+*  non-alphanumeric / non-hyphen character stripped.
+*
+*  Pure: no normalisation, no transliteration — this is the
+*  same shape the index parser, page resolver, and frontend
+*  renderer all need to agree on. Non-ASCII titles (e.g.
+*  Japanese) collapse to an empty string here; callers fall back
+*  to other strategies (title-match in the index, or the agent
+*  pre-resolving to a slug-form target via `[[slug|display]]`). */
+function wikiSlugify(text) {
+	return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+//#endregion
+Object.defineProperty(exports, "isSafeSlug", {
+	enumerable: true,
+	get: function() {
+		return isSafeSlug;
+	}
+});
+Object.defineProperty(exports, "wikiSlugify", {
+	enumerable: true,
+	get: function() {
+		return wikiSlugify;
+	}
+});
+
+//# sourceMappingURL=slug-DbwORN9z.cjs.map

package/dist/slug-DbwORN9z.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug-DbwORN9z.cjs","names":[],"sources":["../src/wiki/slug.ts"],"sourcesContent":["// Pure wiki-page slug helpers — string-only, no Node / browser\n// dependencies, importable from any bundle.\n//\n// Used by:\n//   - server/workspace/wiki-pages/io.ts (the write chokepoint)\n//   - server/workspace/hooks/handlers/wikiSnapshot.ts (the\n//     PostToolUse handler that fires on Write/Edit of a wiki page)\n//   - server/api/routes/wiki.ts (page resolver + lint)\n//   - server/api/routes/wiki/history.ts (history slug guard)\n//   - src/plugins/wiki/route.ts (router slug guard — replaces the\n//     local `isSafeWikiSlug` duplicate that existed before the\n//     pure-lib refactor)\n//   - src/plugins/wiki/helpers.ts (renderer slugify for [[…]] links)\n//\n// Any helper that needs `node:path` lives in `./paths.ts` so that\n// importing this file from frontend code never pulls in Node\n// builtins.\n\n/** Reject slugs that would escape `data/wiki/pages/` once\n *  joined back into a path, or that are otherwise invalid as\n *  page filenames. The chokepoint must defend itself even when\n *  callers derive the slug from a trusted source — a typo or\n *  future caller mistake should fail loud, not silently write\n *  outside the wiki tree.\n *\n *  The rule is intentionally narrow — separators / `..` / NUL /\n *  empty — so it only rejects unambiguous violations. Aesthetic\n *  concerns (e.g. dot-prefixed filenames) are out of scope: a\n *  pre-existing `data/wiki/pages/.foo.md` should remain writable\n *  through the chokepoint (codex review iter-2 #883). */\nexport function isSafeSlug(slug: string): boolean {\n  if (slug.length === 0) return false;\n  if (slug === \".\" || slug === \"..\") return false;\n  if (slug.includes(\"/\") || slug.includes(\"\\\\\")) return false;\n  if (slug.includes(\"\\0\")) return false;\n  return true;\n}\n\n/** Slug rules for `[[wiki link]]` text → slug derivation:\n *  lowercase, spaces collapsed to hyphens, every non-ASCII /\n *  non-alphanumeric / non-hyphen character stripped.\n *\n *  Pure: no normalisation, no transliteration — this is the\n *  same shape the index parser, page resolver, and frontend\n *  renderer all need to agree on. Non-ASCII titles (e.g.\n *  Japanese) collapse to an empty string here; callers fall back\n *  to other strategies (title-match in the index, or the agent\n *  pre-resolving to a slug-form target via `[[slug|display]]`). */\nexport function wikiSlugify(text: string): string {\n  return text\n    .toLowerCase()\n    .replace(/\\s+/g, \"-\")\n    .replace(/[^a-z0-9-]/g, \"\");\n}\n"],"mappings":";;;;;;;;;;;;;AA8BA,SAAgB,WAAW,MAAuB;CAChD,IAAI,KAAK,WAAW,GAAG,OAAO;CAC9B,IAAI,SAAS,OAAO,SAAS,MAAM,OAAO;CAC1C,IAAI,KAAK,SAAS,GAAG,KAAK,KAAK,SAAS,IAAI,GAAG,OAAO;CACtD,IAAI,KAAK,SAAS,IAAI,GAAG,OAAO;CAChC,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,YAAY,MAAsB;CAChD,OAAO,KACJ,YAAY,CAAC,CACb,QAAQ,QAAQ,GAAG,CAAC,CACpB,QAAQ,eAAe,EAAE;AAC9B"}

package/dist/wiki/graph.d.ts

@@ -0,0 +1,33 @@
+import { WikiPageEntry } from './index-parse.js';
+export interface WikiGraphNode {
+    slug: string;
+    title: string;
+}
+export interface WikiGraphEdge {
+    from: string;
+    to: string;
+}
+export interface WikiGraph {
+    nodes: WikiGraphNode[];
+    edges: WikiGraphEdge[];
+}
+/** One page's raw body plus its canonical (file-derived) slug. */
+export interface WikiPageContent {
+    slug: string;
+    content: string;
+}
+/** Resolve a raw `[[link]]` target to an existing page slug, or null.
+ *  Mirrors the route resolver's strategy: slugify first, then fall
+ *  back to matching an index entry title so non-ASCII targets like
+ *  `[[さくらインターネット]]` resolve to their ASCII file slug. */
+export declare function resolveLinkTarget(target: string, fileSlugs: ReadonlySet<string>, slugByTitle: ReadonlyMap<string, string>): string | null;
+/** Resolved, deduped outgoing slugs for one page body. Self-links and
+ *  links to non-existent pages are dropped (the latter are already a
+ *  lint "broken link", not a graph edge). */
+export declare function pageOutgoingSlugs(fromSlug: string, content: string, fileSlugs: ReadonlySet<string>, slugByTitle: ReadonlyMap<string, string>): string[];
+/** Build the full page→page graph. Nodes are the existing page files
+ *  (titled from index.md, falling back to the slug for un-indexed
+ *  pages); edges are the resolved `[[links]]`, deduped per (from,to). */
+export declare function buildWikiGraph(pages: readonly WikiPageContent[], entries: readonly WikiPageEntry[]): WikiGraph;
+/** Pages that link TO `slug` (incoming edges), deduped, as nodes. */
+export declare function incomingLinks(graph: WikiGraph, slug: string): WikiGraphNode[];

package/dist/wiki/index-parse.d.ts

@@ -0,0 +1,39 @@
+export interface WikiPageEntry {
+    title: string;
+    slug: string;
+    description: string;
+    tags: string[];
+}
+export declare const BULLET_LINK_PATTERN: RegExp;
+export declare const BULLET_WIKI_LINK_PATTERN: RegExp;
+/** Extract `#tag` tokens from a bullet description, returning the
+ *  stripped description and a sorted, deduped, lowercased tag list.
+ *  Only matches at word boundaries so mid-word `#` (e.g. anchor
+ *  URLs) is left alone. */
+export declare function extractHashTags(text: string): {
+    description: string;
+    tags: string[];
+};
+/** Split a table Tags cell — tolerates comma, whitespace, or `#`
+ *  prefixes. Empty cell yields an empty list. */
+export declare function parseTagsCell(cell: string): string[];
+/** Map header cell names → column indices, case- and whitespace-
+ *  tolerant. Used by the row parser to locate the Tags column (and
+ *  any other named column) without assuming a fixed position, so
+ *  older 3- and 4-column tables keep working. */
+export declare function buildTableColumnMap(headerRow: string): Map<string, number>;
+/** Extract the slug segment from a bullet link's href. Accepts the
+ *  canonical `pages/<slug>.md`, a bare `<slug>.md`, or just `<slug>`
+ *  — the three forms produced by different historical writers of
+ *  index.md. Returns "" for hrefs that don't look like a wiki page
+ *  reference (e.g. `https://example.com`) so the caller can fall
+ *  back to title-based slugification. */
+export declare function extractSlugFromBulletHref(rawHref: string): string;
+/** Parse entries from index.md. Supports three formats:
+ *  1. Table: `| slug | Title | Summary | (Tags) |`
+ *  2. Bullet link: `- [Title](pages/slug.md) — description`
+ *  3. Wiki link: `- [[Title]] — description`
+ *
+ *  Returns entries in source order. Any unrecognised line is
+ *  silently skipped — index.md is freeform markdown otherwise. */
+export declare function parseIndexEntries(content: string): WikiPageEntry[];

package/dist/wiki/index.cjs

@@ -0,0 +1,493 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_slug = require("../slug-DbwORN9z.cjs");
+//#region src/wiki/link.ts
+/** Inline `[[...]]` link pattern. The capture group is the raw
+*  text between the brackets — the caller is expected to feed it
+*  through `parseWikiLink` to split off any `|display` suffix.
+*
+*  Body length is capped at 200 chars to keep the regex linear:
+*  catastrophic backtracking isn't possible (no nested
+*  alternation), but a malicious page with thousands of
+*  unmatched `[[` could still pin the CPU. 200 is well above the
+*  longest legitimate title we've seen and matches the cap the
+*  server-side `WIKI_LINK_PATTERN` constant has carried since the
+*  original implementation in #951. */
+var WIKI_LINK_PATTERN = /\[\[([^\][\r\n]{1,200})\]\]/g;
+/** Split the raw text inside `[[...]]` into target + display.
+*
+*  - `[[foo|Bar Baz]]` → `{ target: "foo", display: "Bar Baz" }`
+*  - `[[foo]]`         → `{ target: "foo", display: "foo" }`
+*  - `[[|empty target]]` → `{ target: "", display: "empty target" }`
+*    (caller decides whether an empty target is meaningful;
+*    typically lint flags it, renderer shows the display text raw)
+*  - `[[foo|]]`        → `{ target: "foo", display: "" }`
+*    (same — caller decides)
+*
+*  Whitespace around the pipe is preserved on the display side
+*  (so the user can write `[[foo| ある記事 ]]` and get the
+*  spacing intentionally) but TRIMMED on the target side, since
+*  a slug-comparable target with leading/trailing whitespace is
+*  always a typo.
+*
+*  Only the FIRST pipe splits. `[[a|b|c]]` becomes
+*  `{ target: "a", display: "b|c" }` so display strings can
+*  legitimately contain a literal `|`. */
+function parseWikiLink(inner) {
+	const pipeIdx = inner.indexOf("|");
+	if (pipeIdx === -1) return {
+		target: inner,
+		display: inner
+	};
+	return {
+		target: inner.slice(0, pipeIdx).trim(),
+		display: inner.slice(pipeIdx + 1)
+	};
+}
+//#endregion
+//#region src/wiki/index-parse.ts
+var BULLET_LINK_PATTERN = /^[-*]\s+\[([^\]]+)\]\(([^)]*)\)(?:\s*[—–-]\s*(.*))?/;
+var BULLET_WIKI_LINK_PATTERN = /^[-*]\s+\[\[([^\]]+)\]\](?:\s*[—–-]\s*(.*))?/;
+var TABLE_SEPARATOR_PATTERN = /^\|[\s|:-]+\|$/;
+var HASHTAG_PATTERN = /(?:^|\s)#([\p{L}\p{N}][\p{L}\p{N}_-]*)/gu;
+/** Extract `#tag` tokens from a bullet description, returning the
+*  stripped description and a sorted, deduped, lowercased tag list.
+*  Only matches at word boundaries so mid-word `#` (e.g. anchor
+*  URLs) is left alone. */
+function extractHashTags(text) {
+	const tags = [];
+	HASHTAG_PATTERN.lastIndex = 0;
+	let match;
+	while ((match = HASHTAG_PATTERN.exec(text)) !== null) tags.push(match[1].toLowerCase());
+	return {
+		description: text.replace(HASHTAG_PATTERN, "").replace(/\s+/g, " ").trim(),
+		tags: [...new Set(tags)].sort()
+	};
+}
+/** Split a table Tags cell — tolerates comma, whitespace, or `#`
+*  prefixes. Empty cell yields an empty list. */
+function parseTagsCell(cell) {
+	const tokens = cell.split(/[,\s]+/).map((token) => token.trim().replace(/^#/, "").toLowerCase()).filter((token) => token.length > 0);
+	return [...new Set(tokens)].sort();
+}
+/** Map header cell names → column indices, case- and whitespace-
+*  tolerant. Used by the row parser to locate the Tags column (and
+*  any other named column) without assuming a fixed position, so
+*  older 3- and 4-column tables keep working. */
+function buildTableColumnMap(headerRow) {
+	const cells = headerRow.split("|").slice(1, -1).map((cell) => cell.trim().replace(/^`|`$/g, "").toLowerCase());
+	const map = /* @__PURE__ */ new Map();
+	cells.forEach((cell, i) => {
+		if (cell) map.set(cell, i);
+	});
+	return map;
+}
+/** Resolve the per-column indices the row parser needs. Falls back
+*  to positional defaults (0/1/2) when the table has no header map.
+*  "summary" is the canonical column name; "description" is accepted
+*  as a legacy alias used by older fixtures. */
+function resolveTableColumnIndices(columnMap) {
+	return {
+		slug: columnMap?.get("slug") ?? 0,
+		title: columnMap?.get("title") ?? 1,
+		summary: columnMap?.get("summary") ?? columnMap?.get("description") ?? 2,
+		tags: columnMap?.get("tags")
+	};
+}
+function parseTableRow(trimmed, columnMap) {
+	const cols = trimmed.split("|").slice(1, -1).map((column) => column.trim().replace(/^`|`$/g, ""));
+	if (cols.length < 2) return null;
+	const idx = resolveTableColumnIndices(columnMap);
+	const slug = cols[idx.slug] ?? "";
+	const title = cols[idx.title] || slug;
+	if (!slug || !title) return null;
+	return {
+		title,
+		slug,
+		description: cols[idx.summary] ?? "",
+		tags: idx.tags !== void 0 ? parseTagsCell(cols[idx.tags] ?? "") : []
+	};
+}
+/** Extract the slug segment from a bullet link's href. Accepts the
+*  canonical `pages/<slug>.md`, a bare `<slug>.md`, or just `<slug>`
+*  — the three forms produced by different historical writers of
+*  index.md. Returns "" for hrefs that don't look like a wiki page
+*  reference (e.g. `https://example.com`) so the caller can fall
+*  back to title-based slugification. */
+function extractSlugFromBulletHref(rawHref) {
+	const href = rawHref.trim();
+	if (!href) return "";
+	if (/^[a-z]+:\/\//i.test(href)) return "";
+	return (href.split("/").pop() ?? href).replace(/\.md$/i, "");
+}
+function parseBulletLinkRow(trimmed) {
+	const match = BULLET_LINK_PATTERN.exec(trimmed);
+	if (!match) return null;
+	const title = match[1].trim();
+	const href = match[2] ?? "";
+	const { description, tags } = extractHashTags(match[3]?.trim() ?? "");
+	return {
+		title,
+		slug: extractSlugFromBulletHref(href) || require_slug.wikiSlugify(title),
+		description,
+		tags
+	};
+}
+function parseBulletWikiLinkRow(trimmed) {
+	const match = BULLET_WIKI_LINK_PATTERN.exec(trimmed);
+	if (!match) return null;
+	const { target, display } = parseWikiLink(match[1]);
+	const title = (display || target).trim();
+	const slug = target ? require_slug.wikiSlugify(target) : require_slug.wikiSlugify(title);
+	const { description, tags } = extractHashTags(match[2]?.trim() ?? "");
+	return {
+		title,
+		slug,
+		description,
+		tags
+	};
+}
+/** Parse entries from index.md. Supports three formats:
+*  1. Table: `| slug | Title | Summary | (Tags) |`
+*  2. Bullet link: `- [Title](pages/slug.md) — description`
+*  3. Wiki link: `- [[Title]] — description`
+*
+*  Returns entries in source order. Any unrecognised line is
+*  silently skipped — index.md is freeform markdown otherwise. */
+function parseIndexEntries(content) {
+	const entries = [];
+	let inTable = false;
+	let columnMap = null;
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("|")) {
+			if (TABLE_SEPARATOR_PATTERN.test(trimmed)) {
+				inTable = true;
+				continue;
+			}
+			if (!inTable) {
+				columnMap = buildTableColumnMap(trimmed);
+				inTable = true;
+				continue;
+			}
+			const entry = parseTableRow(trimmed, columnMap);
+			if (entry) entries.push(entry);
+			continue;
+		}
+		inTable = false;
+		columnMap = null;
+		const bullet = parseBulletLinkRow(trimmed) ?? parseBulletWikiLinkRow(trimmed);
+		if (bullet) entries.push(bullet);
+	}
+	return entries;
+}
+//#endregion
+//#region src/wiki/lint.ts
+/** Files on disk that aren't referenced by index.md. */
+function findOrphanPages(fileSlugs, indexedSlugs) {
+	const issues = [];
+	for (const slug of fileSlugs) if (!indexedSlugs.has(slug)) issues.push(`- **Orphan page**: \`${slug}.md\` exists but is missing from index.md`);
+	return issues;
+}
+/** Slugs referenced by index.md that have no corresponding file. */
+function findMissingFiles(pageEntries, fileSlugs) {
+	const issues = [];
+	for (const entry of pageEntries) if (!fileSlugs.has(entry.slug)) issues.push(`- **Missing file**: index.md references \`${entry.slug}\` but the file does not exist`);
+	return issues;
+}
+/** Walk a page's body for `[[…]]` links and flag any whose
+*  resolved slug doesn't exist in the file set.
+*
+*  Critically: this routes through `parseWikiLink` so
+*  `[[slug|display]]` is split correctly — the lint slugifies the
+*  TARGET, not the full bracket body. Pre-#1297 the lint
+*  slugified the entire content (`slug|display`), which collapsed
+*  to a slug that always missed and produced ~168 false-positive
+*  "broken link" warnings. */
+function findBrokenLinksInPage(fileName, content, fileSlugs) {
+	const issues = [];
+	const matches = [...content.matchAll(WIKI_LINK_PATTERN)];
+	for (const match of matches) {
+		const { target } = parseWikiLink(match[1]);
+		const linkSlug = require_slug.wikiSlugify(target);
+		if (linkSlug.length === 0) {
+			issues.push(`- **Broken link** in \`${fileName}\`: [[${match[1]}]] → empty target`);
+			continue;
+		}
+		if (!fileSlugs.has(linkSlug)) issues.push(`- **Broken link** in \`${fileName}\`: [[${match[1]}]] → \`${linkSlug}.md\` not found`);
+	}
+	return issues;
+}
+function formatTagList(tags) {
+	return `[${[...tags].sort().join(", ")}]`;
+}
+/** Flag any slug whose index.md tags differ from the page's own
+*  frontmatter `tags:` field. Comparison is set-based and order-
+*  insensitive; both sides are lowercased at parse time. Slugs
+*  missing from `frontmatterTagsBySlug` are ignored here — the
+*  missing file itself is already reported by `findMissingFiles`. */
+function findTagDrift(pageEntries, frontmatterTagsBySlug) {
+	const issues = [];
+	for (const entry of pageEntries) {
+		const pageTags = frontmatterTagsBySlug.get(entry.slug.toLowerCase());
+		if (pageTags === void 0) continue;
+		const pageSet = new Set(pageTags);
+		const indexSet = new Set(entry.tags);
+		if (pageSet.size !== indexSet.size || [...pageSet].some((tag) => !indexSet.has(tag))) issues.push(`- **Tag drift**: \`${entry.slug}.md\` frontmatter has ${formatTagList(pageTags)} but index.md has ${formatTagList(entry.tags)}`);
+	}
+	return issues;
+}
+/** Render the final markdown report from the accumulated issues
+*  list. Empty input yields the "wiki is healthy" sentinel so the
+*  caller can write the same file every time without branching on
+*  presence. */
+function formatLintReport(issues) {
+	if (issues.length === 0) return "# Wiki Lint Report\n\n✓ No issues found. Wiki is healthy.";
+	const noun = `issue${issues.length !== 1 ? "s" : ""}`;
+	return `# Wiki Lint Report\n\n${issues.length} ${noun} found:\n\n${issues.join("\n")}`;
+}
+//#endregion
+//#region src/wiki/graph.ts
+/** Resolve a raw `[[link]]` target to an existing page slug, or null.
+*  Mirrors the route resolver's strategy: slugify first, then fall
+*  back to matching an index entry title so non-ASCII targets like
+*  `[[さくらインターネット]]` resolve to their ASCII file slug. */
+function resolveLinkTarget(target, fileSlugs, slugByTitle) {
+	const slug = require_slug.wikiSlugify(target);
+	if (slug.length > 0 && fileSlugs.has(slug)) return slug;
+	const byTitle = slugByTitle.get(target.trim());
+	if (byTitle !== void 0 && fileSlugs.has(byTitle)) return byTitle;
+	return null;
+}
+/** Resolved, deduped outgoing slugs for one page body. Self-links and
+*  links to non-existent pages are dropped (the latter are already a
+*  lint "broken link", not a graph edge). */
+function pageOutgoingSlugs(fromSlug, content, fileSlugs, slugByTitle) {
+	const out = /* @__PURE__ */ new Set();
+	for (const match of content.matchAll(WIKI_LINK_PATTERN)) {
+		const { target } = parseWikiLink(match[1]);
+		const resolved = resolveLinkTarget(target, fileSlugs, slugByTitle);
+		if (resolved !== null && resolved !== fromSlug) out.add(resolved);
+	}
+	return [...out];
+}
+function buildTitleMaps(entries) {
+	const titleBySlug = /* @__PURE__ */ new Map();
+	const slugByTitle = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!titleBySlug.has(entry.slug)) titleBySlug.set(entry.slug, entry.title);
+		if (entry.title.length > 0 && !slugByTitle.has(entry.title)) slugByTitle.set(entry.title, entry.slug);
+	}
+	return {
+		titleBySlug,
+		slugByTitle
+	};
+}
+/** Build the full page→page graph. Nodes are the existing page files
+*  (titled from index.md, falling back to the slug for un-indexed
+*  pages); edges are the resolved `[[links]]`, deduped per (from,to). */
+function buildWikiGraph(pages, entries) {
+	const fileSlugs = new Set(pages.map((page) => page.slug));
+	const { titleBySlug, slugByTitle } = buildTitleMaps(entries);
+	const nodes = pages.map((page) => ({
+		slug: page.slug,
+		title: titleBySlug.get(page.slug) ?? page.slug
+	}));
+	const edges = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const page of pages) for (const toSlug of pageOutgoingSlugs(page.slug, page.content, fileSlugs, slugByTitle)) {
+		const key = [page.slug, toSlug].join("\n");
+		if (seen.has(key)) continue;
+		seen.add(key);
+		edges.push({
+			from: page.slug,
+			to: toSlug
+		});
+	}
+	return {
+		nodes,
+		edges
+	};
+}
+/** Pages that link TO `slug` (incoming edges), deduped, as nodes. */
+function incomingLinks(graph, slug) {
+	const nodeBySlug = new Map(graph.nodes.map((node) => [node.slug, node]));
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const edge of graph.edges) {
+		if (edge.to !== slug || seen.has(edge.from)) continue;
+		seen.add(edge.from);
+		const node = nodeBySlug.get(edge.from);
+		if (node) result.push(node);
+	}
+	return result;
+}
+//#endregion
+//#region src/wiki/route.ts
+var WIKI_ROUTE_SECTION = {
+	pages: "pages",
+	log: "log",
+	lintReport: "lint-report",
+	graph: "graph"
+};
+var WIKI_ACTION = {
+	index: "index",
+	page: "page",
+	log: "log",
+	lintReport: "lint_report",
+	graph: "graph",
+	save: "save"
+};
+function isSafeWikiSlug(value) {
+	return typeof value === "string" && require_slug.isSafeSlug(value);
+}
+function readWikiRouteTarget(params) {
+	if (!params || typeof params !== "object") return null;
+	const { section, slug } = params;
+	if (section === void 0 || section === "") return { kind: "index" };
+	if (section === WIKI_ROUTE_SECTION.pages) {
+		if (!isSafeWikiSlug(slug)) return null;
+		return {
+			kind: "page",
+			slug
+		};
+	}
+	if (section === WIKI_ROUTE_SECTION.log) return { kind: "log" };
+	if (section === WIKI_ROUTE_SECTION.lintReport) return { kind: "lint_report" };
+	if (section === WIKI_ROUTE_SECTION.graph) return { kind: "graph" };
+	return null;
+}
+function buildWikiRouteParams(target) {
+	switch (target.kind) {
+		case "index": return {
+			section: "",
+			slug: ""
+		};
+		case "page": return {
+			section: WIKI_ROUTE_SECTION.pages,
+			slug: target.slug
+		};
+		case "log": return {
+			section: WIKI_ROUTE_SECTION.log,
+			slug: ""
+		};
+		case "lint_report": return {
+			section: WIKI_ROUTE_SECTION.lintReport,
+			slug: ""
+		};
+		case "graph": return {
+			section: WIKI_ROUTE_SECTION.graph,
+			slug: ""
+		};
+		default: throw new Error(`unreachable WikiTarget kind: ${JSON.stringify(target)}`);
+	}
+}
+function wikiActionFor(target) {
+	switch (target.kind) {
+		case "index": return WIKI_ACTION.index;
+		case "page": return WIKI_ACTION.page;
+		case "log": return WIKI_ACTION.log;
+		case "lint_report": return WIKI_ACTION.lintReport;
+		case "graph": return WIKI_ACTION.graph;
+		default: throw new Error(`unreachable WikiTarget kind: ${JSON.stringify(target)}`);
+	}
+}
+//#endregion
+//#region src/wiki/render.ts
+/** HTML-escape attribute / text content. Self-contained on purpose:
+*  this package can't reach the host's escaper, and the rule is a
+*  fixed five-char map. */
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (char) => {
+		switch (char) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "\"": return "&quot;";
+			default: return "&#39;";
+		}
+	});
+}
+/**
+* Replace every `[[page name]]` occurrence in `content` with a
+* `<span class="wiki-link" data-page="…">…</span>` element. The
+* page name may not contain `]`; an opening `[[` that is not
+* followed later by `]]` (with no bare `]` in between) is left
+* untouched so malformed text renders as-is — matching the
+* previous regex's non-match behaviour.
+*
+* `[[target|display]]` is split via the shared `parseWikiLink`
+* helper so `data-page` carries only the target slug while the
+* visible text shows the display half (#1297). Both halves are
+* HTML-escaped before interpolation — `parseWikiLink` runs BEFORE
+* the host's `marked.parse`, so escaping has to happen here.
+*/
+function renderWikiLinks(content) {
+	const out = [];
+	let i = 0;
+	while (i < content.length) {
+		if (content[i] === "[" && content[i + 1] === "[") {
+			const closeStart = findNextCloseBrackets(content, i + 2);
+			if (closeStart !== -1) {
+				const { target, display } = parseWikiLink(content.slice(i + 2, closeStart));
+				out.push(`<span class="wiki-link" data-page="${escapeHtml(target)}">${escapeHtml(display)}</span>`);
+				i = closeStart + 2;
+				continue;
+			}
+		}
+		out.push(content[i]);
+		i++;
+	}
+	return out.join("");
+}
+/**
+* Starting at `from`, scan forward for a `]]` sequence. Returns
+* the index of the first `]` of that pair, or -1 if a bare `]`
+* (one not immediately followed by a second `]`) is encountered
+* first — mirroring the old regex's `[^\]]+` constraint that the
+* page name must contain no `]` characters. Also returns -1 if
+* nothing matched before the end of input, or if the pair sits
+* immediately after `from` (zero-length page name, which the old
+* regex rejected via the `+` quantifier).
+*/
+function findNextCloseBrackets(str, from) {
+	let j = from;
+	while (j < str.length) {
+		if (str[j] === "]") {
+			if (str[j + 1] === "]" && j > from) return j;
+			return -1;
+		}
+		j++;
+	}
+	return -1;
+}
+//#endregion
+exports.BULLET_LINK_PATTERN = BULLET_LINK_PATTERN;
+exports.BULLET_WIKI_LINK_PATTERN = BULLET_WIKI_LINK_PATTERN;
+exports.WIKI_ACTION = WIKI_ACTION;
+exports.WIKI_LINK_PATTERN = WIKI_LINK_PATTERN;
+exports.WIKI_ROUTE_SECTION = WIKI_ROUTE_SECTION;
+exports.buildTableColumnMap = buildTableColumnMap;
+exports.buildWikiGraph = buildWikiGraph;
+exports.buildWikiRouteParams = buildWikiRouteParams;
+exports.escapeHtml = escapeHtml;
+exports.extractHashTags = extractHashTags;
+exports.extractSlugFromBulletHref = extractSlugFromBulletHref;
+exports.findBrokenLinksInPage = findBrokenLinksInPage;
+exports.findMissingFiles = findMissingFiles;
+exports.findOrphanPages = findOrphanPages;
+exports.findTagDrift = findTagDrift;
+exports.formatLintReport = formatLintReport;
+exports.incomingLinks = incomingLinks;
+exports.isSafeSlug = require_slug.isSafeSlug;
+exports.isSafeWikiSlug = isSafeWikiSlug;
+exports.pageOutgoingSlugs = pageOutgoingSlugs;
+exports.parseIndexEntries = parseIndexEntries;
+exports.parseTagsCell = parseTagsCell;
+exports.parseWikiLink = parseWikiLink;
+exports.readWikiRouteTarget = readWikiRouteTarget;
+exports.renderWikiLinks = renderWikiLinks;
+exports.resolveLinkTarget = resolveLinkTarget;
+exports.wikiActionFor = wikiActionFor;
+exports.wikiSlugify = require_slug.wikiSlugify;
+
+//# sourceMappingURL=index.cjs.map