@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/serialization/Incremental.js

@@ -1,227 +0,0 @@
-"use strict";
-// Incremental (diff) serialization — per-transaction deltas instead of full
-// snapshots. The substrate for autosave, DB persistence, and multiplayer sync
-// (GoJS's toIncrementalJson/applyIncrementalJson is the reference model).
-//
-// Capture side (this file): IncrementalCapture subscribes to a live diagram's
-// event stream and coalesces mutations between commits into a patch:
-//   - added:    full serialized entities (created since last commit)
-//   - removed:  ids
-//   - modified: full serialized entities (REPLACE semantics — deterministic,
-//                and immune to the changeLog ring-buffer truncation that a
-//                per-property delta would depend on)
-//   - diagram:  name/viewport/metadata when they changed
-// add+remove of the same entity within one window coalesces to a no-op.
-//
-// Apply side: DiagramModel.applyIncremental(patch) — lives on the model (it
-// needs the private indices) and installs added entities through the SAME
-// unified restore path as document load, updates modified entities IN PLACE
-// (object identity preserved for renderers holding references), and fires
-// normal change events so listeners repaint.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IncrementalCapture = exports.INCREMENTAL_FORMAT = void 0;
-exports.beginIncrementalCapture = beginIncrementalCapture;
-const DiagramMigrations_1 = require("./DiagramMigrations");
-exports.INCREMENTAL_FORMAT = 'grafloria-incremental';
-const emptyIds = () => ({ added: new Set(), removed: new Set(), modified: new Set() });
-/**
- * Watches a live diagram and produces a DiagramIncremental per commit().
- * Continues capturing after commit (autosave-loop friendly) until stop().
- */
-class IncrementalCapture {
-    constructor(diagram) {
-        this.diagram = diagram;
-        this.nodes = emptyIds();
-        this.links = emptyIds();
-        this.groups = emptyIds();
-        this.strokes = emptyIds(); // wave10/whiteboard
-        this.disposers = [];
-        this.groupDisposers = new Map();
-        this.stopped = false;
-        this.baseVersion = diagram.version;
-        this.nameSnapshot = diagram.name;
-        this.viewportSnapshot = JSON.stringify(diagram.viewport);
-        this.metadataSnapshot = JSON.stringify(Object.fromEntries(diagram.metadata));
-        const track = (ids) => ({
-            added: (entity) => {
-                if (ids.removed.has(entity.id)) {
-                    // removed then re-added inside one window = a modification
-                    ids.removed.delete(entity.id);
-                    ids.modified.add(entity.id);
-                }
-                else {
-                    ids.added.add(entity.id);
-                }
-            },
-            removed: (entity) => {
-                if (ids.added.has(entity.id)) {
-                    // add+remove inside one window coalesces to a no-op
-                    ids.added.delete(entity.id);
-                }
-                else {
-                    ids.removed.add(entity.id);
-                }
-                ids.modified.delete(entity.id);
-            },
-            changed: (entity) => {
-                if (!ids.added.has(entity.id) && !ids.removed.has(entity.id)) {
-                    ids.modified.add(entity.id);
-                }
-            },
-        });
-        const n = track(this.nodes);
-        const l = track(this.links);
-        const g = track(this.groups);
-        const s = track(this.strokes); // wave10/whiteboard
-        this.disposers.push(
-        // Ink. Strokes are immutable after commit (you draw one, you erase one — you do
-        // not edit one point-by-point), so unlike groups there is no per-entity change
-        // stream to watch. If stroke editing ever lands, it needs a watchStroke() exactly
-        // like watchGroup() below, or the edit will not reach this channel.
-        diagram.on('stroke:added', s.added), diagram.on('stroke:removed', s.removed), diagram.on('node:added', n.added), diagram.on('node:removed', n.removed), diagram.on('node:changed', n.changed), 
-        // moves/resizes are forwarded as dedicated events, not node:changed
-        diagram.on('node:moved', ({ nodeId }) => n.changed({ id: nodeId })), diagram.on('node:resized', ({ nodeId }) => n.changed({ id: nodeId })), diagram.on('link:added', l.added), diagram.on('link:removed', l.removed), diagram.on('link:changed', l.changed), diagram.on('group:added', (group) => {
-            g.added(group);
-            this.watchGroup(group.id);
-        }), diagram.on('group:removed', (group) => {
-            g.removed(group);
-            this.unwatchGroup(group.id);
-        }));
-        // Group mutations are NOT forwarded at diagram level — watch each group's
-        // own change stream (and every group that appears while capturing).
-        for (const group of diagram.getGroups()) {
-            this.watchGroup(group.id);
-        }
-    }
-    watchGroup(groupId) {
-        if (this.groupDisposers.has(groupId))
-            return;
-        const group = this.diagram.getGroup(groupId);
-        if (!group)
-            return;
-        this.groupDisposers.set(groupId, group.on('change', () => {
-            if (!this.groups.added.has(groupId) && !this.groups.removed.has(groupId)) {
-                this.groups.modified.add(groupId);
-            }
-        }));
-    }
-    unwatchGroup(groupId) {
-        var _a;
-        (_a = this.groupDisposers.get(groupId)) === null || _a === void 0 ? void 0 : _a();
-        this.groupDisposers.delete(groupId);
-    }
-    /** Anything captured since the window began? */
-    hasChanges() {
-        const any = (ids) => ids.added.size + ids.removed.size + ids.modified.size > 0;
-        return (any(this.nodes) ||
-            any(this.links) ||
-            any(this.groups) ||
-            any(this.strokes) ||
-            this.diagramChanges() !== undefined);
-    }
-    diagramChanges() {
-        const out = {};
-        if (this.diagram.name !== this.nameSnapshot)
-            out.name = this.diagram.name;
-        if (JSON.stringify(this.diagram.viewport) !== this.viewportSnapshot) {
-            out.viewport = Object.assign({}, this.diagram.viewport);
-        }
-        const metadata = Object.fromEntries(this.diagram.metadata);
-        if (JSON.stringify(metadata) !== this.metadataSnapshot)
-            out.metadata = metadata;
-        return Object.keys(out).length ? out : undefined;
-    }
-    /**
-     * Drain the window into a patch (null when nothing changed) and keep
-     * capturing. Added/modified entities are serialized LIVE at commit time,
-     * so intra-window churn costs nothing.
-     */
-    commit() {
-        if (this.stopped) {
-            throw new Error('IncrementalCapture is stopped');
-        }
-        if (!this.hasChanges())
-            return null;
-        const serializeNodes = (ids) => [...ids]
-            .map((id) => { var _a; return (_a = this.diagram.getNode(id)) === null || _a === void 0 ? void 0 : _a.serialize(); })
-            .filter((d) => !!d);
-        const serializeLinks = (ids) => [...ids]
-            .map((id) => { var _a; return (_a = this.diagram.getLink(id)) === null || _a === void 0 ? void 0 : _a.serialize(); })
-            .filter((d) => !!d);
-        const serializeGroups = (ids) => [...ids]
-            .map((id) => { var _a; return (_a = this.diagram.getGroup(id)) === null || _a === void 0 ? void 0 : _a.serialize(); })
-            .filter((d) => !!d);
-        const serializeStrokes = (ids) => [...ids]
-            .map((id) => { var _a; return (_a = this.diagram.getStroke(id)) === null || _a === void 0 ? void 0 : _a.serialize(); })
-            .filter((d) => !!d);
-        const patch = {
-            format: exports.INCREMENTAL_FORMAT,
-            schemaVersion: DiagramMigrations_1.DIAGRAM_SCHEMA_VERSION,
-            baseVersion: this.baseVersion,
-            targetVersion: this.diagram.version,
-            added: {
-                nodes: serializeNodes(this.nodes.added),
-                links: serializeLinks(this.links.added),
-                groups: serializeGroups(this.groups.added),
-            },
-            removed: {
-                nodes: [...this.nodes.removed],
-                links: [...this.links.removed],
-                groups: [...this.groups.removed],
-            },
-            modified: {
-                nodes: serializeNodes(this.nodes.modified),
-                links: serializeLinks(this.links.modified),
-                groups: serializeGroups(this.groups.modified),
-            },
-        };
-        // wave10/whiteboard: written only when there IS ink in the window, so a patch from a
-        // diagram nobody has drawn on is byte-identical to the one this class emitted before
-        // this wave. (Same rule as the document's `strokes` key.)
-        if (this.strokes.added.size)
-            patch.added.strokes = serializeStrokes(this.strokes.added);
-        if (this.strokes.removed.size)
-            patch.removed.strokes = [...this.strokes.removed];
-        if (this.strokes.modified.size) {
-            patch.modified.strokes = serializeStrokes(this.strokes.modified);
-        }
-        const diagramDelta = this.diagramChanges();
-        if (diagramDelta)
-            patch.diagram = diagramDelta;
-        // Reset the window IN PLACE — the event listeners hold references to
-        // these exact Ids objects (bound in the constructor); reassigning would
-        // orphan them and silently stop capture after the first commit.
-        const resetIds = (ids) => {
-            ids.added.clear();
-            ids.removed.clear();
-            ids.modified.clear();
-        };
-        resetIds(this.nodes);
-        resetIds(this.links);
-        resetIds(this.groups);
-        resetIds(this.strokes);
-        this.baseVersion = this.diagram.version;
-        this.nameSnapshot = this.diagram.name;
-        this.viewportSnapshot = JSON.stringify(this.diagram.viewport);
-        this.metadataSnapshot = JSON.stringify(Object.fromEntries(this.diagram.metadata));
-        return patch;
-    }
-    /** Unsubscribe everything. The capture cannot be reused afterwards. */
-    stop() {
-        if (this.stopped)
-            return;
-        this.stopped = true;
-        for (const dispose of this.disposers)
-            dispose();
-        this.disposers = [];
-        for (const dispose of this.groupDisposers.values())
-            dispose();
-        this.groupDisposers.clear();
-    }
-}
-exports.IncrementalCapture = IncrementalCapture;
-/** Convenience: start watching a diagram for incremental commits. */
-function beginIncrementalCapture(diagram) {
-    return new IncrementalCapture(diagram);
-}
-//# sourceMappingURL=Incremental.js.map

