@statelyai/sdk 0.17.0 → 0.20.0

package/README.md

@@ -37,6 +37,10 @@ embed.init({
   format: 'xstate',
   mode: 'editing',
   theme: 'dark',
+  documents: [
+    { path: 'README.md', content: '# How this workflow works' },
+    { path: 'src/machine.ts', content: machineSource },
+  ],
 });
 ```
 
@@ -70,12 +74,24 @@ embed.on('capabilityDenied', (event) => {
 Use `access-unverified` when reopening or signing in, rather than upgrading, is
 the appropriate recovery action.
 
+### Editor hosts
+
+<!-- shared editor host session and protocol from src/editorHostSession.ts and src/editorHostProtocol.ts -->
+
+CLI and editor-extension hosts use `EditorHostSession` from
+`@statelyai/sdk/editor-host` for initialization, saves, source refreshes,
+clipboard requests, and editor protocol negotiation. Use
+`createRemoteEditorSyncBackend` for two-way validation of the versioned Editor
+Sync HTTP contract.
+Hosts keep ownership of files, credentials, UI, and transport adapters.
+
 Key capabilities:
 
 - **Mount or attach** to any container element or existing iframe
 - **Two-way sync** - push machine configs in, get changes and saves back via event callbacks
 - **Export** to multiple formats: XState v5, XState JSON, Mermaid, Redux, Zustand, ASL, SCXML, and more
 - **Access policies** for read-only, no-export, no-AI, shallow-viewer embeds
+- **Reference documents** supplied as ordered, read-only Markdown, code, or text
 - **Comments** via Liveblocks integration (optional)
 - **Asset uploads** with built-in S3 and Supabase adapters, or bring your own upload handler
 - **Runtime settings** - toggle color mode, grid, snap lines, autolayout, and view mode on the fly
@@ -181,13 +197,33 @@ const inspector = createInspector({
 });
 ```
 
+For persisted actors, `resolveSessionId` can keep one producer-local identity
+across sequential restore/resume incarnations. Generate a new id for a new
+logical invocation, persist it beside the actor snapshot, and reuse it only
+after the previous incarnation has stopped. Create a new inspector for the
+restored actor system, reusing the same room and producer identities:
+
+```ts
+const inspector = createInspector({
+  roomId: persistedInspectionRoomId,
+  producerId: persistedInspectionProducerId,
+  resolveSessionId: (actor, defaultSessionId) =>
+    actor.logic === machine ? persistedInspectionId : defaultSessionId,
+});
+```
+
+A resume must reuse the same room id, producer id, and resolved session id. Keep
+the room id private because it is the room's bearer capability. A new logical
+invocation keeps the producer id but receives a new resolved session id.
+
 Stopped actors remain in `inspector.actors` and in reconnect checkpoints, so
 completed request-scoped runs stay available for inspection.
 
 XState v5 and v6 inspection events normalize to independent actor, event,
 snapshot, and stop observations before crossing the WebSocket protocol.
-`actorId` is system-local and `sessionId` is process-local. A room uses
-`producerId + sessionId` as the global actor identity.
+`actorId` is system-local. `sessionId` defaults to XState's runtime value and
+may be producer-resolved. A room uses `producerId + sessionId` as the global
+actor identity.
 Observations captured before the first transport registration replay in order
 after the initial actor-tree baseline. Reconnects use the latest checkpoint.
 In Node, the inspector opens in the default browser automatically. The SDK

package/dist/auth.d.mts

@@ -1,2 +1,2 @@
-import { i as getCredentialToken, n as StatelyCredential, r as createAuthorizationHeader, t as StatelyAuthMode } from "./auth-2Thaw42j.mjs";
+import { i as getCredentialToken, n as StatelyCredential, r as createAuthorizationHeader, t as StatelyAuthMode } from "./auth-B0ZTKri2.mjs";
 export { StatelyAuthMode, StatelyCredential, createAuthorizationHeader, getCredentialToken };

package/dist/editor-sync-types-D8_EZm0A.d.mts

