@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicEdges.queries.js

@@ -0,0 +1,851 @@
+import { v } from 'convex/values';
+import { checkScopeAccess } from '@lucern/access-control/access';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { componentsGeneric, queryGeneric, anyApi } from 'convex/server';
+
+// src/epistemicEdges.queries.ts
+
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+}
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
+  }
+  console.debug(message, context ?? {});
+}
+var api = anyApi;
+componentsGeneric();
+var query = queryGeneric;
+v.union(
+  v.literal("L4"),
+  v.literal("L3"),
+  v.literal("L2"),
+  v.literal("L1"),
+  v.literal("ontological"),
+  v.literal("organizational")
+);
+v.object({
+  b: v.number(),
+  d: v.number(),
+  u: v.number(),
+  a: v.number()
+});
+var edgeTypeValidator = v.union(
+  // --- L4 Decision Edges (Phase 2A) ---
+  v.literal("based_on_belief"),
+  v.literal("based_on_question"),
+  v.literal("blocked_by_contradiction"),
+  v.literal("informed_by_theme"),
+  // --- Evidence Flow (L2 → L3, L2 → L1) ---
+  v.literal("derived_from"),
+  v.literal("responds_to"),
+  v.literal("informs"),
+  v.literal("tests"),
+  v.literal("explores"),
+  v.literal("qualifies"),
+  // --- Synthesis (L2 → L2, L2 → L1) ---
+  // "based_on" removed — use "derived_from" instead
+  // --- Theme Relationships (L3 → L3) ---
+  v.literal("relates_to_thesis"),
+  v.literal("belongs_to"),
+  v.literal("plays_theme"),
+  v.literal("scoped_by"),
+  // --- Deal/Company ---
+  v.literal("evaluates"),
+  // --- People (ontological → ontological, ontological → L3) ---
+  v.literal("perspective_on"),
+  v.literal("works_at"),
+  v.literal("mentioned_in"),
+  v.literal("founded_by"),
+  // --- Value Chain (ontological → ontological) ---
+  v.literal("participates_in"),
+  v.literal("performs"),
+  v.literal("function_in"),
+  v.literal("impacts"),
+  // --- Investment (ontological → ontological) ---
+  v.literal("invested_in"),
+  v.literal("raised_from"),
+  // --- Lifecycle (same layer only) ---
+  v.literal("supersedes"),
+  v.literal("same_as"),
+  // --- Same-Type Relationships: Belief ↔ Belief (L3 → L3) ---
+  v.literal("depends_on"),
+  v.literal("supports"),
+  v.literal("contains"),
+  // --- Belief Cluster Mapping (L3 → L3) ---
+  v.literal("counterfactual_of"),
+  v.literal("cascade_to"),
+  v.literal("cascade_from"),
+  v.literal("mutually_exclusive"),
+  v.literal("correlates_with"),
+  v.literal("amplifies"),
+  v.literal("precondition_for"),
+  v.literal("in_tension_with"),
+  // --- Belief ↔ Belief: Epistemic Impact (Confidence Propagation) ---
+  v.literal("falsified_by"),
+  v.literal("exclusive_with"),
+  v.literal("contradicts"),
+  v.literal("collapses_if"),
+  v.literal("strengthened_by"),
+  v.literal("weakened_by"),
+  v.literal("alternative_to"),
+  v.literal("subsumes"),
+  v.literal("validated_by"),
+  v.literal("required_for"),
+  v.literal("blocks"),
+  // --- Same-Type Relationships: Question ↔ Question (L3 → L3) ---
+  v.literal("prerequisite_for"),
+  v.literal("parallel_to"),
+  // --- Same-Type Relationships: Evidence ↔ Evidence (L2 → L2) ---
+  v.literal("corroborates"),
+  v.literal("extends"),
+  v.literal("same_source_as"),
+  v.literal("same_theme_as"),
+  // --- NEW: Deep Epistemic Analysis Edges (Phase: Schema Upgrade) ---
+  v.literal("assumes"),
+  v.literal("would_predict"),
+  v.literal("analogous_to"),
+  v.literal("independent_of"),
+  // --- Entity↔Belief Bridge (OE-B) ---
+  v.literal("competes_with")
+);
+function edgeMatchesWorkspaceReasoningScope(edge, scope) {
+  return scope.topicId !== void 0 && edge.topicId === scope.topicId || scope.projectId !== void 0 && edge.projectId === scope.projectId;
+}
+async function collectScopedEdges(ctx, scope, scanLimit) {
+  const queries = [];
+  if (scope.topicId) {
+    queries.push(
+      ctx.db.query("epistemicEdges").withIndex(
+        "by_topic",
+        (q) => q.eq("topicId", scope.topicId)
+      ).order("desc").take(scanLimit)
+    );
+  }
+  if (scope.projectId) {
+    queries.push(
+      ctx.db.query("epistemicEdges").withIndex(
+        "by_topic",
+        (q) => q.eq("topicId", scope.projectId)
+      ).order("desc").take(scanLimit)
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  const flattened = (await Promise.all(queries)).flat();
+  for (const edge of flattened) {
+    const key = String(edge._id);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(edge);
+  }
+  return deduped;
+}
+
+// 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/edgeValidation.ts
+function getLayerDepth(layer) {
+  switch (layer) {
+    case "L4":
+      return 4;
+    case "L3":
+      return 3;
+    case "L2":
+      return 2;
+    case "L1":
+      return 1;
+    case "ontological":
+      return 0;
+    default:
+      return -1;
+  }
+}
+function shouldContinueTraversal(currentLayer, targetLayer, options) {
+  const currentDepth = getLayerDepth(currentLayer);
+  const targetDepth = getLayerDepth(targetLayer);
+  if (options.minLayer !== void 0 && targetDepth < options.minLayer) {
+    return false;
+  }
+  if (options.maxLayer !== void 0 && targetDepth > options.maxLayer) {
+    return false;
+  }
+  switch (options.mode) {
+    case "anchor_down":
+      return targetDepth <= currentDepth;
+    case "anchor_up":
+      return targetDepth >= currentDepth;
+    case "same_layer":
+      return targetDepth === currentDepth;
+    case "decision_trace":
+      return currentDepth === 4 ? targetDepth === 3 : targetDepth === currentDepth;
+    default:
+      return true;
+  }
+}
+function getDefaultMinLayer(mode) {
+  switch (mode) {
+    case "anchor_down":
+      return 1;
+    case "anchor_up":
+      return 2;
+    case "same_layer":
+      return 1;
+    case "decision_trace":
+      return 3;
+    default:
+      return 1;
+  }
+}
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
+  }
+  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;
+}
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function pickPrimaryTopic(candidates) {
+  return [...candidates].sort((a, b) => {
+    const depthA = a.depth ?? 9999;
+    const depthB = b.depth ?? 9999;
+    if (depthA !== depthB) {
+      return depthA - depthB;
+    }
+    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
+    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
+    if (createdA !== createdB) {
+      return createdA - createdB;
+    }
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  })[0];
+}
+async function findTopicsByScopeAlias(ctx, scopeId) {
+  try {
+    return await ctx.db.query("topics").withIndex(
+      "by_graph_scope_project",
+      (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
+    ).collect();
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve scope alias via index",
+      {
+        error,
+        scopeId
+      }
+    );
+    const topics = await ctx.db.query("topics").collect();
+    return topics.filter((topic) => {
+      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
+      const mappedProjectId = asMappedProjectId(topic);
+      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
+    });
+  }
+}
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by host query",
+      {
+        error,
+        topicId
+      }
+    );
+    return null;
+  }
+}
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by legacy scope",
+      {
+        error,
+        legacyScopeId
+      }
+    );
+    return null;
+  }
+}
+async function resolveInheritedWorkspaceScope(ctx, topic) {
+  const MAX_DEPTH = 10;
+  let tenantId = normalizeScopeValue(topic.tenantId);
+  let workspaceId = normalizeScopeValue(topic.workspaceId);
+  if (tenantId && workspaceId) {
+    return { tenantId, workspaceId };
+  }
+  let current = topic;
+  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
+    current = await ctx.db.get(current.parentTopicId);
+    if (!current) break;
+    if (!tenantId) {
+      tenantId = normalizeScopeValue(current.tenantId);
+    }
+    if (!workspaceId) {
+      workspaceId = normalizeScopeValue(current.workspaceId);
+    }
+    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) {
+      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"
+    };
+  }
+  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"
+      };
+    }
+    throw new Error(
+      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
+    );
+  }
+  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/epistemicEdges.queries.ts
+var get = query({
+  args: { edgeId: v.id("epistemicEdges") },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.edgeId);
+  }
+});
+var getByGlobalId = query({
+  args: { globalId: v.string() },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+  }
+});
+var getFromNode = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const { edgeType } = args;
+    if (edgeType) {
+      return await ctx.db.query("epistemicEdges").withIndex(
+        "by_from_type",
+        (q) => q.eq("fromNodeId", args.fromNodeId).eq("edgeType", edgeType)
+      ).collect();
+    }
+    return await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", args.fromNodeId)).collect();
+  }
+});
+var getToNode = query({
+  args: {
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const { edgeType } = args;
+    if (edgeType) {
+      return await ctx.db.query("epistemicEdges").withIndex(
+        "by_to_type",
+        (q) => q.eq("toNodeId", args.toNodeId).eq("edgeType", edgeType)
+      ).collect();
+    }
+    return await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", args.toNodeId)).collect();
+  }
+});
+var getBySourceNode = query({
+  args: {
+    sourceNodeId: v.string(),
+    edgeType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const isConvexId = args.sourceNodeId.length === 32 || args.sourceNodeId.includes("epistemicNodes");
+    if (isConvexId) {
+      const query2 = args.edgeType ? ctx.db.query("epistemicEdges").withIndex(
+        "by_from_type",
+        (q) => q.eq("fromNodeId", args.sourceNodeId).eq("edgeType", args.edgeType)
+      ) : ctx.db.query("epistemicEdges").withIndex(
+        "by_from",
+        (q) => q.eq("fromNodeId", args.sourceNodeId)
+      );
+      return await query2.collect();
+    }
+    const byGlobalId = await ctx.db.query("epistemicEdges").withIndex(
+      "by_source_global_id",
+      (q) => q.eq("sourceGlobalId", args.sourceNodeId)
+    ).collect();
+    if (args.edgeType) {
+      return byGlobalId.filter((edge) => edge.edgeType === args.edgeType);
+    }
+    return byGlobalId;
+  }
+});
+var getByTargetNode = query({
+  args: {
+    targetNodeId: v.string(),
+    edgeType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const isConvexId = args.targetNodeId.length === 32 || args.targetNodeId.includes("epistemicNodes");
+    if (isConvexId) {
+      const query2 = args.edgeType ? ctx.db.query("epistemicEdges").withIndex(
+        "by_to_type",
+        (q) => q.eq("toNodeId", args.targetNodeId).eq("edgeType", args.edgeType)
+      ) : ctx.db.query("epistemicEdges").withIndex(
+        "by_to",
+        (q) => q.eq("toNodeId", args.targetNodeId)
+      );
+      return await query2.collect();
+    }
+    const byGlobalId = await ctx.db.query("epistemicEdges").withIndex(
+      "by_target_global_id",
+      (q) => q.eq("targetGlobalId", args.targetNodeId)
+    ).collect();
+    if (args.edgeType) {
+      return byGlobalId.filter((edge) => edge.edgeType === args.edgeType);
+    }
+    return byGlobalId;
+  }
+});
+var getBetween = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_to",
+      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
+    ).collect();
+    if (args.edgeType) {
+      return edges.filter((e) => e.edgeType === args.edgeType);
+    }
+    return edges;
+  }
+});
+var getByNodes = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_to",
+      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
+    ).first();
+  }
+});
+var getByProjectAndType = query({
+  args: {
+    ...optionalScopeArgs,
+    edgeType: edgeTypeValidator
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (!args.projectId && !args.topicId) {
+      return [];
+    }
+    let scope;
+    try {
+      scope = await resolveTopicProjectScope(ctx, {
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicEdges] Failed to resolve getAll scope",
+        {
+          error,
+          projectId: args.projectId,
+          topicId: args.topicId
+        }
+      );
+      return [];
+    }
+    const projectEdges = await collectScopedEdges(ctx, scope, 5e3);
+    return projectEdges.filter(
+      (e) => e.edgeType === args.edgeType && edgeMatchesWorkspaceReasoningScope(e, scope)
+    ).slice(0, 5e3);
+  }
+});
+var getByProject = query({
+  args: {
+    ...optionalScopeArgs,
+    userId: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (!args.projectId && !args.topicId) {
+      return [];
+    }
+    let scope;
+    try {
+      scope = await resolveTopicProjectScope(ctx, {
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicEdges] Failed to resolve getByProject scope",
+        {
+          error,
+          projectId: args.projectId,
+          topicId: args.topicId
+        }
+      );
+      return [];
+    }
+    if (args.userId) {
+      const hasAccess = await checkScopeAccess(
+        ctx,
+        String(scope.topicId ?? scope.projectId),
+        args.userId
+      );
+      if (!hasAccess) {
+        return [];
+      }
+    }
+    const pageSize = Math.max(1, Math.min(Math.floor(args.limit ?? 500), 2e3));
+    const edges = await collectScopedEdges(
+      ctx,
+      scope,
+      Math.min(pageSize * 3, 6e3)
+    );
+    return edges.filter((edge) => edgeMatchesWorkspaceReasoningScope(edge, scope)).slice(0, pageSize);
+  }
+});
+var listAll = query({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = Math.max(
+      1,
+      Math.min(Math.floor(args.limit ?? 5e3), 1e4)
+    );
+    return await ctx.db.query("epistemicEdges").order("desc").take(pageSize);
+  }
+});
+var findContradictions = query({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
+    ).collect();
+    return edges.filter((e) => (e.weight ?? 0) < 0);
+  }
+});
+var findSupport = query({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
+    ).collect();
+    return edges.filter((e) => (e.weight ?? 0) >= 0);
+  }
+});
+var getLineage = query({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    maxDepth: v.optional(v.number()),
+    // Phase 2D: Layer-aware traversal options
+    minLayer: v.optional(v.number()),
+    // 1=L1, 2=L2, 3=L3, 4=L4
+    maxLayer: v.optional(v.number()),
+    mode: v.optional(
+      v.union(
+        v.literal("anchor_down"),
+        v.literal("anchor_up"),
+        v.literal("same_layer"),
+        v.literal("decision_trace")
+      )
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const maxDepth = args.maxDepth ?? 10;
+    const mode = args.mode ?? "anchor_down";
+    const minLayer = args.minLayer ?? getDefaultMinLayer(mode);
+    const maxLayer = args.maxLayer ?? 4;
+    const lineage = [];
+    const visited = /* @__PURE__ */ new Set();
+    const startNode = await ctx.db.get(args.nodeId);
+    if (!startNode) {
+      return lineage;
+    }
+    const startLayer = startNode.epistemicLayer || getNodeLayer(startNode.nodeType);
+    const queue = [{ nodeId: args.nodeId, depth: 0, currentLayer: startLayer }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current || current.depth >= maxDepth) {
+        continue;
+      }
+      const nodeIdStr = current.nodeId.toString();
+      if (visited.has(nodeIdStr)) {
+        continue;
+      }
+      visited.add(nodeIdStr);
+      const edges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", current.nodeId)).collect();
+      const lineageEdges = edges.filter((e) => e.edgeType === "derived_from");
+      for (const edge of lineageEdges) {
+        if (!edge.toNodeId) {
+          continue;
+        }
+        const targetNode = await ctx.db.get(edge.toNodeId);
+        if (!targetNode || visited.has(edge.toNodeId.toString())) {
+          continue;
+        }
+        const targetLayer = edge.toLayer || targetNode.epistemicLayer || getNodeLayer(targetNode.nodeType);
+        const shouldContinue = shouldContinueTraversal(
+          current.currentLayer,
+          targetLayer,
+          { mode, minLayer, maxLayer }
+        );
+        if (!shouldContinue) {
+          continue;
+        }
+        lineage.push({
+          node: targetNode,
+          depth: current.depth + 1,
+          edgeType: edge.edgeType,
+          layer: targetLayer
+        });
+        queue.push({
+          nodeId: edge.toNodeId,
+          depth: current.depth + 1,
+          currentLayer: targetLayer
+        });
+      }
+    }
+    return lineage;
+  }
+});
+var getEvidenceForBelief = query({
+  args: {
+    beliefNodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const informsEdges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", args.beliefNodeId).eq("edgeType", "informs")
+    ).collect();
+    const supportEdges = informsEdges.filter((e) => (e.weight ?? 0) >= 0);
+    const contradictEdges = informsEdges.filter((e) => (e.weight ?? 0) < 0);
+    const supportingEvidence = await Promise.all(
+      supportEdges.map(async (edge) => ({
+        edge,
+        node: await ctx.db.get(edge.fromNodeId)
+      }))
+    );
+    const contradictingEvidence = await Promise.all(
+      contradictEdges.map(async (edge) => ({
+        edge,
+        node: await ctx.db.get(edge.fromNodeId)
+      }))
+    );
+    const filteredSupporting = supportingEvidence.filter((e) => e.node !== null);
+    const filteredContradicting = contradictingEvidence.filter(
+      (e) => e.node !== null
+    );
+    return {
+      supporting: filteredSupporting,
+      contradicting: filteredContradicting,
+      supportCount: filteredSupporting.length,
+      contradictCount: filteredContradicting.length
+    };
+  }
+});
+var getClusterEdges = query({
+  args: {
+    beliefIds: v.array(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (args.beliefIds.length === 0) {
+      return [];
+    }
+    const beliefIdSet = new Set(args.beliefIds);
+    const allEdges = await ctx.db.query("epistemicEdges").collect();
+    return allEdges.filter((edge) => {
+      const fromInCluster = beliefIdSet.has(String(edge.fromNodeId)) || edge.sourceGlobalId && beliefIdSet.has(edge.sourceGlobalId);
+      const toInCluster = beliefIdSet.has(String(edge.toNodeId)) || edge.targetGlobalId && beliefIdSet.has(edge.targetGlobalId);
+      return fromInCluster && toInCluster;
+    });
+  }
+});
+
+export { findContradictions, findSupport, get, getBetween, getByGlobalId, getByNodes, getByProject, getByProjectAndType, getBySourceNode, getByTargetNode, getClusterEdges, getEvidenceForBelief, getFromNode, getLineage, getToNode, listAll };
+//# sourceMappingURL=epistemicEdges.queries.js.map
+//# sourceMappingURL=epistemicEdges.queries.js.map