process-graph 1.3.0 → 2.0.0

package/dist/view-DcktInd7.js

@@ -0,0 +1,392 @@
+import { n as modelSchema, s as toPointer } from "./schema-CL95Lyni.js";
+import { t as validate } from "./validate-DF3mQZww.js";
+//#region ../../core/graph/schema/dist/parse.js
+/** Thrown by `parseModel` when the input is not a valid model. */
+var ModelParseError = class extends Error {
+	/** Every problem found, in the order the schema and then `validate` reported them. Never empty. */
+	issues;
+	/**
+	* @param issues - The problems found. Must not be empty.
+	*/
+	constructor(issues) {
+		super(`Invalid model: ${issues.map((issue) => issue.source === "schema" ? `${issue.pointer === "" ? "/" : issue.pointer}: ${issue.message}` : issue.message).join("; ")}`);
+		this.name = "ModelParseError";
+		this.issues = issues;
+	}
+};
+/**
+* Loads a model from untrusted input, such as parsed JSON.
+*
+* The input is checked against the open schema first, so every shape problem is reported with the JSON pointer of the offending value. Only a well-shaped model is then passed to `validate`, whose issues are surfaced the same way.
+* @param input - The value to load.
+* @returns The validated model, with identifiers as plain strings.
+* @throws ModelParseError when the input is not a well-shaped model or fails `validate`.
+*/
+const parseModel = (input) => {
+	const parsed = modelSchema.safeParse(input);
+	if (!parsed.success) throw new ModelParseError(parsed.error.issues.map((issue) => ({
+		source: "schema",
+		pointer: toPointer(issue.path),
+		message: issue.message
+	})));
+	const issues = validate(parsed.data);
+	if (issues.length > 0) throw new ModelParseError(issues.map((issue) => ({
+		source: "validate",
+		code: issue.code,
+		message: issue.message
+	})));
+	return parsed.data;
+};
+//#endregion
+//#region ../../core/graph/export/dist/terminal-text.js
+/**
+* The characters that must never reach a terminal as they are, by Unicode general category: controls (`Cc`, where ESC starts the sequences that clear the screen, move the cursor or, through OSC 52, set the clipboard, and the C1 controls some terminals read as the same sequences), format characters (`Cf`, which holds every bidirectional control, the invisible operators, the soft hyphen, the interlinear annotation characters and the tag characters, all of which reorder, hide or change what is shown), the line and paragraph separators (`Zl`, `Zp`), and the unassigned and private-use code points (`Cn`, `Co`), which no font shows reliably. Text from a source (an issue title, a label, an actor's name) can carry any of them. A category, not a list of ranges, so a character Unicode adds to one of them is covered without a change here.
+*
+* Three are allowed: line feed and tab, which every text output uses, and the zero-width non-joiner and joiner (U+200C, U+200D), formats that emoji sequences (a family, a profession) and scripts such as Persian, Hindi and Malayalam need to be written correctly, and that cannot reorder or hide text on their own.
+*/
+const unsafeCharacters = /[[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Cn}\p{Co}]--[\n\t\u200C\u200D]]/gv;
+/**
+* Whether a character is one of the unsafe ones (see `unsafeCharacters`).
+* @param character - One character: one code point, which may be two UTF-16 code units.
+* @returns Whether it must be escaped.
+*/
+const isUnsafeCharacter = (character) => character.replaceAll(unsafeCharacters, "") !== character;
+/** Code points are written in hexadecimal. */
+const hexadecimal = 16;
+/** A JSON `\u` escape always has four hexadecimal digits. */
+const jsonEscapeDigits = 4;
+/**
+* A character's code point.
+* @param character - One character, as the unsafe-character pattern matches it.
+* @returns Its code point.
+* @throws Error when given an empty string, which the pattern never matches.
+*/
+const codePointOf = (character) => {
+	const point = character.codePointAt(0);
+	if (point === void 0) throw new Error("an unsafe character match was empty");
+	return point;
+};
+/**
+* Text made safe to write to a terminal. Each unsafe character (see `unsafeCharacters`) is written as the visible escape `\u{<hex>}` of its code point, such as `\u{1b}` for ESC, `\u{202e}` for a right-to-left override or `\u{e0041}` for a tag character, so nothing is lost and nothing acts on the terminal. Line feed, tab, the zero-width joiners and every other character, accented letters, CJK, Arabic and emoji included, pass through. A literal `\u{...}` already in the text is left as it is, so the escaped form is for reading, not for reversing.
+* @param text - The text as written.
+* @returns The text with every unsafe character escaped.
+*/
+const terminalText = (text) => text.replaceAll(unsafeCharacters, (character) => `\\u{${codePointOf(character).toString(hexadecimal)}}`);
+/**
+* A value as JSON that is also safe to write to a terminal. `JSON.stringify` escapes the C0 controls but writes every other unsafe character (see `unsafeCharacters`) as it is; this writes those as `\u` escapes too, a surrogate pair for a code point beyond the Basic Multilingual Plane, which leaves the JSON, and every value parsed from it, exactly the same.
+* @param value - The value to write.
+* @returns The JSON text, indented by two spaces and ending in a line break.
+*/
+const terminalJson = (value) => `${JSON.stringify(value, null, 2).replaceAll(unsafeCharacters, (character) => character.split("").map((unit) => `\\u${unit.charCodeAt(0).toString(hexadecimal).padStart(jsonEscapeDigits, "0")}`).join(""))}\n`;
+//#endregion
+//#region ../../core/graph/export/dist/text.js
+/**
+* The Mermaid entity code for a character that would end or change the meaning of a label: quotes, statement and edge-label delimiters, the entity marker itself and HTML.
+*/
+const mermaidEntity = (character) => {
+	switch (character) {
+		case "#": return "#35;";
+		case "\"": return "#quot;";
+		case "<": return "#lt;";
+		case ">": return "#gt;";
+		case "&": return "#amp;";
+		case ";": return "#59;";
+		case "|": return "#124;";
+		case ":": return "#58;";
+		default: return character;
+	}
+};
+/**
+* Text made safe to place inside any Mermaid label: a line break becomes a space, every control and invisible format character is written as its visible `\u{<hex>}` escape (see `terminalText`), and every character that Mermaid reads as syntax is written as its entity code, so a label from a source (an issue title, a repository name) can never break the diagram or act on the terminal it is printed to.
+* @param text - The label as written.
+* @returns The label as Mermaid source.
+*/
+const mermaidText = (text) => terminalText(text.replaceAll(/[\r\n]/gu, " ")).replaceAll(/[#"<>&;|:]/gu, mermaidEntity);
+/**
+* A Graphviz DOT double-quoted string: line breaks written as DOT's own centred line break, every control and invisible format character as its visible `\u{<hex>}` escape (see `terminalText`), then backslashes, the escapes' included, and quotes escaped. Any identifier or label is valid DOT once quoted this way, and reads back as the escaped text.
+* @param text - The text as written.
+* @returns The quoted DOT string, quotes included.
+*/
+const dotString = (text) => `"${text.split(/\r?\n/u).map((line) => terminalText(line).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")).join("\\n")}"`;
+//#endregion
+//#region ../../core/graph/export/dist/mermaid.js
+/**
+* Model identifiers are free text (`github:org/repo#12`), which Mermaid does not accept as a node identifier, so every emitter names things by position in the view instead: a prefix and the index. The view's order is the model's order, so the same model always gives the same names.
+*/
+const positionalIds = (prefix, ids) => new Map(ids.map((id, index) => [id, `${prefix}${String(index)}`]));
+/** Reads a name the emitter itself assigned, which exists for every identifier the view lists. */
+const nameIn = (names, id) => {
+	const name = names.get(id);
+	if (name === void 0) throw new Error(`"${id}" is not part of the view being emitted`);
+	return name;
+};
+const indent$1 = "  ";
+/** Each flowchart shape in Mermaid's syntax around a node name and quoted label: a stadium for a terminator, a rectangle for a process, a rhombus for a decision and a fork bar for a fork or join. */
+const mermaidShapes = {
+	terminator: (name, label) => `${name}(["${label}"])`,
+	process: (name, label) => `${name}["${label}"]`,
+	decision: (name, label) => `${name}{"${label}"}`,
+	bar: (name, label) => `${name}@{ shape: fork, label: "${label}" }`
+};
+const mermaidNode = (name, node) => mermaidShapes[node.shape](name, mermaidText(node.label));
+/** The edges of a flowchart, a hand-off (an edge whose ends are in different lanes) drawn thick. */
+const mermaidEdges = (view, names, isHandoff) => view.edges.map((edge) => {
+	const arrow = isHandoff(edge.from, edge.to) ? "==>" : "-->";
+	const label = edge.label === void 0 ? "" : `|"${mermaidText(edge.label)}"|`;
+	return `${indent$1}${nameIn(names, edge.from)} ${arrow}${label} ${nameIn(names, edge.to)}`;
+});
+/**
+* A flowchart as a Mermaid `flowchart`, top to bottom. Nodes are declared in the view's order, then edges, each with its guard as the edge label.
+* @param view - The projected flowchart.
+* @returns Mermaid source, ending with a line break.
+*/
+const flowchartToMermaid = (view) => {
+	const names = positionalIds("n", view.nodes.map((node) => node.id));
+	return `${[
+		"flowchart TD",
+		...view.nodes.map((node) => `${indent$1}${mermaidNode(nameIn(names, node.id), node)}`),
+		...mermaidEdges(view, names, () => false)
+	].join("\n")}\n`;
+};
+/**
+* A swimlane as a Mermaid `flowchart`, left to right, with one subgraph per lane in the view's lane order (an empty lane is an empty subgraph, so it stays visible) and nodes with no actor outside every lane. Hand-offs, the edges that change lane, are drawn thick.
+* @param view - The projected swimlane.
+* @returns Mermaid source, ending with a line break.
+*/
+const swimlaneToMermaid = (view) => {
+	const names = positionalIds("n", view.nodes.map((node) => node.id));
+	const nodes = new Map(view.nodes.map((node) => [node.id, node]));
+	const laneOf = /* @__PURE__ */ new Map();
+	view.lanes.forEach((lane, index) => {
+		for (const id of lane.nodes) laneOf.set(id, index);
+	});
+	const declare = (id, depth) => {
+		const node = nodes.get(id);
+		if (node === void 0) throw new Error(`lane member "${id}" is not a node of the view`);
+		return `${depth}${mermaidNode(nameIn(names, id), node)}`;
+	};
+	return `${[
+		"flowchart LR",
+		...view.lanes.flatMap((lane, index) => [
+			`${indent$1}subgraph lane${String(index)}["${mermaidText(lane.label)}"]`,
+			...lane.nodes.map((id) => declare(id, indent$1.repeat(2))),
+			`${indent$1}end`
+		]),
+		...view.unassigned.map((id) => declare(id, indent$1)),
+		...mermaidEdges(view, names, (from, to) => {
+			const fromLane = laneOf.get(from);
+			const toLane = laneOf.get(to);
+			return fromLane !== void 0 && toLane !== void 0 && fromLane !== toLane;
+		})
+	].join("\n")}\n`;
+};
+/** A state machine transition's label: its event, its guard in brackets and its effect after a slash, each only when present. */
+const transitionLabel = (transition) => [
+	transition.event,
+	transition.guard === void 0 ? void 0 : `[${transition.guard}]`,
+	transition.effect === void 0 ? void 0 : `/ ${transition.effect}`
+].filter((part) => part !== void 0).join(" ");
+/**
+* A state machine as a Mermaid `stateDiagram-v2`. Initial and final pseudo-states are Mermaid's `[*]`; every other state is declared with its label. Each transition carries its event, guard and effect.
+* @param view - The projected state machine.
+* @returns Mermaid source, ending with a line break.
+*/
+const stateMachineToMermaid = (view) => {
+	const drawn = view.states.filter((state) => state.role === "state");
+	const names = new Map([...positionalIds("s", drawn.map((state) => state.id)), ...view.states.filter((state) => state.role !== "state").map((state) => [state.id, "[*]"])]);
+	return `${[
+		"stateDiagram-v2",
+		...drawn.map((state) => `${indent$1}state "${mermaidText(state.label)}" as ${nameIn(names, state.id)}`),
+		...view.transitions.map((transition) => {
+			const label = transitionLabel(transition);
+			return `${indent$1}${nameIn(names, transition.source)} --> ${nameIn(names, transition.target)}${label === "" ? "" : ` : ${mermaidText(label)}`}`;
+		})
+	].join("\n")}\n`;
+};
+/** The Mermaid keyword that separates one operand of a fragment from the next, for the operators with more than one operand. */
+const operandSeparator = (operator) => operator === "par" ? "and" : "else";
+/**
+* A sequence diagram as a Mermaid `sequenceDiagram`. Lifelines are declared in order of first appearance, labelled through `participantLabel`; messages follow in scenario order, wrapped in the fragments the projection drew (`alt` operands separated by `else`, `par` operands by `and`), each operand headed by its guard.
+* @param view - The projected sequence diagram.
+* @param participantLabel - The label of a lifeline's participant.
+* @returns Mermaid source, ending with a line break.
+*/
+const sequenceToMermaid = (view, participantLabel) => {
+	const names = positionalIds("p", view.lifelines);
+	const items = (list, depth) => list.flatMap((item) => {
+		const prefix = indent$1.repeat(depth);
+		if (item.kind === "message") {
+			const { message } = item;
+			return [`${prefix}${nameIn(names, message.from)}->>${nameIn(names, message.to)}: ${mermaidText(message.label)}`];
+		}
+		return [...item.operands.flatMap((operand, index) => {
+			const keyword = index === 0 ? item.operator : operandSeparator(item.operator);
+			const guard = operand.guard === void 0 ? "" : ` ${mermaidText(operand.guard)}`;
+			return [`${prefix}${keyword}${guard}`, ...items(operand.items, depth + 1)];
+		}), `${prefix}end`];
+	});
+	return `${[
+		"sequenceDiagram",
+		...view.lifelines.map((lifeline) => `${indent$1}participant ${nameIn(names, lifeline)} as ${mermaidText(participantLabel(lifeline))}`),
+		...items(view.items, 1)
+	].join("\n")}\n`;
+};
+//#endregion
+//#region ../../core/graph/export/dist/dot.js
+const indent = "  ";
+/** A DOT attribute list from name and value pairs, each value quoted; empty when there are none. */
+const attributes = (pairs) => pairs.length === 0 ? "" : ` [${pairs.map(([name, value]) => `${name}=${dotString(value)}`).join(", ")}]`;
+/** A flowchart node's DOT shape: an oval terminator, a box process, a diamond decision, and a filled bar for a fork or join. */
+const nodeShapes = {
+	terminator: [["shape", "oval"]],
+	process: [["shape", "box"]],
+	decision: [["shape", "diamond"]],
+	bar: [
+		["shape", "box"],
+		["style", "filled"],
+		["fillcolor", "black"],
+		["fontcolor", "white"]
+	]
+};
+const dotNode = (node, depth) => `${depth}${dotString(node.id)}${attributes([["label", node.label], ...nodeShapes[node.shape]])};`;
+/** The edges of a flowchart, a hand-off (an edge whose ends are in different lanes) drawn bold. */
+const dotEdges = (view, isHandoff) => view.edges.map((edge) => `${indent}${dotString(edge.from)} -> ${dotString(edge.to)}${attributes([...edge.label === void 0 ? [] : [["label", edge.label]], ...isHandoff(edge.from, edge.to) ? [["style", "bold"]] : []])};`);
+/**
+* A flowchart as a Graphviz `digraph`, top to bottom. Nodes are named by their model identifiers, so the DOT source reads back to the model directly.
+* @param view - The projected flowchart.
+* @returns DOT source, ending with a line break.
+*/
+const flowchartToDot = (view) => `${[
+	`digraph ${dotString("flowchart")} {`,
+	`${indent}rankdir="TB";`,
+	...view.nodes.map((node) => dotNode(node, indent)),
+	...dotEdges(view, () => false),
+	"}"
+].join("\n")}\n`;
+/**
+* A swimlane as a Graphviz `digraph`, left to right, with one `cluster` subgraph per lane in the view's lane order and nodes with no actor outside every lane. An empty lane holds one invisible point so Graphviz still draws it. Hand-offs, the edges that change lane, are drawn bold.
+* @param view - The projected swimlane.
+* @returns DOT source, ending with a line break.
+*/
+const swimlaneToDot = (view) => {
+	const nodes = new Map(view.nodes.map((node) => [node.id, node]));
+	const laneOf = /* @__PURE__ */ new Map();
+	view.lanes.forEach((lane, index) => {
+		for (const id of lane.nodes) laneOf.set(id, index);
+	});
+	const declare = (id, depth) => {
+		const node = nodes.get(id);
+		if (node === void 0) throw new Error(`lane member "${id}" is not a node of the view`);
+		return dotNode(node, depth);
+	};
+	return `${[
+		`digraph ${dotString("swimlane")} {`,
+		`${indent}rankdir="LR";`,
+		...view.lanes.flatMap((lane, index) => {
+			const cluster = `cluster_lane${String(index)}`;
+			return [
+				`${indent}subgraph ${dotString(cluster)} {`,
+				`${indent.repeat(2)}label=${dotString(lane.label)};`,
+				...lane.nodes.length === 0 ? [`${indent.repeat(2)}${dotString(`${cluster}:empty`)}${attributes([["shape", "point"], ["style", "invis"]])};`] : lane.nodes.map((id) => declare(id, indent.repeat(2))),
+				`${indent}}`
+			];
+		}),
+		...view.unassigned.map((id) => declare(id, indent)),
+		...dotEdges(view, (from, to) => {
+			const fromLane = laneOf.get(from);
+			const toLane = laneOf.get(to);
+			return fromLane !== void 0 && toLane !== void 0 && fromLane !== toLane;
+		}),
+		"}"
+	].join("\n")}\n`;
+};
+/** A state's DOT shape: a filled point for an initial pseudo-state, a double circle for a final one, a rounded box for a state. */
+const stateShape = (state) => {
+	if (state.role === "initial") return [["label", ""], ["shape", "point"]];
+	if (state.role === "final") return [["label", ""], ["shape", "doublecircle"]];
+	return [
+		["label", state.label],
+		["shape", "box"],
+		["style", "rounded"]
+	];
+};
+/**
+* A state machine as a Graphviz `digraph`, left to right. Each transition is labelled with its event, guard and effect.
+* @param view - The projected state machine.
+* @returns DOT source, ending with a line break.
+*/
+const stateMachineToDot = (view) => `${[
+	`digraph ${dotString("state machine")} {`,
+	`${indent}rankdir="LR";`,
+	...view.states.map((state) => `${indent}${dotString(state.id)}${attributes(stateShape(state))};`),
+	...view.transitions.map((transition) => {
+		const label = transitionLabel(transition);
+		return `${indent}${dotString(transition.source)} -> ${dotString(transition.target)}${attributes(label === "" ? [] : [["label", label]])};`;
+	}),
+	"}"
+].join("\n")}\n`;
+const placeMessages = (items, fragments) => items.flatMap((item) => item.kind === "message" ? [{
+	message: item.message,
+	fragments
+}] : item.operands.flatMap((operand) => placeMessages(operand.items, [...fragments, operand.guard === void 0 ? item.operator : `${item.operator} [${operand.guard}]`])));
+/**
+* A sequence diagram as a Graphviz `digraph`. DOT has no sequence notation, so the diagram is drawn as a grid: a column per lifeline, headed by its participant's label, with one row per message in scenario order. Each message is an arrow across its row, numbered by its step and prefixed with the fragments around it (operator and guard, outermost first), since DOT cannot draw a box around arrows.
+* @param view - The projected sequence diagram.
+* @param participantLabel - The label of a lifeline's participant.
+* @returns DOT source, ending with a line break.
+*/
+const sequenceToDot = (view, participantLabel) => {
+	const columns = new Map(view.lifelines.map((lifeline, index) => [lifeline, index]));
+	const column = (lifeline) => {
+		const index = columns.get(lifeline);
+		if (index === void 0) throw new Error(`"${lifeline}" is not a lifeline of the view`);
+		return index;
+	};
+	const head = (index) => dotString(`p${String(index)}`);
+	const cell = (index, row) => dotString(`p${String(index)}.${String(row)}`);
+	const placed = placeMessages(view.items, []);
+	const rows = placed.map((_, row) => row + 1);
+	const pointAttributes = attributes([["shape", "point"], ["width", "0"]]);
+	return `${[
+		`digraph ${dotString("sequence")} {`,
+		`${indent}rankdir="TB";`,
+		...view.lifelines.map((lifeline, index) => `${indent}${head(index)}${attributes([["label", participantLabel(lifeline)], ["shape", "box"]])};`),
+		`${indent}{ rank="same"; ${view.lifelines.map((_, index) => `${head(index)};`).join(" ")} }`,
+		...view.lifelines.slice(1).map((_, index) => `${indent}${head(index)} -> ${head(index + 1)}${attributes([["style", "invis"]])};`),
+		...rows.flatMap((row) => [...view.lifelines.map((_, index) => `${indent}${cell(index, row)}${pointAttributes};`), `${indent}{ rank="same"; ${view.lifelines.map((_, index) => `${cell(index, row)};`).join(" ")} }`]),
+		...rows.length === 0 ? [] : view.lifelines.map((_, index) => `${indent}${[head(index), ...rows.map((row) => cell(index, row))].join(" -> ")}${attributes([["style", "dashed"], ["arrowhead", "none"]])};`),
+		...placed.map(({ message, fragments }, index) => {
+			const row = index + 1;
+			const text = fragments.length === 0 ? message.label : `${fragments.join(" / ")}: ${message.label}`;
+			return `${indent}${cell(column(message.from), row)} -> ${cell(column(message.to), row)}${attributes([["label", `${String(row)}. ${text}`], ["constraint", "false"]])};`;
+		}),
+		"}"
+	].join("\n")}\n`;
+};
+//#endregion
+//#region ../../core/graph/export/dist/view.js
+/** The text formats a view is written in: Mermaid, Graphviz DOT, and the projection itself as JSON. */
+const exportFormats = [
+	"mermaid",
+	"dot",
+	"json"
+];
+/**
+* A projected view as text: Mermaid or Graphviz DOT source, or the projection as JSON indented by two spaces and ending in a line break, with every control, format, separator, unassigned and private-use character in it written as a JSON `\u` escape (see `terminalJson`), so the text shows nothing hidden or reordered wherever it is saved or printed and parses back to exactly the projection. This is the one writer of a view's text, so the command line's `show` and a download from the web app give the same text for the same view.
+* @param model - The model the view was projected from, for the labels of a sequence diagram's participants.
+* @param projected - The view, as graph-projection's `project` gives it.
+* @param format - The format to write.
+* @returns The text.
+*/
+const viewText = (model, projected, format) => {
+	if (format === "json") return terminalJson(projected.view);
+	const mermaid = format === "mermaid";
+	if (projected.notation === "flowchart") return mermaid ? flowchartToMermaid(projected.view) : flowchartToDot(projected.view);
+	if (projected.notation === "swimlane") return mermaid ? swimlaneToMermaid(projected.view) : swimlaneToDot(projected.view);
+	if (projected.notation === "stateMachine") return mermaid ? stateMachineToMermaid(projected.view) : stateMachineToDot(projected.view);
+	const labels = new Map(model.participants.map((participant) => [participant.id, participant.label]));
+	const participantLabel = (id) => labels.get(id) ?? id;
+	return mermaid ? sequenceToMermaid(projected.view, participantLabel) : sequenceToDot(projected.view, participantLabel);
+};
+//#endregion
+export { stateMachineToDot as a, sequenceToMermaid as c, isUnsafeCharacter as d, terminalJson as f, parseModel as h, sequenceToDot as i, stateMachineToMermaid as l, ModelParseError as m, viewText as n, swimlaneToDot as o, terminalText as p, flowchartToDot as r, flowchartToMermaid as s, exportFormats as t, swimlaneToMermaid as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "process-graph",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "A process and dependency graph model with projections into flowcharts, swimlanes, state machines and sequence diagrams, reasoning over a run, layout, the GitHub issues source, the SQLite store for Node and the browser, and the process-graph command line, each behind its own subpath.",
   "type": "module",
   "repository": {
@@ -48,6 +48,10 @@
       "types": "./dist/store/wasm/worker.d.ts",
       "import": "./dist/store/wasm/worker.js"
     },
+    "./sync": {
+      "types": "./dist/sync.d.ts",
+      "import": "./dist/sync.js"
+    },
     "./react": {
       "types": "./dist/react.d.ts",
       "import": "./dist/react.js"
@@ -117,21 +121,23 @@
   ],
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.5",
-    "@exadev/process-graph-cli": "1.2.0",
+    "@exadev/process-graph-cli": "1.3.1",
     "@exadev/process-graph-dag": "1.1.1",
-    "@exadev/process-graph-domain": "1.2.1",
-    "@exadev/process-graph-layout": "1.0.5",
-    "@exadev/process-graph-projection": "1.1.2",
-    "@exadev/process-graph-react": "1.1.2",
-    "@exadev/process-graph-react-flow": "1.1.2",
-    "@exadev/process-graph-schema": "1.1.2",
-    "@exadev/process-graph-source-contract": "1.1.2",
-    "@exadev/process-graph-source-github-issues": "1.1.2",
-    "@exadev/process-graph-sqlite-node": "1.1.0",
-    "@exadev/process-graph-sqlite-wasm": "1.0.6",
-    "@exadev/process-graph-store-contract": "1.2.1",
-    "@exadev/process-graph-store-sqlite": "1.2.1",
-    "@exadev/process-graph-ui": "1.1.0",
+    "@exadev/process-graph-domain": "1.2.2",
+    "@exadev/process-graph-export": "1.0.1",
+    "@exadev/process-graph-layout": "1.0.7",
+    "@exadev/process-graph-projection": "1.1.4",
+    "@exadev/process-graph-react": "1.1.4",
+    "@exadev/process-graph-react-flow": "1.1.4",
+    "@exadev/process-graph-schema": "2.0.0",
+    "@exadev/process-graph-source-contract": "2.0.0",
+    "@exadev/process-graph-source-github-issues": "2.0.0",
+    "@exadev/process-graph-sqlite-node": "1.1.1",
+    "@exadev/process-graph-sqlite-wasm": "1.0.7",
+    "@exadev/process-graph-store-contract": "2.0.0",
+    "@exadev/process-graph-store-sqlite": "1.2.2",
+    "@exadev/process-graph-sync": "1.0.1",
+    "@exadev/process-graph-ui": "1.1.2",
     "@orpc/client": "2.0.0-beta.41",
     "@orpc/contract": "2.0.0-beta.41",
     "@orpc/server": "2.0.0-beta.41",

package/dist/dist-81kTKnMq.js

@@ -1,3 +0,0 @@
-import "./exit-codes-0ultCqdS.js";
-import { i as runProcess } from "./dist-BI01yxFA.js";
-export { runProcess };

package/dist/parse-C1Q1zsGt.js

@@ -1,41 +0,0 @@
-import { o as toPointer, t as modelSchema } from "./schema-BPT8fmfa.js";
-import { t as validate } from "./validate-DF3mQZww.js";
-//#region ../../core/graph/schema/dist/parse.js
-/** Thrown by `parseModel` when the input is not a valid model. */
-var ModelParseError = class extends Error {
-	/** Every problem found, in the order the schema and then `validate` reported them. Never empty. */
-	issues;
-	/**
-	* @param issues - The problems found. Must not be empty.
-	*/
-	constructor(issues) {
-		super(`Invalid model: ${issues.map((issue) => issue.source === "schema" ? `${issue.pointer === "" ? "/" : issue.pointer}: ${issue.message}` : issue.message).join("; ")}`);
-		this.name = "ModelParseError";
-		this.issues = issues;
-	}
-};
-/**
-* Loads a model from untrusted input, such as parsed JSON.
-*
-* The input is checked against the open schema first, so every shape problem is reported with the JSON pointer of the offending value. Only a well-shaped model is then passed to `validate`, whose issues are surfaced the same way.
-* @param input - The value to load.
-* @returns The validated model, with identifiers as plain strings.
-* @throws ModelParseError when the input is not a well-shaped model or fails `validate`.
-*/
-const parseModel = (input) => {
-	const parsed = modelSchema.safeParse(input);
-	if (!parsed.success) throw new ModelParseError(parsed.error.issues.map((issue) => ({
-		source: "schema",
-		pointer: toPointer(issue.path),
-		message: issue.message
-	})));
-	const issues = validate(parsed.data);
-	if (issues.length > 0) throw new ModelParseError(issues.map((issue) => ({
-		source: "validate",
-		code: issue.code,
-		message: issue.message
-	})));
-	return parsed.data;
-};
-//#endregion
-export { parseModel as n, ModelParseError as t };