better-review 0.3.0 → 0.5.0

package/dist/cli.js

@@ -1782,8 +1782,8 @@ function getStatusCodeFromKey(code) {
   var _JSONRPC2_TO_HTTP_COD;
   return (_JSONRPC2_TO_HTTP_COD = JSONRPC2_TO_HTTP_CODE[code]) !== null && _JSONRPC2_TO_HTTP_COD !== void 0 ? _JSONRPC2_TO_HTTP_COD : 500;
 }
-function getHTTPStatusCode(json3) {
-  const httpStatuses = new Set((Array.isArray(json3) ? json3 : [json3]).map((res) => {
+function getHTTPStatusCode(json4) {
+  const httpStatuses = new Set((Array.isArray(json4) ? json4 : [json4]).map((res) => {
     if ("error" in res && isObject(res.error.data)) {
       var _res$error$data;
       if (typeof ((_res$error$data = res.error.data) === null || _res$error$data === void 0 ? void 0 : _res$error$data["httpStatus"]) === "number") return res.error.data["httpStatus"];
@@ -4226,7 +4226,7 @@ var HonoRequest = class {
   * ```
   */
   json() {
-    return this.#cachedBody("text").then((text) => JSON.parse(text));
+    return this.#cachedBody("text").then((text2) => JSON.parse(text2));
   }
   /**
   * `.text()` can parse Request body of type `text/plain`
@@ -4744,8 +4744,8 @@ var Context = class {
   * })
   * ```
   */
-  text = (text, arg, headers) => {
-    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
+  text = (text2, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text2) : this.#newResponse(text2, arg, setDefaultContentType(TEXT_PLAIN, headers));
   };
   /**
   * `.json()` can render JSON as `Content-Type:application/json`.
@@ -4762,9 +4762,9 @@ var Context = class {
   json = (object2, arg, headers) => {
     return this.#newResponse(JSON.stringify(object2), arg, setDefaultContentType("application/json", headers));
   };
-  html = (html, arg, headers) => {
-    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
-    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  html = (html2, arg, headers) => {
+    const res = (html3) => this.#newResponse(html3, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+    return typeof html2 === "object" ? resolveCallback(html2, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html2);
   };
   /**
   * `.redirect()` can Redirect, default status code is 302.
@@ -5519,12 +5519,12 @@ var Node3 = class Node4 {
       const pattern = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
       const isParam = Array.isArray(pattern);
       const key = isParam ? pattern[0] : pattern || p;
-      const child2 = curNode.#children[key] ||= new Node4();
-      if (pattern && !child2.#pattern) {
-        child2.#pattern = pattern;
-        curNode.#patterns.push(child2);
+      const child = curNode.#children[key] ||= new Node4();
+      if (pattern && !child.#pattern) {
+        child.#pattern = pattern;
+        curNode.#patterns.push(child);
       }
-      curNode = child2;
+      curNode = child;
       if (isParam) possibleKeys.add(pattern[1]);
     }
     curNode.#methods.push({ [method]: {
@@ -5569,15 +5569,15 @@ var Node3 = class Node4 {
             this.#pushHandlerSets(handlerSets, nextNode, method, node2.#params);
           } else tempNodes.push(nextNode);
         }
-        for (const child2 of node2.#patterns) {
-          const pattern = child2.#pattern;
+        for (const child of node2.#patterns) {
+          const pattern = child.#pattern;
           const params = node2.#params === emptyParams ? {} : { ...node2.#params };
           if (typeof pattern === "string") {
             if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
-              this.#pushHandlerSets(handlerSets, child2, method, node2.#params);
+              this.#pushHandlerSets(handlerSets, child, method, node2.#params);
               if (pattern === "*") {
-                child2.#params = params;
-                tempNodes.push(child2);
+                child.#params = params;
+                tempNodes.push(child);
               }
             }
             continue;
@@ -5597,12 +5597,12 @@ var Node3 = class Node4 {
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
-              this.#pushHandlerSets(handlerSets, child2, method, node2.#params, params);
-              if (m[0].length === restPathString.length && child2.#children["*"]) this.#pushHandlerSets(handlerSets, child2.#children["*"], method, node2.#params, params);
-              for (const _ in child2.#children) {
-                child2.#params = params;
+              this.#pushHandlerSets(handlerSets, child, method, node2.#params, params);
+              if (m[0].length === restPathString.length && child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, node2.#params, params);
+              for (const _ in child.#children) {
+                child.#params = params;
                 const componentCount = m[0].match(/\//g)?.length ?? 0;
-                (curNodesQueue[componentCount] ||= []).push(child2);
+                (curNodesQueue[componentCount] ||= []).push(child);
                 break;
               }
               continue;
@@ -5611,11 +5611,11 @@ var Node3 = class Node4 {
           if (matcher === true || matcher.test(part)) {
             params[name] = part;
             if (isLast) {
-              this.#pushHandlerSets(handlerSets, child2, method, params, node2.#params);
-              if (child2.#children["*"]) this.#pushHandlerSets(handlerSets, child2.#children["*"], method, params, node2.#params);
+              this.#pushHandlerSets(handlerSets, child, method, params, node2.#params);
+              if (child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node2.#params);
             } else {
-              child2.#params = params;
-              tempNodes.push(child2);
+              child.#params = params;
+              tempNodes.push(child);
             }
           }
         }
@@ -5742,9 +5742,9 @@ function hashString(input2, seed = 0) {
 }
 var LINE_PREFIX = { context: " ", add: "+", del: "-" };
 function hunkHash(path, lines) {
-  let text = path + "\n";
-  for (const line of lines) text += LINE_PREFIX[line.type] + line.content + "\n";
-  return hashString(text);
+  let text2 = path + "\n";
+  for (const line of lines) text2 += LINE_PREFIX[line.type] + line.content + "\n";
+  return hashString(text2);
 }
 var HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
 function unquote(path) {
@@ -5786,9 +5786,9 @@ function pathsFromGitHeader(rest) {
   const idx = rest.indexOf(" b/");
   return idx === -1 ? [rest, rest] : [stripPrefix(rest.slice(0, idx)), stripPrefix(rest.slice(idx + 1))];
 }
-function parseUnifiedDiff(text) {
+function parseUnifiedDiff(text2) {
   const files = [];
-  const lines = text.split("\n");
+  const lines = text2.split("\n");
   let file2 = null;
   let hunk = null;
   let oldNo = 0;
@@ -10982,9 +10982,9 @@ function isRecursive(inst, stack, resolve) {
     return PROVEN;
   stack.add(inst);
   let result = NONE;
-  const check2 = (child2) => {
-    if (result !== PROVEN && child2?._zod) {
-      const answer = isRecursive(child2, stack, resolve);
+  const check2 = (child) => {
+    if (result !== PROVEN && child?._zod) {
+      const answer = isRecursive(child, stack, resolve);
       if (answer > result)
         result = answer;
     }
@@ -10995,9 +10995,9 @@ function isRecursive(inst, stack, resolve) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child2 = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
-      if (child2 > answer)
-        answer = child2;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
+      if (child > answer)
+        answer = child;
     }
     return answer;
   };
@@ -15257,8 +15257,8 @@ function ko_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text) => {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+var capitalizeFirstCharacter = (text2) => {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -21554,13 +21554,13 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function handleUnrepresentable(schema, ctx, json3, params, message) {
+function handleUnrepresentable(schema, ctx, json4, params, message) {
   const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({ zodSchema: schema, path: params.path, message }) : ctx.unrepresentable;
   if (result === "any")
     return false;
   if (result === void 0 || result === "throw")
     throw new Error(message);
-  Object.assign(json3, result);
+  Object.assign(json4, result);
   return true;
 }
 function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
@@ -21796,12 +21796,12 @@ function foldObjects(members2) {
   }
   return folded;
 }
-function foldIntersection(json3) {
-  const allOf = json3.allOf;
+function foldIntersection(json4) {
+  const allOf = json4.allOf;
   if (!Array.isArray(allOf) || allOf.length < 2)
     return;
   for (const key of FOLDABLE_KEYS)
-    if (key in json3)
+    if (key in json4)
       return;
   const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
   let folded = null;
@@ -21820,8 +21820,8 @@ function foldIntersection(json3) {
   }
   if (!folded)
     return;
-  delete json3.allOf;
-  assignProps(json3, folded);
+  delete json4.allOf;
+  assignProps(json4, folded);
 }
 function finalize(ctx, schema) {
   const root = ctx.seen.get(schema);
@@ -21903,20 +21903,20 @@ function finalize(ctx, schema) {
     if (ctx.intersections.length) {
       const carriers = /* @__PURE__ */ new Map();
       for (const seen of ctx.seen.values()) {
-        for (const json3 of [seen.schema, seen.def]) {
-          const allOf = json3?.allOf;
+        for (const json4 of [seen.schema, seen.def]) {
+          const allOf = json4?.allOf;
           if (!Array.isArray(allOf))
             continue;
           const existing = carriers.get(allOf);
           if (existing)
-            existing.push(json3);
+            existing.push(json4);
           else
-            carriers.set(allOf, [json3]);
+            carriers.set(allOf, [json4]);
         }
       }
       for (const allOf of ctx.intersections) {
-        for (const json3 of carriers.get(allOf) ?? [])
-          foldIntersection(json3);
+        for (const json4 of carriers.get(allOf) ?? [])
+          foldIntersection(json4);
       }
     }
   }
@@ -22151,29 +22151,29 @@ var exactPatterns = /* @__PURE__ */ new Map([
 ]);
 var exactPattern = (p) => exactPatterns.get(p) ?? p;
 var stringProcessor = (schema, ctx, _json, _params) => {
-  const json3 = _json;
-  json3.type = "string";
+  const json4 = _json;
+  json4.type = "string";
   const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json3.minLength = minimum;
+    json4.minLength = minimum;
   if (typeof maximum === "number")
-    json3.maxLength = maximum;
+    json4.maxLength = maximum;
   if (format) {
-    json3.format = formatMap[format] ?? format;
-    if (json3.format === "")
-      delete json3.format;
+    json4.format = formatMap[format] ?? format;
+    if (json4.format === "")
+      delete json4.format;
     if (format === "time" || laxFormat) {
-      delete json3.format;
+      delete json4.format;
     }
   }
   if (contentEncoding)
-    json3.contentEncoding = contentEncoding;
+    json4.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const patternList = [...patterns].map(exactPattern);
     if (patternList.length === 1)
-      json3.pattern = patternList[0].source;
+      json4.pattern = patternList[0].source;
     else if (patternList.length > 1) {
-      json3.allOf = [
+      json4.allOf = [
         ...patternList.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -22183,31 +22183,31 @@ var stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 var numberProcessor = (schema, ctx, _json, params) => {
-  const json3 = _json;
+  const json4 = _json;
   const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
-  json3.type = isInt ? "integer" : "number";
+  json4.type = isInt ? "integer" : "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
   const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
   if (exMin) {
     if (legacy) {
-      json3.minimum = exclusiveMinimum;
-      json3.exclusiveMinimum = true;
+      json4.minimum = exclusiveMinimum;
+      json4.exclusiveMinimum = true;
     } else {
-      json3.exclusiveMinimum = exclusiveMinimum;
+      json4.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json3.minimum = minimum;
+    json4.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json3.maximum = exclusiveMaximum;
-      json3.exclusiveMaximum = true;
+      json4.maximum = exclusiveMaximum;
+      json4.exclusiveMaximum = true;
     } else {
-      json3.exclusiveMaximum = exclusiveMaximum;
+      json4.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json3.maximum = maximum;
+    json4.maximum = maximum;
   }
   if (multipleOf) {
     const divisors = /* @__PURE__ */ new Set();
@@ -22215,75 +22215,75 @@ var numberProcessor = (schema, ctx, _json, params) => {
       if (Number.isFinite(divisor) && divisor !== 0)
         divisors.add(Math.abs(divisor));
       else
-        handleUnrepresentable(schema, ctx, json3, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
+        handleUnrepresentable(schema, ctx, json4, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
     const [first, ...rest] = divisors;
     if (first !== void 0)
-      json3.multipleOf = first;
+      json4.multipleOf = first;
     if (rest.length)
-      json3.allOf = [...json3.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
+      json4.allOf = [...json4.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
   }
 };
-var booleanProcessor = (_schema, _ctx, json3, _params) => {
-  json3.type = "boolean";
+var booleanProcessor = (_schema, _ctx, json4, _params) => {
+  json4.type = "boolean";
 };
-var bigintProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "BigInt cannot be represented in JSON Schema");
+var bigintProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "BigInt cannot be represented in JSON Schema");
 };
-var symbolProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Symbols cannot be represented in JSON Schema");
+var symbolProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Symbols cannot be represented in JSON Schema");
 };
-var nullProcessor = (_schema, ctx, json3, _params) => {
+var nullProcessor = (_schema, ctx, json4, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json3.type = "string";
-    json3.nullable = true;
-    json3.enum = [null];
+    json4.type = "string";
+    json4.nullable = true;
+    json4.enum = [null];
   } else {
-    json3.type = "null";
+    json4.type = "null";
   }
 };
-var undefinedProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Undefined cannot be represented in JSON Schema");
+var undefinedProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Undefined cannot be represented in JSON Schema");
 };
-var voidProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Void cannot be represented in JSON Schema");
+var voidProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Void cannot be represented in JSON Schema");
 };
-var neverProcessor = (_schema, _ctx, json3, _params) => {
-  json3.not = {};
+var neverProcessor = (_schema, _ctx, json4, _params) => {
+  json4.not = {};
 };
 var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
 var unknownProcessor = (_schema, _ctx, _json, _params) => {
 };
-var dateProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Date cannot be represented in JSON Schema");
+var dateProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Date cannot be represented in JSON Schema");
 };
-var enumProcessor = (schema, _ctx, json3, _params) => {
+var enumProcessor = (schema, _ctx, json4, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.length === 0) {
-    json3.not = {};
+    json4.not = {};
     return;
   }
   if (values.every((v) => typeof v === "number"))
-    json3.type = "number";
+    json4.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json3.type = "string";
-  json3.enum = values;
+    json4.type = "string";
+  json4.enum = values;
 };
-var literalProcessor = (schema, ctx, json3, params) => {
+var literalProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   if (def.values.length === 0) {
-    json3.not = {};
+    json4.not = {};
     return;
   }
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
-      if (handleUnrepresentable(schema, ctx, json3, params, "Literal `undefined` cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json4, params, "Literal `undefined` cannot be represented in JSON Schema"))
         return;
     } else if (typeof val === "bigint") {
-      if (handleUnrepresentable(schema, ctx, json3, params, "BigInt literals cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json4, params, "BigInt literals cannot be represented in JSON Schema"))
         return;
       vals.push(Number(val));
     } else {
@@ -22293,37 +22293,37 @@ var literalProcessor = (schema, ctx, json3, params) => {
   if (vals.length === 0) {
   } else if (vals.length === 1) {
     const val = vals[0];
-    json3.type = val === null ? "null" : typeof val;
+    json4.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json3.enum = [val];
+      json4.enum = [val];
     } else {
-      json3.const = val;
+      json4.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json3.type = "number";
+      json4.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json3.type = "string";
+      json4.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json3.type = "boolean";
+      json4.type = "boolean";
     if (vals.every((v) => v === null))
-      json3.type = "null";
-    json3.enum = vals;
+      json4.type = "null";
+    json4.enum = vals;
   }
 };
-var nanProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "NaN cannot be represented in JSON Schema");
+var nanProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "NaN cannot be represented in JSON Schema");
 };
-var templateLiteralProcessor = (schema, _ctx, json3, _params) => {
-  const _json = json3;
+var templateLiteralProcessor = (schema, _ctx, json4, _params) => {
+  const _json = json4;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx, json3, _params) => {
-  const _json = json3;
+var fileProcessor = (schema, _ctx, json4, _params) => {
+  const _json = json4;
   _json.type = "string";
   _json.format = "binary";
   _json.contentEncoding = "binary";
@@ -22341,34 +22341,34 @@ var fileProcessor = (schema, _ctx, json3, _params) => {
   else
     _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
 };
-var successProcessor = (_schema, _ctx, json3, _params) => {
-  json3.type = "boolean";
+var successProcessor = (_schema, _ctx, json4, _params) => {
+  json4.type = "boolean";
 };
-var customProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Custom types cannot be represented in JSON Schema");
+var customProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Custom types cannot be represented in JSON Schema");
 };
-var functionProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Function types cannot be represented in JSON Schema");
+var functionProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Function types cannot be represented in JSON Schema");
 };
-var transformProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Transforms cannot be represented in JSON Schema");
+var transformProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Transforms cannot be represented in JSON Schema");
 };
-var mapProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Map cannot be represented in JSON Schema");
+var mapProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Map cannot be represented in JSON Schema");
 };
-var setProcessor = (schema, ctx, json3, params) => {
-  handleUnrepresentable(schema, ctx, json3, params, "Set cannot be represented in JSON Schema");
+var setProcessor = (schema, ctx, json4, params) => {
+  handleUnrepresentable(schema, ctx, json4, params, "Set cannot be represented in JSON Schema");
 };
 var arrayProcessor = (schema, ctx, _json, params) => {
-  const json3 = _json;
+  const json4 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json3.minItems = minimum;
+    json4.minItems = minimum;
   if (typeof maximum === "number")
-    json3.maxItems = maximum;
-  json3.type = "array";
-  json3.items = processSchema(def.element, ctx, {
+    json4.maxItems = maximum;
+  json4.type = "array";
+  json4.items = processSchema(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -22384,17 +22384,17 @@ function inputOptin(schema) {
   return schema._zod.optin;
 }
 var objectProcessor = (schema, ctx, _json, params) => {
-  const json3 = _json;
+  const json4 = _json;
   const def = schema._zod.def;
   const shape = def.shape;
   const symbolKeys = Object.getOwnPropertySymbols(shape);
-  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json3, params, "Symbol keys cannot be represented in JSON Schema")) {
+  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json4, params, "Symbol keys cannot be represented in JSON Schema")) {
     return;
   }
-  json3.type = "object";
-  json3.properties = {};
+  json4.type = "object";
+  json4.properties = {};
   for (const key in shape) {
-    assignProp(json3.properties, key, processSchema(shape[key], ctx, {
+    assignProp(json4.properties, key, processSchema(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     }));
@@ -22407,21 +22407,21 @@ var objectProcessor = (schema, ctx, _json, params) => {
     }
   }
   if (requiredKeys.length > 0) {
-    json3.required = requiredKeys;
+    json4.required = requiredKeys;
   }
   if (def.catchall?._zod.def.type === "never") {
-    json3.additionalProperties = false;
+    json4.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json3.additionalProperties = false;
+      json4.additionalProperties = false;
   } else if (def.catchall) {
-    json3.additionalProperties = processSchema(def.catchall, ctx, {
+    json4.additionalProperties = processSchema(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-var unionProcessor = (schema, ctx, json3, params) => {
+var unionProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => processSchema(x, ctx, {
@@ -22429,12 +22429,12 @@ var unionProcessor = (schema, ctx, json3, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
   if (isExclusive) {
-    json3.oneOf = options;
+    json4.oneOf = options;
   } else {
-    json3.anyOf = options;
+    json4.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json3, params) => {
+var intersectionProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   const a = processSchema(def.left, ctx, {
     ...params,
@@ -22449,13 +22449,13 @@ var intersectionProcessor = (schema, ctx, json3, params) => {
     ...isSimpleIntersection(a) ? a.allOf : [a],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json3.allOf = allOf;
+  json4.allOf = allOf;
   ctx.intersections.push(allOf);
 };
 var tupleProcessor = (schema, ctx, _json, params) => {
-  const json3 = _json;
+  const json4 = _json;
   const def = schema._zod.def;
-  json3.type = "array";
+  json4.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
   const prefixItems = def.items.map((x, i) => processSchema(x, ctx, {
@@ -22477,70 +22477,70 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   const maxItems = def.items.length;
   const isClosed = !def.rest;
   if (ctx.target === "draft-2020-12") {
-    json3.prefixItems = prefixItems;
+    json4.prefixItems = prefixItems;
     if (isClosed) {
-      json3.items = false;
+      json4.items = false;
     } else if (rest) {
-      json3.items = rest;
+      json4.items = rest;
     }
     if (minItems > 0)
-      json3.minItems = minItems;
+      json4.minItems = minItems;
     if (isClosed)
-      json3.maxItems = maxItems;
+      json4.maxItems = maxItems;
   } else if (ctx.target === "openapi-3.0") {
-    json3.items = {
+    json4.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json3.items.anyOf.push(rest);
+      json4.items.anyOf.push(rest);
     }
     if (minItems > 0)
-      json3.minItems = minItems;
+      json4.minItems = minItems;
     if (isClosed)
-      json3.maxItems = maxItems;
+      json4.maxItems = maxItems;
   } else {
-    json3.items = prefixItems;
+    json4.items = prefixItems;
     if (isClosed) {
-      json3.additionalItems = false;
+      json4.additionalItems = false;
     } else if (rest) {
-      json3.additionalItems = rest;
+      json4.additionalItems = rest;
     }
     if (minItems > 0)
-      json3.minItems = minItems;
+      json4.minItems = minItems;
     if (isClosed)
-      json3.maxItems = maxItems;
+      json4.maxItems = maxItems;
   }
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json3.minItems = minimum;
+    json4.minItems = minimum;
   if (typeof maximum === "number")
-    json3.maxItems = maximum;
-};
-function stringifyKeyNames(bySchema, json3, visited) {
-  if (json3.$ref) {
-    if (visited.has(json3))
-      return json3;
-    visited.add(json3);
-    const def = bySchema.get(json3)?.def;
+    json4.maxItems = maximum;
+};
+function stringifyKeyNames(bySchema, json4, visited) {
+  if (json4.$ref) {
+    if (visited.has(json4))
+      return json4;
+    visited.add(json4);
+    const def = bySchema.get(json4)?.def;
     if (!def)
-      return json3;
+      return json4;
     const inlined = stringifyKeyNames(bySchema, def, visited);
-    return inlined === def ? json3 : inlined;
+    return inlined === def ? json4 : inlined;
   }
   for (const keyword of ["anyOf", "oneOf"]) {
-    const branches = json3[keyword];
+    const branches = json4[keyword];
     if (!Array.isArray(branches))
       continue;
     const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
     if (mapped.some((branch, i) => branch !== branches[i]))
-      json3 = { ...json3, [keyword]: mapped };
+      json4 = { ...json4, [keyword]: mapped };
   }
-  const types = Array.isArray(json3.type) ? json3.type : [json3.type];
+  const types = Array.isArray(json4.type) ? json4.type : [json4.type];
   const numericType = !types.includes("string") && types.some((t2) => t2 === "number" || t2 === "integer");
-  const values = json3.enum ?? (json3.const !== void 0 ? [json3.const] : void 0);
+  const values = json4.enum ?? (json4.const !== void 0 ? [json4.const] : void 0);
   if (!numericType && !values?.some((v) => typeof v === "number"))
-    return json3;
-  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json3;
+    return json4;
+  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json4;
   if (rest.enum)
     rest.enum = rest.enum.map((v) => typeof v === "number" ? String(v) : v);
   else if (typeof rest.const === "number")
@@ -22580,9 +22580,9 @@ function rewriteKeyNames(ctx) {
   }
 }
 var recordProcessor = (schema, ctx, _json, params) => {
-  const json3 = _json;
+  const json4 = _json;
   const def = schema._zod.def;
-  json3.type = "object";
+  json4.type = "object";
   const keyType = def.keyType;
   const patterns = aggregateChecks(keyType).patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
@@ -22590,13 +22590,13 @@ var recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json3.patternProperties = {};
+    json4.patternProperties = {};
     for (const pattern of patterns) {
-      assignProp(json3.patternProperties, exactPattern(pattern).source, valueSchema);
+      assignProp(json4.patternProperties, exactPattern(pattern).source, valueSchema);
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json3.propertyNames = processSchema(def.keyType, ctx, {
+      json4.propertyNames = processSchema(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
@@ -22608,7 +22608,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
       }
       pending.push(schema);
     }
-    json3.additionalProperties = processSchema(def.valueType, ctx, {
+    json4.additionalProperties = processSchema(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -22618,19 +22618,19 @@ var recordProcessor = (schema, ctx, _json, params) => {
   if (keyValues && !def.partial && !omittableOnInput) {
     const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
     if (validKeyValues.length > 0) {
-      json3.required = validKeyValues.map(String);
+      json4.required = validKeyValues.map(String);
     }
   }
 };
-var nullableProcessor = (schema, ctx, json3, params) => {
+var nullableProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   const inner = processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json3.nullable = true;
+    json4.nullable = true;
   } else {
-    json3.anyOf = [inner, { type: "null" }];
+    json4.anyOf = [inner, { type: "null" }];
   }
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -22640,7 +22640,7 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   seen.ref = def.innerType;
 };
 var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
-function serializeDefaultValue(value, schema, ctx, json3, params) {
+function serializeDefaultValue(value, schema, ctx, json4, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_, val) => {
     if (typeof val !== "bigint")
@@ -22650,30 +22650,30 @@ function serializeDefaultValue(value, schema, ctx, json3, params) {
   });
   if (!unrepresentable)
     return JSON.parse(serialized);
-  handleUnrepresentable(schema, ctx, json3, params, "BigInt defaults cannot be represented in JSON Schema");
+  handleUnrepresentable(schema, ctx, json4, params, "BigInt defaults cannot be represented in JSON Schema");
   return UNREPRESENTABLE_DEFAULT;
 }
-var defaultProcessor = (schema, ctx, json3, params) => {
+var defaultProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json4, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json3.default = value;
+    json4.default = value;
 };
-var prefaultProcessor = (schema, ctx, json3, params) => {
+var prefaultProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io !== "input")
     return;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json4, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json3._prefault = value;
+    json4._prefault = value;
 };
-var catchProcessor = (schema, ctx, json3, params) => {
+var catchProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -22682,10 +22682,10 @@ var catchProcessor = (schema, ctx, json3, params) => {
   try {
     catchValue = def.catchValue(void 0);
   } catch {
-    handleUnrepresentable(schema, ctx, json3, params, "Dynamic catch values are not supported in JSON Schema");
+    handleUnrepresentable(schema, ctx, json4, params, "Dynamic catch values are not supported in JSON Schema");
     return;
   }
-  json3.default = catchValue;
+  json4.default = catchValue;
 };
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -22695,12 +22695,12 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json3, params) => {
+var readonlyProcessor = (schema, ctx, json4, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json3.readOnly = true;
+  json4.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -23342,7 +23342,7 @@ var _ZodString = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodString.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
+    inst._zod.processJSONSchema = (ctx, json4, params) => stringProcessor(inst, ctx, json4, params);
   },
   /* @__PURE__ */ util_exports.derived({
     format: (inst) => aggregateChecks(inst).format ?? null,
@@ -23701,7 +23701,7 @@ var ZodNumber = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
+    inst._zod.processJSONSchema = (ctx, json4, params) => numberProcessor(inst, ctx, json4, params);
     inst.isFinite = true;
   },
   /* @__PURE__ */ util_exports.derived({
@@ -23791,7 +23791,7 @@ function uint32(params) {
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => booleanProcessor(inst, ctx, json4, params);
 });
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
@@ -23801,7 +23801,7 @@ var ZodBigInt = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
+    inst._zod.processJSONSchema = (ctx, json4, params) => bigintProcessor(inst, ctx, json4, params);
   },
   /* @__PURE__ */ util_exports.derived({
     minValue: (inst) => aggregateChecks(inst).minimum ?? null,
@@ -23859,7 +23859,7 @@ function uint64(params) {
 var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
   $ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => symbolProcessor(inst, ctx, json4, params);
 });
 function symbol(params) {
   return _symbol(ZodSymbol, params);
@@ -23867,7 +23867,7 @@ function symbol(params) {
 var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
   $ZodUndefined.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => undefinedProcessor(inst, ctx, json4, params);
 });
 function _undefined3(params) {
   return _undefined2(ZodUndefined, params);
@@ -23875,7 +23875,7 @@ function _undefined3(params) {
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => nullProcessor(inst, ctx, json4, params);
 });
 function _null3(params) {
   return _null2(ZodNull, params);
@@ -23883,7 +23883,7 @@ function _null3(params) {
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
   $ZodAny.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => anyProcessor(inst, ctx, json4, params);
 });
 function any() {
   return _any(ZodAny);
@@ -23891,7 +23891,7 @@ function any() {
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => unknownProcessor(inst, ctx, json4, params);
 });
 function unknown() {
   return _unknown(ZodUnknown);
@@ -23899,7 +23899,7 @@ function unknown() {
 var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => neverProcessor(inst, ctx, json4, params);
 });
 function never(params) {
   return _never(ZodNever, params);
@@ -23907,7 +23907,7 @@ function never(params) {
 var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
   $ZodVoid.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => voidProcessor(inst, ctx, json4, params);
 });
 function _void2(params) {
   return _void(ZodVoid, params);
@@ -23917,7 +23917,7 @@ var ZodDate = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodDate.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
+    inst._zod.processJSONSchema = (ctx, json4, params) => dateProcessor(inst, ctx, json4, params);
     inst.min = (value, params) => inst.check(_gte(value, params));
     inst.max = (value, params) => inst.check(_lte(value, params));
   },
@@ -23939,7 +23939,7 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => arrayProcessor(inst, ctx, json4, params);
   inst.element = def.element;
 }, {
   min(n, params) {
@@ -23969,7 +23969,7 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => objectProcessor(inst, ctx, json4, params);
   util_exports.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 }, {
   keyof() {
@@ -24042,7 +24042,7 @@ function looseObject(shape, params) {
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => unionProcessor(inst, ctx, json4, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -24055,7 +24055,7 @@ function union(options, params) {
 var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
   ZodUnion.init(inst, def);
   $ZodXor.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => unionProcessor(inst, ctx, json4, params);
   inst.options = def.options;
 });
 function xor(options, params) {
@@ -24081,7 +24081,7 @@ function discriminatedUnion(discriminator, options, params) {
 var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => intersectionProcessor(inst, ctx, json4, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -24094,7 +24094,7 @@ var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => tupleProcessor(inst, ctx, json4, params);
 }, {
   rest(rest) {
     return this.clone({
@@ -24127,7 +24127,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodRecord.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => recordProcessor(inst, ctx, json4, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
@@ -24169,7 +24169,7 @@ var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodMap.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => mapProcessor(inst, ctx, json4, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
   inst.min = (...args) => inst.check(_minSize(...args));
@@ -24189,7 +24189,7 @@ var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => setProcessor(inst, ctx, json4, params);
   inst.min = (...args) => inst.check(_minSize(...args));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
   inst.max = (...args) => inst.check(_maxSize(...args));
@@ -24205,7 +24205,7 @@ function set(valueType, params) {
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => enumProcessor(inst, ctx, json4, params);
   inst.enum = def.entries;
   inst.options = [...inst._zod.values];
   const keys = new Set(Object.keys(def.entries));
@@ -24258,7 +24258,7 @@ function nativeEnum(entries, params) {
 var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
   $ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => literalProcessor(inst, ctx, json4, params);
   inst.values = new Set(def.values);
   Object.defineProperty(inst, "value", {
     get() {
@@ -24279,7 +24279,7 @@ function literal(value, params) {
 var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   $ZodFile.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => fileProcessor(inst, ctx, json4, params);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
   inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
@@ -24291,7 +24291,7 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => transformProcessor(inst, ctx, json4, params);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -24330,7 +24330,7 @@ function transform(fn) {
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => optionalProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -24342,7 +24342,7 @@ function optional(innerType) {
 var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => optionalProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -24354,7 +24354,7 @@ function exactOptional(innerType) {
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => nullableProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -24369,7 +24369,7 @@ function nullish2(innerType) {
 var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => defaultProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -24385,7 +24385,7 @@ function _default2(innerType, defaultValue) {
 var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => prefaultProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -24400,7 +24400,7 @@ function prefault(innerType, defaultValue) {
 var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => nonoptionalProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -24413,7 +24413,7 @@ function nonoptional(innerType, params) {
 var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
   $ZodSuccess.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => successProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function success(innerType) {
@@ -24425,7 +24425,7 @@ function success(innerType) {
 var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => catchProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -24439,7 +24439,7 @@ function _catch2(innerType, catchValue) {
 var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
   $ZodNaN.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => nanProcessor(inst, ctx, json4, params);
 });
 function nan(params) {
   return _nan(ZodNaN, params);
@@ -24447,7 +24447,7 @@ function nan(params) {
 var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => pipeProcessor(inst, ctx, json4, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -24489,7 +24489,7 @@ var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) =>
 var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => readonlyProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -24501,7 +24501,7 @@ function readonly(innerType) {
 var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => templateLiteralProcessor(inst, ctx, json4, params);
 });
 function templateLiteral(parts, params) {
   return new ZodTemplateLiteral({
@@ -24513,7 +24513,7 @@ function templateLiteral(parts, params) {
 var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => lazyProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -24525,7 +24525,7 @@ function lazy(getter) {
 var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
   $ZodPromise.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => promiseProcessor(inst, ctx, json4, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function promise(innerType) {
@@ -24537,7 +24537,7 @@ function promise(innerType) {
 var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
   $ZodFunction.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => functionProcessor(inst, ctx, json4, params);
 });
 function _function(params) {
   return new ZodFunction({
@@ -24549,7 +24549,7 @@ function _function(params) {
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
+  inst._zod.processJSONSchema = (ctx, json4, params) => customProcessor(inst, ctx, json4, params);
 });
 function check(fn) {
   const ch = new $ZodCheck({
@@ -25647,6 +25647,16 @@ var trackedEntrySchema = external_exports.union([
 ]);
 var diffSideSchema = external_exports.enum(["LEFT", "RIGHT"]);
 var reviewEventSchema = external_exports.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES"]);
+var reactionContentSchema = external_exports.enum([
+  "THUMBS_UP",
+  "THUMBS_DOWN",
+  "LAUGH",
+  "HOORAY",
+  "CONFUSED",
+  "HEART",
+  "ROCKET",
+  "EYES"
+]);
 var newThreadSchema = external_exports.discriminatedUnion("subjectType", [
   external_exports.object({
     subjectType: external_exports.literal("LINE"),
@@ -25782,148 +25792,15 @@ var GitHub = class {
 };
 
 // ../server/src/github/queries.ts
-var PR_SUMMARY = (
-  /* GraphQL */
-  `
-  fragment PrSummary on PullRequest {
-    id
-    number
-    title
-    url
-    isDraft
-    createdAt
-    updatedAt
-    additions
-    deletions
-    changedFiles
-    headRefOid
-    reviewDecision
-    repository {
-      nameWithOwner
-    }
-    author {
-      login
-      avatarUrl
-    }
-    labels(first: 10) {
-      nodes {
-        name
-        color
-      }
-    }
-    commits(last: 1) {
-      nodes {
-        commit {
-          statusCheckRollup {
-            state
-          }
-        }
-      }
-    }
-    reviewRequests(first: 20) {
-      totalCount
-      nodes {
-        requestedReviewer {
-          __typename
-          ... on User {
-            login
-          }
-          ... on Team {
-            slug
-          }
-        }
-      }
-    }
-    latestOpinionatedReviews(first: 20) {
-      nodes {
-        state
-        author {
-          login
-          avatarUrl
-        }
-      }
-    }
-    viewerLatestReview {
-      state
-      submittedAt
-      commit {
-        oid
-      }
-    }
-    reviewThreads(first: 100) {
-      nodes {
-        isResolved
-        comments(last: 1) {
-          nodes {
-            author {
-              login
-            }
-            createdAt
-          }
-        }
-      }
-    }
-    comments(last: 1) {
-      nodes {
-        author {
-          login
-        }
-        createdAt
-      }
-    }
-    files(first: 100) {
-      totalCount
-      nodes {
-        viewerViewedState
-      }
-    }
-  }
-`
-);
-var INBOX_SECTION_IDS = [
-  "requested",
-  "reviewed",
-  "mine",
-  "involved",
-  "stale",
-  "unreviewed"
-];
-var INBOX_IDS_QUERY = (
-  /* GraphQL */
-  `
-  query InboxIds(${INBOX_SECTION_IDS.map((id) => `$${id}: String!`).join(", ")}) {
-    viewer { login avatarUrl }
-    ${INBOX_SECTION_IDS.map(
-    (id) => `${id}: search(query: $${id}, type: ISSUE, first: 50) {
-        nodes { ... on PullRequest { id } }
-      }`
-  ).join("\n")}
-  }
-`
-);
-var PR_SUMMARIES_QUERY = (
-  /* GraphQL */
-  `
-  query PrSummaries($ids: [ID!]!) {
-    nodes(ids: $ids) {
-      ...PrSummary
-    }
-  }
-  ${PR_SUMMARY}
-`
-);
-var INBOX_FINGERPRINT_QUERY = (
+var REACTION_FIELDS = (
   /* GraphQL */
   `
-  query InboxFingerprint($q: String!) {
-    search(query: $q, type: ISSUE, first: 100) {
-      issueCount
-      nodes {
-        ... on PullRequest {
-          id
-          updatedAt
-          headRefOid
-        }
+  fragment ReactionFields on Reactable {
+    reactionGroups {
+      content
+      viewerHasReacted
+      reactors {
+        totalCount
       }
     }
   }
@@ -25954,7 +25831,9 @@ var REVIEW_COMMENT_FIELDS = (
     }
     viewerCanUpdate
     viewerCanDelete
+    ...ReactionFields
   }
+  ${REACTION_FIELDS}
 `
 );
 var THREAD_FIELDS = (
@@ -26009,6 +25888,7 @@ var PR_QUERY = (
         updatedAt
         body
         bodyHTML
+        ...ReactionFields
         baseRefName
         headRefName
         baseRefOid
@@ -26025,31 +25905,6 @@ var PR_QUERY = (
         headRepository {
           nameWithOwner
         }
-        lastCommit: commits(last: 1) {
-          nodes {
-            commit {
-              statusCheckRollup {
-                state
-                contexts(first: 100) {
-                  nodes {
-                    __typename
-                    ... on CheckRun {
-                      name
-                      conclusion
-                      status
-                      detailsUrl
-                    }
-                    ... on StatusContext {
-                      context
-                      state
-                      targetUrl
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
         reviewRequests(first: 20) {
           nodes {
             requestedReviewer {
@@ -26111,6 +25966,7 @@ var PR_QUERY = (
             url
             body
             bodyHTML
+            ...ReactionFields
             createdAt
             author {
               login
@@ -26125,6 +25981,7 @@ var PR_QUERY = (
             state
             body
             bodyHTML
+            ...ReactionFields
             submittedAt
             createdAt
             url
@@ -26271,182 +26128,442 @@ async function fetchTexts(gh, ref, expressions) {
   return texts;
 }
 
-// ../server/src/inbox.ts
-var SCOPE_CHUNK = 20;
-function scopeChunks(config2) {
-  const terms = [...config2.repos.map((r) => `repo:${r}`), ...config2.orgs.map((o) => `user:${o}`)];
-  const chunks = [];
-  for (let i = 0; i < terms.length; i += SCOPE_CHUNK) chunks.push(terms.slice(i, i + SCOPE_CHUNK).join(" "));
-  return chunks;
-}
-function searchQueries(scope, staleDays, now) {
-  const base = `is:pr is:open archived:false ${scope}`;
-  const staleBefore = new Date(now - staleDays * 864e5).toISOString().slice(0, 10);
-  return {
-    requested: `${base} review-requested:@me`,
-    reviewed: `${base} reviewed-by:@me -author:@me`,
-    mine: `${base} author:@me`,
-    involved: `${base} involves:@me -author:@me`,
-    stale: `${base} updated:<${staleBefore}`,
-    unreviewed: `${base} draft:false review:none`
-  };
-}
-function prKey(owner, repo, number4) {
-  return `${owner}/${repo}#${number4}`.toLowerCase();
-}
-function toInboxPr(node2, me, visit2) {
-  const [owner = "", repo = ""] = node2.repository.nameWithOwner.split("/");
-  let open2 = 0;
-  let awaitingMyReply = 0;
-  let lastOtherActivity = 0;
-  for (const thread of node2.reviewThreads.nodes) {
-    const last = thread.comments.nodes[0];
-    const lastIsOther = last?.author?.login !== me;
-    if (!thread.isResolved) {
-      open2++;
-      if (last && lastIsOther) awaitingMyReply++;
+// ../server/src/github/inboxQueries.ts
+var BOARD_FIELDS = (
+  /* GraphQL */
+  `
+  fragment BoardFields on PullRequest {
+    id
+    number
+    title
+    url
+    isDraft
+    createdAt
+    updatedAt
+    headRefOid
+    reviewDecision
+    isInMergeQueue
+    mergedAt
+    repository {
+      nameWithOwner
+    }
+    author {
+      login
+      avatarUrl
+    }
+    reviews {
+      totalCount
+    }
+    latestOpinionatedReviews(first: 10) {
+      nodes {
+        state
+        author {
+          login
+          avatarUrl
+        }
+      }
+    }
+    reviewRequests(first: 10) {
+      nodes {
+        requestedReviewer {
+          __typename
+          ... on User {
+            login
+          }
+          ... on Team {
+            slug
+          }
+        }
+      }
     }
-    if (last && lastIsOther) lastOtherActivity = Math.max(lastOtherActivity, Date.parse(last.createdAt));
   }
-  const lastComment = node2.comments.nodes[0];
-  if (lastComment && lastComment.author?.login !== me) {
-    lastOtherActivity = Math.max(lastOtherActivity, Date.parse(lastComment.createdAt));
+`
+);
+var BOARD_QUERY = (
+  /* GraphQL */
+  `
+  query Board($ids: [ID!]!) {
+    nodes(ids: $ids) {
+      ...BoardFields
+    }
   }
-  const files = node2.files?.nodes ?? [];
-  const myReview = node2.viewerLatestReview;
-  return {
-    id: node2.id,
-    owner,
-    repo,
-    number: node2.number,
-    title: node2.title,
-    url: node2.url,
-    isDraft: node2.isDraft,
-    author: node2.author,
-    createdAt: node2.createdAt,
-    updatedAt: node2.updatedAt,
-    additions: node2.additions,
-    deletions: node2.deletions,
-    changedFiles: node2.changedFiles,
-    labels: node2.labels.nodes,
-    ci: node2.commits.nodes[0]?.commit.statusCheckRollup?.state ?? null,
-    reviewDecision: node2.reviewDecision,
-    reviews: node2.latestOpinionatedReviews.nodes.flatMap(
-      (r) => r.author ? [{ login: r.author.login, avatarUrl: r.author.avatarUrl, state: r.state }] : []
-    ),
-    requested: node2.reviewRequests.nodes.flatMap((r) => {
-      const name = r.requestedReviewer?.login ?? r.requestedReviewer?.slug;
-      return name ? [name] : [];
-    }),
-    myReview: myReview ? {
-      state: myReview.state,
-      submittedAt: myReview.submittedAt,
-      upToDate: myReview.commit?.oid === node2.headRefOid
-    } : null,
-    threads: { total: node2.reviewThreads.nodes.length, open: open2, awaitingMyReply },
-    files: {
-      viewed: files.filter((f) => f.viewerViewedState === "VIEWED").length,
-      total: node2.files?.totalCount ?? node2.changedFiles
-    },
-    lastVisitAt: visit2?.visitedAt ?? null,
-    unread: !visit2 || visit2.headOid !== node2.headRefOid || lastOtherActivity > visit2.visitedAt
-  };
-}
-function classifyInbox(results, me, visits) {
-  const make = (node2) => {
-    const [owner = "", repo = ""] = node2.repository.nameWithOwner.split("/");
-    return toInboxPr(node2, me, visits.get(prKey(owner, repo, node2.number)));
-  };
-  const placed = /* @__PURE__ */ new Set();
-  const take = (nodes, keep = () => true) => {
-    const out = [];
-    for (const node2 of nodes) {
-      if (placed.has(node2.id)) continue;
-      const pr = make(node2);
-      if (!keep(pr)) continue;
-      placed.add(node2.id);
-      out.push(pr);
-    }
-    return out;
-  };
-  const requested = take(results.requested);
-  const rereview = take(results.reviewed, (pr) => pr.myReview !== null && !pr.myReview.upToDate);
-  const mine = take(results.mine);
-  const mineDraft = mine.filter((pr) => pr.isDraft);
-  const mineTodo = mine.filter(
-    (pr) => !pr.isDraft && (pr.threads.awaitingMyReply > 0 || pr.reviewDecision === "CHANGES_REQUESTED")
-  );
-  const mineReady = mine.filter(
-    (pr) => !pr.isDraft && !mineTodo.includes(pr) && pr.reviewDecision === "APPROVED" && (pr.ci === null || pr.ci === "SUCCESS") && pr.threads.open === 0
-  );
-  const mineWaiting = mine.filter((pr) => !pr.isDraft && !mineTodo.includes(pr) && !mineReady.includes(pr));
-  const involved = take(results.involved);
-  const stale = results.stale.map(make);
-  const unreviewed = results.unreviewed.map(make).filter((pr) => pr.requested.length === 0);
-  const byUpdated = (a, b) => b.updatedAt.localeCompare(a.updatedAt);
-  const sections = [
-    { id: "requested", prs: requested },
-    { id: "rereview", prs: rereview },
-    { id: "mine-todo", prs: mineTodo },
-    { id: "mine-waiting", prs: mineWaiting },
-    { id: "mine-ready", prs: mineReady },
-    { id: "mine-draft", prs: mineDraft },
-    { id: "involved", prs: involved },
-    { id: "stale", prs: stale.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt)) },
-    { id: "unreviewed", prs: unreviewed }
-  ];
-  for (const s of sections) if (s.id !== "stale") s.prs.sort(byUpdated);
-  return sections;
-}
-async function runSearches(gh, config2, now) {
-  const idsBySection = Object.fromEntries(INBOX_SECTION_IDS.map((id) => [id, []]));
-  let viewer2 = null;
-  for (const scope of scopeChunks(config2)) {
-    const data = await gh.graphql(
-      INBOX_IDS_QUERY,
-      searchQueries(scope, config2.staleDays, now)
-    );
-    viewer2 = data.viewer;
-    for (const section of INBOX_SECTION_IDS) {
-      for (const node2 of data[section].nodes) {
-        if (node2.id && !idsBySection[section].includes(node2.id)) idsBySection[section].push(node2.id);
+  ${BOARD_FIELDS}
+`
+);
+var CHECKS_FIELDS = (
+  /* GraphQL */
+  `
+  commits(last: 1) {
+    nodes {
+      commit {
+        statusCheckRollup {
+          state
+        }
       }
     }
   }
-  const unique = [...new Set(INBOX_SECTION_IDS.flatMap((s) => idsBySection[s]))];
-  const byId = /* @__PURE__ */ new Map();
-  for (let i = 0; i < unique.length; i += 100) {
-    const data = await gh.graphql(PR_SUMMARIES_QUERY, { ids: unique.slice(i, i + 100) });
-    for (const node2 of data.nodes) if (node2) byId.set(node2.id, node2);
+`
+);
+var CHECKS_QUERY = (
+  /* GraphQL */
+  `
+  query BoardChecks($ids: [ID!]!) {
+    nodes(ids: $ids) {
+      ... on PullRequest {
+        id
+        ${CHECKS_FIELDS}
+        reviewThreads(first: 100) {
+          nodes {
+            isResolved
+          }
+        }
+      }
+    }
   }
-  const merged = Object.fromEntries(
-    INBOX_SECTION_IDS.map((s) => [s, idsBySection[s].flatMap((id) => byId.get(id) ?? [])])
-  );
-  return { viewer: viewer2, merged };
-}
-async function loadInbox(gh, config2, viewerFallback, lastVisits) {
-  const now = Date.now();
-  const { viewer: viewer2, merged } = await runSearches(gh, config2, now);
-  const me = viewer2 ?? await viewerFallback();
-  const keys = INBOX_SECTION_IDS.flatMap(
-    (id) => merged[id].map((n) => {
-      const [owner = "", repo = ""] = n.repository.nameWithOwner.split("/");
-      return prKey(owner, repo, n.number);
-    })
-  );
-  return {
-    viewer: me,
-    configured: config2.repos.length + config2.orgs.length > 0,
-    sections: classifyInbox(merged, me.login, lastVisits([...new Set(keys)])),
-    fetchedAt: now
+`
+);
+var DETAILS_QUERY = (
+  /* GraphQL */
+  `
+  query BoardDetails($ids: [ID!]!) {
+    nodes(ids: $ids) {
+      ... on PullRequest {
+        id
+        additions
+        deletions
+        ${CHECKS_FIELDS}
+        viewerLatestReview {
+          state
+          commit {
+            oid
+          }
+        }
+        comments(last: 1) {
+          nodes {
+            author {
+              login
+            }
+            createdAt
+          }
+        }
+        reviewThreads(first: 100) {
+          nodes {
+            isResolved
+            comments(last: 1) {
+              nodes {
+                author {
+                  login
+                }
+                createdAt
+              }
+            }
+          }
+        }
+        files(first: 100) {
+          totalCount
+          nodes {
+            viewerViewedState
+          }
+        }
+      }
+    }
+  }
+`
+);
+var SEARCH_IDS_QUERY = (
+  /* GraphQL */
+  `
+  query SearchIds($q: String!, $after: String) {
+    viewer {
+      login
+      avatarUrl
+    }
+    search(query: $q, type: ISSUE, first: 100, after: $after) {
+      issueCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+      nodes {
+        ... on PullRequest {
+          id
+        }
+      }
+    }
+  }
+`
+);
+var INBOX_FINGERPRINT_QUERY = (
+  /* GraphQL */
+  `
+  query InboxFingerprint($q: String!) {
+    search(query: $q, type: ISSUE, first: 100) {
+      issueCount
+      nodes {
+        ... on PullRequest {
+          id
+          updatedAt
+          headRefOid
+          reviewDecision
+          isInMergeQueue
+          ${CHECKS_FIELDS}
+        }
+      }
+    }
+  }
+`
+);
+
+// ../server/src/inbox.ts
+var MERGED_WINDOW_MS = 24 * 36e5;
+function scopeTerms(config2) {
+  return [...config2.repos.map((r) => `repo:${r}`), ...config2.orgs.map((o) => `user:${o}`)];
+}
+var SCOPE_CHUNK = 20;
+function scopeChunks(config2) {
+  const terms = scopeTerms(config2);
+  const chunks = [];
+  for (let i = 0; i < terms.length; i += SCOPE_CHUNK) chunks.push(terms.slice(i, i + SCOPE_CHUNK).join(" "));
+  return chunks;
+}
+function searchQueries(scope, mergedSince) {
+  const open2 = `is:pr is:open archived:false ${scope}`;
+  const since = new Date(mergedSince).toISOString().replace(/\.\d+Z$/, "Z");
+  return {
+    open: `${open2} sort:updated-desc`,
+    requested: `${open2} review-requested:@me`,
+    involved: `${open2} involves:@me -author:@me`,
+    reviewed: `${open2} reviewed-by:@me -author:@me`,
+    merged: `is:pr is:merged archived:false ${scope} merged:>=${since} sort:updated-desc`
+  };
+}
+function prKey(owner, repo, number4) {
+  return `${owner}/${repo}#${number4}`.toLowerCase();
+}
+function isApproved(decision, states) {
+  if (decision !== null) return decision === "APPROVED";
+  return states.includes("APPROVED") && !states.includes("CHANGES_REQUESTED");
+}
+function toInboxPr(node2, me, visit2) {
+  const [owner = "", repo = ""] = node2.repository.nameWithOwner.split("/");
+  let threads;
+  let lastOtherActivity = 0;
+  if (node2.reviewThreads) {
+    threads = { total: node2.reviewThreads.nodes.length, open: 0, awaitingMyReply: 0 };
+    for (const thread of node2.reviewThreads.nodes) {
+      const last = thread.comments?.nodes[0];
+      const lastIsOther = last?.author?.login !== me;
+      if (!thread.isResolved) {
+        threads.open++;
+        if (last && lastIsOther) threads.awaitingMyReply++;
+      }
+      if (last && lastIsOther) lastOtherActivity = Math.max(lastOtherActivity, Date.parse(last.createdAt));
+    }
+  }
+  const lastComment = node2.comments?.nodes[0];
+  if (lastComment && lastComment.author?.login !== me) {
+    lastOtherActivity = Math.max(lastOtherActivity, Date.parse(lastComment.createdAt));
+  }
+  const myReview = node2.viewerLatestReview;
+  return {
+    id: node2.id,
+    owner,
+    repo,
+    number: node2.number,
+    title: node2.title,
+    url: node2.url,
+    isDraft: node2.isDraft,
+    inMergeQueue: node2.isInMergeQueue,
+    mergedAt: node2.mergedAt,
+    author: node2.author,
+    createdAt: node2.createdAt,
+    updatedAt: node2.updatedAt,
+    reviewDecision: node2.reviewDecision,
+    reviewCount: node2.reviews.totalCount,
+    reviews: node2.latestOpinionatedReviews.nodes.flatMap(
+      (r) => r.author ? [{ login: r.author.login, avatarUrl: r.author.avatarUrl, state: r.state }] : []
+    ),
+    requested: node2.reviewRequests.nodes.flatMap((r) => {
+      const name = r.requestedReviewer?.login ?? r.requestedReviewer?.slug;
+      return name ? [name] : [];
+    }),
+    ...node2.commits ? { ci: node2.commits.nodes[0]?.commit.statusCheckRollup?.state ?? null } : {},
+    ...threads ? { threads } : {},
+    ...node2.additions !== void 0 ? { additions: node2.additions, deletions: node2.deletions ?? 0 } : {},
+    ...myReview !== void 0 ? {
+      myReview: myReview && { state: myReview.state, upToDate: myReview.commit?.oid === node2.headRefOid }
+    } : {},
+    ...node2.files ? {
+      files: {
+        viewed: node2.files.nodes.filter((f) => f.viewerViewedState === "VIEWED").length,
+        total: node2.files.totalCount
+      }
+    } : {},
+    lastVisitAt: visit2?.visitedAt ?? null,
+    unread: !visit2 || visit2.headOid !== node2.headRefOid || lastOtherActivity > visit2.visitedAt
+  };
+}
+function stageOf(pr) {
+  if (pr.mergedAt !== null) return "merged";
+  if (pr.inMergeQueue) return "queued";
+  if (pr.isDraft) return "draft";
+  if (isApproved(
+    pr.reviewDecision,
+    pr.reviews.map((r) => r.state)
+  )) {
+    const green = pr.ci === null || pr.ci === "SUCCESS";
+    return green && (pr.threads?.open ?? 0) === 0 ? "ready" : "approved";
+  }
+  const reviewed = pr.reviewDecision === "CHANGES_REQUESTED" || pr.reviewCount > 0 || pr.reviews.length > 0 || (pr.threads?.total ?? 0) > 0;
+  return reviewed ? "review" : "waiting";
+}
+function buildBoard(sources, me, visits, staleBefore) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const node2 of [...sources.open, ...sources.merged]) nodes.set(node2.id, node2);
+  const prs = [...nodes.values()].map((node2) => {
+    const [owner = "", repo = ""] = node2.repository.nameWithOwner.split("/");
+    const pr = toInboxPr(node2, me, visits.get(prKey(owner, repo, node2.number)));
+    const stage = stageOf(pr);
+    const mine = pr.author?.login === me;
+    const tags = mine ? ["mine"] : [];
+    if (stage === "merged") return { ...pr, stage, tags };
+    if (mine) {
+      const feedback = (pr.threads?.awaitingMyReply ?? 0) > 0 || pr.reviewDecision === "CHANGES_REQUESTED";
+      if (!pr.isDraft && feedback) tags.push("todo");
+    } else {
+      if (sources.requested.has(node2.id)) tags.push("requested");
+      if (pr.myReview && !pr.myReview.upToDate) tags.push("rereview");
+      if (tags.length === 0 && (sources.involved.has(node2.id) || pr.myReview)) tags.push("involved");
+    }
+    if (Date.parse(pr.updatedAt) < staleBefore) tags.push("stale");
+    if (stage === "waiting" && pr.requested.length === 0) tags.push("unreviewed");
+    return { ...pr, stage, tags };
+  });
+  return prs.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+var MAX_SEARCH_PAGES = 10;
+var BATCH2 = 25;
+var PARALLEL = 12;
+async function retryOnTimeout(run2) {
+  try {
+    return await run2();
+  } catch (error62) {
+    if (error62 instanceof GitHubError && (error62.status === 502 || error62.status === 504)) return run2();
+    throw error62;
+  }
+}
+async function pool(tasks) {
+  const results = new Array(tasks.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < tasks.length) {
+      const i = next++;
+      results[i] = await tasks[i]();
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(PARALLEL, tasks.length) }, worker));
+  return results;
+}
+async function fetchNodes(gh, query, ids) {
+  const batches = [];
+  for (let i = 0; i < ids.length; i += BATCH2) batches.push(ids.slice(i, i + BATCH2));
+  const results = await pool(
+    batches.map((batch) => () => retryOnTimeout(() => gh.graphql(query, { ids: batch })))
+  );
+  return results.flatMap((r) => r.nodes.filter((n) => n !== null));
+}
+async function searchIds(gh, q, pages) {
+  const ids = [];
+  let after = null;
+  let viewer2 = null;
+  let truncated = false;
+  for (let page = 0; page < pages; page++) {
+    const data = await gh.graphql(SEARCH_IDS_QUERY, { q, after });
+    viewer2 = data.viewer;
+    for (const node2 of data.search.nodes) if (node2.id) ids.push(node2.id);
+    if (!data.search.pageInfo.hasNextPage) break;
+    after = data.search.pageInfo.endCursor;
+    truncated = page === pages - 1;
+  }
+  return { viewer: viewer2, ids, truncated };
+}
+var SIDE_SEARCHES = ["requested", "involved", "reviewed", "merged"];
+async function loadSources(gh, config2, now) {
+  const open2 = scopeTerms(config2).map(
+    (term) => () => searchIds(gh, searchQueries(term, 0).open, MAX_SEARCH_PAGES)
+  );
+  const side = scopeChunks(config2).flatMap((chunk) => {
+    const queries = searchQueries(chunk, now - MERGED_WINDOW_MS);
+    return SIDE_SEARCHES.map((name) => async () => ({ name, ...await searchIds(gh, queries[name], 1) }));
+  });
+  const [openResults, sideResults] = await Promise.all([pool(open2), pool(side)]);
+  const viewer2 = openResults[0]?.viewer ?? sideResults[0]?.viewer ?? null;
+  const sideIds = (name) => new Set(sideResults.filter((r) => r.name === name).flatMap((r) => r.ids));
+  const requested = sideIds("requested");
+  const involved = sideIds("involved");
+  const reviewed = sideIds("reviewed");
+  const mergedIds = [...sideIds("merged")];
+  const openIds = [...new Set(openResults.flatMap((r) => r.ids))];
+  const board = await fetchNodes(gh, BOARD_QUERY, [.../* @__PURE__ */ new Set([...openIds, ...mergedIds])]);
+  const byId = new Map(board.map((node2) => [node2.id, node2]));
+  const me = viewer2?.login;
+  const personal = [];
+  const approved = [];
+  for (const node2 of board) {
+    if (node2.mergedAt !== null) continue;
+    const concernsMe = requested.has(node2.id) || involved.has(node2.id) || reviewed.has(node2.id) || node2.author?.login === me;
+    if (concernsMe) personal.push(node2.id);
+    else if (isApproved(
+      node2.reviewDecision,
+      node2.latestOpinionatedReviews.nodes.map((r) => r.state)
+    )) {
+      approved.push(node2.id);
+    }
+  }
+  const [details, checks] = await Promise.all([
+    fetchNodes(gh, DETAILS_QUERY, personal),
+    fetchNodes(gh, CHECKS_QUERY, approved)
+  ]);
+  for (const extra of [...details, ...checks]) {
+    const node2 = byId.get(extra.id);
+    if (node2) byId.set(extra.id, { ...node2, ...extra });
+  }
+  const nodesOf = (list) => list.flatMap((id) => byId.get(id) ?? []);
+  return {
+    viewer: viewer2,
+    truncated: openResults.some((r) => r.truncated),
+    sources: { open: nodesOf(openIds), merged: nodesOf(mergedIds), requested, involved }
+  };
+}
+async function loadInbox(gh, config2, viewerFallback, lastVisits) {
+  const now = Date.now();
+  const { viewer: viewer2, truncated, sources } = await loadSources(gh, config2, now);
+  const me = viewer2 ?? await viewerFallback();
+  const keys = [...sources.open, ...sources.merged].map((n) => {
+    const [owner = "", repo = ""] = n.repository.nameWithOwner.split("/");
+    return prKey(owner, repo, n.number);
+  });
+  return {
+    viewer: me,
+    configured: config2.repos.length + config2.orgs.length > 0,
+    prs: buildBoard(sources, me.login, lastVisits([...new Set(keys)]), now - config2.staleDays * 864e5),
+    truncated,
+    fetchedAt: now
   };
 }
 async function inboxFingerprint(gh, config2, signal) {
   const parts = [];
   for (const scope of scopeChunks(config2)) {
-    const data = await gh.graphql(INBOX_FINGERPRINT_QUERY, { q: `is:pr is:open archived:false ${scope}` }, signal);
+    const data = await gh.graphql(
+      INBOX_FINGERPRINT_QUERY,
+      { q: `is:pr is:open archived:false ${scope} sort:updated-desc` },
+      signal
+    );
     parts.push(String(data.search.issueCount));
-    for (const n of data.search.nodes) parts.push(`${n.id}:${n.updatedAt}:${n.headRefOid}`);
+    for (const n of data.search.nodes) {
+      const ci = n.commits?.nodes[0]?.commit.statusCheckRollup?.state ?? "";
+      parts.push(`${n.id}:${n.updatedAt}:${n.headRefOid}:${n.reviewDecision}:${n.isInMergeQueue}:${ci}`);
+    }
   }
   return parts.join("|");
 }
@@ -26497,7 +26614,6 @@ async function loadPr(gh, store, ref) {
       reviewers.set(rr.login, { login: rr.login, avatarUrl: rr.avatarUrl, state: "REQUESTED" });
     else if (rr?.__typename === "Team") requestedTeams.push(rr.slug);
   }
-  const rollup = pr.lastCommit.nodes[0]?.commit.statusCheckRollup ?? null;
   const timeline = [
     ...pr.comments.nodes.map((c) => ({
       kind: "comment",
@@ -26505,6 +26621,7 @@ async function loadPr(gh, store, ref) {
       url: c.url,
       body: c.body,
       bodyHTML: c.bodyHTML,
+      reactions: toReactions(c.reactionGroups),
       createdAt: c.createdAt,
       author: c.author,
       unread: c.author?.login !== me && Date.parse(c.createdAt) > lastVisitAt
@@ -26516,6 +26633,7 @@ async function loadPr(gh, store, ref) {
       state: r.state,
       body: r.body,
       bodyHTML: r.bodyHTML,
+      reactions: toReactions(r.reactionGroups),
       createdAt: r.submittedAt ?? r.createdAt,
       author: r.author,
       unread: r.author?.login !== me && Date.parse(r.submittedAt ?? r.createdAt) > lastVisitAt
@@ -26537,6 +26655,7 @@ async function loadPr(gh, store, ref) {
       updatedAt: pr.updatedAt,
       body: pr.body,
       bodyHTML: pr.bodyHTML,
+      reactions: toReactions(pr.reactionGroups),
       baseRefName: pr.baseRefName,
       headRefName: pr.headRefName,
       baseRefOid: pr.baseRefOid,
@@ -26549,12 +26668,6 @@ async function loadPr(gh, store, ref) {
       author: pr.author,
       sameRepo: pr.headRepository?.nameWithOwner.toLowerCase() === `${ref.owner}/${ref.repo}`.toLowerCase()
     },
-    checks: rollup ? {
-      state: rollup.state,
-      contexts: rollup.contexts.nodes.map(
-        (c) => c.__typename === "CheckRun" ? { name: c.name, state: c.conclusion ?? c.status, url: c.detailsUrl } : { name: c.context, state: c.state, url: c.targetUrl }
-      )
-    } : null,
     reviewers: [...reviewers.values()],
     requestedTeams,
     myReview: pr.viewerLatestReview ? {
@@ -26586,6 +26699,9 @@ async function loadPr(gh, store, ref) {
     seenHunks: store.seenHunks(key)
   };
 }
+function toReactions(groups) {
+  return (groups ?? []).filter((g) => g.reactors.totalCount > 0).map((g) => ({ content: g.content, count: g.reactors.totalCount, mine: g.viewerHasReacted }));
+}
 function toComment(c) {
   return {
     id: c.id,
@@ -26593,6 +26709,7 @@ function toComment(c) {
     url: c.url,
     body: c.body,
     bodyHTML: c.bodyHTML,
+    reactions: toReactions(c.reactionGroups),
     createdAt: c.createdAt,
     author: c.author,
     pending: c.state === "PENDING",
@@ -26669,9 +26786,9 @@ async function loadDiff(gh, store, ref, base, head, isFullPr) {
     const res = await gh.request(`/repos/${ref.owner}/${ref.repo}/compare/${base}...${head}`, {
       accept: "application/vnd.github.diff"
     });
-    const text = await res.text();
-    store.putDiff(cacheKey2, text);
-    return { base, head, files: parseUnifiedDiff(text), missingFiles: 0 };
+    const text2 = await res.text();
+    store.putDiff(cacheKey2, text2);
+    return { base, head, files: parseUnifiedDiff(text2), missingFiles: 0 };
   } catch (error62) {
     if (!(error62 instanceof GitHubError) || error62.status === 404) throw error62;
   }
@@ -26704,9 +26821,9 @@ async function loadBlobs(gh, store, ref, oids) {
   if (missing.length > 0) {
     const texts = await fetchTexts(gh, ref, missing);
     for (const oid of missing) {
-      const text = texts.get(oid) ?? null;
-      store.putDiff(key(oid), JSON.stringify(text));
-      out[oid] = text;
+      const text2 = texts.get(oid) ?? null;
+      store.putDiff(key(oid), JSON.stringify(text2));
+      out[oid] = text2;
     }
   }
   return out;
@@ -26720,6 +26837,17 @@ async function setFileViewed(gh, prId, path, viewed) {
     { id: prId, path }
   );
 }
+async function setReaction(gh, subjectId, content, on2) {
+  const mutation = on2 ? "addReaction" : "removeReaction";
+  const data = await gh.graphql(
+    `mutation($id: ID!, $content: ReactionContent!) {
+      ${mutation}(input: { subjectId: $id, content: $content }) { subject { ...ReactionFields } }
+    }
+    ${REACTION_FIELDS}`,
+    { id: subjectId, content }
+  );
+  return toReactions(data[mutation].subject.reactionGroups);
+}
 async function replyToThread(gh, threadId, body, pendingReviewId) {
   const data = await gh.graphql(
     `mutation($thread: ID!, $body: String!, $review: ID) {
@@ -26816,7 +26944,7 @@ async function addIssueComment(gh, subjectId, body) {
     }`,
     { id: subjectId, body }
   );
-  return { kind: "comment", ...data.addComment.commentEdge.node, unread: false };
+  return { kind: "comment", ...data.addComment.commentEdge.node, reactions: [], unread: false };
 }
 async function deleteReviewComment(gh, commentId) {
   await gh.graphql(
@@ -26846,9 +26974,9 @@ async function applySuggestion(gh, ref, input2) {
   const file2 = await gh.rest(
     `/repos/${ref.owner}/${ref.repo}/contents/${encodedPath}?ref=${input2.expectedHeadOid}`
   );
-  const text = Buffer.from(file2.content, "base64").toString("utf8");
-  const eol = text.includes("\r\n") ? "\r\n" : "\n";
-  const lines = text.split(eol);
+  const text2 = Buffer.from(file2.content, "base64").toString("utf8");
+  const eol = text2.includes("\r\n") ? "\r\n" : "\n";
+  const lines = text2.split(eol);
   if (input2.endLine > lines.length || input2.startLine < 1 || input2.startLine > input2.endLine) {
     throw new GitHubError("Lignes de la suggestion hors du fichier.", 422);
   }
@@ -26873,10 +27001,103 @@ async function applySuggestion(gh, ref, input2) {
   return res.commit.sha;
 }
 
-// ../server/src/links/extract.ts
-import ts from "typescript";
+// ../server/src/checks.ts
+var PR_CHECKS_QUERY = (
+  /* GraphQL */
+  `
+  query PrChecks($owner: String!, $repo: String!, $number: Int!) {
+    repository(owner: $owner, name: $repo) {
+      pullRequest(number: $number) {
+        commits(last: 1) {
+          nodes {
+            commit {
+              statusCheckRollup {
+                state
+                contexts(first: 100) {
+                  nodes {
+                    __typename
+                    ... on CheckRun {
+                      name
+                      conclusion
+                      status
+                      detailsUrl
+                      title
+                      checkSuite {
+                        workflowRun {
+                          workflow {
+                            name
+                          }
+                        }
+                      }
+                    }
+                    ... on StatusContext {
+                      context
+                      state
+                      targetUrl
+                      description
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`
+);
+var FAILED = /* @__PURE__ */ new Set(["FAILURE", "TIMED_OUT", "STARTUP_FAILURE", "ACTION_REQUIRED", "CANCELLED", "ERROR"]);
+var SKIPPED = /* @__PURE__ */ new Set(["NEUTRAL", "SKIPPED", "STALE"]);
+var RANK = { failure: 0, pending: 1, success: 2, skipped: 3 };
+function outcomeOf(state) {
+  if (FAILED.has(state)) return "failure";
+  if (state === "SUCCESS") return "success";
+  if (SKIPPED.has(state)) return "skipped";
+  return "pending";
+}
+function toChecks(rollup) {
+  if (!rollup) return null;
+  const all = rollup.contexts.nodes.map((c) => {
+    if (c.__typename === "StatusContext") {
+      return {
+        name: c.context,
+        outcome: outcomeOf(c.state),
+        state: c.state.toLowerCase(),
+        url: c.targetUrl,
+        summary: c.description || null
+      };
+    }
+    const state = c.conclusion ?? c.status;
+    const workflow = c.checkSuite?.workflowRun?.workflow.name;
+    return {
+      name: workflow ? `${workflow} / ${c.name}` : c.name,
+      outcome: outcomeOf(state),
+      state: state.toLowerCase(),
+      url: c.detailsUrl,
+      summary: c.title || null
+    };
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const checks = all.filter((c) => {
+    const key = `${c.name}\0${c.outcome}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  checks.sort((a, b) => RANK[a.outcome] - RANK[b.outcome] || a.name.localeCompare(b.name));
+  return { state: rollup.state, checks };
+}
+async function loadChecks(gh, ref) {
+  const data = await gh.graphql(PR_CHECKS_QUERY, {
+    owner: ref.owner,
+    repo: ref.repo,
+    number: ref.number
+  });
+  return toChecks(data.repository?.pullRequest?.commits.nodes[0]?.commit.statusCheckRollup ?? null);
+}
 
-// ../server/src/links/paths.ts
+// ../../packages/language/src/paths.ts
 function normalizePath(path) {
   const segments = [];
   for (const segment of path.split("/")) {
@@ -26915,74 +27136,200 @@ function sharedPrefixLength(a, b) {
   return count;
 }
 
-// ../server/src/links/extract.ts
-var SCRIPT_KIND_BY_EXTENSION = {
-  ".ts": ts.ScriptKind.TS,
-  ".mts": ts.ScriptKind.TS,
-  ".cts": ts.ScriptKind.TS,
-  ".tsx": ts.ScriptKind.TSX,
-  ".js": ts.ScriptKind.JS,
-  ".mjs": ts.ScriptKind.JS,
-  ".cjs": ts.ScriptKind.JS,
-  ".jsx": ts.ScriptKind.JSX
+// ../../packages/language/src/registry.ts
+var LanguageRegistry = class {
+  #byId = /* @__PURE__ */ new Map();
+  #byFilename = /* @__PURE__ */ new Map();
+  /** Longest extension first. */
+  #byExtension = [];
+  constructor(languages2) {
+    const extensions = /* @__PURE__ */ new Map();
+    for (const language of languages2) {
+      const { id, extensions: exts, filenames = [] } = language.info;
+      if (this.#byId.has(id)) throw new Error(`Langage d\xE9clar\xE9 deux fois : ${id}`);
+      this.#byId.set(id, language);
+      for (const name of filenames) claim2(this.#byFilename, name.toLowerCase(), language);
+      for (const ext of exts) claim2(extensions, ext.toLowerCase(), language);
+    }
+    this.#byExtension = [...extensions].sort(([a], [b]) => b.length - a.length);
+  }
+  /** Every language, in declaration order. */
+  all() {
+    return [...this.#byId.values()];
+  }
+  byId(id) {
+    return this.#byId.get(id);
+  }
+  /** Language of a repository path, or null when no registered language handles it. */
+  detect(path) {
+    const name = basename(path).toLowerCase();
+    const exact = this.#byFilename.get(name);
+    if (exact !== void 0) return exact;
+    for (const [extension, language] of this.#byExtension) {
+      if (name.length > extension.length && name.endsWith(extension)) return language;
+    }
+    return null;
+  }
 };
-var SCRIPT_KIND_BY_LANG = {
-  ts: ts.ScriptKind.TS,
-  typescript: ts.ScriptKind.TS,
-  tsx: ts.ScriptKind.TSX,
-  jsx: ts.ScriptKind.JSX
-};
-var EXTRACTORS = {
-  typescript: extractScriptFile,
-  javascript: extractScriptFile,
-  vue: extractComponentScripts,
-  svelte: extractComponentScripts,
-  python: extractPython,
-  css: extractStyle,
-  go: extractGo,
-  java: extractJvm,
-  kotlin: extractJvm,
-  c: extractInclude,
-  cpp: extractInclude,
-  rust: extractRust,
-  ruby: extractRuby,
-  markdown: () => []
-};
-function extractImports(text, path, language) {
-  return language === null ? [] : EXTRACTORS[language](text, path);
-}
-function extractScriptFile(text, path) {
-  return parseScript(text, path, SCRIPT_KIND_BY_EXTENSION[extname(path).toLowerCase()] ?? ts.ScriptKind.TS);
-}
-function extractComponentScripts(text, path) {
-  const refs = [];
-  for (const match2 of text.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi)) {
-    const lang = /\blang\s*=\s*["']?(tsx?|jsx|typescript)\b/i.exec(match2[1] ?? "")?.[1]?.toLowerCase() ?? "";
-    refs.push(...parseScript(match2[2] ?? "", path, SCRIPT_KIND_BY_LANG[lang] ?? ts.ScriptKind.JS));
+function claim2(map2, key, language) {
+  const owner = map2.get(key);
+  if (owner !== void 0 && owner !== language) {
+    throw new Error(`\xAB ${key} \xBB revendiqu\xE9 par ${owner.info.id} et ${language.info.id}`);
   }
-  return refs;
+  map2.set(key, language);
 }
-function parseScript(text, path, kind) {
-  const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, kind);
+
+// ../../packages/lang-css/src/info.ts
+var cssInfo = { id: "css", label: "CSS", extensions: [".css"] };
+var scssInfo = { id: "scss", label: "SCSS", extensions: [".scss"] };
+var sassInfo = { id: "sass", label: "Sass", extensions: [".sass"] };
+var lessInfo = { id: "less", label: "Less", extensions: [".less"] };
+
+// ../../packages/lang-css/src/analysis.ts
+function extractImports(text2) {
   const refs = [];
-  const visit2 = (node2) => {
-    const ref = scriptImport(node2);
-    if (ref !== null) refs.push(ref);
-    ts.forEachChild(node2, visit2);
-  };
-  visit2(source);
+  const source = text2.replace(/\/\*[\s\S]*?\*\//g, "");
+  for (const match2 of source.matchAll(/@(import|use|forward)\s+([^;\n]+)/g)) {
+    const urls = [...(match2[2] ?? "").matchAll(/url\(\s*["']?([^"')\s]+)["']?\s*\)|["']([^"'\n]+)["']/g)];
+    for (const url2 of match2[1] === "import" ? urls : urls.slice(0, 1)) {
+      const specifier = url2[1] ?? url2[2];
+      if (specifier !== void 0) refs.push({ specifier, names: [] });
+    }
+  }
   return refs;
 }
-function scriptImport(node2) {
-  if (ts.isImportDeclaration(node2)) return withSpecifier(node2.moduleSpecifier, importClauseNames(node2));
-  if (ts.isExportDeclaration(node2)) {
-    return node2.moduleSpecifier === void 0 ? null : withSpecifier(node2.moduleSpecifier, exportNames(node2));
-  }
-  if (ts.isImportEqualsDeclaration(node2) && ts.isExternalModuleReference(node2.moduleReference)) {
-    const name = `${node2.isTypeOnly ? "type " : ""}${node2.name.text}`;
-    return withSpecifier(node2.moduleReference.expression, [name]);
-  }
-  if (ts.isImportTypeNode(node2) && ts.isLiteralTypeNode(node2.argument)) {
+var STYLE_EXTENSIONS = [".scss", ".sass", ".css", ".less"];
+function candidates(base) {
+  const dir = dirname(base);
+  const partial2 = `${dir === "" ? "" : `${dir}/`}_${basename(base)}`;
+  if (STYLE_EXTENSIONS.includes(extname(base))) return [base, partial2];
+  return [
+    base,
+    ...STYLE_EXTENSIONS.flatMap((ext) => [base + ext, partial2 + ext]),
+    ...STYLE_EXTENSIONS.flatMap((ext) => [`${base}/_index${ext}`, `${base}/index${ext}`])
+  ];
+}
+function resolveImport(ref, from, index) {
+  const specifier = ref.specifier.replace(/^~/, "");
+  if (/^(?:[a-z]+:|\/\/)/i.test(specifier)) return [];
+  const paths = candidates(specifier);
+  const relative2 = index.firstRelative(dirname(from), paths);
+  if (relative2 !== null) return [{ path: relative2, names: ref.names }];
+  if (specifier.startsWith(".")) return [];
+  return index.closestWithSuffix(from, paths).map((path) => ({ path, names: ref.names }));
+}
+var stylesheet = (info) => ({ info, extractImports, resolveImport });
+var css = stylesheet(cssInfo);
+var scss = stylesheet(scssInfo);
+var sass = stylesheet(sassInfo);
+var less = stylesheet(lessInfo);
+
+// ../../packages/lang-html/src/info.ts
+var htmlInfo = { id: "html", label: "HTML", extensions: [".html", ".htm"] };
+
+// ../../packages/lang-html/src/analysis.ts
+function extractImports2(text2) {
+  const source = text2.replace(/<!--[\s\S]*?-->/g, "");
+  const refs = [];
+  for (const tag of source.matchAll(/<(script|link)\b[^>]*>/gi)) {
+    const attribute = tag[1].toLowerCase() === "script" ? "src" : "href";
+    const value = new RegExp(`\\s${attribute}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i").exec(tag[0]);
+    const url2 = value?.[1] ?? value?.[2] ?? value?.[3];
+    if (url2) refs.push({ specifier: url2, names: [] });
+  }
+  return refs;
+}
+function resolveImport2(ref, from, index) {
+  const url2 = ref.specifier.replace(/[?#].*$/, "");
+  if (url2 === "" || /^(?:[a-z]+:|\/\/)/i.test(url2)) return [];
+  const rooted = url2.startsWith("/");
+  const relative2 = index.firstRelative(dirname(from), [rooted ? url2.slice(1) : url2]);
+  if (relative2 !== null) return [{ path: relative2, names: ref.names }];
+  if (!rooted) return [];
+  return index.closestWithSuffix(from, [url2.slice(1)]).map((path) => ({ path, names: ref.names }));
+}
+var html = { info: htmlInfo, extractImports: extractImports2, resolveImport: resolveImport2 };
+
+// ../../packages/lang-json/src/info.ts
+var jsonInfo = {
+  id: "json",
+  label: "JSON",
+  extensions: [".json", ".jsonc"],
+  // JSON configuration files without the extension.
+  filenames: [".babelrc", ".eslintrc", ".prettierrc", ".swcrc"]
+};
+
+// ../../packages/lang-json/src/analysis.ts
+var json3 = { info: jsonInfo };
+
+// ../../packages/lang-markdown/src/info.ts
+var markdownInfo = {
+  id: "markdown",
+  label: "MD",
+  extensions: [".md", ".markdown"]
+};
+
+// ../../packages/lang-markdown/src/analysis.ts
+var markdown = { info: markdownInfo };
+
+// ../../packages/lang-text/src/info.ts
+var textInfo = {
+  id: "text",
+  label: "TXT",
+  extensions: [".txt"]
+};
+
+// ../../packages/lang-text/src/analysis.ts
+var text = { info: textInfo };
+
+// ../../packages/lang-typescript/src/analysis.ts
+import ts from "typescript";
+
+// ../../packages/lang-typescript/src/info.ts
+var typescriptInfo = {
+  id: "typescript",
+  label: "TS",
+  extensions: [".ts", ".tsx", ".mts", ".cts"]
+};
+var javascriptInfo = {
+  id: "javascript",
+  label: "JS",
+  extensions: [".js", ".jsx", ".mjs", ".cjs"]
+};
+
+// ../../packages/lang-typescript/src/analysis.ts
+var SCRIPT_KIND_BY_EXTENSION = {
+  ".ts": ts.ScriptKind.TS,
+  ".mts": ts.ScriptKind.TS,
+  ".cts": ts.ScriptKind.TS,
+  ".tsx": ts.ScriptKind.TSX,
+  ".js": ts.ScriptKind.JS,
+  ".mjs": ts.ScriptKind.JS,
+  ".cjs": ts.ScriptKind.JS,
+  ".jsx": ts.ScriptKind.JSX
+};
+function extractImports3(text2, path) {
+  const kind = SCRIPT_KIND_BY_EXTENSION[extname(path).toLowerCase()] ?? ts.ScriptKind.TS;
+  const source = ts.createSourceFile(path, text2, ts.ScriptTarget.Latest, true, kind);
+  const refs = [];
+  const visit2 = (node2) => {
+    const ref = scriptImport(node2);
+    if (ref !== null) refs.push(ref);
+    ts.forEachChild(node2, visit2);
+  };
+  visit2(source);
+  return refs;
+}
+function scriptImport(node2) {
+  if (ts.isImportDeclaration(node2)) return withSpecifier(node2.moduleSpecifier, importClauseNames(node2));
+  if (ts.isExportDeclaration(node2)) {
+    return node2.moduleSpecifier === void 0 ? null : withSpecifier(node2.moduleSpecifier, exportNames(node2));
+  }
+  if (ts.isImportEqualsDeclaration(node2) && ts.isExternalModuleReference(node2.moduleReference)) {
+    const name = `${node2.isTypeOnly ? "type " : ""}${node2.name.text}`;
+    return withSpecifier(node2.moduleReference.expression, [name]);
+  }
+  if (ts.isImportTypeNode(node2) && ts.isLiteralTypeNode(node2.argument)) {
     const names = node2.qualifier === void 0 ? [] : [`type ${node2.qualifier.getText()}`];
     return withSpecifier(node2.argument.literal, names);
   }
@@ -27034,162 +27381,228 @@ function boundNames(call) {
     return ts.isIdentifier(key) ? [key.text] : [];
   });
 }
-function extractPython(text) {
-  const source = text.replace(/\\\r?\n/g, " ");
-  const refs = [];
-  for (const match2 of source.matchAll(
-    /^[ \t]*from[ \t]+(\.+[\w.]*|[\w.]+)[ \t]+import[ \t]+(\([^)]{0,10000}\)|[^\n#;]*)/gm
-  )) {
-    const names = splitNames(match2[2]?.replace(/[()]/g, "") ?? "").filter(
-      (name) => /^(?:\w+|\*)$/.test(name)
-    );
-    if (match2[1] !== void 0 && names.length > 0) refs.push({ specifier: match2[1], names });
+var SCRIPT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".d.ts", ".js", ".jsx", ".mjs", ".cjs"];
+var TS_COUNTERPARTS = {
+  ".js": [".ts", ".tsx"],
+  ".jsx": [".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"]
+};
+var ALIAS_PREFIX = /^(?:@\/|~\/|#\/?)/;
+function scriptCandidates(base) {
+  const extension = extname(base);
+  const counterparts = (TS_COUNTERPARTS[extension] ?? []).map((ts2) => base.slice(0, -extension.length) + ts2);
+  return [
+    base,
+    ...counterparts,
+    ...SCRIPT_EXTENSIONS.map((ext) => base + ext),
+    ...SCRIPT_EXTENSIONS.map((ext) => `${base}/index${ext}`)
+  ];
+}
+function resolveImport3(ref, from, index) {
+  const { specifier, names } = ref;
+  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
+    const path = index.firstRelative(dirname(from), scriptCandidates(specifier));
+    return path === null ? [] : [{ path, names }];
   }
-  for (const match2 of source.matchAll(/^[ \t]*import[ \t]+([^\n#;]+)/gm)) {
-    for (const module of splitNames(match2[1] ?? "")) {
-      if (/^\w+(?:\.\w+)*$/.test(module)) refs.push({ specifier: module, names: [] });
-    }
+  const workspace = index.packageFor(specifier);
+  if (workspace !== null) {
+    const path = resolveWorkspaceImport(workspace.pkg, workspace.subpath, index);
+    return path === null ? [] : [{ path, names }];
   }
-  return refs;
+  if (!ALIAS_PREFIX.test(specifier) && !specifier.startsWith("/")) return [];
+  const remainder = specifier.replace(ALIAS_PREFIX, "").replace(/^\/+/, "");
+  if (remainder === "") return [];
+  return index.closestWithSuffix(from, scriptCandidates(remainder)).map((path) => ({ path, names }));
 }
-function splitNames(list) {
-  return list.replace(/#[^\n]*/g, "").split(",").map(
-    (part) => part.trim().split(/\s+as\s+/)[0]?.trim() ?? ""
-  ).filter((name) => name !== "");
+function resolveWorkspaceImport(pkg, subpath, index) {
+  if (subpath === "") return index.entryOf(pkg);
+  return index.firstRelative(pkg.root, scriptCandidates(subpath)) ?? index.firstRelative(pkg.root, scriptCandidates(`src/${subpath}`));
 }
-function extractStyle(text) {
-  const refs = [];
-  const source = text.replace(/\/\*[\s\S]*?\*\//g, "");
-  for (const match2 of source.matchAll(/@(import|use|forward)\s+([^;\n]+)/g)) {
-    const urls = [...(match2[2] ?? "").matchAll(/url\(\s*["']?([^"')\s]+)["']?\s*\)|["']([^"'\n]+)["']/g)];
-    for (const url2 of match2[1] === "import" ? urls : urls.slice(0, 1)) {
-      const specifier = url2[1] ?? url2[2];
-      if (specifier !== void 0) refs.push({ specifier, names: [] });
+function importedPackageRoot(ref, index) {
+  return ref.specifier.startsWith(".") ? null : index.packageFor(ref.specifier)?.pkg.root ?? null;
+}
+var typescript = {
+  info: typescriptInfo,
+  extractImports: extractImports3,
+  resolveImport: resolveImport3,
+  importedPackageRoot
+};
+var javascript = {
+  info: javascriptInfo,
+  extractImports: extractImports3,
+  resolveImport: resolveImport3,
+  importedPackageRoot
+};
+var DeclaredName = external_exports.string().optional().catch(void 0);
+var DependencyMap = external_exports.record(external_exports.string(), external_exports.unknown()).optional().catch(void 0);
+var PackageJson = external_exports.object({
+  name: DeclaredName,
+  dependencies: DependencyMap,
+  devDependencies: DependencyMap,
+  peerDependencies: DependencyMap,
+  optionalDependencies: DependencyMap
+});
+var NPM_LOCAL_SPEC = /^(?:file|link|portal):(.+)$/;
+function readPackageJson(text2) {
+  const data = PackageJson.parse(JSON.parse(text2));
+  const deps = [];
+  const paths = [];
+  for (const entries of [
+    data.dependencies,
+    data.devDependencies,
+    data.peerDependencies,
+    data.optionalDependencies
+  ]) {
+    for (const [dep, spec] of Object.entries(entries ?? {})) {
+      deps.push(dep);
+      const local = typeof spec === "string" ? NPM_LOCAL_SPEC.exec(spec)?.[1] : void 0;
+      if (local !== void 0) paths.push(local);
     }
   }
-  return refs;
+  const name = data.name?.trim();
+  return { name: name === void 0 || name === "" ? null : name, deps, paths };
 }
-function extractGo(text) {
-  const refs = [];
-  const addSpec = (alias, path) => {
-    if (path === void 0) return;
-    const name = alias !== void 0 && alias !== "_" && alias !== "." ? alias : path.slice(path.lastIndexOf("/") + 1);
-    refs.push({ specifier: path, names: [name] });
+var SRC_EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".jsx"];
+function exportTargets(value) {
+  if (typeof value === "string") return [value];
+  if (!value || typeof value !== "object") return [];
+  const entries = Object.entries(value);
+  const root = entries.find(([k]) => k === ".");
+  const ordered = root ? [root] : entries.filter(([k]) => !k.startsWith("./"));
+  return ordered.flatMap(([, v]) => exportTargets(v));
+}
+function entryCandidates(root, manifestText) {
+  if (!manifestText) return [];
+  const join5 = (rel) => {
+    const clean = rel.replace(/^\.\//, "");
+    return root ? `${root}/${clean}` : clean;
   };
-  for (const match2 of text.matchAll(/^[ \t]*import[ \t]+(?:([\w.]+)[ \t]+)?"([^"\n]+)"/gm))
-    addSpec(match2[1], match2[2]);
-  for (const group of text.matchAll(/^[ \t]*import[ \t]*\(([^)]{0,10000})\)/gm)) {
-    for (const match2 of (group[1] ?? "").matchAll(/^[ \t]*(?:([\w.]+)[ \t]+)?"([^"\n]+)"/gm))
-      addSpec(match2[1], match2[2]);
+  const out = [];
+  let manifest = null;
+  try {
+    manifest = JSON.parse(manifestText);
+  } catch {
   }
-  return refs;
-}
-function extractJvm(text) {
-  return [...text.matchAll(/^[ \t]*import[ \t]+(?:static[ \t]+)?(\w+(?:\.\w+)*(?:\.\*)?)/gm)].flatMap(
-    (match2) => {
-      const specifier = match2[1];
-      return specifier === void 0 ? [] : [{ specifier, names: [specifier.slice(specifier.lastIndexOf(".") + 1)] }];
+  if (manifest && typeof manifest === "object") {
+    const fields = ["exports", "module", "main", "types", "typings"];
+    for (const field of fields) {
+      if (!(field in manifest)) continue;
+      const value = Reflect.get(manifest, field);
+      for (const target of exportTargets(value)) {
+        out.push(join5(target));
+        const source = target.replace(/^\.?\/?(dist|build|lib|out)\//, "src/").replace(/(\.d)?\.(m|c)?[jt]sx?$/, "");
+        if (source !== target) for (const ext of SRC_EXTENSIONS) out.push(join5(source + ext));
+      }
     }
-  );
-}
-function extractInclude(text) {
-  return [...text.matchAll(/^[ \t]*#[ \t]*include[ \t]*"([^"\n]+)"/gm)].flatMap(
-    (match2) => match2[1] === void 0 ? [] : [{ specifier: match2[1], names: [] }]
-  );
+  }
+  for (const base of ["src/index", "index", "src/main"]) {
+    for (const ext of SRC_EXTENSIONS) out.push(join5(base + ext));
+  }
+  return [...new Set(out)];
 }
-function extractRust(text) {
-  const source = text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
-  const refs = [];
-  const visibility = String.raw`(?:pub(?:\([^)\n]*\))?[ \t]+)?`;
-  const modPattern = new RegExp(
-    String.raw`^[ \t]*(?:#\[[^\]\n]*\][ \t]*)*${visibility}mod[ \t]+(?:r#)?(\w+)[ \t]*;`,
-    "gm"
-  );
-  for (const match2 of source.matchAll(modPattern)) {
-    if (match2[1] !== void 0) refs.push({ specifier: `self::${match2[1]}`, names: [match2[1]] });
+var npm = {
+  id: "npm",
+  manifests: ["package.json"],
+  readManifest: readPackageJson,
+  entryCandidates
+};
+
+// ../server/src/languages.ts
+var languages = new LanguageRegistry([
+  typescript,
+  javascript,
+  html,
+  css,
+  scss,
+  sass,
+  less,
+  markdown,
+  json3,
+  text
+]);
+var ecosystems = [npm];
+
+// ../../packages/language/src/analysis.ts
+var FileIndex = class {
+  #paths = /* @__PURE__ */ new Set();
+  #byBasename = /* @__PURE__ */ new Map();
+  #byDir = /* @__PURE__ */ new Map();
+  /** Longest name first, so that `@acme/ui/forms` prefers a package named `@acme/ui/forms` over `@acme/ui`. */
+  #packages = [];
+  constructor(paths, packages = []) {
+    for (const path of paths) {
+      if (this.#paths.has(path)) continue;
+      this.#paths.add(path);
+      pushTo(this.#byBasename, basename(path), path);
+      pushTo(this.#byDir, dirname(path), path);
+    }
+    for (const ref of packages) {
+      const root = ref.root === "" ? "" : normalizePath(ref.root);
+      if (ref.name === "" || root === null) continue;
+      const entries = ref.entries.flatMap((entry) => normalizePath(entry) ?? []);
+      this.#packages.push({ name: ref.name, root, entries });
+    }
+    this.#packages.sort((a, b) => b.name.length - a.name.length);
+  }
+  /** Package named by a bare specifier (`name` or `name/sub/path`), with the remaining subpath. */
+  packageFor(specifier) {
+    for (const pkg of this.#packages) {
+      if (specifier === pkg.name) return { pkg, subpath: "" };
+      if (specifier.startsWith(`${pkg.name}/`)) return { pkg, subpath: specifier.slice(pkg.name.length + 1) };
+    }
+    return null;
   }
-  for (const match2 of source.matchAll(/^[ \t]*(?:#\[[^\]\n]*\][ \t]*)*extern[ \t]+crate[ \t]+(\w+)/gm)) {
-    if (match2[1] !== void 0 && match2[1] !== "self") refs.push({ specifier: match2[1], names: [match2[1]] });
+  /** First entry candidate of a package that is a changed file. */
+  entryOf(pkg) {
+    return pkg.entries.find((entry) => this.#paths.has(entry)) ?? null;
   }
-  for (const match2 of source.matchAll(
-    new RegExp(String.raw`^[ \t]*${visibility}use[ \t]+([^;]{1,10000});`, "gm")
-  )) {
-    const tree = (match2[1] ?? "").replace(/\s+as\s+\w+/g, "").replace(/\s+/g, "");
-    for (const path of expandUseTree(tree)) {
-      const segments = path.replace(/^::/, "").split("::");
-      const last = segments.at(-1);
-      if (last === "*") segments.pop();
-      refs.push({ specifier: segments.join("::"), names: last === void 0 ? [] : [last] });
+  /** Root of the package containing `path`: the root that is its longest segment prefix; null when none. */
+  ownPackageRoot(path) {
+    let best = null;
+    for (const { root } of this.#packages) {
+      const contains = root === "" || path === root || path.startsWith(`${root}/`);
+      if (contains && (best === null || root.length > best.length)) best = root;
     }
+    return best;
   }
-  return refs;
-}
-function expandUseTree(tree) {
-  const open2 = tree.indexOf("{");
-  const close = tree.lastIndexOf("}");
-  if (open2 === -1 || close < open2) return [tree];
-  const head = tree.slice(0, open2);
-  return splitTopLevel(tree.slice(open2 + 1, close)).flatMap(
-    (part) => part === "self" ? [head.replace(/::$/, "")] : expandUseTree(head + part)
-  );
-}
-function splitTopLevel(list) {
-  const parts = [];
-  let depth = 0;
-  let start = 0;
-  for (let i = 0; i < list.length; i++) {
-    const char = list[i];
-    if (char === "{") depth++;
-    else if (char === "}") depth--;
-    else if (char === "," && depth === 0) {
-      parts.push(list.slice(start, i));
-      start = i + 1;
+  has(path) {
+    return path !== null && this.#paths.has(path);
+  }
+  /** Paths equal to `suffix` or ending with `/suffix`. */
+  withSuffix(suffix) {
+    const candidates2 = this.#byBasename.get(basename(suffix)) ?? [];
+    return candidates2.filter((path) => path === suffix || path.endsWith(`/${suffix}`));
+  }
+  /** First candidate path present in the index, relative to `dir`. */
+  firstRelative(dir, candidates2) {
+    for (const candidate of candidates2) {
+      const path = joinPath(dir, candidate);
+      if (this.has(path)) return path;
     }
+    return null;
   }
-  parts.push(list.slice(start));
-  return parts.filter((part) => part !== "");
-}
-function extractRuby(text) {
-  return [...text.matchAll(/^[ \t]*require_relative[ \t(]+["']([^"'\n]+)["']/gm)].flatMap(
-    (match2) => match2[1] === void 0 ? [] : [{ specifier: match2[1], names: [] }]
-  );
-}
-
-// ../server/src/links/language.ts
-var LANGUAGE_BY_EXTENSION = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".css": "css",
-  ".scss": "css",
-  ".sass": "css",
-  ".less": "css",
-  ".go": "go",
-  ".java": "java",
-  ".kt": "kotlin",
-  ".kts": "kotlin",
-  ".c": "c",
-  ".h": "c",
-  ".cpp": "cpp",
-  ".cc": "cpp",
-  ".cxx": "cpp",
-  ".hpp": "cpp",
-  ".hh": "cpp",
-  ".rs": "rust",
-  ".rb": "ruby",
-  ".vue": "vue",
-  ".svelte": "svelte",
-  ".md": "markdown",
-  ".mdx": "markdown"
-};
-function detectLanguage(path) {
-  return LANGUAGE_BY_EXTENSION[extname(path).toLowerCase()] ?? null;
+  /**
+   * Suffix match of the first candidate that matches anything. Among several matches, keeps those sharing
+   * the most leading directories with the importing file (the closest source root / package wins).
+   */
+  closestWithSuffix(from, candidates2) {
+    for (const candidate of candidates2) {
+      const suffix = normalizePath(candidate);
+      const matches = suffix === null ? [] : this.withSuffix(suffix);
+      if (matches.length === 0) continue;
+      const fromDir = dirname(from);
+      const scores = matches.map((path) => sharedPrefixLength(fromDir, dirname(path)));
+      const best = Math.max(...scores);
+      return matches.filter((_, i) => scores[i] === best);
+    }
+    return [];
+  }
+};
+function pushTo(map2, key, value) {
+  const list = map2.get(key);
+  if (list === void 0) map2.set(key, [value]);
+  else list.push(value);
 }
 
 // ../server/src/links/mentions.ts
@@ -27278,365 +27691,81 @@ function findMentions(files, skip) {
     const add = (to, token) => {
       if (to === file2.path || skip(file2.path, to)) return;
       const tokens = tokensByTarget.get(to) ?? /* @__PURE__ */ new Set();
-      tokens.add(token);
-      tokensByTarget.set(to, tokens);
-    };
-    for (const path of mentionedPaths(file2.path, file2.text, paths)) add(path, path);
-    const words = wordSet(file2.text);
-    for (const [token, owner] of distinctiveTokens)
-      if (!tokensByTarget.has(owner) && words.has(token)) add(owner, token);
-    for (const [to, tokens] of tokensByTarget) mentions.push({ from: file2.path, to, tokens: [...tokens] });
-  }
-  return mentions;
-}
-function mentionedPaths(from, text, paths) {
-  const found = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new Set();
-  for (const [raw2] of text.matchAll(/[\w.\-/@$+~[\]]+/g)) {
-    const token = raw2.replace(/^\[+/, "").replace(/[.\]]+$/, "");
-    if (seen.has(token) || !token.includes(".") && !token.includes("/")) continue;
-    seen.add(token);
-    const relative2 = token.startsWith(".") ? joinPath(dirname(from), token) : null;
-    if (relative2 !== null && paths.has(relative2)) {
-      found.add(relative2);
-      continue;
-    }
-    let start = 0;
-    while (true) {
-      const tail = token.slice(start);
-      if (paths.has(tail)) {
-        found.add(tail);
-        break;
-      }
-      const slash = token.indexOf("/", start);
-      if (slash === -1) break;
-      start = slash + 1;
-    }
-  }
-  return found;
-}
-function wordSet(text) {
-  const words = /* @__PURE__ */ new Set();
-  for (const match2 of text.matchAll(/[\w$]+(?:[.-][\w$]+)*/g)) {
-    const word = match2[0];
-    const before = text[match2.index - 1];
-    const after = text[match2.index + word.length];
-    if (before === "/" || before === "\\" || after === "/" || after === "\\") continue;
-    words.add(word);
-    const parts = word.split(/([.-])/);
-    if (parts.length === 1) continue;
-    const chunkCount = (parts.length + 1) / 2;
-    const maxRun = chunkCount > MAX_COMPOUND_CHUNKS ? 1 : chunkCount;
-    for (let first = 0; first < chunkCount; first++) {
-      for (let last = first; last < Math.min(chunkCount, first + maxRun); last++) {
-        words.add(parts.slice(first * 2, last * 2 + 1).join(""));
-      }
-    }
-  }
-  return words;
-}
-
-// ../server/src/links/resolve.ts
-var FileIndex = class {
-  #paths = /* @__PURE__ */ new Set();
-  #byBasename = /* @__PURE__ */ new Map();
-  #byDir = /* @__PURE__ */ new Map();
-  /** Longest name first, so that `@acme/ui/forms` prefers a package named `@acme/ui/forms` over `@acme/ui`. */
-  #packages = [];
-  /** By crate name (`-` → `_`). */
-  #crates = /* @__PURE__ */ new Map();
-  constructor(paths, packages = []) {
-    for (const path of paths) {
-      if (this.#paths.has(path)) continue;
-      this.#paths.add(path);
-      pushTo(this.#byBasename, basename(path), path);
-      pushTo(this.#byDir, dirname(path), path);
-    }
-    for (const ref of packages) {
-      const root = ref.root === "" ? "" : normalizePath(ref.root);
-      if (ref.name === "" || root === null) continue;
-      const entries = ref.entries.flatMap((entry) => normalizePath(entry) ?? []);
-      const pkg = { name: ref.name, root, entries };
-      this.#packages.push(pkg);
-      const crate = ref.name.replaceAll("-", "_");
-      if (!this.#crates.has(crate)) this.#crates.set(crate, pkg);
-    }
-    this.#packages.sort((a, b) => b.name.length - a.name.length);
-  }
-  /** Package named by a bare specifier (`name` or `name/sub/path`), with the remaining subpath. */
-  packageFor(specifier) {
-    for (const pkg of this.#packages) {
-      if (specifier === pkg.name) return { pkg, subpath: "" };
-      if (specifier.startsWith(`${pkg.name}/`)) return { pkg, subpath: specifier.slice(pkg.name.length + 1) };
-    }
-    return null;
-  }
-  crate(name) {
-    return this.#crates.get(name);
-  }
-  /** First entry candidate of a package that is a changed file. */
-  entryOf(pkg) {
-    return pkg.entries.find((entry) => this.#paths.has(entry)) ?? null;
-  }
-  /** Root of the package containing `path`: the root that is its longest segment prefix; null when none. */
-  ownPackageRoot(path) {
-    let best = null;
-    for (const { root } of this.#packages) {
-      const contains = root === "" || path === root || path.startsWith(`${root}/`);
-      if (contains && (best === null || root.length > best.length)) best = root;
-    }
-    return best;
-  }
-  has(path) {
-    return path !== null && this.#paths.has(path);
-  }
-  /** Paths equal to `suffix` or ending with `/suffix`. */
-  withSuffix(suffix) {
-    const candidates = this.#byBasename.get(basename(suffix)) ?? [];
-    return candidates.filter((path) => path === suffix || path.endsWith(`/${suffix}`));
-  }
-  /** Paths whose directory equals `dirSuffix` or ends with `/dirSuffix`. */
-  inDirWithSuffix(dirSuffix) {
-    return [...this.#byDir].flatMap(
-      ([dir, paths]) => dir === dirSuffix || dir.endsWith(`/${dirSuffix}`) ? paths : []
-    );
-  }
-  directories() {
-    return this.#byDir.entries();
-  }
-};
-function pushTo(map2, key, value) {
-  const list = map2.get(key);
-  if (list === void 0) map2.set(key, [value]);
-  else list.push(value);
-}
-var RESOLVERS = {
-  typescript: resolveScript,
-  javascript: resolveScript,
-  vue: resolveScript,
-  svelte: resolveScript,
-  python: resolvePython,
-  css: resolveStyle,
-  go: resolveGo,
-  java: resolveJvm,
-  kotlin: resolveJvm,
-  c: resolveInclude,
-  cpp: resolveInclude,
-  rust: resolveRust,
-  ruby: resolveRuby,
-  markdown: () => []
-};
-function resolveImport(ref, from, language, index) {
-  return language === null ? [] : RESOLVERS[language](ref, from, index);
-}
-function importedPackageRoot(ref, language, index) {
-  if (language === "rust") {
-    const crate = ref.specifier.split("::")[0];
-    return (crate === void 0 ? void 0 : index.crate(crate))?.root ?? null;
-  }
-  const scriptLike = language === "typescript" || language === "javascript" || language === "vue" || language === "svelte";
-  return scriptLike && !ref.specifier.startsWith(".") ? index.packageFor(ref.specifier)?.pkg.root ?? null : null;
-}
-function firstRelative(dir, candidates, index) {
-  for (const candidate of candidates) {
-    const path = joinPath(dir, candidate);
-    if (index.has(path)) return path;
-  }
-  return null;
-}
-function closestWithSuffix(from, candidates, index) {
-  for (const candidate of candidates) {
-    const suffix = normalizePath(candidate);
-    const matches = suffix === null ? [] : index.withSuffix(suffix);
-    if (matches.length === 0) continue;
-    const fromDir = dirname(from);
-    const scores = matches.map((path) => sharedPrefixLength(fromDir, dirname(path)));
-    const best = Math.max(...scores);
-    return matches.filter((_, i) => scores[i] === best);
-  }
-  return [];
-}
-var SCRIPT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".d.ts", ".js", ".jsx", ".mjs", ".cjs"];
-var TS_COUNTERPARTS = {
-  ".js": [".ts", ".tsx"],
-  ".jsx": [".tsx"],
-  ".mjs": [".mts"],
-  ".cjs": [".cts"]
-};
-var ALIAS_PREFIX = /^(?:@\/|~\/|#\/?)/;
-function scriptCandidates(base) {
-  const extension = extname(base);
-  const counterparts = (TS_COUNTERPARTS[extension] ?? []).map((ts2) => base.slice(0, -extension.length) + ts2);
-  return [
-    base,
-    ...counterparts,
-    ...SCRIPT_EXTENSIONS.map((ext) => base + ext),
-    ...SCRIPT_EXTENSIONS.map((ext) => `${base}/index${ext}`)
-  ];
-}
-function resolveScript(ref, from, index) {
-  const { specifier, names } = ref;
-  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
-    const path = firstRelative(dirname(from), scriptCandidates(specifier), index);
-    return path === null ? [] : [{ path, names }];
-  }
-  const workspace = index.packageFor(specifier);
-  if (workspace !== null) {
-    const path = resolveWorkspaceImport(workspace.pkg, workspace.subpath, index);
-    return path === null ? [] : [{ path, names }];
+      tokens.add(token);
+      tokensByTarget.set(to, tokens);
+    };
+    for (const path of mentionedPaths(file2.path, file2.text, paths)) add(path, path);
+    const words = wordSet(file2.text);
+    for (const [token, owner] of distinctiveTokens)
+      if (!tokensByTarget.has(owner) && words.has(token)) add(owner, token);
+    for (const [to, tokens] of tokensByTarget) mentions.push({ from: file2.path, to, tokens: [...tokens] });
   }
-  if (!ALIAS_PREFIX.test(specifier) && !specifier.startsWith("/")) return [];
-  const remainder = specifier.replace(ALIAS_PREFIX, "").replace(/^\/+/, "");
-  if (remainder === "") return [];
-  return closestWithSuffix(from, scriptCandidates(remainder), index).map((path) => ({ path, names }));
-}
-function resolveWorkspaceImport(pkg, subpath, index) {
-  if (subpath === "") return index.entryOf(pkg);
-  return firstRelative(pkg.root, scriptCandidates(subpath), index) ?? firstRelative(pkg.root, scriptCandidates(`src/${subpath}`), index);
-}
-function resolvePython(ref, from, index) {
-  const targets = [];
-  const memberNames = [];
-  for (const name of ref.names) {
-    const submoduleName = ref.specifier.endsWith(".") ? ref.specifier + name : `${ref.specifier}.${name}`;
-    const submodule = name === "*" ? [] : findPythonModule(submoduleName, from, index);
-    if (submodule.length === 0) memberNames.push(name);
-    for (const path of submodule) targets.push({ path, names: [name] });
-  }
-  if (ref.names.length === 0 || memberNames.length > 0) {
-    const names = ref.names.length === 0 ? [ref.specifier] : memberNames;
-    for (const path of findPythonModule(ref.specifier, from, index)) targets.push({ path, names });
-  }
-  return targets;
-}
-function findPythonModule(module, from, index) {
-  const dots = /^\.*/.exec(module)?.[0].length ?? 0;
-  const modulePath = module.slice(dots).split(".").filter(Boolean).join("/");
-  const candidates = modulePath === "" ? ["__init__.py"] : [`${modulePath}.py`, `${modulePath}/__init__.py`];
-  if (dots === 0) return closestWithSuffix(from, candidates, index);
-  let base = dirname(from);
-  for (let level = 1; level < dots && base !== null; level++) base = base === "" ? null : dirname(base);
-  const path = base === null ? null : firstRelative(base, candidates, index);
-  return path === null ? [] : [path];
-}
-var STYLE_EXTENSIONS = [".scss", ".sass", ".css", ".less"];
-function styleCandidates(base) {
-  const dir = dirname(base);
-  const partial2 = `${dir === "" ? "" : `${dir}/`}_${basename(base)}`;
-  if (STYLE_EXTENSIONS.includes(extname(base))) return [base, partial2];
-  return [
-    base,
-    ...STYLE_EXTENSIONS.flatMap((ext) => [base + ext, partial2 + ext]),
-    ...STYLE_EXTENSIONS.flatMap((ext) => [`${base}/_index${ext}`, `${base}/index${ext}`])
-  ];
+  return mentions;
 }
-function resolveStyle(ref, from, index) {
-  const specifier = ref.specifier.replace(/^~/, "");
-  if (/^(?:[a-z]+:|\/\/)/i.test(specifier)) return [];
-  const candidates = styleCandidates(specifier);
-  const relative2 = firstRelative(dirname(from), candidates, index);
-  if (relative2 !== null) return [{ path: relative2, names: ref.names }];
-  if (specifier.startsWith(".")) return [];
-  return closestWithSuffix(from, candidates, index).map((path) => ({ path, names: ref.names }));
-}
-function resolveGo(ref, from, index) {
-  const importSegments = ref.specifier.split("/");
-  const ownDir = dirname(from);
-  let best = 0;
-  let packages = [];
-  for (const [dir, paths] of index.directories()) {
-    const sources = paths.filter((path) => path.endsWith(".go") && !path.endsWith("_test.go"));
-    if (dir === ownDir || sources.length === 0) continue;
-    const score = trailingMatch(dir === "" ? [] : dir.split("/"), importSegments);
-    if (score === 0 || score < best) continue;
-    if (score > best) packages = [];
-    best = score;
-    packages.push(sources);
-  }
-  return packages.flat().map((path) => ({ path, names: ref.names }));
-}
-function trailingMatch(a, b) {
-  let count = 0;
-  while (count < a.length && count < b.length && a[a.length - 1 - count] === b[b.length - 1 - count]) count++;
-  return count;
+function mentionedPaths(from, text2, paths) {
+  const found = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const [raw2] of text2.matchAll(/[\w.\-/@$+~[\]]+/g)) {
+    const token = raw2.replace(/^\[+/, "").replace(/[.\]]+$/, "");
+    if (seen.has(token) || !token.includes(".") && !token.includes("/")) continue;
+    seen.add(token);
+    const relative2 = token.startsWith(".") ? joinPath(dirname(from), token) : null;
+    if (relative2 !== null && paths.has(relative2)) {
+      found.add(relative2);
+      continue;
+    }
+    let start = 0;
+    while (true) {
+      const tail = token.slice(start);
+      if (paths.has(tail)) {
+        found.add(tail);
+        break;
+      }
+      const slash = token.indexOf("/", start);
+      if (slash === -1) break;
+      start = slash + 1;
+    }
+  }
+  return found;
 }
-var JVM_EXTENSIONS = [".java", ".kt"];
-function resolveJvm(ref, from, index) {
-  const segments = ref.specifier.split(".");
-  if (segments.at(-1) === "*") {
-    return index.inDirWithSuffix(segments.slice(0, -1).join("/")).filter((path) => path !== from && JVM_EXTENSIONS.includes(extname(path))).map((path) => ({ path, names: ref.names }));
-  }
-  for (let length = segments.length; length >= Math.min(2, segments.length); length--) {
-    const base = segments.slice(0, length).join("/");
-    const matches = closestWithSuffix(
-      from,
-      JVM_EXTENSIONS.map((ext) => base + ext),
-      index
-    );
-    if (matches.length > 0) return matches.map((path) => ({ path, names: ref.names }));
-  }
-  return [];
-}
-function resolveInclude(ref, from, index) {
-  const relative2 = firstRelative(dirname(from), [ref.specifier], index);
-  const paths = relative2 === null ? closestWithSuffix(from, [ref.specifier], index) : [relative2];
-  return paths.map((path) => ({ path, names: ref.names }));
-}
-var RUST_ROOT_STEMS = { mod: true, lib: true, main: true };
-function rustModuleDir(file2) {
-  const stem = fileStem(file2);
-  const dir = dirname(file2);
-  if (Object.hasOwn(RUST_ROOT_STEMS, stem)) return dir;
-  return dir === "" ? stem : `${dir}/${stem}`;
-}
-function resolveRust(ref, from, index) {
-  const [root, ...rest] = ref.specifier.split("::");
-  let base = null;
-  if (root === "self" || root === "super") {
-    base = rustModuleDir(from);
-    if (root === "super") base = base === "" ? null : dirname(base);
-    while (rest[0] === "super" && base !== null) {
-      rest.shift();
-      base = base === "" ? null : dirname(base);
-    }
-    if (base === null) return [];
-  } else if (root !== "crate") {
-    const crate = root === void 0 ? void 0 : index.crate(root);
-    const entry = crate === void 0 ? null : index.entryOf(crate);
-    return entry === null ? [] : [{ path: entry, names: ref.names }];
-  }
-  for (let length = rest.length; length >= 1; length--) {
-    const modulePath = rest.slice(0, length).join("/");
-    const candidates = [`${modulePath}.rs`, `${modulePath}/mod.rs`];
-    const relative2 = base === null ? null : firstRelative(base, candidates, index);
-    const paths = base === null ? closestWithSuffix(from, candidates, index) : relative2 === null ? [] : [relative2];
-    if (paths.length > 0) return paths.map((path) => ({ path, names: ref.names }));
-  }
-  return [];
-}
-function resolveRuby(ref, from, index) {
-  const candidate = ref.specifier.endsWith(".rb") ? ref.specifier : `${ref.specifier}.rb`;
-  const path = firstRelative(dirname(from), [candidate], index);
-  return path === null ? [] : [{ path, names: ref.names }];
+function wordSet(text2) {
+  const words = /* @__PURE__ */ new Set();
+  for (const match2 of text2.matchAll(/[\w$]+(?:[.-][\w$]+)*/g)) {
+    const word = match2[0];
+    const before = text2[match2.index - 1];
+    const after = text2[match2.index + word.length];
+    if (before === "/" || before === "\\" || after === "/" || after === "\\") continue;
+    words.add(word);
+    const parts = word.split(/([.-])/);
+    if (parts.length === 1) continue;
+    const chunkCount = (parts.length + 1) / 2;
+    const maxRun = chunkCount > MAX_COMPOUND_CHUNKS ? 1 : chunkCount;
+    for (let first = 0; first < chunkCount; first++) {
+      for (let last = first; last < Math.min(chunkCount, first + maxRun); last++) {
+        words.add(parts.slice(first * 2, last * 2 + 1).join(""));
+      }
+    }
+  }
+  return words;
 }
 
 // ../server/src/links/index.ts
 var MAX_PARSED_TEXT = 1e6;
 var MAX_DETAIL = 8;
-function buildLinkGraph(files, options = {}) {
-  const languages = {};
+function buildLinkGraph(files, languages2, options = {}) {
+  const languageIds = {};
   const externalImports = {};
   const packageImports = {};
   const indexed = /* @__PURE__ */ new Map();
   for (const file2 of files) {
-    const language = detectLanguage(file2.path);
-    languages[file2.path] = language;
+    const language = languages2.detect(file2.path);
+    languageIds[file2.path] = language?.info.id ?? null;
     externalImports[file2.path] = 0;
     packageImports[file2.path] = [];
     const key = normalizePath(file2.path);
     if (key === null || indexed.has(key)) continue;
-    const text = file2.text !== null && file2.text.length <= MAX_PARSED_TEXT ? file2.text : null;
-    indexed.set(key, { path: file2.path, key, language, text });
+    const readable = language !== null && file2.text !== null && file2.text.length <= MAX_PARSED_TEXT;
+    indexed.set(key, { path: file2.path, key, language, text: readable ? file2.text : null });
   }
   const edges = /* @__PURE__ */ new Map();
   const addEdge = (from, toKey, kind, detail) => {
@@ -27658,7 +27787,7 @@ function buildLinkGraph(files, options = {}) {
     for (const target of targets.resolved) addEdge(file2, target.path, "import", target.names);
   }
   const mentions = findMentions(
-    [...indexed.values()].map(({ key, text }) => ({ path: key, text })),
+    [...indexed.values()].map(({ key, text: text2 }) => ({ path: key, text: text2 })),
     (from, to) => edges.has(`import\0${from}\0${to}`)
   );
   for (const mention of mentions) {
@@ -27672,7 +27801,7 @@ function buildLinkGraph(files, options = {}) {
       ...edge,
       detail: [...detail].slice(0, MAX_DETAIL)
     })),
-    languages,
+    languages: languageIds,
     externalImports,
     packageImports
   };
@@ -27681,14 +27810,16 @@ function importTargets(file2, index) {
   const resolved = [];
   const packageRoots = /* @__PURE__ */ new Set();
   let unresolved = 0;
-  if (file2.text === null) return { resolved, unresolved, packageRoots: [] };
+  const { language, text: text2 } = file2;
+  if (language?.extractImports === void 0 || text2 === null)
+    return { resolved, unresolved, packageRoots: [] };
   const ownRoot = index.ownPackageRoot(file2.key);
   try {
-    for (const ref of extractImports(file2.text, file2.key, file2.language)) {
-      const targets = resolveImport(ref, file2.key, file2.language, index);
+    for (const ref of language.extractImports(text2, file2.key)) {
+      const targets = language.resolveImport?.(ref, file2.key, index) ?? [];
       if (targets.length === 0) unresolved++;
       resolved.push(...targets);
-      const root = importedPackageRoot(ref, file2.language, index);
+      const root = language.importedPackageRoot?.(ref, index) ?? null;
       if (root !== null && root !== ownRoot) packageRoots.add(root);
     }
   } catch {
@@ -27697,459 +27828,6 @@ function importTargets(file2, index) {
   return { resolved, unresolved, packageRoots: [...packageRoots].sort() };
 }
 
-// ../server/src/packages/toml.ts
-var TomlSyntaxError = class extends Error {
-};
-var ESCAPES = {
-  b: "\b",
-  t: "	",
-  n: "\n",
-  f: "\f",
-  r: "\r",
-  e: "\x1B",
-  '"': '"',
-  "\\": "\\"
-};
-var BARE_KEY = /[A-Za-z0-9_-]+/y;
-var BARE_VALUE = /[^,\]}\r\n#]+/y;
-var BASIC_STRING = /"((?:\\.|[^"\\\r\n])*)"/y;
-function parseToml(text) {
-  return new TomlReader(text).document();
-}
-var TomlReader = class {
-  text;
-  pos = 0;
-  constructor(text) {
-    this.text = text;
-  }
-  document() {
-    const root = /* @__PURE__ */ new Map();
-    let current = root;
-    while (this.pos < this.text.length) {
-      this.skipBlank();
-      const ch = this.text[this.pos];
-      if (ch === void 0) break;
-      if (ch === "\n" || ch === "\r" || ch === "#") {
-        this.skipLine();
-        continue;
-      }
-      try {
-        if (ch === "[") current = this.header(root);
-        else this.keyValue(current);
-        this.endOfLine();
-      } catch (error62) {
-        if (!(error62 instanceof TomlSyntaxError)) throw error62;
-        if (ch === "[") current = /* @__PURE__ */ new Map();
-        this.skipLine();
-      }
-    }
-    return root;
-  }
-  /** `[a.b]` or `[[a.b]]`; returns the table that receives the following keys. */
-  header(root) {
-    const isArray = this.text.startsWith("[[", this.pos);
-    this.pos += isArray ? 2 : 1;
-    const { parents, last } = this.key();
-    this.expect(isArray ? "]]" : "]");
-    const table = parents.reduce(child, root);
-    if (!isArray) return child(table, last);
-    const existing = table.get(last);
-    const list = Array.isArray(existing) ? existing : [];
-    const created = /* @__PURE__ */ new Map();
-    list.push(created);
-    table.set(last, list);
-    return created;
-  }
-  keyValue(table) {
-    const { parents, last } = this.key();
-    this.expect("=");
-    this.skipBlank();
-    parents.reduce(child, table).set(last, this.value());
-  }
-  /** A possibly dotted key, split into its parent path and final segment. */
-  key() {
-    const parents = [];
-    let last = this.simpleKey();
-    for (; ; ) {
-      this.skipBlank();
-      if (this.text[this.pos] !== ".") return { parents, last };
-      this.pos++;
-      parents.push(last);
-      last = this.simpleKey();
-    }
-  }
-  simpleKey() {
-    this.skipBlank();
-    const ch = this.text[this.pos];
-    if (ch === '"') return this.basicString();
-    if (ch === "'") return this.literalString();
-    BARE_KEY.lastIndex = this.pos;
-    const match2 = BARE_KEY.exec(this.text);
-    if (match2 === null) throw new TomlSyntaxError(`Invalid key at ${this.pos}`);
-    this.pos = BARE_KEY.lastIndex;
-    return match2[0];
-  }
-  value() {
-    if (this.text.startsWith('"""', this.pos)) return this.multilineString('"""');
-    if (this.text.startsWith("'''", this.pos)) return this.multilineString("'''");
-    switch (this.text[this.pos]) {
-      case '"':
-        return this.basicString();
-      case "'":
-        return this.literalString();
-      case "[":
-        return this.array();
-      case "{":
-        return this.inlineTable();
-      default: {
-        BARE_VALUE.lastIndex = this.pos;
-        const match2 = BARE_VALUE.exec(this.text);
-        if (match2 === null || match2[0].trim() === "")
-          throw new TomlSyntaxError(`Missing value at ${this.pos}`);
-        this.pos = BARE_VALUE.lastIndex;
-        return null;
-      }
-    }
-  }
-  basicString() {
-    BASIC_STRING.lastIndex = this.pos;
-    const match2 = BASIC_STRING.exec(this.text);
-    if (match2 === null) throw new TomlSyntaxError(`Unterminated string at ${this.pos}`);
-    this.pos = BASIC_STRING.lastIndex;
-    return decodeEscapes(match2[1] ?? "");
-  }
-  literalString() {
-    const start = this.pos + 1;
-    const end = this.text.indexOf("'", start);
-    const newline = this.text.indexOf("\n", start);
-    if (end === -1 || newline !== -1 && newline < end) {
-      throw new TomlSyntaxError(`Unterminated string at ${this.pos}`);
-    }
-    this.pos = end + 1;
-    return this.text.slice(start, end);
-  }
-  /** `"""…"""` (with escapes and line-ending backslashes) or `'''…'''` (verbatim). */
-  multilineString(delimiter) {
-    let start = this.pos + 3;
-    if (this.text.startsWith("\r\n", start)) start += 2;
-    else if (this.text[start] === "\n") start++;
-    let end = this.text.indexOf(delimiter, start);
-    if (end === -1) throw new TomlSyntaxError(`Unterminated string at ${this.pos}`);
-    for (let extra = 0; extra < 2 && this.text[end + 3] === delimiter[0]; extra++) end++;
-    this.pos = end + 3;
-    const raw2 = this.text.slice(start, end);
-    return delimiter === "'''" ? raw2 : decodeEscapes(raw2.replace(/\\[ \t]*\r?\n\s*/g, ""));
-  }
-  array() {
-    this.pos++;
-    const items = [];
-    for (; ; ) {
-      this.skipInsignificant();
-      if (this.text[this.pos] === "]") {
-        this.pos++;
-        return items;
-      }
-      items.push(this.value());
-      this.skipInsignificant();
-      const ch = this.text[this.pos];
-      this.pos++;
-      if (ch === "]") return items;
-      if (ch !== ",") throw new TomlSyntaxError(`Expected , or ] at ${this.pos - 1}`);
-    }
-  }
-  /** `{ a = 1, b.c = "x" }`; newlines are tolerated inside, as many real manifests use them. */
-  inlineTable() {
-    this.pos++;
-    const table = /* @__PURE__ */ new Map();
-    for (; ; ) {
-      this.skipInsignificant();
-      if (this.text[this.pos] === "}") {
-        this.pos++;
-        return table;
-      }
-      this.keyValue(table);
-      this.skipInsignificant();
-      const ch = this.text[this.pos];
-      this.pos++;
-      if (ch === "}") return table;
-      if (ch !== ",") throw new TomlSyntaxError(`Expected , or } at ${this.pos - 1}`);
-    }
-  }
-  expect(token) {
-    this.skipBlank();
-    if (!this.text.startsWith(token, this.pos)) throw new TomlSyntaxError(`Expected ${token} at ${this.pos}`);
-    this.pos += token.length;
-  }
-  endOfLine() {
-    this.skipBlank();
-    const ch = this.text[this.pos];
-    if (ch === void 0 || ch === "#") this.skipLine();
-    else if (ch === "\n") this.pos++;
-    else if (this.text.startsWith("\r\n", this.pos)) this.pos += 2;
-    else throw new TomlSyntaxError(`Unexpected ${ch} at ${this.pos}`);
-  }
-  skipBlank() {
-    while (this.text[this.pos] === " " || this.text[this.pos] === "	") this.pos++;
-  }
-  /** Whitespace, newlines and comments, as allowed between array or inline-table items. */
-  skipInsignificant() {
-    for (; ; ) {
-      const ch = this.text[this.pos];
-      if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") this.pos++;
-      else if (ch === "#") this.skipLine();
-      else return;
-    }
-  }
-  skipLine() {
-    const newline = this.text.indexOf("\n", this.pos);
-    this.pos = newline === -1 ? this.text.length : newline + 1;
-  }
-};
-function child(table, key) {
-  const existing = table.get(key);
-  if (existing instanceof Map) return existing;
-  if (Array.isArray(existing)) {
-    const last = existing.at(-1);
-    if (last instanceof Map) return last;
-  }
-  const created = /* @__PURE__ */ new Map();
-  table.set(key, created);
-  return created;
-}
-function decodeEscapes(raw2) {
-  return raw2.replace(
-    /\\(?:u([0-9A-Fa-f]{4})|U([0-9A-Fa-f]{8})|([\s\S]))/g,
-    (match2, short, long, ch) => {
-      const hex3 = short ?? long;
-      if (hex3 !== void 0) {
-        const codePoint = Number.parseInt(hex3, 16);
-        return codePoint <= 1114111 ? String.fromCodePoint(codePoint) : "\uFFFD";
-      }
-      return ch !== void 0 && Object.hasOwn(ESCAPES, ch) ? ESCAPES[ch] ?? match2 : match2;
-    }
-  );
-}
-
-// ../server/src/packages/manifests.ts
-var MANIFEST_KINDS = {
-  "package.json": { ecosystem: "npm", priority: 0, read: readPackageJson },
-  "pyproject.toml": { ecosystem: "python", priority: 1, read: readPyproject },
-  "setup.py": { ecosystem: "python", priority: 2, read: readSetupPy },
-  "Cargo.toml": { ecosystem: "rust", priority: 3, read: readCargoToml },
-  "go.mod": { ecosystem: "go", priority: 4, read: readGoMod },
-  "pom.xml": { ecosystem: "maven", priority: 5, read: readPom },
-  "build.gradle": { ecosystem: "gradle", priority: 6, read: readGradle },
-  "build.gradle.kts": { ecosystem: "gradle", priority: 6, read: readGradle },
-  "composer.json": { ecosystem: "composer", priority: 7, read: readComposerJson }
-};
-function manifestKind(basename2) {
-  return Object.hasOwn(MANIFEST_KINDS, basename2) ? MANIFEST_KINDS[basename2] : void 0;
-}
-function readManifest(kind, text) {
-  if (text !== null) {
-    try {
-      return kind.read(text);
-    } catch {
-    }
-  }
-  return { name: null, deps: [], paths: [] };
-}
-function nonEmptyString(value) {
-  return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
-}
-var DeclaredName = external_exports.string().optional().catch(void 0);
-var DependencyMap = external_exports.record(external_exports.string(), external_exports.unknown()).optional().catch(void 0);
-var PackageJson = external_exports.object({
-  name: DeclaredName,
-  dependencies: DependencyMap,
-  devDependencies: DependencyMap,
-  peerDependencies: DependencyMap,
-  optionalDependencies: DependencyMap
-});
-var ComposerJson = external_exports.object({ name: DeclaredName, require: DependencyMap, "require-dev": DependencyMap });
-var NPM_LOCAL_SPEC = /^(?:file|link|portal):(.+)$/;
-function readPackageJson(text) {
-  const data = PackageJson.parse(JSON.parse(text));
-  const deps = [];
-  const paths = [];
-  for (const entries of [
-    data.dependencies,
-    data.devDependencies,
-    data.peerDependencies,
-    data.optionalDependencies
-  ]) {
-    for (const [dep, spec] of Object.entries(entries ?? {})) {
-      deps.push(dep);
-      const local = typeof spec === "string" ? NPM_LOCAL_SPEC.exec(spec)?.[1] : void 0;
-      if (local !== void 0) paths.push(local);
-    }
-  }
-  return { name: nonEmptyString(data.name), deps, paths };
-}
-function readComposerJson(text) {
-  const data = ComposerJson.parse(JSON.parse(text));
-  const deps = [...Object.keys(data.require ?? {}), ...Object.keys(data["require-dev"] ?? {})];
-  return { name: nonEmptyString(data.name), deps, paths: [] };
-}
-function tomlAt(table, ...keys) {
-  let value = table;
-  for (const key of keys) value = value instanceof Map ? value.get(key) : void 0;
-  return value;
-}
-function requirementName(requirement) {
-  return /^\s*([A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?)/.exec(requirement)?.[1] ?? null;
-}
-function readPyproject(text) {
-  const doc = parseToml(text);
-  const deps = [];
-  const paths = [];
-  const requirements = (value) => {
-    if (!Array.isArray(value)) return;
-    for (const item of value) {
-      const name2 = typeof item === "string" ? requirementName(item) : null;
-      if (name2 !== null) deps.push(name2);
-    }
-  };
-  const keyedDependencies = (value) => {
-    if (!(value instanceof Map)) return;
-    for (const [dep, spec] of value) {
-      if (dep !== "python") deps.push(dep);
-      const path = nonEmptyString(tomlAt(spec instanceof Map ? spec : void 0, "path"));
-      if (path !== null) paths.push(path);
-    }
-  };
-  requirements(tomlAt(doc, "project", "dependencies"));
-  const optional2 = tomlAt(doc, "project", "optional-dependencies");
-  if (optional2 instanceof Map) for (const group of optional2.values()) requirements(group);
-  const dependencyGroups = tomlAt(doc, "dependency-groups");
-  if (dependencyGroups instanceof Map) for (const group of dependencyGroups.values()) requirements(group);
-  const poetry = tomlAt(doc, "tool", "poetry");
-  keyedDependencies(tomlAt(doc, "tool", "poetry", "dependencies"));
-  keyedDependencies(tomlAt(doc, "tool", "poetry", "dev-dependencies"));
-  const poetryGroups = tomlAt(doc, "tool", "poetry", "group");
-  if (poetryGroups instanceof Map) {
-    for (const group of poetryGroups.values()) {
-      keyedDependencies(tomlAt(group instanceof Map ? group : void 0, "dependencies"));
-    }
-  }
-  keyedDependencies(tomlAt(doc, "tool", "uv", "sources"));
-  const name = nonEmptyString(tomlAt(doc, "project", "name")) ?? nonEmptyString(tomlAt(poetry instanceof Map ? poetry : void 0, "name"));
-  return { name, deps, paths };
-}
-var CARGO_DEPENDENCY_TABLES = ["dependencies", "dev-dependencies", "build-dependencies"];
-function readCargoToml(text) {
-  const doc = parseToml(text);
-  const deps = [];
-  const paths = [];
-  const tables = [
-    ...CARGO_DEPENDENCY_TABLES.map((key) => doc.get(key)),
-    tomlAt(doc, "workspace", "dependencies")
-  ];
-  const targets = doc.get("target");
-  if (targets instanceof Map) {
-    for (const target of targets.values()) {
-      if (target instanceof Map) tables.push(...CARGO_DEPENDENCY_TABLES.map((key) => target.get(key)));
-    }
-  }
-  for (const table of tables) {
-    if (!(table instanceof Map)) continue;
-    for (const [key, spec] of table) {
-      const detail = spec instanceof Map ? spec : void 0;
-      deps.push(nonEmptyString(tomlAt(detail, "package")) ?? key);
-      const path = nonEmptyString(tomlAt(detail, "path"));
-      if (path !== null) paths.push(path);
-    }
-  }
-  return { name: nonEmptyString(tomlAt(doc, "package", "name")), deps, paths };
-}
-var PYTHON_LIST_TOKEN = /(['"])((?:\\.|(?!\1)[^\\\n])*)\1|#[^\n]*|[\])]/g;
-function readSetupPy(text) {
-  const name = /\bname\s*=\s*(['"])([^'"\n]+)\1/.exec(text)?.[2] ?? null;
-  const deps = [];
-  const opener = /\binstall_requires\s*=\s*[[(]/.exec(text);
-  if (opener !== null) {
-    PYTHON_LIST_TOKEN.lastIndex = opener.index + opener[0].length;
-    for (let token = PYTHON_LIST_TOKEN.exec(text); token !== null; token = PYTHON_LIST_TOKEN.exec(text)) {
-      if (token[0] === "]" || token[0] === ")") break;
-      const dep = token[1] !== void 0 ? requirementName(token[2] ?? "") : null;
-      if (dep !== null) deps.push(dep);
-    }
-  }
-  return { name: nonEmptyString(name), deps, paths: [] };
-}
-function readGoMod(text) {
-  let name = null;
-  const deps = [];
-  const paths = [];
-  const directive = (verb, args) => {
-    const first = args.split(/\s+/)[0]?.replace(/^"(.*)"$/, "$1") ?? "";
-    if (verb === "module" && first !== "") name = first;
-    else if (verb === "require" && first !== "") deps.push(first);
-    else if (verb === "replace") {
-      const target = args.split("=>")[1]?.trim().split(/\s+/)[0] ?? "";
-      if (/^\.\.?(?:\/|$)/.test(target)) paths.push(target);
-    }
-  };
-  let block = null;
-  for (const raw2 of text.split("\n")) {
-    const commentAt = raw2.indexOf("//");
-    const line = (commentAt === -1 ? raw2 : raw2.slice(0, commentAt)).trim();
-    if (line === "") continue;
-    if (block !== null) {
-      if (line === ")") block = null;
-      else directive(block, line);
-      continue;
-    }
-    const match2 = /^([a-z]+)\s*(.*)$/.exec(line);
-    const verb = match2?.[1];
-    const args = match2?.[2] ?? "";
-    if (verb === void 0) continue;
-    if (args === "(") block = verb;
-    else directive(verb, args);
-  }
-  return { name, deps, paths };
-}
-var XML_TAG = /<(\/?)([A-Za-z_][\w.:-]*)[^>]*?(\/?)>/g;
-function readPom(text) {
-  const xml = text.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "");
-  const stack = [];
-  let name = null;
-  const deps = [];
-  for (const match2 of xml.matchAll(XML_TAG)) {
-    const [whole, closing, qualified = "", selfClosing] = match2;
-    const tag = qualified.slice(qualified.lastIndexOf(":") + 1);
-    if (selfClosing === "/") continue;
-    if (closing !== "/") {
-      stack.push({ tag, contentStart: match2.index + whole.length });
-      continue;
-    }
-    const openAt = stack.findLastIndex((element) => element.tag === tag);
-    const open2 = stack[openAt];
-    if (open2 === void 0) continue;
-    if (tag === "artifactId") {
-      const value = nonEmptyString(xml.slice(open2.contentStart, match2.index));
-      const ancestors = stack.slice(0, openAt).map((element) => element.tag);
-      if (value !== null && ancestors.length === 1 && ancestors[0] === "project") name ??= value;
-      else if (value !== null && ancestors.at(-1) === "dependency" && !ancestors.includes("dependencyManagement")) {
-        deps.push(value);
-      }
-    }
-    stack.length = openAt;
-  }
-  return { name, deps, paths: [] };
-}
-var C_COMMENT_OR_STRING = /("(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*')|\/\/[^\n]*|\/\*[\s\S]*?\*\//g;
-var GRADLE_PROJECT_REF = /\bproject\s*\(\s*(?:path\s*[:=]\s*)?(['"])(:[^'"]*)\1/g;
-function readGradle(text) {
-  const code = text.replace(C_COMMENT_OR_STRING, (_match, literal2) => literal2 ?? "");
-  const deps = [];
-  for (const match2 of code.matchAll(GRADLE_PROJECT_REF)) {
-    const path = (match2[2] ?? "").split(":").filter(Boolean).join("/");
-    if (path !== "") deps.push(path);
-  }
-  return { name: null, deps, paths: [] };
-}
-
 // ../server/src/packages/index.ts
 var REPO_ROOT_NAME = "(racine)";
 var EXCLUDED_DIRS = {
@@ -28157,53 +27835,72 @@ var EXCLUDED_DIRS = {
   vendor: true,
   dist: true,
   build: true,
-  target: true,
   out: true,
   ".git": true,
-  ".venv": true,
-  venv: true,
-  __pycache__: true,
   coverage: true,
   fixtures: true,
   __fixtures__: true,
   testdata: true,
   __mocks__: true
 };
-function isManifestPath(path) {
+function manifestKind(basename2, ecosystems2) {
+  let priority = 0;
+  for (const ecosystem of ecosystems2) {
+    for (const manifest of ecosystem.manifests) {
+      if (manifest === basename2) return { ecosystem, priority };
+      priority++;
+    }
+  }
+  return void 0;
+}
+function isManifestPath(path, ecosystems2) {
   const segments = path.split("/");
   const basename2 = segments.pop() ?? "";
-  return manifestKind(basename2) !== void 0 && !segments.some((segment) => Object.hasOwn(EXCLUDED_DIRS, segment));
+  return manifestKind(basename2, ecosystems2) !== void 0 && !segments.some((segment) => Object.hasOwn(EXCLUDED_DIRS, segment));
+}
+function readManifest(ecosystem, path, text2) {
+  if (text2 !== null) {
+    try {
+      return ecosystem.readManifest(text2, path.slice(path.lastIndexOf("/") + 1));
+    } catch {
+    }
+  }
+  return { name: null, deps: [], paths: [] };
 }
-function parseWorkspace(manifests) {
+function parseWorkspace(manifests, ecosystems2) {
   const chosen = /* @__PURE__ */ new Map();
   for (const file2 of manifests) {
     const slash = file2.path.lastIndexOf("/");
-    const kind = isManifestPath(file2.path) ? manifestKind(file2.path.slice(slash + 1)) : void 0;
+    const kind = isManifestPath(file2.path, ecosystems2) ? manifestKind(file2.path.slice(slash + 1), ecosystems2) : void 0;
     if (kind === void 0) continue;
     const root = slash === -1 ? "" : file2.path.slice(0, slash);
     const current = chosen.get(root);
     const wins = current === void 0 || kind.priority < current.kind.priority || kind.priority === current.kind.priority && file2.path < current.file.path;
     if (wins) chosen.set(root, { file: file2, kind });
   }
-  const parsed = [...chosen].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([root, { file: file2, kind }]) => ({ root, path: file2.path, kind, info: readManifest(kind, file2.text) }));
+  const parsed = [...chosen].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([root, { file: file2, kind }]) => ({
+    root,
+    path: file2.path,
+    ecosystem: kind.ecosystem,
+    info: readManifest(kind.ecosystem, file2.path, file2.text)
+  }));
   const byName = /* @__PURE__ */ new Map();
-  for (const { root, kind, info } of parsed) {
+  const matchKey = (ecosystem, name) => ecosystem.normalizeName?.(name) ?? name;
+  for (const { root, ecosystem, info } of parsed) {
     if (info.name === null) continue;
-    let names = byName.get(kind.ecosystem);
+    let names = byName.get(ecosystem);
     if (names === void 0) {
       names = /* @__PURE__ */ new Map();
-      byName.set(kind.ecosystem, names);
+      byName.set(ecosystem, names);
     }
-    const key = matchKey(kind.ecosystem, info.name);
+    const key = matchKey(ecosystem, info.name);
     if (!names.has(key)) names.set(key, root);
   }
   const roots = new Set(parsed.map(({ root }) => root));
-  const gradleRoots = parsed.filter(({ kind }) => kind.ecosystem === "gradle").map(({ root }) => root);
-  return parsed.map(({ root, path, kind, info }) => {
-    const { ecosystem } = kind;
+  return parsed.map(({ root, path, ecosystem, info }) => {
     const targets = /* @__PURE__ */ new Set();
     for (const dep of info.deps) {
-      const target = ecosystem === "gradle" ? resolveGradleProject(dep, root, gradleRoots) : byName.get(ecosystem)?.get(matchKey(ecosystem, dep));
+      const target = byName.get(ecosystem)?.get(matchKey(ecosystem, dep));
       if (target !== void 0) targets.add(target);
     }
     for (const relative2 of info.paths) {
@@ -28211,11 +27908,10 @@ function parseWorkspace(manifests) {
       if (target !== null && roots.has(target)) targets.add(target);
     }
     targets.delete(root);
-    const fallback = ecosystem === "gradle" ? root.slice(root.lastIndexOf("/") + 1) : root;
     return {
       root,
-      name: info.name ?? (fallback === "" ? REPO_ROOT_NAME : fallback),
-      ecosystem,
+      name: info.name ?? (root === "" ? REPO_ROOT_NAME : root),
+      ecosystem: ecosystem.id,
       manifest: path,
       dependsOn: [...targets].sort()
     };
@@ -28229,16 +27925,6 @@ function packageRootOf(path, roots) {
   }
   return best;
 }
-function matchKey(ecosystem, name) {
-  switch (ecosystem) {
-    case "python":
-      return name.toLowerCase().replace(/[-_.]+/g, "-");
-    case "rust":
-      return name.toLowerCase().replace(/_/g, "-");
-    default:
-      return name;
-  }
-}
 function resolvePath(dir, relative2) {
   const normalized = relative2.replace(/\\/g, "/");
   if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) return null;
@@ -28250,42 +27936,9 @@ function resolvePath(dir, relative2) {
   }
   return segments.join("/");
 }
-function resolveGradleProject(projectPath, from, gradleRoots) {
-  let best;
-  let bestDepth = -1;
-  for (const root of gradleRoots) {
-    if (root !== projectPath && !root.endsWith(`/${projectPath}`)) continue;
-    const base = root.slice(0, Math.max(0, root.length - projectPath.length - 1));
-    const depth = base === "" || from === base || from.startsWith(`${base}/`) ? base.length : -1;
-    if (best === void 0 || depth > bestDepth) {
-      best = root;
-      bestDepth = depth;
-    }
-  }
-  if (best !== void 0) return best;
-  const projectName = projectPath.slice(projectPath.lastIndexOf("/") + 1);
-  const byBasename = gradleRoots.filter((root) => root.slice(root.lastIndexOf("/") + 1) === projectName);
-  return byBasename.length === 1 ? byBasename[0] : void 0;
-}
 
 // ../server/src/prLinks.ts
-var LINKS_VERSION = 6;
-var languageSchema = external_exports.enum([
-  "typescript",
-  "javascript",
-  "python",
-  "css",
-  "go",
-  "java",
-  "kotlin",
-  "c",
-  "cpp",
-  "rust",
-  "ruby",
-  "vue",
-  "svelte",
-  "markdown"
-]).nullable();
+var LINKS_VERSION = 7;
 var cachedSchema = external_exports.object({
   edges: external_exports.array(
     external_exports.object({
@@ -28295,7 +27948,7 @@ var cachedSchema = external_exports.object({
       detail: external_exports.array(external_exports.string())
     })
   ),
-  languages: external_exports.record(external_exports.string(), languageSchema),
+  languages: external_exports.record(external_exports.string(), external_exports.string().nullable()),
   externalImports: external_exports.record(external_exports.string(), external_exports.number()),
   packageImports: external_exports.record(external_exports.string(), external_exports.array(external_exports.string())),
   files: external_exports.array(external_exports.object({ path: external_exports.string(), status: external_exports.enum(["added", "deleted", "modified", "renamed"]) })),
@@ -28304,7 +27957,7 @@ var cachedSchema = external_exports.object({
     external_exports.object({
       root: external_exports.string(),
       name: external_exports.string(),
-      ecosystem: external_exports.enum(["npm", "python", "go", "rust", "maven", "gradle", "composer"]),
+      ecosystem: external_exports.string(),
       files: external_exports.array(external_exports.string()),
       dependsOn: external_exports.array(external_exports.string()),
       usedBy: external_exports.array(external_exports.string())
@@ -28314,7 +27967,7 @@ var cachedSchema = external_exports.object({
     external_exports.object({
       root: external_exports.string(),
       name: external_exports.string(),
-      ecosystem: external_exports.enum(["npm", "python", "go", "rust", "maven", "gradle", "composer"]),
+      ecosystem: external_exports.string(),
       touched: external_exports.boolean()
     })
   ),
@@ -28330,49 +27983,10 @@ async function manifestPaths(gh, store, ref, head) {
   const tree = await gh.rest(
     `/repos/${ref.owner}/${ref.repo}/git/trees/${head}?recursive=1`
   );
-  const paths = tree.tree.filter((t2) => t2.type === "blob" && isManifestPath(t2.path)).map((t2) => t2.path);
+  const paths = tree.tree.filter((t2) => t2.type === "blob" && isManifestPath(t2.path, ecosystems)).map((t2) => t2.path);
   store.putDiff(key, JSON.stringify(paths));
   return paths;
 }
-var SRC_EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".jsx"];
-function exportTargets(value) {
-  if (typeof value === "string") return [value];
-  if (!value || typeof value !== "object") return [];
-  const entries = Object.entries(value);
-  const root = entries.find(([k]) => k === ".");
-  const ordered = root ? [root] : entries.filter(([k]) => !k.startsWith("./"));
-  return ordered.flatMap(([, v]) => exportTargets(v));
-}
-function entryCandidates(pkg, manifestText) {
-  const join5 = (rel) => {
-    const clean = rel.replace(/^\.\//, "");
-    return pkg.root ? `${pkg.root}/${clean}` : clean;
-  };
-  const out = [];
-  if (pkg.ecosystem === "npm" && manifestText) {
-    let manifest = null;
-    try {
-      manifest = JSON.parse(manifestText);
-    } catch {
-    }
-    if (manifest && typeof manifest === "object") {
-      const fields = ["exports", "module", "main", "types", "typings"];
-      for (const field of fields) {
-        if (!(field in manifest)) continue;
-        const value = Reflect.get(manifest, field);
-        for (const target of exportTargets(value)) {
-          out.push(join5(target));
-          const source = target.replace(/^\.?\/?(dist|build|lib|out)\//, "src/").replace(/(\.d)?\.(m|c)?[jt]sx?$/, "");
-          if (source !== target) for (const ext of SRC_EXTENSIONS) out.push(join5(source + ext));
-        }
-      }
-    }
-    for (const base of ["src/index", "index", "src/main"])
-      for (const ext of SRC_EXTENSIONS) out.push(join5(base + ext));
-  }
-  if (pkg.ecosystem === "rust") out.push(join5("src/lib.rs"), join5("src/main.rs"));
-  return [...new Set(out)];
-}
 async function loadWorkspace(gh, store, ref, head) {
   const manifests = await manifestPaths(gh, store, ref, head);
   const dirs = new Set(manifests.map((p) => p.includes("/") ? p.slice(0, p.lastIndexOf("/")) : ""));
@@ -28383,11 +27997,14 @@ async function loadWorkspace(gh, store, ref, head) {
     manifests.map((path) => `${head}:${path}`)
   );
   const textOf = (path) => texts.get(`${head}:${path}`) ?? null;
-  const packages = parseWorkspace(manifests.map((path) => ({ path, text: textOf(path) })));
+  const packages = parseWorkspace(
+    manifests.map((path) => ({ path, text: textOf(path) })),
+    ecosystems
+  );
   const refs = packages.map((p) => ({
     name: p.name,
     root: p.root,
-    entries: entryCandidates(p, textOf(p.manifest))
+    entries: ecosystems.find((e) => e.id === p.ecosystem)?.entryCandidates(p.root, textOf(p.manifest)) ?? []
   }));
   return { packages, refs };
 }
@@ -28446,26 +28063,76 @@ async function loadLinks(gh, store, ref, base, head, fullPr) {
     if (parsed.success) return parsed.data;
   }
   const diff = await loadDiff(gh, store, ref, base, head, fullPr);
-  const readable = diff.files.filter((f) => !f.binary);
+  const analysed = diff.files.filter((f) => languages.detect(f.path) !== null);
   const expression = (f) => f.status === "deleted" ? `${base}:${f.oldPath}` : `${head}:${f.path}`;
-  const texts = await fetchTexts(gh, ref, readable.map(expression));
-  const sources = diff.files.map((f) => ({
-    path: f.path,
-    text: f.binary ? null : texts.get(expression(f)) ?? null
-  }));
+  const texts = await fetchTexts(gh, ref, analysed.filter((f) => !f.binary).map(expression));
+  const textOf = (f) => f.binary ? null : texts.get(expression(f)) ?? null;
+  const sources = diff.files.map((f) => ({ path: f.path, text: textOf(f) }));
   const workspace = await loadWorkspace(gh, store, ref, head);
-  const graph = buildLinkGraph(sources, workspace ? { packages: workspace.refs } : void 0);
+  const graph = buildLinkGraph(sources, languages, workspace ? { packages: workspace.refs } : void 0);
   const paths = diff.files.map((f) => f.path);
   const links = {
     ...graph,
     files: diff.files.map((f) => ({ path: f.path, status: f.status })),
-    unreadable: sources.filter((s) => s.text === null).map((s) => s.path),
+    unreadable: analysed.filter((f) => textOf(f) === null).map((f) => f.path),
     ...workspace ? orderPackages(workspace.packages, paths, graph.edges) : { packages: [], workspace: [], packageEdges: [] }
   };
   store.putDiff(cacheKey2, JSON.stringify(links));
   return links;
 }
 
+// ../server/src/poll.ts
+function sleep(ms, signal) {
+  const { promise: promise2, resolve } = Promise.withResolvers();
+  const timer = setTimeout(resolve, ms);
+  signal?.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timer);
+      resolve();
+    },
+    { once: true }
+  );
+  return promise2;
+}
+async function* pollChanges(intervalMs, signal, fingerprint, extraTrigger) {
+  let last = null;
+  try {
+    last = await fingerprint();
+  } catch (error62) {
+    console.warn("[poll]", error62 instanceof Error ? error62.message : error62);
+  }
+  const triggerIt = extraTrigger?.[Symbol.asyncIterator]();
+  const nextTrigger = () => {
+    const promise2 = triggerIt?.next();
+    promise2?.catch(() => void 0);
+    return promise2;
+  };
+  let pendingTrigger = signal?.aborted ? void 0 : nextTrigger();
+  try {
+    while (!signal?.aborted) {
+      const tick = sleep(intervalMs, signal).then(() => "tick");
+      const winner = pendingTrigger ? await Promise.race([tick, pendingTrigger.then(() => "trigger")]) : await tick;
+      if (signal?.aborted) return;
+      if (winner === "trigger") {
+        pendingTrigger = nextTrigger();
+        last = null;
+        yield { at: Date.now() };
+        continue;
+      }
+      try {
+        const next = await fingerprint();
+        if (last !== null && next !== last) yield { at: Date.now() };
+        last = next;
+      } catch (error62) {
+        console.warn("[poll]", error62 instanceof Error ? error62.message : error62);
+      }
+    }
+  } finally {
+    await triggerIt?.return?.().catch(() => void 0);
+  }
+}
+
 // ../../node_modules/.pnpm/@trpc+server@11.19.0_typescript@6.0.3/node_modules/@trpc/server/dist/initTRPC-B259os3T.mjs
 var middlewareMarker = "middlewareMarker";
 function createMiddlewareFactory() {
@@ -28811,51 +28478,10 @@ var procedure = t.procedure.use(githubErrors);
 
 // ../server/src/router.ts
 var PR_POLL_MS = 3e4;
-var INBOX_POLL_MS = 12e4;
+var INBOX_POLL_MS = 6e4;
 async function viewer(ctx) {
   return (await ctx.gh.graphql("{ viewer { login avatarUrl } }")).viewer;
 }
-function sleep(ms, signal) {
-  const { promise: promise2, resolve } = Promise.withResolvers();
-  const timer = setTimeout(resolve, ms);
-  signal?.addEventListener(
-    "abort",
-    () => {
-      clearTimeout(timer);
-      resolve();
-    },
-    { once: true }
-  );
-  return promise2;
-}
-async function* pollChanges(intervalMs, signal, fingerprint, extraTrigger) {
-  let last = null;
-  try {
-    last = await fingerprint();
-  } catch (error62) {
-    console.warn("[poll]", error62 instanceof Error ? error62.message : error62);
-  }
-  const triggerIt = extraTrigger?.[Symbol.asyncIterator]();
-  let pendingTrigger = triggerIt?.next();
-  while (!signal?.aborted) {
-    const tick = sleep(intervalMs, signal).then(() => "tick");
-    const winner = pendingTrigger ? await Promise.race([tick, pendingTrigger.then(() => "trigger")]) : await tick;
-    if (signal?.aborted) return;
-    if (winner === "trigger") {
-      pendingTrigger = triggerIt?.next();
-      last = null;
-      yield { at: Date.now() };
-      continue;
-    }
-    try {
-      const next = await fingerprint();
-      if (last !== null && next !== last) yield { at: Date.now() };
-      last = next;
-    } catch (error62) {
-      console.warn("[poll]", error62 instanceof Error ? error62.message : error62);
-    }
-  }
-}
 var configRouter = router({
   get: procedure.query(({ ctx }) => ctx.config.get()),
   add: procedure.input(trackedEntrySchema).mutation(async ({ ctx, input: input2 }) => {
@@ -28885,6 +28511,8 @@ var inboxRouter = router({
 });
 var prRouter = router({
   get: procedure.input(prRefSchema).query(({ ctx, input: input2 }) => loadPr(ctx.gh, ctx.store, input2)),
+  /** Polled by the PR page while checks run. */
+  checks: procedure.input(prRefSchema).query(({ ctx, input: input2 }) => loadChecks(ctx.gh, input2)),
   diff: procedure.input(external_exports.object({ ref: prRefSchema, base: shaSchema, head: shaSchema, fullPr: external_exports.boolean() })).query(({ ctx, input: input2 }) => loadDiff(ctx.gh, ctx.store, input2.ref, input2.base, input2.head, input2.fullPr)),
   links: procedure.input(external_exports.object({ ref: prRefSchema, base: shaSchema, head: shaSchema, fullPr: external_exports.boolean() })).query(({ ctx, input: input2 }) => loadLinks(ctx.gh, ctx.store, input2.ref, input2.base, input2.head, input2.fullPr)),
   blobs: procedure.input(external_exports.object({ ref: prRefSchema, oids: external_exports.array(shaSchema).min(1).max(2) })).query(({ ctx, input: input2 }) => loadBlobs(ctx.gh, ctx.store, input2.ref, input2.oids)),
@@ -28925,6 +28553,7 @@ var prRouter = router({
     ({ ctx, input: input2 }) => replyToThread(ctx.gh, input2.threadId, input2.body, input2.pendingReviewId)
   ),
   setResolved: procedure.input(external_exports.object({ threadId: external_exports.string(), resolved: external_exports.boolean() })).mutation(({ ctx, input: input2 }) => setThreadResolved(ctx.gh, input2.threadId, input2.resolved)),
+  react: procedure.input(external_exports.object({ subjectId: external_exports.string(), content: reactionContentSchema, on: external_exports.boolean() })).mutation(({ ctx, input: input2 }) => setReaction(ctx.gh, input2.subjectId, input2.content, input2.on)),
   addThread: procedure.input(
     external_exports.object({
       prId: external_exports.string(),
@@ -29023,8 +28652,11 @@ function createApp(options) {
   );
   if (options.webDist && existsSync2(options.webDist)) {
     const root = relative(process.cwd(), options.webDist);
-    app.use("/*", serveStatic({ root }));
-    app.get("*", serveStatic({ root, rewriteRequestPath: () => "/index.html" }));
+    const onFound = (path, c) => {
+      if (path.endsWith("index.html")) c.header("Cache-Control", "no-cache");
+    };
+    app.use("/*", serveStatic({ root, onFound }));
+    app.get("*", serveStatic({ root, rewriteRequestPath: () => "/index.html", onFound }));
   }
   return app;
 }
@@ -29088,11 +28720,11 @@ var ConfigStore = class extends EventEmitter {
     }
   }
   #write(next) {
-    const text = JSON.stringify(next, null, 2) + "\n";
+    const text2 = JSON.stringify(next, null, 2) + "\n";
     const tmp = this.path + ".tmp";
-    writeFileSync(tmp, text);
+    writeFileSync(tmp, text2);
     renameSync(tmp, this.path);
-    this.#lastWritten = text;
+    this.#lastWritten = text2;
     this.#config = next;
     this.emit("change", next);
     return next;