@bpmnkit/camunda-docspack 0.0.0

package/dist/mdx.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Reducing Camunda's MDX to the Markdown a chunk should carry.
+ *
+ * The rule this module exists to enforce: **never drop anything silently**. Camunda's own
+ * `docusaurus-plugin-llms` export removes every construct it does not recognise, which is how
+ * 94 BPMN diagrams vanish from the best-practice pages while the prose goes on referring to
+ * them. Here an unrecognised component is an error naming the file and line, so a new upstream
+ * component stops the build instead of quietly thinning the corpus.
+ */
+/** Raised when a document uses a construct no rule covers. The build must not continue. */
+export declare class UnknownConstructError extends Error {
+    readonly file: string;
+    readonly line: number;
+    readonly construct: string;
+    constructor(file: string, line: number, construct: string);
+}
+export interface StripOptions {
+    /** Path reported in an error, so a failure names the upstream file a human must look at. */
+    file: string;
+    /** Lines removed before this body, so a reported line number opens the right place. */
+    lineOffset?: number;
+    /** Resolve `<div bpmn="…"/>` to flow text. Returning undefined drops the embed. */
+    renderBpmn?: (path: string) => string | undefined;
+    /**
+     * Read an imported Markdown partial, relative to the importing file. Returning undefined
+     * leaves the component to the allowlist, so a missing partial fails loudly.
+     */
+    readPartial?: (importPath: string) => string | undefined;
+    /** Guards against a partial that imports itself, directly or through another. */
+    depth?: number;
+}
+/**
+ * Strip one MDX document to Markdown.
+ *
+ * @throws UnknownConstructError when a component appears that no rule covers.
+ */
+export declare function stripMdx(source: string, options: StripOptions): string;
+//# sourceMappingURL=mdx.d.ts.map

package/dist/mdx.js

