@bpmnkit/docspack 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 urbanisierung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+<div align="center">
+  <a href="https://bpmnkit.com"><img src="https://bpmnkit.com/favicon.svg" width="72" height="72" alt="BPMN Kit logo"></a>
+  <h1>@bpmnkit/docspack</h1>
+  <p>BPMN Kit documentation as an offline, version-locked docspack package with a built-in search CLI for AI agents</p>
+
+  [![npm](https://img.shields.io/npm/v/@bpmnkit/docspack?style=flat-square&color=6244d7)](https://www.npmjs.com/package/@bpmnkit/docspack)
+  [![license](https://img.shields.io/npm/l/@bpmnkit/docspack?style=flat-square)](https://github.com/bpmnkit/monorepo/blob/main/LICENSE)
+  [![typescript](https://img.shields.io/badge/TypeScript-strict-6244d7?style=flat-square&logo=typescript&logoColor=white)](https://github.com/bpmnkit/monorepo)
+  [![ai-assisted](https://img.shields.io/badge/AI--assisted-claude-8b5cf6?style=flat-square)](https://github.com/bpmnkit/monorepo)
+  [![experimental](https://img.shields.io/badge/status-experimental-f59e0b?style=flat-square)](https://github.com/bpmnkit/monorepo)
+
+  [Website](https://bpmnkit.com) · [Documentation](https://docs.bpmnkit.com) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/packages/docspack/CHANGELOG.md)
+</div>
+
+---
+
+## Overview
+
+`@bpmnkit/docspack` ships the BPMN Kit documentation the way an AI agent can actually use it: as an npm package whose version tracks the docs, indexed locally and searched offline.
+
+An agent installs it, asks a question, and gets back the two or three passages that answer it — not a whole documentation site, and not whatever the model remembers about an older release.
+
+It follows the [docspack package format](https://docspack.dev/spec), so the upstream `docspack` CLI discovers and indexes it like any other vendor pack. The bundled `bpmnkit-docs` command does the same job with no extra tooling.
+
+```
+Markdown docs → chunks + manifest → BM25 index → three passages
+```
+
+## Features
+
+- **Offline** — `ask`, `search` and `list` read the filesystem only. No server, no network call, nothing resident between questions
+- **Version-locked** — the installed `package.json` version wins over the manifest, so an agent reads the docs for the release it has
+- **Bounded answers** — three chunks and 3,000 tokens by default, budgeted from the manifest before any content is read
+- **Real retrieval** — BM25 over chunk text with Porter stemming, so `authenticate` finds a passage that only says `authentication`; tags and API identifiers weigh 3× prose
+- **docspack-compatible** — `.llms/manifest.json` validates against `https://docspack.dev/schema/v1.json`
+- **Safe by construction** — a manifest is untrusted input: chunk paths that escape `.llms/` are refused, and community packages are labelled
+- **Zero runtime dependencies**
+
+## Installation
+
+```sh
+npm install -D @bpmnkit/docspack
+```
+
+## Quick Start
+
+Give an agent one line in `AGENTS.md` or `CLAUDE.md`:
+
+```
+Run \`npx bpmnkit-docs ask "<question>"\` for BPMN Kit documentation.
+It answers from the version this project installed.
+```
+
+Then:
+
+```sh
+npx bpmnkit-docs ask "how do I deploy a process to Camunda 8"
+npx bpmnkit-docs search "exclusive gateway"
+npx bpmnkit-docs list
+```
+
+```
+## @bpmnkit/docspack@0.0.1/getting-started.quick-start.step-3-deploy-and-run
+
+# Quick Start — Step 3: Deploy and run
+...
+
+---
+cost: 1,204 tokens, capped at 3,000
+```
+
+## API Reference
+
+```typescript
+// Discover and index every docs package installed under a directory
+function discoverPacks(cwd?: string): Pack[]
+function indexPacks(packs: readonly Pack[]): DocsIndex
+
+// Rank chunks, or take the top ones that fit a token budget
+function search(index: DocsIndex, query: string, options?: SearchOptions): SearchHit[]
+function answer(
+  index: DocsIndex,
+  query: string,
+  options?: AnswerOptions,
+): { hits: SearchHit[]; tokens: number; maxTokens: number }
+
+interface SearchOptions {
+  limit?: number      // chunks to return. Default: 3
+  packs?: readonly string[] // restrict to these package names
+}
+
+interface AnswerOptions extends SearchOptions {
+  maxTokens?: number  // ceiling for an answer. Default: 3000
+}
+
+// Generate a .llms/ payload from a directory of Markdown
+function buildPack(options: BuildOptions): BuildResult
+
+// Read one package, validating it the way a consumer must
+function loadPack(dir: string): Pack
+```
+
+### CLI
+
+| Command | Purpose |
+| --- | --- |
+| `bpmnkit-docs ask <question>` | Answer from the installed docs packages — the command to give an agent |
+| `bpmnkit-docs search <query>` | Rank matching chunks, for reading in a terminal |
+| `bpmnkit-docs list` | Show the docs packages found and their index state |
+| `bpmnkit-docs build` | Regenerate this package's `.llms/` payload from the docs source |
+
+Options: `--limit <n>`, `--max-tokens <n>`, `--pack <name>`, `--cwd <dir>`.
+
+---
+
+## Related Packages
+
+| Package | Description |
+|---------|-------------|
+| [`@bpmnkit/core`](https://www.npmjs.com/package/@bpmnkit/core) | BPMN/DMN/Form parser, builder, layout engine |
+| [`@bpmnkit/canvas`](https://www.npmjs.com/package/@bpmnkit/canvas) | Zero-dependency SVG BPMN viewer |
+| [`@bpmnkit/editor`](https://www.npmjs.com/package/@bpmnkit/editor) | Full-featured interactive BPMN editor |
+| [`@bpmnkit/engine`](https://www.npmjs.com/package/@bpmnkit/engine) | Lightweight BPMN process execution engine |
+| [`@bpmnkit/feel`](https://www.npmjs.com/package/@bpmnkit/feel) | FEEL expression language parser & evaluator |
+| [`@bpmnkit/plugins`](https://www.npmjs.com/package/@bpmnkit/plugins) | 22 composable canvas plugins |
+| [`@bpmnkit/api`](https://www.npmjs.com/package/@bpmnkit/api) | Camunda 8 REST API TypeScript client |
+| [`@bpmnkit/ascii`](https://www.npmjs.com/package/@bpmnkit/ascii) | Render BPMN diagrams as Unicode ASCII art |
+| [`@bpmnkit/ui`](https://www.npmjs.com/package/@bpmnkit/ui) | Shared design tokens and UI components |
+| [`@bpmnkit/profiles`](https://www.npmjs.com/package/@bpmnkit/profiles) | Shared auth, profile storage, and client factories for CLI & proxy |
+| [`@bpmnkit/operate`](https://www.npmjs.com/package/@bpmnkit/operate) | Monitoring & operations frontend for Camunda clusters |
+| [`@bpmnkit/connector-gen`](https://www.npmjs.com/package/@bpmnkit/connector-gen) | Generate connector templates from OpenAPI specs |
+| [`@bpmnkit/connectors`](https://www.npmjs.com/package/@bpmnkit/connectors) | Camunda 8 OOTB connector catalog and deterministic template application |
+| [`@bpmnkit/cli`](https://www.npmjs.com/package/@bpmnkit/cli) | Camunda 8 command-line interface (casen) |
+| [`@bpmnkit/proxy`](https://www.npmjs.com/package/@bpmnkit/proxy) | Local AI bridge and Camunda API proxy server |
+| [`@bpmnkit/patterns`](https://www.npmjs.com/package/@bpmnkit/patterns) | Domain process patterns for BPMNKit AIKit |
+| [`@bpmnkit/reebe-wasm`](https://www.npmjs.com/package/@bpmnkit/reebe-wasm) | WebAssembly BPMN engine for browser simulation |
+| [`@bpmnkit/worker-client`](https://www.npmjs.com/package/@bpmnkit/worker-client) | Thin Zeebe REST client for standalone workers |
+| [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
+| [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |
+| [`@bpmnkit/casen-report`](https://www.npmjs.com/package/@bpmnkit/casen-report) | HTML reports from Camunda 8 incident and SLA data |
+| [`@bpmnkit/casen-worker-http`](https://www.npmjs.com/package/@bpmnkit/casen-worker-http) | Example HTTP worker plugin — completes jobs with live JSONPlaceholder API data |
+| [`@bpmnkit/casen-worker-ai`](https://www.npmjs.com/package/@bpmnkit/casen-worker-ai) | AI task worker — classify, summarize, extract, and decide using Claude |
+
+## License
+
+[MIT](https://github.com/bpmnkit/monorepo/blob/main/LICENSE) © BPMN Kit — made by [u11g](https://u11g.com)
+
+<div align="center">
+  <a href="https://bpmnkit.com"><img src="https://bpmnkit.com/favicon.svg" width="32" height="32" alt="BPMN Kit"></a>
+</div>

package/dist/build.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Generating the `.llms/` payload from a directory of Markdown.
+ *
+ * The output is what gets published: `.llms/chunks/*.md`, `.llms/manifest.json`
+ * and an `llms.txt` table of contents at the package root.
+ */
+export declare const SCHEMA_URL = "https://docspack.dev/schema/v1.json";
+export interface BuildOptions {
+    /** Directory of Markdown documents, walked recursively. */
+    source: string;
+    /** Package root — `.llms/` and `llms.txt` are written here. */
+    packDir: string;
+    name: string;
+    version: string;
+    /** Libraries this package documents, each `name` or `name@version`. */
+    documents: string[];
+    description?: string;
+    /** Base URL each chunk links back to. */
+    siteUrl?: string;
+    maxTokens?: number;
+    minTokens?: number;
+}
+export interface BuildResult {
+    documents: number;
+    chunks: number;
+    tokens: number;
+}
+export declare function buildPack(options: BuildOptions): BuildResult;
+//# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -0,0 +1,89 @@
+/**
+ * Generating the `.llms/` payload from a directory of Markdown.
+ *
+ * The output is what gets published: `.llms/chunks/*.md`, `.llms/manifest.json`
+ * and an `llms.txt` table of contents at the package root.
+ */
+import { mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { chunkDocument, uniqueId } from "./chunk.js";
+export const SCHEMA_URL = "https://docspack.dev/schema/v1.json";
+export function buildPack(options) {
+    const source = resolve(options.source);
+    const packDir = resolve(options.packDir);
+    const files = markdownFiles(source);
+    if (files.length === 0)
+        throw new Error(`${source}: no Markdown documents found`);
+    const built = [];
+    const ids = new Set();
+    for (const file of files) {
+        const slug = relative(source, file)
+            .replace(/\.mdx?$/, "")
+            .split(/[\\/]/)
+            .join("/");
+        const chunks = chunkDocument({ slug, markdown: readFileSync(file, "utf8") }, {
+            maxTokens: options.maxTokens,
+            minTokens: options.minTokens,
+            ...(options.siteUrl ? { siteUrl: options.siteUrl } : {}),
+        });
+        for (const chunk of chunks)
+            built.push({ ...chunk, id: uniqueId(chunk.id, ids) });
+    }
+    const chunksDir = join(packDir, ".llms", "chunks");
+    rmSync(chunksDir, { recursive: true, force: true });
+    mkdirSync(chunksDir, { recursive: true });
+    for (const chunk of built)
+        writeFileSync(join(chunksDir, `${chunk.id}.md`), chunk.body);
+    const manifest = {
+        $schema: SCHEMA_URL,
+        name: options.name,
+        version: options.version,
+        documents: options.documents,
+        chunks: built.map((chunk) => ({
+            id: chunk.id,
+            file: `chunks/${chunk.id}.md`,
+            tokens: chunk.tokens,
+            tags: chunk.tags,
+            entities: chunk.entities,
+        })),
+    };
+    writeFileSync(join(packDir, ".llms", "manifest.json"), `${JSON.stringify(manifest, null, "\t")}\n`);
+    writeFileSync(join(packDir, "llms.txt"), tableOfContents(options, built));
+    return {
+        documents: files.length,
+        chunks: built.length,
+        tokens: built.reduce((sum, chunk) => sum + chunk.tokens, 0),
+    };
+}
+/** The human-readable table of contents the format requires at the package root. */
+function tableOfContents(options, chunks) {
+    const lines = [`# ${options.name}`, ""];
+    if (options.description)
+        lines.push(`> ${options.description}`, "");
+    lines.push(`Version ${options.version}. ${chunks.length} chunks documenting ${options.documents.join(", ")}.`, "", "```sh", `npm i -D ${options.name}`, `npx bpmnkit-docs ask "how do I deploy a process"`, "```", "");
+    const groups = new Map();
+    for (const chunk of chunks) {
+        const group = chunk.id.includes(".") ? (chunk.id.split(".")[0] ?? "docs") : "docs";
+        groups.set(group, [...(groups.get(group) ?? []), chunk]);
+    }
+    for (const [group, entries] of [...groups].sort(([a], [b]) => a.localeCompare(b))) {
+        lines.push(`## ${group}`, "");
+        for (const chunk of entries) {
+            lines.push(`- [${chunk.title}](.llms/chunks/${chunk.id}.md) — ${chunk.tokens} tokens`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function markdownFiles(dir) {
+    const out = [];
+    for (const name of readdirSync(dir).sort()) {
+        const path = join(dir, name);
+        if (statSync(path).isDirectory())
+            out.push(...markdownFiles(path));
+        else if (name.endsWith(".md"))
+            out.push(path);
+    }
+    return out;
+}
+//# sourceMappingURL=build.js.map

package/dist/chunk.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Splitting Markdown into retrievable chunks.
+ *
+ * A chunk is one `##` section: the unit a reader would have scrolled to anyway.
+ * Sections too large for the budget are subdivided at `###` and then at paragraph
+ * boundaries; sections too small to stand alone are merged with the next one, so
+ * reference tables do not become one chunk per row.
+ */
+/** A Markdown file to be chunked, identified by its slug under the docs root. */
+export interface SourceDoc {
+    /** Path relative to the docs root without extension, e.g. `guides/ai-agents`. */
+    slug: string;
+    markdown: string;
+}
+/** A chunk before it is written: the manifest entry and the file body together. */
+export interface BuiltChunk {
+    id: string;
+    title: string;
+    tags: string[];
+    entities: string[];
+    /** Markdown written to `.llms/chunks/<id>.md`. */
+    body: string;
+    tokens: number;
+}
+export interface ChunkOptions {
+    /** Subdivide a section above this many tokens. */
+    maxTokens?: number;
+    /** Merge a section below this many tokens into the next one. */
+    minTokens?: number;
+    /** Base URL used for the source link at the foot of each chunk. */
+    siteUrl?: string;
+}
+/** Split one document into chunks. */
+export declare function chunkDocument(doc: SourceDoc, options?: ChunkOptions): BuiltChunk[];
+/**
+ * Make `id` unique against `used`, recording it. Ids are unique within a document
+ * by construction, but two documents can still land on the same one — a page
+ * `cli/casen` and a `## casen` section of a page `cli` both want `cli.casen`.
+ */
+export declare function uniqueId(id: string, used: Set<string>): string;
+//# sourceMappingURL=chunk.d.ts.map

package/dist/chunk.js

@@ -0,0 +1,242 @@
+/**
+ * Splitting Markdown into retrievable chunks.
+ *
+ * A chunk is one `##` section: the unit a reader would have scrolled to anyway.
+ * Sections too large for the budget are subdivided at `###` and then at paragraph
+ * boundaries; sections too small to stand alone are merged with the next one, so
+ * reference tables do not become one chunk per row.
+ */
+import { STOP_WORDS, estimateTokens, tokenize } from "./text.js";
+const FRONT_MATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+const DIRECTIVE = /^<!--\s*docspack:\s*(tags|entities)\s*=\s*(.+?)\s*-->\s*$/;
+/** Split one document into chunks. */
+export function chunkDocument(doc, options = {}) {
+    const maxTokens = options.maxTokens ?? 800;
+    const minTokens = options.minTokens ?? 120;
+    const { attributes, body } = parseFrontMatter(doc.markdown);
+    const title = attributes.title ?? titleFromSlug(doc.slug);
+    const docTags = attributes.tags ?? [];
+    const merged = mergeSmall(splitByHeading(body, 2), minTokens);
+    const chunks = [];
+    const used = new Set();
+    for (const section of merged) {
+        for (const part of subdivide(section, maxTokens)) {
+            const text = part.lines.join("\n").trim();
+            if (text === "")
+                continue;
+            const directives = readDirectives(part.lines);
+            const chunkTitle = part.heading === "" ? title : `${title} — ${part.heading}`;
+            const source = options.siteUrl ? `\n\n---\nSource: ${options.siteUrl}/${doc.slug}/` : "";
+            const bodyText = `# ${chunkTitle}\n\n${stripDirectives(text)}${source}\n`;
+            chunks.push({
+                id: uniqueId(makeId(doc.slug, part.heading), used),
+                title: chunkTitle,
+                tags: dedupe([
+                    ...docTags,
+                    ...directives.tags,
+                    ...doc.slug.split("/"),
+                    ...headingTags(part.heading),
+                ]).slice(0, 12),
+                entities: dedupe([...directives.entities, ...extractEntities(text)]).slice(0, 12),
+                body: bodyText,
+                tokens: estimateTokens(bodyText),
+            });
+        }
+    }
+    return chunks;
+}
+/** Parse the leading YAML front matter. Only the keys a chunk needs are read. */
+function parseFrontMatter(markdown) {
+    const match = FRONT_MATTER.exec(markdown);
+    if (!match?.[1])
+        return { attributes: {}, body: markdown };
+    const attributes = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const pair = /^(title|tags):\s*(.*)$/.exec(line);
+        if (!pair?.[1])
+            continue;
+        const value = (pair[2] ?? "").trim();
+        if (pair[1] === "title")
+            attributes.title = unquote(value);
+        else
+            attributes.tags = value
+                .replace(/^\[|\]$/g, "")
+                .split(",")
+                .map(unquote)
+                .filter(Boolean);
+    }
+    return { attributes, body: markdown.slice(match[0].length) };
+}
+function unquote(value) {
+    return value
+        .trim()
+        .replace(/^["']|["']$/g, "")
+        .trim();
+}
+/**
+ * Split on ATX headings of exactly `level`, ignoring anything inside a fenced
+ * code block — a `## comment` in a shell sample is not a section.
+ */
+function splitByHeading(body, level) {
+    const marker = new RegExp(`^#{${level}}\\s+(.+?)\\s*$`);
+    const sections = [{ heading: "", lines: [] }];
+    let fence = null;
+    for (const line of body.split(/\r?\n/)) {
+        const fenceMatch = /^\s*(```+|~~~+)/.exec(line);
+        if (fenceMatch?.[1]) {
+            if (fence === null)
+                fence = fenceMatch[1][0] ?? null;
+            else if (line.trimStart().startsWith(fence))
+                fence = null;
+        }
+        const heading = fence === null ? marker.exec(line) : null;
+        if (heading?.[1])
+            sections.push({ heading: heading[1], lines: [] });
+        else
+            sections[sections.length - 1]?.lines.push(line);
+    }
+    return sections.filter((s) => s.heading !== "" || s.lines.join("").trim() !== "");
+}
+/** Merge each section that is too short to answer anything into the one after it. */
+function mergeSmall(sections, minTokens) {
+    const out = [];
+    for (const section of sections) {
+        const previous = out[out.length - 1];
+        if (previous && estimateTokens(previous.lines.join("\n")) < minTokens) {
+            previous.lines.push("", section.heading === "" ? "" : `## ${section.heading}`, ...section.lines);
+            continue;
+        }
+        out.push({ heading: section.heading, lines: [...section.lines] });
+    }
+    return out;
+}
+/** Break an oversized section at `###`, then at paragraph boundaries. */
+function subdivide(section, maxTokens) {
+    if (estimateTokens(section.lines.join("\n")) <= maxTokens)
+        return [section];
+    const parts = [];
+    for (const sub of splitByHeading(section.lines.join("\n"), 3)) {
+        const heading = sub.heading === "" ? section.heading : `${section.heading} — ${sub.heading}`;
+        parts.push(...byParagraph({ heading, lines: sub.lines }, maxTokens));
+    }
+    return parts.length > 0 ? parts : [section];
+}
+/** Last resort: pack whole paragraphs until the budget is spent, never mid-fence. */
+function byParagraph(section, maxTokens) {
+    if (estimateTokens(section.lines.join("\n")) <= maxTokens)
+        return [section];
+    const parts = [];
+    let current = [];
+    let fence = null;
+    const flush = () => {
+        if (current.join("").trim() === "")
+            return;
+        const suffix = parts.length === 0 ? "" : ` (${parts.length + 1})`;
+        parts.push({ heading: `${section.heading}${suffix}`, lines: current });
+        current = [];
+    };
+    for (const line of section.lines) {
+        const fenceMatch = /^\s*(```+|~~~+)/.exec(line);
+        if (fenceMatch?.[1]) {
+            if (fence === null)
+                fence = fenceMatch[1][0] ?? null;
+            else if (line.trimStart().startsWith(fence))
+                fence = null;
+        }
+        if (fence === null && line.trim() === "" && estimateTokens(current.join("\n")) >= maxTokens) {
+            flush();
+            continue;
+        }
+        current.push(line);
+    }
+    flush();
+    return parts;
+}
+function readDirectives(lines) {
+    const tags = [];
+    const entities = [];
+    for (const line of lines) {
+        const match = DIRECTIVE.exec(line.trim());
+        if (!match?.[2])
+            continue;
+        const values = match[2]
+            .split(",")
+            .map((v) => v.trim())
+            .filter(Boolean);
+        if (match[1] === "tags")
+            tags.push(...values);
+        else
+            entities.push(...values);
+    }
+    return { tags, entities };
+}
+function stripDirectives(text) {
+    return text
+        .split(/\r?\n/)
+        .filter((line) => !DIRECTIVE.test(line.trim()))
+        .join("\n")
+        .trim();
+}
+/** Heading words carry the topic; function words carry nothing worth weighting 3x. */
+function headingTags(heading) {
+    return tokenize(heading).filter((word) => word.length > 2 && !STOP_WORDS.has(word));
+}
+/**
+ * Identifiers named in inline code. A bare word in backticks is usually a value,
+ * not an API, so only qualified, called or camel-cased names are kept.
+ */
+function extractEntities(text) {
+    const found = [];
+    for (const match of text.matchAll(/`([^`\n]{2,60})`/g)) {
+        const value = (match[1] ?? "").trim();
+        if (!/^@?[A-Za-z][\w./-]*(\(\))?$/.test(value))
+            continue;
+        if (!/[./]/.test(value) && !value.endsWith("()") && !/[a-z][A-Z]/.test(value))
+            continue;
+        found.push(value);
+    }
+    return found;
+}
+function makeId(slug, heading) {
+    const base = slugify(slug.replace(/\//g, "."));
+    const section = slugify(heading);
+    return section === "" ? base : `${base}.${section}`;
+}
+/** Reduce to the manifest's `^[A-Za-z0-9][A-Za-z0-9._-]*$`. */
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/-{2,}/g, "-")
+        .replace(/^[^a-z0-9]+|[-._]+$/g, "");
+}
+/**
+ * Make `id` unique against `used`, recording it. Ids are unique within a document
+ * by construction, but two documents can still land on the same one — a page
+ * `cli/casen` and a `## casen` section of a page `cli` both want `cli.casen`.
+ */
+export function uniqueId(id, used) {
+    const base = id === "" ? "chunk" : id;
+    let candidate = base;
+    for (let n = 2; used.has(candidate); n++)
+        candidate = `${base}-${n}`;
+    used.add(candidate);
+    return candidate;
+}
+function titleFromSlug(slug) {
+    const last = slug.split("/").pop() ?? slug;
+    return last.replace(/[-_]+/g, " ").replace(/\b[a-z]/g, (c) => c.toUpperCase());
+}
+function dedupe(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const key = value.toLowerCase();
+        if (value === "" || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(value);
+    }
+    return out;
+}
+//# sourceMappingURL=chunk.js.map

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * `bpmnkit-docs` — read the installed documentation packages and answer from them.
+ *
+ * Every command reads the filesystem only. There is no server, no network call
+ * and nothing resident between questions.
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map