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

package/dist/export/extensions.js

@@ -0,0 +1,122 @@
+import { isObject } from "./element.js";
+const RESERVED_PREFIXES = ["xml", "xmlns", "xsi", "dc", "di", "bpmndi"];
+const ABSOLUTE = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+const ABSOLUTE_KEY = /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/|urn:)/i;
+const splitIri = (iri) => {
+    const cut = Math.max(iri.lastIndexOf("#"), iri.lastIndexOf("/"), iri.lastIndexOf(":")) + 1;
+    return { namespace: iri.slice(0, cut), local: iri.slice(cut) };
+};
+const isScalar = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+export class Extensions {
+    namespaces = new Map();
+    terms = new Map();
+    references = new Set();
+    base;
+    byNamespace = new Map();
+    generated = 0;
+    constructor(context, base) {
+        this.base = base;
+        const entries = Array.isArray(context) ? context : [context];
+        for (const entry of entries) {
+            if (!isObject(entry))
+                continue;
+            for (const [term, definition] of Object.entries(entry)) {
+                if (term.startsWith("@"))
+                    continue;
+                if (typeof definition === "string")
+                    this.terms.set(term, definition);
+                else if (isObject(definition) && typeof definition["@id"] === "string") {
+                    this.terms.set(term, definition["@id"]);
+                    if (definition["@type"] === "@id")
+                        this.references.add(term);
+                }
+            }
+        }
+    }
+    expand(key, viaTerm = true) {
+        const colon = key.indexOf(":");
+        if (colon > 0) {
+            const prefix = key.slice(0, colon);
+            const namespace = this.terms.get(prefix);
+            if (namespace !== undefined && ABSOLUTE.test(namespace) && !key.startsWith(`${prefix}://`)) {
+                return { namespace, local: key.slice(colon + 1), preferred: prefix };
+            }
+            return ABSOLUTE_KEY.test(key) ? splitIri(key) : undefined;
+        }
+        const target = this.terms.get(key);
+        if (viaTerm && target !== undefined && target !== key)
+            return this.expand(target, false);
+        return undefined;
+    }
+    prefixFor(resolved) {
+        const known = this.byNamespace.get(resolved.namespace);
+        if (known !== undefined)
+            return known;
+        let prefix = resolved.preferred;
+        if (prefix === undefined || RESERVED_PREFIXES.includes(prefix) || this.namespaces.has(prefix)) {
+            do
+                prefix = `ns${++this.generated}`;
+            while (this.namespaces.has(prefix) || this.terms.has(prefix));
+        }
+        this.namespaces.set(prefix, resolved.namespace);
+        this.byNamespace.set(resolved.namespace, prefix);
+        return prefix;
+    }
+    qualify(key) {
+        const resolved = this.expand(key);
+        if (resolved === undefined || resolved.local === "")
+            return undefined;
+        return `${this.prefixFor(resolved)}:${resolved.local}`;
+    }
+    content(value) {
+        if (isScalar(value))
+            return String(value);
+        if (!isObject(value))
+            return undefined;
+        const result = {};
+        for (const [key, member] of Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+            const name = this.qualify(key);
+            if (name === undefined)
+                continue;
+            const items = (Array.isArray(member) ? member : [member]).map((item) => this.content(item)).filter((item) => item !== undefined);
+            if (items.length > 0)
+                result[name] = items;
+        }
+        return result;
+    }
+    resolve(reference) {
+        try {
+            return new URL(reference, this.base).href;
+        }
+        catch {
+            return reference;
+        }
+    }
+    scalar(key, value) {
+        const reference = isObject(value) && Object.keys(value).length === 1 && typeof value.id === "string" ? value.id : value;
+        if (!isScalar(reference))
+            return undefined;
+        return typeof reference === "string" && this.references.has(key) ? this.resolve(reference) : String(reference);
+    }
+    attribute(key, value, element) {
+        const name = this.qualify(key);
+        const text = this.scalar(key, value);
+        if (name === undefined || text === undefined)
+            return false;
+        element[`@_${name}`] = text;
+        return true;
+    }
+    apply(key, value, element) {
+        const name = this.qualify(key);
+        if (name === undefined)
+            return false;
+        if (this.attribute(key, value, element))
+            return true;
+        const items = (Array.isArray(value) ? value : [value]).map((item) => this.content(item)).filter((item) => item !== undefined);
+        if (items.length === 0)
+            return true;
+        const container = (element.extensionElements ??= {});
+        container[name] = [...(container[name] ?? []), ...items];
+        return true;
+    }
+}

package/dist/export/layout-export.d.ts

@@ -0,0 +1,4 @@
+import { type LayoutOptions } from "../layout/layout.ts";
+import { type ExportOptions, type ExportResult } from "./export.ts";
+export type LayoutAndExportOptions = ExportOptions & LayoutOptions;
+export declare const layoutAndExport: (input: unknown, options?: LayoutAndExportOptions) => Promise<ExportResult>;

package/dist/export/layout-export.js

@@ -0,0 +1,25 @@
+import { layoutDocument, LayoutInputError } from "../layout/layout.js";
+import { exportDocument, ExportInputError, schemaFinding } from "./export.js";
+import { isObject } from "./element.js";
+import { normalize } from "./normalize.js";
+export const layoutAndExport = async (input, options = {}) => {
+    if (!isObject(input))
+        return exportDocument(input, options);
+    let document;
+    try {
+        document = await normalize(input, options.documentUrl);
+    }
+    catch (error) {
+        throw new ExportInputError([{ code: "invalid-context", location: "/@context", message: error.message }]);
+    }
+    let laidOut;
+    try {
+        laidOut = layoutDocument(document, { force: options.force }).document;
+    }
+    catch (error) {
+        if (error instanceof LayoutInputError)
+            throw new ExportInputError(error.errors.map(schemaFinding));
+        throw error;
+    }
+    return exportDocument(laidOut, { documentUrl: options.documentUrl });
+};

package/dist/export/mapping-check.d.ts

@@ -0,0 +1,39 @@
+import type { Store } from "n3";
+import { type ElementMapping } from "../convert/mapping.ts";
+export interface ConverterTables {
+    elements: Record<string, ElementMapping>;
+    containment: Record<string, Record<string, string>>;
+    roots: string[];
+    diagramElements: string[];
+}
+export interface ExporterTables {
+    elements: Record<string, ElementMapping>;
+    containment: Record<string, Record<string, string>>;
+    supported: Record<string, string[]>;
+    diagram: Record<string, {
+        attributes: string[];
+        children: string[];
+    }>;
+    roots: string[];
+}
+export interface AllowedDifference {
+    where: string;
+    reason: string;
+}
+export type ExportMappingReason = "not-in-context" | "not-in-ontology" | "not-exported" | "export-only" | "term-mismatch" | "type-mismatch" | "not-supported" | "stale-allowance";
+export interface ExportMappingProblem {
+    where: string;
+    reason: ExportMappingReason;
+    detail: string;
+}
+export interface ExportMappingInput {
+    exporter: ExporterTables;
+    converter: ConverterTables;
+    store: Store;
+    context: Record<string, string>;
+    allowed?: AllowedDifference[];
+}
+export declare const converterTables: () => ConverterTables;
+export declare const exporterTables: () => ExporterTables;
+export declare const ALLOWED_DIFFERENCES: AllowedDifference[];
+export declare const checkExportMapping: ({ exporter, converter, store, context, allowed }: ExportMappingInput) => ExportMappingProblem[];

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>;