@documentation-robotics/cli 0.1.0 → 0.1.5

package/dist/core/graph-model.js

@@ -0,0 +1,266 @@
+class GraphModel {
+  nodes;
+  edges;
+  indices;
+  nodesVersion = 0;
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map(), this.edges = /* @__PURE__ */ new Map(), this.indices = {
+      nodesByLayer: /* @__PURE__ */ new Map(),
+      nodesByType: /* @__PURE__ */ new Map(),
+      edgesBySource: /* @__PURE__ */ new Map(),
+      edgesByDestination: /* @__PURE__ */ new Map(),
+      edgesByPredicate: /* @__PURE__ */ new Map()
+    };
+  }
+  /**
+   * Get the current version of the nodes (for cache invalidation)
+   */
+  getNodesVersion() {
+    return this.nodesVersion;
+  }
+  /**
+   * Add a node to the graph and update indices
+   * If a node with the same ID exists, its old index entries are cleaned up
+   */
+  addNode(node) {
+    const existingNode = this.nodes.get(node.id);
+    if (existingNode) {
+      const oldLayerSet = this.indices.nodesByLayer.get(existingNode.layer);
+      oldLayerSet && (oldLayerSet.delete(node.id), oldLayerSet.size === 0 && this.indices.nodesByLayer.delete(existingNode.layer));
+      const oldTypeSet = this.indices.nodesByType.get(existingNode.type);
+      oldTypeSet && (oldTypeSet.delete(node.id), oldTypeSet.size === 0 && this.indices.nodesByType.delete(existingNode.type));
+    }
+    this.nodes.set(node.id, node), this.indices.nodesByLayer.has(node.layer) || this.indices.nodesByLayer.set(node.layer, /* @__PURE__ */ new Set());
+    const layerSet = this.indices.nodesByLayer.get(node.layer);
+    layerSet && layerSet.add(node.id), this.indices.nodesByType.has(node.type) || this.indices.nodesByType.set(node.type, /* @__PURE__ */ new Set());
+    const typeSet = this.indices.nodesByType.get(node.type);
+    typeSet && typeSet.add(node.id), this.nodesVersion++;
+  }
+  /**
+   * Remove a node from the graph
+   * Also removes all associated edges
+   */
+  removeNode(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!node)
+      return !1;
+    this.nodes.delete(nodeId);
+    const layerSet = this.indices.nodesByLayer.get(node.layer);
+    layerSet && (layerSet.delete(nodeId), layerSet.size === 0 && this.indices.nodesByLayer.delete(node.layer));
+    const typeSet = this.indices.nodesByType.get(node.type);
+    typeSet && (typeSet.delete(nodeId), typeSet.size === 0 && this.indices.nodesByType.delete(node.type));
+    const edgesInvolving = [];
+    for (const [edgeId, edge] of this.edges.entries())
+      (edge.source === nodeId || edge.destination === nodeId) && edgesInvolving.push(edgeId);
+    for (const edgeId of edgesInvolving)
+      this.removeEdge(edgeId);
+    return this.nodesVersion++, !0;
+  }
+  /**
+   * Update node properties
+   */
+  updateNode(nodeId, updates) {
+    const node = this.nodes.get(nodeId);
+    if (!node)
+      return !1;
+    if (updates.layer && updates.layer !== node.layer) {
+      const oldLayerSet = this.indices.nodesByLayer.get(node.layer);
+      oldLayerSet && (oldLayerSet.delete(nodeId), oldLayerSet.size === 0 && this.indices.nodesByLayer.delete(node.layer)), this.indices.nodesByLayer.has(updates.layer) || this.indices.nodesByLayer.set(updates.layer, /* @__PURE__ */ new Set());
+      const newLayerSet = this.indices.nodesByLayer.get(updates.layer);
+      newLayerSet && newLayerSet.add(nodeId);
+    }
+    if (updates.type && updates.type !== node.type) {
+      const oldTypeSet = this.indices.nodesByType.get(node.type);
+      oldTypeSet && (oldTypeSet.delete(nodeId), oldTypeSet.size === 0 && this.indices.nodesByType.delete(node.type)), this.indices.nodesByType.has(updates.type) || this.indices.nodesByType.set(updates.type, /* @__PURE__ */ new Set());
+      const newTypeSet = this.indices.nodesByType.get(updates.type);
+      newTypeSet && newTypeSet.add(nodeId);
+    }
+    return Object.assign(node, updates), this.nodesVersion++, !0;
+  }
+  /**
+   * Add an edge to the graph and update indices
+   * Validates that both source and destination nodes exist
+   * @throws Error if source or destination node does not exist
+   */
+  addEdge(edge) {
+    if (!this.nodes.has(edge.source))
+      throw new Error(`Cannot add edge: source node "${edge.source}" does not exist`);
+    if (!this.nodes.has(edge.destination))
+      throw new Error(`Cannot add edge: destination node "${edge.destination}" does not exist`);
+    this.edges.set(edge.id, edge), this.indices.edgesBySource.has(edge.source) || this.indices.edgesBySource.set(edge.source, /* @__PURE__ */ new Set());
+    const sourceSet = this.indices.edgesBySource.get(edge.source);
+    sourceSet && sourceSet.add(edge.id), this.indices.edgesByDestination.has(edge.destination) || this.indices.edgesByDestination.set(edge.destination, /* @__PURE__ */ new Set());
+    const destSet = this.indices.edgesByDestination.get(edge.destination);
+    destSet && destSet.add(edge.id), this.indices.edgesByPredicate.has(edge.predicate) || this.indices.edgesByPredicate.set(edge.predicate, /* @__PURE__ */ new Set());
+    const predicateSet = this.indices.edgesByPredicate.get(edge.predicate);
+    predicateSet && predicateSet.add(edge.id);
+  }
+  /**
+   * Remove an edge from the graph
+   */
+  removeEdge(edgeId) {
+    const edge = this.edges.get(edgeId);
+    if (!edge)
+      return !1;
+    this.edges.delete(edgeId);
+    const sourceSet = this.indices.edgesBySource.get(edge.source);
+    sourceSet && (sourceSet.delete(edgeId), sourceSet.size === 0 && this.indices.edgesBySource.delete(edge.source));
+    const destSet = this.indices.edgesByDestination.get(edge.destination);
+    destSet && (destSet.delete(edgeId), destSet.size === 0 && this.indices.edgesByDestination.delete(edge.destination));
+    const predicateSet = this.indices.edgesByPredicate.get(edge.predicate);
+    return predicateSet && (predicateSet.delete(edgeId), predicateSet.size === 0 && this.indices.edgesByPredicate.delete(edge.predicate)), !0;
+  }
+  /**
+   * Update edge properties
+   */
+  updateEdge(edgeId, updates) {
+    const edge = this.edges.get(edgeId);
+    if (!edge)
+      return !1;
+    if (updates.predicate && updates.predicate !== edge.predicate) {
+      const oldPredicateSet = this.indices.edgesByPredicate.get(edge.predicate);
+      oldPredicateSet && (oldPredicateSet.delete(edgeId), oldPredicateSet.size === 0 && this.indices.edgesByPredicate.delete(edge.predicate)), this.indices.edgesByPredicate.has(updates.predicate) || this.indices.edgesByPredicate.set(updates.predicate, /* @__PURE__ */ new Set());
+      const newPredicateSet = this.indices.edgesByPredicate.get(updates.predicate);
+      newPredicateSet && newPredicateSet.add(edgeId);
+    }
+    return Object.assign(edge, updates), !0;
+  }
+  /**
+   * Get a node by its ID
+   */
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  /**
+   * Get all nodes in a specific layer
+   */
+  getNodesByLayer(layer) {
+    const nodeIds = this.indices.nodesByLayer.get(layer) ?? /* @__PURE__ */ new Set(), result = [];
+    for (const id of nodeIds) {
+      const node = this.nodes.get(id);
+      node && result.push(node);
+    }
+    return result;
+  }
+  /**
+   * Get all nodes of a specific type
+   */
+  getNodesByType(type) {
+    const nodeIds = this.indices.nodesByType.get(type) ?? /* @__PURE__ */ new Set(), result = [];
+    for (const id of nodeIds) {
+      const node = this.nodes.get(id);
+      node && result.push(node);
+    }
+    return result;
+  }
+  /**
+   * Get outgoing edges from a node, optionally filtered by predicate
+   */
+  getEdgesFrom(nodeId, predicate) {
+    const edgeIds = this.indices.edgesBySource.get(nodeId) ?? /* @__PURE__ */ new Set(), edges = [];
+    for (const id of edgeIds) {
+      const edge = this.edges.get(id);
+      edge && edges.push(edge);
+    }
+    return predicate ? edges.filter((e) => e.predicate === predicate) : edges;
+  }
+  /**
+   * Get incoming edges to a node, optionally filtered by predicate
+   */
+  getEdgesTo(nodeId, predicate) {
+    const edgeIds = this.indices.edgesByDestination.get(nodeId) ?? /* @__PURE__ */ new Set(), edges = [];
+    for (const id of edgeIds) {
+      const edge = this.edges.get(id);
+      edge && edges.push(edge);
+    }
+    return predicate ? edges.filter((e) => e.predicate === predicate) : edges;
+  }
+  /**
+   * Get edges between two specific nodes
+   */
+  getEdgesBetween(sourceId, destinationId, predicate) {
+    return this.getEdgesFrom(sourceId, predicate).filter((e) => e.destination === destinationId);
+  }
+  /**
+   * Get all edges in the graph
+   */
+  getAllEdges() {
+    return Array.from(this.edges.values());
+  }
+  /**
+   * Traverse the graph starting from a node using breadth-first search
+   */
+  traverse(startNodeId, predicate, maxDepth = 1 / 0) {
+    const visited = /* @__PURE__ */ new Set(), result = [], queue = [{ nodeId: startNodeId, depth: 0 }];
+    for (; queue.length > 0; ) {
+      const { nodeId, depth } = queue.shift();
+      if (visited.has(nodeId) || depth > maxDepth)
+        continue;
+      visited.add(nodeId);
+      const node = this.nodes.get(nodeId);
+      node && result.push(node);
+      const edges = this.getEdgesFrom(nodeId, predicate);
+      for (const edge of edges)
+        visited.has(edge.destination) || queue.push({ nodeId: edge.destination, depth: depth + 1 });
+    }
+    return result;
+  }
+  /**
+   * Get total number of nodes
+   */
+  getNodeCount() {
+    return this.nodes.size;
+  }
+  /**
+   * Get total number of edges
+   */
+  getEdgeCount() {
+    return this.edges.size;
+  }
+  /**
+   * Clear all data from the graph
+   */
+  clear() {
+    this.nodes.clear(), this.edges.clear(), this.indices.nodesByLayer.clear(), this.indices.nodesByType.clear(), this.indices.edgesBySource.clear(), this.indices.edgesByDestination.clear(), this.indices.edgesByPredicate.clear();
+  }
+  /**
+   * Convert Element to GraphNode
+   * Preserves spec-node fields so they survive graph round-trips
+   */
+  /** UUID pattern for detecting actual UUIDs vs slug IDs */
+  static UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  static fromElement(element) {
+    const graphId = element.path || element.id, isUUID = GraphModel.UUID_PATTERN.test(element.id);
+    return {
+      id: graphId,
+      uuid: isUUID ? element.id : void 0,
+      // preserve UUID for round-tripping
+      layer: element.layer || "unknown",
+      type: element.type,
+      name: element.name,
+      description: element.description,
+      properties: element.attributes || {},
+      spec_node_id: element.spec_node_id || void 0,
+      layer_id: element.layer_id || void 0,
+      attributes: element.attributes && Object.keys(element.attributes).length > 0 ? element.attributes : void 0,
+      source_reference: element.source_reference,
+      metadata: element.metadata
+    };
+  }
+  /**
+   * Convert Relationship to GraphEdge
+   */
+  static relationshipToEdge(relationship, edgeId) {
+    return {
+      id: edgeId,
+      source: relationship.source,
+      destination: relationship.target,
+      predicate: relationship.predicate,
+      properties: relationship.properties
+    };
+  }
+}
+export {
+  GraphModel
+};
+//# sourceMappingURL=graph-model.js.map

