@stocksharp/diagram 0.2.2 → 0.3.0

package/dist/types/embed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embed.d.ts","sourceRoot":"","sources":["../../src/embed.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAGpE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AA0BnE,MAAM,WAAW,sBAAsB;IAAG,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;CAAE;AAC3G,MAAM,WAAW,sBAAsB;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;CAAE;AACvG,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,KAAK,EAAE,sBAAsB,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,OAAO,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IACnC,qBAAqB,CAAC,EAAE,CACvB,OAAO,EAAE,0BAA0B,EACnC,MAAM,EAAE,kBAAkB,KACtB,IAAI,CAAC;IACV,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACnD;AAmKD,wBAAsB,YAAY,CACjC,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAEpC;AAgJD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAGhE;AAyCD,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CA4BpC;AAKD,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAyBpC;AAKD,wBAAgB,SAAS,CAAC,IAAI,GAAE,UAAqB,EAAE,OAAO,GAAE,mBAAwB,GAAG,IAAI,CAkB9F"}
+{"version":3,"file":"embed.d.ts","sourceRoot":"","sources":["../../src/embed.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAGpE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AA4BnE,MAAM,WAAW,sBAAsB;IAAG,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;CAAE;AAC3G,MAAM,WAAW,sBAAsB;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;CAAE;AACvG,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,KAAK,EAAE,sBAAsB,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,OAAO,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IACnC,qBAAqB,CAAC,EAAE,CACvB,OAAO,EAAE,0BAA0B,EACnC,MAAM,EAAE,kBAAkB,KACtB,IAAI,CAAC;IACV,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACnD;AAgPD,wBAAsB,YAAY,CACjC,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAEpC;AA6JD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAGhE;AA4DD,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CA2BpC;AAKD,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAwBpC;AAKD,wBAAgB,SAAS,CAAC,IAAI,GAAE,UAAqB,EAAE,OAAO,GAAE,mBAAwB,GAAG,IAAI,CAkB9F"}

package/dist/types/index.d.ts

@@ -4,11 +4,11 @@ export type { DiagramAction, DiagramActionState, } from './core/action-registry.
 export { DiagramCommandHistory } from './core/history.js';
 export type { DiagramCommand, DiagramHistoryListener, DiagramHistoryState, } from './core/history.js';
 export { DIAGRAM_DOCUMENT_VERSION } from './core/model.js';
-export type { DiagramDocument, DiagramDocumentEndpoint, DiagramDocumentInput, DiagramDocumentLink, DiagramDocumentLinkInput, DiagramDocumentNode, DiagramDocumentNodeInput, DiagramDocumentPort, DiagramDocumentPortInput, DiagramDocumentVersion, DiagramParameterSchema, JsonObject, JsonPrimitive, JsonValue, } from './core/model.js';
-export { createEditableDiagramPermissions, createDiagramNodeRuntimeState, createDiagramPortRuntimeState, createDiagramRuntimeState, cloneDiagramRuntimeState, createDiagramSelection, createDiagramViewState, createReadOnlyDiagramPermissions, } from './core/state.js';
+export type { DiagramDocument, DiagramDocumentEndpoint, DiagramDocumentInput, DiagramDocumentLink, DiagramDocumentLinkInput, DiagramDocumentNode, DiagramDocumentNodeInput, DiagramDocumentPort, DiagramDocumentPortInput, DiagramDocumentVersion, DiagramParameterSchema, JsonObject, JsonPrimitive, JsonValue, PortDynamicMode, } from './core/model.js';
+export { createEditableDiagramPermissions, createDiagramNodeRuntimeState, createDiagramPortRuntimeState, createDiagramRuntimeState, cloneDiagramNodeErrors, cloneDiagramRuntimeState, createDiagramSelection, createDiagramViewState, createReadOnlyDiagramPermissions, } from './core/state.js';
 export { DIAGRAM_VIEW_STATE_VERSION, DiagramViewStateError, createDiagramViewStateDocument, parseDiagramViewState, serializeDiagramViewState, } from './core/view-state.js';
 export type { DiagramViewStateDocument } from './core/view-state.js';
-export type { DiagramErrorState, DiagramGlobalErrorKind, DiagramInteractionPermissions, DiagramNodeErrorKind, DiagramNodePortRuntimeState, DiagramNodeRuntimeState, DiagramPortDirection, DiagramPortRuntimeState, DiagramRuntimeState, DiagramSelectedPort, DiagramSelection, DiagramViewState, } from './core/state.js';
+export type { DiagramErrorState, DiagramGlobalErrorKind, DiagramInteractionPermissions, DiagramNodeErrorKind, DiagramNodeErrors, DiagramNodePortRuntimeState, DiagramNodeRuntimeState, DiagramPortDirection, DiagramPortRuntimeState, DiagramRuntimeState, DiagramSelectedPort, DiagramSelection, DiagramSnapshot, DiagramViewState, } from './core/state.js';
 export { StockSharpDiagram, } from './diagram/stocksharp-diagram.js';
 export type { ContextCommand, ContextCommandPayload, ContextCommandState, ContextMenuRequestedPayload, DiagramEvents, DiagramClipboard, DiagramGridSettings, DiagramLoadOptions, DiagramNodeBounds, DiagramOptions, DiagramPoint, DiagramScreenshotOptions, DiagramScreenshotScope, DiagramThemeOptions, DocumentLoadFailedPayload, LinkChangePayload, LinkHoverPayload, LinkRelinkedPayload, LinkSelectedPayload, LinkValidationPayload, LinkValidationReason, LinkValidationResult, LinkValidator, LinkValidatorArgs, LoadFinishedPayload, NodeChangePayload, NodeErrorKind, NodeErrorOptions, NodeHoverPayload, NodeMovedPayload, NodeSelectedPayload, PortHoverPayload, PortClickAction, PortClickedPayload, PortSelectedPayload, } from './diagram/api.js';
 export { StockSharpCatalog } from './diagram/catalog.js';

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stocksharp/diagram",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Browser strategy-diagram editor for StockSharp with typed ports, palette, canvas rendering, persistence, and a TypeScript API.",
   "license": "SEE LICENSE IN LICENSE",
   "author": {
@@ -107,7 +107,7 @@
   "scripts": {
     "build": "node build.mjs",
     "prepack": "npm run build",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.demo.json && tsc --noEmit -p tsconfig.test.json",
     "api:check": "node tools/check-public-api.mjs",
     "api:update": "node tools/check-public-api.mjs --update",
     "serve": "node serve.mjs",

package/src/canvas-renderer.ts

@@ -6,11 +6,14 @@
 
 import { createDiagramDocument, parseDiagramDocument } from './core/document.js';
 import { DiagramCommandHistory } from './core/history.js';
+import { setJsonKey } from './core/json.js';
+import { toPortDynamicMode } from './core/model.js';
 import type {
     DiagramDocument,
     DiagramParameterSchema,
     JsonObject,
     JsonValue,
+    PortDynamicMode,
 } from './core/model.js';
 import type {
     DiagramGlobalErrorKind,
@@ -40,7 +43,7 @@ export interface PortInit {
     maxLinks?: number;
     availableTypes?: string[];
     isDynamic?: boolean;
-    dynamicMode?: string;
+    dynamicMode?: PortDynamicMode;
     isSibling?: boolean;
     metadata?: JsonObject;
 }
@@ -258,7 +261,7 @@ function copyJsonValue(value: JsonValue): JsonValue {
 function copyJsonObject(value: JsonObject | undefined): JsonObject {
     if (value === undefined) return {};
     const result: JsonObject = {};
-    for (const [key, item] of Object.entries(value)) result[key] = copyJsonValue(item);
+    for (const [key, item] of Object.entries(value)) setJsonKey(result, key, copyJsonValue(item));
     return result;
 }
 
@@ -298,7 +301,7 @@ export class PortModel {
     maxLinks: number;
     availableTypes: string[];
     isDynamic: boolean;
-    dynamicMode: string;
+    dynamicMode: PortDynamicMode;
     isSibling: boolean;
     metadata: JsonObject;
     // layout cache (world coords), filled at draw time
@@ -313,7 +316,7 @@ export class PortModel {
         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;
         this.metadata = copyJsonObject(init.metadata);
     }
@@ -439,10 +442,8 @@ export class LinkModel {
     }
 }
 
-const HEADER_H = 22;
 const PORT_R = 6;
 const PORT_ROW_H = 20;
-const NODE_PAD = 10;
 const RELINK_HANDLE_PX = 8;  // WPF relink adornment is an 8x8 diamond
 const RELINK_DRAG_THRESHOLD_PX = 4;
 const PORT_SQ = 9;           // socket square size — sits outside the node
@@ -530,8 +531,6 @@ export class Diagram {
     private dragNode: NodeModel | null = null;
     private dragStart: Array<{ n: NodeModel; x: number; y: number }> = [];   // group-drag origin
     private dragAnchor = { wx: 0, wy: 0 };
-    private dragDX = 0;
-    private dragDY = 0;
     private panning = false;
     private panX = 0;
     private panY = 0;
@@ -1121,7 +1120,7 @@ export class Diagram {
     setNodeParamValue(nodeId: string, name: string, value: string | undefined): boolean {
         return this.updateNodeState(nodeId, 'set node parameter', (node) => {
             if (value === undefined) delete node.paramValues[name];
-            else node.paramValues[name] = value;
+            else setJsonKey(node.paramValues, name, value);
         });
     }
 
@@ -1207,7 +1206,7 @@ export class Diagram {
         for (const node of this.nodes) {
             if (node.loadError.length === 0) continue;
             const state = createDiagramNodeRuntimeState();
-            state.error = { kind: 'load', message: node.loadError, pulse: ++this.runtimePulse };
+            state.errors.load = { kind: 'load', message: node.loadError, pulse: ++this.runtimePulse };
             this.runtimeState.nodes[node.id] = state;
         }
         if (Object.keys(this.runtimeState.nodes).length > 0) this.emitRuntimeStateChanged();
@@ -1418,15 +1417,17 @@ export class Diagram {
         this.runtimePulse = Math.max(
             this.runtimePulse,
             this.runtimeState.globalError?.pulse ?? 0,
-            ...Object.values(this.runtimeState.nodes).map((node) => node.error?.pulse ?? 0),
+            ...Object.values(this.runtimeState.nodes)
+                .flatMap((node) => [node.errors.runtime?.pulse ?? 0, node.errors.load?.pulse ?? 0]),
         );
         for (const node of this.nodes) {
-            const error = this.runtimeState.nodes[node.id]?.error ?? null;
-            const previousError = previous.nodes[node.id]?.error ?? null;
-            node.runtimeError = error?.kind === 'runtime' ? error.message : '';
-            node.loadError = error?.kind === 'load' ? error.message : '';
-            if (error?.kind === 'runtime') {
-                if (previousError?.kind !== 'runtime' || previousError.pulse !== error.pulse) {
+            const errors = this.runtimeState.nodes[node.id]?.errors;
+            const previousRuntime = previous.nodes[node.id]?.errors.runtime;
+            const runtimeError = errors?.runtime;
+            node.runtimeError = runtimeError?.message ?? '';
+            node.loadError = errors?.load?.message ?? '';
+            if (runtimeError !== undefined) {
+                if (previousRuntime === undefined || previousRuntime.pulse !== runtimeError.pulse) {
                     node.errorFlashStart = performance.now();
                 }
             } else {
@@ -1486,7 +1487,11 @@ export class Diagram {
         const state = this.getRuntimeState();
         const nodeState = state.nodes[id] ?? createDiagramNodeRuntimeState();
         state.nodes[id] = nodeState;
-        nodeState.error = message.length === 0 ? null : { kind, message, pulse: ++this.runtimePulse };
+        // Only this kind's slot is written, so an error of the other kind that is
+        // already on the node survives.
+        if (message.length === 0) delete nodeState.errors[kind];
+        else if (kind === 'load') nodeState.errors.load = { kind, message, pulse: ++this.runtimePulse };
+        else nodeState.errors.runtime = { kind, message, pulse: ++this.runtimePulse };
         this.runtimeState = state;
         this.emitRuntimeStateChanged();
         return true;
@@ -1501,12 +1506,9 @@ export class Diagram {
         if (kind === undefined || kind === 'load') node.loadError = '';
         const state = this.getRuntimeState();
         const nodeState = state.nodes[id];
-        if (nodeState !== undefined && (kind === undefined || nodeState.error?.kind === kind)) {
-            nodeState.error = node.runtimeError.length > 0
-                ? { kind: 'runtime', message: node.runtimeError, pulse: ++this.runtimePulse }
-                : node.loadError.length > 0
-                    ? { kind: 'load', message: node.loadError, pulse: ++this.runtimePulse }
-                    : null;
+        if (nodeState !== undefined) {
+            if (kind === undefined || kind === 'runtime') delete nodeState.errors.runtime;
+            if (kind === undefined || kind === 'load') delete nodeState.errors.load;
         }
         this.runtimeState = state;
         this.emitRuntimeStateChanged();

package/src/core/action-registry.ts

@@ -22,6 +22,31 @@ export class DiagramActionRegistry<TId extends string, TContext> {
         };
     }
 
+    /**
+     * Registers one action per id from a table keyed by TId, in key order.
+     * Because the table is a total Record, adding a member to TId without adding
+     * its action stops compiling instead of producing a command that silently
+     * does nothing.
+     */
+    registerAll(actions: Record<TId, Omit<DiagramAction<TId, TContext>, 'id'>>): () => void {
+        // Object.keys is typed string[] because a value can carry keys beyond the
+        // ones its type names. This parameter is a total Record over TId, so its
+        // keys are exactly TId.
+        const ids = Object.keys(actions) as TId[];
+        // Delegating rather than spreading: a spread would copy own fields and
+        // drop the prototype, so a class-based action would register cleanly and
+        // then throw on its first call.
+        const disposers = ids.map((id) => {
+            const action = actions[id];
+            return this.register({
+                id,
+                canExecute: (context) => action.canExecute(context),
+                execute: (context) => action.execute(context),
+            });
+        });
+        return () => disposers.forEach((dispose) => dispose());
+    }
+
     get(id: TId): DiagramAction<TId, TContext> | null {
         return this.actions.get(id) ?? null;
     }

package/src/core/document.ts

@@ -1,15 +1,15 @@
+import { setJsonKey } from './json.js';
+import { toPortDynamicMode } from './model.js';
 import {
     DIAGRAM_DOCUMENT_VERSION,
     type DiagramDocument,
     type DiagramDocumentEndpoint,
     type DiagramDocumentInput,
     type DiagramDocumentLink,
-    type DiagramDocumentLinkInput,
     type DiagramDocumentNode,
-    type DiagramDocumentNodeInput,
     type DiagramDocumentPort,
-    type DiagramDocumentPortInput,
     type DiagramParameterSchema,
+    type PortDynamicMode,
     type JsonObject,
     type JsonValue,
 } from './model.js';
@@ -40,13 +40,18 @@ export class DiagramDocumentError extends Error {
 }
 
 export function createDiagramDocument(input: DiagramDocumentInput = {}): DiagramDocument {
-    const nodes = (input.nodes ?? []).map((node, index) => normalizeNode(node, `$.nodes[${index}]`));
+    // DiagramDocumentInput is a structural interface, so its shape is a claim by
+    // the caller, not a guarantee. Elements are checked the same way parsed ones
+    // are, otherwise a malformed one surfaces as a TypeError naming no path.
+    const rawNodes = mapElements(input.nodes, '$.nodes');
+    const rawLinks = mapElements(input.links, '$.links');
+    const nodes = rawNodes.map((node, index) => normalizeNode(node, `$.nodes[${index}]`));
     const usedLinkIds = new Set<string>();
 
-    for (let index = 0; index < (input.links ?? []).length; index++) {
-        const id = input.links?.[index].id;
-        if (id === undefined) continue;
-        requireIdentifier(id, `$.links[${index}].id`);
+    for (let index = 0; index < rawLinks.length; index++) {
+        const raw = rawLinks[index].id;
+        if (raw === undefined) continue;
+        const id = requireIdentifier(raw, `$.links[${index}].id`);
         if (usedLinkIds.has(id)) {
             throw new DiagramDocumentError(`duplicate link id "${id}"`, `$.links[${index}].id`);
         }
@@ -54,12 +59,14 @@ export function createDiagramDocument(input: DiagramDocumentInput = {}): Diagram
     }
 
     let sequence = 1;
-    const links = (input.links ?? []).map((link, index) => {
+    const links = rawLinks.map((link, index) => {
         let id = link.id;
         if (id === undefined) {
-            do id = `link_${sequence++}`;
-            while (usedLinkIds.has(id));
-            usedLinkIds.add(id);
+            let generated: string;
+            do generated = `link_${sequence++}`;
+            while (usedLinkIds.has(generated));
+            usedLinkIds.add(generated);
+            id = generated;
         }
         return normalizeLink({ ...link, id }, `$.links[${index}]`);
     });
@@ -92,7 +99,7 @@ export function parseDiagramDocument(source: string | unknown): DiagramDocument
         }
     }
 
-    const root = requireObject(value, '$');
+    const root = requireStructure(value, '$');
     const version = requireNumber(root.version, '$.version');
     if (version !== DIAGRAM_DOCUMENT_VERSION) {
         throw new DiagramDocumentError(`unsupported document version ${version}`, '$.version');
@@ -107,7 +114,8 @@ export function parseDiagramDocument(source: string | unknown): DiagramDocument
     return document;
 }
 
-function normalizeNode(input: DiagramDocumentNodeInput, path: string): DiagramDocumentNode {
+function normalizeNode(value: unknown, path: string): DiagramDocumentNode {
+    const input = requireStructure(value, path);
     const id = requireIdentifier(input.id, `${path}.id`);
     return {
         id,
@@ -122,30 +130,36 @@ function normalizeNode(input: DiagramDocumentNodeInput, path: string): DiagramDo
         icon: requireString(input.icon ?? '', `${path}.icon`),
         message: requireString(input.message ?? '', `${path}.message`),
         openAction: requireString(input.openAction ?? '', `${path}.openAction`),
-        inPorts: (input.inPorts ?? []).map((port, index) => normalizePort(port, `${path}.inPorts[${index}]`)),
-        outPorts: (input.outPorts ?? []).map((port, index) => normalizePort(port, `${path}.outPorts[${index}]`)),
-        parameters: (input.parameters ?? []).map((parameter, index) => normalizeParameter(parameter, `${path}.parameters[${index}]`)),
+        inPorts: mapElements(input.inPorts, `${path}.inPorts`)
+            .map((port, index) => normalizePort(port, `${path}.inPorts[${index}]`)),
+        outPorts: mapElements(input.outPorts, `${path}.outPorts`)
+            .map((port, index) => normalizePort(port, `${path}.outPorts[${index}]`)),
+        parameters: mapElements(input.parameters, `${path}.parameters`)
+            .map((parameter, index) => normalizeParameter(parameter, `${path}.parameters[${index}]`)),
         paramValues: cloneStringRecord(input.paramValues ?? {}, `${path}.paramValues`),
         metadata: cloneJsonObject(input.metadata ?? {}, `${path}.metadata`),
     };
 }
 
-function normalizePort(input: DiagramDocumentPortInput, path: string): DiagramDocumentPort {
+function normalizePort(value: unknown, path: string): DiagramDocumentPort {
+    const input = requireStructure(value, path);
     return {
         id: requireIdentifier(input.id, `${path}.id`),
         name: requireString(input.name, `${path}.name`),
         description: requireString(input.description ?? '', `${path}.description`),
         type: requireString(input.type ?? '', `${path}.type`),
         maxLinks: requireNonNegativeInteger(input.maxLinks ?? 0, `${path}.maxLinks`),
-        availableTypes: (input.availableTypes ?? []).map((type, index) => requireString(type, `${path}.availableTypes[${index}]`)),
+        availableTypes: requireArray(input.availableTypes ?? [], `${path}.availableTypes`)
+            .map((type, index) => requireString(type, `${path}.availableTypes[${index}]`)),
         isDynamic: requireBoolean(input.isDynamic ?? false, `${path}.isDynamic`),
-        dynamicMode: requireString(input.dynamicMode ?? '', `${path}.dynamicMode`),
+        dynamicMode: requirePortDynamicMode(input.dynamicMode ?? '', `${path}.dynamicMode`),
         isSibling: requireBoolean(input.isSibling ?? false, `${path}.isSibling`),
         metadata: cloneJsonObject(input.metadata ?? {}, `${path}.metadata`),
     };
 }
 
-function normalizeParameter(input: DiagramParameterSchema, path: string): DiagramParameterSchema {
+function normalizeParameter(value: unknown, path: string): DiagramParameterSchema {
+    const input = requireStructure(value, path);
     return {
         name: requireIdentifier(input.name, `${path}.name`),
         displayName: requireString(input.displayName, `${path}.displayName`),
@@ -162,7 +176,8 @@ function normalizeParameter(input: DiagramParameterSchema, path: string): Diagra
     };
 }
 
-function normalizeLink(input: DiagramDocumentLinkInput & { id: string }, path: string): DiagramDocumentLink {
+function normalizeLink(value: unknown, path: string): DiagramDocumentLink {
+    const input = requireStructure(value, path);
     return {
         id: requireIdentifier(input.id, `${path}.id`),
         from: normalizeEndpoint(input.from, `${path}.from`),
@@ -171,7 +186,8 @@ function normalizeLink(input: DiagramDocumentLinkInput & { id: string }, path: s
     };
 }
 
-function normalizeEndpoint(input: DiagramDocumentEndpoint, path: string): DiagramDocumentEndpoint {
+function normalizeEndpoint(value: unknown, path: string): DiagramDocumentEndpoint {
+    const input = requireStructure(value, path);
     return {
         nodeId: requireIdentifier(input.nodeId, `${path}.nodeId`),
         portId: requireIdentifier(input.portId, `${path}.portId`),
@@ -179,7 +195,7 @@ function normalizeEndpoint(input: DiagramDocumentEndpoint, path: string): Diagra
 }
 
 function parseNode(value: unknown, path: string): DiagramDocumentNode {
-    const node = requireObject(value, path);
+    const node = requireStructure(value, path);
     return normalizeNode({
         id: requireString(node.id, `${path}.id`),
         typeId: requireString(node.typeId, `${path}.typeId`),
@@ -202,7 +218,7 @@ function parseNode(value: unknown, path: string): DiagramDocumentNode {
 }
 
 function parsePort(value: unknown, path: string): DiagramDocumentPort {
-    const port = requireObject(value, path);
+    const port = requireStructure(value, path);
     return normalizePort({
         id: requireString(port.id, `${path}.id`),
         name: requireString(port.name, `${path}.name`),
@@ -211,14 +227,14 @@ function parsePort(value: unknown, path: string): DiagramDocumentPort {
         maxLinks: requireNumber(port.maxLinks, `${path}.maxLinks`),
         availableTypes: requireArray(port.availableTypes, `${path}.availableTypes`).map((type, index) => requireString(type, `${path}.availableTypes[${index}]`)),
         isDynamic: requireBoolean(port.isDynamic, `${path}.isDynamic`),
-        dynamicMode: requireString(port.dynamicMode, `${path}.dynamicMode`),
+        dynamicMode: requirePortDynamicMode(port.dynamicMode, `${path}.dynamicMode`),
         isSibling: requireBoolean(port.isSibling, `${path}.isSibling`),
         metadata: cloneJsonObject(port.metadata, `${path}.metadata`),
     }, path);
 }
 
 function parseParameter(value: unknown, path: string): DiagramParameterSchema {
-    const parameter = requireObject(value, path);
+    const parameter = requireStructure(value, path);
     return normalizeParameter({
         name: requireString(parameter.name, `${path}.name`),
         displayName: requireString(parameter.displayName, `${path}.displayName`),
@@ -236,7 +252,7 @@ function parseParameter(value: unknown, path: string): DiagramParameterSchema {
 }
 
 function parseLink(value: unknown, path: string): DiagramDocumentLink {
-    const link = requireObject(value, path);
+    const link = requireStructure(value, path);
     return normalizeLink({
         id: requireString(link.id, `${path}.id`),
         from: parseEndpoint(link.from, `${path}.from`),
@@ -246,7 +262,7 @@ function parseLink(value: unknown, path: string): DiagramDocumentLink {
 }
 
 function parseEndpoint(value: unknown, path: string): DiagramDocumentEndpoint {
-    const endpoint = requireObject(value, path);
+    const endpoint = requireStructure(value, path);
     return {
         nodeId: requireIdentifier(endpoint.nodeId, `${path}.nodeId`),
         portId: requireIdentifier(endpoint.portId, `${path}.portId`),
@@ -298,7 +314,7 @@ function validateUniquePorts(ports: readonly DiagramDocumentPort[], path: string
 function cloneStringRecord(value: unknown, path: string): Record<string, string> {
     const object = requireObject(value, path);
     const result: Record<string, string> = {};
-    for (const [key, item] of Object.entries(object)) result[key] = requireString(item, `${path}.${key}`);
+    for (const [key, item] of Object.entries(object)) setJsonKey(result, key, requireString(item, `${path}.${key}`));
     return result;
 }
 
@@ -309,7 +325,7 @@ function cloneJsonObject(value: unknown, path: string, ancestors = new WeakSet<o
     const result: JsonObject = {};
     try {
         for (const [key, item] of Object.entries(object)) {
-            result[key] = cloneJsonValue(item, `${path}.${key}`, ancestors);
+            setJsonKey(result, key, cloneJsonValue(item, `${path}.${key}`, ancestors));
         }
     } finally {
         ancestors.delete(object);
@@ -333,6 +349,23 @@ function cloneJsonValue(value: unknown, path: string, ancestors: WeakSet<object>
     throw new DiagramDocumentError('expected a JSON value', path);
 }
 
+/**
+ * A container whose fields are read individually. Any object will do, including
+ * a class instance: hosts build schemes out of DiagramNode and Port, not object
+ * literals, and every field is validated on its own below.
+ */
+function requireStructure(value: unknown, path: string): Record<string, unknown> {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new DiagramDocumentError('expected an object', path);
+    }
+    return value as Record<string, unknown>;
+}
+
+/**
+ * A value that has to survive JSON round-tripping unchanged. Stricter than
+ * requireStructure on purpose: a Date or any other class instance would
+ * serialize to something the parser could not read back.
+ */
 function requireObject(value: unknown, path: string): Record<string, unknown> {
     if (!isObject(value)) throw new DiagramDocumentError('expected an object', path);
     return value;
@@ -344,6 +377,21 @@ function isObject(value: unknown): value is Record<string, unknown> {
     return prototype === Object.prototype || prototype === null;
 }
 
+/**
+ * Reads an optional array of objects, rejecting a non-array, a hole or a
+ * non-object element. null counts as absent, like the `?? []` every other
+ * optional field is read through.
+ */
+function mapElements(value: unknown, path: string): Record<string, unknown>[] {
+    if (value === undefined || value === null) return [];
+    // Array.from rather than map: map skips holes, carrying an undefined element
+    // into the result instead of reporting it.
+    return Array.from(
+        requireArray(value, path),
+        (element, index) => requireStructure(element, `${path}[${index}]`),
+    );
+}
+
 function requireArray(value: unknown, path: string): unknown[] {
     if (!Array.isArray(value)) throw new DiagramDocumentError('expected an array', path);
     return value;
@@ -354,6 +402,18 @@ function requireString(value: unknown, path: string): string {
     return value;
 }
 
+/**
+ * Coerces rather than rejects. The set is closed in the types, which is where a
+ * typo gets caught, but a persisted scheme can carry anything a JavaScript host
+ * wrote before that -- and refusing to load it would brick the whole document
+ * over a field whose every value except 'onConnect' behaves identically. The
+ * type must still be a string, so a number or an object is a real error.
+ */
+function requirePortDynamicMode(value: unknown, path: string): PortDynamicMode {
+    const mode = requireString(value, path);
+    return toPortDynamicMode(mode);
+}
+
 function requireIdentifier(value: unknown, path: string): string {
     const id = requireString(value, path);
     if (id.trim().length === 0) throw new DiagramDocumentError('identifier cannot be empty', path);

package/src/core/json.ts

@@ -0,0 +1,16 @@
+/**
+ * Stores a key that JSON can legitimately carry but plain assignment cannot hold.
+ *
+ * `JSON.parse` produces `__proto__` as an ordinary own key, yet writing it back
+ * with `target[key] = value` hits the inherited `__proto__` setter: the value is
+ * dropped and the object's prototype is replaced instead. A document parsed that
+ * way loses data and stops satisfying the parser's own "plain object" guard, so
+ * anything the parser accepted could no longer be serialized or cloned.
+ */
+export function setJsonKey<T>(target: Record<string, T>, key: string, value: T): void {
+    if (key === '__proto__') {
+        Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+        return;
+    }
+    target[key] = value;
+}

package/src/core/model.ts

@@ -20,6 +20,19 @@ export interface DiagramParameterSchema {
     editorType: string;
 }
 
+/**
+ * How a dynamic port grows. Only 'onConnect' makes the editor add a typed
+ * sibling when a link lands on the port; '' and 'manual' leave it to the host.
+ * The renderer compares this with ===, so a value outside the set silently
+ * selects the do-nothing branch -- hence a union rather than a string.
+ */
+export type PortDynamicMode = '' | 'manual' | 'onConnect';
+
+/** Narrows an untyped value to the closed set, defaulting to the inert mode. */
+export function toPortDynamicMode(value: unknown): PortDynamicMode {
+    return value === 'manual' || value === 'onConnect' ? value : '';
+}
+
 export interface DiagramDocumentPort {
     id: string;
     name: string;
@@ -28,7 +41,7 @@ export interface DiagramDocumentPort {
     maxLinks: number;
     availableTypes: string[];
     isDynamic: boolean;
-    dynamicMode: string;
+    dynamicMode: PortDynamicMode;
     isSibling: boolean;
     metadata: JsonObject;
 }

package/src/core/state.ts

@@ -1,3 +1,20 @@
+/**
+ * Recursively read-only view of a state object. The snapshot accessors hand back
+ * detached copies, so writing to one is silently discarded -- this makes that a
+ * compile error instead. The setters accept it, so a snapshot still round-trips.
+ */
+export type DiagramSnapshot<T> = {
+    readonly [K in keyof T]: DiagramSnapshotValue<T[K]>;
+};
+
+// Distributes over unions, so an optional or nullable object property keeps
+// being descended into instead of falling through as its writable self.
+type DiagramSnapshotValue<T> = T extends readonly (infer TItem)[]
+    ? readonly DiagramSnapshotValue<TItem>[]
+    : T extends object
+        ? DiagramSnapshot<T>
+        : T;
+
 export type DiagramPortDirection = 'in' | 'out';
 export type DiagramNodeErrorKind = 'runtime' | 'load';
 export type DiagramGlobalErrorKind = 'invalid' | 'load' | 'locked' | 'encrypted';
@@ -23,9 +40,18 @@ export interface DiagramNodePortRuntimeState {
     out: Record<string, DiagramPortRuntimeState>;
 }
 
+/**
+ * At most one error per kind. A node can carry a load error and a runtime error
+ * at the same time -- the tooltip shows both -- so a single slot could not hold
+ * what the editor already models, and every state write dropped one of them.
+ */
+export type DiagramNodeErrors = {
+    [TKind in DiagramNodeErrorKind]?: DiagramErrorState<TKind>;
+};
+
 export interface DiagramNodeRuntimeState {
     active: boolean;
-    error: DiagramErrorState<DiagramNodeErrorKind> | null;
+    errors: DiagramNodeErrors;
     ports: DiagramNodePortRuntimeState;
 }
 
@@ -77,7 +103,7 @@ export function cloneDiagramRuntimeState(state: DiagramRuntimeState): DiagramRun
         globalError: state.globalError === null ? null : { ...state.globalError },
         nodes: Object.fromEntries(Object.entries(state.nodes).map(([nodeId, node]) => [nodeId, {
             active: node.active,
-            error: node.error === null ? null : { ...node.error },
+            errors: cloneDiagramNodeErrors(node.errors),
             ports: {
                 in: Object.fromEntries(Object.entries(node.ports.in)
                     .map(([portId, port]) => [portId, { ...port }])),
@@ -142,7 +168,19 @@ export function createReadOnlyDiagramPermissions(): DiagramInteractionPermission
 export function createDiagramNodeRuntimeState(): DiagramNodeRuntimeState {
     return {
         active: false,
-        error: null,
+        errors: {},
         ports: { in: {}, out: {} },
     };
 }
+
+/**
+ * Tolerates a missing map: hosts persist runtime snapshots and build them by
+ * hand, so a state written before this field existed still has to be readable.
+ */
+export function cloneDiagramNodeErrors(errors: DiagramNodeErrors | undefined | null): DiagramNodeErrors {
+    const result: DiagramNodeErrors = {};
+    if (errors === undefined || errors === null) return result;
+    if (errors.runtime !== undefined) result.runtime = { ...errors.runtime };
+    if (errors.load !== undefined) result.load = { ...errors.load };
+    return result;
+}