@statelyai/sdk 0.29.1 → 0.31.1

package/dist/{editorHostSession-DNpXPNAc.mjs → editorHostSession-CT8y0yzG.mjs}

@@ -1,5 +1,7 @@
 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-Bko7wge8.mjs";
+import { p as graphChangeToPatchesResult } from "./dist-wbhkeGh6.mjs";
+import * as ts$1 from "typescript";
 
 //#region ../api-contract/dist/editor-sync.mjs
 const EDITOR_SYNC_PROTOCOL_VERSION = 1;
@@ -80,20 +82,22 @@ const editorSyncDocumentContextSchema = object({
 	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 = editorSyncDocumentContextSchema.extend({
+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()
+	preserveStatelyMetadata: boolean().optional(),
+	sourceUpdateStrategy: _enum(["preserve", "rewrite"]).optional()
 }).passthrough();
 const editorSyncTextReplacementSchema = object({
 	uri: string().optional(),
@@ -185,27 +189,27 @@ var EditorHostSession = class {
 	currentSourceLocations;
 	access;
 	watchedSourceUris = /* @__PURE__ */ new Set();
-	selfEditCount = 0;
-	saveReminderShown = false;
 	watcher;
 	changeWatcher;
 	retrieveRequestCount = 0;
 	pendingRetrievals = /* @__PURE__ */ new Map();
-	constructor(options) {
+	constructor(options, saveReminderState = { shown: false }, selfEditState = { count: 0 }) {
 		this.options = options;
+		this.saveReminderState = saveReminderState;
+		this.selfEditState = selfEditState;
 		this.watcher = options.source.watchSavedDocuments?.((uri) => {
-			this.saveReminderShown = false;
+			this.saveReminderState.shown = false;
 			return this.handleSavedDocument(uri);
 		});
 		this.changeWatcher = options.source.watchChangedDocuments?.((uri) => {
 			if (uri !== this.options.source.rootUri && !this.watchedSourceUris.has(uri)) return;
-			if (this.selfEditCount > 0) return;
-			if (this.saveReminderShown) return;
-			this.saveReminderShown = true;
+			if (this.selfEditState.count > 0) return;
+			if (this.saveReminderState.shown) return;
+			this.saveReminderState.shown = true;
 			this.options.send({
 				type: "@statelyai.toast",
 				message: "Save code to see changes.",
-				toastType: "info"
+				toastType: "warning"
 			});
 		});
 	}
@@ -264,7 +268,11 @@ var EditorHostSession = class {
 					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 }, message.requestId);
+					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":
@@ -317,6 +325,7 @@ var EditorHostSession = class {
 			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;
@@ -372,7 +381,22 @@ var EditorHostSession = class {
 			return;
 		}
 		const previousGraph = this.lastPersistedGraph ?? this.currentGraph;
-		if (!message.patches?.length && graphsEqual(previousGraph, message.graph)) {
+		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({
@@ -384,34 +408,40 @@ var EditorHostSession = class {
 		}
 		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: message.patches,
+			patches,
 			prevGraph: previousGraph,
 			nextGraph: message.graph,
 			sourceLocations: this.currentSourceLocations,
 			serialized,
-			preserveStatelyMetadata: this.options.source.getPreserveStatelyMetadata?.(this.options.source.rootUri) ?? true
+			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: message.patches?.length ?? 0,
+				patchCount: patches?.length ?? 0,
 				profile: this.currentSourceLocations?.profileRef ?? this.currentSourceLocations?.profile,
-				sourceFile: this.options.source.rootFileName.split(/[\\/]/).pop()
+				sourceFile: this.options.source.rootFileName.split(/[\\/]/).pop(),
+				sourceUpdateStrategy,
+				canRewrite: sourceUpdateStrategy === "preserve"
 			}, message.requestId);
 			return;
 		}
-		this.selfEditCount++;
+		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.selfEditCount--;
+			this.selfEditState.count--;
 		}
 		this.currentGraph = message.graph;
 		this.lastPersistedGraph = message.graph;
@@ -423,13 +453,14 @@ var EditorHostSession = class {
 	}
 	async handleSavedDocument(uri) {
 		if (this.editorProtocolState !== "compatible") return;
-		if (uri !== this.options.source.rootUri && !this.watchedSourceUris.has(uri) || this.selfEditCount > 0) return;
+		if (uri !== this.options.source.rootUri && !this.watchedSourceUris.has(uri) || this.selfEditState.count > 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,
+				...this.options.source.machineIndex !== void 0 ? { machineIndex: this.options.source.machineIndex } : {},
 				documents
 			});
 			this.currentFormat = update.format;
@@ -503,6 +534,335 @@ var EditorHostSession = class {
 		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(),
+					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.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(),
+			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 {
@@ -540,4 +900,4 @@ function stateSourceLocationUris(sourceLocations) {
 }
 
 //#endregion
-export { fetchEditorSyncAccess as i, EditorSyncError as n, createRemoteEditorSyncBackend as r, EditorHostSession as t };
+export { fetchEditorSyncAccess as a, createRemoteEditorSyncBackend as i, EditorHostWorkspaceSession as n, EditorSyncError as r, EditorHostSession as t };

package/dist/editorHostSession.d.mts

@@ -1,2 +1,2 @@
-import { a as EditorSyncError, c as fetchEditorSyncAccess, d as EditorHostExportFormat, f as EditorHostInboundMessage, h as EditorHostValidationIssue, i as EditorSyncBackend, l as EDITOR_PROTOCOL_VERSION, m as EditorHostOutboundMessage, n as EditorHostSessionOptions, o as RemoteEditorSyncBackendOptions, p as EditorHostInitOptions, r as EditorSourceHost, s as createRemoteEditorSyncBackend, t as EditorHostSession, u as EditorHostDiagnostic } from "./editorHostSession-vSt07IJV.mjs";
-export { EDITOR_PROTOCOL_VERSION, EditorHostDiagnostic, EditorHostExportFormat, EditorHostInboundMessage, EditorHostInitOptions, EditorHostOutboundMessage, EditorHostSession, EditorHostSessionOptions, EditorHostValidationIssue, EditorSourceHost, EditorSyncBackend, EditorSyncError, RemoteEditorSyncBackendOptions, createRemoteEditorSyncBackend, fetchEditorSyncAccess };
+import { _ as EditorHostOutboundMessage, a as EditorHostWorkspaceSessionOptions, c as EditorSyncError, d as fetchEditorSyncAccess, f as EDITOR_PROTOCOL_VERSION, g as EditorHostInitOptions, h as EditorHostInboundMessage, i as EditorHostWorkspaceSession, l as RemoteEditorSyncBackendOptions, m as EditorHostExportFormat, n as EditorHostSessionOptions, o as EditorSourceHost, p as EditorHostDiagnostic, r as EditorHostWorkspaceMachine, s as EditorSyncBackend, t as EditorHostSession, u as createRemoteEditorSyncBackend, v as EditorHostValidationIssue } from "./editorHostSession-Bo-YhDEG.mjs";
+export { EDITOR_PROTOCOL_VERSION, EditorHostDiagnostic, EditorHostExportFormat, EditorHostInboundMessage, EditorHostInitOptions, EditorHostOutboundMessage, EditorHostSession, EditorHostSessionOptions, EditorHostValidationIssue, EditorHostWorkspaceMachine, EditorHostWorkspaceSession, EditorHostWorkspaceSessionOptions, EditorSourceHost, EditorSyncBackend, EditorSyncError, RemoteEditorSyncBackendOptions, createRemoteEditorSyncBackend, fetchEditorSyncAccess };

package/dist/editorHostSession.mjs

@@ -1,5 +1,6 @@
 import "./openapi-BTDjYWXd.mjs";
 import { t as EDITOR_PROTOCOL_VERSION } from "./editorHostProtocol-Bko7wge8.mjs";
-import { i as fetchEditorSyncAccess, n as EditorSyncError, r as createRemoteEditorSyncBackend, t as EditorHostSession } from "./editorHostSession-DNpXPNAc.mjs";
+import { a as fetchEditorSyncAccess, i as createRemoteEditorSyncBackend, n as EditorHostWorkspaceSession, r as EditorSyncError, t as EditorHostSession } from "./editorHostSession-CT8y0yzG.mjs";
+import "./dist-wbhkeGh6.mjs";
 
-export { EDITOR_PROTOCOL_VERSION, EditorHostSession, EditorSyncError, createRemoteEditorSyncBackend, fetchEditorSyncAccess };
+export { EDITOR_PROTOCOL_VERSION, EditorHostSession, EditorHostWorkspaceSession, EditorSyncError, createRemoteEditorSyncBackend, fetchEditorSyncAccess };

package/dist/embed.d.mts

@@ -1,7 +1,6 @@
-import { i as ProfileManifest } from "./index-D4pdeDpT.mjs";
-import { i as StatelyGraph } from "./graph-C8E1Exad.mjs";
-import { n as EmbedPanelPosition, t as EmbedPanelConfig } from "./embedPanel-Bpbq4sfJ.mjs";
-import { CapabilityDeniedEvent, CommentsConfig, EditorCapabilities, EmbedDocument, EmbedDocumentLanguage, EmbedEventHandler, EmbedEventMap, EmbedEventName, EmbedExtensionsManifest, EmbedMode, ExportCallOptions, ExportFormat, ExportFormatMap, InitOptions, MachineInitOptions, MachineSourceLocations, MachineVersionAutoSaveOptions, ProjectEmbedMachine, ProjectWorkspaceAction, ProjectWorkspaceActionIcon, ProjectWorkspaceCapabilities, ProjectWorkspaceConfig, ProjectWorkspaceMachine, ProjectWorkspaceMachineOrigin, ProjectWorkspaceProject, UploadResult } from "./protocol.mjs";
+import { i as ProfileManifest } from "./index-DlOZxzrW.mjs";
+import { i as StatelyGraph } from "./graph-CR_g-mOq.mjs";
+import { Bt as UploadResult, D as ExportCallOptions, F as InitOptions, G as MachineVersionAutoSaveOptions, O as ExportFormat, Qt as EmbedPanelPosition, S as EmbedExtensionsManifest, U as MachineInitOptions, W as MachineSourceLocations, Y as ProjectEmbedMachine, Zt as EmbedPanelConfig, _ as EmbedDocumentLanguage, at as ProjectWorkspaceCapabilities, b as EmbedEventName, ct as ProjectWorkspaceMachineOrigin, d as CommentsConfig, g as EmbedDocument, k as ExportFormatMap, m as EditorCapabilities, nt as ProjectWorkspaceAction, ot as ProjectWorkspaceConfig, r as CapabilityDeniedEvent, rt as ProjectWorkspaceActionIcon, st as ProjectWorkspaceMachine, ut as ProjectWorkspaceProject, v as EmbedEventHandler, w as EmbedMode, y as EmbedEventMap } from "./protocol-2cvzJtGN.mjs";
 import { AssetUploadAdapter } from "./assetStorage.mjs";
 
 //#region src/embed.d.ts

package/dist/embed.mjs

@@ -1,4 +1,4 @@
-import { a as createEventRegistry, o as createPendingExportManager, r as createPostMessageTransport, s as toInitMessage, t as SDK_VERSION } from "./version-DC3yW9Dk.mjs";
+import { a as createEventRegistry, o as createPendingExportManager, r as createPostMessageTransport, s as toInitMessage, t as SDK_VERSION } from "./version-B6OHpDiz.mjs";
 import { t as EDITOR_PROTOCOL_VERSION } from "./editorHostProtocol-Bko7wge8.mjs";
 
 //#region src/embed.ts
@@ -44,6 +44,8 @@ function serializeExtensions(options) {
 			description: profile.description,
 			namespace: profile.namespace,
 			extends: profile.extends,
+			lineage: profile.lineage,
+			selectable: profile.selectable,
 			formats: profile.formats,
 			defaultFormat: profile.defaultFormat,
 			graph: profile.graph,
@@ -290,7 +292,8 @@ function createStatelyEmbed(options) {
 					machineId: save.machineId,
 					patches: save.patches,
 					validations: save.validations,
-					sourceLocations: save.sourceLocations
+					sourceLocations: save.sourceLocations,
+					sourceUpdateStrategy: save.sourceUpdateStrategy
 				});
 				break;
 			}

package/dist/{graph-C8E1Exad.d.mts → graph-CR_g-mOq.d.mts}

@@ -1,4 +1,4 @@
-import { t as CodeExpression } from "./index-D4pdeDpT.mjs";
+import { t as CodeExpression } from "./index-DlOZxzrW.mjs";
 import * as _statelyai_graph0 from "@statelyai/graph";
 import { Graph } from "@statelyai/graph";
 

package/dist/graph.d.mts

@@ -1,2 +1,2 @@
-import { _ as studioMachineConverter, a as StatelyGraphData, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, n as StatelyActorImplementation, o as StatelyGuard, p as StudioEventTypeData, r as StatelyEdgeData, s as StatelyImplementation, t as StatelyAction, u as StatelyTagImplementation, v as toStudioMachine } from "./graph-C8E1Exad.mjs";
+import { _ as studioMachineConverter, a as StatelyGraphData, c as StatelyInvoke, d as StudioAction, f as StudioEdge, g as fromStudioMachine, h as StudioNode, i as StatelyGraph, l as StatelyNodeData, m as StudioMachine, n as StatelyActorImplementation, o as StatelyGuard, p as StudioEventTypeData, r as StatelyEdgeData, s as StatelyImplementation, t as StatelyAction, u as StatelyTagImplementation, v as toStudioMachine } from "./graph-CR_g-mOq.mjs";
 export { StatelyAction, StatelyActorImplementation, StatelyEdgeData, StatelyGraph, StatelyGraphData, StatelyGuard, StatelyImplementation, StatelyInvoke, StatelyNodeData, StatelyTagImplementation, StudioAction, StudioEdge, StudioEventTypeData, StudioMachine, StudioNode, fromStudioMachine, studioMachineConverter, toStudioMachine };