package/dist/core/graph-model.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/graph-model.ts"],
+  "sourcesContent": ["import { Element } from \"./element.js\";\nimport type { ElementMetadata, Relationship, SourceReference } from \"../types/index.js\";\n\n/**\n * Graph node representing a model element\n * Replaces Element class for graph-based storage\n */\nexport interface GraphNode {\n  id: string; // Path (slug) used as graph key: {layer}.{type}.{kebab-name}\n  uuid?: string; // UUIDv4 preserved for round-tripping (element.id)\n  layer: string; // Layer this node belongs to\n  type: string; // Element type\n  name: string; // Display name\n  description?: string; // Optional description\n  properties?: Record<string, unknown>; // Custom properties\n  // Spec-node aligned fields (preserved through graph round-trip)\n  spec_node_id?: string;\n  layer_id?: string;\n  attributes?: Record<string, unknown>;\n  source_reference?: SourceReference;\n  metadata?: ElementMetadata;\n}\n\n/**\n * Graph edge representing a relationship between nodes\n */\nexport interface GraphEdge {\n  id: string; // Unique identifier\n  source: string; // Source node ID\n  destination: string; // Destination node ID\n  predicate: string; // Relationship type\n  properties?: Record<string, unknown>; // Optional properties\n  category?: \"structural\" | \"behavioral\";\n}\n\n/**\n * Index structures for efficient querying\n */\ninterface GraphIndices {\n  nodesByLayer: Map<string, Set<string>>; // layer -> node IDs\n  nodesByType: Map<string, Set<string>>; // type -> node IDs\n  edgesBySource: Map<string, Set<string>>; // source node ID -> edge IDs\n  edgesByDestination: Map<string, Set<string>>; // destination node ID -> edge IDs\n  edgesByPredicate: Map<string, Set<string>>; // predicate -> edge IDs\n}\n\n/**\n * Graph model interface for node/edge storage with query capabilities\n */\nexport interface IGraphModel {\n  nodes: Map<string, GraphNode>;\n  edges: Map<string, GraphEdge>;\n\n  // Query methods\n  getNode(id: string): GraphNode | undefined;\n  getNodesByLayer(layer: string): GraphNode[];\n  getNodesByType(type: string): GraphNode[];\n  getEdgesFrom(nodeId: string, predicate?: string): GraphEdge[];\n  getEdgesTo(nodeId: string, predicate?: string): GraphEdge[];\n  getEdgesBetween(sourceId: string, destinationId: string, predicate?: string): GraphEdge[];\n  getAllEdges(): GraphEdge[];\n\n  // Mutation methods\n  addNode(node: GraphNode): void;\n  removeNode(nodeId: string): boolean;\n  updateNode(nodeId: string, updates: Partial<GraphNode>): boolean;\n\n  addEdge(edge: GraphEdge): void;\n  removeEdge(edgeId: string): boolean;\n  updateEdge(edgeId: string, updates: Partial<GraphEdge>): boolean;\n\n  // Traversal\n  traverse(startNodeId: string, predicate?: string, maxDepth?: number): GraphNode[];\n\n  // Utility\n  getNodeCount(): number;\n  getEdgeCount(): number;\n  clear(): void;\n}\n\n/**\n * Implementation of graph model with indices for efficient queries\n */\nexport class GraphModel implements IGraphModel {\n  nodes: Map<string, GraphNode>;\n  edges: Map<string, GraphEdge>;\n  private indices: GraphIndices;\n  private nodesVersion: number = 0;\n\n  constructor() {\n    this.nodes = new Map();\n    this.edges = new Map();\n    this.indices = {\n      nodesByLayer: new Map(),\n      nodesByType: new Map(),\n      edgesBySource: new Map(),\n      edgesByDestination: new Map(),\n      edgesByPredicate: new Map(),\n    };\n  }\n\n  /**\n   * Get the current version of the nodes (for cache invalidation)\n   */\n  getNodesVersion(): number {\n    return this.nodesVersion;\n  }\n\n  /**\n   * Add a node to the graph and update indices\n   * If a node with the same ID exists, its old index entries are cleaned up\n   */\n  addNode(node: GraphNode): void {\n    const existingNode = this.nodes.get(node.id);\n\n    // Clean up old index entries if node is being replaced\n    if (existingNode) {\n      // Remove from old layer index\n      const oldLayerSet = this.indices.nodesByLayer.get(existingNode.layer);\n      if (oldLayerSet) {\n        oldLayerSet.delete(node.id);\n        if (oldLayerSet.size === 0) {\n          this.indices.nodesByLayer.delete(existingNode.layer);\n        }\n      }\n\n      // Remove from old type index\n      const oldTypeSet = this.indices.nodesByType.get(existingNode.type);\n      if (oldTypeSet) {\n        oldTypeSet.delete(node.id);\n        if (oldTypeSet.size === 0) {\n          this.indices.nodesByType.delete(existingNode.type);\n        }\n      }\n    }\n\n    // Add new node\n    this.nodes.set(node.id, node);\n\n    // Update layer index\n    if (!this.indices.nodesByLayer.has(node.layer)) {\n      this.indices.nodesByLayer.set(node.layer, new Set());\n    }\n    const layerSet = this.indices.nodesByLayer.get(node.layer);\n    if (layerSet) {\n      layerSet.add(node.id);\n    }\n\n    // Update type index\n    if (!this.indices.nodesByType.has(node.type)) {\n      this.indices.nodesByType.set(node.type, new Set());\n    }\n    const typeSet = this.indices.nodesByType.get(node.type);\n    if (typeSet) {\n      typeSet.add(node.id);\n    }\n\n    // Increment version to invalidate caches\n    this.nodesVersion++;\n  }\n\n  /**\n   * Remove a node from the graph\n   * Also removes all associated edges\n   */\n  removeNode(nodeId: string): boolean {\n    const node = this.nodes.get(nodeId);\n    if (!node) {\n      return false;\n    }\n\n    // Remove from nodes map\n    this.nodes.delete(nodeId);\n\n    // Remove from layer index\n    const layerSet = this.indices.nodesByLayer.get(node.layer);\n    if (layerSet) {\n      layerSet.delete(nodeId);\n      if (layerSet.size === 0) {\n        this.indices.nodesByLayer.delete(node.layer);\n      }\n    }\n\n    // Remove from type index\n    const typeSet = this.indices.nodesByType.get(node.type);\n    if (typeSet) {\n      typeSet.delete(nodeId);\n      if (typeSet.size === 0) {\n        this.indices.nodesByType.delete(node.type);\n      }\n    }\n\n    // Remove all edges involving this node\n    const edgesInvolving: string[] = [];\n    for (const [edgeId, edge] of this.edges.entries()) {\n      if (edge.source === nodeId || edge.destination === nodeId) {\n        edgesInvolving.push(edgeId);\n      }\n    }\n    for (const edgeId of edgesInvolving) {\n      this.removeEdge(edgeId);\n    }\n\n    // Increment version to invalidate caches\n    this.nodesVersion++;\n    return true;\n  }\n\n  /**\n   * Update node properties\n   */\n  updateNode(nodeId: string, updates: Partial<GraphNode>): boolean {\n    const node = this.nodes.get(nodeId);\n    if (!node) {\n      return false;\n    }\n\n    // Handle layer change\n    if (updates.layer && updates.layer !== node.layer) {\n      const oldLayerSet = this.indices.nodesByLayer.get(node.layer);\n      if (oldLayerSet) {\n        oldLayerSet.delete(nodeId);\n        if (oldLayerSet.size === 0) {\n          this.indices.nodesByLayer.delete(node.layer);\n        }\n      }\n      if (!this.indices.nodesByLayer.has(updates.layer)) {\n        this.indices.nodesByLayer.set(updates.layer, new Set());\n      }\n      const newLayerSet = this.indices.nodesByLayer.get(updates.layer);\n      if (newLayerSet) {\n        newLayerSet.add(nodeId);\n      }\n    }\n\n    // Handle type change\n    if (updates.type && updates.type !== node.type) {\n      const oldTypeSet = this.indices.nodesByType.get(node.type);\n      if (oldTypeSet) {\n        oldTypeSet.delete(nodeId);\n        if (oldTypeSet.size === 0) {\n          this.indices.nodesByType.delete(node.type);\n        }\n      }\n      if (!this.indices.nodesByType.has(updates.type)) {\n        this.indices.nodesByType.set(updates.type, new Set());\n      }\n      const newTypeSet = this.indices.nodesByType.get(updates.type);\n      if (newTypeSet) {\n        newTypeSet.add(nodeId);\n      }\n    }\n\n    // Apply updates\n    Object.assign(node, updates);\n    // Increment version to invalidate caches\n    this.nodesVersion++;\n    return true;\n  }\n\n  /**\n   * Add an edge to the graph and update indices\n   * Validates that both source and destination nodes exist\n   * @throws Error if source or destination node does not exist\n   */\n  addEdge(edge: GraphEdge): void {\n    // Validate that source node exists\n    if (!this.nodes.has(edge.source)) {\n      throw new Error(`Cannot add edge: source node \"${edge.source}\" does not exist`);\n    }\n\n    // Validate that destination node exists\n    if (!this.nodes.has(edge.destination)) {\n      throw new Error(`Cannot add edge: destination node \"${edge.destination}\" does not exist`);\n    }\n\n    this.edges.set(edge.id, edge);\n\n    // Update source index\n    if (!this.indices.edgesBySource.has(edge.source)) {\n      this.indices.edgesBySource.set(edge.source, new Set());\n    }\n    const sourceSet = this.indices.edgesBySource.get(edge.source);\n    if (sourceSet) {\n      sourceSet.add(edge.id);\n    }\n\n    // Update destination index\n    if (!this.indices.edgesByDestination.has(edge.destination)) {\n      this.indices.edgesByDestination.set(edge.destination, new Set());\n    }\n    const destSet = this.indices.edgesByDestination.get(edge.destination);\n    if (destSet) {\n      destSet.add(edge.id);\n    }\n\n    // Update predicate index\n    if (!this.indices.edgesByPredicate.has(edge.predicate)) {\n      this.indices.edgesByPredicate.set(edge.predicate, new Set());\n    }\n    const predicateSet = this.indices.edgesByPredicate.get(edge.predicate);\n    if (predicateSet) {\n      predicateSet.add(edge.id);\n    }\n  }\n\n  /**\n   * Remove an edge from the graph\n   */\n  removeEdge(edgeId: string): boolean {\n    const edge = this.edges.get(edgeId);\n    if (!edge) {\n      return false;\n    }\n\n    // Remove from edges map\n    this.edges.delete(edgeId);\n\n    // Remove from source index\n    const sourceSet = this.indices.edgesBySource.get(edge.source);\n    if (sourceSet) {\n      sourceSet.delete(edgeId);\n      if (sourceSet.size === 0) {\n        this.indices.edgesBySource.delete(edge.source);\n      }\n    }\n\n    // Remove from destination index\n    const destSet = this.indices.edgesByDestination.get(edge.destination);\n    if (destSet) {\n      destSet.delete(edgeId);\n      if (destSet.size === 0) {\n        this.indices.edgesByDestination.delete(edge.destination);\n      }\n    }\n\n    // Remove from predicate index\n    const predicateSet = this.indices.edgesByPredicate.get(edge.predicate);\n    if (predicateSet) {\n      predicateSet.delete(edgeId);\n      if (predicateSet.size === 0) {\n        this.indices.edgesByPredicate.delete(edge.predicate);\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Update edge properties\n   */\n  updateEdge(edgeId: string, updates: Partial<GraphEdge>): boolean {\n    const edge = this.edges.get(edgeId);\n    if (!edge) {\n      return false;\n    }\n\n    // Handle predicate change\n    if (updates.predicate && updates.predicate !== edge.predicate) {\n      const oldPredicateSet = this.indices.edgesByPredicate.get(edge.predicate);\n      if (oldPredicateSet) {\n        oldPredicateSet.delete(edgeId);\n        if (oldPredicateSet.size === 0) {\n          this.indices.edgesByPredicate.delete(edge.predicate);\n        }\n      }\n      if (!this.indices.edgesByPredicate.has(updates.predicate)) {\n        this.indices.edgesByPredicate.set(updates.predicate, new Set());\n      }\n      const newPredicateSet = this.indices.edgesByPredicate.get(updates.predicate);\n      if (newPredicateSet) {\n        newPredicateSet.add(edgeId);\n      }\n    }\n\n    // Note: Source and destination changes are not supported (use removeEdge + addEdge)\n    // Apply updates\n    Object.assign(edge, updates);\n    return true;\n  }\n\n  /**\n   * Get a node by its ID\n   */\n  getNode(id: string): GraphNode | undefined {\n    return this.nodes.get(id);\n  }\n\n  /**\n   * Get all nodes in a specific layer\n   */\n  getNodesByLayer(layer: string): GraphNode[] {\n    const nodeIds = this.indices.nodesByLayer.get(layer) ?? new Set();\n    const result: GraphNode[] = [];\n    for (const id of nodeIds) {\n      const node = this.nodes.get(id);\n      if (node) {\n        result.push(node);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Get all nodes of a specific type\n   */\n  getNodesByType(type: string): GraphNode[] {\n    const nodeIds = this.indices.nodesByType.get(type) ?? new Set();\n    const result: GraphNode[] = [];\n    for (const id of nodeIds) {\n      const node = this.nodes.get(id);\n      if (node) {\n        result.push(node);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Get outgoing edges from a node, optionally filtered by predicate\n   */\n  getEdgesFrom(nodeId: string, predicate?: string): GraphEdge[] {\n    const edgeIds = this.indices.edgesBySource.get(nodeId) ?? new Set();\n    const edges: GraphEdge[] = [];\n    for (const id of edgeIds) {\n      const edge = this.edges.get(id);\n      if (edge) {\n        edges.push(edge);\n      }\n    }\n\n    if (predicate) {\n      return edges.filter((e) => e.predicate === predicate);\n    }\n    return edges;\n  }\n\n  /**\n   * Get incoming edges to a node, optionally filtered by predicate\n   */\n  getEdgesTo(nodeId: string, predicate?: string): GraphEdge[] {\n    const edgeIds = this.indices.edgesByDestination.get(nodeId) ?? new Set();\n    const edges: GraphEdge[] = [];\n    for (const id of edgeIds) {\n      const edge = this.edges.get(id);\n      if (edge) {\n        edges.push(edge);\n      }\n    }\n\n    if (predicate) {\n      return edges.filter((e) => e.predicate === predicate);\n    }\n    return edges;\n  }\n\n  /**\n   * Get edges between two specific nodes\n   */\n  getEdgesBetween(sourceId: string, destinationId: string, predicate?: string): GraphEdge[] {\n    const outgoing = this.getEdgesFrom(sourceId, predicate);\n    return outgoing.filter((e) => e.destination === destinationId);\n  }\n\n  /**\n   * Get all edges in the graph\n   */\n  getAllEdges(): GraphEdge[] {\n    return Array.from(this.edges.values());\n  }\n\n  /**\n   * Traverse the graph starting from a node using breadth-first search\n   */\n  traverse(startNodeId: string, predicate?: string, maxDepth: number = Infinity): GraphNode[] {\n    const visited = new Set<string>();\n    const result: GraphNode[] = [];\n    const queue: { nodeId: string; depth: number }[] = [{ nodeId: startNodeId, depth: 0 }];\n\n    while (queue.length > 0) {\n      const { nodeId, depth } = queue.shift()!;\n\n      if (visited.has(nodeId) || depth > maxDepth) {\n        continue;\n      }\n\n      visited.add(nodeId);\n      const node = this.nodes.get(nodeId);\n      if (node) {\n        result.push(node);\n      }\n\n      // Find outgoing edges\n      const edges = this.getEdgesFrom(nodeId, predicate);\n      for (const edge of edges) {\n        if (!visited.has(edge.destination)) {\n          queue.push({ nodeId: edge.destination, depth: depth + 1 });\n        }\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Get total number of nodes\n   */\n  getNodeCount(): number {\n    return this.nodes.size;\n  }\n\n  /**\n   * Get total number of edges\n   */\n  getEdgeCount(): number {\n    return this.edges.size;\n  }\n\n  /**\n   * Clear all data from the graph\n   */\n  clear(): void {\n    this.nodes.clear();\n    this.edges.clear();\n    this.indices.nodesByLayer.clear();\n    this.indices.nodesByType.clear();\n    this.indices.edgesBySource.clear();\n    this.indices.edgesByDestination.clear();\n    this.indices.edgesByPredicate.clear();\n  }\n\n  /**\n   * Convert Element to GraphNode\n   * Preserves spec-node fields so they survive graph round-trips\n   */\n  /** UUID pattern for detecting actual UUIDs vs slug IDs */\n  private static readonly UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n  static fromElement(element: Element): GraphNode {\n    // path is the graph key; fall back to id for elements without a path\n    const graphId = element.path || element.id;\n    // Only preserve UUID when the id is actually a UUID (not a slug)\n    const isUUID = GraphModel.UUID_PATTERN.test(element.id);\n    return {\n      id: graphId,\n      uuid: isUUID ? element.id : undefined,   // preserve UUID for round-tripping\n      layer: element.layer || \"unknown\",\n      type: element.type,\n      name: element.name,\n      description: element.description,\n      properties: element.attributes || {},\n      spec_node_id: element.spec_node_id || undefined,\n      layer_id: element.layer_id || undefined,\n      attributes: element.attributes && Object.keys(element.attributes).length > 0\n        ? element.attributes\n        : undefined,\n      source_reference: element.source_reference,\n      metadata: element.metadata,\n    };\n  }\n\n  /**\n   * Convert Relationship to GraphEdge\n   */\n  static relationshipToEdge(relationship: Relationship, edgeId: string): GraphEdge {\n    return {\n      id: edgeId,\n      source: relationship.source,\n      destination: relationship.target,\n      predicate: relationship.predicate,\n      properties: relationship.properties,\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/layer.js

@@ -1,36 +1,173 @@
 import { Element } from "./element.js";
+import { GraphModel } from "./graph-model.js";
 class Layer {
   name;
-  elements;
+  graph;
   metadata;
   dirty = !1;
-  constructor(name, elements = []) {
-    this.name = name, this.elements = new Map(elements.map((e) => [e.id, e]));
+  cachedElements = null;
+  cachedNodesVersion = 0;
+  constructor(name, elementsOrGraph, elementsIfGraphPassed) {
+    this.name = name;
+    let actualGraph, elementsToAdd = [];
+    elementsOrGraph instanceof GraphModel ? (actualGraph = elementsOrGraph, Array.isArray(elementsIfGraphPassed) && (elementsToAdd = elementsIfGraphPassed)) : Array.isArray(elementsOrGraph) ? elementsToAdd = elementsOrGraph : elementsOrGraph === void 0 && Array.isArray(elementsIfGraphPassed) && (elementsToAdd = elementsIfGraphPassed), this.graph = actualGraph || new GraphModel();
+    for (const element of elementsToAdd) {
+      element.layer = this.name, (!element.layer_id || element.layer_id === "") && (element.layer_id = this.name);
+      const node = GraphModel.fromElement(element), nodeProperties = node.properties || {};
+      node.properties = nodeProperties, element.references && element.references.length > 0 && (nodeProperties.__references__ = element.references), element.relationships && element.relationships.length > 0 && (nodeProperties.__relationships__ = element.relationships), element.semanticId && (nodeProperties.__semanticId__ = element.semanticId), this.graph.addNode(node);
+    }
   }
   /**
-   * Add an element to the layer
+   * Get all elements in this layer from the graph
+   * Converts graph nodes back to Elements for backward compatibility
+   * Results are cached and invalidated when the underlying graph changes
+   */
+  get elements() {
+    const currentVersion = this.graph.getNodesVersion();
+    if (this.cachedElements !== null && this.cachedNodesVersion === currentVersion)
+      return this.cachedElements;
+    const result = /* @__PURE__ */ new Map(), nodes = this.graph.getNodesByLayer(this.name);
+    for (const node of nodes) {
+      const element = new Element({
+        id: node.uuid || node.id,
+        path: node.id,
+        spec_node_id: node.spec_node_id,
+        layer_id: node.layer_id,
+        type: node.type,
+        name: node.name,
+        description: node.description,
+        attributes: node.attributes,
+        source_reference: node.source_reference,
+        metadata: node.metadata,
+        layer: node.layer,
+        references: node.properties?.__references__ ?? [],
+        relationships: node.properties?.__relationships__ ?? [],
+        semanticId: node.properties?.__semanticId__
+      });
+      result.set(node.id, element);
+    }
+    return this.cachedElements = result, this.cachedNodesVersion = currentVersion, result;
+  }
+  /**
+   * Add an element to the layer (stores in graph)
    */
   addElement(element) {
-    this.elements.set(element.id, element), this.dirty = !0;
+    element.layer = this.name, (!element.layer_id || element.layer_id === "") && (element.layer_id = this.name);
+    const node = GraphModel.fromElement(element), nodeProperties = node.properties || {};
+    if (node.properties = nodeProperties, element.references && element.references.length > 0 && (nodeProperties.__references__ = element.references), element.relationships && element.relationships.length > 0 && (nodeProperties.__relationships__ = element.relationships), element.semanticId && (nodeProperties.__semanticId__ = element.semanticId), this.graph.addNode(node), element.references && element.references.length > 0)
+      for (const ref of element.references)
+        this.graph.nodes.has(ref.source) && this.graph.nodes.has(ref.target) && this.graph.addEdge({
+          id: `${ref.source}-${ref.type}-${ref.target}`,
+          source: ref.source,
+          destination: ref.target,
+          predicate: ref.type,
+          properties: {}
+        });
+    if (element.relationships && element.relationships.length > 0)
+      for (const rel of element.relationships)
+        this.graph.nodes.has(rel.source) && this.graph.nodes.has(rel.target) && this.graph.addEdge({
+          id: `${rel.source}-${rel.predicate}-${rel.target}`,
+          source: rel.source,
+          destination: rel.target,
+          predicate: rel.predicate,
+          properties: {}
+        });
+    this.dirty = !0;
   }
   /**
-   * Get an element by ID
+   * Get an element by UUID or semantic ID from the graph.
+   * Supports direct UUID lookup, and falls back to semantic ID lookup for legacy elements.
+   *
+   * @param id - UUID or semantic ID of the element to get
+   * @returns The element if found, undefined if not found
    */
   getElement(id) {
-    return this.elements.get(id);
+    let node = this.graph.nodes.get(id);
+    if (!node) {
+      for (const candidate of this.graph.nodes.values())
+        if (candidate.layer === this.name && (candidate.uuid === id || candidate.properties?.__semanticId__ === id || candidate.id === id)) {
+          node = candidate;
+          break;
+        }
+    }
+    if (!(!node || node.layer !== this.name))
+      return new Element({
+        id: node.uuid || node.id,
+        path: node.id,
+        spec_node_id: node.spec_node_id,
+        layer_id: node.layer_id,
+        type: node.type,
+        name: node.name,
+        description: node.description,
+        attributes: node.attributes,
+        source_reference: node.source_reference,
+        metadata: node.metadata,
+        layer: node.layer,
+        references: node.properties?.__references__ ?? [],
+        relationships: node.properties?.__relationships__ ?? []
+      });
+  }
+  /**
+   * Update an element in the graph
+   */
+  updateElement(element) {
+    const node = this.graph.nodes.get(element.path || element.id);
+    if (!node || node.layer !== this.name)
+      return !1;
+    const properties = { ...node.properties || {} };
+    element.references && element.references.length > 0 ? properties.__references__ = element.references : delete properties.__references__, element.relationships && element.relationships.length > 0 ? properties.__relationships__ = element.relationships : delete properties.__relationships__;
+    const updated = this.graph.updateNode(element.path || element.id, {
+      type: element.type,
+      name: element.name,
+      description: element.description,
+      properties,
+      spec_node_id: element.spec_node_id || void 0,
+      layer_id: element.layer_id || void 0,
+      attributes: element.attributes,
+      source_reference: element.source_reference,
+      metadata: element.metadata
+    });
+    return updated && (this.dirty = !0), updated;
   }
   /**
-   * Delete an element by ID
+   * Delete an element by ID from the graph
+   *
+   * @param id - UUID of the element to delete
+   * @returns true if element was deleted, false if not found
    */
   deleteElement(id) {
-    const result = this.elements.delete(id);
+    let node = this.graph.nodes.get(id);
+    if (!node || node.layer !== this.name) {
+      for (const candidate of this.graph.nodes.values())
+        if (candidate.layer === this.name && (candidate.uuid === id || candidate.properties?.__semanticId__ === id || candidate.id === id)) {
+          node = candidate;
+          break;
+        }
+    }
+    if (!node || node.layer !== this.name)
+      return !1;
+    const result = this.graph.removeNode(node.id);
     return result && (this.dirty = !0), result;
   }
   /**
-   * List all elements in the layer
+   * List all elements in the layer from the graph
    */
   listElements() {
-    return Array.from(this.elements.values());
+    return this.graph.getNodesByLayer(this.name).map((node) => new Element({
+      id: node.uuid || node.id,
+      path: node.id,
+      spec_node_id: node.spec_node_id,
+      layer_id: node.layer_id,
+      type: node.type,
+      name: node.name,
+      description: node.description,
+      attributes: node.attributes,
+      source_reference: node.source_reference,
+      metadata: node.metadata,
+      layer: node.layer,
+      references: node.properties?.__references__ ?? [],
+      relationships: node.properties?.__relationships__ ?? []
+    }));
   }
   /**
    * Check if layer has unsaved changes
@@ -49,23 +186,29 @@ class Layer {
    */
   toJSON() {
     const result = {
-      elements: Array.from(this.elements.values()).map((e) => e.toJSON())
+      elements: this.listElements().map((e) => e.toJSON())
     };
     return this.metadata && (result.metadata = this.metadata), result;
   }
   /**
    * Create Layer from JSON data
    */
-  static fromJSON(name, data) {
+  static fromJSON(name, data, graph) {
     const elements = data.elements.map((e) => new Element({
       id: e.id,
+      path: e.path,
+      spec_node_id: e.spec_node_id,
+      layer_id: e.layer_id,
       type: e.type,
       name: e.name,
       description: e.description,
-      properties: e.properties,
+      attributes: e.attributes,
+      source_reference: e.source_reference,
+      metadata: e.metadata,
       references: e.references,
-      relationships: e.relationships
-    })), layer = new Layer(name, elements);
+      relationships: e.relationships,
+      layer: name
+    })), layer = new Layer(name, graph, elements);
     return layer.metadata = data.metadata, layer;
   }
 }

