Compare a written-out deeplink prefix with its case folded too

Folding only the first segment left a prefix that spans more than one segment
half-matched: `Waitpoints/Tokens/wp_123` did not equal `waitpoints/tokens`, so
the graft branch fired on top of it and produced
`waitpoints/tokens/Tokens/wp_123`, which matches no route. The all-lowercase
spelling worked, so this was a regression the previous commit introduced.

Compare as many leading segments as the prefix spans, lowercased, and return the
prefix in the map's own spelling with everything past it exactly as written.
Driven off `prefix` rather than special-cased for waitpoints, so a second
multi-segment entry is covered when it is added.

Author: claude

apps/webapp/app/utils/deeplinkPages.test.ts

@@ -216,6 +216,37 @@ describe("resolveDeeplinkPage", () => {
     );
   });
 
+  it("recognises a written-out prefix whatever its case, however many segments it spans", () => {
+    // `waitpoints`' prefix is two segments, so folding only the first left `Tokens` looking like a
+    // segment of its own: the graft fired on top of it and produced waitpoints/tokens/Tokens/{id},
+    // which matches no route. The lowercase spelling worked, so this was case-folding's own bug.
+    expect(resolveDeeplinkPage("Waitpoints/Tokens/wp_123")).toBe("waitpoints/tokens/wp_123");
+    expect(resolveDeeplinkPage("waitpoints/Tokens/wp_123")).toBe("waitpoints/tokens/wp_123");
+    expect(resolveDeeplinkPage("WAITPOINTS/TOKENS/wp_123")).toBe("waitpoints/tokens/wp_123");
+    // The bare longhand, with nothing beyond the prefix to carry.
+    expect(resolveDeeplinkPage("Waitpoints/Tokens")).toBe("waitpoints/tokens");
+  });
+
+  it("holds for every multi-segment prefix in the map, not just waitpoints", () => {
+    // Driven off the map so a second such entry is covered the day it is added rather than the day
+    // someone notices. Every prefix segment is upper-cased and the id is left mixed.
+    const multiSegment = [...ENV_PAGE_TARGETS.values()].filter(({ prefix }) =>
+      prefix.includes("/")
+    );
+
+    // Guards against this passing because it iterated nothing.
+    expect(multiSegment.length).toBeGreaterThan(0);
+
+    for (const { prefix } of multiSegment) {
+      const shouted = prefix
+        .split("/")
+        .map((segment) => segment.toUpperCase())
+        .join("/");
+      expect(resolveDeeplinkPage(`${shouted}/${PROBE}`)).toBe(`${prefix}/${PROBE}`);
+      expect(resolveDeeplinkPage(shouted)).toBe(prefix);
+    }
+  });
+
   it("drops traversal segments, in plain and escaped spellings", () => {
     expect(resolveDeeplinkPage("runs/../../../etc/passwd")).toBe("runs/etc/passwd");
     expect(resolveDeeplinkPage("../runs")).toBe("runs");

apps/webapp/app/utils/deeplinkPages.ts

@@ -111,24 +111,32 @@ function isUsableSegment(segment: string): boolean {
  * `suffix` is expected already encoded (see `deeplinkSuffix`) and is passed through untouched — an
  * `encodeURIComponent` pass here would double-encode every id that contains an escape.
  *
- * Only the first segment is matched case-insensitively, to the same end as the prefix in
- * `deeplinkSuffix`: `/env/{env}/APIKeys` would have matched its route, so `/deeplink/APIKeys` should
- * reach it rather than falling through to the environment root. The name resolves to the map's own
- * spelling, and every segment after it is left exactly as written — folding the case of a task or
- * run id would break the link far more thoroughly than the miss this fixes.
+ * The name is matched case-insensitively, to the same end as the prefix in `deeplinkSuffix`:
+ * `/env/{env}/APIKeys` would have matched its route, so `/deeplink/APIKeys` should reach it rather
+ * than falling through to the environment root. So is the written-out prefix, which is why the
+ * comparison is against the lowercased path rather than the path itself — a prefix can be more than
+ * one segment (`waitpoints/tokens`), and reading only `Tokens` as a segment of its own would graft
+ * the prefix on top of it and produce `waitpoints/tokens/Tokens/{id}`.
+ *
+ * The prefix comes back in the map's own spelling and everything past it exactly as written, since
+ * folding the case of a task or run id would break the link far more thoroughly than the miss this
+ * fixes.
  */
 export function resolveDeeplinkPage(suffix: string): string | undefined {
-  const [first = "", ...rest] = suffix.split("/").filter(isUsableSegment);
+  const segments = suffix.split("/").filter(isUsableSegment);
+  const [first = "", ...rest] = segments;
 
-  const name = first.toLowerCase();
-  const target = ENV_PAGE_TARGETS.get(name);
+  const target = ENV_PAGE_TARGETS.get(first.toLowerCase());
   if (target === undefined) return undefined;
 
   if (rest.length === 0) return target.landing;
 
-  const written = [name, ...rest].join("/");
+  //however many segments the prefix spans, so the whole of it is compared and none of it re-grafted
+  const prefixDepth = target.prefix.split("/").length;
+  const writesPrefix = segments.slice(0, prefixDepth).join("/").toLowerCase() === target.prefix;
+
   //already written out under the prefix, so grafting would duplicate it
-  if (written === target.prefix || written.startsWith(`${target.prefix}/`)) return written;
+  const beyondPrefix = writesPrefix ? segments.slice(prefixDepth) : rest;
 
-  return [target.prefix, ...rest].join("/");
+  return [target.prefix, ...beyondPrefix].join("/");
 }