@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/epistemicNodes.internal.js

@@ -1,13 +1,17 @@
-import { v } from 'convex/values';
-import { componentsGeneric, anyApi, internalMutationGeneric, internalQueryGeneric } from 'convex/server';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { assertUuidV7Identity } from '@lucern/contracts/ids';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, internalMutationGeneric, internalQueryGeneric } from 'convex/server';
 import '@lucern/contracts';
+import { assertUuidV7Identity } from '@lucern/contracts/ids';
 
 // src/epistemicNodes.internal.ts
-var api = anyApi;
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
 componentsGeneric();
-var internal = anyApi;
+var internal = unsafeApi;
 var internalMutation = internalMutationGeneric;
 var internalQuery = internalQueryGeneric;
 
@@ -22,6 +26,200 @@ function debugGraphPrimitiveFallback(message, context) {
   }
   console.debug(message, context ?? {});
 }
+function insertEpistemicNode(ctx, doc) {
+  assertUuidV7Identity("epistemicNodes", doc.globalId);
+  return ctx.db.insert("epistemicNodes", doc);
+}
+
+// src/epistemicNodes.helpers.ts
+function buildNodeStatusSuccessResult() {
+  return { success: true };
+}
+function buildNodeNotFoundResult() {
+  const result = {};
+  result.success = false;
+  result.error = "Node not found";
+  return result;
+}
+function buildNodeDeletedResult(deletedEdgeCount) {
+  return {
+    success: true,
+    deletedEdgeCount
+  };
+}
+v.union(
+  v.literal("L4"),
+  v.literal("L3"),
+  v.literal("L2"),
+  v.literal("L1"),
+  v.literal("ontological"),
+  v.literal("organizational")
+);
+v.union(v.literal("decision"));
+v.union(
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal")
+);
+v.union(
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis")
+);
+v.union(
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source")
+);
+v.union(
+  // L4: Audit targets
+  v.literal("decision"),
+  // L3: Traversal anchors
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal"),
+  // L2: Compression boundary
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis"),
+  v.literal("answer"),
+  // L1: Terminal leaves
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source")
+);
+v.union(
+  v.literal("company"),
+  v.literal("person"),
+  v.literal("investor"),
+  v.literal("function"),
+  v.literal("value_chain")
+);
+v.union(v.literal("topic"));
+var nodeTypeValidator = v.union(
+  // L4: Audit targets
+  v.literal("decision"),
+  // L3: Traversal anchors
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal"),
+  // L2: Compression boundary
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis"),
+  v.literal("answer"),
+  // L1: Terminal leaves
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source"),
+  // Ontological
+  v.literal("company"),
+  v.literal("person"),
+  v.literal("investor"),
+  v.literal("function"),
+  v.literal("value_chain"),
+  // Organizational
+  v.literal("topic")
+);
+var sourceTypeValidator = v.union(
+  v.literal("human"),
+  v.literal("ai_extracted"),
+  v.literal("ai_generated"),
+  v.literal("imported"),
+  v.literal("system")
+  // System-generated (migrations, classifiers)
+);
+v.union(
+  v.literal("active"),
+  v.literal("superseded"),
+  v.literal("archived"),
+  v.literal("deleted")
+);
+var verificationStatusValidator = v.union(
+  v.literal("unverified"),
+  v.literal("human_verified"),
+  v.literal("ai_verified"),
+  v.literal("contradicted"),
+  v.literal("outdated")
+);
+
+// src/graphTypes.ts
+function getNodeLayer(nodeType) {
+  const L4_TYPES = ["decision"];
+  const L3_TYPES = ["belief", "question", "theme", "deal"];
+  const L2_TYPES = ["claim", "evidence", "synthesis", "answer"];
+  const L1_TYPES = ["atomic_fact", "excerpt", "source"];
+  const ONTOLOGICAL_TYPES = [
+    "company",
+    "person",
+    "investor",
+    "function",
+    "value_chain"
+  ];
+  const ORGANIZATIONAL_TYPES = ["topic"];
+  if (L4_TYPES.includes(nodeType)) {
+    return "L4";
+  }
+  if (L3_TYPES.includes(nodeType)) {
+    return "L3";
+  }
+  if (L2_TYPES.includes(nodeType)) {
+    return "L2";
+  }
+  if (L1_TYPES.includes(nodeType)) {
+    return "L1";
+  }
+  if (ONTOLOGICAL_TYPES.includes(nodeType)) {
+    return "ontological";
+  }
+  if (ORGANIZATIONAL_TYPES.includes(nodeType)) {
+    return "organizational";
+  }
+  console.warn(`[GraphTypes] Unknown nodeType "${nodeType}", defaulting to L2`);
+  return "L2";
+}
+
+// src/invariantEnforcement.ts
+function throwInvariantError(args) {
+  const error = new Error(args.message);
+  error.status = args.status ?? 409;
+  error.code = args.code ?? "INVARIANT_VIOLATION";
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function isBeliefNode(node) {
+  return node?.nodeType === "belief";
+}
+function assertBeliefNodeHardDeleteAllowed(args) {
+  if (!isBeliefNode(args.node)) {
+    return;
+  }
+  if (!args.allowBeliefHardDelete) {
+    throwInvariantError({
+      message: "Belief hard delete is forbidden by default. Beliefs must retain lineage and audit history.",
+      invariantCode: "belief.hard_delete_forbidden",
+      suggestion: "Use epistemicBeliefs.archive() or epistemicBeliefs.forkBelief() instead. Only migration repair flows may opt into hard delete explicitly.",
+      details: { mutationName: args.mutationName, nodeId: args.node._id }
+    });
+  }
+  if (!args.reason.trim().toLowerCase().startsWith("migration:")) {
+    throwInvariantError({
+      message: "Belief hard delete bypasses require a migration-scoped rationale.",
+      invariantCode: "belief.hard_delete_forbidden",
+      suggestion: 'Retry with allowBeliefHardDelete: true and a reason starting with "migration:" only for one-off data repair flows.',
+      details: {
+        mutationName: args.mutationName,
+        nodeId: args.node._id,
+        reason: args.reason
+      }
+    });
+  }
+}
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
 async function resolveTopicNodeScopeOrNull(ctx, ref) {
   if (!ctx?.db || typeof ctx.db.query !== "function") {
@@ -56,13 +254,15 @@ function asMappedProjectId(topic) {
   if (!topic) {
     return;
   }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  const directLegacyProjectId = normalizeScopeValue(
+    topic[LEGACY_SCOPE_FIELD]
+  );
   if (directLegacyProjectId) {
     return directLegacyProjectId;
   }
   const metadata = topic.metadata || {};
   const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
-  return candidate ? candidate : void 0;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
 }
 function normalizeScopeValue(value) {
   if (typeof value !== "string") {
@@ -87,8 +287,9 @@ function pickPrimaryTopic(candidates) {
   })[0];
 }
 async function findTopicsByScopeAlias(ctx, scopeId) {
+  const query = ctx.db.query("topics");
   try {
-    return await ctx.db.query("topics").withIndex(
+    return await query.withIndex(
       "by_graph_scope_project",
       (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
     ).collect();
@@ -100,7 +301,7 @@ async function findTopicsByScopeAlias(ctx, scopeId) {
         scopeId
       }
     );
-    const topics = await ctx.db.query("topics").collect();
+    const topics = await query.collect();
     return topics.filter((topic) => {
       const normalizedGlobalId = normalizeScopeValue(topic.globalId);
       const mappedProjectId = asMappedProjectId(topic);
@@ -156,338 +357,196 @@ async function resolveInheritedWorkspaceScope(ctx, topic) {
   let current = topic;
   for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
     current = await ctx.db.get(current.parentTopicId);
-    if (!current) break;
+    if (!current) {
+      break;
+    }
     if (!tenantId) {
       tenantId = normalizeScopeValue(current.tenantId);
     }
     if (!workspaceId) {
       workspaceId = normalizeScopeValue(current.workspaceId);
     }
-    if (tenantId && workspaceId) break;
+    if (tenantId && workspaceId) {
+      break;
+    }
   }
   return { tenantId, workspaceId };
 }
 async function resolveTopicProjectScope(ctx, args) {
   if (args.topicId) {
-    let topic = null;
-    try {
-      topic = await ctx.db.get(
-        args.topicId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load topic by direct id",
-        {
-          error,
-          topicId: args.topicId
-        }
-      );
-    }
-    if (!topic) {
-      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
-    }
-    if (!topic) {
-      topic = pickPrimaryTopic(
-        await findTopicsByScopeAlias(ctx, String(args.topicId))
-      ) ?? null;
-    }
-    if (!topic) {
-      const nodeScope = await resolveTopicNodeScopeOrNull(
-        ctx,
-        String(args.topicId)
-      );
-      if (nodeScope) {
-        return nodeScope;
-      }
-      throw new Error(`Topic not found: ${String(args.topicId)}`);
-    }
-    const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
-    const mapped = asMappedProjectId(topic);
-    if (mapped) {
-      return {
-        topicId: topic._id,
-        projectId: mapped,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic"
-      };
-    }
-    return {
-      topicId: topic._id,
-      tenantId: inherited.tenantId,
-      workspaceId: inherited.workspaceId,
-      source: "topic"
-    };
+    return await resolveScopeFromTopicId(ctx, args.topicId);
   }
   if (args.projectId) {
-    let directTopic = null;
-    try {
-      directTopic = await ctx.db.get(
-        args.projectId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load direct project topic",
-        {
-          error,
-          projectId: args.projectId
-        }
-      );
-    }
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    directTopic = await tryResolveHostTopicByLegacyScope(ctx, args.projectId);
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    const topics = await findTopicsByScopeAlias(ctx, args.projectId);
-    const primary = pickPrimaryTopic(topics);
-    if (primary) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, primary);
-      return {
-        topicId: primary._id,
-        projectId: args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "project_mapped_topic"
-      };
-    }
-    const nodeScope = await resolveTopicNodeScopeOrNull(
-      ctx,
-      String(args.projectId)
-    );
-    if (nodeScope) {
-      return {
-        ...nodeScope,
-        projectId: nodeScope.projectId ?? String(args.projectId)
-      };
-    }
-    throw new Error(
-      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
-    );
+    return await resolveScopeFromLegacyProjectId(ctx, args.projectId);
   }
   throw new Error(
     "Missing scope: provide topicId (preferred) or legacy projectId alias."
   );
 }
-var optionalScopeArgs = {
-  projectId: v.optional(v.string()),
-  topicId: v.optional(v.string())
-};
-
-// src/graphTypes.ts
-function getNodeLayer(nodeType) {
-  const L4_TYPES = ["decision"];
-  const L3_TYPES = ["belief", "question", "theme", "deal"];
-  const L2_TYPES = ["claim", "evidence", "synthesis", "answer"];
-  const L1_TYPES = ["atomic_fact", "excerpt", "source"];
-  const ONTOLOGICAL_TYPES = [
-    "company",
-    "person",
-    "investor",
-    "function",
-    "value_chain"
-  ];
-  const ORGANIZATIONAL_TYPES = ["topic"];
-  if (L4_TYPES.includes(nodeType)) {
-    return "L4";
+async function resolveScopeFromTopicId(ctx, topicId) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
   }
-  if (L3_TYPES.includes(nodeType)) {
-    return "L3";
-  }
-  if (L2_TYPES.includes(nodeType)) {
-    return "L2";
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, String(topicId));
+  if (nodeScope) {
+    return nodeScope;
   }
-  if (L1_TYPES.includes(nodeType)) {
-    return "L1";
+  throw new Error(`Topic not found: ${String(topicId)}`);
+}
+async function resolveTopicDocFromTopicId(ctx, topicId) {
+  const direct = await tryReadTopicDoc(ctx, topicId, {
+    failureLog: "[topicScope] Failed to load topic by direct id",
+    idLogKey: "topicId"
+  });
+  if (direct) {
+    return direct;
+  }
+  const hostTopic = await tryResolveHostTopicById(ctx, String(topicId));
+  if (hostTopic) {
+    return hostTopic;
+  }
+  return pickPrimaryTopic(await findTopicsByScopeAlias(ctx, String(topicId))) ?? null;
+}
+async function resolveScopeFromLegacyProjectId(ctx, legacyProjectId) {
+  const directTopic = await resolveDirectLegacyProjectTopic(
+    ctx,
+    legacyProjectId
+  );
+  if (directTopic) {
+    return await buildTopicScope(ctx, directTopic, "topic_inferred", {
+      fallbackProjectId: legacyProjectId
+    });
   }
-  if (ONTOLOGICAL_TYPES.includes(nodeType)) {
-    return "ontological";
+  const primary = pickPrimaryTopic(
+    await findTopicsByScopeAlias(ctx, legacyProjectId)
+  );
+  if (primary) {
+    return await buildTopicScope(ctx, primary, "project_mapped_topic", {
+      fallbackProjectId: legacyProjectId
+    });
   }
-  if (ORGANIZATIONAL_TYPES.includes(nodeType)) {
-    return "organizational";
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, legacyProjectId);
+  if (nodeScope) {
+    return {
+      ...nodeScope,
+      projectId: nodeScope.projectId ?? legacyProjectId
+    };
   }
-  console.warn(`[GraphTypes] Unknown nodeType "${nodeType}", defaulting to L2`);
-  return "L2";
+  throw new Error(
+    `Legacy project scope ${legacyProjectId} has no mapped topic.`
+  );
 }
-
-// src/epistemicNodes.helpers.ts
-function buildNodeStatusSuccessResult() {
-  return { success: true };
+async function resolveDirectLegacyProjectTopic(ctx, legacyProjectId) {
+  const directTopic = await tryReadTopicDoc(ctx, legacyProjectId, {
+    failureLog: "[topicScope] Failed to load direct project topic",
+    idLogKey: "projectId"
+  });
+  return directTopic ?? tryResolveHostTopicByLegacyScope(ctx, legacyProjectId);
 }
-function buildNodeNotFoundResult() {
-  const result = {};
-  result.success = false;
-  result.error = "Node not found";
-  return result;
+async function tryReadTopicDoc(ctx, id, log) {
+  try {
+    return await ctx.db.get(id);
+  } catch (error) {
+    debugGraphPrimitiveFallback(log.failureLog, {
+      error,
+      [log.idLogKey]: id
+    });
+    return null;
+  }
 }
-function buildNodeDeletedResult(deletedEdgeCount) {
+async function buildTopicScope(ctx, topic, source, options = {}) {
+  const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+  const mapped = asMappedProjectId(topic);
   return {
-    success: true,
-    deletedEdgeCount
+    topicId: topic._id,
+    ...mapped || options.fallbackProjectId ? { projectId: mapped ?? options.fallbackProjectId } : {},
+    tenantId: inherited.tenantId,
+    workspaceId: inherited.workspaceId,
+    source
   };
 }
-v.union(
-  v.literal("L4"),
-  v.literal("L3"),
-  v.literal("L2"),
-  v.literal("L1"),
-  v.literal("ontological"),
-  v.literal("organizational")
-);
-v.union(v.literal("decision"));
-v.union(
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal")
-);
-v.union(
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis")
-);
-v.union(
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source")
-);
-v.union(
-  // L4: Audit targets
-  v.literal("decision"),
-  // L3: Traversal anchors
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal"),
-  // L2: Compression boundary
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis"),
-  v.literal("answer"),
-  // L1: Terminal leaves
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source")
-);
-v.union(
-  v.literal("company"),
-  v.literal("person"),
-  v.literal("investor"),
-  v.literal("function"),
-  v.literal("value_chain")
-);
-v.union(v.literal("topic"));
-var nodeTypeValidator = v.union(
-  // L4: Audit targets
-  v.literal("decision"),
-  // L3: Traversal anchors
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal"),
-  // L2: Compression boundary
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis"),
-  v.literal("answer"),
-  // L1: Terminal leaves
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source"),
-  // Ontological
-  v.literal("company"),
-  v.literal("person"),
-  v.literal("investor"),
-  v.literal("function"),
-  v.literal("value_chain"),
-  // Organizational
-  v.literal("topic")
-);
-var sourceTypeValidator = v.union(
-  v.literal("human"),
-  v.literal("ai_extracted"),
-  v.literal("ai_generated"),
-  v.literal("imported"),
-  v.literal("system")
-  // System-generated (migrations, classifiers)
-);
-v.union(
-  v.literal("active"),
-  v.literal("superseded"),
-  v.literal("archived"),
-  v.literal("deleted")
-);
-var verificationStatusValidator = v.union(
-  v.literal("unverified"),
-  v.literal("human_verified"),
-  v.literal("ai_verified"),
-  v.literal("contradicted"),
-  v.literal("outdated")
-);
+var optionalScopeArgs = {
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+};
 
-// src/invariantEnforcement.ts
-function throwInvariantError(args) {
-  const error = new Error(args.message);
-  error.status = args.status ?? 409;
-  error.code = args.code ?? "INVARIANT_VIOLATION";
-  error.invariantCode = args.invariantCode;
-  error.suggestion = args.suggestion;
-  error.details = args.details;
-  throw error;
+// src/epistemicNodes.internal.ts
+var optionalNodeScopeArgs = optionalScopeArgs;
+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 isBeliefNode(node) {
-  return node?.nodeType === "belief";
+function readConvexId(value) {
+  const normalized = readOptionalString(value);
+  return normalized ? normalized : null;
 }
-function assertBeliefNodeHardDeleteAllowed(args) {
-  if (!isBeliefNode(args.node)) {
-    return;
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readEpistemicLayer(value) {
+  const layer = readOptionalString(value);
+  return layer && EPISTEMIC_LAYERS.has(layer) ? layer : void 0;
+}
+function resolveEpistemicLayer(args) {
+  return readEpistemicLayer(args.providedLayer) ?? getNodeLayer(args.nodeType);
+}
+function readInternalNodeRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
   }
-  if (!args.allowBeliefHardDelete) {
-    throwInvariantError({
-      message: "Belief hard delete is forbidden by default. Beliefs must retain lineage and audit history.",
-      invariantCode: "belief.hard_delete_forbidden",
-      suggestion: "Use epistemicBeliefs.archive() or epistemicBeliefs.forkBelief() instead. Only migration repair flows may opt into hard delete explicitly.",
-      details: { mutationName: args.mutationName, nodeId: args.node._id }
-    });
+  const id = readConvexId(record._id);
+  const nodeType = readOptionalString(record.nodeType);
+  if (!(id && nodeType)) {
+    return null;
   }
-  if (!args.reason.trim().toLowerCase().startsWith("migration:")) {
-    throwInvariantError({
-      message: "Belief hard delete bypasses require a migration-scoped rationale.",
-      invariantCode: "belief.hard_delete_forbidden",
-      suggestion: 'Retry with allowBeliefHardDelete: true and a reason starting with "migration:" only for one-off data repair flows.',
-      details: {
-        mutationName: args.mutationName,
-        nodeId: args.node._id,
-        reason: args.reason
-      }
-    });
+  const node = { _id: id, nodeType };
+  const canonicalText = readOptionalString(record.canonicalText);
+  if (canonicalText !== void 0) {
+    node.canonicalText = canonicalText;
+  }
+  const globalId = readOptionalString(record.globalId);
+  if (globalId !== void 0) {
+    node.globalId = globalId;
+  }
+  const projectId = readOptionalString(record.projectId);
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  const status = readOptionalString(record.status);
+  if (status !== void 0) {
+    node.status = status;
+  }
+  const title = readOptionalString(record.title);
+  if (title !== void 0) {
+    node.title = title;
   }
+  return node;
 }
-async function insertEpistemicNode(ctx, doc) {
-  assertUuidV7Identity("epistemicNodes", doc.globalId);
-  return ctx.db.insert("epistemicNodes", doc);
+function readInternalEdgeRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  if (!id) {
+    return null;
+  }
+  const edge = { _id: id };
+  const globalId = readOptionalString(record.globalId);
+  if (globalId !== void 0) {
+    edge.globalId = globalId;
+  }
+  return edge;
 }
-
-// src/epistemicNodes.internal.ts
-var optionalNodeScopeArgs = optionalScopeArgs;
 var createInternal = internalMutation({
   args: {
     ...optionalNodeScopeArgs,
@@ -547,11 +606,14 @@ var createInternal = internalMutation({
             projectId: args.projectId
           }
         );
-        return void 0;
+        return;
       }
     })() : void 0;
     const contentHash = args.contentHash || `${args.nodeType}:${args.canonicalText}`.slice(0, 64);
-    const epistemicLayer = args.epistemicLayer || getNodeLayer(args.nodeType);
+    const epistemicLayer = resolveEpistemicLayer({
+      nodeType: args.nodeType,
+      providedLayer: args.epistemicLayer
+    });
     const nodeId = await insertEpistemicNode(ctx, {
       globalId: args.globalId,
       nodeType: args.nodeType,
@@ -592,9 +654,7 @@ var getInternal = internalQuery({
     nodeId: v.id("epistemicNodes")
   },
   returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.get(args.nodeId);
-  }
+  handler: async (ctx, args) => await ctx.db.get(args.nodeId)
 });
 var updateSyncStatus = internalMutation({
   args: {
@@ -663,7 +723,7 @@ var hardDelete = internalMutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.nodeId);
+    const node = readInternalNodeRow(await ctx.db.get(args.nodeId));
     if (!node) {
       return buildNodeNotFoundResult();
     }
@@ -675,7 +735,7 @@ var hardDelete = internalMutation({
     });
     await ctx.db.insert("epistemicAudit", {
       entityType: "node",
-      entityId: args.nodeId,
+      entityId: String(args.nodeId),
       changeType: "deleted",
       projectId: node.projectId,
       changedBy: "system:hard_delete",
@@ -683,21 +743,31 @@ var hardDelete = internalMutation({
       isAgent: false,
       previousState: {
         nodeType: node.nodeType,
-        title: node.title || node.canonicalText?.slice(0, 100),
+        title: node.title ?? node.canonicalText?.slice(0, 100),
         status: node.status
       },
       rationale: args.reason
     });
-    const fromEdges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", args.nodeId)).collect();
-    const toEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", args.nodeId)).collect();
+    const endpointRefs = [String(args.nodeId), node.globalId].filter(
+      (ref) => typeof ref === "string" && ref.length > 0
+    );
     const uniqueEdges = /* @__PURE__ */ new Map();
-    for (const edge of [...fromEdges, ...toEdges]) {
-      uniqueEdges.set(edge.globalId, edge);
+    for (const endpointRef of endpointRefs) {
+      const fromEdges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", endpointRef)).collect();
+      const toEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", endpointRef)).collect();
+      for (const rawEdge of [...fromEdges, ...toEdges]) {
+        const edge = readInternalEdgeRow(rawEdge);
+        if (edge) {
+          uniqueEdges.set(edge.globalId ?? String(edge._id), edge);
+        }
+      }
     }
     for (const edge of uniqueEdges.values()) {
-      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
-        globalId: edge.globalId
-      });
+      if (edge.globalId) {
+        await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+          globalId: edge.globalId
+        });
+      }
       await ctx.db.delete(edge._id);
     }
     await ctx.db.delete(args.nodeId);