@decaf-ts/ui-decorators 0.20.9 → 0.21.1

package/lib/esm/graph/snapshot.js

@@ -1,680 +0,0 @@
-import { graphLeafPortsOf, graphWorkflowDefinitionOf } from "./reader.js";
-import { isGraphJsonSafeValue } from "./document/GraphJsonValue.js";
-import { graphValueSchemaFromValidation, } from "./catalog/GraphValueSchemaDerivation.js";
-const GRAPH_LEGACY_BOUNDARY_ALIASES = ["$workflow", "workflow", "graph"];
-const GRAPH_CONSTRUCTOR_DATA_KEYS = [
-    "node",
-    "modelClass",
-    "sourceClass",
-    "constructor",
-    "definition",
-    "executor",
-];
-export const GRAPH_WORKFLOW_SNAPSHOT_VERSION = 1;
-function isPlainObject(value) {
-    return (!!value &&
-        typeof value === "object" &&
-        !Array.isArray(value) &&
-        !(value instanceof Date));
-}
-function cloneValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((entry) => cloneValue(entry));
-    }
-    if (value instanceof Date) {
-        return new Date(value.getTime());
-    }
-    if (isPlainObject(value)) {
-        const cloned = {};
-        for (const [key, entry] of Object.entries(value)) {
-            cloned[key] = cloneValue(entry);
-        }
-        return cloned;
-    }
-    return value;
-}
-function asString(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    return typeof value === "string" ? value : String(value);
-}
-function isWorkflowDefinitionLike(value) {
-    return (isPlainObject(value) &&
-        typeof value.name === "string" &&
-        typeof value.tag === "string" &&
-        typeof value.kind === "string" &&
-        Array.isArray(value.inputs) &&
-        Array.isArray(value.outputs) &&
-        Array.isArray(value.nodes) &&
-        Array.isArray(value.relations));
-}
-function snapshotNodeKey(node) {
-    return node.ref?.id ?? node.id ?? node.ref?.path ?? node.ref?.property;
-}
-function snapshotEdgeKey(edge) {
-    return (edge.id ??
-        [edge.sourceRef ?? edge.source, edge.sourcePort, edge.targetRef ?? edge.target, edge.targetPort]
-            .filter(Boolean)
-            .join("::"));
-}
-function normalizeValueEntries(entries, definitions) {
-    const byPath = new Map();
-    if (Array.isArray(entries)) {
-        for (const entry of entries) {
-            if (!entry?.path)
-                continue;
-            byPath.set(entry.path, cloneValue(entry));
-        }
-    }
-    else if (isPlainObject(entries)) {
-        for (const [path, value] of Object.entries(entries)) {
-            byPath.set(path, { path, value: cloneValue(value) });
-        }
-    }
-    const normalized = definitions.map((definition) => {
-        const path = definition.path ?? definition.property;
-        const current = byPath.get(path);
-        const entry = {
-            label: definition.label,
-            type: definition.type,
-            required: definition.required,
-            model: definition.model,
-            metadata: cloneValue(definition.graph?.metadata ??
-                definition.element?.props ??
-                definition.prop?.props ??
-                {}),
-            ...current,
-            path,
-        };
-        if (!Object.keys(entry.metadata || {}).length) {
-            delete entry.metadata;
-        }
-        return entry;
-    });
-    for (const entry of byPath.values()) {
-        if (normalized.some((current) => current.path === entry.path))
-            continue;
-        normalized.push(cloneValue(entry));
-    }
-    return normalized;
-}
-function normalizeNodes(nodes, definitions) {
-    const byKey = new Map();
-    const result = [];
-    for (const definition of definitions) {
-        const node = {
-            id: definition.id,
-            ref: {
-                id: definition.id,
-                kind: definition.kind,
-            },
-            label: definition.label,
-            kind: definition.kind,
-            data: definition.node !== undefined ? { node: cloneValue(definition.node) } : undefined,
-            metadata: cloneValue(definition.metadata),
-        };
-        result.push(node);
-        byKey.set(definition.id, node);
-    }
-    for (const entry of nodes || []) {
-        const key = snapshotNodeKey(entry);
-        const current = key ? byKey.get(key) : undefined;
-        if (current) {
-            const merged = {
-                ...current,
-                ...cloneValue(entry),
-                id: entry.id || current.id,
-                ref: {
-                    ...current.ref,
-                    ...entry.ref,
-                    id: entry.ref?.id ?? current.ref?.id ?? current.id,
-                },
-                position: entry.position ? cloneValue(entry.position) : current.position,
-                size: entry.size ? cloneValue(entry.size) : current.size,
-                ports: {
-                    ...(current.ports || {}),
-                    ...(entry.ports || {}),
-                },
-                data: {
-                    ...(current.data || {}),
-                    ...(entry.data || {}),
-                },
-                metadata: {
-                    ...(current.metadata || {}),
-                    ...(entry.metadata || {}),
-                },
-            };
-            if (key)
-                byKey.set(key, merged);
-            const index = result.findIndex((value) => value.id === current.id);
-            if (index >= 0)
-                result[index] = merged;
-            continue;
-        }
-        const cloned = cloneValue(entry);
-        result.push(cloned);
-        if (key)
-            byKey.set(key, cloned);
-    }
-    return result;
-}
-function normalizeEdges(edges, relations) {
-    const byKey = new Map();
-    const result = [];
-    for (const [index, relation] of relations.entries()) {
-        const source = asString(relation.source) ?? `source-${index}`;
-        const target = asString(relation.target) ?? `target-${index}`;
-        const edge = {
-            id: relation.label || `${source}:${relation.sourcePort ?? "*"}->${target}:${relation.targetPort ?? "*"}`,
-            source,
-            sourceRef: source,
-            sourcePort: relation.sourcePort,
-            target,
-            targetRef: target,
-            targetPort: relation.targetPort,
-            label: relation.label,
-            metadata: cloneValue(relation.metadata),
-        };
-        result.push(edge);
-        byKey.set(edge.id, edge);
-    }
-    for (const entry of edges || []) {
-        const key = snapshotEdgeKey(entry);
-        const current = key ? byKey.get(key) : undefined;
-        if (current) {
-            const merged = {
-                ...current,
-                ...cloneValue(entry),
-                id: entry.id || current.id,
-                source: entry.source || current.source,
-                sourceRef: entry.sourceRef ?? current.sourceRef ?? entry.source ?? current.source,
-                target: entry.target || current.target,
-                targetRef: entry.targetRef ?? current.targetRef ?? entry.target ?? current.target,
-                // Labels are document-carried display semantics (§4.4.7): a row merged
-                // from a canvas clone that never carried its own label must not erase
-                // the relation row's label.
-                label: entry.label ?? current.label,
-                metadata: {
-                    ...(current.metadata || {}),
-                    ...(entry.metadata || {}),
-                },
-            };
-            if (key)
-                byKey.set(key, merged);
-            const index = result.findIndex((value) => value.id === current.id);
-            if (index >= 0)
-                result[index] = merged;
-            continue;
-        }
-        const cloned = cloneValue(entry);
-        result.push(cloned);
-        if (key)
-            byKey.set(key, cloned);
-    }
-    return result;
-}
-function normalizeWorkflowDefinition(definition, overrides = {}) {
-    return {
-        name: overrides.name ?? definition.name,
-        tag: overrides.tag ?? definition.tag,
-        kind: overrides.kind ?? definition.kind,
-        category: overrides.category ?? definition.category,
-        color: overrides.color ?? definition.color,
-        group: overrides.group ?? definition.group,
-        height: overrides.height ?? definition.height,
-        icon: overrides.icon ?? definition.icon,
-        labels: cloneValue(overrides.labels ?? definition.labels ?? []),
-        maxChildren: overrides.maxChildren ?? definition.maxChildren,
-        minWidth: overrides.minWidth ?? definition.minWidth,
-        width: overrides.width ?? definition.width,
-        metadata: cloneValue(overrides.metadata ??
-            ("workflow" in definition ? definition.workflow : definition.metadata)),
-        inputs: cloneValue(overrides.inputs ?? definition.inputs ?? []),
-        outputs: cloneValue(overrides.outputs ?? definition.outputs ?? []),
-        nodes: cloneValue(overrides.nodes ?? definition.nodes ?? []),
-        relations: cloneValue(overrides.relations ?? definition.relations ?? []),
-    };
-}
-export function graphWorkflowSnapshotDefinitionOf(model) {
-    const definition = isWorkflowDefinitionLike(model)
-        ? model
-        : graphWorkflowDefinitionOf(model);
-    return normalizeWorkflowDefinition(definition);
-}
-export function graphWorkflowSnapshotOf(model, input) {
-    const normalizedDefinition = normalizeWorkflowDefinition(graphWorkflowSnapshotDefinitionOf(model), input?.definition);
-    const inputPorts = graphLeafPortsOf(normalizedDefinition.inputs);
-    const outputPorts = graphLeafPortsOf(normalizedDefinition.outputs);
-    return {
-        version: GRAPH_WORKFLOW_SNAPSHOT_VERSION,
-        definition: normalizedDefinition,
-        state: {
-            inputs: normalizeValueEntries(input?.inputs, inputPorts),
-            outputs: normalizeValueEntries(input?.outputs, outputPorts),
-            nodes: normalizeNodes(input?.nodes, normalizedDefinition.nodes),
-            edges: normalizeEdges(input?.edges, normalizedDefinition.relations),
-            ui: cloneValue(input?.ui || {}),
-            metadata: cloneValue(input?.metadata || {}),
-        },
-    };
-}
-export function graphWorkflowSnapshotRestore(snapshot, model) {
-    if (!("version" in snapshot)) {
-        return graphWorkflowSnapshotOf(model ??
-            snapshot.definition ??
-            {}, snapshot);
-    }
-    const fullSnapshot = snapshot;
-    const definition = model
-        ? graphWorkflowSnapshotDefinitionOf(model)
-        : fullSnapshot.definition;
-    return graphWorkflowSnapshotOf(definition, {
-        inputs: fullSnapshot.state.inputs,
-        outputs: fullSnapshot.state.outputs,
-        nodes: fullSnapshot.state.nodes,
-        edges: fullSnapshot.state.edges,
-        ui: fullSnapshot.state.ui,
-        metadata: fullSnapshot.state.metadata,
-    });
-}
-export function graphWorkflowSnapshotToJSON(snapshot, space) {
-    return JSON.stringify(snapshot, undefined, space);
-}
-export function graphWorkflowSnapshotFromJSON(input, model) {
-    const snapshot = typeof input === "string" ? JSON.parse(input) : input;
-    return graphWorkflowSnapshotRestore(snapshot, model);
-}
-export function graphWorkflowSnapshotInputValuesOf(snapshot) {
-    return Object.fromEntries(snapshot.state.inputs.map((entry) => [entry.path, cloneValue(entry.value)]));
-}
-export function graphWorkflowSnapshotOutputValuesOf(snapshot) {
-    return Object.fromEntries(snapshot.state.outputs.map((entry) => [entry.path, cloneValue(entry.value)]));
-}
-function dropUnsafeEntries(source) {
-    const result = {};
-    for (const [key, value] of Object.entries(source)) {
-        if (GRAPH_CONSTRUCTOR_DATA_KEYS.includes(key))
-            continue;
-        const sanitized = sanitizeToGraphJsonValue(value);
-        if (sanitized !== undefined)
-            result[key] = sanitized;
-    }
-    return result;
-}
-/**
- * Sanitizes a legacy snapshot into a JSON-safe payload while preserving its
- * structural keys (`version`, `definition`, `state`). Constructor-key stripping
- * still applies to the payload contents inside, so the canonical→legacy
- * round trip stays lossless for persisted data.
- */
-function sanitizeLegacySnapshotPayload(snapshot) {
-    return {
-        version: snapshot.version,
-        definition: dropUnsafeEntries((snapshot.definition ?? {})),
-        state: dropUnsafeEntries((snapshot.state ?? {})),
-    };
-}
-function sanitizeToGraphJsonValue(value) {
-    if (value === null)
-        return null;
-    const type = typeof value;
-    if (type === "string" || type === "boolean")
-        return value;
-    if (type === "number")
-        return Number.isFinite(value) ? value : undefined;
-    if (Array.isArray(value)) {
-        const items = [];
-        for (const item of value) {
-            const sanitized = sanitizeToGraphJsonValue(item);
-            if (sanitized !== undefined)
-                items.push(sanitized);
-        }
-        return items;
-    }
-    if (type === "object") {
-        return dropUnsafeEntries(value);
-    }
-    return undefined;
-}
-function boundaryAliasesFor(definition) {
-    const aliases = new Set(GRAPH_LEGACY_BOUNDARY_ALIASES);
-    if (definition.tag)
-        aliases.add(definition.tag);
-    if (definition.name)
-        aliases.add(definition.name);
-    return aliases;
-}
-function legacyEndpoint(refId, port, aliases, boundaryPortIds) {
-    const resolvedPort = port ?? "";
-    if (!refId || aliases.has(refId)) {
-        return { scope: "workflow", port: resolvedPort };
-    }
-    // The legacy decorated-root canvas rendered workflow input ports as draggable
-    // boundary badges (`input-{port}`, port handle `value`). Those bindings stay
-    // lossless only when the badge id folds back onto the workflow port it was
-    // drawn for (DECAF-50 §4.11); otherwise a workflow port would collapse into
-    // one shared boundary endpoint and drop real edges (§4.4.6 canonical form).
-    if (refId.startsWith("input-")) {
-        const workflowPortId = boundaryPortIds?.get(refId.slice("input-".length) ?? "");
-        if (workflowPortId) {
-            return {
-                scope: "workflow",
-                port: workflowPortId,
-            };
-        }
-    }
-    return { scope: "node", nodeId: refId, port: resolvedPort };
-}
-/**
- * Maps workflow input-property names to their legacy boundary-badge ids
- * (`input-{property}`), so badges drawn on the canvas resolve back to the
- * workflow port they represent (§4.11).
- */
-function boundaryPortIdsFor(snapshot) {
-    const map = new Map();
-    for (const port of snapshot.definition.inputs) {
-        map.set(`input-${port.property}`, port.property);
-    }
-    return map;
-}
-/**
- * Resolves the decorated definition's own edge labels by canonical endpoint
- * pair, so converted legacy edges that never carried a label on the edge row
- * (canvas-drawn clones merged over the relation rows) still restore the
- * document-carried {@link GraphEdgeInstance.label} (§4.4.7) instead of losing
- * the display affordance on save/reload.
- */
-function legacyRelationLabelByEndpoint(snapshot, aliases, boundaryPortIds) {
-    const map = new Map();
-    for (const relation of snapshot.definition.relations) {
-        const label = typeof relation.label === "string" ? relation.label : undefined;
-        if (!label)
-            continue;
-        const sourceRef = typeof relation.source === "string" ? relation.source : undefined;
-        const targetRef = typeof relation.target === "string" ? relation.target : undefined;
-        map.set(edgePairKeyOf({
-            source: legacyEndpoint(sourceRef, relation.sourcePort, aliases, boundaryPortIds),
-            target: legacyEndpoint(targetRef, relation.targetPort, aliases, boundaryPortIds),
-        }), label);
-    }
-    return map;
-}
-function endpointToLegacyRef(endpoint) {
-    if (endpoint.scope === "workflow") {
-        return { refId: "$workflow", port: endpoint.port };
-    }
-    return { refId: endpoint.nodeId, port: endpoint.port };
-}
-function portInstanceFromDefinition(port, value) {
-    const instance = {
-        id: port.property,
-        label: port.label,
-    };
-    instance.schema = graphValueSchemaFromValidation(port.validation, port.type, port.model);
-    if (port.required)
-        instance.required = true;
-    if (value !== undefined)
-        instance.defaultValue = value;
-    const metadata = sanitizeToGraphJsonValue(port.graph ?? {});
-    if (metadata && Object.keys(metadata).length)
-        instance.metadata = metadata;
-    return instance;
-}
-function inputBindingsFromPorts(ports) {
-    if (!ports)
-        return undefined;
-    const bindings = {};
-    for (const [property, port] of Object.entries(ports)) {
-        if (port?.mode === "port") {
-            bindings[property] = { mode: "edge" };
-        }
-        else if ("value" in (port ?? {})) {
-            const value = sanitizeToGraphJsonValue(port.value);
-            bindings[property] = { mode: "literal", value: value ?? null };
-        }
-    }
-    return Object.keys(bindings).length ? bindings : undefined;
-}
-function nodeInstanceFromLegacy(node) {
-    const instance = {
-        id: node.id,
-        kind: node.kind ?? node.ref?.kind ?? node.id,
-        parameters: dropUnsafeEntries(node.data ?? {}),
-    };
-    if (node.label)
-        instance.label = node.label;
-    const bindings = inputBindingsFromPorts(node.ports);
-    if (bindings)
-        instance.inputBindings = bindings;
-    const metadata = sanitizeToGraphJsonValue(node.metadata ?? {});
-    if (metadata && Object.keys(metadata).length)
-        instance.metadata = metadata;
-    if (node.position || node.size || node.expanded !== undefined) {
-        const ui = {
-            position: node.position ? { x: node.position.x, y: node.position.y } : { x: 0, y: 0 },
-        };
-        if (node.size)
-            ui.size = { width: node.size.width, height: node.size.height };
-        if (node.expanded !== undefined)
-            ui.expanded = node.expanded;
-        instance.ui = ui;
-    }
-    return instance;
-}
-function edgeInstanceFromLegacy(edge, aliases, boundaryPortIds, relationLabelByPair) {
-    const source = legacyEndpoint(edge.sourceRef ?? edge.source, edge.sourcePort, aliases, boundaryPortIds);
-    const target = legacyEndpoint(edge.targetRef ?? edge.target, edge.targetPort, aliases, boundaryPortIds);
-    const instance = {
-        id: edge.id,
-        type: "data",
-        source,
-        target,
-    };
-    const label = edge.label ?? relationLabelByPair?.get(edgePairKeyOf({ source, target }));
-    if (label)
-        instance.label = label;
-    const metadata = sanitizeToGraphJsonValue(edge.metadata ?? {});
-    if (metadata && Object.keys(metadata).length)
-        instance.metadata = metadata;
-    return instance;
-}
-/** Endpoint-pair key for edge identity (canonical `GraphEndpoint` shape). */
-function edgePairKeyOf(edge) {
-    const keyOf = (endpoint) => endpoint.scope === "node"
-        ? `node:${endpoint.nodeId}:${endpoint.port}`
-        : `workflow:${endpoint.port}`;
-    return `${keyOf(edge.source)}->${keyOf(edge.target)}`;
-}
-/**
- * Maps a legacy (pre-P7) canvas snapshot to the canonical
- * {@link GraphWorkflowDocument} (DECAF-50 §4.4.6): legacy `node.data` becomes
- * instance `parameters`, legacy `node.metadata` becomes instance `metadata`,
- * workflow boundary badges (`input-{port}`) fold back onto their workflow
- * ports, and edge labels missing from cloned edge rows are restored from the
- * decorated definition's relation labels (§4.4.7).
- */
-export function graphWorkflowDocumentFromLegacySnapshot(snapshot) {
-    const aliases = boundaryAliasesFor(snapshot.definition);
-    const boundaryPortIds = boundaryPortIdsFor(snapshot);
-    const relationLabelByPair = legacyRelationLabelByEndpoint(snapshot, aliases, boundaryPortIds);
-    const inputs = Object.fromEntries(snapshot.state.inputs.map((entry) => [entry.path, sanitizeToGraphJsonValue(entry.value)]));
-    const outputs = Object.fromEntries(snapshot.state.outputs.map((entry) => [entry.path, sanitizeToGraphJsonValue(entry.value)]));
-    const document = {
-        id: snapshot.definition.tag || snapshot.definition.name,
-        name: snapshot.definition.name,
-        inputs: snapshot.definition.inputs.map((port) => portInstanceFromDefinition(port, inputs[port.property])),
-        outputs: snapshot.definition.outputs.map((port) => portInstanceFromDefinition(port, outputs[port.property])),
-        nodes: snapshot.state.nodes.map(nodeInstanceFromLegacy),
-        edges: snapshot.state.edges.map((edge) => edgeInstanceFromLegacy(edge, aliases, boundaryPortIds, relationLabelByPair)),
-    };
-    if (snapshot.definition.metadata) {
-        const metadata = sanitizeToGraphJsonValue(snapshot.definition.metadata);
-        if (metadata && Object.keys(metadata).length)
-            document.metadata = metadata;
-    }
-    const ui = {};
-    const viewport = snapshot.state.ui?.["diagramMetadata"];
-    const parsedViewport = viewport?.["viewport"];
-    if (parsedViewport && typeof parsedViewport === "object") {
-        const v = parsedViewport;
-        const x = typeof v["x"] === "number" ? v["x"] : Number(v["x"]) || 0;
-        const y = typeof v["y"] === "number" ? v["y"] : Number(v["y"]) || 0;
-        const zoom = typeof v["scale"] === "number" ? v["scale"] : Number(v["scale"]) || 1;
-        ui.viewport = { x, y, zoom };
-    }
-    if (ui.viewport)
-        document.ui = ui;
-    return document;
-}
-/**
- * Converts a legacy persisted snapshot into the canonical wrapper. The canonical
- * `document` carries executable semantics; `editor.legacy` keeps the sanitized
- * (constructor-free) legacy payload so a canonical→legacy round trip is lossless
- * for persisted data.
- */
-export function graphWorkflowSnapshotFromLegacy(snapshot) {
-    const document = graphWorkflowDocumentFromLegacySnapshot(snapshot);
-    const editor = {};
-    const sanitizedLegacy = sanitizeLegacySnapshotPayload(snapshot);
-    if (sanitizedLegacy && isGraphJsonSafeValue(sanitizedLegacy))
-        editor.legacy = sanitizedLegacy;
-    const ui = snapshot.state.ui;
-    if (ui) {
-        const duplicateCounts = ui["duplicateCounts"];
-        if (duplicateCounts && typeof duplicateCounts === "object") {
-            editor.duplicateCounts = duplicateCounts;
-        }
-        const diagramMetadata = ui["diagramMetadata"];
-        if (diagramMetadata && typeof diagramMetadata === "object") {
-            editor.diagramMetadata = sanitizeToGraphJsonValue(diagramMetadata);
-        }
-        const nodeConfigs = ui["nodeConfigs"];
-        if (nodeConfigs && typeof nodeConfigs === "object") {
-            editor.nodeConfigs = sanitizeToGraphJsonValue(nodeConfigs);
-        }
-    }
-    editor.nodePorts = {};
-    for (const node of snapshot.state.nodes) {
-        if (node.ports) {
-            editor.nodePorts[node.id] = sanitizeToGraphJsonValue(node.ports);
-        }
-    }
-    if (!Object.keys(editor.nodePorts).length)
-        delete editor.nodePorts;
-    const definitionDisplay = dropUnsafeEntries(snapshot.definition);
-    delete definitionDisplay["inputs"];
-    delete definitionDisplay["outputs"];
-    delete definitionDisplay["nodes"];
-    delete definitionDisplay["relations"];
-    editor.definitionDisplay = definitionDisplay;
-    const metadata = sanitizeToGraphJsonValue(snapshot.state.metadata ?? {});
-    return { document, editor, metadata: Object.keys(metadata).length ? metadata : undefined };
-}
-/**
- * Reconstructs a legacy snapshot from a canonical wrapper. Uses the
- * `editor.legacy` payload when present for exact round trips; otherwise it
- * rebuilds a best-effort legacy snapshot from the document + editor state
- * (constructors are never restored).
- */
-export function graphWorkflowSnapshotToLegacy(snapshot) {
-    if (snapshot.editor?.legacy && isGraphJsonSafeValue(snapshot.editor.legacy)) {
-        return cloneValue(snapshot.editor.legacy);
-    }
-    const { document, editor } = snapshot;
-    const aliases = new Set(GRAPH_LEGACY_BOUNDARY_ALIASES);
-    if (document.id)
-        aliases.add(document.id);
-    if (document.name)
-        aliases.add(document.name);
-    const display = (editor?.definitionDisplay ?? {});
-    const definition = {
-        ...cloneValue(display),
-        name: document.name,
-        tag: document.id || display["tag"] || document.name,
-        inputs: document.inputs.map((port) => portToLegacyDefinition(port)),
-        outputs: document.outputs.map((port) => portToLegacyDefinition(port)),
-        nodes: document.nodes.map((node) => ({ id: node.id, kind: node.kind })),
-        relations: document.edges.map((edge) => ({
-            id: edge.id,
-            source: endpointToLegacyRef(edge.source).refId,
-            sourcePort: edge.source.port,
-            target: endpointToLegacyRef(edge.target).refId,
-            targetPort: edge.target.port,
-            label: edge.label,
-        })),
-    };
-    const state = {
-        inputs: document.inputs.map((port) => ({
-            path: port.id,
-            value: cloneValue(port.defaultValue),
-            label: port.label,
-            required: port.required,
-        })),
-        outputs: document.outputs.map((port) => ({
-            path: port.id,
-            value: cloneValue(port.defaultValue),
-            label: port.label,
-            required: port.required,
-        })),
-        nodes: document.nodes.map((node) => ({
-            id: node.id,
-            ref: { id: node.id, kind: node.kind },
-            label: node.label,
-            kind: node.kind,
-            position: node.ui?.position ? { x: node.ui.position.x, y: node.ui.position.y } : undefined,
-            size: node.ui?.size ? { width: node.ui.size.width, height: node.ui.size.height } : undefined,
-            expanded: node.ui?.expanded,
-            ports: editor?.nodePorts?.[node.id] ?? undefined,
-            data: cloneValue(node.parameters ?? {}),
-            metadata: cloneValue(node.metadata ?? {}),
-        })),
-        edges: document.edges.map((edge) => {
-            const source = endpointToLegacyRef(edge.source);
-            const target = endpointToLegacyRef(edge.target);
-            const isBoundary = source.refId === "$workflow" || target.refId === "$workflow";
-            const isConnection = edge.type === "connection";
-            return {
-                id: edge.id,
-                source: source.refId,
-                sourceRef: source.refId,
-                sourcePort: source.port,
-                target: target.refId,
-                targetRef: target.refId,
-                targetPort: target.port,
-                label: edge.label,
-                type: isConnection ? "connection" : isBoundary ? "output" : "data",
-                metadata: cloneValue(edge.metadata ?? {}),
-            };
-        }),
-        ui: cloneValue({
-            ...(editor?.duplicateCounts ? { duplicateCounts: editor.duplicateCounts } : {}),
-            ...(editor?.diagramMetadata ? { diagramMetadata: editor.diagramMetadata } : {}),
-            ...(editor?.nodeConfigs ? { nodeConfigs: editor.nodeConfigs } : {}),
-        }),
-        metadata: cloneValue(snapshot.metadata ?? {}),
-    };
-    return {
-        version: GRAPH_WORKFLOW_SNAPSHOT_VERSION,
-        definition,
-        state,
-    };
-}
-function portToLegacyDefinition(port) {
-    return {
-        property: port.id,
-        label: port.label,
-        required: port.required,
-        metadata: cloneValue(port.metadata ?? {}),
-    };
-}
-/** Normalizes any accepted snapshot/document form to a canonical wrapper. */
-export function graphWorkflowSnapshotLikeToCanonical(value) {
-    if ("document" in value) {
-        return value;
-    }
-    if ("state" in value || "definition" in value) {
-        return graphWorkflowSnapshotFromLegacy(value);
-    }
-    return { document: value };
-}
-//# sourceMappingURL=snapshot.js.map