package/src/libs/engine/src/serialization/Serializer.d.ts

@@ -1,29 +0,0 @@
-import { DiagramModel } from '../models/DiagramModel';
-import type { SerializedDiagram as DiagramSerializedData, DiagramLoadOptions } from '../models/DiagramModel';
-import type { DiagramMode } from '../engine/DiagramMode';
-import { type DiagramDocumentEnvelope, type WrapOptions } from './DocumentEnvelope';
-export interface SerializedDiagram extends Omit<DiagramSerializedData, 'version'> {
-    version: string;
-    diagramVersion?: number;
-    mode?: DiagramMode;
-}
-export declare class DiagramSerializer {
-    private readonly VERSION;
-    /**
-     * Serialize diagram to plain object
-     */
-    serialize(diagram: DiagramModel): SerializedDiagram;
-    /**
-     * Serialize wrapped in the portable document envelope (generator identity,
-     * createdAt, integrity checksum). The envelope is the recommended shape for
-     * NEW persistence; deserialize() accepts both it and the legacy flat form.
-     */
-    serializeEnvelope(diagram: DiagramModel, options?: WrapOptions): DiagramDocumentEnvelope;
-    /**
-     * Deserialize diagram from plain object — accepts the enveloped document,
-     * the legacy Serializer flat form, or a raw DiagramModel.serialize payload.
-     * Envelope checksums are verified (mismatch throws — corruption must never
-     * load silently).
-     */
-    deserialize(data: SerializedDiagram | DiagramDocumentEnvelope, options?: DiagramLoadOptions): DiagramModel;
-}