package/dist/core/layer.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/core/layer.ts"],
-  "sourcesContent": ["import { Element } from \"./element.js\";\nimport type { LayerData } from \"../types/index.js\";\n\n/**\n * Layer class representing a container for elements within a layer\n */\nexport class Layer {\n  name: string;\n  elements: Map<string, Element>;\n  metadata?: { layer: string; version: string };\n  private dirty: boolean = false;\n\n  constructor(name: string, elements: Element[] = []) {\n    this.name = name;\n    this.elements = new Map(elements.map((e) => [e.id, e]));\n  }\n\n  /**\n   * Add an element to the layer\n   */\n  addElement(element: Element): void {\n    this.elements.set(element.id, element);\n    this.dirty = true;\n  }\n\n  /**\n   * Get an element by ID\n   */\n  getElement(id: string): Element | undefined {\n    return this.elements.get(id);\n  }\n\n  /**\n   * Delete an element by ID\n   */\n  deleteElement(id: string): boolean {\n    const result = this.elements.delete(id);\n    if (result) {\n      this.dirty = true;\n    }\n    return result;\n  }\n\n  /**\n   * List all elements in the layer\n   */\n  listElements(): Element[] {\n    return Array.from(this.elements.values());\n  }\n\n  /**\n   * Check if layer has unsaved changes\n   */\n  isDirty(): boolean {\n    return this.dirty;\n  }\n\n  /**\n   * Mark layer as clean (no unsaved changes)\n   */\n  markClean(): void {\n    this.dirty = false;\n  }\n\n  /**\n   * Serialize to JSON representation\n   */\n  toJSON(): LayerData {\n    const result: LayerData = {\n      elements: Array.from(this.elements.values()).map((e) => e.toJSON()),\n    };\n\n    if (this.metadata) {\n      result.metadata = this.metadata;\n    }\n\n    return result;\n  }\n\n  /**\n   * Create Layer from JSON data\n   */\n  static fromJSON(name: string, data: LayerData): Layer {\n    const elements = data.elements.map(\n      (e) =>\n        new Element({\n          id: e.id,\n          type: e.type,\n          name: e.name,\n          description: e.description,\n          properties: e.properties,\n          references: e.references,\n          relationships: e.relationships,\n        })\n    );\n    const layer = new Layer(name, elements);\n    layer.metadata = data.metadata;\n    return layer;\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,eAAe;AAMlB,MAAO,MAAK;EAChB;EACA;EACA;EACQ,QAAiB;EAEzB,YAAY,MAAc,WAAsB,CAAA,GAAE;AAChD,SAAK,OAAO,MACZ,KAAK,WAAW,IAAI,IAAI,SAAS,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;EACxD;;;;EAKA,WAAW,SAAgB;AACzB,SAAK,SAAS,IAAI,QAAQ,IAAI,OAAO,GACrC,KAAK,QAAQ;EACf;;;;EAKA,WAAW,IAAU;AACnB,WAAO,KAAK,SAAS,IAAI,EAAE;EAC7B;;;;EAKA,cAAc,IAAU;AACtB,UAAM,SAAS,KAAK,SAAS,OAAO,EAAE;AACtC,WAAI,WACF,KAAK,QAAQ,KAER;EACT;;;;EAKA,eAAY;AACV,WAAO,MAAM,KAAK,KAAK,SAAS,OAAM,CAAE;EAC1C;;;;EAKA,UAAO;AACL,WAAO,KAAK;EACd;;;;EAKA,YAAS;AACP,SAAK,QAAQ;EACf;;;;EAKA,SAAM;AACJ,UAAM,SAAoB;MACxB,UAAU,MAAM,KAAK,KAAK,SAAS,OAAM,CAAE,EAAE,IAAI,CAAC,MAAM,EAAE,OAAM,CAAE;;AAGpE,WAAI,KAAK,aACP,OAAO,WAAW,KAAK,WAGlB;EACT;;;;EAKA,OAAO,SAAS,MAAc,MAAe;AAC3C,UAAM,WAAW,KAAK,SAAS,IAC7B,CAAC,MACC,IAAI,QAAQ;MACV,IAAI,EAAE;MACN,MAAM,EAAE;MACR,MAAM,EAAE;MACR,aAAa,EAAE;MACf,YAAY,EAAE;MACd,YAAY,EAAE;MACd,eAAe,EAAE;KAClB,CAAC,GAEA,QAAQ,IAAI,MAAM,MAAM,QAAQ;AACtC,iBAAM,WAAW,KAAK,UACf;EACT;;",
+  "sourcesContent": ["import { Element } from \"./element.js\";\nimport { GraphModel } from \"./graph-model.js\";\nimport type { LayerData, Reference, Relationship } from \"../types/index.js\";\n\n/**\n * Layer class - thin wrapper over graph model for backward compatibility\n * Queries the graph for elements in a specific layer\n */\nexport class Layer {\n  name: string;\n  graph: GraphModel;\n  metadata?: { layer: string; version: string };\n  private dirty: boolean = false;\n  private cachedElements: Map<string, Element> | null = null;\n  private cachedNodesVersion: number = 0;\n\n  constructor(\n    name: string,\n    elementsOrGraph?: Element[] | GraphModel,\n    elementsIfGraphPassed?: Element[]\n  ) {\n    this.name = name;\n\n    // Handle overloaded constructor:\n    // new Layer(name) - create with empty graph\n    // new Layer(name, elements) - create with elements array\n    // new Layer(name, graph) - create with provided graph\n    // new Layer(name, undefined, elements) - create with elements\n    // new Layer(name, graph, elements) - create with provided graph and elements\n    let actualGraph: GraphModel | undefined;\n    let elementsToAdd: Element[] = [];\n\n    if (elementsOrGraph instanceof GraphModel) {\n      // Called with graph as second parameter\n      actualGraph = elementsOrGraph;\n      // Elements are in the third parameter if provided\n      if (Array.isArray(elementsIfGraphPassed)) {\n        elementsToAdd = elementsIfGraphPassed;\n      }\n    } else if (Array.isArray(elementsOrGraph)) {\n      // Called with elements as second parameter\n      elementsToAdd = elementsOrGraph;\n    } else if (elementsOrGraph === undefined && Array.isArray(elementsIfGraphPassed)) {\n      // Called with undefined graph and elements in third parameter\n      elementsToAdd = elementsIfGraphPassed;\n    }\n\n    // Use provided graph or create a new one\n    this.graph = actualGraph || new GraphModel();\n\n    // Add elements to the graph (without marking as dirty during construction)\n    for (const element of elementsToAdd) {\n      // Ensure element has the correct layer\n      element.layer = this.name;\n      // Also set layer_id to maintain consistency with layer name\n      if (!element.layer_id || element.layer_id === \"\") {\n        element.layer_id = this.name;\n      }\n      const node = GraphModel.fromElement(element);\n\n      // Store references and relationships as node properties for preservation\n      // Ensure properties object exists; fromElement always initializes it, but type is optional\n      const nodeProperties = node.properties || {};\n      node.properties = nodeProperties;\n\n      if (element.references && element.references.length > 0) {\n        nodeProperties[\"__references__\"] = element.references;\n      }\n      if (element.relationships && element.relationships.length > 0) {\n        nodeProperties[\"__relationships__\"] = element.relationships;\n      }\n\n      // Store semantic ID if present (for legacy format elements converted to UUID)\n      if ((element as any).semanticId) {\n        nodeProperties[\"__semanticId__\"] = (element as any).semanticId;\n      }\n\n      this.graph.addNode(node);\n      // Don't mark as dirty during construction - elements added in constructor are initial state\n    }\n  }\n\n  /**\n   * Get all elements in this layer from the graph\n   * Converts graph nodes back to Elements for backward compatibility\n   * Results are cached and invalidated when the underlying graph changes\n   */\n  get elements(): Map<string, Element> {\n    const currentVersion = this.graph.getNodesVersion();\n\n    // Return cached result if graph hasn't changed\n    if (this.cachedElements !== null && this.cachedNodesVersion === currentVersion) {\n      return this.cachedElements;\n    }\n\n    // Rebuild cache\n    const result = new Map<string, Element>();\n    const nodes = this.graph.getNodesByLayer(this.name);\n\n    for (const node of nodes) {\n      const element = new Element({\n        id: node.uuid || node.id,\n        path: node.id,\n        spec_node_id: node.spec_node_id,\n        layer_id: node.layer_id,\n        type: node.type,\n        name: node.name,\n        description: node.description,\n        attributes: node.attributes,\n        source_reference: node.source_reference,\n        metadata: node.metadata,\n        layer: node.layer,\n        references: (node.properties?.[\"__references__\"] ?? []) as Reference[],\n        relationships: (node.properties?.[\"__relationships__\"] ?? []) as Relationship[],\n        semanticId: node.properties?.[\"__semanticId__\"],\n      } as any);\n      result.set(node.id, element);\n    }\n\n    this.cachedElements = result;\n    this.cachedNodesVersion = currentVersion;\n    return result;\n  }\n\n  /**\n   * Add an element to the layer (stores in graph)\n   */\n  addElement(element: Element): void {\n    // Ensure element has the correct layer\n    element.layer = this.name;\n    // Also set layer_id to maintain consistency with layer name\n    if (!element.layer_id || element.layer_id === \"\") {\n      element.layer_id = this.name;\n    }\n    const node = GraphModel.fromElement(element);\n\n    // Store references and relationships as node properties for preservation\n    // Ensure properties object exists; fromElement always initializes it, but type is optional\n    const nodeProperties = node.properties || {};\n    node.properties = nodeProperties;\n\n    if (element.references && element.references.length > 0) {\n      nodeProperties[\"__references__\"] = element.references;\n    }\n    if (element.relationships && element.relationships.length > 0) {\n      nodeProperties[\"__relationships__\"] = element.relationships;\n    }\n\n    // Store semantic ID if present (for legacy format elements converted to UUID)\n    if ((element as any).semanticId) {\n      nodeProperties[\"__semanticId__\"] = (element as any).semanticId;\n    }\n\n    // Add node to graph first\n    this.graph.addNode(node);\n\n    // Create graph edges from references for export compatibility\n    // Only create edges if both source and destination nodes exist\n    if (element.references && element.references.length > 0) {\n      for (const ref of element.references) {\n        if (this.graph.nodes.has(ref.source) && this.graph.nodes.has(ref.target)) {\n          this.graph.addEdge({\n            id: `${ref.source}-${ref.type}-${ref.target}`,\n            source: ref.source,\n            destination: ref.target,\n            predicate: ref.type,\n            properties: {},\n          });\n        }\n      }\n    }\n\n    // Create graph edges from relationships for export compatibility\n    // Only create edges if both source and destination nodes exist\n    if (element.relationships && element.relationships.length > 0) {\n      for (const rel of element.relationships) {\n        if (this.graph.nodes.has(rel.source) && this.graph.nodes.has(rel.target)) {\n          this.graph.addEdge({\n            id: `${rel.source}-${rel.predicate}-${rel.target}`,\n            source: rel.source,\n            destination: rel.target,\n            predicate: rel.predicate,\n            properties: {},\n          });\n        }\n      }\n    }\n\n    this.dirty = true;\n  }\n\n  /**\n   * Get an element by UUID or semantic ID from the graph.\n   * Supports direct UUID lookup, and falls back to semantic ID lookup for legacy elements.\n   *\n   * @param id - UUID or semantic ID of the element to get\n   * @returns The element if found, undefined if not found\n   */\n  getElement(id: string): Element | undefined {\n    // First try direct lookup by path (graph key) or UUID\n    let node = this.graph.nodes.get(id);\n\n    if (!node) {\n      // Fallback: look up by UUID (node.uuid === id) or legacy semanticId\n      for (const candidate of this.graph.nodes.values()) {\n        if (\n          candidate.layer === this.name &&\n          (candidate.uuid === id ||\n            candidate.properties?.[\"__semanticId__\"] === id ||\n            candidate.id === id)\n        ) {\n          node = candidate;\n          break;\n        }\n      }\n    }\n\n    if (!node || node.layer !== this.name) {\n      return undefined;\n    }\n\n    return new Element({\n      id: node.uuid || node.id,\n      path: node.id,\n      spec_node_id: node.spec_node_id,\n      layer_id: node.layer_id,\n      type: node.type,\n      name: node.name,\n      description: node.description,\n      attributes: node.attributes,\n      source_reference: node.source_reference,\n      metadata: node.metadata,\n      layer: node.layer,\n      references: (node.properties?.[\"__references__\"] ?? []) as Reference[],\n      relationships: (node.properties?.[\"__relationships__\"] ?? []) as Relationship[],\n    });\n  }\n\n  /**\n   * Update an element in the graph\n   */\n  updateElement(element: Element): boolean {\n    const node = this.graph.nodes.get(element.path || element.id);\n    if (!node || node.layer !== this.name) {\n      return false;\n    }\n\n    // Prepare properties including references and relationships\n    // Start with existing node properties to preserve graph metadata fields like __references__ and __relationships__\n    const properties = { ...(node.properties || {}) };\n\n    // Persist references and relationships as node properties\n    if (element.references && element.references.length > 0) {\n      properties[\"__references__\"] = element.references;\n    } else {\n      delete properties[\"__references__\"];\n    }\n\n    if (element.relationships && element.relationships.length > 0) {\n      properties[\"__relationships__\"] = element.relationships;\n    } else {\n      delete properties[\"__relationships__\"];\n    }\n\n    // Convert element to graph node and update in place, including spec-node fields\n    // so that source_reference and attributes changes aren't lost on the next save cycle\n    const updated = this.graph.updateNode(element.path || element.id, {\n      type: element.type,\n      name: element.name,\n      description: element.description,\n      properties,\n      spec_node_id: element.spec_node_id || undefined,\n      layer_id: element.layer_id || undefined,\n      attributes: element.attributes,\n      source_reference: element.source_reference,\n      metadata: element.metadata,\n    });\n\n    if (updated) {\n      this.dirty = true;\n    }\n    return updated;\n  }\n\n  /**\n   * Delete an element by ID from the graph\n   *\n   * @param id - UUID of the element to delete\n   * @returns true if element was deleted, false if not found\n   */\n  deleteElement(id: string): boolean {\n    let node = this.graph.nodes.get(id);\n\n    if (!node || node.layer !== this.name) {\n      // Fallback: search by UUID or semanticId if direct path lookup failed\n      for (const candidate of this.graph.nodes.values()) {\n        if (\n          candidate.layer === this.name &&\n          (candidate.uuid === id ||\n            candidate.properties?.[\"__semanticId__\"] === id ||\n            candidate.id === id)\n        ) {\n          node = candidate;\n          break;\n        }\n      }\n    }\n\n    if (!node || node.layer !== this.name) {\n      return false;\n    }\n\n    const result = this.graph.removeNode(node.id);\n    if (result) {\n      this.dirty = true;\n    }\n    return result;\n  }\n\n  /**\n   * List all elements in the layer from the graph\n   */\n  listElements(): Element[] {\n    const nodes = this.graph.getNodesByLayer(this.name);\n    return nodes.map(\n      (node) =>\n        new Element({\n          id: node.uuid || node.id,\n          path: node.id,\n          spec_node_id: node.spec_node_id,\n          layer_id: node.layer_id,\n          type: node.type,\n          name: node.name,\n          description: node.description,\n          attributes: node.attributes,\n          source_reference: node.source_reference,\n          metadata: node.metadata,\n          layer: node.layer,\n          references: (node.properties?.[\"__references__\"] ?? []) as Reference[],\n          relationships: (node.properties?.[\"__relationships__\"] ?? []) as Relationship[],\n        })\n    );\n  }\n\n  /**\n   * Check if layer has unsaved changes\n   */\n  isDirty(): boolean {\n    return this.dirty;\n  }\n\n  /**\n   * Mark layer as clean (no unsaved changes)\n   */\n  markClean(): void {\n    this.dirty = false;\n  }\n\n  /**\n   * Serialize to JSON representation\n   */\n  toJSON(): LayerData {\n    const result: LayerData = {\n      elements: this.listElements().map((e) => e.toJSON()),\n    };\n\n    if (this.metadata) {\n      result.metadata = this.metadata;\n    }\n\n    return result;\n  }\n\n  /**\n   * Create Layer from JSON data\n   */\n  static fromJSON(name: string, data: LayerData, graph?: GraphModel): Layer {\n    const elements = data.elements.map(\n      (e) =>\n        new Element({\n          id: e.id,\n          path: e.path,\n          spec_node_id: e.spec_node_id,\n          layer_id: e.layer_id,\n          type: e.type,\n          name: e.name,\n          description: e.description,\n          attributes: e.attributes,\n          source_reference: e.source_reference,\n          metadata: e.metadata,\n          references: e.references,\n          relationships: e.relationships,\n          layer: name,\n        })\n    );\n    const layer = new Layer(name, graph, elements);\n    layer.metadata = data.metadata;\n    return layer;\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/core/layers.js

@@ -0,0 +1,32 @@
+const CANONICAL_LAYER_NAMES = [
+  "motivation",
+  "business",
+  "security",
+  "application",
+  "technology",
+  "api",
+  "data-model",
+  "data-store",
+  "ux",
+  "navigation",
+  "apm",
+  "testing"
+];
+function getLayerOrder(layerName) {
+  const index = CANONICAL_LAYER_NAMES.indexOf(layerName);
+  return index >= 0 ? index + 1 : -1;
+}
+function getLayerByOrder(order) {
+  if (!(order < 1 || order > CANONICAL_LAYER_NAMES.length))
+    return CANONICAL_LAYER_NAMES[order - 1];
+}
+function isValidLayerName(name) {
+  return CANONICAL_LAYER_NAMES.includes(name);
+}
+export {
+  CANONICAL_LAYER_NAMES,
+  getLayerByOrder,
+  getLayerOrder,
+  isValidLayerName
+};
+//# sourceMappingURL=layers.js.map

package/dist/core/layers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/layers.ts"],
+  "sourcesContent": ["/**\n * Canonical layer names and ordering for the 12-layer architecture model.\n * This is the source of truth for layer naming and ordering.\n */\n\nexport const CANONICAL_LAYER_NAMES = [\n  'motivation',\n  'business',\n  'security',\n  'application',\n  'technology',\n  'api',\n  'data-model',\n  'data-store',\n  'ux',\n  'navigation',\n  'apm',\n  'testing'\n] as const;\n\nexport type CanonicalLayerName = (typeof CANONICAL_LAYER_NAMES)[number];\n\n/**\n * Get the numeric order of a layer (1-12)\n */\nexport function getLayerOrder(layerName: string): number {\n  const index = CANONICAL_LAYER_NAMES.indexOf(layerName as CanonicalLayerName);\n  return index >= 0 ? index + 1 : -1;\n}\n\n/**\n * Get layer name by numeric order (1-12)\n */\nexport function getLayerByOrder(order: number): string | undefined {\n  if (order < 1 || order > CANONICAL_LAYER_NAMES.length) {\n    return undefined;\n  }\n  return CANONICAL_LAYER_NAMES[order - 1];\n}\n\n/**\n * Check if a layer name is valid (type predicate for compile-time narrowing)\n */\nexport function isValidLayerName(name: string): name is CanonicalLayerName {\n  return CANONICAL_LAYER_NAMES.includes(name as CanonicalLayerName);\n}\n"],
+  "mappings": "AAKO,MAAM,wBAAwB;EACnC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAQI,SAAU,cAAc,WAAiB;AAC7C,QAAM,QAAQ,sBAAsB,QAAQ,SAA+B;AAC3E,SAAO,SAAS,IAAI,QAAQ,IAAI;AAClC;AAKM,SAAU,gBAAgB,OAAa;AAC3C,MAAI,UAAQ,KAAK,QAAQ,sBAAsB;AAG/C,WAAO,sBAAsB,QAAQ,CAAC;AACxC;AAKM,SAAU,iBAAiB,MAAY;AAC3C,SAAO,sBAAsB,SAAS,IAA0B;AAClE;",
+  "names": []
+}