@stocksharp/diagram 0.2.3 → 0.4.0

package/src/diagram/stocksharp-diagram.ts

@@ -6,7 +6,7 @@ import {
     parseDiagramViewState,
     serializeDiagramViewState,
 } from '../core/view-state.js';
-import type { DiagramDocument } from '../core/model.js';
+import type { DiagramDocument, PortDynamicMode } from '../core/model.js';
 import { DiagramActionRegistry } from '../core/action-registry.js';
 import type {
     DiagramGlobalErrorKind,
@@ -14,6 +14,7 @@ import type {
     DiagramPortRuntimeState,
     DiagramRuntimeState,
     DiagramSelection,
+    DiagramSnapshot,
     DiagramViewState,
 } from '../core/state.js';
 import {
@@ -77,7 +78,6 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
     private fullscreen = false;
     private fullscreenButtonVisible = true;
     private fullscreenLabels: DiagramFullscreenLabels = { enter: 'Enter fullscreen', exit: 'Exit fullscreen' };
-    private linkValidator: LinkValidator | null = null;
     private readonly contextActions = new DiagramActionRegistry<ContextCommand, ContextActionContext>();
 
     constructor(options: DiagramOptions) {
@@ -105,7 +105,6 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
     }
 
     setLinkValidator(validator: LinkValidator | null): void {
-        this.linkValidator = validator;
         this.canvas.setLinkValidator(validator === null ? null : ({ fromNode, fromPort, toNode, toPort }) => validator({
             fromNode: this.fromCanvasNode(fromNode),
             fromPort: this.fromCanvasPort(fromPort),
@@ -178,7 +177,7 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         this.canvas.setGridSnap(enabled, size);
     }
 
-    getGridSnap(): DiagramGridSettings {
+    getGridSnap(): DiagramSnapshot<DiagramGridSettings> {
         return this.canvas.getGridSnap();
     }
 
@@ -202,29 +201,33 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         this.canvas.removeLink(this.toCanvasLink(link));
     }
 
-    addPort(nodeId: string, direction: PortDirection, port: Port): void {
-        this.canvas.addPort(nodeId, direction, this.toCanvasPort(port));
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
+    addPort(nodeId: string, direction: PortDirection, port: Port): boolean {
+        return this.canvas.addPort(nodeId, direction, this.toCanvasPort(port));
     }
 
-    removePort(nodeId: string, direction: PortDirection, portId: string): void {
-        this.canvas.removePort(nodeId, direction, portId);
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
+    removePort(nodeId: string, direction: PortDirection, portId: string): boolean {
+        return this.canvas.removePort(nodeId, direction, portId);
     }
 
-    updatePortType(nodeId: string, direction: PortDirection, portId: string, type: string): void {
-        this.canvas.updatePortType(nodeId, direction, portId, type);
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
+    updatePortType(nodeId: string, direction: PortDirection, portId: string, type: string): boolean {
+        return this.canvas.updatePortType(nodeId, direction, portId, type);
     }
 
     updatePort(nodeId: string, direction: PortDirection, portId: string, patch: PortUpdate): boolean {
         return this.canvas.updatePort(nodeId, direction, portId, patch);
     }
 
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
     setNodePorts(
         nodeId: string,
-        inPorts: ReadonlyArray<{ key: string; name: string; description: string; type: string; maxLinks: number; availableTypes?: string[]; isDynamic?: boolean; dynamicMode?: string }>,
-        outPorts: ReadonlyArray<{ key: string; name: string; description: string; type: string; maxLinks: number; availableTypes?: string[]; isDynamic?: boolean; dynamicMode?: string }>,
-    ): void {
+        inPorts: ReadonlyArray<{ key: string; name: string; description: string; type: string; maxLinks: number; availableTypes?: string[]; isDynamic?: boolean; dynamicMode?: PortDynamicMode }>,
+        outPorts: ReadonlyArray<{ key: string; name: string; description: string; type: string; maxLinks: number; availableTypes?: string[]; isDynamic?: boolean; dynamicMode?: PortDynamicMode }>,
+    ): boolean {
         const current = this.canvas.findNode(nodeId);
-        if (current === undefined) return;
+        if (current === undefined) return false;
         const convert = (port: typeof inPorts[number]): CanvasPortInit => ({
             id: port.key,
             name: port.name,
@@ -243,15 +246,17 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         for (const sibling of current.outPorts.filter((port) => port.isSibling)) {
             if (!nextOut.some((port) => port.id === sibling.id)) nextOut.push(sibling.toInit());
         }
-        this.canvas.setNodePorts(nodeId, nextIn, nextOut);
+        return this.canvas.setNodePorts(nodeId, nextIn, nextOut);
     }
 
-    updateNode(nodeId: string, patch: { name?: string; description?: string; color?: string; border?: string }): void {
-        this.canvas.updateNode(nodeId, patch);
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
+    updateNode(nodeId: string, patch: { name?: string; description?: string; color?: string; border?: string }): boolean {
+        return this.canvas.updateNode(nodeId, patch);
     }
 
-    setNodeMessage(nodeId: string, message: string): void {
-        this.canvas.updateNode(nodeId, { message });
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
+    setNodeMessage(nodeId: string, message: string): boolean {
+        return this.canvas.updateNode(nodeId, { message });
     }
 
     setNodeError(nodeId: string, message: string, options: NodeErrorOptions = {}): boolean {
@@ -262,11 +267,11 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         return this.canvas.clearNodeError(nodeId, kind);
     }
 
-    getRuntimeState(): DiagramRuntimeState {
+    getRuntimeState(): DiagramSnapshot<DiagramRuntimeState> {
         return this.canvas.getRuntimeState();
     }
 
-    setRuntimeState(state: DiagramRuntimeState): void {
+    setRuntimeState(state: DiagramSnapshot<DiagramRuntimeState>): void {
         this.canvas.setRuntimeState(state);
     }
 
@@ -291,12 +296,14 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         this.canvas.setGlobalError(message, kind);
     }
 
-    setNodeParamValue(nodeId: string, paramName: string, value: string | undefined): void {
-        this.canvas.setNodeParamValue(nodeId, paramName, value);
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
+    setNodeParamValue(nodeId: string, paramName: string, value: string | undefined): boolean {
+        return this.canvas.setNodeParamValue(nodeId, paramName, value);
     }
 
-    setNodeName(nodeId: string, value: string): void {
-        this.canvas.updateNode(nodeId, { name: value });
+    /** False when nothing changed: no such node or port, or the edit was a no-op. */
+    setNodeName(nodeId: string, value: string): boolean {
+        return this.canvas.updateNode(nodeId, { name: value });
     }
 
     /** Groups host-driven document edits into one undo/redo operation. */
@@ -312,7 +319,7 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         this.canvas.setReadOnly(readonly);
     }
 
-    getInteractionPermissions(): DiagramInteractionPermissions {
+    getInteractionPermissions(): DiagramSnapshot<DiagramInteractionPermissions> {
         return this.canvas.getInteractionPermissions();
     }
 
@@ -341,11 +348,11 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         this.canvas.setZoom(scale);
     }
 
-    getViewState(): DiagramViewState {
+    getViewState(): DiagramSnapshot<DiagramViewState> {
         return this.canvas.getViewState();
     }
 
-    setViewState(state: DiagramViewState): void {
+    setViewState(state: DiagramSnapshot<DiagramViewState>): void {
         this.canvas.setViewState(state);
         this.overviewContainer?.classList.toggle('hidden', !state.overviewVisible);
     }
@@ -365,7 +372,7 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
         return this.canvas.takeScreenshot(options);
     }
 
-    getSelection(): DiagramSelection {
+    getSelection(): DiagramSnapshot<DiagramSelection> {
         return this.canvas.getSelection();
     }
 
@@ -400,12 +407,12 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
     }
 
     /** Text of the fullscreen button, for a host that renders in another language. */
-    setFullscreenLabels(labels: DiagramFullscreenLabels): void {
+    setFullscreenLabels(labels: DiagramSnapshot<DiagramFullscreenLabels>): void {
         this.fullscreenLabels = labels;
         this.updateFullscreenButton();
     }
 
-    getFullscreenLabels(): DiagramFullscreenLabels {
+    getFullscreenLabels(): DiagramSnapshot<DiagramFullscreenLabels> {
         return { ...this.fullscreenLabels };
     }
 
@@ -760,51 +767,47 @@ export class StockSharpDiagram extends EventEmitter<DiagramEvents> {
 
     private registerContextActions(): void {
         const permissions = () => this.canvas.getInteractionPermissions();
-        this.contextActions.register({
-            id: 'undo',
-            canExecute: () => this.canUndo(),
-            execute: () => this.undo(),
-        });
-        this.contextActions.register({
-            id: 'redo',
-            canExecute: () => this.canRedo(),
-            execute: () => this.redo(),
-        });
-        this.contextActions.register({
-            id: 'cut',
-            canExecute: ({ nodes }) => nodes.length > 0 && permissions().copy && permissions().deleteSelection,
-            execute: () => this.cutSelection(),
-        });
-        this.contextActions.register({
-            id: 'copy',
-            canExecute: ({ nodes }) => nodes.length > 0 && permissions().copy,
-            execute: () => this.copySelection(),
-        });
-        this.contextActions.register({
-            id: 'paste',
-            canExecute: () => this.canvas.hasClipboard() && permissions().paste,
-            execute: () => this.pasteSelection(),
-        });
-        this.contextActions.register({
-            id: 'open',
-            canExecute: ({ nodes }) => nodes.length === 1 && nodes[0].openAction.length > 0,
-            execute: ({ nodes }) => this.emit('nodeOpen', { nodes }),
-        });
-        this.contextActions.register({
-            id: 'delete',
-            canExecute: ({ selection }) => permissions().deleteSelection
-                && (selection.nodeIds.length > 0 || selection.linkIds.length > 0),
-            execute: () => this.canvas.deleteSelection(),
-        });
-        this.contextActions.register({
-            id: 'properties',
-            canExecute: ({ nodes }) => nodes.length > 0,
-            execute: ({ nodes }) => this.emit('nodeProperties', { nodes }),
-        });
-        this.contextActions.register({
-            id: 'help',
-            canExecute: ({ nodes }) => this.helpEnabled && nodes.length > 0,
-            execute: ({ nodes }) => this.emit('nodeHelp', { nodes }),
+        // Keyed by ContextCommand, so a command added to the union without an
+        // entry here fails to compile rather than quietly missing from the menu.
+        // Key order is menu order.
+        this.contextActions.registerAll({
+            undo: {
+                canExecute: () => this.canUndo(),
+                execute: () => this.undo(),
+            },
+            redo: {
+                canExecute: () => this.canRedo(),
+                execute: () => this.redo(),
+            },
+            cut: {
+                canExecute: ({ nodes }) => nodes.length > 0 && permissions().copy && permissions().deleteSelection,
+                execute: () => this.cutSelection(),
+            },
+            copy: {
+                canExecute: ({ nodes }) => nodes.length > 0 && permissions().copy,
+                execute: () => this.copySelection(),
+            },
+            paste: {
+                canExecute: () => this.canvas.hasClipboard() && permissions().paste,
+                execute: () => this.pasteSelection(),
+            },
+            open: {
+                canExecute: ({ nodes }) => nodes.length === 1 && nodes[0].openAction.length > 0,
+                execute: ({ nodes }) => this.emit('nodeOpen', { nodes }),
+            },
+            delete: {
+                canExecute: ({ selection }) => permissions().deleteSelection
+                    && (selection.nodeIds.length > 0 || selection.linkIds.length > 0),
+                execute: () => this.canvas.deleteSelection(),
+            },
+            properties: {
+                canExecute: ({ nodes }) => nodes.length > 0,
+                execute: ({ nodes }) => this.emit('nodeProperties', { nodes }),
+            },
+            help: {
+                canExecute: ({ nodes }) => this.helpEnabled && nodes.length > 0,
+                execute: ({ nodes }) => this.emit('nodeHelp', { nodes }),
+            },
         });
     }
 

package/src/diagram/types.ts

@@ -1,4 +1,5 @@
-import type { JsonObject } from '../core/model.js';
+import { toPortDynamicMode } from '../core/model.js';
+import type { JsonObject, PortDynamicMode } from '../core/model.js';
 
 // Core data model — node/port catalog (palette) and the live diagram (DiagramNode + Link).
 
@@ -29,7 +30,7 @@ export interface PortInit {
     /// True when this port can be added/removed at runtime on a node.
     isDynamic?: boolean;
     /// "" / "manual" / "onConnect" — see PalettePortDto.dynamicMode docs.
-    dynamicMode?: string;
+    dynamicMode?: PortDynamicMode;
     /// True when this port was spawned by the grow-on-connect pipeline.
     /// Distinguishes anchor + runtime siblings on save (only siblings are
     /// persisted in the diagram blob; anchors come from the palette schema).
@@ -47,7 +48,7 @@ export class Port {
     maxLinks: number;
     availableTypes: string[];
     isDynamic: boolean;
-    dynamicMode: string;
+    dynamicMode: PortDynamicMode;
     isSibling: boolean;
 
     constructor(init: PortInit) {
@@ -58,7 +59,7 @@ export class Port {
         this.maxLinks = typeof init.maxLinks === 'number' ? init.maxLinks : 0;
         this.availableTypes = init.availableTypes ?? [];
         this.isDynamic = init.isDynamic ?? false;
-        this.dynamicMode = init.dynamicMode ?? '';
+        this.dynamicMode = toPortDynamicMode(init.dynamicMode);
         this.isSibling = init.isSibling ?? false;
     }
 
@@ -268,7 +269,7 @@ export interface PortData {
     /// the anchor port spawns a sibling
     /// on each link drop and the link is rerouted to the sibling.
     isDynamic?: boolean;
-    dynamicMode?: string;
+    dynamicMode?: PortDynamicMode;
     /// True when this port was spawned by the dynamic-growth pipeline rather
     /// than declared on the palette element. Persists in the diagram blob so
     /// reload restores the same set of sibling sockets.

package/src/embed.ts

@@ -11,6 +11,8 @@ import { StockSharpDiagram } from './diagram/stocksharp-diagram.js';
 import { StockSharpCatalog } from './diagram/catalog.js';
 import { DiagramNode, Link, Node, Port, PortType } from './diagram/types.js';
 import type { FullscreenRequestedPayload } from './diagram/api.js';
+import { toPortDynamicMode } from './core/model.js';
+import type { PortDynamicMode } from './core/model.js';
 
 interface PalettePort {
 	key: string;
@@ -19,7 +21,7 @@ interface PalettePort {
 	maxLinks?: number;
 	availableTypes?: string[];
 	isDynamic?: boolean;
-	dynamicMode?: string;
+	dynamicMode?: PortDynamicMode;
 }
 
 interface PaletteElement {
@@ -166,59 +168,136 @@ function toDiagramNodes(
 // Walk the persisted Content.Value.Scheme.Model.{Nodes,Links} structure into
 // the thin scheme. Defensive at every field so a partially
 // broken document yields as many nodes as are readable; a wholly unusable one yields an empty scheme.
+// Every reader below narrows rather than asserts: the input is arbitrary JSON
+// from a URL or an inline <script>, so a type assertion here would only be a
+// promise the data never made. Anything unreadable is skipped, never thrown on.
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return isRecord(value) ? value : undefined;
+}
+
+function asArray(value: unknown): unknown[] {
+	return Array.isArray(value) ? value : [];
+}
+
+function asString(value: unknown): string {
+	return typeof value === 'string' ? value : '';
+}
+
+function asFiniteNumber(value: unknown): number {
+	return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
 function nodeName(node: Record<string, unknown>): string {
-	const settings = node?.Settings as Record<string, unknown> | undefined;
-	const parameters = settings?.Parameters as Record<string, unknown> | undefined;
-	const nameParam = parameters?.Name as Record<string, unknown> | undefined;
-	const nameVal = nameParam?.Value;
-	if (typeof nameVal === 'string' && nameVal.length > 0)
-		return nameVal;
-	if (typeof node?.Figure === 'string' && (node.Figure as string).length > 0)
-		return node.Figure as string;
-	return typeof node?.Key === 'string' ? node.Key as string : '';
+	const named = asRecord(asRecord(asRecord(node.Settings)?.Parameters)?.Name)?.Value;
+	if (typeof named === 'string' && named.length > 0)
+		return named;
+	const figure = asString(node.Figure);
+	return figure.length > 0 ? figure : asString(node.Key);
 }
 
 function parseRawScheme(raw: unknown): DiagramEmbedScheme {
 	const nodes: DiagramEmbedSchemeNode[] = [];
 	const links: DiagramEmbedSchemeLink[] = [];
 
-	const root = raw as Record<string, unknown>;
-	const content = root?.Content as Record<string, unknown> | undefined;
-	const value = content?.Value as Record<string, unknown> | undefined;
-	const scheme = value?.Scheme as Record<string, unknown> | undefined;
-	const model = scheme?.Model as Record<string, unknown> | undefined;
-	if (!model)
+	const model = asRecord(asRecord(asRecord(asRecord(raw)?.Content)?.Value)?.Scheme)?.Model;
+	const fields = asRecord(model);
+	if (fields === undefined)
 		return { nodes, links };
 
-	for (const raw of (model.Nodes as Record<string, unknown>[] ?? [])) {
-		const key = raw?.Key;
+	for (const entry of asArray(fields.Nodes)) {
+		const node = asRecord(entry);
+		if (node === undefined)
+			continue;
+		const key = node.Key;
 		if (typeof key !== 'string' || key.length === 0)
 			continue;
 		nodes.push({
 			id: key,
-			typeId: typeof raw.TypeId === 'string' ? raw.TypeId : '',
-			name: nodeName(raw),
-			x: typeof raw.X === 'number' ? raw.X : 0,
-			y: typeof raw.Y === 'number' ? raw.Y : 0,
+			typeId: asString(node.TypeId),
+			name: nodeName(node),
+			x: asFiniteNumber(node.X),
+			y: asFiniteNumber(node.Y),
 		});
 	}
 
-	for (const raw of (model.Links as Record<string, unknown>[] ?? [])) {
-		const from = raw?.From;
-		const to = raw?.To;
+	for (const entry of asArray(fields.Links)) {
+		const link = asRecord(entry);
+		if (link === undefined)
+			continue;
+		const from = link.From;
+		const to = link.To;
 		if (typeof from !== 'string' || typeof to !== 'string')
 			continue;
 		links.push({
 			from,
-			fromPort: typeof raw.FromPort === 'string' ? raw.FromPort : '',
+			fromPort: asString(link.FromPort),
 			to,
-			toPort: typeof raw.ToPort === 'string' ? raw.ToPort : '',
+			toPort: asString(link.ToPort),
 		});
 	}
 
 	return { nodes, links };
 }
 
+function parsePalettePorts(value: unknown): PalettePort[] {
+	const ports: PalettePort[] = [];
+	for (const entry of asArray(value)) {
+		const port = asRecord(entry);
+		if (port === undefined)
+			continue;
+		const key = asString(port.key);
+		if (key.length === 0)
+			continue;
+		ports.push({
+			key,
+			name: asString(port.name),
+			type: asString(port.type),
+			maxLinks: asFiniteNumber(port.maxLinks),
+			availableTypes: asArray(port.availableTypes).filter((item): item is string => typeof item === 'string'),
+			isDynamic: port.isDynamic === true,
+			dynamicMode: toPortDynamicMode(port.dynamicMode),
+		});
+	}
+	return ports;
+}
+
+function parsePalette(value: unknown): Palette {
+	const socketTypes: Palette['socketTypes'] = [];
+	const elements: PaletteElement[] = [];
+	const root = asRecord(value);
+	if (root === undefined)
+		return { socketTypes, elements };
+
+	for (const entry of asArray(root.socketTypes)) {
+		const socket = asRecord(entry);
+		const name = asString(socket?.name);
+		if (name.length === 0)
+			continue;
+		socketTypes.push({ name, color: asString(socket?.color) });
+	}
+
+	for (const entry of asArray(root.elements)) {
+		const element = asRecord(entry);
+		const typeId = asString(element?.typeId);
+		if (element === undefined || typeId.length === 0)
+			continue;
+		elements.push({
+			typeId,
+			name: asString(element.name),
+			groupName: asString(element.groupName),
+			icon: asString(element.icon),
+			inPorts: parsePalettePorts(element.inPorts),
+			outPorts: parsePalettePorts(element.outPorts),
+		});
+	}
+
+	return { socketTypes, elements };
+}
+
 export async function renderScheme(
 	div: HTMLElement,
 	paletteUrl: string,
@@ -237,7 +316,12 @@ async function renderSchemeAtRevision(
 ): Promise<DiagramEmbedHandle | null> {
 	if (renderRevisions.get(div) !== revision)
 		return null;
-	const palette = (await fetch(paletteUrl).then((r) => r.json())) as Palette;
+	// Same treatment the schema fetch gets: a non-2xx answer is a failure, not a
+	// body to parse. Callers that degrade already catch it.
+	const response = await fetch(paletteUrl);
+	if (!response.ok)
+		throw new Error(`Palette request to ${paletteUrl} failed with status ${response.status}.`);
+	const palette = parsePalette(await response.json());
 	if (renderRevisions.get(div) !== revision)
 		return null;
 	const catalog = buildCatalog(palette);
@@ -412,6 +496,25 @@ function stopDisconnectedHostObserverWhenIdle(): void {
 	disconnectedHostObserver = null;
 }
 
+interface EmbedErrorTexts {
+	load: string;
+	empty: string;
+	draw: string;
+}
+
+// The host overrides the inline notes with data-diagram-errors="load|empty|draw".
+// Each slot falls back when it is empty rather than when it is absent: split on a
+// missing attribute yields [''], one present empty string, so a destructuring
+// default would never fire and the note would render blank.
+function errorTexts(div: HTMLElement): EmbedErrorTexts {
+	const parts = (div.dataset.diagramErrors ?? '').split('|');
+	return {
+		load: parts[0] || 'Diagram source could not be loaded.',
+		empty: parts[1] || 'Diagram is empty or malformed.',
+		draw: parts[2] || 'Diagram could not be rendered.',
+	};
+}
+
 function note(div: HTMLElement, message: string, revision: number): void {
 	if (renderRevisions.get(div) !== revision) return;
 	disposeActiveRender(div);
@@ -429,30 +532,29 @@ export async function renderFromSource(
 	options: DiagramEmbedOptions = {},
 ): Promise<DiagramEmbedHandle | null> {
 	const revision = beginRender(div);
-	const errors = (div.dataset.diagramErrors ?? '').split('|');
-	const [errLoad = 'Diagram source could not be loaded.', errEmpty = 'Diagram is empty or malformed.', errDraw = 'Diagram could not be rendered.'] = errors;
+	const errors = errorTexts(div);
 
 	let raw: unknown;
 	try {
 		const resp = await fetch(srcUrl);
-		if (!resp.ok) { note(div, errLoad, revision); return null; }
+		if (!resp.ok) { note(div, errors.load, revision); return null; }
 		const text = (await resp.text()).replace(/^/, '');
 		raw = JSON.parse(text);
 	} catch {
-		note(div, errLoad, revision);
+		note(div, errors.load, revision);
 		return null;
 	}
 
 	const scheme = parseRawScheme(raw);
 	if (scheme.nodes.length === 0) {
-		note(div, errEmpty, revision);
+		note(div, errors.empty, revision);
 		return null;
 	}
 
 	try {
 		return await renderSchemeAtRevision(div, paletteUrl, scheme, revision, options);
 	} catch {
-		note(div, errDraw, revision);
+		note(div, errors.draw, revision);
 		return null;
 	}
 }
@@ -467,27 +569,26 @@ export async function renderFromInline(
 	options: DiagramEmbedOptions = {},
 ): Promise<DiagramEmbedHandle | null> {
 	const revision = beginRender(div);
-	const errors = (div.dataset.diagramErrors ?? '').split('|');
-	const [, errEmpty = 'Diagram is empty or malformed.', errDraw = 'Diagram could not be rendered.'] = errors;
+	const errors = errorTexts(div);
 
 	let raw: unknown;
 	try {
 		raw = JSON.parse(json);
 	} catch {
-		note(div, errEmpty, revision);
+		note(div, errors.empty, revision);
 		return null;
 	}
 
 	const scheme = parseRawScheme(raw);
 	if (scheme.nodes.length === 0) {
-		note(div, errEmpty, revision);
+		note(div, errors.empty, revision);
 		return null;
 	}
 
 	try {
 		return await renderSchemeAtRevision(div, paletteUrl, scheme, revision, options);
 	} catch {
-		note(div, errDraw, revision);
+		note(div, errors.draw, revision);
 		return null;
 	}
 }

package/src/index.ts

@@ -36,6 +36,7 @@ export type {
     JsonObject,
     JsonPrimitive,
     JsonValue,
+    PortDynamicMode,
 } from './core/model.js';
 
 export {
@@ -43,6 +44,7 @@ export {
     createDiagramNodeRuntimeState,
     createDiagramPortRuntimeState,
     createDiagramRuntimeState,
+    cloneDiagramNodeErrors,
     cloneDiagramRuntimeState,
     createDiagramSelection,
     createDiagramViewState,
@@ -64,6 +66,7 @@ export type {
     DiagramGlobalErrorKind,
     DiagramInteractionPermissions,
     DiagramNodeErrorKind,
+    DiagramNodeErrors,
     DiagramNodePortRuntimeState,
     DiagramNodeRuntimeState,
     DiagramPortDirection,
@@ -71,6 +74,7 @@ export type {
     DiagramRuntimeState,
     DiagramSelectedPort,
     DiagramSelection,
+    DiagramSnapshot,
     DiagramViewState,
 } from './core/state.js';