@lucern/graph-primitives 1.0.29 → 1.0.31

package/dist/epistemicHelpers.js

@@ -1,89 +1,14 @@
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric } from 'convex/server';
 import { generateGlobalId, assertUuidV7Identity } from '@lucern/contracts/ids';
-import { componentsGeneric, anyApi } from 'convex/server';
 import '@lucern/contracts';
 
-// src/graphTypes.ts
-var NODE_TYPE_TO_LABEL = {
-  // L4: Audit Targets
-  decision: "Decision",
-  // L3: Traversal Anchors
-  belief: "Belief",
-  question: "Question",
-  theme: "Theme",
-  deal: "Deal",
-  topic: "Topic",
-  // L2: Compression Boundary
-  claim: "Claim",
-  evidence: "Evidence",
-  synthesis: "Synthesis",
-  answer: "Answer",
-  // L1: Terminal Leaves
-  atomic_fact: "AtomicFact",
-  excerpt: "Excerpt",
-  source: "Source",
-  // Ontological (Neo4j is SOT)
-  company: "Company",
-  person: "Person",
-  investor: "Investor",
-  function: "Function",
-  value_chain: "ValueChain"
-};
-var EDGE_TYPE_TO_REL = {
-  // === THE SIX CANONICAL EPISTEMIC EDGE TYPES ===
-  supports: "SUPPORTS",
-  // L3↔L3: belief bears on belief (weight -1 to +1)
-  informs: "INFORMS",
-  // L2→L3: evidence bears on belief
-  depends_on: "DEPENDS_ON",
-  // L3→L3, Q→Q: structural gate
-  derived_from: "DERIVED_FROM",
-  // Any→Any: provenance chain (fork, synthesis, extraction, answer)
-  contains: "CONTAINS",
-  // Any→Any: hierarchy, scoping, membership
-  tests: "TESTS",
-  // Q→L3: question interrogates belief
-  // === L4 DECISION EDGES (derived_from with derivationType=decision) ===
-  // Kept as separate Neo4j relationship types for backward compat with L4 queries.
-  // New code should use derived_from + metadata.
-  based_on_belief: "BASED_ON_BELIEF",
-  based_on_question: "BASED_ON_QUESTION",
-  blocked_by_contradiction: "BLOCKED_BY_CONTRADICTION",
-  informed_by_theme: "INFORMED_BY_THEME",
-  // === ONTOLOGICAL EDGES (tenant-extensible, managed by ontology system) ===
-  works_at: "WORKS_AT",
-  invested_in: "INVESTED_IN",
-  competes_with: "COMPETES_WITH",
-  participates_in: "PARTICIPATES_IN",
-  founded_by: "FOUNDED_BY",
-  evaluates: "EVALUATES",
-  performs: "PERFORMS",
-  function_in: "FUNCTION_IN",
-  impacts: "IMPACTS",
-  raised_from: "RAISED_FROM",
-  mentioned_in: "MENTIONED_IN",
-  perspective_on: "PERSPECTIVE_ON",
-  about_entity: "ABOUT_ENTITY",
-  entity_referenced_in: "ENTITY_REFERENCED_IN"
-};
-function getNeo4jLabel(nodeType) {
-  return NODE_TYPE_TO_LABEL[nodeType] || nodeType.charAt(0).toUpperCase() + nodeType.slice(1);
-}
-function getNeo4jRelType(edgeType) {
-  return EDGE_TYPE_TO_REL[edgeType] || edgeType.toUpperCase();
-}
-var CANONICAL_EPISTEMIC_TYPES = /* @__PURE__ */ new Set([
-  "supports",
-  "informs",
-  "depends_on",
-  "derived_from",
-  "contains",
-  "tests"
-]);
-function isDeprecatedEdgeType(edgeType) {
-  if (CANONICAL_EPISTEMIC_TYPES.has(edgeType)) return false;
-  if (edgeType in EDGE_TYPE_TO_REL) return false;
-  return true;
-}
+// src/convex.ts
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+componentsGeneric();
+var internal = unsafeApi;
 
 // src/epistemicLayerRules.ts
 function getNodeLayer(nodeType) {
@@ -265,11 +190,7 @@ function getDefaultEdgeTypesForMode(mode) {
         "same_theme_as"
       ];
     case "decision_trace":
-      return [
-        "derived_from",
-        "depends_on",
-        "contains"
-      ];
+      return ["derived_from", "depends_on", "contains"];
     default:
       return [];
   }
