statelyai 0.12.7 → 0.13.0

package/dist/{cli-BRxosLYY.mjs → cli-b1m4txJ7.mjs}

@@ -2,6 +2,7 @@ import { Args, Command, Flags, flush, handle, run } from "@oclif/core";
 import fsPromises from "node:fs/promises";
 import * as path$1 from "node:path";
 import path from "node:path";
+import { changeSet, createFileStore, createLoop, parseModelGraph, proposalOutline, verdictLines, verify } from "@statelyai/mcp/loop";
 import { z, z as z$1 } from "zod";
 import { execFile, execFileSync, spawn } from "node:child_process";
 import { promisify } from "node:util";
@@ -26,6 +27,167 @@ import { StudioApiError, buildAuthorizeUrl, createPkcePair, createStatelyClient
 //#region \0rolldown/runtime.js
 var __commonJSMin$1 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
+//#endregion
+//#region src/loopCommands.ts
+/** An XGraph file, or a `.statelyai` head or version file (its `graph`). */
+async function readGraphFile(file) {
+	const value = JSON.parse(await fsPromises.readFile(file, "utf8"));
+	return parseModelGraph(Array.isArray(value.nodes) ? value : value.graph);
+}
+/** `statelyai changes`: change lines and the proposed flow outline, base -> proposed. */
+async function changesReport(baseFile, proposedFile, json = false) {
+	const [base, proposed] = await Promise.all([readGraphFile(baseFile), readGraphFile(proposedFile)]);
+	const { comparison, changes } = await changeSet(base, proposed);
+	if (json) return {
+		text: JSON.stringify({
+			changes,
+			comparison
+		}, null, 2),
+		exitCode: 0
+	};
+	return {
+		text: [
+			...changes.length ? changes.map((line) => `- ${line}`) : ["No behavior changes."],
+			"",
+			proposalOutline({
+				name: path.basename(proposedFile),
+				proposed,
+				comparison,
+				changes
+			})
+		].join("\n"),
+		exitCode: 0
+	};
+}
+/** `statelyai verify <proposal> <regenerated>`: behavior verdict; 1 on drift, 2 when unavailable. */
+async function verifyReport(proposalFile, regeneratedFile, json = false) {
+	const [proposal, regenerated] = await Promise.all([readGraphFile(proposalFile), readGraphFile(regeneratedFile)]);
+	const verdict = await verify(path.basename(proposalFile), proposal, regenerated);
+	return {
+		text: json ? JSON.stringify(verdict, null, 2) : verdictLines(verdict).join("\n"),
+		exitCode: verdict.status === "matches" ? 0 : verdict.status === "drifted" ? 1 : 2
+	};
+}
+const localLoop = (root) => createLoop({ store: createFileStore(root) });
+/** `statelyai brief`: the Apply brief for a pending proposal in `.statelyai/`. */
+async function briefReport(root, machineId, versionId, json = false) {
+	const loop = localLoop(root);
+	const brief = await loop.brief(machineId, versionId);
+	if (json) return {
+		text: JSON.stringify(brief, null, 2),
+		exitCode: 0
+	};
+	const proposal = await loop.getProposal(machineId, versionId);
+	return {
+		text: [
+			proposalOutline({
+				name: `${brief.name} (${machineId}, ${versionId}, from ${brief.origin === "prompt" ? "a prompt" : "the editor"})`,
+				proposed: proposal.proposed,
+				comparison: proposal.comparison,
+				changes: proposal.changes,
+				evidence: proposal.evidence
+			}),
+			"",
+			brief.text
+		].join("\n"),
+		exitCode: 0
+	};
+}
+/** `statelyai pending`: proposals in `.statelyai/` whose baseline is still the head. */
+async function pendingReport(root, json = false) {
+	const { proposals } = await localLoop(root).listPendingProposals({});
+	if (json) return {
+		text: JSON.stringify({ proposals }, null, 2),
+		exitCode: 0
+	};
+	if (!proposals.length) return {
+		text: "No pending proposals in .statelyai/.",
+		exitCode: 0
+	};
+	return {
+		text: proposals.flatMap((proposal) => [
+			`- ${JSON.stringify(proposal.name)} for ${JSON.stringify(proposal.machineName)} (from ${proposal.origin === "prompt" ? "a prompt" : "the editor"})`,
+			`  statelyai brief ${proposal.machineId} --proposal ${proposal.versionId}`,
+			...proposal.changes.map((line) => `  - ${line}`)
+		]).join("\n"),
+		exitCode: 0
+	};
+}
+const jsonFlag = Flags.boolean({
+	description: "Print machine-readable JSON",
+	default: false
+});
+const rootFlag = Flags.string({ description: "Repository root containing .statelyai/ (defaults to the current directory)" });
+var ReportCommand = class extends Command {
+	static enableJsonFlag = false;
+	async print(report) {
+		let result;
+		try {
+			result = await report;
+		} catch (error) {
+			this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+		}
+		this.log(result.text);
+		if (result.exitCode) this.exit(result.exitCode);
+	}
+};
+var ChangesCommand = class ChangesCommand extends ReportCommand {
+	static summary = "Print the behavior changes between two machine graphs.";
+	static description = "Compares XGraph JSON files (or .statelyai head and version files) offline, then prints change lines and an outline of the proposed flow.";
+	static args = {
+		base: Args.string({
+			required: true,
+			description: "Base XGraph JSON file"
+		}),
+		proposed: Args.string({
+			required: true,
+			description: "Proposed XGraph JSON file"
+		})
+	};
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		json: jsonFlag
+	};
+	async run() {
+		const { args, flags } = await this.parse(ChangesCommand);
+		await this.print(changesReport(args.base, args.proposed, flags.json));
+	}
+};
+var BriefCommand = class BriefCommand extends ReportCommand {
+	static summary = "Print the implementation brief for a pending local proposal.";
+	static description = "Reads .statelyai/ and prints the proposal outline and the Apply message an agent implements. Fails when the model changed since the proposal.";
+	static args = { machine: Args.string({
+		required: true,
+		description: "Machine id (its .statelyai/machines file name)"
+	}) };
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		proposal: Flags.string({
+			required: true,
+			description: "Proposal version id, for example v0002"
+		}),
+		root: rootFlag,
+		json: jsonFlag
+	};
+	async run() {
+		const { args, flags } = await this.parse(BriefCommand);
+		await this.print(briefReport(flags.root ?? process.cwd(), args.machine, flags.proposal, flags.json));
+	}
+};
+var PendingCommand = class PendingCommand extends ReportCommand {
+	static summary = "List pending proposals in .statelyai/.";
+	static description = "Lists proposals whose baseline still matches the machine head, newest first.";
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		root: rootFlag,
+		json: jsonFlag
+	};
+	async run() {
+		const { flags } = await this.parse(PendingCommand);
+		await this.print(pendingReport(flags.root ?? process.cwd(), flags.json));
+	}
+};
+
 //#endregion
 //#region ../api-contract/dist/verification.mjs
 const count = z.number().int().nonnegative();
