fix: preserve real prefix when middle ID segment is a reserved word

understand-anything-plugin/packages/core/src/__tests__/normalize-graph.test.ts

@@ -31,6 +31,38 @@ describe("normalizeNodeId", () => {
     ).toBe("file:src/foo.ts");
   });
 
+  it("keeps a real prefix when a different reserved word is a middle segment", () => {
+    // Regression: "endpoint:service:x" is a valid prefix followed by a real
+    // path segment that happens to be a reserved word. The outer "endpoint"
+    // prefix must be preserved, not dropped in favour of "service".
+    expect(
+      normalizeNodeId("endpoint:service:getUser", { type: "endpoint" }),
+    ).toBe("endpoint:service:getUser");
+  });
+
+  it("is idempotent for IDs whose middle segment is a reserved word", () => {
+    const once = normalizeNodeId("endpoint:service:getUser", {
+      type: "endpoint",
+    });
+    expect(normalizeNodeId(once, { type: "endpoint" })).toBe(once);
+  });
+
+  it("strips a project-name prefix that collides with a reserved word", () => {
+    // Regression: when the project name is itself a reserved word ("service")
+    // and the node's real prefix follows ("file"), the spurious outer prefix
+    // must be dropped so the canonical "file:src/foo.ts" form is used — not
+    // left as "service:file:src/foo.ts", which would dangle edges that
+    // reference the canonical ID.
+    expect(
+      normalizeNodeId("service:file:src/foo.ts", { type: "file" }),
+    ).toBe("file:src/foo.ts");
+  });
+
+  it("is idempotent when a reserved-word project prefix is stripped", () => {
+    const once = normalizeNodeId("service:file:src/foo.ts", { type: "file" });
+    expect(normalizeNodeId(once, { type: "file" })).toBe(once);
+  });
+
   it("strips project-name prefix when valid prefix follows", () => {
     expect(
       normalizeNodeId("my-project:file:src/foo.ts", { type: "file" }),

understand-anything-plugin/packages/core/src/analyzer/normalize-graph.ts

@@ -27,8 +27,17 @@ const TYPE_TO_PREFIX: Record<string, string> = {
 /**
  * Strips all non-valid prefixes from an ID, returning the bare path
  * and the first valid prefix found (if any).
+ *
+ * `expectedPrefix` is the canonical prefix for the node's declared type
+ * (e.g. "file" for a file node). It disambiguates a reserved word that
+ * appears before the expected prefix — a spurious project-name prefix that
+ * happens to collide with a reserved word — from a reserved word that is a
+ * legitimate middle path segment.
  */
-function stripToValidPrefix(id: string): { prefix: string | null; path: string } {
+function stripToValidPrefix(
+  id: string,
+  expectedPrefix?: string,
+): { prefix: string | null; path: string } {
   let remaining = id;
 
   // Peel off colon-separated segments until we find a valid prefix or run out
@@ -38,11 +47,22 @@ function stripToValidPrefix(id: string): { prefix: string | null; path: string }
 
     const segment = remaining.slice(0, colonIdx);
     if (VALID_PREFIXES.has(segment)) {
-      // Check for double valid prefix (e.g., "file:file:src/foo.ts")
+      // Collapse the outer prefix only when the next segment is either:
+      //   - the SAME reserved word — a true duplicate ("file:file:src/foo.ts"), or
+      //   - the node's expected prefix — a spurious project-name prefix that
+      //     collides with a reserved word ("service:file:src/foo.ts" for a file
+      //     node), which must resolve to the canonical "file:src/foo.ts".
+      // A different reserved word that is NOT the expected prefix
+      // ("endpoint:service:x" for an endpoint node) is a real path segment and
+      // must be preserved.
       const rest = remaining.slice(colonIdx + 1);
       const innerColonIdx = rest.indexOf(":");
-      if (innerColonIdx > 0 && VALID_PREFIXES.has(rest.slice(0, innerColonIdx))) {
-        // Double-prefixed — skip the outer, recurse on inner
+      const innerSegment = innerColonIdx > 0 ? rest.slice(0, innerColonIdx) : "";
+      if (
+        innerColonIdx > 0 &&
+        (innerSegment === segment || innerSegment === expectedPrefix)
+      ) {
+        // Skip the outer prefix, recurse on the inner one
         remaining = rest;
         continue;
       }
@@ -69,7 +89,7 @@ export function normalizeNodeId(
   if (!trimmed) return trimmed;
 
   const expectedPrefix = TYPE_TO_PREFIX[node.type];
-  const { prefix, path } = stripToValidPrefix(trimmed);
+  const { prefix, path } = stripToValidPrefix(trimmed, expectedPrefix);
 
   if (prefix) {
     // For step nodes with filePath, reconstruct as step:flowSlug:filePath:stepSlug.