@lucern/graph-sync 1.0.29 → 1.0.31

package/dist/index.js

@@ -1,8 +1,9 @@
 import neo4j from 'neo4j-driver';
-import { v } from 'convex/values';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
 import { NODE_TYPE_TO_LABEL, EDGE_TYPE_TO_REL, getNeo4jRelType } from '@lucern/graph-primitives/graphTypes';
-import { anyApi, internalActionGeneric, actionGeneric, internalMutationGeneric, internalQueryGeneric } from 'convex/server';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { internalActionGeneric, actionGeneric, internalMutationGeneric, internalQueryGeneric } from 'convex/server';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -121,7 +122,7 @@ function getDriver() {
     const uri = process.env.NEO4J_URI;
     const user = process.env.NEO4J_USER;
     const password = process.env.NEO4J_PASSWORD;
-    if (!uri || !user || !password) {
+    if (!(uri && user && password)) {
       throw new Error(
         "[Neo4j Driver] Missing credentials. Set NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD via `npx convex env set`"
       );
@@ -182,9 +183,7 @@ async function runWriteTransaction(query, params = {}, timeoutMs = DEFAULT_QUERY
   try {
     const neo4jParams = toNeo4jParams(params);
     const result = await session.executeWrite(
-      async (tx) => {
-        return await tx.run(query, neo4jParams);
-      },
+      async (tx) => await tx.run(query, neo4jParams),
       { timeout: timeoutMs }
     );
     return result.records.map((record) => {
@@ -378,7 +377,9 @@ __export(neo4jEdgeAPI_exports, {
   retryProjectionByGlobalId: () => retryProjectionByGlobalId,
   updateEdge: () => updateEdge
 });
-var internal = anyApi;
+var internal = unsafeConvexAnyApi(
+  "graph-sync top-level module bundle lacks a committed Convex _generated/api surface"
+);
 var action = actionGeneric;
 var internalAction = internalActionGeneric;
 var internalMutation = internalMutationGeneric;
@@ -409,19 +410,21 @@ var DUAL_WRITE_EDGE_TYPES = [
   "mentioned_in",
   "perspective_on"
 ];
+var LOWER_EDGE_TYPE_REGEX = /^[a-z0-9_]+$/u;
+var UPPER_EDGE_TYPE_REGEX = /^[A-Z0-9_]+$/u;
 function needsDualWrite(edgeType) {
   return DUAL_WRITE_EDGE_TYPES.includes(edgeType);
 }
 function normalizeEdgeType(edgeType) {
   const normalized = edgeType.trim().toLowerCase();
-  if (!/^[a-z0-9_]+$/u.test(normalized)) {
+  if (!LOWER_EDGE_TYPE_REGEX.test(normalized)) {
     throw new Error(`[Neo4j Edge API] Invalid edge type: ${edgeType}`);
   }
   return normalized;
 }
 function resolveRelationshipType(edgeType) {
   const relType = getNeo4jRelType(edgeType);
-  if (!/^[A-Z0-9_]+$/u.test(relType)) {
+  if (!UPPER_EDGE_TYPE_REGEX.test(relType)) {
     throw new Error(`[Neo4j Edge API] Invalid relationship type: ${relType}`);
   }
   return relType;
@@ -436,10 +439,61 @@ function readNumberProperty(source, key) {
 }
 function metadataSummary(metadata) {
   if (!metadata) {
-    return void 0;
+    return;
   }
   return Object.entries(metadata).map(([key, value]) => `${key}=${String(value)}`).slice(0, 8).join(" | ");
 }
+function readMetadata(metadata) {
+  return metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : void 0;
+}
+function neo4jEdgeProperties(args, edgeType, metadata, now) {
+  return {
+    globalId: args.globalId,
+    edgeType,
+    weight: args.weight ?? 1,
+    confidence: args.confidence ?? readNumberProperty(metadata, "confidence") ?? 1,
+    context: args.context ?? metadataSummary(metadata) ?? "",
+    derivationType: args.derivationType ?? "",
+    createdBy: args.createdBy,
+    createdAt: now,
+    updatedAt: now,
+    topicId: args.topicId ?? readStringProperty(metadata, "topicId") ?? "",
+    tenantId: args.tenantId ?? readStringProperty(metadata, "tenantId") ?? "",
+    workspaceId: args.workspaceId ?? readStringProperty(metadata, "workspaceId") ?? "",
+    fromLayer: args.fromLayer ?? "",
+    toLayer: args.toLayer ?? "",
+    fromNodeType: args.fromNodeType ?? "",
+    toNodeType: args.toNodeType ?? "",
+    reasoningMethod: args.reasoningMethod ?? "",
+    logicalRole: args.logicalRole ?? "",
+    temporalClass: args.temporalClass ?? "structural",
+    validFrom: args.validFrom ?? now,
+    validUntil: args.validUntil ?? null
+  };
+}
+function mirrorInputFromCreateArgs(args, edgeType) {
+  return {
+    globalId: args.globalId,
+    fromGlobalId: args.fromGlobalId,
+    toGlobalId: args.toGlobalId,
+    edgeType,
+    weight: args.weight,
+    confidence: args.confidence,
+    context: args.context,
+    derivationType: args.derivationType,
+    createdBy: args.createdBy,
+    topicId: args.topicId,
+    fromLayer: args.fromLayer,
+    toLayer: args.toLayer,
+    fromNodeType: args.fromNodeType,
+    toNodeType: args.toNodeType,
+    reasoningMethod: args.reasoningMethod,
+    logicalRole: args.logicalRole,
+    temporalClass: args.temporalClass,
+    validFrom: args.validFrom,
+    validUntil: args.validUntil
+  };
+}
 async function mirrorEdgeToConvex(ctx, args) {
   await ctx.runMutation(internal.epistemicEdges.mirrorEdgeToConvex, args);
 }
@@ -451,6 +505,40 @@ async function queueEdgeRetry(ctx, args) {
     error: args.error
   });
 }
+async function mirrorCreatedEdgeIfNeeded(ctx, args, edgeType) {
+  if (!needsDualWrite(edgeType)) {
+    return;
+  }
+  try {
+    await mirrorEdgeToConvex(ctx, mirrorInputFromCreateArgs(args, edgeType));
+  } catch (error) {
+    await queueEdgeRetry(ctx, {
+      globalId: args.globalId,
+      operation: "upsert",
+      error: `Convex mirror failed: ${error instanceof Error ? error.message : "Unknown error"}`
+    });
+  }
+}
+async function handleMissingNeo4jEndpoints(ctx, args, edgeType) {
+  await queueEdgeRetry(ctx, {
+    globalId: args.globalId,
+    operation: "upsert",
+    error: `Source or target node not yet synced to Neo4j (from: ${args.fromGlobalId}, to: ${args.toGlobalId})`
+  });
+  if (needsDualWrite(edgeType)) {
+    try {
+      await mirrorEdgeToConvex(ctx, mirrorInputFromCreateArgs(args, edgeType));
+    } catch {
+    }
+  }
+  return {
+    success: false,
+    globalId: args.globalId,
+    edgeType,
+    queuedForRetry: true,
+    reason: "nodes_not_synced"
+  };
+}
 var createEdge = internalAction({
   args: {
     globalId: v.string(),
@@ -486,31 +574,9 @@ var createEdge = internalAction({
     }
     const edgeType = normalizeEdgeType(args.edgeType);
     const relType = resolveRelationshipType(edgeType);
-    const metadata = args.metadata && typeof args.metadata === "object" ? args.metadata : void 0;
     const now = Date.now();
-    const properties = {
-      globalId: args.globalId,
-      edgeType,
-      weight: args.weight ?? 1,
-      confidence: args.confidence ?? readNumberProperty(metadata, "confidence") ?? 1,
-      context: args.context ?? metadataSummary(metadata) ?? "",
-      derivationType: args.derivationType ?? "",
-      createdBy: args.createdBy,
-      createdAt: now,
-      updatedAt: now,
-      topicId: args.topicId ?? readStringProperty(metadata, "topicId") ?? "",
-      tenantId: args.tenantId ?? readStringProperty(metadata, "tenantId") ?? "",
-      workspaceId: args.workspaceId ?? readStringProperty(metadata, "workspaceId") ?? "",
-      fromLayer: args.fromLayer ?? "",
-      toLayer: args.toLayer ?? "",
-      fromNodeType: args.fromNodeType ?? "",
-      toNodeType: args.toNodeType ?? "",
-      reasoningMethod: args.reasoningMethod ?? "",
-      logicalRole: args.logicalRole ?? "",
-      temporalClass: args.temporalClass ?? "structural",
-      validFrom: args.validFrom ?? now,
-      validUntil: args.validUntil ?? null
-    };
+    const metadata = readMetadata(args.metadata);
+    const properties = neo4jEdgeProperties(args, edgeType, metadata, now);
     const result = await runWriteTransaction(
       `
       MATCH (from {globalId: $fromGlobalId})
@@ -527,76 +593,9 @@ var createEdge = internalAction({
       }
     );
     if (result.length === 0) {
-      await queueEdgeRetry(ctx, {
-        globalId: args.globalId,
-        operation: "upsert",
-        error: `Source or target node not yet synced to Neo4j (from: ${args.fromGlobalId}, to: ${args.toGlobalId})`
-      });
-      if (needsDualWrite(edgeType)) {
-        try {
-          await mirrorEdgeToConvex(ctx, {
-            globalId: args.globalId,
-            fromGlobalId: args.fromGlobalId,
-            toGlobalId: args.toGlobalId,
-            edgeType,
-            weight: args.weight,
-            confidence: args.confidence,
-            context: args.context,
-            derivationType: args.derivationType,
-            createdBy: args.createdBy,
-            topicId: args.topicId,
-            fromLayer: args.fromLayer,
-            toLayer: args.toLayer,
-            fromNodeType: args.fromNodeType,
-            toNodeType: args.toNodeType,
-            reasoningMethod: args.reasoningMethod,
-            logicalRole: args.logicalRole,
-            temporalClass: args.temporalClass,
-            validFrom: args.validFrom,
-            validUntil: args.validUntil
-          });
-        } catch {
-        }
-      }
-      return {
-        success: false,
-        globalId: args.globalId,
-        edgeType,
-        queuedForRetry: true,
-        reason: "nodes_not_synced"
-      };
-    }
-    if (needsDualWrite(edgeType)) {
-      try {
-        await mirrorEdgeToConvex(ctx, {
-          globalId: args.globalId,
-          fromGlobalId: args.fromGlobalId,
-          toGlobalId: args.toGlobalId,
-          edgeType,
-          weight: args.weight,
-          confidence: args.confidence,
-          context: args.context,
-          derivationType: args.derivationType,
-          createdBy: args.createdBy,
-          topicId: args.topicId,
-          fromLayer: args.fromLayer,
-          toLayer: args.toLayer,
-          fromNodeType: args.fromNodeType,
-          toNodeType: args.toNodeType,
-          reasoningMethod: args.reasoningMethod,
-          logicalRole: args.logicalRole,
-          temporalClass: args.temporalClass,
-          validFrom: args.validFrom,
-          validUntil: args.validUntil
-        });
-      } catch (error) {
-        await queueEdgeRetry(ctx, {
-          globalId: args.globalId,
-          operation: "upsert",
-          error: `Convex mirror failed: ${error instanceof Error ? error.message : "Unknown error"}`
-        });
-      }
+      return handleMissingNeo4jEndpoints(ctx, args, edgeType);
     }
+    await mirrorCreatedEdgeIfNeeded(ctx, args, edgeType);
     return {
       success: true,
       globalId: args.globalId,
@@ -646,9 +645,15 @@ var updateEdge = internalAction({
       throw new Error("[Neo4j Edge API] Neo4j not configured");
     }
     const updates = { updatedAt: Date.now() };
-    if (args.weight !== void 0) updates.weight = args.weight;
-    if (args.confidence !== void 0) updates.confidence = args.confidence;
-    if (args.context !== void 0) updates.context = args.context;
+    if (args.weight !== void 0) {
+      updates.weight = args.weight;
+    }
+    if (args.confidence !== void 0) {
+      updates.confidence = args.confidence;
+    }
+    if (args.context !== void 0) {
+      updates.context = args.context;
+    }
     if (args.derivationType !== void 0) {
       updates.derivationType = args.derivationType;
     }
@@ -736,7 +741,13 @@ var retryProjectionByGlobalId = internalAction({
         error: `[Neo4j Edge API] Edge not found in Neo4j: ${args.globalId}`
       };
     }
-    const edge = result[0];
+    const [edge] = result;
+    if (!edge) {
+      return {
+        success: false,
+        error: `[Neo4j Edge API] Edge not found in Neo4j: ${args.globalId}`
+      };
+    }
     if (!needsDualWrite(edge.edgeType)) {
       return {
         success: true,
@@ -830,6 +841,8 @@ __export(neo4jQueries_exports, {
 });
 
 // src/neo4jQueriesCore.ts
+var TRAILING_SLASH_REGEX = /\/+$/u;
+var NEO4J_QUERY_TIMEOUT_MS = 1e4;
 function toInt(value, defaultValue) {
   if (value === void 0 || value === null) {
     return defaultValue;
@@ -869,15 +882,69 @@ function createNeo4jQueryTransportFailure(error) {
 function resolveProxyBaseUrl(apiBaseUrl) {
   const resolved = apiBaseUrl || process.env.LUCERN_GRAPH_SYNC_QUERY_BASE_URL || process.env.NEXT_PUBLIC_APP_URL;
   const normalized = resolved?.trim();
-  return normalized ? normalized.replace(/\/+$/u, "") : null;
+  return normalized ? normalized.replace(TRAILING_SLASH_REGEX, "") : null;
 }
 function buildProxyEndpoint(proxyBaseUrl) {
   const endpoint = new URL(proxyBaseUrl);
   if (!endpoint.pathname.endsWith("/api/neo4j-query")) {
-    endpoint.pathname = `${endpoint.pathname.replace(/\/+$/u, "")}/api/neo4j-query`;
+    endpoint.pathname = `${endpoint.pathname.replace(
+      TRAILING_SLASH_REGEX,
+      ""
+    )}/api/neo4j-query`;
   }
   return endpoint.toString();
 }
+function tenantContextFromParams(params) {
+  const explicitTenant = typeof params.tenantId === "string" ? params.tenantId.trim() : "";
+  const scopedTopic = typeof params.topicId === "string" ? params.topicId.trim() : "";
+  const legacyProjectScope = typeof params.projectId === "string" ? params.projectId.trim() : "";
+  const scopedTopicId = scopedTopic || legacyProjectScope;
+  const projectTenant = scopedTopicId ? `project:${scopedTopicId}` : "";
+  const defaultTenant = process.env.LUCERN_DEFAULT_TENANT_ID?.trim() || "";
+  return explicitTenant || projectTenant || defaultTenant;
+}
+function neo4jQueryHeaders(syncSecret, apiBaseUrl) {
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${syncSecret}`
+  };
+  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+  if (bypassSecret && apiBaseUrl) {
+    headers["x-vercel-protection-bypass"] = bypassSecret;
+  }
+  return headers;
+}
+async function postNeo4jQuery(args) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(
+    () => controller.abort(),
+    NEO4J_QUERY_TIMEOUT_MS
+  );
+  try {
+    const response = await fetch(buildProxyEndpoint(args.proxyUrl), {
+      method: "POST",
+      headers: neo4jQueryHeaders(args.syncSecret, args.apiBaseUrl),
+      body: JSON.stringify({
+        queryName: args.queryName,
+        params: args.params
+      }),
+      signal: controller.signal
+    });
+    const result = await response.json();
+    if (!response.ok) {
+      return createNeo4jQueryTransportFailure(result.error || "Query failed");
+    }
+    return createNeo4jQueryTransportSuccess(result.data || []);
+  } catch (fetchError) {
+    if (fetchError instanceof Error && fetchError.name === "AbortError") {
+      console.warn("[Neo4j Queries] Request timed out for:", args.queryName);
+      return createNeo4jQueryTransportFailure("Query timed out (10s)");
+    }
+    throw fetchError;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
 function withTopicScope(args, params) {
   return args.topicId ? { ...params, topicId: args.topicId } : params;
 }
@@ -898,55 +965,23 @@ async function callNeo4jQuery(queryName, params, apiBaseUrl) {
   const syncSecret = process.env.NEO4J_SYNC_SECRET;
   if (!syncSecret) {
     console.error("[Neo4j Queries] NEO4J_SYNC_SECRET not configured");
-    return createNeo4jQueryTransportFailure(
-      "Neo4j sync secret not configured"
-    );
+    return createNeo4jQueryTransportFailure("Neo4j sync secret not configured");
   }
   try {
-    const explicitTenant = typeof params.tenantId === "string" ? params.tenantId.trim() : "";
-    const scopedTopic = typeof params.topicId === "string" ? params.topicId.trim() : "";
-    const legacyProject = typeof params.projectId === "string" ? params.projectId.trim() : "";
-    const scopedTopicId = scopedTopic || legacyProject;
-    const projectTenant = scopedTopicId ? `project:${scopedTopicId}` : "";
-    const defaultTenant = process.env.LUCERN_DEFAULT_TENANT_ID?.trim() || "";
-    const tenantId = explicitTenant || projectTenant || defaultTenant;
+    const tenantId = tenantContextFromParams(params);
     if (!tenantId) {
       return createNeo4jQueryTransportFailure(
         "Missing required tenant context (tenantId or topicId)"
       );
     }
     const scopedParams = { ...params, tenantId };
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${syncSecret}`
-    };
-    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-    if (bypassSecret && apiBaseUrl) {
-      headers["x-vercel-protection-bypass"] = bypassSecret;
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 1e4);
-    try {
-      const response = await fetch(buildProxyEndpoint(proxyUrl), {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ queryName, params: scopedParams }),
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const result = await response.json();
-      if (!response.ok) {
-        return createNeo4jQueryTransportFailure(result.error || "Query failed");
-      }
-      return createNeo4jQueryTransportSuccess(result.data || []);
-    } catch (fetchError) {
-      clearTimeout(timeoutId);
-      if (fetchError instanceof Error && fetchError.name === "AbortError") {
-        console.warn("[Neo4j Queries] Request timed out for:", queryName);
-        return createNeo4jQueryTransportFailure("Query timed out (10s)");
-      }
-      throw fetchError;
-    }
+    return await postNeo4jQuery({
+      apiBaseUrl,
+      params: scopedParams,
+      proxyUrl,
+      queryName,
+      syncSecret
+    });
   } catch (error) {
     console.error("[Neo4j Queries] Error in callNeo4jQuery:", queryName, error);
     return createNeo4jQueryTransportFailure(
@@ -2154,6 +2189,7 @@ var neo4jQueryRoute_exports = {};
 __export(neo4jQueryRoute_exports, {
   createNeo4jQueryRouteHandler: () => createNeo4jQueryRouteHandler
 });
+var BEARER_AUTHORIZATION_PATTERN = /^Bearer\s+(.+)$/iu;
 function jsonResponse(body, init) {
   return new Response(JSON.stringify(body), {
     ...init,
@@ -2165,9 +2201,38 @@ function jsonResponse(body, init) {
 }
 function readBearerSecret(request) {
   const authorization = request.headers.get("authorization") ?? "";
-  const match = authorization.match(/^Bearer\s+(.+)$/iu);
+  const match = authorization.match(BEARER_AUTHORIZATION_PATTERN);
   return match?.[1]?.trim() || null;
 }
+function validateRouteSecret(request, options) {
+  const expectedSecret = options.syncSecret ?? process.env.NEO4J_SYNC_SECRET?.trim();
+  if (!expectedSecret) {
+    return jsonResponse(
+      { error: "Neo4j sync secret not configured" },
+      { status: 500 }
+    );
+  }
+  if (readBearerSecret(request) !== expectedSecret) {
+    return jsonResponse({ error: "Unauthorized" }, { status: 401 });
+  }
+  return null;
+}
+async function readQueryBody(request) {
+  try {
+    return {
+      ok: true,
+      body: await request.json()
+    };
+  } catch {
+    return {
+      ok: false,
+      response: jsonResponse({ error: "Invalid JSON body" }, { status: 400 })
+    };
+  }
+}
+function normalizeQueryParams(params) {
+  return params && typeof params === "object" && !Array.isArray(params) ? params : {};
+}
 function hasTenantContext(params) {
   const tenantId = params.tenantId;
   const topicId = params.topicId;
@@ -2184,62 +2249,79 @@ function normalizeConnectedNodesQuery(queryName, params, queries) {
   const aliased = `connectedNodes${hops}`;
   return queries[aliased] ? aliased : queryName;
 }
+function requireTenantContext(options, params) {
+  if ((options.requireTenantContext ?? true) && !hasTenantContext(params)) {
+    return jsonResponse(
+      { error: "Missing required tenant context" },
+      { status: 400 }
+    );
+  }
+  return null;
+}
+function resolveNamedQuery(queryName, params, queries) {
+  const normalizedQueryName = normalizeConnectedNodesQuery(
+    queryName,
+    params,
+    queries
+  );
+  const query = queries[normalizedQueryName];
+  if (!query) {
+    return {
+      ok: false,
+      response: jsonResponse(
+        { error: `Unknown query: ${queryName}` },
+        { status: 400 }
+      )
+    };
+  }
+  return { ok: true, query, queryName: normalizedQueryName };
+}
+async function executeNamedQuery(queryName, query, params) {
+  try {
+    const data = await runCypher(
+      query.cypher,
+      params,
+      query.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS
+    );
+    return jsonResponse({ data, queryName });
+  } catch (error) {
+    return jsonResponse(
+      {
+        error: error instanceof Error ? error.message : "Neo4j query failed",
+        queryName
+      },
+      { status: 500 }
+    );
+  }
+}
 function createNeo4jQueryRouteHandler(options) {
   return async function handleNeo4jQuery(request) {
-    const expectedSecret = options.syncSecret ?? process.env.NEO4J_SYNC_SECRET?.trim();
-    if (!expectedSecret) {
-      return jsonResponse(
-        { error: "Neo4j sync secret not configured" },
-        { status: 500 }
-      );
-    }
-    if (readBearerSecret(request) !== expectedSecret) {
-      return jsonResponse({ error: "Unauthorized" }, { status: 401 });
+    const authError = validateRouteSecret(request, options);
+    if (authError) {
+      return authError;
     }
-    let body;
-    try {
-      body = await request.json();
-    } catch {
-      return jsonResponse({ error: "Invalid JSON body" }, { status: 400 });
+    const bodyResult = await readQueryBody(request);
+    if (!bodyResult.ok) {
+      return bodyResult.response;
     }
+    const { body } = bodyResult;
     if (typeof body.queryName !== "string" || body.queryName.length === 0) {
       return jsonResponse({ error: "Missing queryName" }, { status: 400 });
     }
-    const params = body.params && typeof body.params === "object" && !Array.isArray(body.params) ? body.params : {};
-    if ((options.requireTenantContext ?? true) && !hasTenantContext(params)) {
-      return jsonResponse(
-        { error: "Missing required tenant context" },
-        { status: 400 }
-      );
+    const params = normalizeQueryParams(body.params);
+    const tenantContextError = requireTenantContext(options, params);
+    if (tenantContextError) {
+      return tenantContextError;
     }
-    const queryName = normalizeConnectedNodesQuery(
+    const namedQuery = resolveNamedQuery(
       body.queryName,
       params,
       options.queries
     );
-    const query = options.queries[queryName];
-    if (!query) {
-      return jsonResponse(
-        { error: `Unknown query: ${body.queryName}` },
-        { status: 400 }
-      );
-    }
-    try {
-      const data = await runCypher(
-        query.cypher,
-        params,
-        query.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS
-      );
-      return jsonResponse({ data, queryName });
-    } catch (error) {
-      return jsonResponse(
-        {
-          error: error instanceof Error ? error.message : "Neo4j query failed",
-          queryName
-        },
-        { status: 500 }
-      );
+    if (!namedQuery.ok) {
+      return namedQuery.response;
     }
+    return executeNamedQuery(namedQuery.queryName, namedQuery.query, params);
   };
 }
 
@@ -2257,6 +2339,9 @@ __export(neo4jSync_exports, {
   syncEmbeddingToNeo4j: () => syncEmbeddingToNeo4j,
   syncNodeToNeo4j: () => syncNodeToNeo4j
 });
+var graphSyncHelpers = internal.neo4jSyncHelpers;
+var graphSyncActions = internal.neo4jSync;
+var graphSyncEdgeApi = internal.neo4jEdgeAPI;
 function buildSyncResponse(entityType, operation, fields) {
   return {
     entityType,
@@ -2277,53 +2362,100 @@ function buildSyncFailure(entityType, operation, error, fields) {
     ...fields
   });
 }
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+function readFirstString(...values) {
+  for (const value of values) {
+    const stringValue = readString(value);
+    if (stringValue.length > 0) {
+      return stringValue;
+    }
+  }
+  return "";
+}
+function readArrayLength(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function nodeSyncEventType(operation) {
+  return operation === "delete" ? "node_deleted" : "node_updated";
+}
+function edgeSyncEventType(operation) {
+  return operation === "delete" ? "edge_deleted" : "edge_created";
+}
+function readNeo4jEndpointFailure(edge, operation) {
+  if (edge.fromGlobalId && edge.toGlobalId) {
+    return null;
+  }
+  console.warn(
+    "[Neo4j Sync] Edge missing fromGlobalId or toGlobalId, skipping"
+  );
+  return buildSyncFailure(
+    "edge",
+    operation,
+    "Edge missing connected node globalIds",
+    {
+      skippedReason: "edge_endpoint_missing"
+    }
+  );
+}
+async function applyEdgeOperation(edge, operation, edgeId) {
+  const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
+  if (operation === "delete") {
+    await deleteEdge(edge.globalId);
+    console.log(`[Neo4j Sync] Deleted edge ${edge.globalId}`);
+    return relType;
+  }
+  await upsertEdge(
+    relType,
+    edge.globalId,
+    edge.fromGlobalId ?? "",
+    edge.toGlobalId ?? "",
+    {
+      ...buildEdgeProperties(edge),
+      convexId: edgeId
+    }
+  );
+  console.log(`[Neo4j Sync] Upserted edge ${edge.globalId} as ${relType}`);
+  return relType;
+}
 function buildNodeProperties(node) {
-  const metadata = node.metadata || {};
-  const pillar = metadata.pillar || metadata.topic || "";
-  const stage = metadata.stage || metadata.beliefStage || "";
-  const criticality = metadata.criticality || "";
-  const synthesizedFrom = metadata.synthesizedFrom || [];
-  const epistemicStatus = node.epistemicStatus || "";
-  const methodology = node.methodology || "";
-  const informationAsymmetry = node.informationAsymmetry || "";
-  const questionType = node.questionType || "";
-  const questionPriority = node.questionPriority || "";
-  const answerQuality = node.answerQuality || "";
-  const reversibility = node.reversibility || "";
-  const predictionMeta = node.predictionMeta;
+  const metadata = readRecord(node.metadata);
+  const predictionMeta = readRecord(node.predictionMeta);
   return {
-    convexId: node._id,
+    answerQuality: readString(node.answerQuality),
     canonicalText: node.canonicalText || "",
-    title: node.title || "",
-    status: node.status || "active",
-    subtype: node.subtype || "",
-    domain: node.domain || "",
     confidence: node.confidence || 0,
-    verificationStatus: node.verificationStatus || "unverified",
-    sourceType: node.sourceType || "unknown",
+    convexId: node._id,
     createdAt: node.createdAt,
-    updatedAt: node.updatedAt || Date.now(),
     createdBy: node.createdBy || "",
-    nodeType: node.nodeType,
+    criticality: readString(metadata.criticality),
+    domain: node.domain || "",
     epistemicLayer: node.epistemicLayer || "",
-    // Project and metadata fields
+    epistemicStatus: readString(node.epistemicStatus),
+    expectedBy: predictionMeta?.expectedBy ? String(predictionMeta.expectedBy) : "",
+    informationAsymmetry: readString(node.informationAsymmetry),
+    isPrediction: predictionMeta?.isPrediction ? "true" : "false",
+    methodology: readString(node.methodology),
+    nodeType: node.nodeType,
+    pillar: readFirstString(metadata.pillar, metadata.topic),
     projectId: node.projectId || "",
+    questionPriority: readString(node.questionPriority),
+    questionType: readString(node.questionType),
+    reversibility: readString(node.reversibility),
+    sourceType: node.sourceType || "unknown",
+    stage: readFirstString(metadata.stage, metadata.beliefStage),
+    status: node.status || "active",
+    subtype: node.subtype || "",
+    synthesizedFromCount: readArrayLength(metadata.synthesizedFrom),
     tenantId: node.tenantId || "",
-    workspaceId: node.workspaceId || "",
-    pillar,
-    stage,
-    criticality,
-    synthesizedFromCount: synthesizedFrom.length,
-    // Classification fields (Logic Machine)
-    epistemicStatus,
-    methodology,
-    informationAsymmetry,
-    questionType,
-    questionPriority,
-    answerQuality,
-    reversibility,
-    isPrediction: predictionMeta?.isPrediction ? "true" : "false",
-    expectedBy: predictionMeta?.expectedBy ? String(predictionMeta.expectedBy) : ""
+    title: node.title || "",
+    updatedAt: node.updatedAt || Date.now(),
+    verificationStatus: node.verificationStatus || "unverified",
+    workspaceId: node.workspaceId || ""
   };
 }
 function buildEdgeProperties(edge) {
@@ -2363,7 +2495,7 @@ var syncNodeToNeo4j = internalAction({
         skippedReason: "credentials_missing"
       });
     }
-    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+    const node = await ctx.runQuery(graphSyncHelpers.getNodeForSync, {
       nodeId: args.nodeId
     });
     if (!node) {
@@ -2386,7 +2518,7 @@ var syncNodeToNeo4j = internalAction({
       } else {
         const props = buildNodeProperties(node);
         const embedding = await ctx.runQuery(
-          internal.neo4jSyncHelpers.getEmbeddingForSync,
+          graphSyncHelpers.getEmbeddingForSync,
           { nodeId: args.nodeId }
         );
         if (embedding) {
@@ -2397,8 +2529,8 @@ var syncNodeToNeo4j = internalAction({
           `[Neo4j Sync] Upserted node ${node.globalId} as ${label} with projectId=${node.projectId}` + (embedding ? ` (with ${embedding.length}-dim embedding)` : "")
         );
       }
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
-        eventType: args.operation === "delete" ? "node_deleted" : node ? "node_updated" : "node_created",
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
+        eventType: nodeSyncEventType(args.operation),
         entityId: args.nodeId,
         entityType: node.nodeType,
         status: "success"
@@ -2407,14 +2539,14 @@ var syncNodeToNeo4j = internalAction({
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : "Unknown error";
       console.error("[Neo4j Sync] Node sync error:", errorMsg);
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
         eventType: args.operation === "delete" ? "node_deleted" : "node_updated",
         entityId: args.nodeId,
         entityType: node.nodeType,
         status: "failed",
         error: errorMsg
       });
-      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+      await ctx.runMutation(graphSyncHelpers.queueForRetry, {
         entityType: "node",
         entityId: args.nodeId,
         operation: args.operation,
@@ -2440,7 +2572,7 @@ var syncEdgeToNeo4j = internalAction({
         skippedReason: "credentials_missing"
       });
     }
-    const edge = await ctx.runQuery(internal.neo4jSyncHelpers.getEdgeForSync, {
+    const edge = await ctx.runQuery(graphSyncHelpers.getEdgeForSync, {
       edgeId: args.edgeId
     });
     if (!edge) {
@@ -2455,53 +2587,18 @@ var syncEdgeToNeo4j = internalAction({
         skippedReason: "source_edge_missing"
       });
     }
-    if (!edge.fromGlobalId || !edge.toGlobalId) {
-      console.warn(
-        "[Neo4j Sync] Edge missing fromGlobalId or toGlobalId, skipping"
-      );
-      return buildSyncFailure(
-        "edge",
-        args.operation,
-        "Edge missing connected node globalIds",
-        {
-          skippedReason: "edge_endpoint_missing"
-        }
-      );
+    const edgeForSync = edge;
+    const endpointFailure = readNeo4jEndpointFailure(
+      edgeForSync,
+      args.operation
+    );
+    if (endpointFailure) {
+      return endpointFailure;
     }
-    const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
     try {
-      if (args.operation === "delete") {
-        await deleteEdge(edge.globalId);
-        console.log(`[Neo4j Sync] Deleted edge ${edge.globalId}`);
-      } else {
-        await upsertEdge(
-          relType,
-          edge.globalId,
-          edge.fromGlobalId,
-          edge.toGlobalId,
-          {
-            convexId: args.edgeId,
-            weight: edge.weight || 1,
-            confidence: edge.confidence || 0,
-            context: edge.context || "",
-            derivationType: edge.derivationType || "",
-            createdAt: edge.createdAt,
-            createdBy: edge.createdBy || "",
-            edgeType: edge.edgeType,
-            fromLayer: edge.fromLayer || "",
-            toLayer: edge.toLayer || "",
-            // Classification fields (Logic Machine)
-            reasoningMethod: edge.reasoningMethod || "",
-            logicalRole: edge.logicalRole || "",
-            temporalClass: edge.temporalClass || ""
-          }
-        );
-        console.log(
-          `[Neo4j Sync] Upserted edge ${edge.globalId} as ${relType}`
-        );
-      }
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
-        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+      await applyEdgeOperation(edgeForSync, args.operation, args.edgeId);
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
+        eventType: edgeSyncEventType(args.operation),
         entityId: args.edgeId,
         entityType: edge.edgeType,
         status: "success"
@@ -2510,14 +2607,14 @@ var syncEdgeToNeo4j = internalAction({
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : "Unknown error";
       console.error("[Neo4j Sync] Edge sync error:", errorMsg);
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
-        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
+        eventType: edgeSyncEventType(args.operation),
         entityId: args.edgeId,
         entityType: edge.edgeType,
         status: "failed",
         error: errorMsg
       });
-      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+      await ctx.runMutation(graphSyncHelpers.queueForRetry, {
         entityType: "edge",
         entityId: args.edgeId,
         operation: args.operation,
@@ -2535,13 +2632,10 @@ var syncAllNodesToNeo4j = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 100;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getNodeBatchForSync,
-      {
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getNodeBatchForSync, {
+      limit: batchSize,
+      cursor: args.cursor
+    });
     if (result.nodes.length === 0) {
       return { synced: 0, failed: 0, hasMore: false };
     }
@@ -2586,19 +2680,16 @@ var syncAllEdgesToNeo4j = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 100;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getEdgeBatchForSync,
-      {
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getEdgeBatchForSync, {
+      limit: batchSize,
+      cursor: args.cursor
+    });
     if (result.edges.length === 0) {
       return { synced: 0, failed: 0, hasMore: false };
     }
     const edgesToSync = [];
     for (const edge of result.edges) {
-      if (!edge.fromGlobalId || !edge.toGlobalId) {
+      if (!(edge.fromGlobalId && edge.toGlobalId)) {
         console.warn(
           `[Neo4j Sync] Skipping edge ${edge.globalId} - missing globalIds`
         );
@@ -2644,16 +2735,13 @@ var backfillAllToNeo4j = internalAction({
     console.log("[Neo4j Sync] Starting full backfill...");
     let nodeCursor;
     do {
-      const result = await ctx.runAction(
-        internal.neo4jSync.syncAllNodesToNeo4j,
-        {
-          batchSize,
-          cursor: nodeCursor
-        }
-      );
+      const result = await ctx.runAction(graphSyncActions.syncAllNodesToNeo4j, {
+        batchSize,
+        cursor: nodeCursor
+      });
       totalNodes += result.synced;
       totalFailed += result.failed;
-      nodeCursor = result.hasMore ? result.nextCursor : void 0;
+      nodeCursor = result.hasMore ? result.nextCursor ?? void 0 : void 0;
       console.log(
         `[Neo4j Sync] Nodes progress: ${totalNodes} synced, ${totalFailed} failed`
       );
@@ -2661,16 +2749,13 @@ var backfillAllToNeo4j = internalAction({
     console.log(`[Neo4j Sync] Finished nodes: ${totalNodes} synced`);
     let edgeCursor;
     do {
-      const result = await ctx.runAction(
-        internal.neo4jSync.syncAllEdgesToNeo4j,
-        {
-          batchSize,
-          cursor: edgeCursor
-        }
-      );
+      const result = await ctx.runAction(graphSyncActions.syncAllEdgesToNeo4j, {
+        batchSize,
+        cursor: edgeCursor
+      });
       totalEdges += result.synced;
       totalFailed += result.failed;
-      edgeCursor = result.hasMore ? result.nextCursor : void 0;
+      edgeCursor = result.hasMore ? result.nextCursor ?? void 0 : void 0;
       console.log(
         `[Neo4j Sync] Edges progress: ${totalEdges} synced, ${totalFailed} failed`
       );
@@ -2693,7 +2778,7 @@ var processRetryQueue = internalAction({
   handler: async (ctx, args) => {
     const limit = args.limit ?? 10;
     const pendingItems = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getPendingRetries,
+      graphSyncHelpers.getPendingRetries,
       { limit }
     );
     if (pendingItems.length === 0) {
@@ -2702,31 +2787,31 @@ var processRetryQueue = internalAction({
     let succeeded = 0;
     let failed = 0;
     for (const item of pendingItems) {
-      await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+      await ctx.runMutation(graphSyncHelpers.updateQueueStatus, {
         queueId: item._id,
         status: "in_progress"
       });
       let result;
       if (item.entityType === "node") {
-        result = await ctx.runAction(internal.neo4jSync.syncNodeToNeo4j, {
+        result = await ctx.runAction(graphSyncActions.syncNodeToNeo4j, {
           nodeId: item.entityId,
           operation: item.operation
         });
       } else {
         const resolved = await ctx.runQuery(
-          internal.neo4jSyncHelpers.resolveEdgeRetryTarget,
+          graphSyncHelpers.resolveEdgeRetryTarget,
           {
             entityId: item.entityId
           }
         );
         if (resolved.mode === "convex_id" || resolved.mode === "global_id_in_convex") {
-          result = await ctx.runAction(internal.neo4jSync.syncEdgeToNeo4j, {
+          result = await ctx.runAction(graphSyncActions.syncEdgeToNeo4j, {
             edgeId: resolved.edgeId,
             operation: item.operation
           });
         } else {
           result = await ctx.runAction(
-            internal.neo4jEdgeAPI.retryProjectionByGlobalId,
+            graphSyncEdgeApi.retryProjectionByGlobalId,
             {
               globalId: resolved.edgeGlobalId
             }
@@ -2734,14 +2819,14 @@ var processRetryQueue = internalAction({
         }
       }
       if (result.success) {
-        await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+        await ctx.runMutation(graphSyncHelpers.updateQueueStatus, {
           queueId: item._id,
           status: "succeeded"
         });
         succeeded++;
       } else {
         const updated = await ctx.runMutation(
-          internal.neo4jSyncHelpers.incrementAttempts,
+          graphSyncHelpers.incrementAttempts,
           {
             queueId: item._id,
             error: result.error || "Unknown error"
@@ -2767,7 +2852,7 @@ var syncEmbeddingToNeo4j = internalAction({
         skippedReason: "credentials_missing"
       });
     }
-    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+    const node = await ctx.runQuery(graphSyncHelpers.getNodeForSync, {
       nodeId: args.nodeId
     });
     if (!node?.globalId) {
@@ -2775,10 +2860,9 @@ var syncEmbeddingToNeo4j = internalAction({
         skippedReason: "source_node_missing"
       });
     }
-    const embedding = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getEmbeddingForSync,
-      { nodeId: args.nodeId }
-    );
+    const embedding = await ctx.runQuery(graphSyncHelpers.getEmbeddingForSync, {
+      nodeId: args.nodeId
+    });
     if (!embedding) {
       return buildSyncFailure("embedding", "sync", "Embedding not found", {
         skippedReason: "embedding_missing"
@@ -2828,20 +2912,17 @@ var resyncAllNodes = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 50;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getAllNodesForResync,
-      {
-        nodeType: args.nodeType,
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getAllNodesForResync, {
+      nodeType: args.nodeType,
+      limit: batchSize,
+      cursor: args.cursor
+    });
     let synced = 0;
     let failed = 0;
     for (const node of result.nodes) {
       try {
         const syncResult = await ctx.runAction(
-          internal.neo4jSync.syncNodeToNeo4j,
+          graphSyncActions.syncNodeToNeo4j,
           {
             nodeId: node._id,
             operation: "upsert"
@@ -2874,19 +2955,16 @@ var resyncAllEdges = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 50;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getAllEdgesForResync,
-      {
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getAllEdgesForResync, {
+      limit: batchSize,
+      cursor: args.cursor
+    });
     let synced = 0;
     let failed = 0;
     for (const edge of result.edges) {
       try {
         const syncResult = await ctx.runAction(
-          internal.neo4jSync.syncEdgeToNeo4j,
+          graphSyncActions.syncEdgeToNeo4j,
           {
             edgeId: edge._id,
             operation: "upsert"
@@ -2937,6 +3015,16 @@ function logRetryTargetFallback(context, error) {
   }
   console.debug("[graph-sync][neo4jSyncHelpers]", context, error);
 }
+function readString2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function isSyncEdgeDoc(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && "edgeType" in value && typeof value.edgeType === "string" && "fromNodeId" in value;
+}
 var logSyncEvent = internalMutation({
   args: {
     eventType: v.union(
@@ -2956,7 +3044,7 @@ var logSyncEvent = internalMutation({
     error: v.optional(v.string())
   },
   returns: permissiveReturn,
-  handler: async (_ctx, args) => {
+  handler: (_ctx, args) => {
     console.log(
       `[Neo4j Sync] ${args.eventType} ${args.entityType}:${args.entityId} - ${args.status}`,
       args.error || ""
@@ -2966,9 +3054,7 @@ var logSyncEvent = internalMutation({
 var getNodeForSync = internalQuery({
   args: { 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 getEmbeddingForSync = internalQuery({
   args: { nodeId: v.id("epistemicNodes") },
@@ -2991,11 +3077,9 @@ var getAllNodesForResync = internalQuery({
       numItems: limit,
       cursor: args.cursor ?? null
     };
-    if (args.nodeType) {
-      const result2 = await ctx.db.query("epistemicNodes").withIndex(
-        "by_nodeType",
-        (q) => q.eq("nodeType", args.nodeType)
-      ).paginate(paginationOpts);
+    const nodeType = args.nodeType;
+    if (nodeType) {
+      const result2 = await ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", nodeType)).paginate(paginationOpts);
       return {
         nodes: result2.page,
         hasMore: !result2.isDone,
@@ -3024,8 +3108,8 @@ var getEdgeForSync = internalQuery({
       ...edge,
       // Cross-graph edges may not have toNodeId/fromNodeId in Convex mirror.
       // Fall back to denormalized global IDs when node lookup is unavailable.
-      fromGlobalId: fromNode?.globalId || edge.sourceGlobalId,
-      toGlobalId: toNode?.globalId || edge.targetGlobalId
+      fromGlobalId: readString2(fromNode?.globalId) ?? edge.sourceGlobalId,
+      toGlobalId: readString2(toNode?.globalId) ?? edge.targetGlobalId
     };
   }
 });
@@ -3082,12 +3166,12 @@ var getEdgeBatchForSync = internalQuery({
     const result = await ctx.db.query("epistemicEdges").order("asc").paginate(paginationOpts);
     const enrichedEdges = await Promise.all(
       result.page.map(async (edge) => {
-        const fromNode = await ctx.db.get(edge.fromNodeId);
+        const fromNode = edge.fromNodeId ? await ctx.db.get(edge.fromNodeId) : null;
         const toNode = edge.toNodeId ? await ctx.db.get(edge.toNodeId) : null;
         return {
           ...edge,
-          fromGlobalId: fromNode?.globalId || edge.sourceGlobalId,
-          toGlobalId: toNode?.globalId || edge.targetGlobalId
+          fromGlobalId: readString2(fromNode?.globalId) ?? edge.sourceGlobalId,
+          toGlobalId: readString2(toNode?.globalId) ?? edge.targetGlobalId
         };
       })
     );
@@ -3105,13 +3189,17 @@ var resolveEdgeRetryTarget = internalQuery({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     try {
-      const byId = await ctx.db.get(args.entityId);
-      if (byId && "edgeType" in byId && "fromNodeId" in byId) {
-        return {
-          mode: "convex_id",
-          edgeId: byId._id,
-          edgeGlobalId: byId.globalId
-        };
+      const directEdgeId = ctx.db.normalizeId("epistemicEdges", args.entityId);
+      if (directEdgeId) {
+        const byId = await ctx.db.get(directEdgeId);
+        if (isSyncEdgeDoc(byId)) {
+          const edgeGlobalId = readString2(byId.globalId) ?? args.entityId;
+          return {
+            mode: "convex_id",
+            edgeId: byId._id,
+            edgeGlobalId
+          };
+        }
       }
     } catch (error) {
       logRetryTargetFallback(
@@ -3180,9 +3268,7 @@ var getPendingRetries = internalQuery({
     limit: v.number()
   },
   returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.query("neo4jSyncQueue").withIndex("by_status", (q) => q.eq("status", "pending")).take(args.limit);
-  }
+  handler: async (ctx, args) => await ctx.db.query("neo4jSyncQueue").withIndex("by_status", (q) => q.eq("status", "pending")).take(args.limit)
 });
 var updateQueueStatus = internalMutation({
   args: {
@@ -3238,12 +3324,18 @@ var checkSyncHealth = internalQuery({
     const recentEdges = await ctx.db.query("epistemicEdges").filter((q) => q.gte(q.field("createdAt"), oneHourAgo)).collect();
     const pendingRetries = await ctx.db.query("neo4jSyncQueue").withIndex("by_status", (q) => q.eq("status", "pending")).collect();
     const failedRetries = await ctx.db.query("neo4jSyncQueue").withIndex("by_status", (q) => q.eq("status", "failed")).collect();
+    let healthStatus = "healthy";
+    if (failedRetries.length > 10) {
+      healthStatus = "unhealthy";
+    } else if (pendingRetries.length > 50) {
+      healthStatus = "degraded";
+    }
     return {
       recentNodesUpdated: recentNodes.length,
       recentEdgesUpdated: recentEdges.length,
       pendingRetries: pendingRetries.length,
       failedRetries: failedRetries.length,
-      healthStatus: failedRetries.length > 10 ? "unhealthy" : pendingRetries.length > 50 ? "degraded" : "healthy",
+      healthStatus,
       checkedAt: now
     };
   }