@bpmnkit/camunda-docspack 0.0.0

package/LICENSE

@@ -0,0 +1,42 @@
+Creative Commons Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+
+WHAT THIS PACKAGE IS
+
+This package repackages existing Camunda documentation for offline retrieval by
+AI agents. It contains no documentation written by BPMN Kit.
+
+The documentation content (llms.txt and .llms/) is the work of Camunda Services
+GmbH, taken from camunda/camunda-docs and published at https://docs.camunda.io.
+Copyright in that content remains with Camunda Services GmbH. BPMN Kit claims no
+ownership of it and asserts no rights over it.
+
+BPMN Kit's own contribution is the build tooling in src/ — the code that stages,
+chunks and indexes that content — and nothing more.
+
+THE LICENCE
+
+Camunda publishes its documentation under the Creative Commons
+Attribution-ShareAlike 3.0 Unported licence, and this package redistributes it
+under those same terms, unchanged.
+
+Full licence text: https://creativecommons.org/licenses/by-sa/3.0/legalcode
+
+Chunking the prose, rendering embedded BPMN diagrams as text and rewriting links
+make this package an Adaptation under §1 of that licence rather than a mere
+Collection. ShareAlike therefore applies, and this package as a whole is
+distributed under CC BY-SA 3.0 rather than the MIT licence used elsewhere in this
+repository. See NOTICE for the attribution and the list of changes made.
+
+That licence grants you rights: you may share and adapt this content, provided
+you credit Camunda, say what you changed, and license your result under the same
+terms. Nothing here withdraws or narrows those rights.
+
+NO AFFILIATION
+
+BPMN Kit is not affiliated with, endorsed by, or sponsored by Camunda Services
+GmbH. "Camunda" is a trademark of its owner and is used here only to state
+truthfully whose documentation this is.
+
+This package is a convenience copy, pinned to one upstream commit and therefore
+always some distance behind. For canonical and current documentation, prefer
+https://docs.camunda.io.

package/NOTICE

@@ -0,0 +1,24 @@
+This package repackages existing Camunda documentation for offline retrieval by
+AI agents. It contains no documentation written by BPMN Kit.
+
+The documentation content is the work of Camunda Services GmbH. Copyright in it
+remains with Camunda Services GmbH; BPMN Kit claims no ownership of it and
+asserts no rights over it. BPMN Kit's contribution is the build tooling only.
+
+Source: https://github.com/camunda/camunda-docs @ acbf6806758ce4036eba3791bd884ad114552860
+Published at: https://docs.camunda.io/docs/next/
+Licensed by Camunda under CC BY-SA 3.0: https://creativecommons.org/licenses/by-sa/3.0/
+
+The original work has been modified. Changes:
+  - pages split into retrieval chunks
+  - embedded BPMN diagrams rendered as text flow descriptions
+  - MDX components removed or reduced to text, and Markdown partials inlined
+  - relative links rewritten to absolute docs.camunda.io URLs
+  - page descriptions promoted into the body text
+
+This adaptation is redistributed under CC BY-SA 3.0, as that licence requires.
+Those terms are unchanged: you may share and adapt this content, provided you
+credit Camunda, state what you changed, and license your result alike.
+
+BPMN Kit is not affiliated with, endorsed by, or sponsored by Camunda Services
+GmbH. For canonical and current documentation, prefer https://docs.camunda.io.

package/README.md