package/src/libs/engine/src/serialization/Serializer.js

@@ -1,45 +0,0 @@
-"use strict";
-// DiagramSerializer - Handles diagram serialization/deserialization
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagramSerializer = void 0;
-const DiagramModel_1 = require("../models/DiagramModel");
-const DocumentEnvelope_1 = require("./DocumentEnvelope");
-class DiagramSerializer {
-    constructor() {
-        this.VERSION = '1.0.0';
-    }
-    /**
-     * Serialize diagram to plain object
-     */
-    serialize(diagram) {
-        const serialized = diagram.serialize();
-        // Override version with serializer format version
-        return Object.assign(Object.assign({}, serialized), { version: this.VERSION, diagramVersion: serialized.version });
-    }
-    /**
-     * Serialize wrapped in the portable document envelope (generator identity,
-     * createdAt, integrity checksum). The envelope is the recommended shape for
-     * NEW persistence; deserialize() accepts both it and the legacy flat form.
-     */
-    serializeEnvelope(diagram, options) {
-        return (0, DocumentEnvelope_1.wrapDiagramDocument)(diagram.serialize(), options);
-    }
-    /**
-     * Deserialize diagram from plain object — accepts the enveloped document,
-     * the legacy Serializer flat form, or a raw DiagramModel.serialize payload.
-     * Envelope checksums are verified (mismatch throws — corruption must never
-     * load silently).
-     */
-    deserialize(data, options) {
-        if ((0, DocumentEnvelope_1.isDiagramDocumentEnvelope)(data)) {
-            const { document } = (0, DocumentEnvelope_1.unwrapDiagramDocument)(data);
-            return DiagramModel_1.DiagramModel.fromJSON(document, options);
-        }
-        // Legacy flat form: convert back to diagram format
-        const diagramData = Object.assign(Object.assign({}, data), { version: data.diagramVersion || Number(data.version) || 1 });
-        // Use static fromJSON method (migrations + optional validation run there)
-        return DiagramModel_1.DiagramModel.fromJSON(diagramData, options);
-    }
-}
-exports.DiagramSerializer = DiagramSerializer;
-//# sourceMappingURL=Serializer.js.map

