@statelyai/sdk 0.34.2 → 0.36.0

package/dist/editorHostSession-DCTHhBqC.mjs

@@ -1,912 +0,0 @@
-import { c as object, f as unknown, i as custom, l as record, n as array, o as literal, r as boolean, s as number, t as _enum, u as string } from "./openapi-BTDjYWXd.mjs";
-import { t as EDITOR_PROTOCOL_VERSION } from "./editorHostProtocol-B2_t3Le7.mjs";
-import { p as graphChangeToPatchesResult } from "./dist-DsOTTfYv.mjs";
-import * as ts$1 from "typescript";
-
-//#region ../api-contract/dist/editor-sync.mjs
-const EDITOR_SYNC_PROTOCOL_VERSION = 1;
-const EDITOR_SYNC_PROTOCOL_HEADER = "X-Stately-Editor-Sync-Version";
-const editorSyncErrorResponseSchema = object({
-	error: string(),
-	code: string().optional()
-}).passthrough();
-const editorCapabilitiesSchema = object({
-	edit: boolean().optional(),
-	export: boolean().optional(),
-	ai: boolean().optional(),
-	simulate: boolean().optional(),
-	inspect: 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(),
-	profileRef: custom((value) => typeof value === "string" && value.startsWith("@statelyai/xstate@")).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 editorSyncParseRequestSchema = editorSyncDocumentContextSchema.extend({ machineIndex: number().int().nonnegative().optional() });
-const editorSyncParseResponseSchema = object({
-	machine: unknown(),
-	format: string(),
-	sourceLocations: machineSourceLocationsSchema.optional(),
-	access: editorSyncAccessSchema.optional()
-}).passthrough();
-const editorSyncApplyRequestSchema = editorSyncParseRequestSchema.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(),
-	sourceUpdateStrategy: _enum(["preserve", "rewrite"]).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
-let diagnosticSequence = 0;
-function createDiagnostic(code, phase, details) {
-	return {
-		id: `stately-${Date.now().toString(36)}-${(++diagnosticSequence).toString(36)}`,
-		code,
-		phase,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		...details ? { details } : {}
-	};
-}
-var EditorSyncError = class extends Error {
-	status;
-	code;
-	constructor(message, status, code) {
-		super(message);
-		this.name = "EditorSyncError";
-		this.status = status;
-		this.code = code;
-	}
-};
-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) throwEditorSyncError(response.status, data);
-		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) throwEditorSyncError(response.status, data);
-	return editorSyncAccessResponseSchema.parse(data).access;
-}
-function throwEditorSyncError(status, data) {
-	const parsed = editorSyncErrorResponseSchema.safeParse(data);
-	const error = parsed.success ? parsed.data : void 0;
-	throw new EditorSyncError(error?.error ?? `HTTP ${status}`, status, error?.code);
-}
-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}.`);
-}
-const SOURCE_SAVE_REMINDER_ID = "source-save-reminder";
-var EditorHostSession = class {
-	editorProtocolState = "awaiting";
-	currentGraph;
-	lastPersistedGraph;
-	currentFormat;
-	currentSourceLocations;
-	access;
-	watchedSourceUris = /* @__PURE__ */ new Set();
-	watcher;
-	changeWatcher;
-	retrieveRequestCount = 0;
-	pendingRetrievals = /* @__PURE__ */ new Map();
-	constructor(options, saveReminderState = { shown: false }, selfEditState = { count: 0 }) {
-		this.options = options;
-		this.saveReminderState = saveReminderState;
-		this.selfEditState = selfEditState;
-		this.watcher = options.source.watchSavedDocuments?.((uri) => this.handleSavedDocument(uri));
-		this.changeWatcher = options.source.watchChangedDocuments?.((uri) => {
-			if (!this.isExternalSourceDocument(uri)) return;
-			if (this.saveReminderState.shown) return;
-			this.saveReminderState.shown = true;
-			this.options.send({
-				type: "@statelyai.toast",
-				id: SOURCE_SAVE_REMINDER_ID,
-				message: "Save code to see changes.",
-				toastType: "warning"
-			});
-		});
-	}
-	dispose() {
-		this.watcher?.dispose();
-		this.changeWatcher?.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.reportSourceSyncError(text, "save", {
-						errorName: error instanceof Error ? error.name : void 0,
-						sourceUpdateStrategy: message.sourceUpdateStrategy ?? this.options.sourceUpdateStrategy ?? "preserve",
-						canRewrite: (message.sourceUpdateStrategy ?? this.options.sourceUpdateStrategy ?? "preserve") === "preserve"
-					}, message.requestId);
-				}
-				break;
-			case "@statelyai.refresh":
-				await this.handleSavedDocument(this.options.source.rootUri);
-				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.diagnostic ? `${message.message} (diagnostic ${message.diagnostic.id})` : 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,
-			...this.options.source.machineIndex !== void 0 ? { machineIndex: this.options.source.machineIndex } : {},
-			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,
-			panels: this.options.init?.panels,
-			...this.options.init?.panels === void 0 && {
-				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;
-		let patches = message.patches;
-		if (!patches?.length && previousGraph !== void 0) try {
-			const semanticChange = graphChangeToPatchesResult(previousGraph, message.graph);
-			if (semanticChange.patches.length === 0 && semanticChange.unsupportedChanges.length === 0) {
-				this.currentGraph = message.graph;
-				this.lastPersistedGraph = message.graph;
-				this.options.send({
-					type: "@statelyai.saved",
-					...message.requestId ? { requestId: message.requestId } : {},
-					graph: message.graph
-				});
-				return;
-			}
-			patches = semanticChange.patches;
-		} catch {}
-		if (!patches?.length && graphsEqual(previousGraph, message.graph)) {
-			this.currentGraph = message.graph;
-			this.lastPersistedGraph = message.graph;
-			this.options.send({
-				type: "@statelyai.saved",
-				...message.requestId ? { requestId: message.requestId } : {},
-				graph: message.graph
-			});
-			return;
-		}
-		const documents = await this.options.source.collectDocuments(sourceLocationUris(this.currentSourceLocations));
-		const serialized = await this.getSerializedPayload();
-		const sourceUpdateStrategy = message.sourceUpdateStrategy ?? this.options.sourceUpdateStrategy ?? "preserve";
-		const response = await this.options.sync.apply({
-			rootUri: this.options.source.rootUri,
-			rootFileName: this.options.source.rootFileName,
-			rootDir: this.options.source.rootDir,
-			...this.options.source.machineIndex !== void 0 ? { machineIndex: this.options.source.machineIndex } : {},
-			documents,
-			machineConfig: message.machineConfig,
-			patches,
-			prevGraph: previousGraph,
-			nextGraph: message.graph,
-			sourceLocations: this.currentSourceLocations,
-			serialized,
-			preserveStatelyMetadata: this.options.source.getPreserveStatelyMetadata?.(this.options.source.rootUri) ?? true,
-			sourceUpdateStrategy
-		});
-		assertSyntacticallyValidSourceUpdates(documents, response.replacements, this.options.source.rootUri);
-		if (response.replacements.length === 0) {
-			this.reportSourceSyncError("Could not write visual changes to the source file. Your visual edits are still unsaved.", "save", {
-				reason: "no_replacements",
-				patchCount: patches?.length ?? 0,
-				profile: this.currentSourceLocations?.profileRef ?? this.currentSourceLocations?.profile,
-				sourceFile: this.options.source.rootFileName.split(/[\\/]/).pop(),
-				sourceUpdateStrategy,
-				canRewrite: sourceUpdateStrategy === "preserve"
-			}, message.requestId);
-			return;
-		}
-		this.selfEditState.count++;
-		try {
-			const touchedUris = await this.options.source.applyReplacements(response.replacements, this.options.source.rootUri);
-			await this.options.source.saveDocuments?.(touchedUris);
-		} finally {
-			this.selfEditState.count--;
-		}
-		this.currentGraph = message.graph;
-		this.lastPersistedGraph = message.graph;
-		this.options.send({
-			type: "@statelyai.saved",
-			...message.requestId ? { requestId: message.requestId } : {},
-			graph: message.graph
-		});
-	}
-	isExternalSourceDocument(uri) {
-		return (uri === this.options.source.rootUri || this.watchedSourceUris.has(uri)) && this.selfEditState.count === 0;
-	}
-	async handleSavedDocument(uri) {
-		if (!this.isExternalSourceDocument(uri)) return;
-		if (this.saveReminderState.shown) this.options.send({
-			type: "@statelyai.toast.dismiss",
-			id: SOURCE_SAVE_REMINDER_ID
-		});
-		this.saveReminderState.shown = false;
-		if (this.editorProtocolState !== "compatible") 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,
-				...this.options.source.machineIndex !== void 0 ? { machineIndex: this.options.source.machineIndex } : {},
-				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.reportSourceSyncError(formatError(error, "Failed to read the saved document."), "update", {
-				errorName: error instanceof Error ? error.name : void 0,
-				sourceFile: this.options.source.rootFileName.split(/[\\/]/).pop()
-			});
-		}
-	}
-	reportSourceSyncError(message, phase, details, requestId) {
-		const diagnostic = createDiagnostic(phase === "save" ? "source_sync_failed" : "source_update_failed", phase, {
-			protocolVersion: EDITOR_PROTOCOL_VERSION,
-			client: this.options.client,
-			...details
-		});
-		this.options.send({
-			type: "@statelyai.error",
-			code: diagnostic.code,
-			message,
-			diagnostic,
-			...requestId ? { requestId } : {}
-		});
-		this.options.send({
-			type: "@statelyai.toast",
-			message: phase === "save" ? "Visual changes were not written to the source file." : "The source file could not be applied to the visual editor.",
-			toastType: "error"
-		});
-		this.options.showError?.(`${message} (diagnostic ${diagnostic.id})`);
-	}
-	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));
-	}
-};
-/**
-* Runs one source-sync session per discovered machine while presenting the
-* editor's project/workspace protocol as a single surface.
-*/
-var EditorHostWorkspaceSession = class {
-	children = /* @__PURE__ */ new Map();
-	machineDefinitions = /* @__PURE__ */ new Map();
-	initialMessages = /* @__PURE__ */ new Map();
-	selectedMachineId;
-	sentHandshake = false;
-	sentApiKey = false;
-	initialized = false;
-	projectWorkspaceOpen;
-	retrieveRequestCount = 0;
-	pendingRetrievals = /* @__PURE__ */ new Map();
-	saveReminderStates = /* @__PURE__ */ new Map();
-	selfEditStates = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.options = options;
-		if (options.machines.length === 0) throw new Error("A visual editor workspace needs at least one machine.");
-		this.selectedMachineId = options.currentMachineId && options.machines.some((machine) => machine.id === options.currentMachineId) ? options.currentMachineId : options.machines[0].id;
-		this.projectWorkspaceOpen = options.projectWorkspaceOpen ?? false;
-		for (const machine of options.machines) {
-			const saveReminderState = this.saveReminderStates.get(machine.source.rootUri) ?? { shown: false };
-			this.saveReminderStates.set(machine.source.rootUri, saveReminderState);
-			const selfEditState = this.selfEditStates.get(machine.source.rootUri) ?? { count: 0 };
-			this.selfEditStates.set(machine.source.rootUri, selfEditState);
-			this.children.set(machine.id, new EditorHostSession({
-				...options,
-				source: machine.source,
-				send: (message) => this.handleChildMessage(machine, message)
-			}, saveReminderState, selfEditState));
-		}
-	}
-	async receive(message) {
-		if (message.type === "@statelyai.ready") {
-			await Promise.all([...this.children.values()].map((session) => session.receive(message)));
-			this.flushProjectInit();
-			return;
-		}
-		if (message.type === "@statelyai.project.machineSelected") {
-			if (this.children.has(message.machineId)) this.selectedMachineId = message.machineId;
-			return;
-		}
-		if (message.type === "@statelyai.project.workspaceOpenChanged") {
-			this.projectWorkspaceOpen = message.open;
-			return;
-		}
-		if (message.type === "@statelyai.project.workspaceAction") return;
-		if ((message.type === "@statelyai.retrieved" || message.type === "@statelyai.error") && message.requestId) {
-			const pending = this.pendingRetrievals.get(message.requestId);
-			if (pending) {
-				this.pendingRetrievals.delete(message.requestId);
-				await this.children.get(pending.machineId)?.receive({
-					...message,
-					requestId: pending.childRequestId,
-					machineId: pending.machineId
-				});
-				return;
-			}
-		}
-		const routedMessage = message.type === "@statelyai.save" ? normalizeWorkspaceSaveMessage(message, this.options.machines) : message;
-		const machineId = ("machineId" in routedMessage ? routedMessage.machineId : void 0) ?? this.selectedMachineId;
-		const child = this.children.get(machineId);
-		if (child) await child.receive(routedMessage);
-	}
-	selectMachine(machineId) {
-		if (!this.children.has(machineId)) return;
-		this.selectedMachineId = machineId;
-		this.options.send({
-			type: "@statelyai.project.selectMachine",
-			machineId
-		});
-	}
-	dispose() {
-		for (const child of this.children.values()) child.dispose();
-		this.children.clear();
-		this.pendingRetrievals.clear();
-	}
-	handleChildMessage(machine, message) {
-		switch (message.type) {
-			case "@statelyai.init":
-				this.initialMessages.set(machine.id, message);
-				this.machineDefinitions.set(machine.id, {
-					id: machine.id,
-					name: machine.name,
-					sourceReference: machine.sourceReference,
-					sourceUri: machine.source.rootUri,
-					machine: message.machine,
-					format: message.format,
-					sourceLocations: message.sourceLocations
-				});
-				if (this.initialMessages.size === this.children.size) this.flushProjectInit();
-				return;
-			case "@statelyai.update": {
-				const previous = this.machineDefinitions.get(machine.id);
-				this.machineDefinitions.set(machine.id, {
-					id: machine.id,
-					name: machine.name,
-					sourceReference: machine.sourceReference,
-					sourceUri: machine.source.rootUri,
-					machine: message.machine,
-					format: message.format,
-					sourceLocations: message.sourceLocations,
-					...previous?.projectId ? { projectId: previous.projectId } : {}
-				});
-				if (this.initialized) this.options.send({
-					type: "@statelyai.project.update",
-					machines: this.getProjectMachines(),
-					source: "external",
-					currentMachineId: this.selectedMachineId,
-					projectWorkspace: this.getProjectWorkspace(),
-					projectWorkspaceOpen: this.projectWorkspaceOpen
-				});
-				return;
-			}
-			case "@statelyai.handshake":
-				if (this.sentHandshake) return;
-				this.sentHandshake = true;
-				this.options.send(message);
-				return;
-			case "@statelyai.setApiKey":
-				if (this.sentApiKey) return;
-				this.sentApiKey = true;
-				this.options.send(message);
-				return;
-			case "@statelyai.retrieve": {
-				const requestId = `workspace-retrieve-${++this.retrieveRequestCount}`;
-				this.pendingRetrievals.set(requestId, {
-					machineId: machine.id,
-					childRequestId: message.requestId
-				});
-				this.options.send({
-					...message,
-					requestId,
-					machineId: machine.id
-				});
-				return;
-			}
-			case "@statelyai.saved":
-			case "@statelyai.toast":
-			case "@statelyai.toast.dismiss":
-			case "@statelyai.error":
-				this.options.send({
-					...message,
-					machineId: machine.id
-				});
-				return;
-			default: this.options.send(message);
-		}
-	}
-	flushProjectInit() {
-		if (this.initialized || this.initialMessages.size === 0) return;
-		const first = this.initialMessages.values().next().value;
-		if (!first) return;
-		if (!this.machineDefinitions.has(this.selectedMachineId)) {
-			const firstAvailableMachineId = this.machineDefinitions.keys().next().value;
-			if (!firstAvailableMachineId) return;
-			this.selectedMachineId = firstAvailableMachineId;
-		}
-		this.initialized = true;
-		this.options.send({
-			type: "@statelyai.project.init",
-			machines: this.getProjectMachines(),
-			chrome: this.options.showHeader ? { header: true } : void 0,
-			currentMachineId: this.selectedMachineId,
-			mode: first.mode,
-			theme: first.theme,
-			readOnly: first.readOnly,
-			readOnlyReason: first.readOnlyReason,
-			capabilities: first.capabilities,
-			settings: first.settings,
-			panels: first.panels,
-			unsavedIndicator: first.unsavedIndicator,
-			projectWorkspace: this.getProjectWorkspace(),
-			projectWorkspaceOpen: this.projectWorkspaceOpen
-		});
-	}
-	getProjectMachines() {
-		return this.options.machines.flatMap((machine) => {
-			const definition = this.machineDefinitions.get(machine.id);
-			return definition ? [definition] : [];
-		});
-	}
-	getProjectWorkspace() {
-		return { project: {
-			id: "source-workspace",
-			name: this.options.workspaceName ?? "Source workspace",
-			machines: this.options.machines.flatMap((machine) => this.machineDefinitions.has(machine.id) ? [{
-				id: machine.id,
-				name: machine.name
-			}] : [])
-		} };
-	}
-};
-function normalizeWorkspaceSaveMessage(message, machines) {
-	const sourceReferences = new Map(machines.flatMap((machine) => machine.sourceReference ? [[machine.id, machine.sourceReference]] : []));
-	if (sourceReferences.size === 0) return message;
-	try {
-		const usedReferences = /* @__PURE__ */ new Set();
-		const graph = structuredClone(message.graph);
-		const machineConfig = structuredClone(message.machineConfig);
-		normalizeInvokeSources(graph, sourceReferences, usedReferences);
-		normalizeInvokeSources(machineConfig, sourceReferences, usedReferences);
-		if (usedReferences.size === 0) return message;
-		addWorkspaceActorImplementations(graph, usedReferences);
-		const patches = message.patches ? structuredClone(message.patches) : void 0;
-		if (patches) {
-			normalizeInvokeSources(patches, sourceReferences, usedReferences);
-			for (const sourceReference of usedReferences) {
-				if (patches.some((patch) => isRecord(patch) && patch.op === "createImplementation" && patch.sourceType === "actor" && isRecord(patch.implementation) && patch.implementation.id === sourceReference)) continue;
-				patches.push({
-					op: "createImplementation",
-					sourceType: "actor",
-					implementation: {
-						id: sourceReference,
-						name: sourceReference,
-						code: sourceReference
-					}
-				});
-			}
-		}
-		return {
-			...message,
-			graph,
-			machineConfig,
-			...patches ? { patches } : {}
-		};
-	} catch {
-		return message;
-	}
-}
-function normalizeInvokeSources(value, sourceReferences, usedReferences) {
-	if (Array.isArray(value)) {
-		for (const item of value) normalizeInvokeSources(item, sourceReferences, usedReferences);
-		return;
-	}
-	if (!isRecord(value)) return;
-	if (typeof value.src === "string") {
-		const sourceReference = sourceReferences.get(value.src);
-		if (sourceReference) {
-			value.src = sourceReference;
-			usedReferences.add(sourceReference);
-		}
-	}
-	for (const child of Object.values(value)) normalizeInvokeSources(child, sourceReferences, usedReferences);
-}
-function addWorkspaceActorImplementations(graph, sourceReferences) {
-	if (!isRecord(graph) || !isRecord(graph.data)) return;
-	if (!isRecord(graph.data.implementations)) graph.data.implementations = {};
-	const implementations = graph.data.implementations;
-	if (!isRecord(implementations)) return;
-	const actors = Array.isArray(implementations.actors) ? implementations.actors : implementations.actors = [];
-	for (const sourceReference of sourceReferences) {
-		if (actors.some((actor) => isRecord(actor) && actor.id === sourceReference)) continue;
-		actors.push({
-			id: sourceReference,
-			name: sourceReference,
-			description: null,
-			inputSchema: null,
-			outputSchema: null,
-			code: {
-				body: sourceReference,
-				lang: "ts",
-				deps: {}
-			}
-		});
-	}
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function assertSyntacticallyValidSourceUpdates(documents, replacements, rootUri) {
-	const documentsByIdentifier = /* @__PURE__ */ new Map();
-	for (const document of documents) {
-		documentsByIdentifier.set(document.uri, document);
-		documentsByIdentifier.set(document.fileName, document);
-	}
-	const replacementsByUri = /* @__PURE__ */ new Map();
-	for (const replacement of replacements) {
-		const uri = replacement.uri ?? rootUri;
-		const current = replacementsByUri.get(uri) ?? [];
-		current.push(replacement);
-		replacementsByUri.set(uri, current);
-	}
-	for (const [uri, documentReplacements] of replacementsByUri) {
-		const document = documentsByIdentifier.get(uri);
-		if (!document || !/\.[cm]?[jt]sx?$/i.test(document.fileName)) continue;
-		const candidate = applySourceReplacements(document.text, documentReplacements);
-		const diagnostics = getIntroducedSyntacticDiagnostics(document.fileName, document.text, candidate);
-		if (diagnostics.length) {
-			const detail = ts$1.flattenDiagnosticMessageText(diagnostics[0].messageText, "\n");
-			throw new Error(`Stately refused to write invalid source to ${document.fileName}: ${detail}`);
-		}
-	}
-}
-function getIntroducedSyntacticDiagnostics(fileName, original, candidate) {
-	const getDiagnostics = (text) => ts$1.transpileModule(text, {
-		fileName,
-		reportDiagnostics: true,
-		compilerOptions: {
-			allowJs: true,
-			jsx: ts$1.JsxEmit.Preserve,
-			target: ts$1.ScriptTarget.Latest
-		}
-	}).diagnostics ?? [];
-	const originalCounts = /* @__PURE__ */ new Map();
-	for (const diagnostic of getDiagnostics(original)) {
-		const key = diagnosticKey(diagnostic);
-		originalCounts.set(key, (originalCounts.get(key) ?? 0) + 1);
-	}
-	return getDiagnostics(candidate).filter((diagnostic) => {
-		const key = diagnosticKey(diagnostic);
-		const remaining = originalCounts.get(key) ?? 0;
-		if (remaining === 0) return true;
-		originalCounts.set(key, remaining - 1);
-		return false;
-	});
-}
-function diagnosticKey(diagnostic) {
-	return `${diagnostic.code}:${ts$1.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
-}
-function applySourceReplacements(source, replacements) {
-	const lineStarts = [0];
-	for (let index = 0; index < source.length; index++) if (source.charCodeAt(index) === 10) lineStarts.push(index + 1);
-	const offsetAt = (line, character) => (lineStarts[Math.min(Math.max(line, 0), lineStarts.length - 1)] ?? 0) + character;
-	return [...replacements].sort((left, right) => offsetAt(right.range.startLine, right.range.startChar) - offsetAt(left.range.startLine, left.range.startChar)).reduce((text, replacement) => {
-		const start = offsetAt(replacement.range.startLine, replacement.range.startChar);
-		const end = offsetAt(replacement.range.endLine, replacement.range.endChar);
-		return `${text.slice(0, start)}${replacement.newText}${text.slice(end)}`;
-	}, source);
-}
-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 { fetchEditorSyncAccess as a, createRemoteEditorSyncBackend as i, EditorHostWorkspaceSession as n, EditorSyncError as r, EditorHostSession as t };