@bpmn-ld/bpmn-ld 0.0.0-stage → 0.2.0

package/dist/export/mapping-check.js

@@ -0,0 +1,175 @@
+import { declaredClasses, declaredProperties } from "../ontology.js";
+import { CONTAINMENT, ELEMENT_MAPPINGS, ELEMENT_NAMESPACES, ROOT_ELEMENTS as CONVERTER_ROOTS } from "../convert/mapping.js";
+import { DIAGRAM_EXPORT } from "./diagram.js";
+import { SUPPORTED_ELEMENTS } from "./element.js";
+import { CONTAINS, MAPPINGS } from "./data.js";
+import { ROOT_ELEMENTS as EXPORT_ROOT_TYPES } from "./export.js";
+export const converterTables = () => ({
+    elements: ELEMENT_MAPPINGS,
+    containment: CONTAINMENT,
+    roots: CONVERTER_ROOTS,
+    diagramElements: Object.keys(ELEMENT_NAMESPACES),
+});
+export const exporterTables = () => ({
+    elements: MAPPINGS,
+    containment: CONTAINS,
+    supported: SUPPORTED_ELEMENTS,
+    diagram: DIAGRAM_EXPORT,
+    roots: [...Object.values(EXPORT_ROOT_TYPES), "BPMNDiagram"],
+});
+const DATA_ELEMENTS = [
+    "dataObject",
+    "dataObjectReference",
+    "dataStore",
+    "dataStoreReference",
+    "dataInput",
+    "dataOutput",
+    "inputSet",
+    "outputSet",
+    "ioSpecification",
+    "dataInputAssociation",
+    "dataOutputAssociation",
+    "assignment",
+    "transformation",
+    "from",
+    "to",
+];
+const dataReason = "data constructs are exported but the converter does not read them yet";
+export const ALLOWED_DIFFERENCES = [
+    ...DATA_ELEMENTS.map((name) => ({ where: name, reason: dataReason })),
+    { where: "roots.dataStore", reason: dataReason },
+    { where: "*.singles.ioSpecification", reason: "activities carry an ioSpecification only on export" },
+    { where: "containment.*.data*", reason: "data containment is export-only" },
+    { where: "containment.*.inputSet", reason: "data containment is export-only" },
+    { where: "containment.*.outputSet", reason: "data containment is export-only" },
+    { where: "containment.*.assignment", reason: "data containment is export-only" },
+];
+const flatten = (mapping) => {
+    const paths = new Map();
+    paths.set("type", mapping.type);
+    for (const [attribute, term] of Object.entries(mapping.attributes))
+        paths.set(`attributes.${attribute}`, term);
+    for (const field of ["singles", "textChildren", "textLists"]) {
+        for (const [child, term] of Object.entries(mapping[field] ?? {}))
+            paths.set(`${field}.${child}`, term);
+    }
+    for (const lookup of mapping.lookups ?? [])
+        paths.set(`lookups.${lookup.attribute}`, lookup.term);
+    for (const term of mapping.booleans ?? [])
+        paths.set(`booleans.${term}`, term);
+    for (const term of mapping.numbers ?? [])
+        paths.set(`numbers.${term}`, term);
+    if (mapping.bodyTerm !== undefined)
+        paths.set("bodyTerm", mapping.bodyTerm);
+    return paths;
+};
+const containmentPaths = (containment) => {
+    const paths = new Map();
+    for (const [parent, children] of Object.entries(containment)) {
+        for (const [child, term] of Object.entries(children))
+            paths.set(`containment.${parent}.${child}`, term);
+    }
+    return paths;
+};
+const diagramPaths = (names, terms) => {
+    const paths = new Map();
+    for (const name of names)
+        for (const term of terms(name))
+            paths.set(`diagram.${name}.${term}`, term);
+    return paths;
+};
+const converterDiagram = (converter) => diagramPaths(converter.diagramElements, (name) => {
+    const mapping = converter.elements[name];
+    const flat = [...flatten(mapping)].filter(([path]) => path !== "type").map(([, term]) => term);
+    const contained = Object.values(converter.containment[name] ?? {});
+    return [...flat, ...contained];
+});
+const exporterDiagram = (exporter) => diagramPaths(Object.keys(exporter.diagram), (name) => [...exporter.diagram[name].attributes, ...exporter.diagram[name].children]);
+const compare = (where, converterPaths, exporterPaths, problems) => {
+    for (const [path, term] of converterPaths) {
+        const prefix = where === "" ? "" : `${where}.`;
+        const exported = exporterPaths.get(path);
+        if (exported === undefined)
+            problems.push({ where: `${prefix}${path}`, reason: "not-exported", detail: `converter maps ${path} to ${term}` });
+        else if (exported !== term)
+            problems.push({ where: `${prefix}${path}`, reason: "term-mismatch", detail: `converter ${term}, exporter ${exported}` });
+    }
+    for (const [path, term] of exporterPaths) {
+        if (!converterPaths.has(path))
+            problems.push({ where: `${where === "" ? "" : `${where}.`}${path}`, reason: "export-only", detail: `exporter maps ${path} to ${term}` });
+    }
+};
+const ontologyProblems = (exporter, store, context) => {
+    const classes = declaredClasses(store);
+    const properties = declaredProperties(store);
+    const problems = [];
+    const check = (term, kind, where) => {
+        const iri = context[term];
+        if (iri === undefined)
+            problems.push({ where, reason: "not-in-context", detail: term });
+        else if (!(kind === "class" ? classes : properties).has(iri))
+            problems.push({ where, reason: "not-in-ontology", detail: term });
+    };
+    for (const [element, mapping] of Object.entries(exporter.elements)) {
+        for (const [path, term] of flatten(mapping)) {
+            if (path === "attributes.id")
+                continue;
+            check(term, path === "type" ? "class" : "property", `${element}.${path}`);
+        }
+    }
+    for (const [path, term] of containmentPaths(exporter.containment))
+        check(term, "property", path);
+    for (const [path, term] of exporterDiagram(exporter))
+        if (!path.endsWith(".id"))
+            check(term, "property", path);
+    return problems;
+};
+const matches = (pattern, where) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`).test(where);
+export const checkExportMapping = ({ exporter, converter, store, context, allowed = ALLOWED_DIFFERENCES }) => {
+    const problems = ontologyProblems(exporter, store, context);
+    for (const [element, mapping] of Object.entries(converter.elements)) {
+        const exported = exporter.elements[element];
+        if (exported === undefined) {
+            problems.push({ where: element, reason: "not-exported", detail: `converter element ${element} has no exporter mapping` });
+            continue;
+        }
+        compare(element, flatten(mapping), flatten(exported), problems);
+    }
+    for (const element of Object.keys(exporter.elements)) {
+        if (!(element in converter.elements))
+            problems.push({ where: element, reason: "export-only", detail: `exporter element ${element} is not read by the converter` });
+    }
+    compare("", containmentPaths(converter.containment), containmentPaths(exporter.containment), problems);
+    compare("", converterDiagram(converter), exporterDiagram(exporter), problems);
+    for (const [parent, children] of Object.entries(converter.containment)) {
+        if (converter.diagramElements.includes(parent))
+            continue;
+        for (const child of Object.keys(children)) {
+            if (!(exporter.supported[parent] ?? []).includes(child)) {
+                problems.push({ where: `supported.${parent}.${child}`, reason: "not-supported", detail: `exporter does not export ${child} inside ${parent}` });
+            }
+        }
+    }
+    for (const root of converter.roots) {
+        if (!exporter.roots.includes(root))
+            problems.push({ where: `roots.${root}`, reason: "not-exported", detail: `converter root ${root} is not exported` });
+    }
+    for (const root of exporter.roots) {
+        if (!converter.roots.includes(root))
+            problems.push({ where: `roots.${root}`, reason: "export-only", detail: `exporter root ${root} is not read by the converter` });
+    }
+    const used = new Set();
+    const remaining = problems.filter((problem) => {
+        if (problem.reason !== "export-only")
+            return true;
+        const allowance = allowed.find((entry) => matches(entry.where, problem.where));
+        if (allowance !== undefined)
+            used.add(allowance);
+        return allowance === undefined;
+    });
+    for (const entry of allowed) {
+        if (!used.has(entry))
+            remaining.push({ where: entry.where, reason: "stale-allowance", detail: entry.reason });
+    }
+    return remaining;
+};

package/dist/export/normalize.d.ts

@@ -0,0 +1,3 @@
+import { type Json } from "./element.ts";
+export declare const isFlat: (document: Json) => boolean;
+export declare const normalize: (document: Json, documentUrl?: string) => Promise<Json>;

package/dist/export/normalize.js

@@ -0,0 +1,67 @@
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import jsonld from "jsonld";
+import { COMBINED_CONTEXT_IRI, defaultBase } from "../convert/convert.js";
+import { fileDocumentLoader } from "../loader.js";
+import { ROOT } from "../paths.js";
+import { isObject } from "./element.js";
+const loader = async (url) => fileDocumentLoader(url === COMBINED_CONTEXT_IRI ? pathToFileURL(join(ROOT, "contexts/combined.jsonld")).href : url);
+const isReference = (value) => isObject(value) && Object.keys(value).length === 1 && typeof value.id === "string";
+const topLevelNodes = (document) => (Array.isArray(document["@graph"]) ? document["@graph"] : [document]).filter(isObject);
+const contextBase = (document) => {
+    const context = Array.isArray(document["@context"]) ? document["@context"] : [document["@context"]];
+    const entry = context.find((item) => isObject(item) && typeof item["@base"] === "string");
+    return entry?.["@base"] ?? defaultBase();
+};
+const containsReference = (value, ids) => {
+    if (Array.isArray(value))
+        return value.some((item) => containsReference(item, ids));
+    if (!isObject(value))
+        return false;
+    if (isReference(value))
+        return ids.has(value.id);
+    return Object.entries(value).some(([key, member]) => !key.startsWith("@") && containsReference(member, ids));
+};
+export const isFlat = (document) => {
+    const nodes = topLevelNodes(document);
+    const ids = new Set(nodes.filter((node) => node.type !== undefined && typeof node.id === "string").map((node) => node.id));
+    return nodes.some((node) => Object.entries(node).some(([key, member]) => !key.startsWith("@") && containsReference(member, ids)));
+};
+const nest = (value, index, nested, path) => {
+    if (Array.isArray(value))
+        return value.map((item) => nest(item, index, nested, path));
+    if (!isObject(value))
+        return value;
+    if (isReference(value)) {
+        const target = index.get(value.id);
+        if (target === undefined || path.has(value.id))
+            return value;
+        nested.add(value.id);
+        return nest(target, index, nested, path);
+    }
+    const id = typeof value.id === "string" ? value.id : undefined;
+    if (id !== undefined)
+        path.add(id);
+    const result = {};
+    for (const [key, member] of Object.entries(value)) {
+        if (key === "id" && typeof member === "string" && member.startsWith("_:"))
+            continue;
+        result[key] = key.startsWith("@") ? member : nest(member, index, nested, path);
+    }
+    if (id !== undefined)
+        path.delete(id);
+    return result;
+};
+export const normalize = async (document, documentUrl) => {
+    if (!isFlat(document))
+        return document;
+    const options = { base: documentUrl ?? contextBase(document), documentLoader: loader };
+    const flat = await jsonld.flatten(document, undefined, options);
+    const compacted = await jsonld.compact(flat, document["@context"], options);
+    const nodes = topLevelNodes(compacted);
+    const index = new Map(nodes.filter((node) => typeof node.id === "string").map((node) => [node.id, node]));
+    const nested = new Set();
+    const nodesNested = nodes.map((node) => nest(node, index, nested, new Set()));
+    const roots = nodesNested.filter((_, position) => !(typeof nodes[position].id === "string" && nested.has(nodes[position].id)));
+    return { "@context": compacted["@context"], "@graph": roots };
+};

package/dist/export-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/export-cli.js

@@ -0,0 +1,5 @@
+import { runExport } from "./export-run.js";
+const { exitCode, stdout, stderr } = await runExport(process.argv.slice(2));
+process.stdout.write(stdout);
+process.stderr.write(stderr);
+process.exitCode = exitCode;

package/dist/export-run.d.ts

@@ -0,0 +1,10 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_EXPORT_PROBLEM = 1;
+export declare const EXIT_BAD_INPUT = 2;
+export interface CliResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare const USAGE = "Usage: export <input.jsonld> [options]\n\nExports a BPMN-LD document (nested or flat canonical form) to BPMN 2.0 XML.\n\nOptions:\n  -o, --output <file>  Write XML to <file> instead of standard output\n      --layout         Add BPMN DI first: shapes and edges are laid out for flow nodes\n                       and sequence flows that lack them, existing DI is kept\n      --force          With --layout, replace existing diagrams by a fresh full layout\n      --strict         Exit with code 1 if the export produced any warning\n      --json           Print one JSON document { xml?, warnings, errors } on standard\n                       output instead of the XML and the text diagnostics. xml is\n                       left out when --output is given or the export failed\n  -h, --help           Show this help\n\nWithout --json, warnings and errors are written to standard error.\n\nExit codes:\n  0  Exported successfully\n  1  Strict mode found warnings\n  2  Usage error or unusable input (missing file, invalid JSON, invalid BPMN-LD)\n";
+export declare const runExport: (argv: string[]) => Promise<CliResult>;

package/dist/export-run.js

@@ -0,0 +1,157 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+import { layoutAndExport } from "./export/layout-export.js";
+import { exportDocument, ExportInputError } from "./export/export.js";
+export const EXIT_OK = 0;
+export const EXIT_EXPORT_PROBLEM = 1;
+export const EXIT_BAD_INPUT = 2;
+const MAX_REPORTED_ERRORS = 10;
+export const USAGE = `Usage: export <input.jsonld> [options]
+
+Exports a BPMN-LD document (nested or flat canonical form) to BPMN 2.0 XML.
+
+Options:
+  -o, --output <file>  Write XML to <file> instead of standard output
+      --layout         Add BPMN DI first: shapes and edges are laid out for flow nodes
+                       and sequence flows that lack them, existing DI is kept
+      --force          With --layout, replace existing diagrams by a fresh full layout
+      --strict         Exit with code 1 if the export produced any warning
+      --json           Print one JSON document { xml?, warnings, errors } on standard
+                       output instead of the XML and the text diagnostics. xml is
+                       left out when --output is given or the export failed
+  -h, --help           Show this help
+
+Without --json, warnings and errors are written to standard error.
+
+Exit codes:
+  0  Exported successfully
+  1  Strict mode found warnings
+  2  Usage error or unusable input (missing file, invalid JSON, invalid BPMN-LD)
+`;
+class UsageError extends Error {
+}
+const parseArgs = (argv) => {
+    const options = { input: "", strict: false, layout: false, force: false, json: false };
+    let input;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-h" || arg === "--help")
+            return "help";
+        else if (arg === "-o" || arg === "--output") {
+            const value = argv[++i];
+            if (value === undefined || value.startsWith("-"))
+                throw new UsageError(`${arg} requires a value`);
+            options.output = value;
+        }
+        else if (arg === "--strict")
+            options.strict = true;
+        else if (arg === "--layout")
+            options.layout = true;
+        else if (arg === "--force")
+            options.force = true;
+        else if (arg === "--json")
+            options.json = true;
+        else if (arg.startsWith("-"))
+            throw new UsageError(`unknown option ${arg}`);
+        else if (input !== undefined)
+            throw new UsageError(`unexpected extra argument ${arg}`);
+        else
+            input = arg;
+    }
+    if (input === undefined)
+        throw new UsageError("missing input file");
+    if (options.force && !options.layout)
+        throw new UsageError("--force requires --layout");
+    options.input = input;
+    return options;
+};
+const failure = (exitCode, stderr) => ({ exitCode, stdout: "", stderr });
+const readJson = (path) => {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const reason = error.code === "ENOENT" ? "no such file" : (error.message ?? "cannot read");
+        throw new UsageError(`cannot read ${path}: ${reason}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new UsageError(`${path} is not valid JSON: ${error.message}`);
+    }
+};
+const failureError = (code, message) => ({ code, location: "/", message });
+const jsonResult = (exitCode, report) => ({
+    exitCode,
+    stdout: `${JSON.stringify(report, null, 2)}\n`,
+    stderr: "",
+});
+const formatWarning = (w) => `warning: ${w.kind} ${w.construct} at ${w.location} [${w.code}]${w.node ? ` node ${w.node}` : ""}${w.message ? `: ${w.message}` : ""}`;
+export const runExport = async (argv) => {
+    let options;
+    try {
+        options = parseArgs(argv);
+    }
+    catch (error) {
+        if (error instanceof UsageError)
+            return failure(EXIT_BAD_INPUT, `error: ${error.message}\n\n${USAGE}`);
+        throw error;
+    }
+    if (options === "help")
+        return { exitCode: EXIT_OK, stdout: USAGE, stderr: "" };
+    let document;
+    try {
+        document = readJson(options.input);
+    }
+    catch (error) {
+        if (!(error instanceof UsageError))
+            throw error;
+        if (!options.json)
+            return failure(EXIT_BAD_INPUT, `error: ${error.message}\n`);
+        const code = error.message.includes("not valid JSON") ? "invalid-json" : "unreadable-input";
+        return jsonResult(EXIT_BAD_INPUT, { warnings: [], errors: [failureError(code, error.message)] });
+    }
+    let result;
+    try {
+        const documentUrl = pathToFileURL(resolve(options.input)).href;
+        result = options.layout
+            ? await layoutAndExport(document, { documentUrl, force: options.force })
+            : await exportDocument(document, { documentUrl });
+    }
+    catch (error) {
+        if (!(error instanceof ExportInputError))
+            throw error;
+        if (options.json)
+            return jsonResult(EXIT_BAD_INPUT, { warnings: [], errors: error.findings });
+        const shown = error.errors.slice(0, MAX_REPORTED_ERRORS).map((e) => `error: ${options.input}: invalid BPMN-LD: ${e}`);
+        const more = error.errors.length - shown.length;
+        if (more > 0)
+            shown.push(`error: ... and ${more} more`);
+        return failure(EXIT_BAD_INPUT, `${shown.join("\n")}\n`);
+    }
+    const errors = [];
+    let exitCode = EXIT_OK;
+    if (options.strict && result.warnings.length > 0) {
+        errors.push(failureError("strict-mode", `strict mode: ${result.warnings.length} warning(s)`));
+        exitCode = EXIT_EXPORT_PROBLEM;
+    }
+    if (options.output !== undefined) {
+        try {
+            writeFileSync(options.output, result.xml);
+        }
+        catch (error) {
+            const message = `cannot write ${options.output}: ${error.message}`;
+            if (options.json)
+                return jsonResult(EXIT_BAD_INPUT, { warnings: result.warnings, errors: [...errors, failureError("cannot-write", message)] });
+            return failure(EXIT_BAD_INPUT, [...result.warnings.map(formatWarning), ...errors.map((e) => `error: ${e.message}`), `error: ${message}`].join("\n") + "\n");
+        }
+    }
+    if (options.json) {
+        return jsonResult(exitCode, { ...(options.output === undefined ? { xml: result.xml } : {}), warnings: result.warnings, errors });
+    }
+    const lines = [...result.warnings.map(formatWarning), ...errors.map((e) => `error: ${e.message}`)];
+    return { exitCode, stdout: options.output === undefined ? result.xml : "", stderr: lines.length ? `${lines.join("\n")}\n` : "" };
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { ROOT } from "./paths.ts";
+export { runAnalyze } from "./analyze-run.ts";
+export { runCheckXml } from "./check-xml-run.ts";
+export { runConvert } from "./convert-run.ts";
+export { runExport } from "./export-run.ts";
+export { installSkill, SUPPORTED_SKILL_DIRECTORIES } from "./install-skill.ts";
+export { runInstallSkill } from "./install-skill-run.ts";
+export { runLayout } from "./layout-run.ts";
+export { runRender } from "./render-run.ts";
+export { runValidate } from "./validate-run.ts";

package/dist/index.js

@@ -0,0 +1,10 @@
+export { ROOT } from "./paths.js";
+export { runAnalyze } from "./analyze-run.js";
+export { runCheckXml } from "./check-xml-run.js";
+export { runConvert } from "./convert-run.js";
+export { runExport } from "./export-run.js";
+export { installSkill, SUPPORTED_SKILL_DIRECTORIES } from "./install-skill.js";
+export { runInstallSkill } from "./install-skill-run.js";
+export { runLayout } from "./layout-run.js";
+export { runRender } from "./render-run.js";
+export { runValidate } from "./validate-run.js";

package/dist/install-skill-run.d.ts

@@ -0,0 +1,8 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_BAD_INPUT = 2;
+export interface CliResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare const runInstallSkill: (argv: string[]) => Promise<CliResult>;

package/dist/install-skill-run.js

@@ -0,0 +1,30 @@
+import { parseArgs } from "node:util";
+import { installSkill } from "./install-skill.js";
+export const EXIT_OK = 0;
+export const EXIT_BAD_INPUT = 2;
+export const runInstallSkill = async (argv) => {
+    let copy = false;
+    let replace = false;
+    let home;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--copy")
+            copy = true;
+        else if (arg === "--replace")
+            replace = true;
+        else if (arg === "--home")
+            home = argv[++i];
+        else if (arg === "-h" || arg === "--help") {
+            return { exitCode: EXIT_OK, stdout: "Usage: bpmn-ld install-skill [--copy] [--replace] [--home <dir>]\n", stderr: "" };
+        }
+    }
+    const result = installSkill({ copy, replace, home });
+    const lines = [
+        ...result.installed.map((p) => `installed ${p}`),
+        ...result.skipped.map((p) => `skipped ${p}`),
+        ...result.missing.map((p) => `missing ${p}`),
+        ...result.failed.map((p) => `failed ${p.path}: ${p.error}`),
+    ];
+    const failed = result.failed.length > 0;
+    return { exitCode: failed ? EXIT_BAD_INPUT : EXIT_OK, stdout: `${lines.join("\n")}\n`, stderr: "" };
+};