package/src/libs/engine/src/serialization/Subgraph.d.ts

@@ -1,51 +0,0 @@
-import { DiagramModel } from '../models/DiagramModel';
-import { NodeModel, type SerializedNode } from '../models/NodeModel';
-import { LinkModel, type SerializedLink } from '../models/LinkModel';
-import { GroupModel, type SerializedGroup } from '../models/GroupModel';
-import type { Point } from '../types';
-export declare const SUBGRAPH_FORMAT: "grafloria-subgraph";
-export interface SerializedSubgraph {
-    format: typeof SUBGRAPH_FORMAT;
-    schemaVersion: number;
-    sourceDiagramId?: string;
-    nodes: SerializedNode[];
-    links: SerializedLink[];
-    groups: SerializedGroup[];
-    /** Links that crossed the selection boundary and were therefore excluded. */
-    boundaryLinks: Array<{
-        linkId: string;
-        insideEnd: 'source' | 'target';
-    }>;
-}
-export interface SubgraphSelection {
-    nodeIds: Iterable<string>;
-    groupIds?: Iterable<string>;
-}
-export declare function serializeSubgraph(diagram: DiagramModel, selection: SubgraphSelection): SerializedSubgraph;
-export interface DeserializeSubgraphOptions {
-    /**
-     * Mint fresh ids/uuids for every entity (default true). Turn off only when
-     * importing into a diagram KNOWN not to contain the ids (e.g. template
-     * instantiation into an empty document where stable ids are wanted).
-     */
-    remapIds?: boolean;
-    /** Translate all node/group positions by this delta (paste-at-cursor). */
-    offset?: Point;
-}
-export interface DeserializedSubgraph {
-    nodes: NodeModel[];
-    links: LinkModel[];
-    groups: GroupModel[];
-    /** oldId -> newId for nodes and groups (identity map when remapIds=false). */
-    idMap: Map<string, string>;
-    /** oldPortId -> newPortId (identity when remapIds=false). */
-    portIdMap: Map<string, string>;
-}
-/**
- * Install a subgraph into a live diagram through the unified restore path.
- *
- * This is a USER MUTATION (unlike document load): entities are installed via
- * restore* so the normal node:added/link:added events fire for undo and
- * rendering, and port registries are reconciled at the end.
- */
-export declare function deserializeSubgraphInto(diagram: DiagramModel, subgraph: SerializedSubgraph, options?: DeserializeSubgraphOptions): DeserializedSubgraph;