@@ -0,0 +1,222 @@
+/**
+ * Reducing Camunda's MDX to the Markdown a chunk should carry.
+ *
+ * The rule this module exists to enforce: **never drop anything silently**. Camunda's own
+ * `docusaurus-plugin-llms` export removes every construct it does not recognise, which is how
+ * 94 BPMN diagrams vanish from the best-practice pages while the prose goes on referring to
+ * them. Here an unrecognised component is an error naming the file and line, so a new upstream
+ * component stops the build instead of quietly thinning the corpus.
+ */
+/** Raised when a document uses a construct no rule covers. The build must not continue. */
+export class UnknownConstructError extends Error {
+    file;
+    line;
+    construct;
+    constructor(file, line, construct) {
+        super(`${file}:${line}: unhandled MDX construct <${construct}>`);
+        this.file = file;
+        this.line = line;
+        this.construct = construct;
+        this.name = "UnknownConstructError";
+    }
+}
+/**
+ * Components that carry meaning and are replaced by text rather than removed.
+ *
+ * `MarkerCamundaExtension` is the reason this map exists: it appears 25 times in the FEEL
+ * reference to mark a function as Camunda's own rather than standard FEEL, and a reader who
+ * loses it is told the opposite of the truth.
+ */
+const REPLACED = {
+    MarkerCamundaExtension: "(Camunda extension)",
+    MarkerStronglyConsistentExtension: "(strongly consistent)",
+    MarkerEventuallyConsistentExtension: "(eventually consistent)",
+    MarkerRequiredPermissions: "(requires permissions)",
+    MarkerGuideline: "(guideline)",
+    MarkerAddedInVersion: "(added in version)",
+    GitHubInlineIcon: "",
+};
+/** Components that are page furniture: navigation cards, decorative icons, layout wrappers. */
+const DROPPED = new Set([
+    "PageDescription",
+    "AoGrid",
+    "ApiGrid",
+    "FormViewer",
+    "Versions",
+    "GlossaryTerm",
+    "CamundaDistributions",
+    "CamundaSelfManaged",
+    "HelmInstallOverviewMethods",
+    "Property",
+    "Highlight",
+    "br",
+    "hr",
+    "img",
+    "p",
+    "span",
+    "div",
+    "a",
+    "b",
+    "i",
+    "em",
+    "strong",
+    "code",
+    "pre",
+    "ul",
+    "ol",
+    "li",
+    "table",
+    "thead",
+    "tbody",
+    "tr",
+    "td",
+    "th",
+    "small",
+    "sup",
+    "sub",
+    "details",
+    "summary",
+    "figure",
+    "figcaption",
+]);
+/** An imported SVG component renders as an inline icon; its name is the only text in it. */
+const SVG_COMPONENT = /^[A-Z][A-Za-z0-9]*Svg$/;
+const ADMONITION = /^:::(note|tip|info|caution|warning|important|danger|success)\s*(.*)$/;
+const ADMONITION_END = /^:::\s*$/;
+const IMPORT = /^import\s/;
+const EXPORT = /^export\s/;
+/** A partial chain deeper than this is a cycle, not a document. */
+const MAX_PARTIAL_DEPTH = 4;
+/** `import SaasPrereqs from '../guides/react-components/\_saas-prerequisites.md'` */
+const PARTIAL_IMPORT = /^import\s+(\w+)\s+from\s+["']([^"']+\.mdx?)["']/;
+/**
+ * Strip one MDX document to Markdown.
+ *
+ * @throws UnknownConstructError when a component appears that no rule covers.
+ */
+export function stripMdx(source, options) {
+    const out = [];
+    let fence = null;
+    const partials = partialImports(source);
+    const lines = source.split(/\r?\n/);
+    for (const [index, raw] of lines.entries()) {
+        const line = raw;
+        const number = index + 1 + (options.lineOffset ?? 0);
+        const fenceMatch = /^\s*(```+|~~~+)/.exec(line);
+        if (fenceMatch?.[1]) {
+            fence = fence === null ? (fenceMatch[1][0] ?? null) : null;
+            out.push(line);
+            continue;
+        }
+        if (fence !== null) {
+            out.push(line);
+            continue;
+        }
+        if (IMPORT.test(line) || EXPORT.test(line))
+            continue;
+        const admonition = ADMONITION.exec(line.trim());
+        if (admonition?.[1]) {
+            const title = (admonition[2] ?? "").trim();
+            out.push(`**${capitalize(admonition[1])}${title === "" ? "" : `: ${title}`}**`);
+            continue;
+        }
+        if (ADMONITION_END.test(line.trim()))
+            continue;
+        const bpmn = /<div\s+bpmn="([^"]+)"[^>]*\/?>/.exec(line);
+        if (bpmn?.[1]) {
+            const rendered = options.renderBpmn?.(bpmn[1]);
+            if (rendered !== undefined && rendered.trim() !== "")
+                out.push("", rendered, "");
+            continue;
+        }
+        // A partial is included by using the component the import bound it to. Its prose is the
+        // page's prose — prerequisites, setup steps — so it is inlined, not dropped.
+        const used = /<(\w+)\s*\/>/.exec(line.trim());
+        const importPath = used?.[1] === undefined ? undefined : partials.get(used[1]);
+        if (importPath !== undefined) {
+            const partial = options.readPartial?.(importPath);
+            if (partial !== undefined) {
+                out.push("", inlinePartial(partial, importPath, options), "");
+                continue;
+            }
+        }
+        // `<span className="callout">1</span>` numbers a element in the diagram above. The
+        // number means nothing on its own, so it becomes an ordered marker the prose after it
+        // still reads correctly against.
+        const calloutMatch = /<span\s+className="callout">\s*(\d+)\s*<\/span>/.exec(line);
+        if (calloutMatch?.[1]) {
+            out.push(`**(${calloutMatch[1]})**`);
+            continue;
+        }
+        out.push(replaceComponents(line, options.file, number));
+    }
+    return collapseBlankRuns(out.join("\n")).trim();
+}
+/**
+ * Rewrite or remove every JSX tag on one line, failing on anything unrecognised.
+ *
+ * Inline code is left alone first: `<key>` in `run view <key>` is a placeholder a reader is
+ * meant to substitute, and rewriting or refusing it would be wrong both ways.
+ */
+function replaceComponents(line, file, number) {
+    return outsideCode(line, (text) => replaceTags(text, file, number));
+}
+function replaceTags(text, file, number) {
+    return text.replace(/<\/?([A-Za-z][\w.]*)\b[^>]*>/g, (tag, rawName) => {
+        const name = rawName.split(".")[0] ?? rawName;
+        const replacement = REPLACED[name];
+        if (replacement !== undefined)
+            return replacement;
+        if (SVG_COMPONENT.test(name))
+            return "";
+        if (DROPPED.has(name))
+            return "";
+        // JSX components are capitalised by the language's own rule. A lowercase name that is
+        // not HTML is prose in angle brackets — `<your-token>`, `<version>` — and belongs to
+        // the sentence, so it stays exactly as written.
+        if (name[0] === name[0]?.toLowerCase())
+            return tag;
+        // Tabs are the one construct that must keep its labels: a tab titled "VS Code Copilot"
+        // is the search term someone would actually type.
+        if (name === "Tabs")
+            return "";
+        if (name === "TabItem") {
+            const value = /value=\{?"([^"]+)"\}?/.exec(tag)?.[1];
+            return value === undefined ? "" : `\n### ${value}\n`;
+        }
+        throw new UnknownConstructError(file, number, name);
+    });
+}
+/** Map every `import Name from "./partial.md"` in a document to the path it names. */
+function partialImports(source) {
+    const found = new Map();
+    for (const line of source.split(/\r?\n/)) {
+        const match = PARTIAL_IMPORT.exec(line.trim());
+        if (!match?.[1] || !match[2])
+            continue;
+        // Docusaurus escapes the leading underscore of a partial's filename for MDX.
+        found.set(match[1], match[2].replace(/\\_/g, "_"));
+    }
+    return found;
+}
+/** Strip a partial with the same rules, keeping its own frontmatter out of the prose. */
+function inlinePartial(source, path, options) {
+    const depth = (options.depth ?? 0) + 1;
+    if (depth > MAX_PARTIAL_DEPTH) {
+        throw new Error(`${options.file}: partial imports nested more than ${MAX_PARTIAL_DEPTH} deep`);
+    }
+    const body = source.replace(/^?---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+    return stripMdx(body, { ...options, file: path, lineOffset: 0, depth });
+}
+/** Apply `transform` to the parts of a line that are not inside an inline code span. */
+function outsideCode(line, transform) {
+    const parts = line.split(/(`+[^`]*`+)/);
+    return parts.map((part) => (part.startsWith("`") ? part : transform(part))).join("");
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function collapseBlankRuns(text) {
+    return text.replace(/\n{3,}/g, "\n\n");
+}
+//# sourceMappingURL=mdx.js.map

package/dist/notice.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The attribution this package is legally obliged to carry.
+ *
+ * camunda-docs is licensed CC BY-SA 3.0. Chunking the prose, rendering embedded BPMN as text
+ * and rewriting links make this package an *Adaptation* under §1 of that licence rather than a
+ * Collection, which obliges it to credit the Original Author, to "clearly label, demarcate or
+ * otherwise identify that changes were made", and to license the result under the same terms.
+ *
+ * It is generated on every build so the commit it names is the one actually adapted.
+ */
+export declare const UPSTREAM = "https://github.com/camunda/camunda-docs";
+export declare const LICENCE_URL = "https://creativecommons.org/licenses/by-sa/3.0/";
+export declare function notice(commit: string): string;
+//# sourceMappingURL=notice.d.ts.map

package/dist/notice.js

@@ -0,0 +1,45 @@
+/**
+ * The attribution this package is legally obliged to carry.
+ *
+ * camunda-docs is licensed CC BY-SA 3.0. Chunking the prose, rendering embedded BPMN as text
+ * and rewriting links make this package an *Adaptation* under §1 of that licence rather than a
+ * Collection, which obliges it to credit the Original Author, to "clearly label, demarcate or
+ * otherwise identify that changes were made", and to license the result under the same terms.
+ *
+ * It is generated on every build so the commit it names is the one actually adapted.
+ */
+export const UPSTREAM = "https://github.com/camunda/camunda-docs";
+export const LICENCE_URL = "https://creativecommons.org/licenses/by-sa/3.0/";
+/** The changes this package makes to the original work, as §4(b) requires them to be stated. */
+const 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",
+];
+export function notice(commit) {
+    return `${[
+        "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: ${UPSTREAM} @ ${commit}`,
+        "Published at: https://docs.camunda.io/docs/next/",
+        `Licensed by Camunda under CC BY-SA 3.0: ${LICENCE_URL}`,
+        "",
+        "The original work has been modified. Changes:",
+        ...CHANGES.map((change) => `  - ${change}`),
+        "",
+        "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.",
+    ].join("\n")}\n`;
+}
+//# sourceMappingURL=notice.js.map

package/dist/openapi.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Turning the Orchestration Cluster API specification into one digest per operation.
+ *
+ * The generated reference pages in `docs/apis-tools/*​/specifications/` are unusable here — each
+ * one is a base64-gzipped blob wrapped in React imports, with no prose an index can match. The
+ * specification itself is the real source, so operations are read from it directly.
+ *
+ * The document is modular: the entry file's `paths` are `$ref`s into 50 sibling files, each with
+ * its own `components`. Rather than bundle it — which means solving name collisions and
+ * recursive schemas for an artefact nobody reads — references are resolved on demand, relative
+ * to the file they appear in, and only to the depth a digest shows.
+ */
+export interface Operation {
+    /** Kebab-cased `operationId`, which is also the page Camunda publishes it at. */
+    readonly slug: string;
+    readonly operationId: string;
+    readonly method: string;
+    readonly path: string;
+    readonly summary: string;
+    readonly digest: string;
+    /**
+     * Search terms the index weights above prose.
+     *
+     * Without these a digest loses every query to the concept pages: it says "activate" and
+     * "jobs" once each, while the prose that merely mentions jobs says them twenty times, and
+     * BM25 has no reason to prefer the endpoint. These are the words someone actually types.
+     */
+    readonly tags: string[];
+    /** Both spellings of the operation's address, so it can be asked for by name. */
+    readonly entities: string[];
+}
+/**
+ * Read every operation in the specification, in a stable order.
+ *
+ * @param entry path to the entry document, e.g. `api/camunda/v2/camunda-openapi.yaml`
+ */
+export declare function readOperations(entry: string): Operation[];
+//# sourceMappingURL=openapi.d.ts.map

package/dist/openapi.js

@@ -0,0 +1,297 @@
+/**
+ * Turning the Orchestration Cluster API specification into one digest per operation.
+ *
+ * The generated reference pages in `docs/apis-tools/*​/specifications/` are unusable here — each
+ * one is a base64-gzipped blob wrapped in React imports, with no prose an index can match. The
+ * specification itself is the real source, so operations are read from it directly.
+ *
+ * The document is modular: the entry file's `paths` are `$ref`s into 50 sibling files, each with
+ * its own `components`. Rather than bundle it — which means solving name collisions and
+ * recursive schemas for an artefact nobody reads — references are resolved on demand, relative
+ * to the file they appear in, and only to the depth a digest shows.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse } from "yaml";
+/** A schema expanded deeper than this stops being a digest and becomes the document again. */
+const MAX_FIELD_DEPTH = 1;
+/** Fields listed beyond this are elided; the schema name is there for the rest. */
+const MAX_FIELDS = 25;
+/** A field note longer than this is a paragraph, not a label. */
+const MAX_FIELD_NOTE = 160;
+/**
+ * Read every operation in the specification, in a stable order.
+ *
+ * @param entry path to the entry document, e.g. `api/camunda/v2/camunda-openapi.yaml`
+ */
+export function readOperations(entry) {
+    const cache = new Map();
+    const load = (file) => {
+        const cached = cache.get(file);
+        if (cached !== undefined)
+            return cached;
+        const parsed = (parse(readFileSync(file, "utf8")) ?? {});
+        cache.set(file, parsed);
+        return parsed;
+    };
+    const root = { value: load(entry), file: entry };
+    const paths = asRecord(root.value.paths);
+    const operations = [];
+    // Code-unit order, not localeCompare: collation is locale-dependent, and the build asserts
+    // that the same commit produces the same bytes on any runner.
+    for (const [path, entryValue] of Object.entries(paths).sort(([a], [b]) => (a < b ? -1 : 1))) {
+        const item = deref(entryValue, root, load);
+        if (item === undefined)
+            continue;
+        for (const method of ["get", "post", "put", "patch", "delete"]) {
+            const raw = asRecord(item.value[method]);
+            const operationId = asString(raw.operationId);
+            if (operationId === "")
+                continue;
+            const context = { value: load(item.file), file: item.file };
+            operations.push({
+                slug: kebab(operationId),
+                operationId,
+                method: method.toUpperCase(),
+                path,
+                summary: asString(raw.summary) || operationId,
+                digest: digest(method.toUpperCase(), path, raw, context, load),
+                tags: searchTerms(operationId, method, path, raw),
+                entities: [operationId, `${method.toUpperCase()} ${path}`],
+            });
+        }
+    }
+    return operations;
+}
+/** Words from the operation's id, verb, address and spec tag — deduplicated, lowercase. */
+function searchTerms(operationId, method, path, raw) {
+    const specTags = Array.isArray(raw.tags) ? raw.tags.map(String) : [];
+    const words = [
+        ...kebab(operationId).split("-"),
+        method.toLowerCase(),
+        ...path.split(/[/{}]/),
+        ...specTags.flatMap((tag) => tag.toLowerCase().split(/[\s-]+/)),
+        "api",
+        "endpoint",
+    ];
+    return [...new Set(words.map((word) => word.toLowerCase()).filter((word) => word.length > 1))];
+}
+/** One operation, written as the lines an agent needs to make the call and nothing more. */
+function digest(method, path, raw, context, load) {
+    const lines = [`\`${method} ${path}\``, ""];
+    const notes = markers(asString(raw.description));
+    const prose = withoutMarkers(asString(raw.description)).trim();
+    if (prose !== "")
+        lines.push(prose, "");
+    if (notes.length > 0)
+        lines.push(...notes.map((note) => `- ${note}`), "");
+    const auth = securitySchemes(raw.security);
+    if (auth.length > 0)
+        lines.push(`Authentication: ${auth.join(" or ")}`, "");
+    const parameters = describeParameters(raw.parameters, context, load);
+    if (parameters.length > 0)
+        lines.push("Parameters:", ...parameters, "");
+    const body = describeBody(raw.requestBody, context, load);
+    if (body.length > 0)
+        lines.push("Request body:", ...body, "");
+    const responses = describeResponses(raw.responses, context, load);
+    if (responses.length > 0)
+        lines.push("Responses:", ...responses, "");
+    return lines
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/**
+ * Camunda encodes three facts into the description as `[[MARKER:value]]`, which its own site
+ * renders as admonitions. They answer questions an agent actually asks — what permission does
+ * this need, when did it appear, is the read consistent — so they are decoded rather than
+ * stripped. The permissions marker is base64 JSON.
+ */
+function markers(description) {
+    const out = [];
+    for (const match of description.matchAll(/\[\[([A-Z_]+):([^\]]*)\]\]/g)) {
+        const [, name = "", value = ""] = match;
+        if (name === "ADDED_IN_VERSION")
+            out.push(`Added in Camunda ${value}.`);
+        else if (name === "CONSISTENCY")
+            out.push(`Consistency: ${value.toLowerCase()}.`);
+        else if (name === "REQUIRED_PERMISSIONS") {
+            const permissions = decodePermissions(value);
+            if (permissions !== undefined)
+                out.push(`Required permissions: ${permissions}.`);
+        }
+    }
+    return out;
+}
+function decodePermissions(encoded) {
+    try {
+        const parsed = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+        const listed = (parsed.permissions ?? [])
+            .map((entry) => `${entry.permissionType} on ${entry.resourceType}`)
+            .filter((entry) => !entry.includes("undefined"));
+        return listed.length === 0 ? undefined : listed.join(", ");
+    }
+    catch {
+        return undefined;
+    }
+}
+function withoutMarkers(description) {
+    return description.replace(/\[\[[A-Z_]+:[^\]]*\]\]/g, "");
+}
+function securitySchemes(security) {
+    if (!Array.isArray(security))
+        return [];
+    return [...new Set(security.flatMap((entry) => Object.keys(asRecord(entry))))];
+}
+function describeParameters(value, context, load) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const entry of value) {
+        const parameter = deref(entry, context, load)?.value;
+        if (parameter === undefined)
+            continue;
+        const name = asString(parameter.name);
+        if (name === "")
+            continue;
+        const required = parameter.required === true ? ", required" : "";
+        const where = asString(parameter.in);
+        const type = schemaName(parameter.schema, context, load);
+        out.push(`  ${name} (${[where, type, required.slice(2)].filter(Boolean).join(", ")})`);
+    }
+    return out;
+}
+function describeBody(value, context, load) {
+    const body = deref(value, context, load);
+    if (body === undefined)
+        return [];
+    const media = asRecord(body.value.content);
+    const [type, schema] = Object.entries(media)[0] ?? [];
+    if (type === undefined)
+        return [];
+    const target = deref(asRecord(schema).schema, { value: load(body.file), file: body.file }, load);
+    const name = schemaName(asRecord(schema).schema, { value: load(body.file), file: body.file }, load);
+    const required = body.value.required === true ? " (required)" : "";
+    const head = `  ${type}: ${name}${required}`;
+    return target === undefined ? [head] : [head, ...fields(target, load, 1)];
+}
+function describeResponses(value, context, load) {
+    const responses = asRecord(value);
+    const out = [];
+    for (const [status, entry] of Object.entries(responses)) {
+        const response = deref(entry, context, load);
+        if (response === undefined)
+            continue;
+        const media = asRecord(response.value.content);
+        const [, schema] = Object.entries(media)[0] ?? [];
+        const name = schemaName(asRecord(schema).schema, { value: load(response.file), file: response.file }, load);
+        const description = asString(response.value.description).replace(/\s+/g, " ").trim();
+        out.push(`  ${status}${name === "" ? "" : ` ${name}`}${description === "" ? "" : ` — ${description}`}`);
+    }
+    return out;
+}
+/** One level of a schema's own properties: enough to build the call, not the whole type graph. */
+function fields(schema, load, depth) {
+    if (depth > MAX_FIELD_DEPTH)
+        return [];
+    const properties = asRecord(schema.value.properties);
+    const required = new Set(Array.isArray(schema.value.required) ? schema.value.required.map(String) : []);
+    const out = [];
+    for (const [name, value] of Object.entries(properties).slice(0, MAX_FIELDS)) {
+        const property = asRecord(value);
+        const context = { value: load(schema.file), file: schema.file };
+        const type = schemaName(value, context, load) || asString(property.type) || "unknown";
+        const flag = required.has(name) ? ", required" : "";
+        const note = summarize(asString(property.description));
+        out.push(`    ${name} (${type}${flag})${note === "" ? "" : ` — ${note}`}`);
+    }
+    if (Object.keys(properties).length > MAX_FIELDS)
+        out.push("    …");
+    return out;
+}
+/**
+ * A field's description, cut to a line.
+ *
+ * Cut by length at a word boundary rather than at the first full stop: Camunda's field
+ * descriptions are full of abbreviations, and splitting on the period in "(e.g. ..." truncates
+ * the sentence exactly where it was about to become useful.
+ */
+function summarize(description) {
+    const text = description.replace(/\s+/g, " ").trim();
+    if (text.length <= MAX_FIELD_NOTE)
+        return text;
+    const cut = text.slice(0, MAX_FIELD_NOTE);
+    return `${cut.slice(0, cut.lastIndexOf(" ")).trimEnd()}…`;
+}
+/** A schema's name if it has one, else its primitive shape. */
+function schemaName(value, context, load) {
+    const schema = asRecord(value);
+    const ref = asString(schema.$ref);
+    if (ref !== "")
+        return ref.split("/").pop() ?? "";
+    if (asString(schema.type) === "array") {
+        const items = schemaName(schema.items, context, load);
+        return items === "" ? "array" : `${items}[]`;
+    }
+    const composed = schema.allOf ?? schema.oneOf ?? schema.anyOf;
+    if (Array.isArray(composed) && composed[0] !== undefined) {
+        return schemaName(composed[0], context, load);
+    }
+    return asString(schema.type);
+}
+/**
+ * Follow a `$ref` to the thing it names.
+ *
+ * A reference is relative to the file it is written in — `common-responses.yaml#/components/…`
+ * from `jobs.yaml` means the sibling file — so the file travels with the value.
+ */
+function deref(value, context, load) {
+    let current = asRecord(value);
+    let file = context.file;
+    for (let hop = 0; hop < 8; hop++) {
+        const ref = asString(current.$ref);
+        if (ref === "")
+            return { value: current, file };
+        const [target = "", pointer = ""] = ref.split("#");
+        const next = target === "" ? file : join(dirname(file), target);
+        const found = pointerInto(load(next), pointer);
+        if (found === undefined)
+            return undefined;
+        current = found;
+        file = next;
+    }
+    return undefined;
+}
+/** Walk a JSON pointer, undoing the `~1` escape a path like `/jobs/activation` needs. */
+function pointerInto(doc, pointer) {
+    let current = doc;
+    for (const raw of pointer.split("/")) {
+        if (raw === "")
+            continue;
+        const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[key];
+    }
+    return typeof current === "object" && current !== null
+        ? current
+        : undefined;
+}
+/** `activateJobs` → `activate-jobs`, which is the filename Camunda publishes the page at. */
+function kebab(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[^A-Za-z0-9]+/g, "-")
+        .toLowerCase()
+        .replace(/^-+|-+$/g, "");
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : "";
+}
+//# sourceMappingURL=openapi.js.map