better-review 0.3.0 → 0.4.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({
@@ -26669,9 +26669,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 +26704,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;
@@ -26846,9 +26846,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 +26873,7 @@ async function applySuggestion(gh, ref, input2) {
   return res.commit.sha;
 }
 
-// ../server/src/links/extract.ts
-import ts from "typescript";
-
-// ../server/src/links/paths.ts
+// ../../packages/language/src/paths.ts
 function normalizePath(path) {
   const segments = [];
   for (const segment of path.split("/")) {
@@ -26915,7 +26912,168 @@ function sharedPrefixLength(a, b) {
   return count;
 }
 
-// ../server/src/links/extract.ts
+// ../../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;
+  }
+};
+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}`);
+  }
+  map2.set(key, language);
+}
+
+// ../../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 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;
+}
+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,
@@ -26926,44 +27084,9 @@ var SCRIPT_KIND_BY_EXTENSION = {
   ".cjs": ts.ScriptKind.JS,
   ".jsx": ts.ScriptKind.JSX
 };
-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));
-  }
-  return refs;
-}
-function parseScript(text, path, kind) {
-  const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, kind);
+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);
@@ -27034,162 +27157,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);
   }
-  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]] });
+  /** 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(
-    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] });
+  /** 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;
   }
-  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
@@ -27289,10 +27478,10 @@ function findMentions(files, skip) {
   }
   return mentions;
 }
-function mentionedPaths(from, text, paths) {
+function mentionedPaths(from, text2, paths) {
   const found = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
-  for (const [raw2] of text.matchAll(/[\w.\-/@$+~[\]]+/g)) {
+  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);
@@ -27315,12 +27504,12 @@ function mentionedPaths(from, text, paths) {
   }
   return found;
 }
-function wordSet(text) {
+function wordSet(text2) {
   const words = /* @__PURE__ */ new Set();
-  for (const match2 of text.matchAll(/[\w$]+(?:[.-][\w$]+)*/g)) {
+  for (const match2 of text2.matchAll(/[\w$]+(?:[.-][\w$]+)*/g)) {
     const word = match2[0];
-    const before = text[match2.index - 1];
-    const after = text[match2.index + word.length];
+    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(/([.-])/);
@@ -27336,307 +27525,23 @@ function wordSet(text) {
   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 }];
-  }
-  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}`])
-  ];
-}
-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;
-}
-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 }];
-}
-
 // ../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 +27563,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 +27577,7 @@ function buildLinkGraph(files, options = {}) {
       ...edge,
       detail: [...detail].slice(0, MAX_DETAIL)
     })),
-    languages,
+    languages: languageIds,
     externalImports,
     packageImports
   };
@@ -27681,14 +27586,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 +27604,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 +27611,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 +27684,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 +27701,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 +27712,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 +27724,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 +27733,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 +27743,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 +27759,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 +27773,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,20 +27839,18 @@ 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));
@@ -29023,8 +28414,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 +28482,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;