@@ -0,0 +1,121 @@
+<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/camunda-docspack</h1>
+  <p>Camunda 8 documentation as an offline, version-locked docspack package for AI agents</p>
+
+  [![npm](https://img.shields.io/npm/v/@bpmnkit/camunda-docspack?style=flat-square&color=6244d7)](https://www.npmjs.com/package/@bpmnkit/camunda-docspack)
+  [![license](https://img.shields.io/npm/l/@bpmnkit/camunda-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://bpmnkit.com/docs) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/packages/camunda-docspack/CHANGELOG.md)
+</div>
+
+---
+
+## Overview
+
+`@bpmnkit/camunda-docspack` packages the Camunda 8 documentation — BPMN, FEEL, engine concepts and the Orchestration Cluster API — as a [docspack](https://docspack.dev/spec) pack you can search offline, with no network call and no MCP server.
+
+It is built from the `docs/` tree of [camunda/camunda-docs](https://github.com/camunda/camunda-docs), which is the unreleased **8.10** documentation, plus the Orchestration Cluster API specification.
+
+> **This is Camunda's documentation, not BPMN Kit's.** The content is the work of Camunda Services GmbH and copyright in it remains with them; this package contains no documentation written by BPMN Kit and claims no rights over what it carries. All it adds is the tooling that stages, chunks and indexes that content so an AI agent can retrieve it offline. BPMN Kit is not affiliated with, endorsed by, or sponsored by Camunda. It is a convenience copy pinned to one upstream commit, so for canonical and current documentation prefer [docs.camunda.io](https://docs.camunda.io).
+
+## Features
+
+- **Diagrams as text** — the best-practice pages argue through embedded BPMN diagrams. Camunda's own Markdown export drops them; this renders each one as a flow description, so a page about naming gateways still contains the gateway, its question and its conditions.
+- **227 API operations** — one digest per endpoint, read from the specification rather than from the generated reference pages, with required permissions decoded, the version it appeared in, and its consistency guarantee.
+- **Every chunk cites its page** — links are rewritten to absolute `docs.camunda.io` URLs, and each chunk ends with the page it came from.
+- **Nothing dropped silently** — an MDX component the build does not recognise fails the build by file and line instead of quietly thinning the corpus.
+- **Offline** — one SQLite-free local index; no server, nothing resident.
+
+## Installation
+
+```sh
+npm i -D @bpmnkit/camunda-docspack
+pnpm add -D @bpmnkit/camunda-docspack
+```
+
+## Quick Start
+
+Search it with the CLI that ships in `@bpmnkit/docspack`:
+
+```sh
+npx bpmnkit-docs ask "how should I name an exclusive gateway"
+npx bpmnkit-docs ask "POST /jobs/activation"
+npx bpmnkit-docs ask "what permissions does creating a process instance need"
+npx bpmnkit-docs ask "FEEL string concatenation" --pack @bpmnkit/camunda-docspack
+```
+
+Answers cap at 3 chunks / 3,000 tokens, so prefer several narrow questions to one broad one.
+
+## API Reference
+
+The published artefact is the `.llms/` payload. These exports are the build that produces it:
+
+| Export | Purpose |
+| --- | --- |
+| `build(options)` | Stage a camunda-docs checkout and write the `.llms/` payload |
+| `stage(options)` | Run the staging transforms only, to a directory |
+| `bpmnToText(xml)` | Render a BPMN diagram as a compact flow description |
+| `readOperations(entry)` | Read one digest per operation from an OpenAPI document |
+| `stripMdx(source, options)` | Reduce Camunda's MDX to indexable Markdown |
+| `absoluteLinks(markdown, slug)` | Rewrite relative links to `docs.camunda.io` URLs |
+| `notice(commit)` | The CC BY-SA 3.0 attribution written on every build |
+
+Rebuild the pack against a checkout:
+
+```sh
+node packages/camunda-docspack/dist/cli.js --camunda-docs ../camunda-docs
+```
+
+## Licence
+
+**The documentation content belongs to Camunda.** It is the work of Camunda Services GmbH, taken from camunda/camunda-docs, and copyright in it remains with them. BPMN Kit claims no ownership of it and asserts no rights over it; its own contribution is the build tooling in `src/` and nothing else.
+
+Camunda publishes that documentation under **CC BY-SA 3.0**, and this package redistributes it under those same terms, unchanged. Chunking the prose and rendering its embedded diagrams as text make this an Adaptation under §1 of that licence rather than a mere Collection, so ShareAlike applies and the package as a whole is CC BY-SA 3.0 rather than MIT like the rest of BPMN Kit.
+
+Those terms grant you rights, and nothing here narrows them: you may share and adapt this content, provided you credit Camunda, state what you changed, and license your result alike. See `NOTICE` for the attribution, the upstream commit, and the list of changes made.
+
+BPMN Kit is not affiliated with, endorsed by, or sponsored by Camunda Services GmbH. "Camunda" is a trademark of its owner, used here only to state truthfully whose documentation this is. For canonical and current documentation, prefer [docs.camunda.io](https://docs.camunda.io).
+
+---
+
+## 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/docspack`](https://www.npmjs.com/package/@bpmnkit/docspack) | BPMN Kit docs as an offline docspack package for AI agents |
+| [`@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/user-tasks`](https://www.npmjs.com/package/@bpmnkit/user-tasks) | Embeddable user task widget for Camunda 8 |
+| [`@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/bpmn-text.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rendering an embedded BPMN diagram as text an agent can read.
+ *
+ * Camunda's best-practice pages carry their argument in the diagram: a page about naming
+ * gateways shows the gateway, its question and the labels on its outgoing flows. Camunda's
+ * own Markdown export drops those embeds, so the prose is left referring to elements that
+ * are not in the text at all.
+ *
+ * `@bpmnkit/ascii` already draws BPMN as box art, but it truncates element labels to the
+ * box width (`Reject payment of in…`) and omits condition expressions — exactly the two
+ * things these pages are about — and costs ~420 tokens for a seven-element diagram. So this
+ * walks the parsed model instead and writes the flow as a sentence, which keeps every name
+ * whole at roughly a sixth of the size.
+ */
+/**
+ * Convert BPMN XML to a compact flow description.
+ *
+ * Returns an empty string for a diagram with no flow nodes, so a caller can drop the embed
+ * rather than emit an empty heading.
+ */
+export declare function bpmnToText(xml: string): string;
+//# sourceMappingURL=bpmn-text.d.ts.map

package/dist/bpmn-text.js

@@ -0,0 +1,183 @@
+/**
+ * Rendering an embedded BPMN diagram as text an agent can read.
+ *
+ * Camunda's best-practice pages carry their argument in the diagram: a page about naming
+ * gateways shows the gateway, its question and the labels on its outgoing flows. Camunda's
+ * own Markdown export drops those embeds, so the prose is left referring to elements that
+ * are not in the text at all.
+ *
+ * `@bpmnkit/ascii` already draws BPMN as box art, but it truncates element labels to the
+ * box width (`Reject payment of in…`) and omits condition expressions — exactly the two
+ * things these pages are about — and costs ~420 tokens for a seven-element diagram. So this
+ * walks the parsed model instead and writes the flow as a sentence, which keeps every name
+ * whole at roughly a sixth of the size.
+ */
+import { Bpmn } from "@bpmnkit/core";
+/** Element types whose kind is worth naming in the text; everything else reads as its name. */
+const KIND = {
+    startEvent: "start",
+    endEvent: "end",
+    intermediateCatchEvent: "intermediate catch event",
+    intermediateThrowEvent: "intermediate throw event",
+    boundaryEvent: "boundary event",
+    exclusiveGateway: "exclusive gateway",
+    parallelGateway: "parallel gateway",
+    inclusiveGateway: "inclusive gateway",
+    eventBasedGateway: "event-based gateway",
+    complexGateway: "complex gateway",
+    subProcess: "subprocess",
+    callActivity: "call activity",
+    serviceTask: "service task",
+    userTask: "user task",
+    scriptTask: "script task",
+    businessRuleTask: "business rule task",
+    sendTask: "send task",
+    receiveTask: "receive task",
+    manualTask: "manual task",
+};
+/**
+ * Convert BPMN XML to a compact flow description.
+ *
+ * Returns an empty string for a diagram with no flow nodes, so a caller can drop the embed
+ * rather than emit an empty heading.
+ */
+export function bpmnToText(xml) {
+    const definitions = Bpmn.parse(withSyntheticIds(xml));
+    const blocks = [];
+    for (const process of definitions.processes) {
+        const lines = describeProcess(process);
+        if (lines.length === 0)
+            continue;
+        const title = process.name ? `Diagram (BPMN): ${process.name}` : "Diagram (BPMN):";
+        blocks.push([title, ...lines].join("\n"));
+    }
+    return blocks.join("\n\n");
+}
+/** Elements `Bpmn.parse` demands an `id` on, though the BPMN 2.0 schema marks it optional. */
+const ID_OPTIONAL = /<((?:[\w.-]+:)?(?:definitions|BPMNDiagram|BPMNPlane))(\s[^>]*?)?(\/?)>/g;
+/**
+ * Supply the ids `Bpmn.parse` insists on.
+ *
+ * It rejects `<definitions>`, `<bpmndi:BPMNDiagram>` and `<bpmndi:BPMNPlane>` without an `id`,
+ * but `tDefinitions` and the DI types all mark that attribute optional, and 10 of the 141
+ * diagrams in camunda-docs omit it. Without this, a tenth of the diagrams would go
+ * undescribed — the exact failure this module exists to prevent.
+ *
+ * This is a workaround for the parser's strictness, not a property of these documents. If
+ * `@bpmnkit/core` is relaxed to match the schema, delete this and its call site.
+ */
+function withSyntheticIds(xml) {
+    let counter = 0;
+    return xml.replace(ID_OPTIONAL, (tag, name, attributes, close) => {
+        const declared = attributes ?? "";
+        if (/\sid\s*=/.test(declared))
+            return tag;
+        counter += 1;
+        return `<${name}${declared} id="docspack_${counter}"${close}>`;
+    });
+}
+function describeProcess(process) {
+    const byId = new Map(process.flowElements.map((element) => [element.id, element]));
+    const outgoing = new Map();
+    const targets = new Set();
+    for (const flow of process.sequenceFlows) {
+        outgoing.set(flow.sourceRef, [...(outgoing.get(flow.sourceRef) ?? []), flow]);
+        targets.add(flow.targetRef);
+    }
+    // A start event is the natural entry point; a fragment without one (the docs are full of
+    // them, showing three elements out of a larger model) is entered at whatever has no
+    // incoming flow, and failing that at the first element, so nothing goes undescribed.
+    const starts = process.flowElements.filter((element) => element.type === "startEvent");
+    const roots = starts.length > 0 ? starts : process.flowElements.filter((element) => !targets.has(element.id));
+    const entries = roots.length > 0 ? roots : process.flowElements.slice(0, 1);
+    const lines = [];
+    const walked = new Set();
+    for (const entry of entries)
+        walk(entry, "  ", lines, { byId, outgoing, walked });
+    const lanes = describeLanes(process);
+    if (lanes.length > 0)
+        lines.push(...lanes);
+    for (const annotation of process.textAnnotations) {
+        const text = collapse(annotation.text ?? "");
+        if (text !== "")
+            lines.push(`  note: ${text}`);
+    }
+    return lines;
+}
+/**
+ * Write one path through the model, branching onto indented lines at every split.
+ *
+ * `walked` is shared across the whole process rather than per path: a join reached from two
+ * branches is described once, and a loop terminates instead of unrolling forever.
+ */
+function walk(start, indent, lines, context) {
+    const segment = [];
+    let current = start;
+    while (current) {
+        if (context.walked.has(current.id)) {
+            segment.push(`(back to ${label(current)})`);
+            break;
+        }
+        context.walked.add(current.id);
+        segment.push(label(current));
+        const flows = context.outgoing.get(current.id) ?? [];
+        if (flows.length === 0)
+            break;
+        if (flows.length === 1) {
+            const only = flows[0];
+            if (!only)
+                break;
+            const edge = edgeLabel(only);
+            if (edge !== "")
+                segment.push(edge);
+            current = context.byId.get(only.targetRef);
+            continue;
+        }
+        lines.push(`${indent}${segment.join(" → ")}`);
+        for (const flow of flows) {
+            const target = context.byId.get(flow.targetRef);
+            if (!target)
+                continue;
+            const edge = edgeLabel(flow);
+            const prefix = `${indent}  — ${edge === "" ? "" : `${edge} `}`;
+            const branch = [];
+            walk(target, `${indent}  `, branch, context);
+            const [first = "", ...rest] = branch;
+            lines.push(`${prefix}${first.trim()}`, ...rest);
+        }
+        return;
+    }
+    if (segment.length > 0)
+        lines.push(`${indent}${segment.join(" → ")}`);
+}
+/** A flow's own label: its name, its condition, or both — the part a reader is told to write. */
+function edgeLabel(flow) {
+    const name = collapse(flow.name ?? "");
+    const condition = collapse(flow.conditionExpression?.text ?? "");
+    if (name !== "" && condition !== "")
+        return `[${name}: ${condition}]`;
+    if (name !== "")
+        return `[${name}]`;
+    if (condition !== "")
+        return `[${condition}]`;
+    return "";
+}
+function label(element) {
+    const name = collapse(element.name ?? "");
+    const kind = KIND[element.type];
+    if (name === "")
+        return kind ?? element.type;
+    return kind === undefined ? `"${name}"` : `${kind} "${name}"`;
+}
+function describeLanes(process) {
+    const lanes = process.laneSet?.lanes ?? [];
+    const named = lanes.filter((lane) => collapse(lane.name ?? "") !== "");
+    if (named.length === 0)
+        return [];
+    return [`  lanes: ${named.map((lane) => collapse(lane.name ?? "")).join(", ")}`];
+}
+/** Modeller labels wrap with newlines for the canvas; a chunk wants one line. */
+function collapse(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+//# sourceMappingURL=bpmn-text.js.map

package/dist/build.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The whole build: stage camunda-docs, then hand the result to `@bpmnkit/docspack`.
+ *
+ * Chunking, manifest and `llms.txt` are all the docspack package's job — this adds only what
+ * it cannot know, which is how to turn Camunda's MDX into Markdown worth indexing.
+ */
+import { type StageResult } from "./stage.js";
+export interface BuildOptions {
+    /** Root of a camunda-docs checkout. */
+    camundaDocs: string;
+    /** This package's root — `.llms/`, `llms.txt` and `NOTICE` are written here. */
+    packDir: string;
+    /** Upstream commit the checkout is at, recorded in the NOTICE for attribution. */
+    commit: string;
+}
+export interface BuildReport extends StageResult {
+    chunks: number;
+    tokens: number;
+}
+export declare function build(options: BuildOptions): BuildReport;
+//# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -0,0 +1,35 @@
+/**
+ * The whole build: stage camunda-docs, then hand the result to `@bpmnkit/docspack`.
+ *
+ * Chunking, manifest and `llms.txt` are all the docspack package's job — this adds only what
+ * it cannot know, which is how to turn Camunda's MDX into Markdown worth indexing.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { buildPack } from "@bpmnkit/docspack";
+import { notice } from "./notice.js";
+import { stage } from "./stage.js";
+export function build(options) {
+    const packDir = resolve(options.packDir);
+    const manifest = JSON.parse(readFileSync(join(packDir, "package.json"), "utf8"));
+    const config = manifest.docspack ?? {};
+    const staging = resolve(packDir, config.source ?? "./build/staging");
+    const staged = stage({ source: options.camundaDocs, out: staging });
+    const result = buildPack({
+        source: staging,
+        packDir,
+        name: manifest.name,
+        version: manifest.version,
+        documents: config.documents ?? [manifest.name],
+        ...(manifest.description ? { description: manifest.description } : {}),
+        ...(config.siteUrl ? { siteUrl: config.siteUrl } : {}),
+        ...(config.maxTokens === undefined ? {} : { maxTokens: config.maxTokens }),
+        ...(config.minTokens === undefined ? {} : { minTokens: config.minTokens }),
+    });
+    // Written by the build rather than kept by hand: CC BY-SA 3.0 obliges this package to say
+    // which upstream revision it adapted and what it changed, and a hand-maintained notice
+    // would state last month's commit.
+    writeFileSync(join(packDir, "NOTICE"), notice(options.commit));
+    return { ...staged, chunks: result.chunks, tokens: result.tokens };
+}
+//# sourceMappingURL=build.js.map

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * `camunda-docspack-build` — regenerate this package's `.llms/` payload.
+ *
+ * It needs a camunda-docs checkout, which it does not clone itself: the weekly workflow
+ * already does that and records the commit it used, and a build that fetched its own source
+ * could not be asked to produce the same bytes twice.
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * `camunda-docspack-build` — regenerate this package's `.llms/` payload.
+ *
+ * It needs a camunda-docs checkout, which it does not clone itself: the weekly workflow
+ * already does that and records the commit it used, and a build that fetched its own source
+ * could not be asked to produce the same bytes twice.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { build } from "./build.js";
+const USAGE = `camunda-docspack-build — build the Camunda 8 docspack payload
+
+Usage:
+  camunda-docspack-build [--camunda-docs <dir>]
+
+Options:
+  --camunda-docs <dir>   Path to a camunda-docs checkout.
+                         Defaults to $CAMUNDA_DOCS, then ../camunda-docs.
+`;
+function main(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    const flag = argv.indexOf("--camunda-docs");
+    const packDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+    const camundaDocs = resolve((flag === -1 ? undefined : argv[flag + 1]) ??
+        process.env.CAMUNDA_DOCS ??
+        resolve(packDir, "../../../camunda-docs"));
+    if (!existsSync(camundaDocs)) {
+        process.stderr.write(`No camunda-docs checkout at ${camundaDocs}.\nClone it, then pass --camunda-docs <dir> or set CAMUNDA_DOCS.\n`);
+        return 1;
+    }
+    const report = build({ camundaDocs, packDir, commit: headCommit(camundaDocs) });
+    process.stdout.write(`Built ${report.chunks} chunks from ${report.documents} documents ` +
+        `(${report.tokens.toLocaleString("en-US")} tokens), ` +
+        `${report.diagrams} diagrams, ${report.partials} partials, ` +
+        `${report.operations} API operations.\n`);
+    for (const missing of report.missingDiagrams) {
+        process.stderr.write(`warning: diagram not found in static/bpmn: ${missing}\n`);
+    }
+    if (report.unresolvedLinks.length > 0) {
+        process.stderr.write(`warning: ${report.unresolvedLinks.length} link(s) name a page missing upstream:\n`);
+        for (const link of report.unresolvedLinks)
+            process.stderr.write(`  ${link}\n`);
+    }
+    return 0;
+}
+/** The upstream revision, for the NOTICE. Unknown is recorded, never guessed. */
+function headCommit(dir) {
+    try {
+        return execFileSync("git", ["-C", dir, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
+    }
+    catch {
+        return "unknown revision";
+    }
+}
+process.exitCode = main(process.argv.slice(2));
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@bpmnkit/camunda-docspack` — Camunda 8 documentation as a docspack package.
+ *
+ * The published artefact is the `.llms/` payload; these exports are the build that produces
+ * it, so the weekly workflow and the tests can drive the same code the CLI does.
+ *
+ * @see https://docspack.dev/spec for the package format.
+ */
+export { type BuildOptions, type BuildReport, build } from "./build.js";
+export { bpmnToText } from "./bpmn-text.js";
+export { SITE_URL, absoluteLinks } from "./links.js";
+export { type StripOptions, UnknownConstructError, stripMdx } from "./mdx.js";
+export { LICENCE_URL, UPSTREAM, notice } from "./notice.js";
+export { type Operation, readOperations } from "./openapi.js";
+export { INCLUDED, type StageOptions, type StageResult, stage } from "./stage.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * `@bpmnkit/camunda-docspack` — Camunda 8 documentation as a docspack package.
+ *
+ * The published artefact is the `.llms/` payload; these exports are the build that produces
+ * it, so the weekly workflow and the tests can drive the same code the CLI does.
+ *
+ * @see https://docspack.dev/spec for the package format.
+ */
+export { build } from "./build.js";
+export { bpmnToText } from "./bpmn-text.js";
+export { SITE_URL, absoluteLinks } from "./links.js";
+export { UnknownConstructError, stripMdx } from "./mdx.js";
+export { LICENCE_URL, UPSTREAM, notice } from "./notice.js";
+export { readOperations } from "./openapi.js";
+export { INCLUDED, stage } from "./stage.js";
+//# sourceMappingURL=index.js.map

package/dist/links.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rewriting Camunda's in-repo links to absolute documentation URLs.
+ *
+ * A chunk is read far away from the tree it came from, so `](/components/foo.md#bar)` and
+ * `](../naming-bpmn-elements/)` are worse than no link: they look resolvable and are not.
+ * Docusaurus serves `docs/` at `/docs/next/<path minus extension>/`, and nothing in the
+ * selected corpus overrides its URL with frontmatter `slug`, so the file path is the URL.
+ */
+/** Where the unreleased tree is published. */
+export declare const SITE_URL = "https://docs.camunda.io/docs/next";
+/**
+ * Rewrite every relative link in one document.
+ *
+ * @param markdown document body
+ * @param slug the document's own path under `docs/`, without extension
+ */
+export declare function absoluteLinks(markdown: string, slug: string): string;
+//# sourceMappingURL=links.d.ts.map

package/dist/links.js

@@ -0,0 +1,72 @@
+/**
+ * Rewriting Camunda's in-repo links to absolute documentation URLs.
+ *
+ * A chunk is read far away from the tree it came from, so `](/components/foo.md#bar)` and
+ * `](../naming-bpmn-elements/)` are worse than no link: they look resolvable and are not.
+ * Docusaurus serves `docs/` at `/docs/next/<path minus extension>/`, and nothing in the
+ * selected corpus overrides its URL with frontmatter `slug`, so the file path is the URL.
+ */
+/** Where the unreleased tree is published. */
+export const SITE_URL = "https://docs.camunda.io/docs/next";
+const INLINE_LINK = /\]\(([^)\s]+)(\s+"[^"]*")?\)/g;
+/**
+ * Rewrite every relative link in one document.
+ *
+ * @param markdown document body
+ * @param slug the document's own path under `docs/`, without extension
+ */
+export function absoluteLinks(markdown, slug) {
+    return markdown.replace(INLINE_LINK, (match, target, title = "") => {
+        const url = resolve(target, slug);
+        return url === undefined ? match : `](${url}${title})`;
+    });
+}
+function resolve(target, slug) {
+    if (target === "" || /^[a-z][\w+.-]*:/i.test(target) || target.startsWith("#"))
+        return undefined;
+    const [rawPath = "", hash = ""] = splitHash(target);
+    if (rawPath === "")
+        return undefined;
+    // Camunda writes relative links both ways, and Docusaurus resolves them differently.
+    //
+    // A link naming a file — `./sizing-your-environment.md` — is a file reference, resolved
+    // against the directory the linking document sits in. A link without an extension —
+    // `../naming-bpmn-elements/` — is left as a URL for the browser, which resolves it against
+    // the page's own trailing-slash URL, making the slug itself the base directory.
+    //
+    // Applying either rule to both forms breaks roughly a third of the corpus's links.
+    const isFile = /\.mdx?$/.test(rawPath);
+    const base = isFile ? slug.split("/").slice(0, -1) : slug.split("/");
+    const path = rawPath.startsWith("/") ? rawPath.slice(1) : joinRelative(base, rawPath);
+    if (path === undefined)
+        return undefined;
+    // An image or download keeps its extension and is served from the site root, not from the
+    // docs tree; only a page reference loses `.md` and gains the version prefix.
+    const page = path.replace(/\.mdx?$/, "");
+    if (page === path && /\.[a-z0-9]{2,5}$/i.test(path))
+        return undefined;
+    return `${SITE_URL}/${trimSlashes(page)}${hash}`;
+}
+function splitHash(target) {
+    const index = target.indexOf("#");
+    return index === -1 ? [target, ""] : [target.slice(0, index), target.slice(index)];
+}
+/** Apply `.` and `..` segments against the linking document's own directory. */
+function joinRelative(base, target) {
+    const segments = [...base];
+    for (const part of target.split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..") {
+            if (segments.pop() === undefined)
+                return undefined;
+            continue;
+        }
+        segments.push(part);
+    }
+    return segments.join("/");
+}
+function trimSlashes(value) {
+    return value.replace(/^\/+|\/+$/g, "");
+}
+//# sourceMappingURL=links.js.map