package/src/libs/engine/src/serialization/Subgraph.js

@@ -1,172 +0,0 @@
-"use strict";
-// First-class subgraph serialization — ONE code path for clipboard fragments,
-// templates, and cross-diagram slices.
-//
-// serializeSubgraph captures a selection as a self-contained document: the
-// selected nodes, every link whose BOTH endpoints live inside the selection,
-// and the selected groups with their membership filtered to the selection.
-// Links that cross the boundary are recorded (not silently dropped) so
-// callers can surface them.
-//
-// deserializeSubgraphInto installs a subgraph into a live diagram through the
-// SAME unified restore path as document load (fully wired entities), with
-// id/uuid remapping on by default — pasting twice must yield two independent
-// copies, never id collisions.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUBGRAPH_FORMAT = void 0;
-exports.serializeSubgraph = serializeSubgraph;
-exports.deserializeSubgraphInto = deserializeSubgraphInto;
-const NodeModel_1 = require("../models/NodeModel");
-const remapNodePortIds_1 = require("../commands/basic/remapNodePortIds");
-const id_1 = require("../utils/id");
-const DiagramMigrations_1 = require("./DiagramMigrations");
-exports.SUBGRAPH_FORMAT = 'grafloria-subgraph';
-function serializeSubgraph(diagram, selection) {
-    var _a;
-    const nodeIds = new Set(selection.nodeIds);
-    const groupIds = new Set((_a = selection.groupIds) !== null && _a !== void 0 ? _a : []);
-    const nodes = [];
-    const selectedPortIds = new Set();
-    for (const nodeId of nodeIds) {
-        const node = diagram.getNode(nodeId);
-        if (!node)
-            continue;
-        nodes.push(node.serialize());
-        for (const port of node.getPorts()) {
-            selectedPortIds.add(port.id);
-        }
-    }
-    const links = [];
-    const boundaryLinks = [];
-    for (const link of diagram.getLinks()) {
-        const sourceIn = selectedPortIds.has(link.sourcePortId);
-        const targetIn = selectedPortIds.has(link.targetPortId);
-        if (sourceIn && targetIn) {
-            links.push(link.serialize());
-        }
-        else if (sourceIn || targetIn) {
-            boundaryLinks.push({ linkId: link.id, insideEnd: sourceIn ? 'source' : 'target' });
-        }
-    }
-    const groups = [];
-    for (const groupId of groupIds) {
-        const group = diagram.getGroup(groupId);
-        if (!group)
-            continue;
-        const serialized = group.serialize();
-        // Self-containment: membership and containment pointers may only
-        // reference things that travel with the subgraph.
-        serialized.members = serialized.members.filter((m) => nodeIds.has(m) || groupIds.has(m));
-        if (serialized.parentGroupId !== undefined && !groupIds.has(serialized.parentGroupId)) {
-            serialized.parentGroupId = undefined;
-        }
-        groups.push(serialized);
-    }
-    return {
-        format: exports.SUBGRAPH_FORMAT,
-        schemaVersion: DiagramMigrations_1.DIAGRAM_SCHEMA_VERSION,
-        sourceDiagramId: diagram.id,
-        nodes,
-        links,
-        groups,
-        boundaryLinks,
-    };
-}
-/**
- * Install a subgraph into a live diagram through the unified restore path.
- *
- * This is a USER MUTATION (unlike document load): entities are installed via
- * restore* so the normal node:added/link:added events fire for undo and
- * rendering, and port registries are reconciled at the end.
- */
-function deserializeSubgraphInto(diagram, subgraph, options = {}) {
-    var _a, _b;
-    const remap = options.remapIds !== false;
-    const offset = (_a = options.offset) !== null && _a !== void 0 ? _a : { x: 0, y: 0 };
-    const idMap = new Map();
-    const portIdMap = new Map();
-    // --- nodes ---------------------------------------------------------------
-    const nodes = [];
-    for (const nodeData of subgraph.nodes) {
-        const node = NodeModel_1.NodeModel.fromJSON(nodeData);
-        const oldId = node.id;
-        if (remap) {
-            const newId = (0, id_1.generateId)();
-            node.id = newId;
-            idMap.set(oldId, newId);
-            // Fresh port ids + uuids for the clone; records old->new port ids.
-            (0, remapNodePortIds_1.remapNodePortIds)(node, newId, portIdMap);
-        }
-        else {
-            idMap.set(oldId, oldId);
-            for (const port of node.getPorts()) {
-                portIdMap.set(port.id, port.id);
-            }
-        }
-        // Direct field write (not setPosition): applying the paste offset is part
-        // of materializing the clone, not a user mutation to version-track.
-        node.position = { x: node.position.x + offset.x, y: node.position.y + offset.y };
-        // Parent pointers may only reference nodes that travel with the subgraph.
-        if (node.parentId) {
-            node.parentId = (_b = idMap.get(node.parentId)) !== null && _b !== void 0 ? _b : undefined;
-        }
-        diagram.restoreNode(node.serialize());
-        // restoreNode re-creates from JSON; fetch the installed instance.
-        const installed = diagram.getNode(node.id);
-        nodes.push(installed);
-    }
-    // Second pass: parentId of an earlier node may reference a LATER node in
-    // the subgraph — resolve any still-unmapped parents now that idMap is full.
-    if (remap) {
-        for (const installed of nodes) {
-            if (installed.parentId && idMap.has(installed.parentId)) {
-                installed.parentId = idMap.get(installed.parentId);
-            }
-        }
-    }
-    // --- links ---------------------------------------------------------------
-    const links = [];
-    for (const linkData of subgraph.links) {
-        const sourcePortId = portIdMap.get(linkData.sourcePortId);
-        const targetPortId = portIdMap.get(linkData.targetPortId);
-        if (!sourcePortId || !targetPortId) {
-            // Endpoint didn't travel with the subgraph — skip rather than install
-            // a dangling link (serializeSubgraph should have excluded it already).
-            continue;
-        }
-        const data = Object.assign(Object.assign({}, linkData), { id: remap ? (0, id_1.generateId)() : linkData.id, uuid: remap ? (0, id_1.generateUUID)() : linkData.uuid, sourcePortId,
-            targetPortId, sourceNodeId: linkData.sourceNodeId ? idMap.get(linkData.sourceNodeId) : undefined, targetNodeId: linkData.targetNodeId ? idMap.get(linkData.targetNodeId) : undefined });
-        const link = diagram.restoreLink(data);
-        if (link)
-            links.push(link);
-    }
-    // --- groups --------------------------------------------------------------
-    const groups = [];
-    // First mint group ids so nested parentGroupId can remap regardless of order.
-    if (remap) {
-        for (const groupData of subgraph.groups) {
-            idMap.set(groupData.id, (0, id_1.generateId)());
-        }
-    }
-    else {
-        for (const groupData of subgraph.groups) {
-            idMap.set(groupData.id, groupData.id);
-        }
-    }
-    for (const groupData of subgraph.groups) {
-        const data = Object.assign(Object.assign({}, groupData), { id: idMap.get(groupData.id), uuid: remap ? (0, id_1.generateUUID)() : groupData.uuid, members: groupData.members
-                .map((m) => idMap.get(m))
-                .filter((m) => !!m), parentGroupId: groupData.parentGroupId !== undefined
-                ? idMap.get(groupData.parentGroupId)
-                : undefined, position: groupData.position
-                ? { x: groupData.position.x + offset.x, y: groupData.position.y + offset.y }
-                : groupData.position });
-        const group = diagram.restoreGroup(data);
-        if (group)
-            groups.push(group);
-    }
-    // --- derived state -------------------------------------------------------
-    diagram.reconcilePortConnections();
-    return { nodes, links, groups, idMap, portIdMap };
-}
-//# sourceMappingURL=Subgraph.js.map