@@ -679,7 +841,11 @@ async function verifyProject(options = {}) {
 var VerifyCommand = class VerifyCommand extends Command {
 	static enableJsonFlag = false;
 	static summary = "Validate a verification report, print its verdict, and export JSON or JUnit.";
-	static description = "Saved-report processing works offline. Live execution requires a configured verification adapter.";
+	static description = "Saved-report processing works offline. Live execution requires a configured verification adapter. With two graph files, compares a proposal with its regeneration instead (exit 1 on drift).";
+	static args = {
+		proposal: Args.string({ description: "Proposal XGraph JSON file (or .statelyai version file) to compare" }),
+		regenerated: Args.string({ description: "Regenerated XGraph JSON file (or .statelyai head file)" })
+	};
 	static flags = {
 		model: Flags.string({ description: "Model file or registry machine ID (live execution)" }),
 		bindings: Flags.string({ description: "Bindings file (live execution)" }),
@@ -698,7 +864,19 @@ var VerifyCommand = class VerifyCommand extends Command {
 		})
 	};
 	async run() {
-		const { flags } = await this.parse(VerifyCommand);
+		const { args, flags } = await this.parse(VerifyCommand);
+		if (args.proposal || args.regenerated) {
+			if (!args.proposal || !args.regenerated) this.error("Pass both the proposal and the regenerated graph files.", { exit: 2 });
+			let report;
+			try {
+				report = await verifyReport(args.proposal, args.regenerated);
+			} catch (error) {
+				this.error(error instanceof Error ? error.message : String(error), { exit: 2 });
+			}
+			this.log(report.text);
+			if (report.exitCode) this.exit(report.exitCode);
+			return;
+		}
 		let result;
 		try {
 			result = await verifyProject({
@@ -928,258 +1106,594 @@ function offsetAt(lineStarts, line, character) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/xstate-dev.esm.js
-function getGlobal() {
-	if (typeof globalThis !== "undefined") return globalThis;
-	if (typeof self !== "undefined") return self;
-	if (typeof window !== "undefined") return window;
-	if (typeof global !== "undefined") return global;
-}
-function getDevTools() {
-	const w = getGlobal();
-	if (w.__xstate__) return w.__xstate__;
-}
-const devToolsAdapter = (service) => {
-	if (typeof window === "undefined") return;
-	const devTools = getDevTools();
-	if (devTools) devTools.register(service);
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/raise-e974d1c9.esm.js
-var Mailbox = class {
-	constructor(_process) {
-		this._process = _process;
-		this._active = false;
-		this._current = null;
-		this._last = null;
-	}
-	start() {
-		this._active = true;
-		this.flush();
-	}
-	clear() {
-		if (this._current) {
-			this._current.next = null;
-			this._last = this._current;
-		}
-	}
-	enqueue(event) {
-		const enqueued = {
-			value: event,
-			next: null
-		};
-		if (this._current) {
-			this._last.next = enqueued;
-			this._last = enqueued;
-			return;
-		}
-		this._current = enqueued;
-		this._last = enqueued;
-		if (this._active) this.flush();
-	}
-	flush() {
-		while (this._current) {
-			const consumed = this._current;
-			this._process(consumed.value);
-			this._current = consumed.next;
-		}
-		this._last = null;
-	}
-};
-const STATE_DELIMITER = ".";
-const TARGETLESS_KEY = "";
-const NULL_EVENT = "";
-const STATE_IDENTIFIER = "#";
-const WILDCARD = "*";
-const XSTATE_INIT = "xstate.init";
-const XSTATE_STOP = "xstate.stop";
+//#region ../graph-tools/dist/semanticGraphDiffModel-1Yw70u6x.mjs
 /**
-* Returns an event that represents an implicit event that is sent after the
-* specified `delay`.
+* Convert a resolved {@link GraphNode} back into a {@link NodeConfig}.
 *
-* @param delayRef The delay in milliseconds
-* @param id The state node ID where this event is handled
+* Faithful and complete: round-tripping through `createGraphNode` yields a
+* deep-equal node. Optional fields are only included when present; ports are
+* deep-copied so the config does not share port objects with the source node.
 */
-function createAfterEvent(delayRef, id) {
-	return { type: `xstate.after.${delayRef}.${id}` };
+function toNodeConfig(node) {
+	const config = { id: node.id };
+	if (node.parentId != null) config.parentId = node.parentId;
+	if (node.initialNodeId != null) config.initialNodeId = node.initialNodeId;
+	if (node.label != null) config.label = node.label;
+	if (node.data != null) config.data = node.data;
+	if (node.ports !== void 0) config.ports = node.ports.map((p) => ({ ...p }));
+	if (node.x !== void 0) config.x = node.x;
+	if (node.y !== void 0) config.y = node.y;
+	if (node.width !== void 0) config.width = node.width;
+	if (node.height !== void 0) config.height = node.height;
+	if (node.shape !== void 0) config.shape = node.shape;
+	if (node.color !== void 0) config.color = node.color;
+	if (node.style !== void 0) config.style = node.style;
+	return config;
 }
 /**
-* Returns an event that represents that a final state node has been reached in
-* the parent state node.
+* Convert a resolved {@link GraphEdge} back into an {@link EdgeConfig}.
 *
-* @param id The final state node's parent state node `id`
-* @param output The data to pass into the event
+* Faithful and complete: round-tripping through `createGraphEdge` yields a
+* deep-equal edge. Optional fields are only included when present.
 */
-function createDoneStateEvent(id, output) {
-	return {
-		type: `xstate.done.state.${id}`,
-		output
+function toEdgeConfig(edge) {
+	const config = {
+		id: edge.id,
+		sourceId: edge.sourceId,
+		targetId: edge.targetId
 	};
+	if (edge.label != null) config.label = edge.label;
+	if (edge.data != null) config.data = edge.data;
+	if (edge.weight !== void 0) config.weight = edge.weight;
+	if (edge.mode !== void 0) config.mode = edge.mode;
+	if (edge.sourcePort !== void 0) config.sourcePort = edge.sourcePort;
+	if (edge.targetPort !== void 0) config.targetPort = edge.targetPort;
+	if (edge.points !== void 0) config.points = edge.points.map((p) => ({ ...p }));
+	if (edge.routing !== void 0) config.routing = edge.routing;
+	if (edge.x !== void 0) config.x = edge.x;
+	if (edge.y !== void 0) config.y = edge.y;
+	if (edge.width !== void 0) config.width = edge.width;
+	if (edge.height !== void 0) config.height = edge.height;
+	if (edge.color !== void 0) config.color = edge.color;
+	if (edge.style !== void 0) config.style = edge.style;
+	return config;
+}
+const LAYOUT_KEYS$1 = {
+	node: [
+		"x",
+		"y",
+		"width",
+		"height",
+		"style",
+		"color",
+		"shape"
+	],
+	edge: [
+		"x",
+		"y",
+		"width",
+		"height",
+		"points",
+		"routing",
+		"style",
+		"color"
+	]
+};
+new Set(LAYOUT_KEYS$1.node), new Set(LAYOUT_KEYS$1.edge);
+/** Shallow-compare two values, returning true if they differ. */
+function differs(a, b) {
+	if (a === b) return false;
+	if (a == null || b == null) return a !== b;
+	if (typeof a === "object" && typeof b === "object") return JSON.stringify(a) !== JSON.stringify(b);
+	return true;
 }
+const NODE_COMPARE_KEYS = [
+	"parentId",
+	"initialNodeId",
+	"label",
+	"data",
+	"ports",
+	"x",
+	"y",
+	"width",
+	"height",
+	"shape",
+	"color",
+	"style"
+];
+const EDGE_COMPARE_KEYS = [
+	"sourceId",
+	"targetId",
+	"label",
+	"data",
+	"weight",
+	"mode",
+	"sourcePort",
+	"targetPort",
+	"points",
+	"routing",
+	"x",
+	"y",
+	"width",
+	"height",
+	"color",
+	"style"
+];
 /**
-* Returns an event that represents that an invoked service has terminated.
+* Compute a structured diff from graph `a` to graph `b` by matching IDs.
 *
-* An invoked service is terminated when it has reached a top-level final state
-* node, but not when it is canceled.
+* @example
+* ```ts
+* import { createGraph, getDiff } from '@statelyai/graph';
 *
-* @param invokeId The invoked service ID
-* @param output The data to pass into the event
-*/
-function createDoneActorEvent(invokeId, output) {
-	return {
-		type: `xstate.done.actor.${invokeId}`,
-		output,
-		actorId: invokeId
-	};
-}
-function createErrorActorEvent(id, error) {
-	return {
-		type: `xstate.error.actor.${id}`,
-		error,
-		actorId: id
-	};
-}
-function createInitEvent(input) {
-	return {
-		type: XSTATE_INIT,
-		input
-	};
-}
-/**
-* This function makes sure that unhandled errors are thrown in a separate
-* macrotask. It allows those errors to be detected by global error handlers and
-* reported to bug tracking services without interrupting our own stack of
-* execution.
+* const a = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
+* const b = createGraph({ nodes: [{ id: 'n1', label: 'hello' }, { id: 'n2' }], edges: [] });
 *
-* @param err Error to be thrown
+* const diff = getDiff(a, b);
+* // diff.nodes.added → [{ id: 'n2' }]
+* // diff.nodes.updated → [{ id: 'n1', old: { label: '' }, new: { label: 'hello' } }]
+* ```
 */
-function reportUnhandledError(err) {
-	setTimeout(() => {
-		throw err;
-	});
-}
-const symbolObservable = typeof Symbol === "function" && Symbol.observable || "@@observable";
-function matchesState(parentStateId, childStateId) {
-	const parentStateValue = toStateValue(parentStateId);
-	const childStateValue = toStateValue(childStateId);
-	if (typeof childStateValue === "string") {
-		if (typeof parentStateValue === "string") return childStateValue === parentStateValue;
-		return false;
+function getDiff(a, b) {
+	const aNodeMap = new Map(a.nodes.map((n) => [n.id, n]));
+	const bNodeMap = new Map(b.nodes.map((n) => [n.id, n]));
+	const aEdgeMap = new Map(a.edges.map((e) => [e.id, e]));
+	const bEdgeMap = new Map(b.edges.map((e) => [e.id, e]));
+	const diff = {
+		nodes: {
+			added: [],
+			removed: [],
+			updated: []
+		},
+		edges: {
+			added: [],
+			removed: [],
+			updated: []
+		}
+	};
+	for (const [id, nodeB] of bNodeMap) {
+		const nodeA = aNodeMap.get(id);
+		if (!nodeA) diff.nodes.added.push(toNodeConfig(nodeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of NODE_COMPARE_KEYS) {
+				const oldValue = nodeA[key] ?? null;
+				const newValue = nodeB[key] ?? null;
+				if (differs(oldValue, newValue)) {
+					oldPartial[key] = oldValue;
+					newPartial[key] = newValue;
+				}
+			}
+			if (Object.keys(oldPartial).length > 0) diff.nodes.updated.push({
+				id,
+				old: oldPartial,
+				new: newPartial
+			});
+		}
 	}
-	if (typeof parentStateValue === "string") return parentStateValue in childStateValue;
-	return Object.keys(parentStateValue).every((key) => {
-		if (!(key in childStateValue)) return false;
-		return matchesState(parentStateValue[key], childStateValue[key]);
-	});
-}
-function toStatePath(stateId) {
-	if (isArray(stateId)) return stateId;
-	const result = [];
-	let segment = "";
-	for (let i = 0; i < stateId.length; i++) {
-		switch (stateId.charCodeAt(i)) {
-			case 92:
-				segment += stateId[i + 1];
-				i++;
-				continue;
-			case 46:
-				result.push(segment);
-				segment = "";
-				continue;
+	for (const [id, nodeA] of aNodeMap) if (!bNodeMap.has(id)) diff.nodes.removed.push(toNodeConfig(nodeA));
+	for (const [id, edgeB] of bEdgeMap) {
+		const edgeA = aEdgeMap.get(id);
+		if (!edgeA) diff.edges.added.push(toEdgeConfig(edgeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of EDGE_COMPARE_KEYS) {
+				const oldValue = edgeA[key] ?? null;
+				const newValue = edgeB[key] ?? null;
+				if (differs(oldValue, newValue)) {
+					oldPartial[key] = oldValue;
+					newPartial[key] = newValue;
+				}
+			}
+			if (Object.keys(oldPartial).length > 0) diff.edges.updated.push({
+				id,
+				old: oldPartial,
+				new: newPartial
+			});
 		}
-		segment += stateId[i];
 	}
-	result.push(segment);
-	return result;
+	for (const [id, edgeA] of aEdgeMap) if (!bEdgeMap.has(id)) diff.edges.removed.push(toEdgeConfig(edgeA));
+	return diff;
 }
-function toStateValue(stateValue) {
-	if (isMachineSnapshot(stateValue)) return stateValue.value;
-	if (typeof stateValue !== "string") return stateValue;
-	return pathToStateValue(toStatePath(stateValue));
+/**
+* Check if a diff has zero changes.
+*
+* @example
+* ```ts
+* import { createGraph, getDiff, isEmptyDiff } from '@statelyai/graph';
+*
+* const g = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
+* const diff = getDiff(g, g);
+* isEmptyDiff(diff); // true
+* ```
+*/
+function isEmptyDiff$1(diff) {
+	return diff.nodes.added.length === 0 && diff.nodes.removed.length === 0 && diff.nodes.updated.length === 0 && diff.edges.added.length === 0 && diff.edges.removed.length === 0 && diff.edges.updated.length === 0;
 }
-function pathToStateValue(statePath) {
-	if (statePath.length === 1) return statePath[0];
-	const value = {};
-	let marker = value;
-	for (let i = 0; i < statePath.length - 1; i++) if (i === statePath.length - 2) marker[statePath[i]] = statePath[i + 1];
-	else {
-		const previous = marker;
-		marker = {};
-		previous[statePath[i]] = marker;
-	}
-	return value;
+function summarizeGraphDiff(diff) {
+	return {
+		hasChanges: !isEmptyDiff$1(diff),
+		nodeChanges: diff.nodes.added.length + diff.nodes.removed.length + diff.nodes.updated.length,
+		edgeChanges: diff.edges.added.length + diff.edges.removed.length + diff.edges.updated.length
+	};
 }
-function mapValues(collection, iteratee) {
-	const result = {};
-	const collectionKeys = Object.keys(collection);
-	for (let i = 0; i < collectionKeys.length; i++) {
-		const key = collectionKeys[i];
-		result[key] = iteratee(collection[key], key, collection, i);
+function nodeDepth$1(graph, node) {
+	let depth = 0;
+	let parentId = node.parentId;
+	while (parentId) {
+		depth++;
+		parentId = graph.nodes.find((candidate) => candidate.id === parentId)?.parentId;
 	}
-	return result;
-}
-function toArrayStrict(value) {
-	if (isArray(value)) return value;
-	return [value];
-}
-function toArray$1(value) {
-	if (value === void 0) return [];
-	return toArrayStrict(value);
-}
-function resolveOutput(mapper, context, event, self) {
-	if (typeof mapper === "function") return mapper({
-		context,
-		event,
-		self
-	});
-	return mapper;
-}
-function isArray(value) {
-	return Array.isArray(value);
-}
-function isErrorActorEvent(event) {
-	return event.type.startsWith("xstate.error.actor");
+	return depth;
 }
-function toTransitionConfigArray(configLike) {
-	return toArrayStrict(configLike).map((transitionLike) => {
-		if (typeof transitionLike === "undefined" || typeof transitionLike === "string") return { target: transitionLike };
-		return transitionLike;
-	});
+function nodeKey(node) {
+	return node.data?.key || node.id;
 }
-function normalizeTarget(target) {
-	if (target === void 0 || target === TARGETLESS_KEY) return;
-	return toArray$1(target);
+function edgeSignature(edge) {
+	return [
+		edge.sourceId,
+		edge.data?.eventType,
+		edge.targetId,
+		edge.data?.guard?.type ?? ""
+	].join("->");
 }
-function toObserver(nextHandler, errorHandler, completionHandler) {
-	const isObserver = typeof nextHandler === "object";
-	const self = isObserver ? nextHandler : void 0;
-	return {
-		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
-		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
-	};
+function getStableNodeId(node, parentStableId, siblingIndex, preferredIds) {
+	const preferredId = preferredIds?.get(node.id);
+	if (preferredId !== void 0) return preferredId;
+	if (node.parentId === null) return "root";
+	const key = nodeKey(node);
+	const suffix = siblingIndex === 0 ? key : `${key}_${siblingIndex + 1}`;
+	return parentStableId ? `${parentStableId}.${suffix}` : suffix;
 }
-function createInvokeId(stateNodeId, index) {
-	return `${index}.${stateNodeId}`;
+function getStableEdgeId(edge, siblingIndex, preferredIds) {
+	const preferredId = preferredIds?.get(edge.id);
+	if (preferredId !== void 0) return preferredId;
+	const suffix = siblingIndex === 0 ? "" : `.${siblingIndex + 1}`;
+	return edgeSignature(edge).concat(suffix);
 }
-function resolveReferencedActor(machine, src) {
-	const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
-	if (!match) return machine.implementations.actors[src];
-	const [, indexStr, nodeId] = match;
-	const invokeConfig = machine.getStateNodeById(nodeId).config.invoke;
-	return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
+function removePresentationFields(entity, kind) {
+	const mutableEntity = entity;
+	for (const key of LAYOUT_KEYS$1[kind]) delete mutableEntity[key];
+	const data = mutableEntity.data;
+	if (data && typeof data === "object" && !Array.isArray(data)) delete data.color;
 }
 /**
-* Checks if an event type matches an event descriptor, supporting wildcards.
-* Event descriptors can be:
-*
-* - Exact matches: "event.type"
-* - Wildcard: "*"
-* - Partial matches: "event.*"
+* Rewrites entity ids to structural ("semantic") ids so two graphs that model
+* the same machine compare equal regardless of how their ids were minted.
 *
-* @param eventType - The actual event type string
-* @param descriptor - The event descriptor to match against
+* Invariant: node and edge array order is preserved exactly. Callers
+* (`alignCompareIds` in the editor's /v1/diff route) rely on
+* `normalized.nodes[i]` describing `graph.nodes[i]` to translate a semantic id
+* back to the caller's original id. Never sort, filter, or reorder the arrays
+* on the returned graph; sorting for traversal must be done on a copy, as the
+* depth ordering below does.
+*
+* Presentation-only fields defined by `LAYOUT_KEYS`, plus entity data colors,
+* are removed. When preferred ids are supplied, matching raw ids retain the
+* base graph's semantic identity so a stable-id rename is reported as an
+* update.
+*
+* Entity `data` is treated as optional throughout: sparse graphs (a node with
+* `data: {}`, an edge with `data: null`) normalize instead of throwing.
+*/
+function normalizeGraphForSemanticDiff(graph, preferredIds) {
+	const normalized = structuredClone(graph);
+	const nodeIdMap = /* @__PURE__ */ new Map();
+	const siblingKeys = /* @__PURE__ */ new Map();
+	const reservedNodeIds = new Set(preferredIds?.nodes.values());
+	const claimedNodeIds = /* @__PURE__ */ new Set();
+	const nodesByDepth = [...normalized.nodes].sort((a, b) => nodeDepth$1(normalized, a) - nodeDepth$1(normalized, b));
+	for (const node of nodesByDepth) {
+		const parentStableId = node.parentId ? nodeIdMap.get(node.parentId) ?? node.parentId : null;
+		const key = `${parentStableId ?? ""}:${nodeKey(node)}`;
+		const siblingIndex = siblingKeys.get(key) ?? 0;
+		siblingKeys.set(key, siblingIndex + 1);
+		const proposedId = getStableNodeId(node, parentStableId, siblingIndex, preferredIds?.nodes);
+		let stableId = proposedId;
+		let collisionIndex = 2;
+		while (!preferredIds?.nodes.has(node.id) && (reservedNodeIds.has(stableId) || claimedNodeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
+		claimedNodeIds.add(stableId);
+		nodeIdMap.set(node.id, stableId);
+	}
+	for (const node of normalized.nodes) {
+		removePresentationFields(node, "node");
+		node.id = nodeIdMap.get(node.id) ?? node.id;
+		if (node.parentId) node.parentId = nodeIdMap.get(node.parentId) ?? node.parentId;
+		if (node.initialNodeId) node.initialNodeId = nodeIdMap.get(node.initialNodeId) ?? node.initialNodeId;
+		if (node.data?.initialId) node.data.initialId = nodeIdMap.get(node.data.initialId) ?? node.data.initialId;
+	}
+	const edgeSiblingKeys = /* @__PURE__ */ new Map();
+	const reservedEdgeIds = new Set(preferredIds?.edges.values());
+	const claimedEdgeIds = /* @__PURE__ */ new Set();
+	for (const edge of normalized.edges) {
+		removePresentationFields(edge, "edge");
+		edge.sourceId = nodeIdMap.get(edge.sourceId) ?? edge.sourceId;
+		edge.targetId = nodeIdMap.get(edge.targetId) ?? edge.targetId;
+		const key = edgeSignature(edge);
+		const siblingIndex = edgeSiblingKeys.get(key) ?? 0;
+		edgeSiblingKeys.set(key, siblingIndex + 1);
+		const proposedId = getStableEdgeId(edge, siblingIndex, preferredIds?.edges);
+		let stableId = proposedId;
+		let collisionIndex = 2;
+		while (!preferredIds?.edges.has(edge.id) && (reservedEdgeIds.has(stableId) || claimedEdgeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
+		claimedEdgeIds.add(stableId);
+		edge.id = stableId;
+	}
+	if (normalized.initialNodeId) normalized.initialNodeId = nodeIdMap.get(normalized.initialNodeId) ?? normalized.initialNodeId;
+	return normalized;
+}
+function diffGraphsSemantically(baseGraph, compareGraph) {
+	const base = normalizeGraphForSemanticDiff(baseGraph);
+	const compareNodeIds = new Set(compareGraph.nodes.map((node) => node.id));
+	const compareEdgeIds = new Set(compareGraph.edges.map((edge) => edge.id));
+	const compare = normalizeGraphForSemanticDiff(compareGraph, {
+		nodes: new Map(baseGraph.nodes.map((node, index) => [node.id, base.nodes[index].id]).filter(([id]) => compareNodeIds.has(id))),
+		edges: new Map(baseGraph.edges.map((edge, index) => [edge.id, base.edges[index].id]).filter(([id]) => compareEdgeIds.has(id)))
+	});
+	const diff = getDiff(base, compare);
+	return {
+		base,
+		compare,
+		diff,
+		summary: summarizeGraphDiff(diff)
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/xstate-dev.esm.js
+function getGlobal() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
+}
+function getDevTools() {
+	const w = getGlobal();
+	if (w.__xstate__) return w.__xstate__;
+}
+const devToolsAdapter = (service) => {
+	if (typeof window === "undefined") return;
+	const devTools = getDevTools();
+	if (devTools) devTools.register(service);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.32.1/node_modules/xstate/dist/raise-e974d1c9.esm.js
+var Mailbox = class {
+	constructor(_process) {
+		this._process = _process;
+		this._active = false;
+		this._current = null;
+		this._last = null;
+	}
+	start() {
+		this._active = true;
+		this.flush();
+	}
+	clear() {
+		if (this._current) {
+			this._current.next = null;
+			this._last = this._current;
+		}
+	}
+	enqueue(event) {
+		const enqueued = {
+			value: event,
+			next: null
+		};
+		if (this._current) {
+			this._last.next = enqueued;
+			this._last = enqueued;
+			return;
+		}
+		this._current = enqueued;
+		this._last = enqueued;
+		if (this._active) this.flush();
+	}
+	flush() {
+		while (this._current) {
+			const consumed = this._current;
+			this._process(consumed.value);
+			this._current = consumed.next;
+		}
+		this._last = null;
+	}
+};
+const STATE_DELIMITER = ".";
+const TARGETLESS_KEY = "";
+const NULL_EVENT = "";
+const STATE_IDENTIFIER = "#";
+const WILDCARD = "*";
+const XSTATE_INIT = "xstate.init";
+const XSTATE_STOP = "xstate.stop";
+/**
+* Returns an event that represents an implicit event that is sent after the
+* specified `delay`.
+*
+* @param delayRef The delay in milliseconds
+* @param id The state node ID where this event is handled
+*/
+function createAfterEvent(delayRef, id) {
+	return { type: `xstate.after.${delayRef}.${id}` };
+}
+/**
+* Returns an event that represents that a final state node has been reached in
+* the parent state node.
+*
+* @param id The final state node's parent state node `id`
+* @param output The data to pass into the event
+*/
+function createDoneStateEvent(id, output) {
+	return {
+		type: `xstate.done.state.${id}`,
+		output
+	};
+}
+/**
+* Returns an event that represents that an invoked service has terminated.
+*
+* An invoked service is terminated when it has reached a top-level final state
+* node, but not when it is canceled.
+*
+* @param invokeId The invoked service ID
+* @param output The data to pass into the event
+*/
+function createDoneActorEvent(invokeId, output) {
+	return {
+		type: `xstate.done.actor.${invokeId}`,
+		output,
+		actorId: invokeId
+	};
+}
+function createErrorActorEvent(id, error) {
+	return {
+		type: `xstate.error.actor.${id}`,
+		error,
+		actorId: id
+	};
+}
+function createInitEvent(input) {
+	return {
+		type: XSTATE_INIT,
+		input
+	};
+}
+/**
+* This function makes sure that unhandled errors are thrown in a separate
+* macrotask. It allows those errors to be detected by global error handlers and
+* reported to bug tracking services without interrupting our own stack of
+* execution.
+*
+* @param err Error to be thrown
+*/
+function reportUnhandledError(err) {
+	setTimeout(() => {
+		throw err;
+	});
+}
+const symbolObservable = typeof Symbol === "function" && Symbol.observable || "@@observable";
+function matchesState(parentStateId, childStateId) {
+	const parentStateValue = toStateValue(parentStateId);
+	const childStateValue = toStateValue(childStateId);
+	if (typeof childStateValue === "string") {
+		if (typeof parentStateValue === "string") return childStateValue === parentStateValue;
+		return false;
+	}
+	if (typeof parentStateValue === "string") return parentStateValue in childStateValue;
+	return Object.keys(parentStateValue).every((key) => {
+		if (!(key in childStateValue)) return false;
+		return matchesState(parentStateValue[key], childStateValue[key]);
+	});
+}
+function toStatePath(stateId) {
+	if (isArray(stateId)) return stateId;
+	const result = [];
+	let segment = "";
+	for (let i = 0; i < stateId.length; i++) {
+		switch (stateId.charCodeAt(i)) {
+			case 92:
+				segment += stateId[i + 1];
+				i++;
+				continue;
+			case 46:
+				result.push(segment);
+				segment = "";
+				continue;
+		}
+		segment += stateId[i];
+	}
+	result.push(segment);
+	return result;
+}
+function toStateValue(stateValue) {
+	if (isMachineSnapshot(stateValue)) return stateValue.value;
+	if (typeof stateValue !== "string") return stateValue;
+	return pathToStateValue(toStatePath(stateValue));
+}
+function pathToStateValue(statePath) {
+	if (statePath.length === 1) return statePath[0];
+	const value = {};
+	let marker = value;
+	for (let i = 0; i < statePath.length - 1; i++) if (i === statePath.length - 2) marker[statePath[i]] = statePath[i + 1];
+	else {
+		const previous = marker;
+		marker = {};
+		previous[statePath[i]] = marker;
+	}
+	return value;
+}
+function mapValues(collection, iteratee) {
+	const result = {};
+	const collectionKeys = Object.keys(collection);
+	for (let i = 0; i < collectionKeys.length; i++) {
+		const key = collectionKeys[i];
+		result[key] = iteratee(collection[key], key, collection, i);
+	}
+	return result;
+}
+function toArrayStrict(value) {
+	if (isArray(value)) return value;
+	return [value];
+}
+function toArray$1(value) {
+	if (value === void 0) return [];
+	return toArrayStrict(value);
+}
+function resolveOutput(mapper, context, event, self) {
+	if (typeof mapper === "function") return mapper({
+		context,
+		event,
+		self
+	});
+	return mapper;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isErrorActorEvent(event) {
+	return event.type.startsWith("xstate.error.actor");
+}
+function toTransitionConfigArray(configLike) {
+	return toArrayStrict(configLike).map((transitionLike) => {
+		if (typeof transitionLike === "undefined" || typeof transitionLike === "string") return { target: transitionLike };
+		return transitionLike;
+	});
+}
+function normalizeTarget(target) {
+	if (target === void 0 || target === TARGETLESS_KEY) return;
+	return toArray$1(target);
+}
+function toObserver(nextHandler, errorHandler, completionHandler) {
+	const isObserver = typeof nextHandler === "object";
+	const self = isObserver ? nextHandler : void 0;
+	return {
+		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+	};
+}
+function createInvokeId(stateNodeId, index) {
+	return `${index}.${stateNodeId}`;
+}
+function resolveReferencedActor(machine, src) {
+	const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+	if (!match) return machine.implementations.actors[src];
+	const [, indexStr, nodeId] = match;
+	const invokeConfig = machine.getStateNodeById(nodeId).config.invoke;
+	return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
+}
+/**
+* Checks if an event type matches an event descriptor, supporting wildcards.
+* Event descriptors can be:
+*
+* - Exact matches: "event.type"
+* - Wildcard: "*"
+* - Partial matches: "event.*"
+*
+* @param eventType - The actual event type string
+* @param descriptor - The event descriptor to match against
 * @returns True if the event type matches the descriptor
 */
 function matchesEventDescriptor(eventType, descriptor) {
@@ -5538,666 +6052,333 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					if (shouldTrackWidth) {
 						hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
 						previousLineBreak = i;
-					}
-				} else if (!isPrintable(char)) return STYLE_DOUBLE;
-				plain = plain && isPlainSafe(char, prevChar, inblock);
-				prevChar = char;
-			}
-			hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
-		}
-		if (!hasLineBreak && !hasFoldableLine) {
-			if (plain && !forceQuotes && !testAmbiguousType(string)) return STYLE_PLAIN;
-			return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-		}
-		if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE;
-		if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
-		return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-	}
-	function writeScalar(state, string, level, iskey, inblock) {
-		state.dump = function() {
-			if (string.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"\"" : "''";
-			if (!state.noCompatMode) {
-				if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"" + string + "\"" : "'" + string + "'";
-			}
-			const indent = state.indent * Math.max(1, level);
-			const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-			const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
-			function testAmbiguity(string) {
-				return testImplicitResolving(state, string);
-			}
-			switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
-				case STYLE_PLAIN: return string;
-				case STYLE_SINGLE: return "'" + string.replace(/'/g, "''") + "'";
-				case STYLE_LITERAL: return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
-				case STYLE_FOLDED: return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
-				case STYLE_DOUBLE: return "\"" + escapeString(string, lineWidth) + "\"";
-				default: throw new YAMLException("impossible error: invalid scalar style");
-			}
-		}();
-	}
-	function blockHeader(string, indentPerLevel) {
-		const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
-		const clip = string[string.length - 1] === "\n";
-		return indentIndicator + (clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-") + "\n";
-	}
-	function dropEndingNewline(string) {
-		return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
-	}
-	function foldString(string, width) {
-		const lineRe = /(\n+)([^\n]*)/g;
-		let result = function() {
-			let nextLF = string.indexOf("\n");
-			nextLF = nextLF !== -1 ? nextLF : string.length;
-			lineRe.lastIndex = nextLF;
-			return foldLine(string.slice(0, nextLF), width);
-		}();
-		let prevMoreIndented = string[0] === "\n" || string[0] === " ";
-		let moreIndented;
-		let match;
-		while (match = lineRe.exec(string)) {
-			const prefix = match[1];
-			const line = match[2];
-			moreIndented = line[0] === " ";
-			result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
-			prevMoreIndented = moreIndented;
-		}
-		return result;
-	}
-	function foldLine(line, width) {
-		if (line === "" || line[0] === " ") return line;
-		const breakRe = / [^ ]/g;
-		let match;
-		let start = 0;
-		let end;
-		let curr = 0;
-		let next = 0;
-		let result = "";
-		while (match = breakRe.exec(line)) {
-			next = match.index;
-			if (next - start > width) {
-				end = curr > start ? curr : next;
-				result += "\n" + line.slice(start, end);
-				start = end + 1;
-			}
-			curr = next;
-		}
-		result += "\n";
-		if (line.length - start > width && curr > start) result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
-		else result += line.slice(start);
-		return result.slice(1);
-	}
-	function escapeString(string) {
-		let result = "";
-		let char = 0;
-		for (let i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
-			char = codePointAt(string, i);
-			const escapeSeq = ESCAPE_SEQUENCES[char];
-			if (!escapeSeq && isPrintable(char)) {
-				result += string[i];
-				if (char >= 65536) result += string[i + 1];
-			} else result += escapeSeq || encodeHex(char);
-		}
-		return result;
-	}
-	function writeFlowSequence(state, level, object) {
-		let _result = "";
-		const _tag = state.tag;
-		for (let index = 0, length = object.length; index < length; index += 1) {
-			let value = object[index];
-			if (state.replacer) value = state.replacer.call(object, String(index), value);
-			if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
-				if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
-				_result += state.dump;
-			}
-		}
-		state.tag = _tag;
-		state.dump = "[" + _result + "]";
-	}
-	function writeBlockSequence(state, level, object, compact) {
-		let _result = "";
-		const _tag = state.tag;
-		for (let index = 0, length = object.length; index < length; index += 1) {
-			let value = object[index];
-			if (state.replacer) value = state.replacer.call(object, String(index), value);
-			if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
-				if (!compact || _result !== "") _result += generateNextLine(state, level);
-				if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) _result += "-";
-				else _result += "- ";
-				_result += state.dump;
-			}
-		}
-		state.tag = _tag;
-		state.dump = _result || "[]";
-	}
-	function writeFlowMapping(state, level, object) {
-		let _result = "";
-		const _tag = state.tag;
-		const objectKeyList = Object.keys(object);
-		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
-			let pairBuffer = "";
-			if (_result !== "") pairBuffer += ", ";
-			if (state.condenseFlow) pairBuffer += "\"";
-			const objectKey = objectKeyList[index];
-			let objectValue = object[objectKey];
-			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-			if (!writeNode(state, level, objectKey, false, false)) continue;
-			if (state.dump.length > 1024) pairBuffer += "? ";
-			pairBuffer += state.dump + (state.condenseFlow ? "\"" : "") + ":" + (state.condenseFlow ? "" : " ");
-			if (!writeNode(state, level, objectValue, false, false)) continue;
-			pairBuffer += state.dump;
-			_result += pairBuffer;
-		}
-		state.tag = _tag;
-		state.dump = "{" + _result + "}";
-	}
-	function writeBlockMapping(state, level, object, compact) {
-		let _result = "";
-		const _tag = state.tag;
-		const objectKeyList = Object.keys(object);
-		if (state.sortKeys === true) objectKeyList.sort();
-		else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
-		else if (state.sortKeys) throw new YAMLException("sortKeys must be a boolean or a function");
-		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
-			let pairBuffer = "";
-			if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
-			const objectKey = objectKeyList[index];
-			let objectValue = object[objectKey];
-			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-			if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
-			const explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
-			if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
-			else pairBuffer += "? ";
-			pairBuffer += state.dump;
-			if (explicitPair) pairBuffer += generateNextLine(state, level);
-			if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
-			if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
-			else pairBuffer += ": ";
-			pairBuffer += state.dump;
-			_result += pairBuffer;
-		}
-		state.tag = _tag;
-		state.dump = _result || "{}";
-	}
-	function detectType(state, object, explicit) {
-		const typeList = explicit ? state.explicitTypes : state.implicitTypes;
-		for (let index = 0, length = typeList.length; index < length; index += 1) {
-			const type = typeList[index];
-			if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
-				if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
-				else state.tag = type.tag;
-				else state.tag = "?";
-				if (type.represent) {
-					const style = state.styleMap[type.tag] || type.defaultStyle;
-					let _result;
-					if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
-					else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
-					else throw new YAMLException("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
-					state.dump = _result;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-	function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-		state.tag = null;
-		state.dump = object;
-		if (!detectType(state, object, false)) detectType(state, object, true);
-		const type = _toString.call(state.dump);
-		const inblock = block;
-		if (block) block = state.flowLevel < 0 || state.flowLevel > level;
-		const objectOrArray = type === "[object Object]" || type === "[object Array]";
-		let duplicateIndex;
-		let duplicate;
-		if (objectOrArray) {
-			duplicateIndex = state.duplicates.indexOf(object);
-			duplicate = duplicateIndex !== -1;
-		}
-		if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
-		if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
-		else {
-			if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
-			if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
-				writeBlockMapping(state, level, state.dump, compact);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-			} else {
-				writeFlowMapping(state, level, state.dump);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-			}
-			else if (type === "[object Array]") if (block && state.dump.length !== 0) {
-				if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
-				else writeBlockSequence(state, level, state.dump, compact);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-			} else {
-				writeFlowSequence(state, level, state.dump);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-			}
-			else if (type === "[object String]") {
-				if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
-			} else if (type === "[object Undefined]") return false;
-			else {
-				if (state.skipInvalid) return false;
-				throw new YAMLException("unacceptable kind of an object to dump " + type);
-			}
-			if (state.tag !== null && state.tag !== "?") {
-				let tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
-				if (state.tag[0] === "!") tagStr = "!" + tagStr;
-				else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
-				else tagStr = "!<" + tagStr + ">";
-				state.dump = tagStr + " " + state.dump;
+					}
+				} else if (!isPrintable(char)) return STYLE_DOUBLE;
+				plain = plain && isPlainSafe(char, prevChar, inblock);
+				prevChar = char;
 			}
+			hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
 		}
-		return true;
-	}
-	function getDuplicateReferences(object, state) {
-		const objects = [];
-		const duplicatesIndexes = [];
-		inspectNode(object, objects, duplicatesIndexes);
-		const length = duplicatesIndexes.length;
-		for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
-		state.usedDuplicates = new Array(length);
+		if (!hasLineBreak && !hasFoldableLine) {
+			if (plain && !forceQuotes && !testAmbiguousType(string)) return STYLE_PLAIN;
+			return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+		}
+		if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE;
+		if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+		return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
 	}
-	function inspectNode(object, objects, duplicatesIndexes) {
-		if (object !== null && typeof object === "object") {
-			const index = objects.indexOf(object);
-			if (index !== -1) {
-				if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
-			} else {
-				objects.push(object);
-				if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
-				else {
-					const objectKeyList = Object.keys(object);
-					for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
-				}
+	function writeScalar(state, string, level, iskey, inblock) {
+		state.dump = function() {
+			if (string.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"\"" : "''";
+			if (!state.noCompatMode) {
+				if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"" + string + "\"" : "'" + string + "'";
 			}
-		}
+			const indent = state.indent * Math.max(1, level);
+			const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+			const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
+			function testAmbiguity(string) {
+				return testImplicitResolving(state, string);
+			}
+			switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
+				case STYLE_PLAIN: return string;
+				case STYLE_SINGLE: return "'" + string.replace(/'/g, "''") + "'";
+				case STYLE_LITERAL: return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
+				case STYLE_FOLDED: return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
+				case STYLE_DOUBLE: return "\"" + escapeString(string, lineWidth) + "\"";
+				default: throw new YAMLException("impossible error: invalid scalar style");
+			}
+		}();
 	}
-	function dump(input, options) {
-		options = options || {};
-		const state = new State(options);
-		if (!state.noRefs) getDuplicateReferences(input, state);
-		let value = input;
-		if (state.replacer) value = state.replacer.call({ "": value }, "", value);
-		if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
-		return "";
+	function blockHeader(string, indentPerLevel) {
+		const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
+		const clip = string[string.length - 1] === "\n";
+		return indentIndicator + (clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-") + "\n";
 	}
-	module.exports.dump = dump;
-}));
-var import_js_yaml = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var loader = require_loader();
-	var dumper = require_dumper();
-	function renamed(from, to) {
-		return function() {
-			throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
-		};
+	function dropEndingNewline(string) {
+		return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
 	}
-	module.exports.Type = require_type();
-	module.exports.Schema = require_schema();
-	module.exports.FAILSAFE_SCHEMA = require_failsafe();
-	module.exports.JSON_SCHEMA = require_json();
-	module.exports.CORE_SCHEMA = require_core();
-	module.exports.DEFAULT_SCHEMA = require_default();
-	module.exports.load = loader.load;
-	module.exports.loadAll = loader.loadAll;
-	module.exports.dump = dumper.dump;
-	module.exports.YAMLException = require_exception();
-	module.exports.types = {
-		binary: require_binary(),
-		float: require_float(),
-		map: require_map(),
-		null: require_null(),
-		pairs: require_pairs(),
-		set: require_set(),
-		timestamp: require_timestamp(),
-		bool: require_bool(),
-		int: require_int(),
-		merge: require_merge(),
-		omap: require_omap(),
-		seq: require_seq(),
-		str: require_str()
-	};
-	module.exports.safeLoad = renamed("safeLoad", "load");
-	module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
-	module.exports.safeDump = renamed("safeDump", "dump");
-})))(), 1);
-var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
-var index_vite_proxy_tmp_default = import_js_yaml.default;
-
-//#endregion
-//#region ../graph-tools/dist/index.mjs
-/**
-* Convert a resolved {@link GraphNode} back into a {@link NodeConfig}.
-*
-* Faithful and complete: round-tripping through `createGraphNode` yields a
-* deep-equal node. Optional fields are only included when present; ports are
-* deep-copied so the config does not share port objects with the source node.
-*/
-function toNodeConfig(node) {
-	const config = { id: node.id };
-	if (node.parentId != null) config.parentId = node.parentId;
-	if (node.initialNodeId != null) config.initialNodeId = node.initialNodeId;
-	if (node.label != null) config.label = node.label;
-	if (node.data != null) config.data = node.data;
-	if (node.ports !== void 0) config.ports = node.ports.map((p) => ({ ...p }));
-	if (node.x !== void 0) config.x = node.x;
-	if (node.y !== void 0) config.y = node.y;
-	if (node.width !== void 0) config.width = node.width;
-	if (node.height !== void 0) config.height = node.height;
-	if (node.shape !== void 0) config.shape = node.shape;
-	if (node.color !== void 0) config.color = node.color;
-	if (node.style !== void 0) config.style = node.style;
-	return config;
-}
-/**
-* Convert a resolved {@link GraphEdge} back into an {@link EdgeConfig}.
-*
-* Faithful and complete: round-tripping through `createGraphEdge` yields a
-* deep-equal edge. Optional fields are only included when present.
-*/
-function toEdgeConfig(edge) {
-	const config = {
-		id: edge.id,
-		sourceId: edge.sourceId,
-		targetId: edge.targetId
-	};
-	if (edge.label != null) config.label = edge.label;
-	if (edge.data != null) config.data = edge.data;
-	if (edge.weight !== void 0) config.weight = edge.weight;
-	if (edge.mode !== void 0) config.mode = edge.mode;
-	if (edge.sourcePort !== void 0) config.sourcePort = edge.sourcePort;
-	if (edge.targetPort !== void 0) config.targetPort = edge.targetPort;
-	if (edge.points !== void 0) config.points = edge.points.map((p) => ({ ...p }));
-	if (edge.routing !== void 0) config.routing = edge.routing;
-	if (edge.x !== void 0) config.x = edge.x;
-	if (edge.y !== void 0) config.y = edge.y;
-	if (edge.width !== void 0) config.width = edge.width;
-	if (edge.height !== void 0) config.height = edge.height;
-	if (edge.color !== void 0) config.color = edge.color;
-	if (edge.style !== void 0) config.style = edge.style;
-	return config;
-}
-const LAYOUT_KEYS$1 = {
-	node: [
-		"x",
-		"y",
-		"width",
-		"height",
-		"style",
-		"color",
-		"shape"
-	],
-	edge: [
-		"x",
-		"y",
-		"width",
-		"height",
-		"points",
-		"routing",
-		"style",
-		"color"
-	]
-};
-new Set(LAYOUT_KEYS$1.node), new Set(LAYOUT_KEYS$1.edge);
-/** Shallow-compare two values, returning true if they differ. */
-function differs(a, b) {
-	if (a === b) return false;
-	if (a == null || b == null) return a !== b;
-	if (typeof a === "object" && typeof b === "object") return JSON.stringify(a) !== JSON.stringify(b);
-	return true;
-}
-const NODE_COMPARE_KEYS = [
-	"parentId",
-	"initialNodeId",
-	"label",
-	"data",
-	"ports",
-	"x",
-	"y",
-	"width",
-	"height",
-	"shape",
-	"color",
-	"style"
-];
-const EDGE_COMPARE_KEYS = [
-	"sourceId",
-	"targetId",
-	"label",
-	"data",
-	"weight",
-	"mode",
-	"sourcePort",
-	"targetPort",
-	"points",
-	"routing",
-	"x",
-	"y",
-	"width",
-	"height",
-	"color",
-	"style"
-];
-/**
-* Compute a structured diff from graph `a` to graph `b` by matching IDs.
-*
-* @example
-* ```ts
-* import { createGraph, getDiff } from '@statelyai/graph';
-*
-* const a = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
-* const b = createGraph({ nodes: [{ id: 'n1', label: 'hello' }, { id: 'n2' }], edges: [] });
-*
-* const diff = getDiff(a, b);
-* // diff.nodes.added → [{ id: 'n2' }]
-* // diff.nodes.updated → [{ id: 'n1', old: { label: '' }, new: { label: 'hello' } }]
-* ```
-*/
-function getDiff(a, b) {
-	const aNodeMap = new Map(a.nodes.map((n) => [n.id, n]));
-	const bNodeMap = new Map(b.nodes.map((n) => [n.id, n]));
-	const aEdgeMap = new Map(a.edges.map((e) => [e.id, e]));
-	const bEdgeMap = new Map(b.edges.map((e) => [e.id, e]));
-	const diff = {
-		nodes: {
-			added: [],
-			removed: [],
-			updated: []
-		},
-		edges: {
-			added: [],
-			removed: [],
-			updated: []
+	function foldString(string, width) {
+		const lineRe = /(\n+)([^\n]*)/g;
+		let result = function() {
+			let nextLF = string.indexOf("\n");
+			nextLF = nextLF !== -1 ? nextLF : string.length;
+			lineRe.lastIndex = nextLF;
+			return foldLine(string.slice(0, nextLF), width);
+		}();
+		let prevMoreIndented = string[0] === "\n" || string[0] === " ";
+		let moreIndented;
+		let match;
+		while (match = lineRe.exec(string)) {
+			const prefix = match[1];
+			const line = match[2];
+			moreIndented = line[0] === " ";
+			result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
+			prevMoreIndented = moreIndented;
 		}
-	};
-	for (const [id, nodeB] of bNodeMap) {
-		const nodeA = aNodeMap.get(id);
-		if (!nodeA) diff.nodes.added.push(toNodeConfig(nodeB));
-		else {
-			const oldPartial = {};
-			const newPartial = {};
-			for (const key of NODE_COMPARE_KEYS) {
-				const oldValue = nodeA[key] ?? null;
-				const newValue = nodeB[key] ?? null;
-				if (differs(oldValue, newValue)) {
-					oldPartial[key] = oldValue;
-					newPartial[key] = newValue;
-				}
+		return result;
+	}
+	function foldLine(line, width) {
+		if (line === "" || line[0] === " ") return line;
+		const breakRe = / [^ ]/g;
+		let match;
+		let start = 0;
+		let end;
+		let curr = 0;
+		let next = 0;
+		let result = "";
+		while (match = breakRe.exec(line)) {
+			next = match.index;
+			if (next - start > width) {
+				end = curr > start ? curr : next;
+				result += "\n" + line.slice(start, end);
+				start = end + 1;
 			}
-			if (Object.keys(oldPartial).length > 0) diff.nodes.updated.push({
-				id,
-				old: oldPartial,
-				new: newPartial
-			});
+			curr = next;
 		}
+		result += "\n";
+		if (line.length - start > width && curr > start) result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
+		else result += line.slice(start);
+		return result.slice(1);
 	}
-	for (const [id, nodeA] of aNodeMap) if (!bNodeMap.has(id)) diff.nodes.removed.push(toNodeConfig(nodeA));
-	for (const [id, edgeB] of bEdgeMap) {
-		const edgeA = aEdgeMap.get(id);
-		if (!edgeA) diff.edges.added.push(toEdgeConfig(edgeB));
-		else {
-			const oldPartial = {};
-			const newPartial = {};
-			for (const key of EDGE_COMPARE_KEYS) {
-				const oldValue = edgeA[key] ?? null;
-				const newValue = edgeB[key] ?? null;
-				if (differs(oldValue, newValue)) {
-					oldPartial[key] = oldValue;
-					newPartial[key] = newValue;
+	function escapeString(string) {
+		let result = "";
+		let char = 0;
+		for (let i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+			char = codePointAt(string, i);
+			const escapeSeq = ESCAPE_SEQUENCES[char];
+			if (!escapeSeq && isPrintable(char)) {
+				result += string[i];
+				if (char >= 65536) result += string[i + 1];
+			} else result += escapeSeq || encodeHex(char);
+		}
+		return result;
+	}
+	function writeFlowSequence(state, level, object) {
+		let _result = "";
+		const _tag = state.tag;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			let value = object[index];
+			if (state.replacer) value = state.replacer.call(object, String(index), value);
+			if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
+				if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
+				_result += state.dump;
+			}
+		}
+		state.tag = _tag;
+		state.dump = "[" + _result + "]";
+	}
+	function writeBlockSequence(state, level, object, compact) {
+		let _result = "";
+		const _tag = state.tag;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			let value = object[index];
+			if (state.replacer) value = state.replacer.call(object, String(index), value);
+			if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
+				if (!compact || _result !== "") _result += generateNextLine(state, level);
+				if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) _result += "-";
+				else _result += "- ";
+				_result += state.dump;
+			}
+		}
+		state.tag = _tag;
+		state.dump = _result || "[]";
+	}
+	function writeFlowMapping(state, level, object) {
+		let _result = "";
+		const _tag = state.tag;
+		const objectKeyList = Object.keys(object);
+		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+			let pairBuffer = "";
+			if (_result !== "") pairBuffer += ", ";
+			if (state.condenseFlow) pairBuffer += "\"";
+			const objectKey = objectKeyList[index];
+			let objectValue = object[objectKey];
+			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+			if (!writeNode(state, level, objectKey, false, false)) continue;
+			if (state.dump.length > 1024) pairBuffer += "? ";
+			pairBuffer += state.dump + (state.condenseFlow ? "\"" : "") + ":" + (state.condenseFlow ? "" : " ");
+			if (!writeNode(state, level, objectValue, false, false)) continue;
+			pairBuffer += state.dump;
+			_result += pairBuffer;
+		}
+		state.tag = _tag;
+		state.dump = "{" + _result + "}";
+	}
+	function writeBlockMapping(state, level, object, compact) {
+		let _result = "";
+		const _tag = state.tag;
+		const objectKeyList = Object.keys(object);
+		if (state.sortKeys === true) objectKeyList.sort();
+		else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
+		else if (state.sortKeys) throw new YAMLException("sortKeys must be a boolean or a function");
+		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+			let pairBuffer = "";
+			if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
+			const objectKey = objectKeyList[index];
+			let objectValue = object[objectKey];
+			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+			if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
+			const explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+			if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
+			else pairBuffer += "? ";
+			pairBuffer += state.dump;
+			if (explicitPair) pairBuffer += generateNextLine(state, level);
+			if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
+			if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
+			else pairBuffer += ": ";
+			pairBuffer += state.dump;
+			_result += pairBuffer;
+		}
+		state.tag = _tag;
+		state.dump = _result || "{}";
+	}
+	function detectType(state, object, explicit) {
+		const typeList = explicit ? state.explicitTypes : state.implicitTypes;
+		for (let index = 0, length = typeList.length; index < length; index += 1) {
+			const type = typeList[index];
+			if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
+				if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
+				else state.tag = type.tag;
+				else state.tag = "?";
+				if (type.represent) {
+					const style = state.styleMap[type.tag] || type.defaultStyle;
+					let _result;
+					if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
+					else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
+					else throw new YAMLException("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
+					state.dump = _result;
 				}
+				return true;
 			}
-			if (Object.keys(oldPartial).length > 0) diff.edges.updated.push({
-				id,
-				old: oldPartial,
-				new: newPartial
-			});
 		}
+		return false;
 	}
-	for (const [id, edgeA] of aEdgeMap) if (!bEdgeMap.has(id)) diff.edges.removed.push(toEdgeConfig(edgeA));
-	return diff;
-}
-/**
-* Check if a diff has zero changes.
-*
-* @example
-* ```ts
-* import { createGraph, getDiff, isEmptyDiff } from '@statelyai/graph';
-*
-* const g = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
-* const diff = getDiff(g, g);
-* isEmptyDiff(diff); // true
-* ```
-*/
-function isEmptyDiff$1(diff) {
-	return diff.nodes.added.length === 0 && diff.nodes.removed.length === 0 && diff.nodes.updated.length === 0 && diff.edges.added.length === 0 && diff.edges.removed.length === 0 && diff.edges.updated.length === 0;
-}
-function summarizeGraphDiff(diff) {
-	return {
-		hasChanges: !isEmptyDiff$1(diff),
-		nodeChanges: diff.nodes.added.length + diff.nodes.removed.length + diff.nodes.updated.length,
-		edgeChanges: diff.edges.added.length + diff.edges.removed.length + diff.edges.updated.length
-	};
-}
-function nodeDepth$1(graph, node) {
-	let depth = 0;
-	let parentId = node.parentId;
-	while (parentId) {
-		depth++;
-		parentId = graph.nodes.find((candidate) => candidate.id === parentId)?.parentId;
+	function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+		state.tag = null;
+		state.dump = object;
+		if (!detectType(state, object, false)) detectType(state, object, true);
+		const type = _toString.call(state.dump);
+		const inblock = block;
+		if (block) block = state.flowLevel < 0 || state.flowLevel > level;
+		const objectOrArray = type === "[object Object]" || type === "[object Array]";
+		let duplicateIndex;
+		let duplicate;
+		if (objectOrArray) {
+			duplicateIndex = state.duplicates.indexOf(object);
+			duplicate = duplicateIndex !== -1;
+		}
+		if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
+		if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
+		else {
+			if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
+			if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
+				writeBlockMapping(state, level, state.dump, compact);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+			} else {
+				writeFlowMapping(state, level, state.dump);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+			}
+			else if (type === "[object Array]") if (block && state.dump.length !== 0) {
+				if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
+				else writeBlockSequence(state, level, state.dump, compact);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+			} else {
+				writeFlowSequence(state, level, state.dump);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+			}
+			else if (type === "[object String]") {
+				if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
+			} else if (type === "[object Undefined]") return false;
+			else {
+				if (state.skipInvalid) return false;
+				throw new YAMLException("unacceptable kind of an object to dump " + type);
+			}
+			if (state.tag !== null && state.tag !== "?") {
+				let tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
+				if (state.tag[0] === "!") tagStr = "!" + tagStr;
+				else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
+				else tagStr = "!<" + tagStr + ">";
+				state.dump = tagStr + " " + state.dump;
+			}
+		}
+		return true;
 	}
-	return depth;
-}
-function nodeKey(node) {
-	return node.data?.key || node.id;
-}
-function edgeSignature(edge) {
-	return [
-		edge.sourceId,
-		edge.data?.eventType,
-		edge.targetId,
-		edge.data?.guard?.type ?? ""
-	].join("->");
-}
-function getStableNodeId(node, parentStableId, siblingIndex, preferredIds) {
-	const preferredId = preferredIds?.get(node.id);
-	if (preferredId !== void 0) return preferredId;
-	if (node.parentId === null) return "root";
-	const key = nodeKey(node);
-	const suffix = siblingIndex === 0 ? key : `${key}_${siblingIndex + 1}`;
-	return parentStableId ? `${parentStableId}.${suffix}` : suffix;
-}
-function getStableEdgeId(edge, siblingIndex, preferredIds) {
-	const preferredId = preferredIds?.get(edge.id);
-	if (preferredId !== void 0) return preferredId;
-	const suffix = siblingIndex === 0 ? "" : `.${siblingIndex + 1}`;
-	return edgeSignature(edge).concat(suffix);
-}
-function removePresentationFields(entity, kind) {
-	const mutableEntity = entity;
-	for (const key of LAYOUT_KEYS$1[kind]) delete mutableEntity[key];
-	const data = mutableEntity.data;
-	if (data && typeof data === "object" && !Array.isArray(data)) delete data.color;
-}
-/**
-* Rewrites entity ids to structural ("semantic") ids so two graphs that model
-* the same machine compare equal regardless of how their ids were minted.
-*
-* Invariant: node and edge array order is preserved exactly. Callers
-* (`alignCompareIds` in the editor's /v1/diff route) rely on
-* `normalized.nodes[i]` describing `graph.nodes[i]` to translate a semantic id
-* back to the caller's original id. Never sort, filter, or reorder the arrays
-* on the returned graph; sorting for traversal must be done on a copy, as the
-* depth ordering below does.
-*
-* Presentation-only fields defined by `LAYOUT_KEYS`, plus entity data colors,
-* are removed. When preferred ids are supplied, matching raw ids retain the
-* base graph's semantic identity so a stable-id rename is reported as an
-* update.
-*
-* Entity `data` is treated as optional throughout: sparse graphs (a node with
-* `data: {}`, an edge with `data: null`) normalize instead of throwing.
-*/
-function normalizeGraphForSemanticDiff(graph, preferredIds) {
-	const normalized = structuredClone(graph);
-	const nodeIdMap = /* @__PURE__ */ new Map();
-	const siblingKeys = /* @__PURE__ */ new Map();
-	const reservedNodeIds = new Set(preferredIds?.nodes.values());
-	const claimedNodeIds = /* @__PURE__ */ new Set();
-	const nodesByDepth = [...normalized.nodes].sort((a, b) => nodeDepth$1(normalized, a) - nodeDepth$1(normalized, b));
-	for (const node of nodesByDepth) {
-		const parentStableId = node.parentId ? nodeIdMap.get(node.parentId) ?? node.parentId : null;
-		const key = `${parentStableId ?? ""}:${nodeKey(node)}`;
-		const siblingIndex = siblingKeys.get(key) ?? 0;
-		siblingKeys.set(key, siblingIndex + 1);
-		const proposedId = getStableNodeId(node, parentStableId, siblingIndex, preferredIds?.nodes);
-		let stableId = proposedId;
-		let collisionIndex = 2;
-		while (!preferredIds?.nodes.has(node.id) && (reservedNodeIds.has(stableId) || claimedNodeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
-		claimedNodeIds.add(stableId);
-		nodeIdMap.set(node.id, stableId);
+	function getDuplicateReferences(object, state) {
+		const objects = [];
+		const duplicatesIndexes = [];
+		inspectNode(object, objects, duplicatesIndexes);
+		const length = duplicatesIndexes.length;
+		for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
+		state.usedDuplicates = new Array(length);
 	}
-	for (const node of normalized.nodes) {
-		removePresentationFields(node, "node");
-		node.id = nodeIdMap.get(node.id) ?? node.id;
-		if (node.parentId) node.parentId = nodeIdMap.get(node.parentId) ?? node.parentId;
-		if (node.initialNodeId) node.initialNodeId = nodeIdMap.get(node.initialNodeId) ?? node.initialNodeId;
-		if (node.data?.initialId) node.data.initialId = nodeIdMap.get(node.data.initialId) ?? node.data.initialId;
+	function inspectNode(object, objects, duplicatesIndexes) {
+		if (object !== null && typeof object === "object") {
+			const index = objects.indexOf(object);
+			if (index !== -1) {
+				if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
+			} else {
+				objects.push(object);
+				if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
+				else {
+					const objectKeyList = Object.keys(object);
+					for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
+				}
+			}
+		}
 	}
-	const edgeSiblingKeys = /* @__PURE__ */ new Map();
-	const reservedEdgeIds = new Set(preferredIds?.edges.values());
-	const claimedEdgeIds = /* @__PURE__ */ new Set();
-	for (const edge of normalized.edges) {
-		removePresentationFields(edge, "edge");
-		edge.sourceId = nodeIdMap.get(edge.sourceId) ?? edge.sourceId;
-		edge.targetId = nodeIdMap.get(edge.targetId) ?? edge.targetId;
-		const key = edgeSignature(edge);
-		const siblingIndex = edgeSiblingKeys.get(key) ?? 0;
-		edgeSiblingKeys.set(key, siblingIndex + 1);
-		const proposedId = getStableEdgeId(edge, siblingIndex, preferredIds?.edges);
-		let stableId = proposedId;
-		let collisionIndex = 2;
-		while (!preferredIds?.edges.has(edge.id) && (reservedEdgeIds.has(stableId) || claimedEdgeIds.has(stableId))) stableId = `${proposedId}:unmatched:${collisionIndex++}`;
-		claimedEdgeIds.add(stableId);
-		edge.id = stableId;
+	function dump(input, options) {
+		options = options || {};
+		const state = new State(options);
+		if (!state.noRefs) getDuplicateReferences(input, state);
+		let value = input;
+		if (state.replacer) value = state.replacer.call({ "": value }, "", value);
+		if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+		return "";
 	}
-	if (normalized.initialNodeId) normalized.initialNodeId = nodeIdMap.get(normalized.initialNodeId) ?? normalized.initialNodeId;
-	return normalized;
-}
-function diffGraphsSemantically(baseGraph, compareGraph) {
-	const base = normalizeGraphForSemanticDiff(baseGraph);
-	const compareNodeIds = new Set(compareGraph.nodes.map((node) => node.id));
-	const compareEdgeIds = new Set(compareGraph.edges.map((edge) => edge.id));
-	const compare = normalizeGraphForSemanticDiff(compareGraph, {
-		nodes: new Map(baseGraph.nodes.map((node, index) => [node.id, base.nodes[index].id]).filter(([id]) => compareNodeIds.has(id))),
-		edges: new Map(baseGraph.edges.map((edge, index) => [edge.id, base.edges[index].id]).filter(([id]) => compareEdgeIds.has(id)))
-	});
-	const diff = getDiff(base, compare);
-	return {
-		base,
-		compare,
-		diff,
-		summary: summarizeGraphDiff(diff)
+	module.exports.dump = dump;
+}));
+var import_js_yaml = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var loader = require_loader();
+	var dumper = require_dumper();
+	function renamed(from, to) {
+		return function() {
+			throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
+		};
+	}
+	module.exports.Type = require_type();
+	module.exports.Schema = require_schema();
+	module.exports.FAILSAFE_SCHEMA = require_failsafe();
+	module.exports.JSON_SCHEMA = require_json();
+	module.exports.CORE_SCHEMA = require_core();
+	module.exports.DEFAULT_SCHEMA = require_default();
+	module.exports.load = loader.load;
+	module.exports.loadAll = loader.loadAll;
+	module.exports.dump = dumper.dump;
+	module.exports.YAMLException = require_exception();
+	module.exports.types = {
+		binary: require_binary(),
+		float: require_float(),
+		map: require_map(),
+		null: require_null(),
+		pairs: require_pairs(),
+		set: require_set(),
+		timestamp: require_timestamp(),
+		bool: require_bool(),
+		int: require_int(),
+		merge: require_merge(),
+		omap: require_omap(),
+		seq: require_seq(),
+		str: require_str()
 	};
-}
+	module.exports.safeLoad = renamed("safeLoad", "load");
+	module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
+	module.exports.safeDump = renamed("safeDump", "dump");
+})))(), 1);
+var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
+var index_vite_proxy_tmp_default = import_js_yaml.default;
+
+//#endregion
+//#region ../graph-tools/dist/index.mjs
 /** A patch changes machine semantics rather than presentation metadata. */
 function isStructuralPatch(patch) {
 	if (patch.op === "createImplementation" && !patch.implementation.code) return false;
@@ -7552,10 +7733,16 @@ function graphToMachineConfig(graph, options = {}) {
 		const tags = node.data.tags;
 		const stateMeta = showMeta ? buildMeta({
 			...node.data.meta,
-			...node.data.assets?.length ? { "@statelyai.assets": node.data.assets.map(({ type, url, size }) => ({
+			...node.data.assets?.length ? { "@statelyai.assets": node.data.assets.map(({ type, url, size, width, height, name, metadata }) => ({
 				type,
 				url,
-				...size ? { size } : {}
+				...size ? { size } : {},
+				...name !== void 0 ? { name } : {},
+				...metadata !== void 0 ? { metadata } : {},
+				...type === "iframe" ? {
+					...width !== void 0 ? { width } : {},
+					...height !== void 0 ? { height } : {}
+				} : {}
 			})) } : {},
 			...node.data.appearance ? { "@statelyai.appearance": node.data.appearance } : {}
 		}, node.data.color, showStatelyMeta) : void 0;
@@ -7609,10 +7796,16 @@ function graphToMachineConfig(graph, options = {}) {
 				const type = edge.data.eventType ?? "";
 				const transitionMeta = showMeta ? buildMeta({
 					...edge.data.meta,
-					...edge.data.assets?.length ? { "@statelyai.assets": edge.data.assets.map(({ type, url, size }) => ({
+					...edge.data.assets?.length ? { "@statelyai.assets": edge.data.assets.map(({ type, url, size, width, height, name, metadata }) => ({
 						type,
 						url,
-						...size ? { size } : {}
+						...size ? { size } : {},
+						...name !== void 0 ? { name } : {},
+						...metadata !== void 0 ? { metadata } : {},
+						...type === "iframe" ? {
+							...width !== void 0 ? { width } : {},
+							...height !== void 0 ? { height } : {}
+						} : {}
 					})) } : {},
 					...edge.data.appearance ? { "@statelyai.appearance": edge.data.appearance } : {}
 				}, edge.data.color, showStatelyMeta) : edge.data.meta?.[FN_PROJECTION_META] ? { [FN_PROJECTION_META]: edge.data.meta[FN_PROJECTION_META] } : void 0;
@@ -13332,7 +13525,7 @@ function modify(text, path, value, options) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/adapters-Dt77BFUa.mjs
+//#region ../editor-sync/dist/adapters-9XXzVfbF.mjs
 const sourceFileUris = /* @__PURE__ */ new WeakMap();
 function collectXStateSourceLocations(sourceText, document, options = {}) {
 	const sourceFile = ts$1.createSourceFile(document.fileName, sourceText, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(document.fileName));
@@ -13347,10 +13540,13 @@ function collectXStateSourceLocations(sourceText, document, options = {}) {
 	const states = [];
 	const statesObjectLocations = [];
 	collectStateLocations(root, [], states, statesObjectLocations, bindings, staticValues, root);
-	const packageProfile = detectXStatePackageProfile(options.resolver?.resolvePackageJson?.({
+	const packageProfile = detectXStatePackageProfile(machineFactoryPackage(sourceFile, {
 		fileName: document.fileName,
 		uri
-	}, "xstate"));
+	}, options.machineIndex, options.resolver) === "xstate" ? options.resolver?.resolvePackageJson?.({
+		fileName: document.fileName,
+		uri
+	}, "xstate") : void 0);
 	const rootProfile = detectXStateSourceProfile(sourceText);
 	const referencedStateSymbols = new Set([...states, ...statesObjectLocations].map((state) => state.symbol).filter((symbol) => typeof symbol === "string"));
 	const resolvedTransitionFunctions = collectResolvedTransitionFunctions(root, bindings);
@@ -13378,6 +13574,104 @@ function collectXStateSourceLocations(sourceText, document, options = {}) {
 		}])
 	};
 }
+/** Only the package providing this machine's factory can establish its version. */
+function machineFactoryPackage(sourceFile, document, machineIndex = 0, resolver) {
+	const modules = /* @__PURE__ */ new Map();
+	const rootModule = {
+		file: sourceFile,
+		document
+	};
+	modules.set(document.uri, rootModule);
+	const visited = /* @__PURE__ */ new Set();
+	function imported(module, specifier, name) {
+		if (!specifier.startsWith(".")) return specifier;
+		const snapshot = resolver?.resolveImport(module.document, specifier);
+		if (!snapshot || !name) return void 0;
+		let target = modules.get(snapshot.uri);
+		if (!target) {
+			target = {
+				file: ts$1.createSourceFile(snapshot.fileName, snapshot.text, ts$1.ScriptTarget.Latest, true, getScriptKind$2$1(snapshot.fileName)),
+				document: snapshot
+			};
+			modules.set(snapshot.uri, target);
+		}
+		return exported(target, name);
+	}
+	function exported(module, name) {
+		const key = `${module.document.uri}\0export\0${name}`;
+		if (visited.has(key)) return void 0;
+		visited.add(key);
+		try {
+			for (const statement of module.file.statements) {
+				if (!ts$1.isExportDeclaration(statement) || !statement.exportClause || !ts$1.isNamedExports(statement.exportClause)) continue;
+				const element = statement.exportClause.elements.find((element) => element.name.text === name);
+				if (!element) continue;
+				const localName = element.propertyName?.text ?? element.name.text;
+				return statement.moduleSpecifier && ts$1.isStringLiteral(statement.moduleSpecifier) ? imported(module, statement.moduleSpecifier.text, localName) : symbol(module, localName);
+			}
+			for (const statement of module.file.statements) if (ts$1.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts$1.SyntaxKind.ExportKeyword)) {
+				if (statement.declarationList.declarations.some((declaration) => ts$1.isIdentifier(declaration.name) && declaration.name.text === name)) return symbol(module, name);
+			}
+			for (const statement of module.file.statements) {
+				if (!ts$1.isExportDeclaration(statement) || statement.exportClause || !statement.moduleSpecifier || !ts$1.isStringLiteral(statement.moduleSpecifier)) continue;
+				const result = imported(module, statement.moduleSpecifier.text, name);
+				if (result) return result;
+			}
+			return;
+		} finally {
+			visited.delete(key);
+		}
+	}
+	function symbol(module, name, member) {
+		const key = `${module.document.uri}\0symbol\0${name}\0${member ?? ""}`;
+		if (visited.has(key)) return void 0;
+		visited.add(key);
+		try {
+			for (const statement of module.file.statements) {
+				if (ts$1.isImportDeclaration(statement) && ts$1.isStringLiteral(statement.moduleSpecifier)) {
+					const bindings = statement.importClause?.namedBindings;
+					if (bindings && ts$1.isNamedImports(bindings)) {
+						const element = bindings.elements.find((element) => element.name.text === name);
+						if (element) return imported(module, statement.moduleSpecifier.text, element.propertyName?.text ?? element.name.text);
+					} else if (bindings && ts$1.isNamespaceImport(bindings) && bindings.name.text === name) return imported(module, statement.moduleSpecifier.text, member);
+				}
+				if (!ts$1.isVariableStatement(statement)) continue;
+				for (const declaration of statement.declarationList.declarations) {
+					if (!declaration.initializer) continue;
+					if (ts$1.isIdentifier(declaration.name) && declaration.name.text === name) return resolve(module, declaration.initializer, member);
+					if (ts$1.isObjectBindingPattern(declaration.name)) {
+						const element = declaration.name.elements.find((element) => !element.dotDotDotToken && ts$1.isIdentifier(element.name) && element.name.text === name);
+						if (element) return resolve(module, declaration.initializer, element.propertyName ? element.propertyName.getText(module.file).replace(/^['"]|['"]$/g, "") : name);
+					}
+				}
+			}
+			return;
+		} finally {
+			visited.delete(key);
+		}
+	}
+	function resolve(module, node, member) {
+		if (ts$1.isIdentifier(node)) return symbol(module, node.text, member);
+		if (ts$1.isCallExpression(node)) {
+			if (ts$1.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1 && ts$1.isStringLiteral(node.arguments[0])) return imported(module, node.arguments[0].text, member);
+			return resolve(module, node.expression);
+		}
+		if (ts$1.isPropertyAccessExpression(node)) return resolve(module, node.expression, node.name.text);
+		if (ts$1.isParenthesizedExpression(node) || ts$1.isAsExpression(node) || ts$1.isSatisfiesExpression(node) || ts$1.isNonNullExpression(node)) return resolve(module, node.expression, member);
+	}
+	let factory;
+	let index = 0;
+	const visit = (node) => {
+		if (factory) return;
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1$1(node.expression)) {
+			if (index++ === machineIndex) factory = node;
+			return;
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return factory ? resolve(rootModule, factory) : void 0;
+}
 function detectXStatePackageProfile(packageJson) {
 	if (!packageJson) return void 0;
 	let manifest;
@@ -14109,7 +14403,14 @@ function parseSourceToMachine(text, document, options = {}) {
 	].filter(removeOverlappingRanges).sort(compareSourceRangesDescending));
 	if (sourceLocations.profile === "xstate-v6-alpha" || options.machineIndex !== void 0) {
 		const importedTransitionSources = collectImportedXStateTransitionSources(text, document, options);
-		const parseText = importedTransitionSources.length ? `${hydratedText}\n${importedTransitionSources.join("\n")}` : hydratedText;
+		const transitionDeclarations = ts$1.createSourceFile(document.fileName, importedTransitionSources.join("\n"), ts$1.ScriptTarget.Latest, true, ts$1.ScriptKind.TSX);
+		const transitionSymbols = /* @__PURE__ */ new Set();
+		for (const statement of transitionDeclarations.statements) if (ts$1.isFunctionDeclaration(statement) && statement.name) transitionSymbols.add(statement.name.text);
+		else if (ts$1.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) if (ts$1.isIdentifier(declaration.name)) transitionSymbols.add(declaration.name.text);
+		}
+		const moduleText = applySourceRangeReplacements(hydratedText, collectHydratedImportReplacements(hydratedText, document, transitionSymbols).sort(compareSourceRangesDescending));
+		const parseText = importedTransitionSources.length ? `${moduleText}\n${importedTransitionSources.join("\n")}` : moduleText;
 		const selectedMachineIndex = options.machineIndex ?? 0;
 		const config = extractXStateMachineConfigEntries(parseText, { profile: sourceLocations.profile }).find((entry) => entry.machineIndex === selectedMachineIndex)?.config;
 		if (!config) throw new Error(`No machine at index ${selectedMachineIndex} was found in ${document.fileName}.`);
@@ -14127,17 +14428,38 @@ function parseSourceToMachine(text, document, options = {}) {
 			setupImplementations[category] = Object.fromEntries(Object.entries(value).map(([name, body]) => [name, typeof body === "string" ? raw(body) : body]));
 			delete machineConfig[category];
 		}
-		if (Object.keys(setupImplementations).length) return `import { setup } from "xstate";
-
-export const machine = setup(${serializeJS(setupImplementations, 0)}).createMachine(${serializeJS(machineConfig, 0)});
-`;
-		return `import { createMachine } from "xstate";
-
-export const machine = createMachine(${serializeJS(machineConfig, 0)});
-`;
+		const factory = Object.keys(setupImplementations).length ? "setup" : "createMachine";
+		return selectMachineInModule(parseText, selectedMachineIndex, factory, factory === "setup" ? `setup(${serializeJS(setupImplementations, 0)}).createMachine(${serializeJS(machineConfig, 0)})` : `createMachine(${serializeJS(machineConfig, 0)})`);
 	}
 	return hydratedText;
 }
+function selectMachineInModule(source, machineIndex, factory, expression) {
+	const file = ts$1.createSourceFile("machine.ts", source, ts$1.ScriptTarget.Latest, true, ts$1.ScriptKind.TSX);
+	const replacements = [];
+	let index = 0;
+	let factoryAlias = "__stately_sync_factory";
+	while (source.includes(factoryAlias)) factoryAlias += "_";
+	const visit = (node) => {
+		if (ts$1.isCallExpression(node) && isCreateMachineExpression$1$1(node.expression)) {
+			if (index++ === machineIndex) replacements.push({
+				start: node.getStart(file),
+				end: node.getEnd(),
+				text: `(() => { const ${factory} = ${factoryAlias}; return ${expression}; })()`
+			});
+			else replacements.push({
+				start: node.expression.getStart(file),
+				end: node.expression.getEnd(),
+				text: `(${node.expression.getText(file)})`
+			});
+			return;
+		}
+		ts$1.forEachChild(node, visit);
+	};
+	visit(file);
+	let result = source;
+	for (const replacement of replacements.sort((a, b) => b.start - a.start)) result = result.slice(0, replacement.start) + replacement.text + result.slice(replacement.end);
+	return `import { ${factory} as ${factoryAlias} } from 'xstate';\n${result}`;
+}
 function readHydratedStatesObject(uri, range, states, resolver) {
 	if (!resolver) return null;
 	const document = resolver.read(uri);
@@ -14176,11 +14498,13 @@ function collectHydratedImportReplacements(text, document, hydratedSymbols) {
 		if (!statement.moduleSpecifier.text.startsWith(".")) continue;
 		const namedBindings = statement.importClause?.namedBindings;
 		if (!namedBindings || !ts$1.isNamedImports(namedBindings)) continue;
-		const importedNames = namedBindings.elements.map((element) => element.name.text);
-		if (importedNames.length === 0 || !importedNames.every((name) => hydratedSymbols.has(name))) continue;
+		const remaining = namedBindings.elements.filter((element) => !hydratedSymbols.has(element.name.text));
+		if (remaining.length === namedBindings.elements.length) continue;
+		const clause = statement.importClause;
+		const replacement = remaining.length || clause.name ? ts$1.createPrinter().printNode(ts$1.EmitHint.Unspecified, ts$1.factory.updateImportDeclaration(statement, statement.modifiers, ts$1.factory.updateImportClause(clause, clause.isTypeOnly, clause.name, remaining.length ? ts$1.factory.updateNamedImports(namedBindings, remaining) : void 0), statement.moduleSpecifier, statement.attributes), sourceFile) + "\n" : "";
 		replacements.push({
 			range: toSourceRange(sourceFile, statement, { includeTrailingNewline: true }),
-			newText: ""
+			newText: replacement
 		});
 	}
 	return replacements;
@@ -18422,7 +18746,7 @@ function diagnosticKey$1(diagnostic) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/localBackend-DH1qEsOz.mjs
+//#region ../editor-sync/dist/localBackend-CAt5onqr.mjs
 var LocalEditorSyncBackend = class {
 	constructor(access) {
 		this.access = access;
@@ -18870,7 +19194,7 @@ async function updateMachineDefinition(client, machineId, localGraph) {
 }
 
 //#endregion
-//#region ../editor-sync/dist/presentationMetadata-YX6iRP4T.mjs
+//#region ../editor-sync/dist/presentationMetadata-CIXaHmqN.mjs
 function createStudioPresentationMetadataStore(client, machineId) {
 	const load = async () => {
 		return {
@@ -19236,6 +19560,54 @@ function isPresentationOverlay(value) {
 function clone(value) {
 	return value === void 0 ? value : structuredClone(value);
 }
+/**
+* Apply only what an automatic layout computed to the last persisted graph:
+* the completed layout status of each newly laid-out region and the positions
+* of entities inside those regions. Colors, notes, assets, display choices and
+* manual moves the user has not saved stay as they were persisted.
+*/
+function mergeAutomaticLayout(persisted, laidOut) {
+	if (!isGraph(persisted) || !isGraph(laidOut)) return persisted;
+	const result = clone(persisted);
+	const laidOutNodes = new Map(laidOut.nodes.map((node) => [node.id, node]));
+	const regions = /* @__PURE__ */ new Set();
+	if (laidOut.layout?.status === "complete" && result.layout?.status !== "complete") {
+		regions.add(null);
+		result.layout = {
+			...result.layout,
+			...clone(laidOut.layout)
+		};
+	}
+	for (const node of result.nodes) if (laidOutNodes.get(node.id)?.data?.layout?.status === "complete" && node.data?.layout?.status !== "complete") {
+		regions.add(node.id);
+		node.data = {
+			...node.data,
+			layout: {
+				...node.data?.layout,
+				status: "complete"
+			}
+		};
+	}
+	if (regions.size === 0) return result;
+	const parentOf = new Map(result.nodes.map((node) => [node.id, node.parentId ?? null]));
+	const inRegion = (nodeId) => typeof nodeId === "string" && parentOf.has(nodeId) && regions.has(parentOf.get(nodeId));
+	const copyPosition = (target, source) => {
+		if (!source) return;
+		for (const field of [
+			"position",
+			"x",
+			"y"
+		]) if (source[field] !== void 0) target[field] = clone(source[field]);
+	};
+	for (const node of result.nodes) if (inRegion(node.id)) copyPosition(node, laidOutNodes.get(node.id));
+	const laidOutEdges = new Map(laidOut.edges.map((edge) => [edge.id, edge]));
+	for (const edge of result.edges) if (inRegion(edge.sourceId) || inRegion(edge.targetId)) copyPosition(edge, laidOutEdges.get(edge.id));
+	if (Array.isArray(result.annotations) && Array.isArray(laidOut.annotations)) {
+		const laidOutAnnotations = new Map(laidOut.annotations.map((item) => [item.id, item]));
+		for (const annotation of result.annotations) if (regions.has(annotation.parentId ?? null)) copyPosition(annotation, laidOutAnnotations.get(annotation.id));
+	}
+	return result;
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.5.0_zod@4.4.3/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs
@@ -19669,7 +20041,7 @@ const editorSyncApplyResponseSchema = z$1.object({ replacements: z$1.array(edito
 const editorSyncAccessResponseSchema = z$1.object({ access: editorSyncAccessSchema });
 
 //#endregion
-//#region ../editor-sync/dist/host-BX7mLyHj.mjs
+//#region ../editor-sync/dist/host-DCVLN7MS.mjs
 let diagnosticSequence = 0;
 function presentationsEqual(first, second) {
 	return JSON.stringify(createPresentationSnapshot(first)) === JSON.stringify(createPresentationSnapshot(second));
@@ -19846,6 +20218,7 @@ var EditorHostSession = class {
 				this.currentGraph = message.graph;
 				if (message.source === "external") this.lastPersistedGraph = message.sourceBaselineGraph ?? message.graph;
 				this.currentSourceLocations = mergeSourceLocations(this.currentSourceLocations, message.sourceLocations);
+				if (message.source === "layout") await this.persistAutomaticLayout(message.graph, message.serialized);
 				break;
 			case "@statelyai.save":
 				try {
@@ -20076,6 +20449,27 @@ var EditorHostSession = class {
 			return graph;
 		}
 	}
+	/**
+	* Store automatic layout positions as presentation metadata so the next
+	* session skips automatic layout. Unsaved colors, notes or moves are never
+	* committed this way: such a graph waits for the user's save. Source files are never written, and a graph with unsaved structural edits
+	* waits for the user's save instead.
+	*/
+	async persistAutomaticLayout(graph, serialized) {
+		const persisted = this.lastPersistedGraph;
+		if (!this.options.presentation || this.access?.readOnly || persisted === void 0) return;
+		try {
+			const change = graphChangeToPatchesResult(persisted, graph);
+			if (change.unsupportedChanges.length > 0 || change.patches.some(isStructuralPatch)) return;
+		} catch {
+			return;
+		}
+		if (!presentationsEqual(mergeAutomaticLayout(persisted, graph), graph)) return;
+		try {
+			await this.options.presentation.persist(graph, { serialized: serialized?.digraph !== void 0 ? serialized : await this.getSerializedPayload(serialized) });
+			this.lastPersistedGraph = graph;
+		} catch {}
+	}
 	async persistPresentation(graph, serialized) {
 		if (!this.options.presentation) return;
 		try {
@@ -20636,7 +21030,7 @@ function sourceLocationUris(sourceLocations) {
 
 //#endregion
 //#region src/version.ts
-const CLI_VERSION = "0.12.7";
+const CLI_VERSION = "0.13.0";
 
 //#endregion
 //#region src/cliHost.ts
@@ -21737,7 +22131,7 @@ function getScriptKind$1(fileName) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@statelyai+graph@2.1.0_@statelyai+layout@0.4.2_cytoscape@3.34.0_d3-force@3.0.0_d3-hiera_48d6687797f6ba8a844c48e50eec3ae1/node_modules/@statelyai/graph/dist/index.mjs
+//#region ../../node_modules/.pnpm/@statelyai+graph@2.1.0_@statelyai+layout@0.4.3_cytoscape@3.34.0_d3-force@3.0.0_d3-hiera_2afdfa88fae2fa10712f99651d0f58d6/node_modules/@statelyai/graph/dist/index.mjs
 const LAYOUT_KEYS = {
 	node: [
 		"x",
@@ -24118,7 +24512,10 @@ const COMMANDS = {
 	init: InitCommand,
 	login: LoginCommand,
 	logout: LogoutCommand,
-	whoami: WhoamiCommand
+	whoami: WhoamiCommand,
+	changes: ChangesCommand,
+	brief: BriefCommand,
+	pending: PendingCommand
 };
 async function run$1(argv = process.argv.slice(2), entryUrl = import.meta.url) {
 	const normalizedArgv = argv.length === 1 && argv[0] === "-h" ? ["--help"] : argv;
@@ -24142,4 +24539,4 @@ function isDirectExecution() {
 if (isDirectExecution()) run$1();
 
 //#endregion
-export { run$1 as C, verifyProject as D, resolveVerificationRequest as E, formatVerificationJUnit as O, resolveProjectStatus as S, scanProjectSources as T, isFileGitDirty as _, discoverMachinesInSource as a, resolveCredentialStatus as b, formatDiscoveredMachines as c, formatProjectStatus as d, formatStoredCredentialSource as f, initProject as g, inferInitProjectName as h, discoverLinkedPullTargets as i, createStatelyProjectConfig as k, formatMissingNewMachineDirMessage as l, getEnvCredential as m, buildOAuthLoginStart as n, discoverOAuthLogin as o, getEnvApiKey as p, classifyPushCandidates as r, discoverRemoteProjectMachineTargets as s, COMMANDS as t, formatPlanSummary as u, resolveApiKey as v, scanProjectMachines as w, resolveOpenRootDir as x, resolveConfiguredPullTargets as y };
+export { briefReport as A, run$1 as C, verifyProject as D, resolveVerificationRequest as E, pendingReport as M, readGraphFile as N, formatVerificationJUnit as O, verifyReport as P, resolveProjectStatus as S, scanProjectSources as T, isFileGitDirty as _, discoverMachinesInSource as a, resolveCredentialStatus as b, formatDiscoveredMachines as c, formatProjectStatus as d, formatStoredCredentialSource as f, initProject as g, inferInitProjectName as h, discoverLinkedPullTargets as i, changesReport as j, createStatelyProjectConfig as k, formatMissingNewMachineDirMessage as l, getEnvCredential as m, buildOAuthLoginStart as n, discoverOAuthLogin as o, getEnvApiKey as p, classifyPushCandidates as r, discoverRemoteProjectMachineTargets as s, COMMANDS as t, formatPlanSummary as u, resolveApiKey as v, scanProjectMachines as w, resolveOpenRootDir as x, resolveConfiguredPullTargets as y };