package/dist/install-skill.d.ts

@@ -0,0 +1,23 @@
+export declare const SUPPORTED_SKILL_DIRECTORIES: string[];
+export interface InstallSkillResult {
+    installed: string[];
+    skipped: string[];
+    missing: string[];
+    failed: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+export interface InstallSkillOptions {
+    cwd?: string;
+    home?: string;
+    source?: string;
+    copy?: boolean;
+    replace?: boolean;
+    exists?: (path: string) => boolean;
+    mkdir?: (path: string) => void;
+    symlink?: (source: string, dest: string) => void;
+    copyDir?: (source: string, dest: string) => void;
+    remove?: (path: string) => void;
+}
+export declare const installSkill: (options?: InstallSkillOptions) => InstallSkillResult;

package/dist/install-skill.js

@@ -0,0 +1,76 @@
+import { cpSync, existsSync, mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { ROOT } from "./paths.js";
+export const SUPPORTED_SKILL_DIRECTORIES = [
+    ".agents/skills",
+    ".claude/skills",
+    ".codex/skills",
+    ".pi/agent/skills",
+    ".gemini/config/skills",
+    ".hermes/skills",
+];
+const defaultExists = (p) => existsSync(p);
+export const installSkill = (options = {}) => {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? process.env.HOME ?? "";
+    const source = options.source ?? resolve(ROOT, "skills", "bpmn-ld");
+    const exists = options.exists ?? defaultExists;
+    const mkdir = options.mkdir ?? ((p) => mkdirSync(p, { recursive: true }));
+    const symlink = options.symlink ?? ((s, d) => symlinkSync(s, d, "dir"));
+    const copyDir = options.copyDir ?? ((s, d) => cpSync(s, d, { recursive: true }));
+    const remove = options.remove ?? ((p) => rmSync(p, { recursive: true, force: true }));
+    const bases = [cwd, home].filter(Boolean).filter((b, i, arr) => arr.indexOf(b) === i);
+    const result = { installed: [], skipped: [], missing: [], failed: [] };
+    for (const base of bases) {
+        for (const relative of SUPPORTED_SKILL_DIRECTORIES) {
+            const agentConfig = resolve(base, relative.split("/")[0]);
+            const skillsDir = resolve(base, relative);
+            const destination = resolve(skillsDir, "bpmn-ld");
+            const configExists = exists(agentConfig);
+            if (!configExists) {
+                result.missing.push(skillsDir);
+                continue;
+            }
+            if (!exists(skillsDir)) {
+                try {
+                    mkdir(skillsDir);
+                }
+                catch (error) {
+                    result.failed.push({ path: skillsDir, error: error.message });
+                    continue;
+                }
+            }
+            if (exists(destination) && !options.replace) {
+                result.skipped.push(destination);
+                continue;
+            }
+            if (exists(destination) && options.replace) {
+                try {
+                    remove(destination);
+                }
+                catch (error) {
+                    result.failed.push({ path: destination, error: error.message });
+                    continue;
+                }
+            }
+            try {
+                if (options.copy) {
+                    copyDir(source, destination);
+                }
+                else {
+                    try {
+                        symlink(source, destination);
+                    }
+                    catch {
+                        copyDir(source, destination);
+                    }
+                }
+                result.installed.push(destination);
+            }
+            catch (error) {
+                result.failed.push({ path: destination, error: error.message });
+            }
+        }
+    }
+    return result;
+};

package/dist/layout/collaboration.d.ts

@@ -0,0 +1,36 @@
+import { type LaneNode } from "./lanes.ts";
+import { type Box, type FlowNode, type Point, type ProcessModel } from "./model.ts";
+export declare const POOL_HEADER = 30;
+export interface Participant {
+    id: string;
+    model?: ProcessModel;
+    lanes?: LaneNode[];
+    unframed?: boolean;
+}
+export interface MessageFlowInput {
+    id: string;
+    source: string;
+    target: string;
+}
+export interface Existing {
+    fixed: Map<string, Box>;
+    obstacles: Map<string, Box[]>;
+    missingFlows?: Set<string>;
+}
+export interface PlacedShape {
+    element: string;
+    kind: "pool" | "lane" | "node";
+    box: Box;
+    node?: FlowNode;
+}
+export interface PlacedEdge {
+    element: string;
+    source?: string;
+    target?: string;
+    route: Point[];
+}
+export interface CollaborationLayout {
+    shapes: PlacedShape[];
+    edges: PlacedEdge[];
+}
+export declare const layoutCollaboration: (participants: Participant[], messageFlows: MessageFlowInput[], existing: Existing) => CollaborationLayout;