@@ -0,0 +1,94 @@
+//#region ../api-contract/dist/editor-sync-types.d.mts
+//#region src/editor-sync-types.d.ts
+interface EditorCapabilities {
+  edit?: boolean;
+  export?: boolean;
+  ai?: boolean;
+  simulate?: boolean;
+  inspect?: boolean;
+  navigateHierarchy?: boolean;
+  maxDepth?: number;
+  panels?: string[];
+  commands?: string[];
+}
+interface EditorSyncAccess {
+  level: 'full' | 'restricted';
+  readOnly: boolean;
+  readOnlyReason?: 'free-plan' | 'access-unverified';
+  capabilities: EditorCapabilities;
+}
+interface EditorSyncSourceRange {
+  startLine: number;
+  startChar: number;
+  endLine: number;
+  endChar: number;
+}
+interface EditorSyncSourceLocation {
+  uri: string;
+  range: EditorSyncSourceRange;
+}
+interface EditorSyncStateSourceLocation extends EditorSyncSourceLocation {
+  path: string[];
+  kind: 'inline' | 'objectReference' | 'createStateConfig';
+  symbol?: string;
+  keyRange?: EditorSyncSourceRange;
+  referenceRange?: EditorSyncSourceRange;
+  keySource?: {
+    kind: 'const' | 'enumMember' | 'computedLiteral';
+    symbol?: string;
+    valueRange?: EditorSyncSourceRange;
+    machineLocal?: boolean;
+  };
+  keyReplacementText?: string;
+}
+interface MachineSourceLocations {
+  version: 1;
+  profile?: 'xstate-v5' | 'xstate-v6-alpha';
+  root?: EditorSyncSourceLocation;
+  statesObject?: EditorSyncStateSourceLocation;
+  states: EditorSyncStateSourceLocation[];
+  staticValues?: Array<EditorSyncSourceLocation & {
+    value: string;
+  }>;
+  transitionFunctions?: Array<EditorSyncSourceLocation & {
+    symbol: string;
+    sourcePaths: string[][];
+  }>;
+}
+interface EditorSyncSourceDocument {
+  uri: string;
+  fileName: string;
+  text: string;
+}
+interface EditorSyncDocumentContext {
+  rootUri: string;
+  rootFileName: string;
+  rootDir: string;
+  documents: EditorSyncSourceDocument[];
+}
+type EditorSyncParseRequest = EditorSyncDocumentContext;
+interface EditorSyncParseResponse {
+  machine: unknown;
+  format: string;
+  sourceLocations?: MachineSourceLocations;
+  access?: EditorSyncAccess;
+}
+interface EditorSyncApplyRequest extends EditorSyncDocumentContext {
+  machineConfig?: unknown;
+  patches?: unknown[];
+  prevGraph?: unknown;
+  nextGraph?: unknown;
+  sourceLocations?: MachineSourceLocations;
+  serialized?: Record<string, string>;
+  preserveStatelyMetadata?: boolean;
+}
+interface EditorSyncTextReplacement {
+  uri?: string;
+  range: EditorSyncSourceRange;
+  newText: string;
+}
+interface EditorSyncApplyResponse {
+  replacements: EditorSyncTextReplacement[];
+} //#endregion
+//#endregion
+export { EditorSyncParseRequest as a, EditorSyncSourceLocation as c, EditorSyncTextReplacement as d, MachineSourceLocations as f, EditorSyncApplyResponse as i, EditorSyncSourceRange as l, EditorSyncAccess as n, EditorSyncParseResponse as o, EditorSyncApplyRequest as r, EditorSyncSourceDocument as s, EditorCapabilities as t, EditorSyncStateSourceLocation as u };

package/dist/editorHostProtocol-D_h4y3rX.mjs

@@ -0,0 +1,5 @@
+//#region src/editorHostProtocol.ts
+const EDITOR_PROTOCOL_VERSION = 1;
+
+//#endregion
+export { EDITOR_PROTOCOL_VERSION as t };

package/dist/editorHostSession-CZHd22pZ.mjs