@@ -562,10 +483,63 @@ function validateEdgeLayers(edgeType, fromLayer, toLayer) {
   }
   return { valid: true };
 }
-componentsGeneric();
-var internal = anyApi;
 
 // src/epistemicEdgeCreation.ts
+var EPISTEMIC_LAYERS = /* @__PURE__ */ new Set([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readConvexId(value) {
+  const normalized = readOptionalString(value);
+  return normalized;
+}
+function readEpistemicLayer(value) {
+  const layer = readOptionalString(value);
+  return layer && EPISTEMIC_LAYERS.has(layer) ? layer : void 0;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readEdgeNodeRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  const globalId = readOptionalString(record.globalId);
+  const nodeType = readOptionalString(record.nodeType);
+  if (!(id && globalId && nodeType)) {
+    return null;
+  }
+  const node = { _id: id, globalId, nodeType };
+  const epistemicLayer = readEpistemicLayer(record.epistemicLayer);
+  if (epistemicLayer !== void 0) {
+    node.epistemicLayer = epistemicLayer;
+  }
+  const metadata = readRecord(record.metadata);
+  if (metadata !== void 0) {
+    node.metadata = metadata;
+  }
+  const projectId = readOptionalString(record.projectId);
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  return node;
+}
+function requireEdgeNodeRow(value, context) {
+  const node = readEdgeNodeRow(value);
+  if (!node) {
+    throw new Error(`${context} requires a canonical epistemic node row.`);
+  }
+  return node;
+}
 function normalizeConfidence(confidence) {
   if (typeof confidence === "number") {
     return confidence > 1 ? confidence / 100 : confidence;
@@ -586,13 +560,16 @@ function normalizeConfidence(confidence) {
 }
 async function createEpistemicEdge(ctx, params) {
   const globalId = generateGlobalId();
-  const fromNode = await ctx.db.get(params.fromNodeId);
-  const toNode = await ctx.db.get(params.toNodeId);
-  if (!fromNode || !toNode) {
-    throw new Error("One or both nodes not found");
-  }
-  const fromLayer = fromNode.epistemicLayer || getNodeLayer(fromNode.nodeType);
-  const toLayer = toNode.epistemicLayer || getNodeLayer(toNode.nodeType);
+  const fromNode = requireEdgeNodeRow(
+    await ctx.db.get(params.fromNodeId),
+    "Create epistemic edge source"
+  );
+  const toNode = requireEdgeNodeRow(
+    await ctx.db.get(params.toNodeId),
+    "Create epistemic edge target"
+  );
+  const fromLayer = fromNode.epistemicLayer ?? getNodeLayer(fromNode.nodeType);
+  const toLayer = toNode.epistemicLayer ?? getNodeLayer(toNode.nodeType);
   if (!params.skipLayerValidation) {
     const validation = validateEdgeLayers(params.edgeType, fromLayer, toLayer);
     if (!validation.valid) {
@@ -629,11 +606,11 @@ async function createEdgeForInsightQuestionLink(ctx, questionId, insightId, crea
     questionNode: questionNode ? String(questionNode) : null,
     insightNode: insightNode ? String(insightNode) : null
   });
-  if (!questionNode || !insightNode) {
+  if (!(questionNode && insightNode)) {
     console.log("[EpistemicSpine] Missing nodes, skipping edge creation");
     return null;
   }
-  const question = await ctx.db.get(questionId);
+  const question = readEdgeNodeRow(await ctx.db.get(questionId));
   const projectId = question?.projectId;
   return await createEpistemicEdge(ctx, {
     fromNodeId: insightNode,
@@ -645,16 +622,16 @@ async function createEdgeForInsightQuestionLink(ctx, questionId, insightId, crea
   });
 }
 async function findNodeByLegacyId(ctx, legacyType, legacyId) {
-  const nodeType = legacyType === "insight" ? "evidence" : legacyType === "artifact" ? "source" : legacyType;
+  const nodeType = normalizeLegacyNodeType(legacyType);
   const nodes = await ctx.db.query("epistemicNodes").withIndex(
     "by_nodeType",
     (q) => q.eq("nodeType", nodeType)
   ).collect();
   const legacyKey = `legacy${legacyType.charAt(0).toUpperCase() + legacyType.slice(1)}Id`;
   const legacyIdStr = String(legacyId);
-  const found = nodes.find((n) => {
-    const metadata = n.metadata;
-    const storedId = metadata?.[legacyKey];
+  const found = nodes.find((candidate) => {
+    const node = readEdgeNodeRow(candidate);
+    const storedId = node?.metadata?.[legacyKey];
     return storedId && String(storedId) === legacyIdStr;
   });
   if (!found) {
@@ -662,9 +639,18 @@ async function findNodeByLegacyId(ctx, legacyType, legacyId) {
       `[EpistemicSpine] Node not found for ${legacyType}:${legacyIdStr}, searched ${nodes.length} ${nodeType} nodes`
     );
   }
-  return found?._id ?? null;
+  return readEdgeNodeRow(found)?._id ?? null;
+}
+function normalizeLegacyNodeType(legacyType) {
+  if (legacyType === "insight") {
+    return "evidence";
+  }
+  if (legacyType === "artifact") {
+    return "source";
+  }
+  return legacyType;
 }
-async function insertEpistemicNode(ctx, doc) {
+function insertEpistemicNode(ctx, doc) {
   assertUuidV7Identity("epistemicNodes", doc.globalId);
   return ctx.db.insert("epistemicNodes", doc);
 }
@@ -674,8 +660,11 @@ function generateContentHash(nodeType, text) {
   const content = `${nodeType}:${normalizeText(text)}`;
   let hash = 5381;
   for (let i = 0; i < content.length; i++) {
-    hash = (hash << 5) + hash + content.charCodeAt(i);
-    hash &= hash;
+    const nextHash = hash * 33 + content.charCodeAt(i);
+    hash = nextHash - Math.floor(nextHash / 4294967296) * 4294967296;
+    if (hash >= 2147483648) {
+      hash -= 4294967296;
+    }
   }
   const hashHex = Math.abs(hash).toString(16).padStart(8, "0");
   const lengthHex = content.length.toString(16).padStart(4, "0");
@@ -685,6 +674,71 @@ function generateContentHash(nodeType, text) {
 function normalizeText(text) {
   return text.trim().toLowerCase().replace(/\s+/g, " ");
 }
+function readOptionalString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readOptionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readConvexId2(value) {
+  const normalized = readOptionalString2(value);
+  return normalized ? normalized : null;
+}
+function readExistingEpistemicNodeRow(value) {
+  const record = readRecord2(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId2(record._id);
+  if (!id) {
+    return null;
+  }
+  const node = { _id: id };
+  const metadata = readRecord2(record.metadata);
+  if (metadata) {
+    node.metadata = metadata;
+  }
+  const projectId = readOptionalString2(record.projectId);
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  const status = readOptionalString2(record.status);
+  if (status !== void 0) {
+    node.status = status;
+  }
+  return node;
+}
+function readSourceArtifactRow(value) {
+  const record = readRecord2(value);
+  if (!record) {
+    return null;
+  }
+  const artifact = {};
+  const content = readOptionalString2(record.content);
+  if (content !== void 0) {
+    artifact.content = content;
+  }
+  const metadata = readRecord2(record.metadata);
+  if (metadata) {
+    artifact.metadata = metadata;
+  }
+  const projectId = readOptionalString2(record.projectId);
+  if (projectId !== void 0) {
+    artifact.projectId = projectId;
+  }
+  const stage = readOptionalString2(record.stage);
+  if (stage !== void 0) {
+    artifact.stage = stage;
+  }
+  const topicId = readOptionalString2(record.topicId);
+  if (topicId !== void 0) {
+    artifact.topicId = topicId;
+  }
+  return artifact;
+}
 function mapInsightSourceType(sourceType) {
   switch (sourceType) {
     case "verified":
@@ -707,16 +761,38 @@ function mapVerificationStatus(status) {
       return "unverified";
   }
 }
+function inferInsightConfidence(verificationStatus) {
+  if (verificationStatus === "manually_verified") {
+    return 0.9;
+  }
+  if (verificationStatus === "deep_verified") {
+    return 0.7;
+  }
+  if (verificationStatus === "pre_screened") {
+    return 0.5;
+  }
+  return 0.3;
+}
+function mapQuestionSourceType(source) {
+  if (source === "manual") {
+    return "human";
+  }
+  if (source === "ai_suggested") {
+    return "ai_generated";
+  }
+  return "ai_extracted";
+}
 async function createEpistemicNodeForInsight(ctx, _insightId, insight) {
   const now = Date.now();
   const globalId = generateGlobalId();
   const contentHash = generateContentHash("evidence", insight.text);
   const existing = await ctx.db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", contentHash)).first();
-  if (existing && existing.status === "active") {
-    await ctx.db.patch(existing._id, {
+  const existingInsightNode = readExistingEpistemicNodeRow(existing);
+  if (existingInsightNode?.status === "active") {
+    await ctx.db.patch(existingInsightNode._id, {
       updatedAt: now
     });
-    return existing._id;
+    return existingInsightNode._id;
   }
   const nodeId = await insertEpistemicNode(ctx, {
     globalId,
@@ -752,7 +828,7 @@ async function createEpistemicNodeForInsight(ctx, _insightId, insight) {
     },
     sourceType: mapInsightSourceType(insight.sourceType),
     aiProvider: insight.aiProvider,
-    confidence: insight.verificationStatus === "manually_verified" ? 0.9 : insight.verificationStatus === "deep_verified" ? 0.7 : insight.verificationStatus === "pre_screened" ? 0.5 : 0.3,
+    confidence: inferInsightConfidence(insight.verificationStatus),
     verificationStatus: mapVerificationStatus(insight.verificationStatus),
     status: "active",
     topicId: insight.projectId,
@@ -784,15 +860,16 @@ async function createEpistemicNodeForBelief(ctx, beliefId, belief) {
   const globalId = generateGlobalId();
   const contentHash = generateContentHash("belief", belief.belief);
   const existing = await ctx.db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", contentHash)).first();
-  if (existing && existing.status === "active") {
-    await ctx.db.patch(existing._id, {
+  const existingBeliefNode = readExistingEpistemicNodeRow(existing);
+  if (existingBeliefNode?.status === "active") {
+    await ctx.db.patch(existingBeliefNode._id, {
       metadata: {
-        ...existing.metadata || {},
+        ...existingBeliefNode.metadata ?? {},
         sourceBeliefId: beliefId
       },
       updatedAt: now
     });
-    return existing._id;
+    return existingBeliefNode._id;
   }
   const nodeId = await insertEpistemicNode(ctx, {
     globalId,
@@ -835,13 +912,14 @@ async function createEpistemicNodeForQuestion(ctx, _questionId, question) {
   const globalId = generateGlobalId();
   const contentHash = generateContentHash("question", question.question);
   const existing = await ctx.db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", contentHash)).first();
-  if (existing && existing.status === "active") {
-    await ctx.db.patch(existing._id, {
+  const existingQuestionNode = readExistingEpistemicNodeRow(existing);
+  if (existingQuestionNode?.status === "active") {
+    await ctx.db.patch(existingQuestionNode._id, {
       updatedAt: now
     });
-    return existing._id;
+    return existingQuestionNode._id;
   }
-  const sourceType = question.source === "manual" ? "human" : question.source === "ai_suggested" ? "ai_generated" : "ai_extracted";
+  const sourceType = mapQuestionSourceType(question.source);
   const nodeId = await insertEpistemicNode(ctx, {
     globalId,
     nodeType: "question",
@@ -882,8 +960,9 @@ async function createEpistemicNodeForArtifact(ctx, artifactId, artifact) {
       artifact.title + artifact.content.slice(0, 500)
     );
     const existing2 = await ctx.db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", contentHash2)).first();
-    if (existing2 && existing2.status === "active") {
-      return existing2._id;
+    const existingSynthesisNode = readExistingEpistemicNodeRow(existing2);
+    if (existingSynthesisNode?.status === "active") {
+      return existingSynthesisNode._id;
     }
     throw new Error("SKIP_SYNTHESIS_NODE_CREATION");
   }
@@ -892,15 +971,16 @@ async function createEpistemicNodeForArtifact(ctx, artifactId, artifact) {
     artifact.title + artifact.content.slice(0, 500)
   );
   const existing = await ctx.db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", contentHash)).first();
-  if (existing && existing.status === "active") {
-    await ctx.db.patch(existing._id, {
+  const existingArtifactNode = readExistingEpistemicNodeRow(existing);
+  if (existingArtifactNode?.status === "active") {
+    await ctx.db.patch(existingArtifactNode._id, {
       metadata: {
-        ...existing.metadata || {},
+        ...existingArtifactNode.metadata ?? {},
         legacyArtifactId: artifactId
       },
       updatedAt: now
     });
-    return existing._id;
+    return existingArtifactNode._id;
   }
   const epistemicLayer = "L1";
   const nodeId = await insertEpistemicNode(ctx, {
@@ -929,21 +1009,28 @@ async function createEpistemicNodeForArtifact(ctx, artifactId, artifact) {
   return nodeId;
 }
 async function findOrCreateSourceNode(ctx, artifactId, createdBy, scopeProjectId) {
-  const artifact = await ctx.db.get(artifactId);
+  const artifact = readSourceArtifactRow(await ctx.db.get(artifactId));
   const effectiveProjectId = scopeProjectId || artifact?.projectId;
   const effectiveTopicId = artifact?.topicId;
   let existingNodes;
   if (effectiveTopicId) {
-    existingNodes = await ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", effectiveTopicId)).collect();
+    const collectedNodes = await ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", effectiveTopicId)).collect();
+    existingNodes = collectedNodes.flatMap((node) => {
+      const row = readExistingEpistemicNodeRow(node);
+      return row ? [row] : [];
+    });
   } else {
-    existingNodes = await ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "source")).collect();
+    const collectedNodes = await ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "source")).collect();
+    existingNodes = collectedNodes.flatMap((node) => {
+      const row = readExistingEpistemicNodeRow(node);
+      return row ? [row] : [];
+    });
   }
   const existing = existingNodes.find((n) => {
     if (effectiveProjectId && n.projectId && n.projectId !== effectiveProjectId) {
       return false;
     }
-    const metadata = n.metadata;
-    return metadata?.legacyArtifactId === artifactId;
+    return n.metadata?.legacyArtifactId === artifactId;
   });
   if (existing) {
     return existing._id;
@@ -953,18 +1040,18 @@ async function findOrCreateSourceNode(ctx, artifactId, createdBy, scopeProjectId
   }
   const now = Date.now();
   const globalId = generateGlobalId();
-  const artifactType = artifact.metadata?.type || "";
-  const isDeepResearch = artifact.metadata?.isDeepResearch;
+  const artifactType = readOptionalString2(artifact.metadata?.type) ?? "";
+  const isDeepResearch = readOptionalBoolean(artifact.metadata?.isDeepResearch) ?? false;
   let nodeType = "source";
   if (isDeepResearch || artifactType.includes("deep") || artifactType.includes("research")) {
     nodeType = "synthesis";
   } else if (artifactType.includes("primer")) {
     nodeType = "synthesis";
   }
-  const title = artifact.metadata?.title || artifact.metadata?.theme || "Untitled";
+  const title = readOptionalString2(artifact.metadata?.title) || readOptionalString2(artifact.metadata?.theme) || "Untitled";
   const contentHash = generateContentHash(
     nodeType,
-    title + (artifact.content?.slice(0, 500) || "")
+    title + (artifact.content?.slice(0, 500) ?? "")
   );
   const epistemicLayer = nodeType === "synthesis" ? "L2" : "L1";
   const nodeId = await insertEpistemicNode(ctx, {
@@ -994,6 +1081,93 @@ async function findOrCreateSourceNode(ctx, artifactId, createdBy, scopeProjectId
   return nodeId;
 }
 
+// src/graphTypes.ts
+var NODE_TYPE_TO_LABEL = {
+  // L4: Audit Targets
+  decision: "Decision",
+  // L3: Traversal Anchors
+  belief: "Belief",
+  question: "Question",
+  theme: "Theme",
+  deal: "Deal",
+  topic: "Topic",
+  // L2: Compression Boundary
+  claim: "Claim",
+  evidence: "Evidence",
+  synthesis: "Synthesis",
+  answer: "Answer",
+  // L1: Terminal Leaves
+  atomic_fact: "AtomicFact",
+  excerpt: "Excerpt",
+  source: "Source",
+  // Ontological (Neo4j is SOT)
+  company: "Company",
+  person: "Person",
+  investor: "Investor",
+  function: "Function",
+  value_chain: "ValueChain"
+};
+var EDGE_TYPE_TO_REL = {
+  // === THE SIX CANONICAL EPISTEMIC EDGE TYPES ===
+  supports: "SUPPORTS",
+  // L3↔L3: belief bears on belief (weight -1 to +1)
+  informs: "INFORMS",
+  // L2→L3: evidence bears on belief
+  depends_on: "DEPENDS_ON",
+  // L3→L3, Q→Q: structural gate
+  derived_from: "DERIVED_FROM",
+  // Any→Any: provenance chain (fork, synthesis, extraction, answer)
+  contains: "CONTAINS",
+  // Any→Any: hierarchy, scoping, membership
+  tests: "TESTS",
+  // Q→L3: question interrogates belief
+  // === L4 DECISION EDGES (derived_from with derivationType=decision) ===
+  // Kept as separate Neo4j relationship types for backward compat with L4 queries.
+  // New code should use derived_from + metadata.
+  based_on_belief: "BASED_ON_BELIEF",
+  based_on_question: "BASED_ON_QUESTION",
+  blocked_by_contradiction: "BLOCKED_BY_CONTRADICTION",
+  informed_by_theme: "INFORMED_BY_THEME",
+  // === ONTOLOGICAL EDGES (tenant-extensible, managed by ontology system) ===
+  works_at: "WORKS_AT",
+  invested_in: "INVESTED_IN",
+  competes_with: "COMPETES_WITH",
+  participates_in: "PARTICIPATES_IN",
+  founded_by: "FOUNDED_BY",
+  evaluates: "EVALUATES",
+  performs: "PERFORMS",
+  function_in: "FUNCTION_IN",
+  impacts: "IMPACTS",
+  raised_from: "RAISED_FROM",
+  mentioned_in: "MENTIONED_IN",
+  perspective_on: "PERSPECTIVE_ON",
+  about_entity: "ABOUT_ENTITY",
+  entity_referenced_in: "ENTITY_REFERENCED_IN"
+};
+function getNeo4jLabel(nodeType) {
+  return NODE_TYPE_TO_LABEL[nodeType] || nodeType.charAt(0).toUpperCase() + nodeType.slice(1);
+}
+function getNeo4jRelType(edgeType) {
+  return EDGE_TYPE_TO_REL[edgeType] || edgeType.toUpperCase();
+}
+var CANONICAL_EPISTEMIC_TYPES = /* @__PURE__ */ new Set([
+  "supports",
+  "informs",
+  "depends_on",
+  "derived_from",
+  "contains",
+  "tests"
+]);
+function isDeprecatedEdgeType(edgeType) {
+  if (CANONICAL_EPISTEMIC_TYPES.has(edgeType)) {
+    return false;
+  }
+  if (edgeType in EDGE_TYPE_TO_REL) {
+    return false;
+  }
+  return true;
+}
+
 export { EDGE_LAYER_RULES, LAYER_TRAVERSAL_RULES, canTraverseToLayer, createEdgeForInsightQuestionLink, createEpistemicEdge, createEpistemicNodeForArtifact, createEpistemicNodeForBelief, createEpistemicNodeForInsight, createEpistemicNodeForQuestion, getDefaultEdgeTypesForMode, getDefaultMinLayer, getLayerDepth, getNeo4jLabel, getNeo4jRelType, getNodeLayer, isDeprecatedEdgeType, isValidLayerConnection, normalizeConfidence, shouldContinueTraversal, validateEdgeLayers };
 //# sourceMappingURL=epistemicHelpers.js.map
 //# sourceMappingURL=epistemicHelpers.js.map