@sigloch/graph-api-core 5.0.0 → 5.2.1

package/dist/browser.d.ts

@@ -13,7 +13,7 @@
  */
 export { findRoot } from './find-root.js';
 export type { RootQueryGraph } from './find-root.js';
-export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph } from './se-descriptor.js';
+export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph, fromOntologyGraph } from './se-descriptor.js';
 export { FormatECodec } from './format-e-codec.js';
 export { isValidTrace, tracePatternsOf } from './types.js';
 export type { GraphNode, GraphEdge, Graph } from './types.js';

package/dist/browser.js

@@ -12,6 +12,6 @@
  * @author andreas@siglochconsulting
  */
 export { findRoot } from './find-root.js';
-export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph } from './se-descriptor.js';
+export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph, fromOntologyGraph } from './se-descriptor.js';
 export { FormatECodec } from './format-e-codec.js';
 export { isValidTrace, tracePatternsOf } from './types.js';

package/dist/edge-ops.js

@@ -31,13 +31,20 @@ export function mergeNodes(graph, sourceUid, targetUid) {
     if (!graph.nodes.some(n => n.uid === sourceUid)) {
         throw new Error(`merge-nodes: source node not found: ${sourceUid}`);
     }
-    const edges = [];
+    // CR-SM-253: two passes, not one. The single-pass form checked the REWIRED edge
+    // against what the loop had collected so far, but appended an untouched edge
+    // unchecked — so the result depended on the order of `graph.edges`: source's edge
+    // first gave `B-verify->R` twice, target's edge first gave it once. Kuzu keys on
+    // (source, type, target) and silently keeps one, so the in-memory graph then claimed
+    // an edge the store did not have. Collecting every survivor first and deduplicating
+    // against the complete set makes the result order-independent.
     const removedEdges = [];
-    const addedEdges = [];
+    const kept = [];
+    const rewiredEdges = [];
     for (const e of graph.edges) {
         const touchesSource = e.sourceId === sourceUid || e.targetId === sourceUid;
         if (!touchesSource) {
-            edges.push(e);
+            kept.push(e);
             continue;
         }
         removedEdges.push(e);
@@ -49,11 +56,18 @@ export function mergeNodes(graph, sourceUid, targetUid) {
         if (rewired.sourceId === rewired.targetId) {
             continue; // self-edge created by rewiring — discarded
         }
+        rewiredEdges.push(rewired);
+    }
+    // `addedEdges` is the delta the store persists. An edge the target already carried
+    // is not an addition — persisting it would write the duplicate into the store path
+    // that the in-memory dedup just prevented.
+    const edges = kept.slice();
+    const addedEdges = [];
+    for (const rewired of rewiredEdges) {
+        if (edges.some(x => sameEdge(x, rewired)))
+            continue;
+        edges.push(rewired);
         addedEdges.push(rewired);
-        // Two incident edges (or one incident + one pre-existing) can rewire onto
-        // the same (source,target,type) — keep the result graph free of duplicates.
-        if (!edges.some(x => sameEdge(x, rewired)))
-            edges.push(rewired);
     }
     const nodes = graph.nodes.filter(n => n.uid !== sourceUid);
     return { graph: { nodes, edges }, removedNode: sourceUid, removedEdges, addedEdges };

package/dist/format-e-codec.d.ts

@@ -23,6 +23,12 @@ export declare class FormatECodec {
     private parseNodeLine;
     private parseEdgeLine;
     private parseMerge;
+    /**
+     * CR-SM-251: derselbe Hydrations-Ort wie beim `@key value`-Pfad. Vorher war dies der einzige
+     * Pfad OHNE Hydration — hart auf `Record<string, string>` typisiert, womit `[concept:true]`
+     * als String "true" ankam und jede `=== true`-Ausnahme wirkungslos blieb (CR-GC-334 hatte
+     * genau diese Doppelung schon einmal fuer Objekte aufgeloest, nur eine Zeile weiter oben).
+     */
     private parseInlineAttrs;
     /**
      * CR-SM-215: fan-out serialization — edges sharing `(sourceId, edgeType)` collapse

package/dist/format-e-codec.js

@@ -7,7 +7,7 @@
  * family (`TYPE-slug`, `Name.TypeAbbr.Counter`, `cand_<hex>`); typing by spelling made
  * every foreign convention fail silently instead of loudly.
  */
-import { hydrateAttrValue } from '@sigloch/contracts/se';
+import { hydrateAttrValue, attributeTypeOf } from '@sigloch/contracts/se';
 import { isValidTrace, tracePatternsOf } from './types.js';
 // ---------------------------------------------------------------------------
 // Regex patterns
@@ -78,7 +78,7 @@ export class FormatECodec {
                     // them back as objects. Kept as a string, `realRef`/`testRef` fail their schema and
                     // the element reads as UNBOUND — R-19/R-20 fired on every node authored through this
                     // path. Same rule as the contracts parser, imported, not re-implemented.
-                    lastOp.attributes[attrMatch[1]] = hydrateAttrValue(attrMatch[2].trim());
+                    lastOp.attributes[attrMatch[1]] = hydrateAttrValue(attrMatch[2].trim(), attributeTypeOf(lastOp.elementType, attrMatch[1]));
                 }
                 else {
                     errors.push(`@attribute line without preceding node: "${line}"`);
@@ -197,7 +197,7 @@ export class FormatECodec {
         const attrMatch = INLINE_ATTRS_RE.exec(rest);
         if (attrMatch) {
             mainPart = rest.slice(0, attrMatch.index).trim();
-            inlineAttrs = this.parseInlineAttrs(attrMatch[1]);
+            inlineAttrs = this.parseInlineAttrs(attrMatch[1], nodeType);
         }
         // Split uid|description
         const pipeIdx = mainPart.indexOf('|');
@@ -237,6 +237,9 @@ export class FormatECodec {
         const action = OP_PREFIX[opChar] ?? 'add';
         // Extract inline attributes from the line
         let mainPart = rest;
+        // CR-SM-251: Kanten-Attribute (cardinality/constraint/notes) sind Strings und bleiben es —
+        // `attributeTypeOf` kennt nur Element-Attribute, ohne Typ faellt die Hydrierung auf String
+        // zurueck. Der Typ ist trotzdem `unknown`, damit hier kein zweiter Hydrations-Pfad entsteht.
         let inlineAttrs;
         const attrMatch = INLINE_ATTRS_RE.exec(rest);
         if (attrMatch) {
@@ -308,12 +311,19 @@ export class FormatECodec {
             sourceIds: parts,
         });
     }
-    parseInlineAttrs(raw) {
+    /**
+     * CR-SM-251: derselbe Hydrations-Ort wie beim `@key value`-Pfad. Vorher war dies der einzige
+     * Pfad OHNE Hydration — hart auf `Record<string, string>` typisiert, womit `[concept:true]`
+     * als String "true" ankam und jede `=== true`-Ausnahme wirkungslos blieb (CR-GC-334 hatte
+     * genau diese Doppelung schon einmal fuer Objekte aufgeloest, nur eine Zeile weiter oben).
+     */
+    parseInlineAttrs(raw, nodeType) {
         const attrs = {};
         for (const pair of raw.split(',')) {
             const colonIdx = pair.indexOf(':');
             if (colonIdx > 0) {
-                attrs[pair.slice(0, colonIdx).trim()] = pair.slice(colonIdx + 1).trim();
+                const key = pair.slice(0, colonIdx).trim();
+                attrs[key] = hydrateAttrValue(pair.slice(colonIdx + 1).trim(), attributeTypeOf(nodeType, key));
             }
         }
         return attrs;

package/dist/index.d.ts

@@ -22,7 +22,7 @@ export { MemoryAdapter } from './memory-adapter.js';
 export type { TransportAdapter, TransportConfig } from './transport-adapter.js';
 export { createGraphApi } from './factory.js';
 export type { GraphApiConfig } from './factory.js';
-export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph } from './se-descriptor.js';
+export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph, fromOntologyGraph } from './se-descriptor.js';
 export { findRoot } from './find-root.js';
 export type { RootQueryGraph } from './find-root.js';
 export { applyEdgeOps, updateEdge, mergeNodes } from './edge-ops.js';

package/dist/index.js

@@ -19,7 +19,7 @@ export { MemoryAdapter } from './memory-adapter.js';
 // Factory
 export { createGraphApi } from './factory.js';
 // SE OntologyDescriptor (derived from @sigloch/contracts/se) [CR-195a]
-export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph } from './se-descriptor.js';
+export { SE_DESCRIPTOR, createSeDescriptor, projectToOntologyGraph, fromOntologyGraph } from './se-descriptor.js';
 // Root-Suche — strukturelle Wurzel (SYS ohne eingehende compose), statt UID-Hardcode
 export { findRoot } from './find-root.js';
 // Edge ops — update-edge (flip/retype) + merge-nodes, shared by GraphService.mutate()

package/dist/se-descriptor.d.ts

@@ -17,6 +17,30 @@ import type { Graph, OntologyDescriptor } from './types.js';
  * attributes (asil/method/kinds/status) are lifted out of `attributes`.
  */
 export declare function projectToOntologyGraph(graph: Graph): OntologyGraph;
+/**
+ * The INVERSE of `projectToOntologyGraph`: an OntologyGraph (elements/traces) back
+ * to the ontology-agnostic Graph (nodes/edges) — every attribute restored under
+ * `attributes`, where the rules read them.
+ *
+ * Why this must be published (CR-SM-254): only the forward direction was exported,
+ * so every consumer that READS a committed `*.graph.json` hand-rolled its own mirror
+ * — and the mirrors drifted. Two were found wrong the same day, both in the same
+ * half: they lifted `status/asil/method/kinds` and forgot `realRef`/`testRefs`, so
+ * `R-19`/`R-20` silently read "unbound" on a fully bound graph and a dashboard
+ * reported `TRR 0/214` against a store that said `214/214`. A hand-rolled inverse
+ * cannot be kept honest by review; it has to have one home.
+ *
+ * Accepts BOTH shapes in the wild, which is the whole point:
+ *   - what THIS module emits — attributes nested under `attributes`, plus the
+ *     lifted convenience fields (status/asil/method/kinds) alongside;
+ *   - a FLATTENED snapshot — `{id, type, name, description, ...attributes}` with no
+ *     `attributes` key at all (graphcode's committed SSOT since its CR-GC-219, which
+ *     drops the nested duplicate so the file a human diffs carries each value once).
+ *
+ * Nested wins nothing: a key already present at top level is never clobbered, so
+ * re-import of an already-flat element is idempotent.
+ */
+export declare function fromOntologyGraph(json: OntologyGraph): Graph;
 /**
  * Canonical SE OntologyDescriptor (ontology + V3 rules + MT metrics), version-pinned
  * to contracts/se ONTOLOGY_VERSION. Plug into GraphService / FormatECodec.

package/dist/se-descriptor.js

@@ -42,6 +42,67 @@ export function projectToOntologyGraph(graph) {
     }));
     return { elements, traces };
 }
+/**
+ * The INVERSE of `projectToOntologyGraph`: an OntologyGraph (elements/traces) back
+ * to the ontology-agnostic Graph (nodes/edges) — every attribute restored under
+ * `attributes`, where the rules read them.
+ *
+ * Why this must be published (CR-SM-254): only the forward direction was exported,
+ * so every consumer that READS a committed `*.graph.json` hand-rolled its own mirror
+ * — and the mirrors drifted. Two were found wrong the same day, both in the same
+ * half: they lifted `status/asil/method/kinds` and forgot `realRef`/`testRefs`, so
+ * `R-19`/`R-20` silently read "unbound" on a fully bound graph and a dashboard
+ * reported `TRR 0/214` against a store that said `214/214`. A hand-rolled inverse
+ * cannot be kept honest by review; it has to have one home.
+ *
+ * Accepts BOTH shapes in the wild, which is the whole point:
+ *   - what THIS module emits — attributes nested under `attributes`, plus the
+ *     lifted convenience fields (status/asil/method/kinds) alongside;
+ *   - a FLATTENED snapshot — `{id, type, name, description, ...attributes}` with no
+ *     `attributes` key at all (graphcode's committed SSOT since its CR-GC-219, which
+ *     drops the nested duplicate so the file a human diffs carries each value once).
+ *
+ * Nested wins nothing: a key already present at top level is never clobbered, so
+ * re-import of an already-flat element is idempotent.
+ */
+export function fromOntologyGraph(json) {
+    const nodes = (json.elements ?? []).map((e) => {
+        const { id, type, name, description, created_at, updated_at, ...rest } = e;
+        return {
+            uid: id,
+            type,
+            name: name ?? id,
+            description: description ?? '',
+            createdAt: created_at,
+            updatedAt: updated_at,
+            attributes: liftAttributes(rest),
+        };
+    });
+    const edges = (json.traces ?? []).map((t) => {
+        const { source, target, type, ...rest } = t;
+        return { sourceId: source, targetId: target, edgeType: type, attributes: liftAttributes(rest) };
+    });
+    return { nodes, edges };
+}
+/**
+ * Merge a nested `attributes` object UP one level and drop the nesting key, so both
+ * the nested and the flattened shape yield the same `attributes`. Idempotent: an
+ * entry with no nested object is returned unchanged.
+ */
+function liftAttributes(rest) {
+    const nested = rest.attributes;
+    if (nested === null || typeof nested !== 'object' || Array.isArray(nested)) {
+        const { attributes: _absent, ...flat } = rest;
+        return flat;
+    }
+    const { attributes: _drop, ...top } = rest;
+    const out = { ...top };
+    for (const [k, v] of Object.entries(nested)) {
+        if (!(k in out))
+            out[k] = v;
+    }
+    return out;
+}
 /**
  * The contracts/se rule catalog, adapted to graph-api-core's Rule shape.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/graph-api-core",
-  "version": "5.0.0",
+  "version": "5.2.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,7 +43,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@sigloch/contracts": ">=5 <6",
+    "@sigloch/contracts": ">=5 <7",
     "kuzu-wasm": "^0.11.3"
   },
   "peerDependenciesMeta": {
@@ -52,7 +52,7 @@
     }
   },
   "devDependencies": {
-    "@sigloch/contracts": "^5.0.1",
+    "@sigloch/contracts": "^6.0.0",
     "kuzu-wasm": "^0.11.3"
   }
 }