@abraca/wiki 2.27.0

package/dist/abracadabra-wiki.esm.js

@@ -0,0 +1,1387 @@
+#!/usr/bin/env node
+import wtf from "wtf_wikipedia";
+import wtfApiPlugin from "wtf-plugin-api";
+import { DocumentManager } from "@abraca/dabra";
+import * as ed from "@noble/ed25519";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+//#region packages/wiki/src/parser.ts
+/**
+* Parse CLI arguments into a structured object.
+* @param argv Raw `process.argv` (includes node path and script path).
+*/
+function parseArgs(argv) {
+	const args = argv.slice(2);
+	const result = {
+		positional: [],
+		params: {},
+		flags: /* @__PURE__ */ new Set()
+	};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--")) {
+			const stripped = arg.slice(2);
+			const eqIdx = stripped.indexOf("=");
+			if (eqIdx !== -1) result.params[stripped.slice(0, eqIdx)] = stripped.slice(eqIdx + 1);
+			else result.flags.add(stripped);
+			continue;
+		}
+		const eqIdx = arg.indexOf("=");
+		if (eqIdx > 0) {
+			const key = arg.slice(0, eqIdx);
+			let value = arg.slice(eqIdx + 1);
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+			result.params[key] = value;
+			continue;
+		}
+		result.positional.push(arg);
+	}
+	return result;
+}
+
+//#endregion
+//#region packages/wiki/src/wikipedia.ts
+/**
+* Rate-limited wrapper around wtf_wikipedia + wtf-plugin-api.
+*
+* Responsibilities:
+*   - Throttle requests to respect Wikimedia API etiquette
+*   - Cache parsed Documents by canonical title
+*   - Resolve redirects so callers always see the redirect target
+*   - Expose getCategoryPages via wtf-plugin-api
+*/
+let pluginExtended = false;
+function ensurePlugin() {
+	if (pluginExtended) return;
+	wtf.extend(wtfApiPlugin);
+	pluginExtended = true;
+}
+/** A token-bucket-ish throttle: at most `rate` calls per second, FIFO. */
+var RateLimiter = class {
+	lastTickMs = 0;
+	constructor(intervalMs) {
+		this.intervalMs = intervalMs;
+	}
+	async wait() {
+		const now = Date.now();
+		const earliest = this.lastTickMs + this.intervalMs;
+		if (now < earliest) await new Promise((r) => setTimeout(r, earliest - now));
+		this.lastTickMs = Math.max(now, earliest);
+	}
+};
+var WikipediaClient = class {
+	cache = /* @__PURE__ */ new Map();
+	redirects = /* @__PURE__ */ new Map();
+	limiter;
+	fetchOpts;
+	constructor(config) {
+		this.config = config;
+		ensurePlugin();
+		this.limiter = new RateLimiter(Math.max(50, Math.floor(1e3 / Math.max(.1, config.rate))));
+		this.fetchOpts = {
+			lang: config.lang,
+			"Api-User-Agent": config.userAgent,
+			follow_redirects: true
+		};
+		if (config.domain) this.fetchOpts.domain = config.domain;
+	}
+	/**
+	* Fetch and parse a Wikipedia article.
+	* - Returns the cached Document if we've seen this title before.
+	* - Follows redirects and caches under both source and target titles.
+	* - Returns null when the page does not exist.
+	*/
+	async fetchArticle(rawTitle) {
+		const title = canonicalTitle(rawTitle);
+		if (this.cache.has(title)) return this.cache.get(title);
+		if (this.redirects.has(title)) {
+			const target = this.redirects.get(title);
+			return this.cache.get(target) ?? null;
+		}
+		await this.limiter.wait();
+		let doc;
+		try {
+			doc = await wtf.fetch(title, this.fetchOpts);
+		} catch (err) {
+			throw new Error(`Wikipedia fetch failed for "${title}": ${err?.message ?? err}`);
+		}
+		if (!doc) return null;
+		if (typeof doc.isRedirect === "function" && doc.isRedirect()) {
+			const target = doc.redirectTo?.()?.page;
+			if (typeof target === "string") {
+				this.redirects.set(title, canonicalTitle(target));
+				return await this.fetchArticle(target);
+			}
+		}
+		const resolvedTitle = canonicalTitle(doc.title?.() ?? title);
+		this.cache.set(resolvedTitle, doc);
+		if (resolvedTitle !== title) this.redirects.set(title, resolvedTitle);
+		return doc;
+	}
+	/**
+	* Fetch the member pages of a category (and optionally sub-categories).
+	* @param category Category title (with or without "Category:" prefix).
+	* @param recursive Whether to traverse sub-categories.
+	* @param maxDepth Recursion depth when recursive=true.
+	*/
+	async fetchCategoryPages(category, recursive, maxDepth) {
+		await this.limiter.wait();
+		const opts = {
+			lang: this.config.lang,
+			"Api-User-Agent": this.config.userAgent,
+			recursive,
+			maxDepth
+		};
+		if (this.config.domain) opts.domain = this.config.domain;
+		return (await wtf.getCategoryPages(category, opts) ?? []).map((m) => ({
+			title: canonicalTitle(m.title),
+			type: m.type === "subcat" ? "subcat" : "page"
+		}));
+	}
+};
+/** Normalize a Wikipedia title — trim, collapse spaces, strip leading/trailing colons. */
+function canonicalTitle(s) {
+	return (s ?? "").toString().replace(/_/g, " ").replace(/\s+/g, " ").trim();
+}
+/** Detect a category-namespaced title. */
+const CATEGORY_PREFIX = /^(Category|Catégorie|Kategorie|Categoría|Categoria|Categorie|Kategoria):/i;
+function isCategoryTitle(title) {
+	return CATEGORY_PREFIX.test(title);
+}
+/** Strip the "Category:" prefix for display. */
+function stripCategoryPrefix(title) {
+	return title.replace(CATEGORY_PREFIX, "").trim();
+}
+
+//#endregion
+//#region packages/wiki/src/snapshot.ts
+function snapshotArticle(doc, title) {
+	return {
+		title,
+		linkTitles: collectLinkTitles(doc),
+		categories: collectCategories(doc),
+		sections: snapshotSections(doc.sections?.() ?? []),
+		infobox: snapshotInfobox(doc.infobox?.()),
+		lead: leadParagraph(doc),
+		url: typeof doc.url === "function" ? doc.url() : null
+	};
+}
+function prettyCategoryLabel(catTitle) {
+	return stripCategoryPrefix(catTitle);
+}
+function collectLinkTitles(doc) {
+	const links = doc.links?.() ?? [];
+	const out = /* @__PURE__ */ new Set();
+	for (const l of links) {
+		if (!l) continue;
+		const page = typeof l.page === "function" ? l.page() : null;
+		if (typeof page !== "string" || page.length === 0) continue;
+		if (isCategoryTitle(page)) continue;
+		out.add(canonicalTitle(page));
+	}
+	return [...out];
+}
+function collectCategories(doc) {
+	const out = [];
+	for (const c of doc.categories?.() ?? []) {
+		const norm = canonicalTitle(c);
+		if (norm) out.push(norm);
+	}
+	return out;
+}
+function snapshotSections(rawSections) {
+	const all = rawSections.map((s) => ({
+		raw: s,
+		title: s.title?.() || "",
+		parentRef: typeof s.parent === "function" ? s.parent() : null,
+		children: []
+	}));
+	const byRaw = /* @__PURE__ */ new Map();
+	for (const s of all) byRaw.set(s.raw, s);
+	const roots = [];
+	for (const s of all) if (s.parentRef && byRaw.has(s.parentRef)) byRaw.get(s.parentRef).children.push(materialize(s));
+	else roots.push(s);
+	return roots.map(materialize);
+}
+function materialize(node) {
+	const lists = node.raw.lists?.() ?? [];
+	const paragraphs = node.raw.paragraphs?.() ?? [];
+	let listLength = 0;
+	for (const l of lists) {
+		const lines = l.lines?.() ?? [];
+		listLength += lines.length;
+	}
+	const isList = lists.length > 0 && (paragraphs.length === 0 || listLength >= paragraphs.length * 2);
+	const bodyParts = [];
+	for (const p of paragraphs) {
+		const md = paragraphMarkdown(p);
+		if (md) bodyParts.push(md);
+	}
+	for (const l of lists) {
+		const lines = l.lines?.() ?? [];
+		for (const line of lines) {
+			const text = lineText(line);
+			if (text) bodyParts.push(`- ${text}`);
+		}
+	}
+	return {
+		title: node.title,
+		body: bodyParts.join("\n\n"),
+		isList,
+		listLength,
+		children: node.children
+	};
+}
+function snapshotInfobox(box) {
+	if (!box) return void 0;
+	const data = typeof box.json === "function" ? box.json() : null;
+	if (!data || typeof data !== "object") return void 0;
+	const rows = [];
+	for (const [key, val] of Object.entries(data)) {
+		const value = stringifyInfoboxValue(val);
+		if (!value) continue;
+		rows.push({
+			key: humanKey(key),
+			value
+		});
+	}
+	return rows.length > 0 ? rows : void 0;
+}
+function stringifyInfoboxValue(val) {
+	if (val == null) return "";
+	if (typeof val === "string") return val;
+	if (typeof val === "number" || typeof val === "boolean") return String(val);
+	if (Array.isArray(val)) return val.map(stringifyInfoboxValue).filter(Boolean).join(", ");
+	if (typeof val === "object") {
+		const o = val;
+		if (typeof o.text === "string") return o.text;
+		if (typeof o.number === "number") return String(o.number);
+	}
+	return "";
+}
+function humanKey(k) {
+	return k.replace(/_/g, " ").replace(/^./, (m) => m.toUpperCase());
+}
+function leadParagraph(doc) {
+	const first = (doc.paragraphs?.() ?? [])[0];
+	if (!first) return "";
+	return paragraphMarkdown(first);
+}
+/**
+* Render a paragraph as markdown, replacing internal links with `[[Title]]`.
+* The streaming orchestrator's link rewriter later swaps `[[Title]]` →
+* `[[docId|label]]` once IDs are known.
+*/
+function paragraphMarkdown(paragraph) {
+	const sentences = paragraph.sentences?.() ?? [];
+	const out = [];
+	for (const s of sentences) out.push(sentenceWithWikilinks(s));
+	return out.join(" ").trim();
+}
+function sentenceWithWikilinks(sentence) {
+	const text = (sentence.text?.() ?? "").toString();
+	const links = sentence.links?.() ?? [];
+	if (links.length === 0) return text;
+	let result = text;
+	const replacements = links.map((l) => {
+		const page = typeof l.page === "function" ? l.page() : null;
+		const display = typeof l.text === "function" ? l.text() : null;
+		if (typeof page !== "string" || page.length === 0) return null;
+		if (isCategoryTitle(page)) return null;
+		const shown = display && display.length > 0 ? display : page;
+		return {
+			page: canonicalTitle(page),
+			shown
+		};
+	}).filter((x) => x !== null).sort((a, b) => b.shown.length - a.shown.length);
+	for (const { page, shown } of replacements) {
+		if (!result.includes(shown)) continue;
+		const replacement = shown === page ? `[[${page}]]` : `[[${page}|${shown}]]`;
+		result = result.replace(shown, replacement);
+	}
+	return result;
+}
+function lineText(line) {
+	if (!line) return "";
+	if (typeof line === "string") return line;
+	if (typeof line.text === "string") return line.text;
+	if (typeof line.text === "function") return line.text();
+	return "";
+}
+
+//#endregion
+//#region packages/wiki/src/render.ts
+const ICONS = {
+	graph: "git-fork",
+	article: "book-open",
+	category: "tag",
+	infobox: "info",
+	outline: "list",
+	gallery: "images",
+	section: "pilcrow",
+	categories: "tags"
+};
+/** Decide a page type for a section based on its shape. */
+function pickSectionType(section) {
+	if (section.children.length > 0) return {
+		type: "outline",
+		icon: ICONS.outline
+	};
+	if (section.isList && section.listLength >= 5) return {
+		type: "outline",
+		icon: ICONS.outline
+	};
+	return {
+		type: "doc",
+		icon: ICONS.section
+	};
+}
+/** Render the lead paragraph as the article-doc body. */
+function renderArticleLead(article) {
+	return article.lead ?? "";
+}
+/** Render the article as a single doc, sections + infobox inlined. */
+function renderArticleSingleDoc(article) {
+	const parts = [];
+	if (article.lead) parts.push(article.lead);
+	if (article.infobox && article.infobox.length > 0) parts.push("## Infobox", renderInfoboxBody(article.infobox));
+	for (const section of article.sections) parts.push(...renderSectionInline(section, 2));
+	return parts.join("\n\n");
+}
+function renderSectionInline(section, level) {
+	const out = [];
+	const prefix = "#".repeat(Math.min(6, level));
+	if (section.title) out.push(`${prefix} ${section.title}`);
+	if (section.body.trim()) out.push(section.body);
+	for (const child of section.children) out.push(...renderSectionInline(child, level + 1));
+	return out;
+}
+function renderInfoboxBody(rows) {
+	return rows.map((r) => `- **${r.key}:** ${r.value}`).join("\n");
+}
+function renderCategoryBody(members, subcategories) {
+	const parts = [];
+	if (members.length > 0) {
+		parts.push("## Pages");
+		parts.push(members.map((m) => `- [[${m}]]`).join("\n"));
+	}
+	if (subcategories.length > 0) {
+		parts.push("## Sub-categories");
+		parts.push(subcategories.map((s) => `- ${s}`).join("\n"));
+	}
+	return parts.join("\n\n");
+}
+/**
+* Replace `[[Title]]` / `[[Title|Alias]]` in markdown with
+* `[[docId|label]]` using the title→docId map. Unresolved titles fall
+* back to plain text (their alias or original title).
+*/
+function rewriteLinks(markdown, titleToDocId) {
+	return markdown.replace(/\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]/g, (_match, target, alias) => {
+		const title = target.trim();
+		const docId = titleToDocId.get(title);
+		const display = (alias && alias.trim().length > 0 ? alias : title).trim();
+		if (!docId) return display;
+		return `[[${docId}|${display}]]`;
+	});
+}
+
+//#endregion
+//#region node_modules/@noble/hashes/utils.js
+/**
+* Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.
+* @param a - value to test
+* @returns `true` when the value is a Uint8Array-compatible view.
+* @example
+* Check whether a value is a Uint8Array-compatible view.
+* ```ts
+* isBytes(new Uint8Array([1, 2, 3]));
+* ```
+*/
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+/**
+* Asserts something is Uint8Array.
+* @param value - value to validate
+* @param length - optional exact length constraint
+* @param title - label included in thrown errors
+* @returns The validated byte array.
+* @throws On wrong argument types. {@link TypeError}
+* @throws On wrong argument ranges or values. {@link RangeError}
+* @example
+* Validate that a value is a byte array.
+* ```ts
+* abytes(new Uint8Array([1, 2, 3]));
+* ```
+*/
+function abytes(value, length, title = "") {
+	const bytes = isBytes(value);
+	const len = value?.length;
+	const needsLen = length !== void 0;
+	if (!bytes || needsLen && len !== length) {
+		const prefix = title && `"${title}" `;
+		const ofLen = needsLen ? ` of length ${length}` : "";
+		const got = bytes ? `length=${len}` : `type=${typeof value}`;
+		const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+		if (!bytes) throw new TypeError(message);
+		throw new RangeError(message);
+	}
+	return value;
+}
+/**
+* Asserts a hash instance has not been destroyed or finished.
+* @param instance - hash instance to validate
+* @param checkFinished - whether to reject finalized instances
+* @throws If the hash instance has already been destroyed or finalized. {@link Error}
+* @example
+* Validate that a hash instance is still usable.
+* ```ts
+* import { aexists } from '@noble/hashes/utils.js';
+* import { sha256 } from '@noble/hashes/sha2.js';
+* const hash = sha256.create();
+* aexists(hash);
+* ```
+*/
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+}
+/**
+* Asserts output is a sufficiently-sized byte array.
+* @param out - destination buffer
+* @param instance - hash instance providing output length
+* Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.
+* @throws On wrong argument types. {@link TypeError}
+* @throws On wrong argument ranges or values. {@link RangeError}
+* @example
+* Validate a caller-provided digest buffer.
+* ```ts
+* import { aoutput } from '@noble/hashes/utils.js';
+* import { sha256 } from '@noble/hashes/sha2.js';
+* const hash = sha256.create();
+* aoutput(new Uint8Array(hash.outputLen), hash);
+* ```
+*/
+function aoutput(out, instance) {
+	abytes(out, void 0, "digestInto() output");
+	const min = instance.outputLen;
+	if (out.length < min) throw new RangeError("\"digestInto() output\" expected to be of length >=" + min);
+}
+/**
+* Zeroizes typed arrays in place. Warning: JS provides no guarantees.
+* @param arrays - arrays to overwrite with zeros
+* @example
+* Zeroize sensitive buffers in place.
+* ```ts
+* clean(new Uint8Array([1, 2, 3]));
+* ```
+*/
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/**
+* Creates a DataView for byte-level manipulation.
+* @param arr - source typed array
+* @returns DataView over the same buffer region.
+* @example
+* Create a DataView over an existing buffer.
+* ```ts
+* createView(new Uint8Array(4));
+* ```
+*/
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Whether the current platform is little-endian. */
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+/**
+* Creates a callable hash function from a stateful class constructor.
+* @param hashCons - hash constructor or factory
+* @param info - optional metadata such as DER OID
+* @returns Frozen callable hash wrapper with `.create()`.
+*   Wrapper construction eagerly calls `hashCons(undefined)` once to read
+*   `outputLen` / `blockLen`, so constructor side effects happen at module
+*   init time.
+* @example
+* Wrap a stateful hash constructor into a callable helper.
+* ```ts
+* import { createHasher } from '@noble/hashes/utils.js';
+* import { sha256 } from '@noble/hashes/sha2.js';
+* const wrapped = createHasher(sha256.create, { oid: sha256.oid });
+* wrapped(new Uint8Array([1]));
+* ```
+*/
+function createHasher(hashCons, info = {}) {
+	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+	const tmp = hashCons(void 0);
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.canXOF = tmp.canXOF;
+	hashC.create = (opts) => hashCons(opts);
+	Object.assign(hashC, info);
+	return Object.freeze(hashC);
+}
+/**
+* Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.
+* @param suffix - final OID byte for the selected hash.
+*   The helper accepts any byte even though only the documented NIST hash
+*   suffixes are meaningful downstream.
+* @returns Object containing the DER-encoded OID.
+* @example
+* Build OID metadata for a NIST hash.
+* ```ts
+* oidNist(0x01);
+* ```
+*/
+const oidNist = (suffix) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	suffix
+]) });
+
+//#endregion
+//#region node_modules/@noble/hashes/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+* Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit
+* strings with partial-byte tails.
+* @param blockLen - internal block size in bytes
+* @param outputLen - digest size in bytes
+* @param padOffset - trailing length field size in bytes
+* @param isLE - whether length and state words are encoded in little-endian
+* @example
+* Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.
+* ```ts
+* import { _SHA1 } from '@noble/hashes/legacy.js';
+* const hash = new _SHA1();
+* hash.update(new Uint8Array([97, 98, 99]));
+* hash.digest();
+* ```
+*/
+var HashMD = class {
+	blockLen;
+	outputLen;
+	canXOF = false;
+	padOffset;
+	isLE;
+	buffer;
+	view;
+	finished = false;
+	length = 0;
+	pos = 0;
+	destroyed = false;
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+			}
+		}
+		this.length += data.length;
+		this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		clean(this.buffer.subarray(pos));
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			pos = 0;
+		}
+		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+		view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+		this.process(view, 0);
+		const oview = createView(out);
+		const len = this.outputLen;
+		if (len % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
+		const outLen = len / 4;
+		const state = this.get();
+		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		to ||= new this.constructor();
+		to.set(...this.get());
+		const { blockLen, buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (length % blockLen) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/** Initial SHA512 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen
+* big-endian 32-bit halves. Derived from the fractional parts of the square roots of the first
+* eight prime numbers. Exported as a shared table; callers must treat it as read-only because
+* constructors copy halves from it by index. */
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]);
+
+//#endregion
+//#region node_modules/@noble/hashes/_u64.js
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	const len = lst.length;
+	let Ah = new Uint32Array(len);
+	let Al = new Uint32Array(len);
+	for (let i = 0; i < len; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
+	}
+	return [Ah, Al];
+}
+const shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+	const l = (Al >>> 0) + (Bl >>> 0);
+	return {
+		h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
+		l: l | 0
+	};
+}
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+//#endregion
+//#region node_modules/@noble/hashes/sha2.js
+/**
+* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+* Check out {@link https://www.rfc-editor.org/rfc/rfc4634 | RFC 4634} and
+* {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf | FIPS 180-4}.
+* @module
+*/
+const K512 = split([
+	"0x428a2f98d728ae22",
+	"0x7137449123ef65cd",
+	"0xb5c0fbcfec4d3b2f",
+	"0xe9b5dba58189dbbc",
+	"0x3956c25bf348b538",
+	"0x59f111f1b605d019",
+	"0x923f82a4af194f9b",
+	"0xab1c5ed5da6d8118",
+	"0xd807aa98a3030242",
+	"0x12835b0145706fbe",
+	"0x243185be4ee4b28c",
+	"0x550c7dc3d5ffb4e2",
+	"0x72be5d74f27b896f",
+	"0x80deb1fe3b1696b1",
+	"0x9bdc06a725c71235",
+	"0xc19bf174cf692694",
+	"0xe49b69c19ef14ad2",
+	"0xefbe4786384f25e3",
+	"0x0fc19dc68b8cd5b5",
+	"0x240ca1cc77ac9c65",
+	"0x2de92c6f592b0275",
+	"0x4a7484aa6ea6e483",
+	"0x5cb0a9dcbd41fbd4",
+	"0x76f988da831153b5",
+	"0x983e5152ee66dfab",
+	"0xa831c66d2db43210",
+	"0xb00327c898fb213f",
+	"0xbf597fc7beef0ee4",
+	"0xc6e00bf33da88fc2",
+	"0xd5a79147930aa725",
+	"0x06ca6351e003826f",
+	"0x142929670a0e6e70",
+	"0x27b70a8546d22ffc",
+	"0x2e1b21385c26c926",
+	"0x4d2c6dfc5ac42aed",
+	"0x53380d139d95b3df",
+	"0x650a73548baf63de",
+	"0x766a0abb3c77b2a8",
+	"0x81c2c92e47edaee6",
+	"0x92722c851482353b",
+	"0xa2bfe8a14cf10364",
+	"0xa81a664bbc423001",
+	"0xc24b8b70d0f89791",
+	"0xc76c51a30654be30",
+	"0xd192e819d6ef5218",
+	"0xd69906245565a910",
+	"0xf40e35855771202a",
+	"0x106aa07032bbd1b8",
+	"0x19a4c116b8d2d0c8",
+	"0x1e376c085141ab53",
+	"0x2748774cdf8eeb99",
+	"0x34b0bcb5e19b48a8",
+	"0x391c0cb3c5c95a63",
+	"0x4ed8aa4ae3418acb",
+	"0x5b9cca4f7763e373",
+	"0x682e6ff3d6b2b8a3",
+	"0x748f82ee5defb2fc",
+	"0x78a5636f43172f60",
+	"0x84c87814a1f0ab72",
+	"0x8cc702081a6439ec",
+	"0x90befffa23631e28",
+	"0xa4506cebde82bde9",
+	"0xbef9a3f7b2c67915",
+	"0xc67178f2e372532b",
+	"0xca273eceea26619c",
+	"0xd186b8c721c0c207",
+	"0xeada7dd6cde0eb1e",
+	"0xf57d4f7fee6ed178",
+	"0x06f067aa72176fba",
+	"0x0a637dc5a2c898a6",
+	"0x113f9804bef90dae",
+	"0x1b710b35131c471b",
+	"0x28db77f523047d84",
+	"0x32caab7b40c72493",
+	"0x3c9ebe0a15c9bebc",
+	"0x431d67c49c100d4c",
+	"0x4cc5d4becb3e42b6",
+	"0x597f299cfc657e2a",
+	"0x5fcb6fab3ad6faec",
+	"0x6c44198c4a475817"
+].map((n) => BigInt(n)));
+const SHA512_Kh = K512[0];
+const SHA512_Kl = K512[1];
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+/** Internal SHA-384 / SHA-512 compression engine from RFC 6234 §6.4. */
+var SHA2_64B = class extends HashMD {
+	constructor(outputLen) {
+		super(128, outputLen, 16, false);
+	}
+	get() {
+		const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		return [
+			Ah,
+			Al,
+			Bh,
+			Bl,
+			Ch,
+			Cl,
+			Dh,
+			Dl,
+			Eh,
+			El,
+			Fh,
+			Fl,
+			Gh,
+			Gl,
+			Hh,
+			Hl
+		];
+	}
+	set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+		this.Ah = Ah | 0;
+		this.Al = Al | 0;
+		this.Bh = Bh | 0;
+		this.Bl = Bl | 0;
+		this.Ch = Ch | 0;
+		this.Cl = Cl | 0;
+		this.Dh = Dh | 0;
+		this.Dl = Dl | 0;
+		this.Eh = Eh | 0;
+		this.El = El | 0;
+		this.Fh = Fh | 0;
+		this.Fl = Fl | 0;
+		this.Gh = Gh | 0;
+		this.Gl = Gl | 0;
+		this.Hh = Hh | 0;
+		this.Hl = Hl | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) {
+			SHA512_W_H[i] = view.getUint32(offset);
+			SHA512_W_L[i] = view.getUint32(offset += 4);
+		}
+		for (let i = 16; i < 80; i++) {
+			const W15h = SHA512_W_H[i - 15] | 0;
+			const W15l = SHA512_W_L[i - 15] | 0;
+			const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+			const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+			const W2h = SHA512_W_H[i - 2] | 0;
+			const W2l = SHA512_W_L[i - 2] | 0;
+			const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+			const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+			const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+			SHA512_W_H[i] = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]) | 0;
+			SHA512_W_L[i] = SUMl | 0;
+		}
+		let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		for (let i = 0; i < 80; i++) {
+			const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+			const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+			const CHIh = Eh & Fh ^ ~Eh & Gh;
+			const CHIl = El & Fl ^ ~El & Gl;
+			const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+			const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+			const T1l = T1ll | 0;
+			const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+			const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+			const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+			const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+			Hh = Gh | 0;
+			Hl = Gl | 0;
+			Gh = Fh | 0;
+			Gl = Fl | 0;
+			Fh = Eh | 0;
+			Fl = El | 0;
+			({h: Eh, l: El} = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+			Dh = Ch | 0;
+			Dl = Cl | 0;
+			Ch = Bh | 0;
+			Cl = Bl | 0;
+			Bh = Ah | 0;
+			Bl = Al | 0;
+			const All = add3L(T1l, sigma0l, MAJl);
+			Ah = add3H(All, T1h, sigma0h, MAJh);
+			Al = All | 0;
+		}
+		({h: Ah, l: Al} = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+		({h: Bh, l: Bl} = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+		({h: Ch, l: Cl} = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+		({h: Dh, l: Dl} = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+		({h: Eh, l: El} = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+		({h: Fh, l: Fl} = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+		({h: Gh, l: Gl} = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+		({h: Hh, l: Hl} = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+		this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+	}
+	roundClean() {
+		clean(SHA512_W_H, SHA512_W_L);
+	}
+	destroy() {
+		this.destroyed = true;
+		clean(this.buffer);
+		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+};
+/** Internal SHA-512 hash class grounded in RFC 6234 §6.3 and §6.4. */
+var _SHA512 = class extends SHA2_64B {
+	Ah = SHA512_IV[0] | 0;
+	Al = SHA512_IV[1] | 0;
+	Bh = SHA512_IV[2] | 0;
+	Bl = SHA512_IV[3] | 0;
+	Ch = SHA512_IV[4] | 0;
+	Cl = SHA512_IV[5] | 0;
+	Dh = SHA512_IV[6] | 0;
+	Dl = SHA512_IV[7] | 0;
+	Eh = SHA512_IV[8] | 0;
+	El = SHA512_IV[9] | 0;
+	Fh = SHA512_IV[10] | 0;
+	Fl = SHA512_IV[11] | 0;
+	Gh = SHA512_IV[12] | 0;
+	Gl = SHA512_IV[13] | 0;
+	Hh = SHA512_IV[14] | 0;
+	Hl = SHA512_IV[15] | 0;
+	constructor() {
+		super(64);
+	}
+};
+/**
+* SHA2-512 hash function from RFC 4634.
+* @param msg - message bytes to hash
+* @returns Digest bytes.
+* @example
+* Hash a message with SHA2-512.
+* ```ts
+* sha512(new Uint8Array([97, 98, 99]));
+* ```
+*/
+const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), /* @__PURE__ */ oidNist(3));
+
+//#endregion
+//#region packages/wiki/src/crypto.ts
+/**
+* Ed25519 key generation, persistence, and challenge signing for CLI auth.
+* Mirrors @abraca/mcp/src/crypto.ts — standalone to avoid MCP SDK dependency.
+*/
+ed.hashes.sha512 = sha512;
+ed.hashes.sha512Async = (m) => Promise.resolve(sha512(m));
+const DEFAULT_KEY_PATH = join(homedir(), ".abracadabra", "cli.key");
+function toBase64url(bytes) {
+	return Buffer.from(bytes).toString("base64url");
+}
+function fromBase64url(b64) {
+	return new Uint8Array(Buffer.from(b64, "base64url"));
+}
+/**
+* Load an existing Ed25519 keypair from disk, or generate and persist a new one.
+* The file stores the raw 32-byte private key seed.
+*/
+async function loadOrCreateKeypair(keyPath) {
+	const path = keyPath || DEFAULT_KEY_PATH;
+	if (existsSync(path)) {
+		const seed = await readFile(path);
+		if (seed.length !== 32) throw new Error(`Invalid key file at ${path}: expected 32 bytes, got ${seed.length}`);
+		const privateKey = new Uint8Array(seed);
+		return {
+			privateKey,
+			publicKeyB64: toBase64url(ed.getPublicKey(privateKey))
+		};
+	}
+	const privateKey = ed.utils.randomSecretKey();
+	const publicKey = ed.getPublicKey(privateKey);
+	const dir = dirname(path);
+	if (!existsSync(dir)) await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(path, Buffer.from(privateKey), { mode: 384 });
+	console.error(`[abracadabra] Generated new keypair at ${path}`);
+	console.error(`[abracadabra] Public key: ${toBase64url(publicKey)}`);
+	return {
+		privateKey,
+		publicKeyB64: toBase64url(publicKey)
+	};
+}
+/** Sign a base64url challenge with the private key; returns base64url signature. */
+function signChallenge(challengeB64, privateKey) {
+	const challenge = fromBase64url(challengeB64);
+	return toBase64url(ed.sign(challenge, privateKey));
+}
+
+//#endregion
+//#region packages/wiki/src/connect.ts
+/**
+* Open a DocumentManager session for the wiki command, mirroring the
+* auth/register flow that CLIConnection uses but using the modern public API.
+*
+* Reuses the CLI's Ed25519 keypair handling (loadOrCreateKeypair, signChallenge)
+* so the wiki command authenticates with the same identity as every other
+* subcommand.
+*/
+async function openSession(config) {
+	const keypair = await loadOrCreateKeypair(config.keyFile);
+	const sign = (challenge) => Promise.resolve(signChallenge(challenge, keypair.privateKey));
+	const dm = new DocumentManager({
+		url: config.url,
+		name: config.name ?? "Wiki Extractor",
+		color: config.color,
+		quiet: config.quiet
+	});
+	try {
+		await dm.client.loginWithKey(keypair.publicKeyB64, sign);
+	} catch (err) {
+		const status = err?.status ?? err?.response?.status;
+		if (status === 404 || status === 422) {
+			if (!config.quiet) console.error("[abracadabra] Key not registered, creating new account...");
+			await dm.client.registerWithKey({
+				publicKey: keypair.publicKeyB64,
+				username: (config.name ?? "wiki-extractor").replace(/\s+/g, "-").toLowerCase(),
+				displayName: config.name ?? "Wiki Extractor",
+				deviceName: "CLI Wiki",
+				inviteCode: config.inviteCode
+			});
+			await dm.client.loginWithKey(keypair.publicKeyB64, sign);
+		} else throw err;
+	}
+	await dm.connect();
+	const rootDocId = dm.rootDocId;
+	if (!rootDocId) throw new Error("Connected but no rootDocId — server has no spaces.");
+	return {
+		dm,
+		rootDocId
+	};
+}
+
+//#endregion
+//#region packages/wiki/src/index.ts
+const USAGE = [
+	"abracadabra-wiki \"<Article Title>\" user-agent=\"<name (email)>\" [options]",
+	"",
+	"Options:",
+	"  mode=single|split   single doc per article OR split into sections+infobox  [split]",
+	"  depth=<n>           follow internal links to depth N                       [1]",
+	"  category-depth=<n>  recurse into sub-categories                            [1]",
+	"  lang=<code>         wiki language                                          [en]",
+	"  domain=<host>       3rd-party MediaWiki host (overrides lang)",
+	"  parent=<docId>      parent doc for the new graph                           [active space root]",
+	"  user-agent=<str>    Api-User-Agent header (REQUIRED by Wikimedia etiquette)",
+	"  rate=<rps>          max wikipedia requests per second                      [3]",
+	"  --include-categories   expand each article's categories into nested graphs",
+	"  --dry-run              fetch only the entry article, print outline, no writes",
+	"",
+	"Environment: ABRA_URL (required unless --dry-run), ABRA_KEY_FILE, ABRA_NAME,",
+	"  ABRA_COLOR, ABRA_INVITE_CODE, ABRA_WIKI_USER_AGENT."
+].join("\n");
+/**
+* Run a Wikipedia import for already-parsed args. Returns a human-readable
+* summary (or an error/usage string). Exported for programmatic use.
+*/
+async function runWiki(args) {
+	const opts = parseOptions(args);
+	if (typeof opts === "string") return opts;
+	const log = (msg) => {
+		if (!args.flags.has("quiet") && !args.flags.has("q")) console.error(`[wiki] ${msg}`);
+	};
+	const wp = new WikipediaClient({
+		lang: opts.lang,
+		domain: opts.domain,
+		userAgent: opts.userAgent,
+		rate: opts.rate
+	});
+	if (opts.dryRun) {
+		log(`fetch ${opts.title}`);
+		const doc = await wp.fetchArticle(opts.title);
+		if (!doc) return `Article not found: "${opts.title}"`;
+		const snap = snapshotArticle(doc, canonicalTitle(doc.title?.() ?? opts.title));
+		return [
+			`Entry: ${snap.title}`,
+			`URL: ${snap.url ?? "(none)"}`,
+			`Internal links: ${snap.linkTitles.length}`,
+			`Categories: ${snap.categories.length}`,
+			`Sections: ${snap.sections.length}`,
+			`Has infobox: ${snap.infobox && snap.infobox.length > 0 ? "yes" : "no"}`,
+			"",
+			"── Sections ──",
+			printSections(snap.sections, "")
+		].join("\n");
+	}
+	const env = globalThis.process?.env ?? {};
+	const url = env["ABRA_URL"];
+	if (!url) return "ABRA_URL is required to write to the server. Set it or pass --dry-run.";
+	const { dm } = await openSession({
+		url,
+		name: env["ABRA_NAME"],
+		color: env["ABRA_COLOR"],
+		inviteCode: env["ABRA_INVITE_CODE"],
+		keyFile: env["ABRA_KEY_FILE"],
+		quiet: args.flags.has("quiet") || args.flags.has("q")
+	});
+	try {
+		const result = await runStreaming(dm, wp, opts, log);
+		return [`Done. Created ${result.articleCount} articles${result.categoryCount > 0 ? ` + ${result.categoryCount} categories` : ""}.`, `Root: ${result.rootDocId}`].join("\n");
+	} finally {
+		await dm.destroy().catch(() => {});
+	}
+}
+async function runStreaming(dm, wp, opts, log) {
+	const titleToDocId = /* @__PURE__ */ new Map();
+	const fetched = /* @__PURE__ */ new Map();
+	const childrenCreated = /* @__PURE__ */ new Set();
+	const categoryToDocId = /* @__PURE__ */ new Map();
+	let categoriesContainerId = null;
+	log(`fetch ${opts.title}`);
+	const entryDoc = await wp.fetchArticle(opts.title);
+	if (!entryDoc) throw new Error(`Article not found: "${opts.title}"`);
+	const entryTitle = canonicalTitle(entryDoc.title?.() ?? opts.title);
+	const entrySnap = snapshotArticle(entryDoc, entryTitle);
+	fetched.set(entryTitle, entrySnap);
+	const rootEntry = dm.tree.create({
+		parentId: opts.parentDocId ?? null,
+		label: entryTitle,
+		type: "graph",
+		meta: { icon: ICONS.graph }
+	});
+	log(`+ ${rootEntry.id.slice(0, 8)}…  ${entryTitle} (graph)`);
+	const entryArticleId = createArticleShell(dm, entrySnap, rootEntry.id, log);
+	titleToDocId.set(entryTitle, entryArticleId);
+	const queue = [{
+		title: entryTitle,
+		depth: 0
+	}];
+	let articleCount = 0;
+	while (queue.length > 0) {
+		const { title, depth } = queue.shift();
+		const articleDocId = titleToDocId.get(title);
+		let snap = fetched.get(title);
+		if (!snap) {
+			log(`fetch [d${depth}] ${title}`);
+			try {
+				const doc = await wp.fetchArticle(title);
+				if (!doc) {
+					log(`  not found — leaving stub`);
+					continue;
+				}
+				snap = snapshotArticle(doc, canonicalTitle(doc.title?.() ?? title));
+				fetched.set(title, snap);
+			} catch (err) {
+				log(`! fetch failed: ${err?.message ?? err}`);
+				continue;
+			}
+		}
+		if (opts.mode === "split" && !childrenCreated.has(title)) {
+			createArticleChildren(dm, snap, articleDocId, log);
+			childrenCreated.add(title);
+		}
+		if (depth < opts.depth) for (const linkTitle of snap.linkTitles) {
+			if (titleToDocId.has(linkTitle)) continue;
+			const shell = dm.tree.create({
+				parentId: rootEntry.id,
+				label: linkTitle,
+				type: "doc",
+				meta: { icon: ICONS.article }
+			});
+			titleToDocId.set(linkTitle, shell.id);
+			queue.push({
+				title: linkTitle,
+				depth: depth + 1
+			});
+			log(`+ ${shell.id.slice(0, 8)}…  ${linkTitle} (doc, shell)`);
+		}
+		if (opts.includeCategories && snap.categories.length > 0) {
+			if (!categoriesContainerId) {
+				const c = dm.tree.create({
+					parentId: rootEntry.id,
+					label: "Categories",
+					type: "graph",
+					meta: { icon: ICONS.categories }
+				});
+				categoriesContainerId = c.id;
+				log(`+ ${c.id.slice(0, 8)}…  Categories (graph)`);
+			}
+			for (const catTitle of snap.categories) {
+				if (categoryToDocId.has(catTitle)) continue;
+				const cat = dm.tree.create({
+					parentId: categoriesContainerId,
+					label: prettyCategoryLabel(catTitle),
+					type: "graph",
+					meta: { icon: ICONS.category }
+				});
+				categoryToDocId.set(catTitle, cat.id);
+				log(`+ ${cat.id.slice(0, 8)}…  ${prettyCategoryLabel(catTitle)} (graph, cat)`);
+			}
+		}
+		const body = opts.mode === "split" ? renderArticleLead(snap) : renderArticleSingleDoc(snap);
+		if (body.trim().length > 0) {
+			const rewritten = rewriteLinks(body, titleToDocId);
+			try {
+				await dm.content.write(articleDocId, rewritten);
+				log(`✓ body  ${title}`);
+			} catch (err) {
+				log(`! body write failed for ${title}: ${err?.message ?? err}`);
+			}
+		}
+		if (opts.mode === "split") await writeChildrenBodies(dm, snap, articleDocId, titleToDocId, log);
+		articleCount++;
+	}
+	let categoryCount = 0;
+	if (opts.includeCategories && categoryToDocId.size > 0) for (const [catTitle, catDocId] of categoryToDocId) {
+		log(`category ${catTitle}`);
+		try {
+			const members = await wp.fetchCategoryPages(catTitle, opts.categoryDepth > 0, Math.max(0, opts.categoryDepth));
+			const memberArticles = [];
+			const subcats = [];
+			for (const m of members) if (m.type === "subcat") subcats.push(prettyCategoryLabel(m.title));
+			else memberArticles.push(m.title);
+			const rewritten = rewriteLinks(renderCategoryBody(memberArticles, subcats), titleToDocId);
+			if (rewritten.trim().length > 0) {
+				await dm.content.write(catDocId, rewritten);
+				log(`✓ body  category ${catTitle}`);
+			}
+			categoryCount++;
+		} catch (err) {
+			log(`! category ${catTitle}: ${err?.message ?? err}`);
+		}
+	}
+	return {
+		rootDocId: rootEntry.id,
+		articleCount,
+		categoryCount
+	};
+}
+function createArticleShell(dm, article, parentId, log) {
+	const meta = { icon: ICONS.article };
+	if (article.url) meta.url = article.url;
+	const entry = dm.tree.create({
+		parentId,
+		label: article.title,
+		type: "doc",
+		meta
+	});
+	log(`+ ${entry.id.slice(0, 8)}…  ${article.title} (doc)`);
+	return entry.id;
+}
+/**
+* Create section + infobox child docs for a split-mode article. Returns nothing
+* — children get bodies written later in writeChildrenBodies.
+*/
+function createArticleChildren(dm, article, articleDocId, log) {
+	if (article.infobox && article.infobox.length > 0) {
+		const ib = dm.tree.create({
+			parentId: articleDocId,
+			label: "Infobox",
+			type: "outline",
+			meta: { icon: ICONS.infobox }
+		});
+		log(`  + ${ib.id.slice(0, 8)}…  Infobox (outline)`);
+		article._infoboxDocId = ib.id;
+	}
+	for (const section of article.sections) createSectionShell(dm, section, articleDocId, log);
+}
+function createSectionShell(dm, section, parentDocId, log) {
+	const hasChildren = section.children.length > 0;
+	if (!section.body.trim() && !hasChildren) return;
+	const { type, icon } = pickSectionType(section);
+	const entry = dm.tree.create({
+		parentId: parentDocId,
+		label: section.title || "Untitled section",
+		type,
+		meta: { icon }
+	});
+	log(`  + ${entry.id.slice(0, 8)}…  ${entry.label} (${type})`);
+	section._docId = entry.id;
+	for (const child of section.children) createSectionShell(dm, child, entry.id, log);
+}
+async function writeChildrenBodies(dm, article, _articleDocId, titleToDocId, log) {
+	const infoboxDocId = article._infoboxDocId;
+	if (infoboxDocId && article.infobox && article.infobox.length > 0) try {
+		await dm.content.write(infoboxDocId, renderInfoboxBody(article.infobox));
+	} catch (err) {
+		log(`! infobox body write failed: ${err?.message ?? err}`);
+	}
+	for (const section of article.sections) await writeSectionBody(dm, section, titleToDocId, log);
+}
+async function writeSectionBody(dm, section, titleToDocId, log) {
+	const docId = section._docId;
+	if (docId && section.body.trim().length > 0) try {
+		await dm.content.write(docId, rewriteLinks(section.body, titleToDocId));
+	} catch (err) {
+		log(`! section body write failed for ${section.title}: ${err?.message ?? err}`);
+	}
+	for (const child of section.children) await writeSectionBody(dm, child, titleToDocId, log);
+}
+function parseOptions(args) {
+	const title = args.positional[0]?.trim() || args.params["title"];
+	if (!title) return "Missing required positional argument: <title>. Example: abracadabra-wiki \"Toronto Raptors\"";
+	const env = globalThis.process?.env ?? {};
+	const userAgent = args.params["user-agent"] || args.params["userAgent"] || env["ABRA_WIKI_USER_AGENT"];
+	if (!userAgent) return ["Missing required parameter: user-agent=\"your-name (you@example.com)\"", "(Wikimedia etiquette requires an Api-User-Agent header. Pass user-agent=... or set ABRA_WIKI_USER_AGENT.)"].join("\n");
+	const mode = args.params["mode"] ?? "split";
+	if (mode !== "single" && mode !== "split") return `Invalid mode "${mode}". Use mode=single or mode=split.`;
+	const depth = parseIntOr(args.params["depth"], 1);
+	const categoryDepth = parseIntOr(args.params["category-depth"] ?? args.params["categoryDepth"], 1);
+	const rate = parseFloatOr(args.params["rate"], 3);
+	return {
+		title,
+		mode,
+		depth,
+		categoryDepth,
+		includeCategories: args.flags.has("include-categories") || args.flags.has("includeCategories"),
+		lang: args.params["lang"] ?? "en",
+		domain: args.params["domain"],
+		parentDocId: args.params["parent"],
+		userAgent,
+		rate,
+		dryRun: args.flags.has("dry-run") || args.flags.has("dryRun")
+	};
+}
+function parseIntOr(s, fallback) {
+	if (!s) return fallback;
+	const n = Number.parseInt(s, 10);
+	return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function parseFloatOr(s, fallback) {
+	if (!s) return fallback;
+	const n = Number.parseFloat(s);
+	return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function printSections(sections, indent) {
+	const lines = [];
+	for (const s of sections) {
+		const hint = s.body ? ` (${s.body.length}b)` : "";
+		lines.push(`${indent}- ${s.title}${hint}${s.children.length > 0 ? ` [${s.children.length} sub]` : ""}`);
+		if (s.children.length > 0) lines.push(printSections(s.children, indent + "  "));
+	}
+	return lines.join("\n");
+}
+async function main() {
+	const args = parseArgs(process.argv);
+	if (args.flags.has("help") || args.flags.has("h") || !args.positional[0]?.trim() && !args.params["title"]) {
+		console.log(USAGE);
+		return;
+	}
+	const output = await runWiki(args);
+	if (output) console.log(output);
+}
+main().catch((err) => {
+	console.error(`Fatal: ${err?.message ?? err}`);
+	process.exit(1);
+});
+
+//#endregion
+export { runWiki };
+//# sourceMappingURL=abracadabra-wiki.esm.js.map