package/src/libs/engine/src/serialization/TextFormat.d.ts

@@ -1,71 +0,0 @@
-import { DiagramModel, type DiagramLoadOptions, type SerializedDiagram } from '../models/DiagramModel';
-export declare const GRAFLORIA_DOC_PREFIX = "%%grafloria:document ";
-export declare const GRAFLORIA_HASH_PREFIX = "%%grafloria:body-hash ";
-export interface ExportTextOptions {
-    /**
-     * Append the lossless sidecar (default true). Without it the text is pure
-     * Mermaid and imports are best-effort DSL parses (the lossy boundary).
-     */
-    lossless?: boolean;
-}
-export interface ImportTextOptions extends DiagramLoadOptions {
-    /**
-     * Which source wins when both exist:
-     *  - 'auto' (default): the sidecar wins UNLESS the body hash shows the body
-     *    was hand-edited after export — then the edited body wins.
-     *  - 'sidecar': always load the sidecar document (ignore body edits).
-     *  - 'text': always parse the body text (ignore the sidecar).
-     */
-    prefer?: 'auto' | 'sidecar' | 'text';
-}
-export interface ImportTextResult {
-    diagram: DiagramModel;
-    /** Which source actually produced the model. */
-    source: 'sidecar' | 'text';
-    /** True when a sidecar existed but the body had been hand-edited. */
-    bodyEdited: boolean;
-    /**
-     * True when a hand-edited body was applied ON TOP of the sidecar document —
-     * the edit took, and everything the grammar cannot express (positions,
-     * styles, ports, groups, viewport) survived from the sidecar.
-     */
-    sidecarMerged?: boolean;
-    /** True when a sidecar line existed but its JSON would not parse. */
-    sidecarInvalid?: boolean;
-    /**
-     * Set to the diagram-type name when the body is a Mermaid type we recognise
-     * but do not yet parse (sequenceDiagram, gantt, pie, …). The diagram is empty
-     * rather than a garbage flowchart. See docs/MERMAID-GAP-ANALYSIS.md Phase 0.
-     */
-    unsupported?: string;
-}
-/** The body without any %%grafloria sidecar lines (what a human reads/edits). */
-export declare function stripGrafloriaSidecar(text: string): string;
-/**
- * Export a diagram as Mermaid-compatible text. With `lossless` (default) the
- * exact document travels in a `%%grafloria:document` comment, so importing this
- * text reproduces the diagram byte-for-byte (serialize-equality), while the
- * body stays renderable by any Mermaid consumer.
- */
-export declare function exportDiagramText(diagram: DiagramModel, options?: ExportTextOptions): string;
-/**
- * The sidecar carries the DOCUMENT — not the viewing session and not derived
- * per-frame state. Two families are stripped:
- *
- * - EPHEMERAL entity state (selected / hovered / focused): per-viewer facts.
- *   Baked in, a committed file re-imports with a node pre-selected because
- *   someone happened to have it selected at export time. Same reasoning (and
- *   same key set) as the collab layer's EPHEMERAL exclusion in OpCapture.
- * - Link `points`: the routed polyline is DERIVED — the renderer re-routes and
- *   re-syncs it on the first frame. Serialized, a single smooth link drags a
- *   17-sample flattened curve into the text form, churning every git diff the
- *   "git-diffable text" story exists for.
- */
-export declare function sanitizeForSidecar(doc: SerializedDiagram): SerializedDiagram;
-/**
- * Import diagram text. Sidecar-carrying text loads losslessly through the
- * unified JSON path; pure Mermaid text parses through the DSL (best effort —
- * the documented lossy boundary). See ImportTextOptions.prefer for who wins
- * when the body was hand-edited after export.
- */
-export declare function importDiagramText(text: string, options?: ImportTextOptions): ImportTextResult;