@@ -0,0 +1,478 @@
+import { t as EDITOR_PROTOCOL_VERSION } from "./editorHostProtocol-D_h4y3rX.mjs";
+import { a as literal, c as record, d as unknown, l as string, n as array, o as number, r as boolean, s as object, t as _enum } from "./schemas-C2raUv-n.mjs";
+
+//#region ../api-contract/dist/editor-sync.mjs
+const EDITOR_SYNC_PROTOCOL_VERSION = 1;
+const EDITOR_SYNC_PROTOCOL_HEADER = "X-Stately-Editor-Sync-Version";
+const editorCapabilitiesSchema = object({
+	edit: boolean().optional(),
+	export: boolean().optional(),
+	ai: boolean().optional(),
+	simulate: boolean().optional(),
+	inspect: boolean().optional(),
+	navigateHierarchy: boolean().optional(),
+	maxDepth: number().optional(),
+	panels: array(string()).optional(),
+	commands: array(string()).optional()
+}).passthrough();
+const editorSyncAccessSchema = object({
+	level: _enum(["full", "restricted"]),
+	readOnly: boolean(),
+	readOnlyReason: _enum(["free-plan", "access-unverified"]).optional(),
+	capabilities: editorCapabilitiesSchema
+}).passthrough();
+const editorSyncSourceRangeSchema = object({
+	startLine: number(),
+	startChar: number(),
+	endLine: number(),
+	endChar: number()
+});
+const editorSyncSourceLocationSchema = object({
+	uri: string(),
+	range: editorSyncSourceRangeSchema
+});
+const editorSyncStateSourceLocationSchema = editorSyncSourceLocationSchema.extend({
+	path: array(string()),
+	kind: _enum([
+		"inline",
+		"objectReference",
+		"createStateConfig"
+	]),
+	symbol: string().optional(),
+	keyRange: editorSyncSourceRangeSchema.optional(),
+	referenceRange: editorSyncSourceRangeSchema.optional(),
+	keySource: object({
+		kind: _enum([
+			"const",
+			"enumMember",
+			"computedLiteral"
+		]),
+		symbol: string().optional(),
+		valueRange: editorSyncSourceRangeSchema.optional(),
+		machineLocal: boolean().optional()
+	}).optional(),
+	keyReplacementText: string().optional()
+});
+const machineSourceLocationsSchema = object({
+	version: literal(1),
+	profile: _enum(["xstate-v5", "xstate-v6-alpha"]).optional(),
+	root: editorSyncSourceLocationSchema.optional(),
+	statesObject: editorSyncStateSourceLocationSchema.optional(),
+	states: array(editorSyncStateSourceLocationSchema),
+	staticValues: array(editorSyncSourceLocationSchema.extend({ value: string() })).optional(),
+	transitionFunctions: array(editorSyncSourceLocationSchema.extend({
+		symbol: string(),
+		sourcePaths: array(array(string()))
+	})).optional()
+}).passthrough();
+const editorSyncSourceDocumentSchema = object({
+	uri: string(),
+	fileName: string(),
+	text: string()
+});
+const editorSyncDocumentContextSchema = object({
+	rootUri: string(),
+	rootFileName: string(),
+	rootDir: string(),
+	documents: array(editorSyncSourceDocumentSchema)
+});
+const editorSyncParseResponseSchema = object({
+	machine: unknown(),
+	format: string(),
+	sourceLocations: machineSourceLocationsSchema.optional(),
+	access: editorSyncAccessSchema.optional()
+}).passthrough();
+const editorSyncApplyRequestSchema = editorSyncDocumentContextSchema.extend({
+	machineConfig: unknown().optional(),
+	patches: array(unknown()).optional(),
+	prevGraph: unknown().optional(),
+	nextGraph: unknown().optional(),
+	sourceLocations: machineSourceLocationsSchema.optional(),
+	serialized: record(string(), string()).optional(),
+	preserveStatelyMetadata: boolean().optional()
+}).passthrough();
+const editorSyncTextReplacementSchema = object({
+	uri: string().optional(),
+	range: editorSyncSourceRangeSchema,
+	newText: string()
+});
+const editorSyncApplyResponseSchema = object({ replacements: array(editorSyncTextReplacementSchema) });
+const editorSyncAccessResponseSchema = object({ access: editorSyncAccessSchema });
+
+//#endregion
+//#region src/editorHostSession.ts
+function createRemoteEditorSyncBackend(options) {
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	async function post(pathname, body) {
+		const url = new URL(pathname, `${options.editorUrl.replace(/\/+$/, "")}/`);
+		const headers = {
+			"Content-Type": "application/json",
+			[EDITOR_SYNC_PROTOCOL_HEADER]: String(EDITOR_SYNC_PROTOCOL_VERSION)
+		};
+		if (options.apiKey) headers.Authorization = `Bearer ${options.apiKey}`;
+		const response = await fetchImpl(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body)
+		});
+		assertEditorSyncResponseProtocol(response);
+		const data = await response.json().catch(() => null);
+		if (!response.ok) {
+			const message = data && typeof data === "object" && "error" in data && typeof data.error === "string" ? data.error : `HTTP ${response.status}`;
+			throw new Error(message);
+		}
+		return data;
+	}
+	return {
+		async parse(request) {
+			return editorSyncParseResponseSchema.parse(await post("/api/editor-sync/parse", request));
+		},
+		async apply(request) {
+			return editorSyncApplyResponseSchema.parse(await post("/api/editor-sync/apply", request));
+		}
+	};
+}
+async function fetchEditorSyncAccess(options) {
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	const url = new URL("/api/editor-sync/access", `${options.editorUrl.replace(/\/+$/, "")}/`);
+	const headers = { [EDITOR_SYNC_PROTOCOL_HEADER]: String(EDITOR_SYNC_PROTOCOL_VERSION) };
+	if (options.apiKey) headers.Authorization = `Bearer ${options.apiKey}`;
+	const response = await fetchImpl(url, {
+		method: "GET",
+		headers
+	});
+	assertEditorSyncResponseProtocol(response);
+	const data = await response.json().catch(() => null);
+	if (!response.ok) {
+		const message = data && typeof data === "object" && "error" in data && typeof data.error === "string" ? data.error : `HTTP ${response.status}`;
+		throw new Error(message);
+	}
+	return editorSyncAccessResponseSchema.parse(data).access;
+}
+function assertEditorSyncResponseProtocol(response) {
+	const selectedVersion = response.headers.get(EDITOR_SYNC_PROTOCOL_HEADER);
+	if (selectedVersion === null || selectedVersion === String(EDITOR_SYNC_PROTOCOL_VERSION)) return;
+	throw new Error(`Editor Sync protocol ${selectedVersion} is unsupported; this client supports ${EDITOR_SYNC_PROTOCOL_VERSION}.`);
+}
+var EditorHostSession = class {
+	editorProtocolState = "awaiting";
+	currentGraph;
+	lastPersistedGraph;
+	currentFormat;
+	currentSourceLocations;
+	access;
+	watchedSourceUris = /* @__PURE__ */ new Set();
+	selfEditCount = 0;
+	watcher;
+	retrieveRequestCount = 0;
+	pendingRetrievals = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.watcher = options.source.watchSavedDocuments?.((uri) => this.handleSavedDocument(uri));
+	}
+	dispose() {
+		this.watcher?.dispose();
+		for (const pending of this.pendingRetrievals.values()) pending.reject(/* @__PURE__ */ new Error("Editor session disposed before export completed."));
+		this.pendingRetrievals.clear();
+	}
+	notifySavedDocument(uri = this.options.source.rootUri) {
+		return this.handleSavedDocument(uri);
+	}
+	async receive(message) {
+		if (message.type !== "@statelyai.ready" && this.editorProtocolState !== "compatible") return;
+		switch (message.type) {
+			case "@statelyai.ready":
+				if (this.editorProtocolState === "incompatible") break;
+				if (message.protocolVersion !== void 0 && message.protocolVersion !== EDITOR_PROTOCOL_VERSION) {
+					this.editorProtocolState = "incompatible";
+					this.options.send({
+						type: "@statelyai.error",
+						code: "unsupported_protocol",
+						message: `Editor protocol ${message.protocolVersion} is unsupported; this client supports ${EDITOR_PROTOCOL_VERSION}.`
+					});
+					break;
+				}
+				this.editorProtocolState = "compatible";
+				try {
+					if (message.protocolVersion !== void 0) this.options.send({
+						type: "@statelyai.handshake",
+						protocolVersion: EDITOR_PROTOCOL_VERSION,
+						client: this.options.client
+					});
+					await this.initialize();
+				} catch (error) {
+					const message = formatError(error, "Failed to initialize the visual editor.");
+					this.options.send({
+						type: "@statelyai.error",
+						code: "initialization_failed",
+						message
+					});
+					this.options.showError?.(message);
+				}
+				break;
+			case "@statelyai.loaded":
+				this.currentGraph = message.graph;
+				this.lastPersistedGraph = message.graph;
+				this.currentSourceLocations = mergeSourceLocations(this.currentSourceLocations, message.sourceLocations);
+				break;
+			case "@statelyai.change":
+				this.currentGraph = message.graph;
+				this.currentSourceLocations = mergeSourceLocations(this.currentSourceLocations, message.sourceLocations);
+				break;
+			case "@statelyai.save":
+				try {
+					await this.save(message);
+				} catch (error) {
+					const text = formatError(error, "Failed to apply Viz changes.");
+					this.options.send({
+						type: "@statelyai.toast",
+						message: text,
+						toastType: "error"
+					});
+					this.options.showError?.(text);
+				}
+				break;
+			case "@statelyai.retrieved":
+				this.resolveRetrieved(message.requestId, message.data);
+				break;
+			case "@statelyai.error":
+				if (message.requestId) {
+					const pending = this.pendingRetrievals.get(message.requestId);
+					if (pending) {
+						this.pendingRetrievals.delete(message.requestId);
+						pending.reject(new Error(message.message));
+						break;
+					}
+				}
+				this.options.showError?.(message.message);
+				break;
+			case "@statelyai.clipboardRead": {
+				let text = "";
+				try {
+					text = await this.options.readClipboard?.() ?? "";
+				} catch {}
+				this.options.send({
+					type: "@statelyai.clipboardReadResponse",
+					requestId: message.requestId,
+					text
+				});
+				break;
+			}
+			case "@statelyai.clipboardWrite": {
+				let ok = false;
+				try {
+					await this.options.writeClipboard?.(message.text);
+					ok = Boolean(this.options.writeClipboard);
+				} catch {}
+				this.options.send({
+					type: "@statelyai.clipboardWriteResponse",
+					requestId: message.requestId,
+					ok
+				});
+				break;
+			}
+		}
+	}
+	async initialize() {
+		const documents = await this.options.source.collectDocuments();
+		const update = await this.options.sync.parse({
+			rootUri: this.options.source.rootUri,
+			rootFileName: this.options.source.rootFileName,
+			rootDir: this.options.source.rootDir,
+			documents
+		});
+		this.currentFormat = update.format;
+		this.currentSourceLocations = update.sourceLocations;
+		this.access = update.access ?? this.options.access;
+		this.updateWatchedSourceUris(update.sourceLocations);
+		if (this.options.apiKey) this.options.send({
+			type: "@statelyai.setApiKey",
+			apiKey: this.options.apiKey
+		});
+		this.options.send({
+			type: "@statelyai.init",
+			machine: update.machine,
+			format: update.format,
+			sourceLocations: update.sourceLocations,
+			mode: this.access?.readOnly ? "viewing" : "editing",
+			readOnly: this.access?.readOnly,
+			readOnlyReason: this.access?.readOnlyReason,
+			capabilities: this.access?.capabilities,
+			theme: this.options.getTheme?.() ?? "light",
+			unsavedIndicator: this.options.init?.unsavedIndicator ?? { enabled: true },
+			settings: this.options.init?.settings,
+			leftPanels: this.options.init?.leftPanels ?? [],
+			rightPanels: this.options.init?.rightPanels ?? [],
+			activePanels: this.options.init?.activePanels ?? []
+		});
+	}
+	async save(message) {
+		this.currentSourceLocations = mergeSourceLocations(this.currentSourceLocations, message.sourceLocations);
+		this.updateWatchedSourceUris(this.currentSourceLocations);
+		if (this.access?.readOnly) {
+			const text = "Your Stately plan allows read-only editor sync.";
+			this.options.send({
+				type: "@statelyai.toast",
+				message: text,
+				toastType: "error"
+			});
+			this.options.showError?.(text);
+			return;
+		}
+		const validationErrors = (message.validations ?? []).filter((validation) => validation.level === "error");
+		if (validationErrors.length > 0) {
+			const text = formatValidationErrorMessage(validationErrors);
+			this.options.send({
+				type: "@statelyai.toast",
+				message: text,
+				toastType: "error"
+			});
+			this.options.showError?.(text);
+			return;
+		}
+		const previousGraph = this.lastPersistedGraph ?? this.currentGraph;
+		if (!message.patches?.length && graphsEqual(previousGraph, message.graph)) {
+			this.currentGraph = message.graph;
+			this.lastPersistedGraph = message.graph;
+			this.options.send({
+				type: "@statelyai.saved",
+				graph: message.graph
+			});
+			return;
+		}
+		const documents = await this.options.source.collectDocuments(sourceLocationUris(this.currentSourceLocations));
+		const serialized = await this.getSerializedPayload();
+		const response = await this.options.sync.apply({
+			rootUri: this.options.source.rootUri,
+			rootFileName: this.options.source.rootFileName,
+			rootDir: this.options.source.rootDir,
+			documents,
+			machineConfig: message.machineConfig,
+			patches: message.patches,
+			prevGraph: previousGraph,
+			nextGraph: message.graph,
+			sourceLocations: this.currentSourceLocations,
+			serialized,
+			preserveStatelyMetadata: this.options.source.getPreserveStatelyMetadata?.(this.options.source.rootUri) ?? true
+		});
+		if (response.replacements.length === 0) {
+			const text = "Unable to apply Viz changes to the source file automatically.";
+			this.options.send({
+				type: "@statelyai.toast",
+				message: text,
+				toastType: "error"
+			});
+			this.options.showError?.(text);
+			return;
+		}
+		this.selfEditCount++;
+		try {
+			const touchedUris = await this.options.source.applyReplacements(response.replacements, this.options.source.rootUri);
+			await this.options.source.saveDocuments?.(touchedUris);
+		} finally {
+			this.selfEditCount--;
+		}
+		this.currentGraph = message.graph;
+		this.lastPersistedGraph = message.graph;
+		this.options.send({
+			type: "@statelyai.saved",
+			graph: message.graph
+		});
+	}
+	async handleSavedDocument(uri) {
+		if (this.editorProtocolState !== "compatible") return;
+		if (uri !== this.options.source.rootUri && !this.watchedSourceUris.has(uri) || this.selfEditCount > 0) return;
+		try {
+			const documents = await this.options.source.collectDocuments(sourceLocationUris(this.currentSourceLocations));
+			const update = await this.options.sync.parse({
+				rootUri: this.options.source.rootUri,
+				rootFileName: this.options.source.rootFileName,
+				rootDir: this.options.source.rootDir,
+				documents
+			});
+			this.currentFormat = update.format;
+			this.currentSourceLocations = update.sourceLocations;
+			this.access = update.access ?? this.access;
+			this.updateWatchedSourceUris(update.sourceLocations);
+			this.options.send({
+				type: "@statelyai.update",
+				machine: update.machine,
+				format: update.format,
+				sourceLocations: update.sourceLocations
+			});
+		} catch (error) {
+			this.options.showError?.(formatError(error, "Failed to read the saved document."));
+		}
+	}
+	updateWatchedSourceUris(sourceLocations) {
+		this.watchedSourceUris.clear();
+		for (const uri of stateSourceLocationUris(sourceLocations)) if (uri !== this.options.source.rootUri) this.watchedSourceUris.add(uri);
+	}
+	async getSerializedPayload() {
+		const format = this.currentFormat;
+		if (!format || format === "xstate") return void 0;
+		try {
+			return { [format]: await this.requestSerialized(format) };
+		} catch {
+			return;
+		}
+	}
+	requestSerialized(format) {
+		const requestId = `retrieve-${++this.retrieveRequestCount}`;
+		return new Promise((resolve, reject) => {
+			this.pendingRetrievals.set(requestId, {
+				resolve,
+				reject
+			});
+			this.options.send({
+				type: "@statelyai.retrieve",
+				requestId,
+				format
+			});
+		});
+	}
+	resolveRetrieved(requestId, data) {
+		const pending = this.pendingRetrievals.get(requestId);
+		if (!pending) return;
+		this.pendingRetrievals.delete(requestId);
+		pending.resolve(typeof data === "string" ? data : JSON.stringify(data, null, 2));
+	}
+};
+function graphsEqual(left, right) {
+	if (left === void 0 || right === void 0) return false;
+	try {
+		return JSON.stringify(left) === JSON.stringify(right);
+	} catch {
+		return false;
+	}
+}
+function mergeSourceLocations(previous, next) {
+	if (!next) return previous;
+	if (!next.profile && previous?.profile) return {
+		...next,
+		profile: previous.profile
+	};
+	return next;
+}
+function formatError(error, fallback) {
+	return error instanceof Error ? error.message : fallback;
+}
+function formatValidationErrorMessage(errors) {
+	const first = errors[0];
+	if (errors.length === 1 && first) return `Cannot save Viz changes: ${first.message}`;
+	return `Cannot save Viz changes: ${errors.length} validation errors. First: ${first?.message ?? "Unknown validation error"}`;
+}
+function sourceLocationUris(sourceLocations) {
+	return [...new Set([
+		sourceLocations?.root?.uri,
+		...(sourceLocations?.states ?? []).map((location) => location.uri),
+		...(sourceLocations?.staticValues ?? []).map((location) => location.uri),
+		...(sourceLocations?.transitionFunctions ?? []).map((location) => location.uri)
+	].filter((uri) => Boolean(uri)))];
+}
+function stateSourceLocationUris(sourceLocations) {
+	return [...new Set((sourceLocations?.states ?? []).map((location) => location.uri).filter(Boolean))];
+}
+
+//#endregion
+export { createRemoteEditorSyncBackend as n, fetchEditorSyncAccess as r, EditorHostSession as t };