gitifact 0.6.0 → 0.6.1

package/dist/main.js

@@ -4205,11 +4205,11 @@ function parseChangelog(text2) {
   let previous;
   let entry2;
   let section;
-  const fail8 = (line, key, values = {}) => new InitError("INVALID_CHANGELOG", t("changelog.atLine", { line, reason: t(key, values) }));
+  const fail9 = (line, key, values = {}) => new InitError("INVALID_CHANGELOG", t("changelog.atLine", { line, reason: t(key, values) }));
   const lines = text2.replace(/\r\n/g, "\n").split("\n");
   const close = (line) => {
     if (entry2 && changelogSections.every((name) => entry2[name].length === 0))
-      throw fail8(line, "changelog.emptyVersion", { version: entry2.version });
+      throw fail9(line, "changelog.emptyVersion", { version: entry2.version });
   };
   lines.forEach((raw, index) => {
     const line = index + 1;
@@ -4220,9 +4220,9 @@ function parseChangelog(text2) {
       close(line);
       const core = [Number(version2[1]), Number(version2[2]), Number(version2[3])];
       if (!realDate(Number(version2[4]), Number(version2[5]), Number(version2[6])))
-        throw fail8(line, "changelog.invalidDate", { text: raw });
+        throw fail9(line, "changelog.invalidDate", { text: raw });
       if (previous && !(core[0] < previous[0] || core[0] === previous[0] && (core[1] < previous[1] || core[1] === previous[1] && core[2] < previous[2]))) {
-        throw fail8(line, "changelog.order", { version: core.join(".") });
+        throw fail9(line, "changelog.order", { version: core.join(".") });
       }
       previous = core;
       section = void 0;
@@ -4233,25 +4233,25 @@ function parseChangelog(text2) {
     const heading = sectionLine.exec(raw);
     if (heading) {
       if (!entry2)
-        throw fail8(line, "changelog.sectionBeforeVersion");
+        throw fail9(line, "changelog.sectionBeforeVersion");
       const name = heading[1].toLowerCase();
       if (entry2[name].length > 0)
-        throw fail8(line, "changelog.duplicateSection", { section: heading[1] });
+        throw fail9(line, "changelog.duplicateSection", { section: heading[1] });
       section = name;
       return;
     }
     const item = itemLine.exec(raw);
     if (item) {
       if (!entry2 || !section)
-        throw fail8(line, "changelog.itemOutsideSection");
+        throw fail9(line, "changelog.itemOutsideSection");
       entry2[section].push(item[1].trimEnd());
       return;
     }
-    throw fail8(line, "changelog.unknownLine", { text: raw });
+    throw fail9(line, "changelog.unknownLine", { text: raw });
   });
   close(lines.length);
   if (entries.length === 0)
-    throw fail8(1, "changelog.noVersions");
+    throw fail9(1, "changelog.noVersions");
   return entries;
 }
 
@@ -4591,10 +4591,10 @@ function decodeGitLine(buffer) {
   if (!value || value.includes("\0")) return invalid();
   return value;
 }
-function fieldsAndPath(record3, count) {
+function fieldsAndPath(record3, count2) {
   const fields2 = [];
   let start = 0;
-  for (let index = 0; index < count; index++) {
+  for (let index = 0; index < count2; index++) {
     const end = record3.indexOf(" ", start);
     if (end <= start) return invalid();
     fields2.push(record3.slice(start, end));
@@ -4645,7 +4645,7 @@ function parsePorcelain(buffer, format) {
       const modes = fields2.slice(3, conflict ? 7 : 6);
       if (modes.some((mode) => !/^(000000|100644|100755|120000|160000)$/.test(mode))) return invalid();
       const oids = fields2.slice(conflict ? 7 : 6);
-      if (oids.some((oid2) => !oidPattern.test(oid2))) return invalid();
+      if (oids.some((oid3) => !oidPattern.test(oid3))) return invalid();
       change2 = { kind: conflict ? "unmerged" : "tracked", path: path3, xy, submodule: submodule(fields2[2]) };
     } else return invalid();
     if (seen.has(change2.path)) return invalid();
@@ -6023,14 +6023,14 @@ function codePointLength(str) {
   const units = str.length;
   if (!highSurrogate.test(str))
     return units;
-  let count = units;
+  let count2 = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count--;
+      count2--;
       i++;
     }
   }
-  return count;
+  return count2;
 }
 function getLengthableOrigin(input2) {
   if (Array.isArray(input2))
@@ -8571,16 +8571,16 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
   };
 });
 function handleExclusiveUnionResults(results, final, inst, ctx) {
-  const matches = [];
+  const matches2 = [];
   for (let i = 0; i < results.length; i++) {
     if (results[i].issues.length === 0)
-      matches.push(i);
+      matches2.push(i);
   }
-  if (matches.length === 1) {
-    final.value = results[matches[0]].value;
+  if (matches2.length === 1) {
+    final.value = results[matches2[0]].value;
     return final;
   }
-  if (matches.length === 0) {
+  if (matches2.length === 0) {
     final.issues.push({
       code: "invalid_union",
       input: final.value,
@@ -8594,7 +8594,7 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
       inst,
       errors: [],
       inclusive: false,
-      matches
+      matches: matches2
     });
   }
   return final;
@@ -10385,8 +10385,8 @@ function az_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.4/node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -13033,8 +13033,8 @@ function hu_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.4/node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count, one, many) {
-  return Math.abs(count) === 1 ? one : many;
+function getArmenianPlural(count2, one, many) {
+  return Math.abs(count2) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -15772,8 +15772,8 @@ function ro_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.4/node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -20407,13 +20407,13 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function handleUnrepresentable(schema, ctx, json2, params, message) {
+function handleUnrepresentable(schema, ctx, json3, 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(json2, result);
+  Object.assign(json3, result);
   return true;
 }
 function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
@@ -20649,12 +20649,12 @@ function foldObjects(members2) {
   }
   return folded;
 }
-function foldIntersection(json2) {
-  const allOf = json2.allOf;
+function foldIntersection(json3) {
+  const allOf = json3.allOf;
   if (!Array.isArray(allOf) || allOf.length < 2)
     return;
   for (const key of FOLDABLE_KEYS)
-    if (key in json2)
+    if (key in json3)
       return;
   const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
   let folded = null;
@@ -20673,8 +20673,8 @@ function foldIntersection(json2) {
   }
   if (!folded)
     return;
-  delete json2.allOf;
-  assignProps(json2, folded);
+  delete json3.allOf;
+  assignProps(json3, folded);
 }
 function finalize(ctx, schema) {
   const root = ctx.seen.get(schema);
@@ -20756,20 +20756,20 @@ function finalize(ctx, schema) {
     if (ctx.intersections.length) {
       const carriers = /* @__PURE__ */ new Map();
       for (const seen of ctx.seen.values()) {
-        for (const json2 of [seen.schema, seen.def]) {
-          const allOf = json2?.allOf;
+        for (const json3 of [seen.schema, seen.def]) {
+          const allOf = json3?.allOf;
           if (!Array.isArray(allOf))
             continue;
           const existing = carriers.get(allOf);
           if (existing)
-            existing.push(json2);
+            existing.push(json3);
           else
-            carriers.set(allOf, [json2]);
+            carriers.set(allOf, [json3]);
         }
       }
       for (const allOf of ctx.intersections) {
-        for (const json2 of carriers.get(allOf) ?? [])
-          foldIntersection(json2);
+        for (const json3 of carriers.get(allOf) ?? [])
+          foldIntersection(json3);
       }
     }
   }
@@ -21004,29 +21004,29 @@ var exactPatterns = /* @__PURE__ */ new Map([
 ]);
 var exactPattern = (p) => exactPatterns.get(p) ?? p;
 var stringProcessor = (schema, ctx, _json, _params) => {
-  const json2 = _json;
-  json2.type = "string";
+  const json3 = _json;
+  json3.type = "string";
   const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minLength = minimum;
+    json3.minLength = minimum;
   if (typeof maximum === "number")
-    json2.maxLength = maximum;
+    json3.maxLength = maximum;
   if (format) {
-    json2.format = formatMap[format] ?? format;
-    if (json2.format === "")
-      delete json2.format;
+    json3.format = formatMap[format] ?? format;
+    if (json3.format === "")
+      delete json3.format;
     if (format === "time" || laxFormat) {
-      delete json2.format;
+      delete json3.format;
     }
   }
   if (contentEncoding)
-    json2.contentEncoding = contentEncoding;
+    json3.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const patternList = [...patterns].map(exactPattern);
     if (patternList.length === 1)
-      json2.pattern = patternList[0].source;
+      json3.pattern = patternList[0].source;
     else if (patternList.length > 1) {
-      json2.allOf = [
+      json3.allOf = [
         ...patternList.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -21036,31 +21036,31 @@ var stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 var numberProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
-  json2.type = isInt ? "integer" : "number";
+  json3.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) {
-      json2.minimum = exclusiveMinimum;
-      json2.exclusiveMinimum = true;
+      json3.minimum = exclusiveMinimum;
+      json3.exclusiveMinimum = true;
     } else {
-      json2.exclusiveMinimum = exclusiveMinimum;
+      json3.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json2.minimum = minimum;
+    json3.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json2.maximum = exclusiveMaximum;
-      json2.exclusiveMaximum = true;
+      json3.maximum = exclusiveMaximum;
+      json3.exclusiveMaximum = true;
     } else {
-      json2.exclusiveMaximum = exclusiveMaximum;
+      json3.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json2.maximum = maximum;
+    json3.maximum = maximum;
   }
   if (multipleOf) {
     const divisors = /* @__PURE__ */ new Set();
@@ -21068,75 +21068,75 @@ var numberProcessor = (schema, ctx, _json, params) => {
       if (Number.isFinite(divisor) && divisor !== 0)
         divisors.add(Math.abs(divisor));
       else
-        handleUnrepresentable(schema, ctx, json2, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
+        handleUnrepresentable(schema, ctx, json3, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
     const [first, ...rest] = divisors;
     if (first !== void 0)
-      json2.multipleOf = first;
+      json3.multipleOf = first;
     if (rest.length)
-      json2.allOf = [...json2.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
+      json3.allOf = [...json3.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
   }
 };
-var booleanProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var booleanProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
-var bigintProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt cannot be represented in JSON Schema");
+var bigintProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt cannot be represented in JSON Schema");
 };
-var symbolProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Symbols 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 nullProcessor = (_schema, ctx, json2, _params) => {
+var nullProcessor = (_schema, ctx, json3, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json2.type = "string";
-    json2.nullable = true;
-    json2.enum = [null];
+    json3.type = "string";
+    json3.nullable = true;
+    json3.enum = [null];
   } else {
-    json2.type = "null";
+    json3.type = "null";
   }
 };
-var undefinedProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Undefined cannot be represented in JSON Schema");
+var undefinedProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Undefined cannot be represented in JSON Schema");
 };
-var voidProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Void 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 neverProcessor = (_schema, _ctx, json2, _params) => {
-  json2.not = {};
+var neverProcessor = (_schema, _ctx, json3, _params) => {
+  json3.not = {};
 };
 var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
 var unknownProcessor = (_schema, _ctx, _json, _params) => {
 };
-var dateProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Date cannot be represented in JSON Schema");
+var dateProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Date cannot be represented in JSON Schema");
 };
-var enumProcessor = (schema, _ctx, json2, _params) => {
+var enumProcessor = (schema, _ctx, json3, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   if (values.every((v) => typeof v === "number"))
-    json2.type = "number";
+    json3.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json2.type = "string";
-  json2.enum = values;
+    json3.type = "string";
+  json3.enum = values;
 };
-var literalProcessor = (schema, ctx, json2, params) => {
+var literalProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   if (def.values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
-      if (handleUnrepresentable(schema, ctx, json2, params, "Literal `undefined` cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "Literal `undefined` cannot be represented in JSON Schema"))
         return;
     } else if (typeof val === "bigint") {
-      if (handleUnrepresentable(schema, ctx, json2, params, "BigInt literals cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "BigInt literals cannot be represented in JSON Schema"))
         return;
       vals.push(Number(val));
     } else {
@@ -21146,37 +21146,37 @@ var literalProcessor = (schema, ctx, json2, params) => {
   if (vals.length === 0) {
   } else if (vals.length === 1) {
     const val = vals[0];
-    json2.type = val === null ? "null" : typeof val;
+    json3.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json2.enum = [val];
+      json3.enum = [val];
     } else {
-      json2.const = val;
+      json3.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json2.type = "number";
+      json3.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json2.type = "string";
+      json3.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json2.type = "boolean";
+      json3.type = "boolean";
     if (vals.every((v) => v === null))
-      json2.type = "null";
-    json2.enum = vals;
+      json3.type = "null";
+    json3.enum = vals;
   }
 };
-var nanProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "NaN cannot be represented in JSON Schema");
+var nanProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "NaN cannot be represented in JSON Schema");
 };
-var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var templateLiteralProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   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, json2, _params) => {
-  const _json = json2;
+var fileProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   _json.type = "string";
   _json.format = "binary";
   _json.contentEncoding = "binary";
@@ -21194,34 +21194,34 @@ var fileProcessor = (schema, _ctx, json2, _params) => {
   else
     _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
 };
-var successProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var successProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
-var customProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Custom types cannot be represented in JSON Schema");
+var customProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Custom types cannot be represented in JSON Schema");
 };
-var functionProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Function 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 transformProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Transforms 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 mapProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Map 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 setProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Set 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 arrayProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
-  json2.type = "array";
-  json2.items = processSchema(def.element, ctx, {
+    json3.maxItems = maximum;
+  json3.type = "array";
+  json3.items = processSchema(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -21237,17 +21237,17 @@ function inputOptin(schema) {
   return schema._zod.optin;
 }
 var objectProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const shape = def.shape;
   const symbolKeys = Object.getOwnPropertySymbols(shape);
-  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json2, params, "Symbol keys cannot be represented in JSON Schema")) {
+  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json3, params, "Symbol keys cannot be represented in JSON Schema")) {
     return;
   }
-  json2.type = "object";
-  json2.properties = {};
+  json3.type = "object";
+  json3.properties = {};
   for (const key in shape) {
-    assignProp(json2.properties, key, processSchema(shape[key], ctx, {
+    assignProp(json3.properties, key, processSchema(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     }));
@@ -21260,21 +21260,21 @@ var objectProcessor = (schema, ctx, _json, params) => {
     }
   }
   if (requiredKeys.length > 0) {
-    json2.required = requiredKeys;
+    json3.required = requiredKeys;
   }
   if (def.catchall?._zod.def.type === "never") {
-    json2.additionalProperties = false;
+    json3.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json2.additionalProperties = false;
+      json3.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = processSchema(def.catchall, ctx, {
+    json3.additionalProperties = processSchema(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-var unionProcessor = (schema, ctx, json2, params) => {
+var unionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => processSchema(x, ctx, {
@@ -21282,12 +21282,12 @@ var unionProcessor = (schema, ctx, json2, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
   if (isExclusive) {
-    json2.oneOf = options;
+    json3.oneOf = options;
   } else {
-    json2.anyOf = options;
+    json3.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json2, params) => {
+var intersectionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const a = processSchema(def.left, ctx, {
     ...params,
@@ -21302,13 +21302,13 @@ var intersectionProcessor = (schema, ctx, json2, params) => {
     ...isSimpleIntersection(a) ? a.allOf : [a],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json2.allOf = allOf;
+  json3.allOf = allOf;
   ctx.intersections.push(allOf);
 };
 var tupleProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "array";
+  json3.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, {
@@ -21330,70 +21330,70 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   const maxItems = def.items.length;
   const isClosed = !def.rest;
   if (ctx.target === "draft-2020-12") {
-    json2.prefixItems = prefixItems;
+    json3.prefixItems = prefixItems;
     if (isClosed) {
-      json2.items = false;
+      json3.items = false;
     } else if (rest) {
-      json2.items = rest;
+      json3.items = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else if (ctx.target === "openapi-3.0") {
-    json2.items = {
+    json3.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json2.items.anyOf.push(rest);
+      json3.items.anyOf.push(rest);
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else {
-    json2.items = prefixItems;
+    json3.items = prefixItems;
     if (isClosed) {
-      json2.additionalItems = false;
+      json3.additionalItems = false;
     } else if (rest) {
-      json2.additionalItems = rest;
+      json3.additionalItems = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   }
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
+    json3.maxItems = maximum;
 };
-function stringifyKeyNames(bySchema, json2, visited) {
-  if (json2.$ref) {
-    if (visited.has(json2))
-      return json2;
-    visited.add(json2);
-    const def = bySchema.get(json2)?.def;
+function stringifyKeyNames(bySchema, json3, visited) {
+  if (json3.$ref) {
+    if (visited.has(json3))
+      return json3;
+    visited.add(json3);
+    const def = bySchema.get(json3)?.def;
     if (!def)
-      return json2;
+      return json3;
     const inlined = stringifyKeyNames(bySchema, def, visited);
-    return inlined === def ? json2 : inlined;
+    return inlined === def ? json3 : inlined;
   }
   for (const keyword of ["anyOf", "oneOf"]) {
-    const branches = json2[keyword];
+    const branches = json3[keyword];
     if (!Array.isArray(branches))
       continue;
     const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
     if (mapped.some((branch, i) => branch !== branches[i]))
-      json2 = { ...json2, [keyword]: mapped };
+      json3 = { ...json3, [keyword]: mapped };
   }
-  const types = Array.isArray(json2.type) ? json2.type : [json2.type];
+  const types = Array.isArray(json3.type) ? json3.type : [json3.type];
   const numericType = !types.includes("string") && types.some((t3) => t3 === "number" || t3 === "integer");
-  const values = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
+  const values = json3.enum ?? (json3.const !== void 0 ? [json3.const] : void 0);
   if (!numericType && !values?.some((v) => typeof v === "number"))
-    return json2;
-  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json2;
+    return json3;
+  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json3;
   if (rest.enum)
     rest.enum = rest.enum.map((v) => typeof v === "number" ? String(v) : v);
   else if (typeof rest.const === "number")
@@ -21433,9 +21433,9 @@ function rewriteKeyNames(ctx) {
   }
 }
 var recordProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
+  json3.type = "object";
   const keyType = def.keyType;
   const patterns = aggregateChecks(keyType).patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
@@ -21443,13 +21443,13 @@ var recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json2.patternProperties = {};
+    json3.patternProperties = {};
     for (const pattern of patterns) {
-      assignProp(json2.patternProperties, exactPattern(pattern).source, valueSchema);
+      assignProp(json3.patternProperties, exactPattern(pattern).source, valueSchema);
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = processSchema(def.keyType, ctx, {
+      json3.propertyNames = processSchema(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
@@ -21461,7 +21461,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
       }
       pending.push(schema);
     }
-    json2.additionalProperties = processSchema(def.valueType, ctx, {
+    json3.additionalProperties = processSchema(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -21471,19 +21471,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) {
-      json2.required = validKeyValues.map(String);
+      json3.required = validKeyValues.map(String);
     }
   }
 };
-var nullableProcessor = (schema, ctx, json2, params) => {
+var nullableProcessor = (schema, ctx, json3, 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;
-    json2.nullable = true;
+    json3.nullable = true;
   } else {
-    json2.anyOf = [inner, { type: "null" }];
+    json3.anyOf = [inner, { type: "null" }];
   }
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -21493,7 +21493,7 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   seen.ref = def.innerType;
 };
 var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
-function serializeDefaultValue(value, schema, ctx, json2, params) {
+function serializeDefaultValue(value, schema, ctx, json3, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_, val) => {
     if (typeof val !== "bigint")
@@ -21503,30 +21503,30 @@ function serializeDefaultValue(value, schema, ctx, json2, params) {
   });
   if (!unrepresentable)
     return JSON.parse(serialized);
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt defaults cannot be represented in JSON Schema");
   return UNREPRESENTABLE_DEFAULT;
 }
-var defaultProcessor = (schema, ctx, json2, params) => {
+var defaultProcessor = (schema, ctx, json3, 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, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2.default = value;
+    json3.default = value;
 };
-var prefaultProcessor = (schema, ctx, json2, params) => {
+var prefaultProcessor = (schema, ctx, json3, 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, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2._prefault = value;
+    json3._prefault = value;
 };
-var catchProcessor = (schema, ctx, json2, params) => {
+var catchProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -21535,10 +21535,10 @@ var catchProcessor = (schema, ctx, json2, params) => {
   try {
     catchValue = def.catchValue(void 0);
   } catch {
-    handleUnrepresentable(schema, ctx, json2, params, "Dynamic catch values are not supported in JSON Schema");
+    handleUnrepresentable(schema, ctx, json3, params, "Dynamic catch values are not supported in JSON Schema");
     return;
   }
-  json2.default = catchValue;
+  json3.default = catchValue;
 };
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -21548,12 +21548,12 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json2, params) => {
+var readonlyProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.readOnly = true;
+  json3.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -22195,7 +22195,7 @@ var _ZodString = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodString.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     format: (inst) => aggregateChecks(inst).format ?? null,
@@ -22554,7 +22554,7 @@ var ZodNumber = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
     inst.isFinite = true;
   },
   /* @__PURE__ */ util_exports.derived({
@@ -22644,7 +22644,7 @@ function uint32(params) {
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
 });
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
@@ -22654,7 +22654,7 @@ var ZodBigInt = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     minValue: (inst) => aggregateChecks(inst).minimum ?? null,
@@ -22712,7 +22712,7 @@ function uint64(params) {
 var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
   $ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
 });
 function symbol(params) {
   return _symbol(ZodSymbol, params);
@@ -22720,7 +22720,7 @@ function symbol(params) {
 var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
   $ZodUndefined.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
 });
 function _undefined3(params) {
   return _undefined2(ZodUndefined, params);
@@ -22728,7 +22728,7 @@ function _undefined3(params) {
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
 });
 function _null3(params) {
   return _null2(ZodNull, params);
@@ -22736,7 +22736,7 @@ function _null3(params) {
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
   $ZodAny.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
 });
 function any() {
   return _any(ZodAny);
@@ -22744,7 +22744,7 @@ function any() {
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
 });
 function unknown() {
   return _unknown(ZodUnknown);
@@ -22752,7 +22752,7 @@ function unknown() {
 var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
 });
 function never(params) {
   return _never(ZodNever, params);
@@ -22760,7 +22760,7 @@ function never(params) {
 var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
   $ZodVoid.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
 });
 function _void2(params) {
   return _void(ZodVoid, params);
@@ -22770,7 +22770,7 @@ var ZodDate = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodDate.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
     inst.min = (value, params) => inst.check(_gte(value, params));
     inst.max = (value, params) => inst.check(_lte(value, params));
   },
@@ -22792,7 +22792,7 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
   inst.element = def.element;
 }, {
   min(n, params) {
@@ -22822,7 +22822,7 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
   util_exports.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 }, {
   keyof() {
@@ -22895,7 +22895,7 @@ function looseObject(shape, params) {
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -22908,7 +22908,7 @@ function union(options, params) {
 var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
   ZodUnion.init(inst, def);
   $ZodXor.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function xor(options, params) {
@@ -22934,7 +22934,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, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -22947,7 +22947,7 @@ var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
 }, {
   rest(rest) {
     return this.clone({
@@ -22980,7 +22980,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodRecord.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
@@ -23022,7 +23022,7 @@ var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodMap.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
   inst.min = (...args) => inst.check(_minSize(...args));
@@ -23042,7 +23042,7 @@ var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
   inst.min = (...args) => inst.check(_minSize(...args));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
   inst.max = (...args) => inst.check(_maxSize(...args));
@@ -23058,7 +23058,7 @@ function set(valueType, params) {
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
   inst.enum = def.entries;
   inst.options = [...inst._zod.values];
   const keys2 = new Set(Object.keys(def.entries));
@@ -23111,7 +23111,7 @@ function nativeEnum(entries, params) {
 var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
   $ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
   inst.values = new Set(def.values);
   Object.defineProperty(inst, "value", {
     get() {
@@ -23132,7 +23132,7 @@ function literal(value, params) {
 var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   $ZodFile.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, 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));
@@ -23144,7 +23144,7 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -23183,7 +23183,7 @@ function transform(fn) {
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -23195,7 +23195,7 @@ function optional(innerType) {
 var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -23207,7 +23207,7 @@ function exactOptional(innerType) {
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -23222,7 +23222,7 @@ function nullish2(innerType) {
 var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -23238,7 +23238,7 @@ function _default2(innerType, defaultValue) {
 var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -23253,7 +23253,7 @@ function prefault(innerType, defaultValue) {
 var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -23266,7 +23266,7 @@ function nonoptional(innerType, params) {
 var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
   $ZodSuccess.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function success(innerType) {
@@ -23278,7 +23278,7 @@ function success(innerType) {
 var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -23292,7 +23292,7 @@ function _catch2(innerType, catchValue) {
 var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
   $ZodNaN.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
 });
 function nan(params) {
   return _nan(ZodNaN, params);
@@ -23300,7 +23300,7 @@ function nan(params) {
 var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -23342,7 +23342,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, json2, params) => readonlyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -23354,7 +23354,7 @@ function readonly(innerType) {
 var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
 });
 function templateLiteral(parts, params) {
   return new ZodTemplateLiteral({
@@ -23366,7 +23366,7 @@ function templateLiteral(parts, params) {
 var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -23378,7 +23378,7 @@ function lazy(getter) {
 var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
   $ZodPromise.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function promise(innerType) {
@@ -23390,7 +23390,7 @@ function promise(innerType) {
 var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
   $ZodFunction.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
 });
 function _function(params) {
   return new ZodFunction({
@@ -23402,7 +23402,7 @@ function _function(params) {
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
 });
 function check(fn) {
   const ch = new $ZodCheck({
@@ -23793,20 +23793,20 @@ function checkArrayGuards(arraySchema, guards) {
     if (guards.containsSchema) {
       const minContains = guards.minContains ?? 1;
       const ceiling = guards.maxContains !== void 0 ? guards.maxContains + 1 : Number.POSITIVE_INFINITY;
-      let matches = 0;
+      let matches2 = 0;
       for (const item of items2) {
-        if (guards.containsSchema.safeParse(item).success && ++matches >= ceiling)
+        if (guards.containsSchema.safeParse(item).success && ++matches2 >= ceiling)
           break;
       }
-      if (matches < minContains) {
+      if (matches2 < minContains) {
         payload.issues.push({
           code: "custom",
-          message: `Array must contain at least ${minContains} matching ${plural(minContains)}; found ${matches}`,
+          message: `Array must contain at least ${minContains} matching ${plural(minContains)}; found ${matches2}`,
           input: items2,
           continue: true
         });
       }
-      if (guards.maxContains !== void 0 && matches > guards.maxContains) {
+      if (guards.maxContains !== void 0 && matches2 > guards.maxContains) {
         payload.issues.push({
           code: "custom",
           message: `Array must contain at most ${guards.maxContains} matching ${plural(guards.maxContains)}`,
@@ -24631,7 +24631,7 @@ var projectInitV5 = external_exports.discriminatedUnion("ok", [
   external_exports.strictObject({ contract: external_exports.literal("project-init"), version: external_exports.literal(5), ok: external_exports.literal(false), error: external_exports.strictObject({ code: external_exports.string(), message: external_exports.string() }) })
 ]);
 
-// ../../packages/contracts/dist/versions/browser-specs-v3.js
+// ../../packages/contracts/dist/versions/browser-specs-v4.js
 var requirement = external_exports.strictObject({ id: external_exports.string(), title: external_exports.string(), body: external_exports.string() });
 var contributor = external_exports.strictObject({ email: external_exports.string(), name: external_exports.string(), commits: external_exports.number().int().nonnegative(), latest: external_exports.string() });
 var source = external_exports.strictObject({ title: external_exports.string(), path: external_exports.string().optional(), url: external_exports.string().optional(), note: external_exports.string().optional() });
@@ -24646,45 +24646,103 @@ var feature = external_exports.strictObject({
   contributors: external_exports.array(contributor),
   updatedAt: external_exports.string().nullable()
 });
-var snapshot = requirement.extend({ specId: external_exports.string(), path: external_exports.string(), sources: external_exports.array(source).optional() }).nullable();
 var document = external_exports.strictObject({ id: external_exports.string(), path: external_exports.string(), title: external_exports.string(), body: external_exports.string(), updatedAt: external_exports.string().nullable() });
+var oid2 = external_exports.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/);
+var browserSpecsV4 = external_exports.strictObject({
+  contract: external_exports.literal("browser-specs"),
+  version: external_exports.literal(4),
+  sessionId: external_exports.string(),
+  head: oid2.nullable(),
+  observedAt: external_exports.string(),
+  working: external_exports.boolean(),
+  features: external_exports.array(feature),
+  documents: external_exports.array(document),
+  contributors: external_exports.array(contributor),
+  contributorsLimited: external_exports.boolean()
+});
+var reference = external_exports.strictObject({ id: external_exports.string(), title: external_exports.string(), specId: external_exports.string(), path: external_exports.string() }).nullable();
+var snapshot = requirement.extend({ specId: external_exports.string(), path: external_exports.string(), sources: external_exports.array(source).optional() }).nullable();
+var changeType = external_exports.enum(["created", "modified", "moved", "deleted"]);
 var event = external_exports.strictObject({
   key: external_exports.string(),
-  commit: external_exports.string(),
+  commit: oid2,
   date: external_exports.string(),
   author: external_exports.string(),
   email: external_exports.string(),
   committer: external_exports.string(),
   message: external_exports.string(),
   id: external_exports.string(),
-  kind: external_exports.enum(["requirement", "design", "wiki"]).optional(),
-  types: external_exports.array(external_exports.enum(["created", "modified", "moved", "deleted"])),
-  before: snapshot,
-  after: snapshot,
+  kind: external_exports.enum(["requirement", "design", "wiki"]),
+  types: external_exports.array(changeType),
+  before: reference,
+  after: reference,
   reasons: external_exports.array(external_exports.string())
 });
-var browserSpecsV3 = external_exports.strictObject({
-  contract: external_exports.literal("browser-specs"),
-  version: external_exports.literal(3),
+var browserHistoryV1 = external_exports.strictObject({
+  contract: external_exports.literal("browser-history"),
+  version: external_exports.literal(1),
   sessionId: external_exports.string(),
-  head: external_exports.string().nullable(),
-  observedAt: external_exports.string(),
+  head: oid2,
+  // Matching changes in all of history, not in this page; `offset` is where this page starts among them.
+  total: external_exports.number().int().nonnegative(),
+  offset: external_exports.number().int().nonnegative(),
   events: external_exports.array(event),
-  nextCursor: external_exports.number().int().nonnegative().nullable(),
-  boundary: external_exports.boolean(),
-  working: external_exports.boolean().optional(),
-  features: external_exports.array(feature).optional(),
-  documents: external_exports.array(document).optional(),
-  contributors: external_exports.array(contributor).optional(),
-  contributorsLimited: external_exports.boolean().optional()
+  // History reaches back to records in the legacy JSON format, which it does not read.
+  boundary: external_exports.boolean()
+});
+var browserHistorySummaryV1 = external_exports.strictObject({
+  contract: external_exports.literal("browser-history-summary"),
+  version: external_exports.literal(1),
+  sessionId: external_exports.string(),
+  head: oid2,
+  total: external_exports.number().int().nonnegative(),
+  byType: external_exports.strictObject({ created: external_exports.number().int().nonnegative(), modified: external_exports.number().int().nonnegative(), moved: external_exports.number().int().nonnegative(), deleted: external_exports.number().int().nonnegative() }),
+  // One entry per commit within three weeks of the newest change, so the reader can count by its own calendar day.
+  pulse: external_exports.array(external_exports.strictObject({ date: external_exports.string(), count: external_exports.number().int().positive() })),
+  // The newest commits: a few of their changes each and how many there are in all.
+  recent: external_exports.array(external_exports.strictObject({ commit: oid2, count: external_exports.number().int().positive(), events: external_exports.array(event) }))
+});
+var browserChangeV1 = external_exports.strictObject({
+  contract: external_exports.literal("browser-change"),
+  version: external_exports.literal(1),
+  sessionId: external_exports.string(),
+  event,
+  before: snapshot,
+  after: snapshot
+});
+var browserSearchV1 = external_exports.strictObject({
+  contract: external_exports.literal("browser-search"),
+  version: external_exports.literal(1),
+  sessionId: external_exports.string(),
+  query: external_exports.string(),
+  hits: external_exports.array(external_exports.strictObject({
+    id: external_exports.string(),
+    kind: external_exports.enum(["feature", "requirement", "design", "document", "history"]),
+    title: external_exports.string(),
+    where: external_exports.string(),
+    line: external_exports.string(),
+    // What the hit opens: a feature (with the requirement or design tab), a wiki page, or one change in the activity.
+    featureId: external_exports.string().optional(),
+    documentId: external_exports.string().optional(),
+    key: external_exports.string().optional()
+  }))
 });
-var browserSpecsFirstV3 = browserSpecsV3.required({
-  working: true,
-  features: true,
-  documents: true,
-  contributors: true,
-  contributorsLimited: true
+var headQuery = oid2;
+var count = (max) => external_exports.string().regex(/^(0|[1-9]\d{0,6})$/).transform(Number).pipe(external_exports.number().int().min(0).max(max));
+var browserHistoryQueryV1 = external_exports.strictObject({
+  head: headQuery,
+  offset: count(1e6).optional(),
+  limit: count(100).pipe(external_exports.number().min(1)).optional(),
+  kind: changeType.optional(),
+  document: external_exports.enum(["requirement", "design", "wiki"]).optional(),
+  feature: external_exports.string().regex(/^S-[a-z2-7]{10}$/).optional(),
+  author: external_exports.string().min(1).max(320).optional(),
+  q: external_exports.string().max(200).optional()
 });
+var browserHistorySummaryQueryV1 = external_exports.strictObject({ head: headQuery });
+var browserChangeQueryV1 = external_exports.strictObject({ key: external_exports.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64}):[RSW]-[a-z2-7]{10}$/) });
+var browserSearchQueryV1 = external_exports.strictObject({ q: external_exports.string().min(1).max(200), head: headQuery.optional() });
+var changelogQueryV1 = external_exports.strictObject({ lang: external_exports.string().regex(/^[a-z]{2}(?:-[A-Z]{2})?$/).optional() });
 
 // ../../packages/contracts/dist/versions/changelog-v1.js
 var items = external_exports.array(external_exports.string().min(1));
@@ -24862,6 +24920,7 @@ var messages_default2 = {
   "server.apiNotFound": "API\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
   "server.sessionChanged": "\uC11C\uBC84 \uC138\uC158\uC774 \uBCC0\uACBD\uB410\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uC5F0\uACB0\uD558\uC138\uC694.",
   "server.badRange": "\uC870\uD68C \uBC94\uC704\uB97C \uD655\uC778\uD558\uC138\uC694.",
+  "server.changeNotFound": "\uADF8 \uCEE4\uBC0B\uC5D0 \uD574\uB2F9 \uBCC0\uACBD\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
   "server.specsUnreadable": "\uBA85\uC138\uB97C \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
   "server.refreshOrigin": "\uC0C8\uB85C\uACE0\uCE68\uC5D0\uB294 \uAC19\uC740 \uCD9C\uCC98\uC758 Origin\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.",
   "server.fileNotFound": "\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
@@ -24934,7 +24993,6 @@ var messages_default2 = {
   "agentBlock.duplicateStart": "GITIFACT \uC2DC\uC791 \uB9C8\uCEE4\uAC00 \uC5EC\uB7EC \uAC1C\uC785\uB2C8\uB2E4. \uC911\uBCF5 \uBE14\uB85D\uC744 \uC815\uB9AC\uD55C \uB4A4 \uB2E4\uC2DC \uC2E4\uD589\uD558\uC138\uC694.",
   "specReader.headUnreadable": "HEAD\uB97C \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
   "specReader.schemaRequired": "\uC0C8 \uC2A4\uD0A4\uB9C8 \uD504\uB85C\uC81D\uD2B8\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.",
-  "specReader.historyChanged": "\uC774\uB825\uC774 \uBC14\uB00C\uC5C8\uC2B5\uB2C8\uB2E4. \uC0C8\uB85C\uACE0\uCE68 \uD6C4 \uB2E4\uC2DC \uC870\uD68C\uD558\uC138\uC694.",
   "specReader.authorUnreadable": "Git \uC791\uC131\uC790\uB97C \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
   "specReader.historyUnreadable": "Git \uC774\uB825 \uD615\uC2DD\uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
   "specReader.projectChanged": "\uC870\uD68C \uC911 \uD504\uB85C\uC81D\uD2B8\uAC00 \uBC14\uB00C\uC5C8\uC2B5\uB2C8\uB2E4. \uC0C8\uB85C\uACE0\uCE68\uD558\uC138\uC694.",
@@ -24954,7 +25012,6 @@ var messages_default2 = {
   "help.browserNoUpdateCheck": "\uC0C8 \uBC84\uC804 \uD655\uC778\uC744 \uC704\uD55C npm \uB808\uC9C0\uC2A4\uD2B8\uB9AC \uC870\uD68C\uB97C \uB054 (GITIFACT_NO_UPDATE_CHECK\uC640 \uAC19\uC74C)",
   "help.updateCommit": "\uAC31\uC2E0\uD55C GITIFACT \uBE14\uB85D\uC774 HEAD\uC640 \uBE14\uB85D \uC548\uC5D0\uC11C\uB9CC \uB2E4\uB974\uBA74 \uADF8 \uD30C\uC77C\uB9CC \uACE0\uC815 \uBA54\uC2DC\uC9C0\uB85C \uCEE4\uBC0B",
   "help.update": "\uC0C8 \uBC84\uC804 \uD655\uC778\uACFC \uC124\uCE58 \uBC29\uBC95 \uC548\uB0B4, \uD504\uB85C\uC81D\uD2B8 \uC9C0\uCE68 \uD30C\uC77C\uC758 GITIFACT \uBE14\uB85D\uC744 \uD604\uC7AC \uBC84\uC804\uC73C\uB85C \uAC31\uC2E0",
-  "server.badLanguage": "\uC5B8\uC5B4 \uCF54\uB4DC\uB97C \uD655\uC778\uD558\uC138\uC694.",
   "server.changelogNotFound": "\uD328\uCE58\uB178\uD2B8\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
   "server.changelogUnreadable": "\uD328\uCE58\uB178\uD2B8\uB97C \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
   "update.text.current": "\uD604\uC7AC \uBC84\uC804: {version}",
@@ -25056,43 +25113,7 @@ async function runStatus(format) {
 import { createServer } from "node:http";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { lstat as lstat4, readFile as readFile4 } from "node:fs/promises";
-import { join as join5 } from "node:path";
-
-// src/server/assets.ts
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-async function loadBrowserAssets(directory) {
-  const assets = /* @__PURE__ */ new Map();
-  async function walk(current, prefix) {
-    for (const entry2 of await readdir(current, { withFileTypes: true })) {
-      if (entry2.isSymbolicLink()) throw new Error(t2("browser.assetSymlink"));
-      const name = prefix + entry2.name;
-      if (entry2.isDirectory()) await walk(join(current, entry2.name), name + "/");
-      else if (entry2.isFile()) assets.set("/" + name, await readFile(join(current, entry2.name)));
-    }
-  }
-  try {
-    await walk(directory, "");
-    if (!assets.has("/index.html")) throw new Error("missing index");
-  } catch {
-    throw new Error(t2("browser.assetsUnreadable"));
-  }
-  return assets;
-}
-function contentType(path3) {
-  if (path3.endsWith(".html")) return "text/html; charset=utf-8";
-  if (path3.endsWith(".js")) return "text/javascript; charset=utf-8";
-  if (path3.endsWith(".css")) return "text/css; charset=utf-8";
-  if (path3.endsWith(".svg")) return "image/svg+xml";
-  if (path3.endsWith(".woff2")) return "font/woff2";
-  if (path3.endsWith(".png")) return "image/png";
-  if (/\.jpe?g$/.test(path3)) return "image/jpeg";
-  if (path3.endsWith(".gif")) return "image/gif";
-  if (path3.endsWith(".webp")) return "image/webp";
-  if (path3.endsWith(".pdf")) return "application/pdf";
-  return "application/octet-stream";
-}
+import { readFile as readFile5 } from "node:fs/promises";
 
 // src/server/status-session.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -25180,6 +25201,172 @@ function createStatusSession(initial, read, cliVersion = "0.0.0") {
   };
 }
 
+// src/server/http/respond.ts
+var HttpError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function json2(response, status, value) {
+  response.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
+  response.end(JSON.stringify(value) + "\n");
+}
+function fail4(response, status, code, message) {
+  json2(response, status, browserHttpErrorV1.parse({ contract: "browser-http-error", version: 1, error: { code, message } }));
+}
+
+// src/server/http/guard.ts
+function admit(request, response, origin, dev) {
+  response.setHeader("X-Content-Type-Options", "nosniff");
+  response.setHeader("X-Frame-Options", "DENY");
+  response.setHeader("Referrer-Policy", "no-referrer");
+  response.setHeader("Content-Security-Policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'");
+  if (request.headers.host !== new URL(origin).host) {
+    fail4(response, 403, "FORBIDDEN", t2("server.forbiddenHost"));
+    return;
+  }
+  const requestOrigin = request.headers.origin;
+  const allowedOrigin = requestOrigin === origin || dev && requestOrigin === "http://127.0.0.1:5173";
+  if (requestOrigin && !allowedOrigin) {
+    fail4(response, 403, "FORBIDDEN", t2("server.forbiddenOrigin"));
+    return;
+  }
+  const raw = request.url ?? "/";
+  if (!raw.startsWith("/") || raw.startsWith("//") || raw.includes("\\")) {
+    fail4(response, 400, "BAD_REQUEST", t2("server.badPath"));
+    return;
+  }
+  let url2;
+  let path3;
+  try {
+    url2 = new URL(raw, origin);
+    path3 = decodeURIComponent(url2.pathname);
+  } catch {
+    fail4(response, 400, "BAD_REQUEST", t2("server.badPath"));
+    return;
+  }
+  if (path3.includes("\0") || path3.includes("\\") || path3.split("/").some((part) => part === ".." || part === ".")) {
+    fail4(response, 400, "BAD_REQUEST", t2("server.badPath"));
+    return;
+  }
+  if (request.headers["transfer-encoding"] || request.headers["content-length"] && request.headers["content-length"] !== "0") {
+    request.resume();
+    fail4(response, 400, "BAD_REQUEST", t2("server.noBody"));
+    return;
+  }
+  const api = path3 === "/api" || path3.startsWith("/api/");
+  if (api && request.headers["sec-fetch-site"] === "cross-site" && !allowedOrigin) {
+    fail4(response, 403, "FORBIDDEN", t2("server.crossSite"));
+    return;
+  }
+  return { url: url2, path: path3, api, allowedOrigin: !!allowedOrigin };
+}
+
+// src/server/http/router.ts
+var route = (value) => value;
+var ok = (body) => ({ status: 200, body });
+var matches = (route2, path3) => route2.path.endsWith("/*") ? path3.startsWith(route2.path.slice(0, -1)) : route2.path === path3;
+async function dispatch(routes, sessionId, url2, path3, request, response, allowedOrigin) {
+  const candidates2 = routes.filter((r) => matches(r, path3));
+  if (!candidates2.length) return fail4(response, 404, "NOT_FOUND", t2("server.apiNotFound"));
+  const found = candidates2.find((r) => r.method === request.method);
+  if (!found) {
+    response.setHeader("Allow", candidates2.map((r) => r.method).join(", "));
+    return fail4(response, 405, "METHOD_NOT_ALLOWED", t2("server.methodNotAllowed"));
+  }
+  let query = {};
+  if (found.query) {
+    const keys2 = [...url2.searchParams.keys()];
+    if (new Set(keys2).size !== keys2.length) return fail4(response, 400, "BAD_REQUEST", t2("server.badRange"));
+    const parsed = found.query.safeParse(Object.fromEntries(url2.searchParams));
+    if (!parsed.success) return fail4(response, 400, "BAD_REQUEST", t2("server.badRange"));
+    query = parsed.data;
+  } else if (url2.search) return fail4(response, 400, "BAD_REQUEST", t2("server.noQuery"));
+  if (found.session && request.headers["x-gitifact-session"] !== sessionId) return fail4(response, 409, "SESSION_CHANGED", t2("server.sessionChanged"));
+  try {
+    const reply = await found.handle({ query, path: path3, request, response, allowedOrigin });
+    if (reply && !response.destroyed) json2(response, reply.status, reply.body);
+  } catch (error62) {
+    if (error62 instanceof HttpError) return fail4(response, error62.status, error62.code, error62.message);
+    fail4(response, 503, "INTERNAL_ERROR", error62 instanceof Error && error62.message ? error62.message : found.unreadable ?? t2("server.internal"));
+  }
+}
+
+// src/server/http/static-files.ts
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function loadBrowserAssets(directory) {
+  const assets = /* @__PURE__ */ new Map();
+  async function walk(current, prefix) {
+    for (const entry2 of await readdir(current, { withFileTypes: true })) {
+      if (entry2.isSymbolicLink()) throw new Error(t2("browser.assetSymlink"));
+      const name = prefix + entry2.name;
+      if (entry2.isDirectory()) await walk(join(current, entry2.name), name + "/");
+      else if (entry2.isFile()) assets.set("/" + name, await readFile(join(current, entry2.name)));
+    }
+  }
+  try {
+    await walk(directory, "");
+    if (!assets.has("/index.html")) throw new Error("missing index");
+  } catch {
+    throw new Error(t2("browser.assetsUnreadable"));
+  }
+  return assets;
+}
+function contentType(path3) {
+  if (path3.endsWith(".html")) return "text/html; charset=utf-8";
+  if (path3.endsWith(".js")) return "text/javascript; charset=utf-8";
+  if (path3.endsWith(".css")) return "text/css; charset=utf-8";
+  if (path3.endsWith(".svg")) return "image/svg+xml";
+  if (path3.endsWith(".woff2")) return "font/woff2";
+  if (path3.endsWith(".png")) return "image/png";
+  if (/\.jpe?g$/.test(path3)) return "image/jpeg";
+  if (path3.endsWith(".gif")) return "image/gif";
+  if (path3.endsWith(".webp")) return "image/webp";
+  if (path3.endsWith(".pdf")) return "application/pdf";
+  return "application/octet-stream";
+}
+function serveStatic(request, response, path3, assets) {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    response.setHeader("Allow", "GET, HEAD");
+    return fail4(response, 405, "METHOD_NOT_ALLOWED", t2("server.methodNotAllowed"));
+  }
+  let assetPath = path3 === "/" ? "/index.html" : path3;
+  let asset = assets.get(assetPath);
+  if (!asset && !path3.startsWith("/assets/") && !path3.split("/").some((part) => part.includes(".")) && request.headers.accept?.includes("text/html")) {
+    asset = assets.get("/index.html");
+    assetPath = "/index.html";
+  }
+  if (!asset) return fail4(response, 404, "NOT_FOUND", t2("server.fileNotFound"));
+  response.writeHead(200, { "Content-Type": contentType(assetPath), "Cache-Control": "no-cache", "Content-Length": asset.length });
+  response.end(request.method === "HEAD" ? void 0 : asset);
+}
+
+// src/server/routes/project-routes.ts
+function projectRoutes(store, readChangelog) {
+  return [
+    // Re-reading the session never contacts the registry; it returns the state the single startup check left.
+    route({ method: "GET", path: "/api/v1/session", session: false, handle: () => ok(store.session) }),
+    route({ method: "GET", path: "/api/v1/status", session: true, handle: () => ({ status: store.latest.ok ? 200 : 503, body: store.latest }) }),
+    route({ method: "POST", path: "/api/v1/status/refresh", session: true, handle: async ({ allowedOrigin }) => {
+      if (!allowedOrigin) throw new HttpError(403, "FORBIDDEN", t2("server.refreshOrigin"));
+      const value = await store.refresh();
+      return { status: value.ok ? 200 : 503, body: value };
+    } }),
+    route({ method: "GET", path: "/api/v1/changelog", session: true, query: changelogQueryV1, unreadable: t2("server.changelogUnreadable"), handle: async ({ query }) => {
+      const language = query.lang ?? defaultLanguage2;
+      const own2 = await readChangelog(language);
+      const text2 = own2 ?? (language === defaultLanguage2 ? null : await readChangelog(defaultLanguage2));
+      if (text2 === null) throw new HttpError(404, "NOT_FOUND", t2("server.changelogNotFound"));
+      return ok(changelogV1.parse({ contract: "changelog", version: 1, language: own2 === null ? defaultLanguage2 : language, fallback: own2 === null, entries: parseChangelog(text2) }));
+    } })
+  ];
+}
+
 // src/adapters/git/command-scope.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var storage = new AsyncLocalStorage();
@@ -25222,19 +25409,24 @@ function specPreviewReader(cwd) {
     }
   };
   return {
+    /** Git under the same guarded environment, for readers that shape their own commands (the browser's history). */
+    run(args, input2) {
+      return git(args, input2);
+    },
+    decode: decode5,
     async index() {
       const output2 = decode5(await git(["ls-files", "--stage", "-z", "--", ...RECORD_PATHSPECS]));
       const files = /* @__PURE__ */ new Map();
       for (const row of output2.split("\0").filter(Boolean)) {
         const match = /^(\d+) ([a-f0-9]+) ([0-3])\t([\s\S]+)$/.exec(row);
         if (!match) throw new SpecPreviewError(t2("reader.invalidIndexEntry"));
-        const [, mode, oid2, stage, path3] = match;
+        const [, mode, oid3, stage, path3] = match;
         if (!["100644", "100755"].includes(mode) || stage !== "0") throw new SpecPreviewError(t2("reader.stagingConflictOrLink"));
         if (!recordPathPattern.test(path3)) {
           if (path3.startsWith(WIKI_DIR + "/")) continue;
           throw new SpecPreviewError(t2("reader.stagingUnsupported"));
         }
-        files.set(path3, oid2);
+        files.set(path3, oid3);
       }
       return files;
     },
@@ -25267,12 +25459,12 @@ function specPreviewReader(cwd) {
       });
     },
     async resolve(ref) {
-      const oid2 = (await git(["rev-parse", "--verify", "--end-of-options", ref + "^{commit}"])).toString("ascii").trim();
-      if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(oid2)) throw new SpecPreviewError(t2("reader.commitUnknown"));
-      return oid2;
+      const oid3 = (await git(["rev-parse", "--verify", "--end-of-options", ref + "^{commit}"])).toString("ascii").trim();
+      if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(oid3)) throw new SpecPreviewError(t2("reader.commitUnknown"));
+      return oid3;
     },
-    async files(oid2, allowLegacyBaseline = false) {
-      const entries = decode5(await git(["ls-tree", "--full-tree", "-r", "-z", oid2, "--", ...RECORD_PATHSPECS]));
+    async files(oid3, allowLegacyBaseline = false) {
+      const entries = decode5(await git(["ls-tree", "--full-tree", "-r", "-z", oid3, "--", ...RECORD_PATHSPECS]));
       const files = /* @__PURE__ */ new Map();
       let legacy;
       for (const row of entries.split("\0").filter(Boolean)) {
@@ -25292,7 +25484,7 @@ function specPreviewReader(cwd) {
       if (new Set([...files.keys()].map((p) => p.split("/")[0])).size > 1) throw new SpecPreviewError(t2("reader.mixedStores"));
       if (legacy) {
         if (files.size) throw new SpecPreviewError(t2("reader.mixedFormats"));
-        parseProjectConfig(decode5(await git(["show", `${oid2}:${legacy}/config.json`])));
+        parseProjectConfig(decode5(await git(["show", `${oid3}:${legacy}/config.json`])));
       }
       if (files.size > 2e3) throw new SpecPreviewError(t2("reader.fileLimit"));
       const blobs = /* @__PURE__ */ new Map();
@@ -25316,12 +25508,12 @@ function specPreviewReader(cwd) {
       }
       return new Map([...files].map(([path3, id]) => [path3, blobs.get(id)]));
     },
-    async read(oid2) {
-      const files = await this.files(oid2);
+    async read(oid3) {
+      const files = await this.files(oid3);
       return parsePreviewFiles(files);
     },
-    async readBundle(oid2) {
-      return parsePreviewBundle(await this.files(oid2));
+    async readBundle(oid3) {
+      return parsePreviewBundle(await this.files(oid3));
     }
   };
 }
@@ -25455,7 +25647,7 @@ async function publishConfig(root, text2, recheck, beforePublish, replace = fals
 }
 
 // src/adapters/filesystem/spec-preview-store.ts
-var fail4 = (message) => {
+var fail5 = (message) => {
   throw new SpecPreviewError(message);
 };
 var info2 = async (path3) => lstat3(path3).catch((e) => {
@@ -25465,7 +25657,7 @@ var info2 = async (path3) => lstat3(path3).catch((e) => {
 var digest = (value) => createHash2("sha256").update(value).digest("hex");
 var LEGACY_LOCKS = ["tryce-spec-preview.lock", "tryce-spec-commit.lock"];
 async function failOnLegacyLock(gitDir) {
-  for (const name of LEGACY_LOCKS) if (await info2(join4(gitDir, name))) fail4(t2("store.legacyLock", { path: join4(gitDir, name) }));
+  for (const name of LEGACY_LOCKS) if (await info2(join4(gitDir, name))) fail5(t2("store.legacyLock", { path: join4(gitDir, name) }));
 }
 var decode3 = (bytes) => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
 var generatePreviewId = (prefix) => prefix + "-" + [...randomBytes(10)].map((n) => "abcdefghijklmnopqrstuvwxyz234567"[n & 31]).join("");
@@ -25473,29 +25665,29 @@ var PreservedPreviewError = class extends SpecPreviewError {
 };
 async function snapshot2(root) {
   const files = /* @__PURE__ */ new Map();
-  let count = 0;
+  let count2 = 0;
   let bytes = 0;
   const parent = await info2(join4(root, ".gitifact"));
-  if (parent && (!parent.isDirectory() || parent.isSymbolicLink())) fail4(t2("store.storeNotDirectory"));
-  if (!parent && await info2(join4(root, ".tryce"))) fail4(t2("store.migrateFirst"));
+  if (parent && (!parent.isDirectory() || parent.isSymbolicLink())) fail5(t2("store.storeNotDirectory"));
+  if (!parent && await info2(join4(root, ".tryce"))) fail5(t2("store.migrateFirst"));
   const config2 = await readConfigFile(root);
-  if (config2 !== void 0 && !("schemaVersion" in parseManagedConfig(config2)) || await info2(join4(root, "specs"))) fail4(t2("store.legacyProject"));
+  if (config2 !== void 0 && !("schemaVersion" in parseManagedConfig(config2)) || await info2(join4(root, "specs"))) fail5(t2("store.legacyProject"));
   async function visit2(path3, depth, documents) {
     const stat3 = await info2(join4(root, path3));
     if (!stat3) return;
-    if (stat3.isSymbolicLink() || !stat3.isDirectory() && !stat3.isFile()) fail4(t2("store.linkOrSpecial", { path: path3 }));
-    if (++count > 4e3) fail4(t2("store.tooManyFiles"));
+    if (stat3.isSymbolicLink() || !stat3.isDirectory() && !stat3.isFile()) fail5(t2("store.linkOrSpecial", { path: path3 }));
+    if (++count2 > 4e3) fail5(t2("store.tooManyFiles"));
     if (stat3.isDirectory()) {
-      if (depth > (documents ? 8 : 1)) fail4(t2("store.tooDeep", { path: path3 }));
+      if (depth > (documents ? 8 : 1)) fail5(t2("store.tooDeep", { path: path3 }));
       for (const name of (await readdir3(join4(root, path3))).sort()) await visit2(path3 + "/" + name, depth + 1, documents);
     } else {
-      if (path3.endsWith("/tryce.json")) fail4(t2("store.legacyJson"));
+      if (path3.endsWith("/tryce.json")) fail5(t2("store.legacyJson"));
       if (documents ? !(path3.endsWith(".md") || depth === 1 && path3.endsWith("/history.jsonl")) : !/\/(requirements\.md|design\.md|history\.jsonl)$/.test(path3)) return;
-      if (!recordPathPattern.test(path3) || path3.startsWith(".tryce/")) fail4(t2("store.unsupportedPath", { path: path3 }));
-      if (stat3.nlink !== 1 || stat3.size > 1024 * 1024) fail4(t2("store.hardLinkOrSize"));
+      if (!recordPathPattern.test(path3) || path3.startsWith(".tryce/")) fail5(t2("store.unsupportedPath", { path: path3 }));
+      if (stat3.nlink !== 1 || stat3.size > 1024 * 1024) fail5(t2("store.hardLinkOrSize"));
       const raw = await readFile3(join4(root, path3));
       bytes += raw.length;
-      if (raw.length > 1024 * 1024 || bytes > 16 * 1024 * 1024) fail4(t2("store.sizeLimit"));
+      if (raw.length > 1024 * 1024 || bytes > 16 * 1024 * 1024) fail5(t2("store.sizeLimit"));
       files.set(path3, decode3(raw));
     }
   }
@@ -25507,11 +25699,11 @@ async function snapshot2(root) {
 async function readWorkingPreviewState(cwd) {
   const { root, gitDir } = await specPreviewReader(cwd).location();
   await failOnLegacyLock(gitDir);
-  if (await info2(join4(gitDir, "gitifact-spec-preview.lock"))) fail4(t2("store.locked"));
+  if (await info2(join4(gitDir, "gitifact-spec-preview.lock"))) fail5(t2("store.locked"));
   const first = await snapshot2(root);
   const second = await snapshot2(root);
-  if (first.stamp !== second.stamp) fail4(t2("store.changedWhileReading"));
-  if (await info2(join4(gitDir, "gitifact-spec-preview.lock"))) fail4(t2("store.lockedWhileReading"));
+  if (first.stamp !== second.stamp) fail5(t2("store.changedWhileReading"));
+  if (await info2(join4(gitDir, "gitifact-spec-preview.lock"))) fail5(t2("store.lockedWhileReading"));
   return first;
 }
 async function readWorkingPreview(cwd) {
@@ -25519,9 +25711,9 @@ async function readWorkingPreview(cwd) {
   return { stamp, specs, wiki, warnings: await workingWarnings(root, bundle) };
 }
 async function saveWorkingPreview(cwd, input2, publish = rename2) {
-  if (!input2 || typeof input2 !== "object" || Array.isArray(input2)) fail4(t2("store.invalidInput"));
+  if (!input2 || typeof input2 !== "object" || Array.isArray(input2)) fail5(t2("store.invalidInput"));
   const request = input2;
-  if (Object.keys(request).sort().join(",") !== "expected,operations" || typeof request.expected !== "string") fail4(t2("store.expectedOperations"));
+  if (Object.keys(request).sort().join(",") !== "expected,operations" || typeof request.expected !== "string") fail5(t2("store.expectedOperations"));
   return previewTransaction(cwd, request.expected, async (before) => {
     const result = editSpecPreview(before.bundle, request.operations, generatePreviewId);
     const writes = /* @__PURE__ */ new Map();
@@ -25549,7 +25741,7 @@ async function previewTransaction(cwd, expected2, build, publish = rename2, afte
   try {
     await mkdir2(lock);
   } catch (e) {
-    if (e.code === "EEXIST") fail4(t2("store.locked"));
+    if (e.code === "EEXIST") fail5(t2("store.locked"));
     throw e;
   }
   const createdDirs = [];
@@ -25560,7 +25752,7 @@ async function previewTransaction(cwd, expected2, build, publish = rename2, afte
   async function directory(path3) {
     const stat3 = await info2(path3);
     if (stat3) {
-      if (!stat3.isDirectory() || stat3.isSymbolicLink()) fail4(t2("store.notDirectory", { path: path3 }));
+      if (!stat3.isDirectory() || stat3.isSymbolicLink()) fail5(t2("store.notDirectory", { path: path3 }));
       return;
     }
     await directory(dirname(path3));
@@ -25569,11 +25761,11 @@ async function previewTransaction(cwd, expected2, build, publish = rename2, afte
   }
   try {
     const before = await snapshot2(root);
-    if (before.stamp !== expected2) fail4(t2("store.staleExpected"));
+    if (before.stamp !== expected2) fail5(t2("store.staleExpected"));
     const result = await build(before);
     for (const [path3, after2] of result.writes) {
-      if (!recordPathPattern.test(path3) || path3.startsWith(".tryce/") || path3.split("/").some((p) => p === ".." || p === "." || /[\\:\0]/.test(p))) fail4(t2("store.unsupportedSavePath"));
-      if (after2 !== null && Buffer.byteLength(after2) > 1024 * 1024) fail4(t2("store.fileSizeLimit"));
+      if (!recordPathPattern.test(path3) || path3.startsWith(".tryce/") || path3.split("/").some((p) => p === ".." || p === "." || /[\\:\0]/.test(p))) fail5(t2("store.unsupportedSavePath"));
+      if (after2 !== null && Buffer.byteLength(after2) > 1024 * 1024) fail5(t2("store.fileSizeLimit"));
       changed.push({ path: path3, before: before.files.get(path3) ?? null, after: after2 });
     }
     const finalFiles = new Map(before.files);
@@ -25581,7 +25773,7 @@ async function previewTransaction(cwd, expected2, build, publish = rename2, afte
       if (c.after === null) finalFiles.delete(c.path);
       else finalFiles.set(c.path, c.after);
     }
-    if (finalFiles.size > 2e3 || [...finalFiles.values()].reduce((n, s) => n + Buffer.byteLength(s), 0) > 16 * 1024 * 1024) fail4(t2("store.totalLimit"));
+    if (finalFiles.size > 2e3 || [...finalFiles.values()].reduce((n, s) => n + Buffer.byteLength(s), 0) > 16 * 1024 * 1024) fail5(t2("store.totalLimit"));
     await writeFile(join4(lock, "recovery.json"), JSON.stringify({ root, changed }), { flag: "wx" });
     for (const c of changed) {
       if (c.after === null) {
@@ -25593,19 +25785,19 @@ async function previewTransaction(cwd, expected2, build, publish = rename2, afte
       await writeFile(temp, c.after, { flag: "wx" });
       temporary.push(temp);
     }
-    if ((await snapshot2(root)).stamp !== before.stamp) fail4(t2("store.changedPreparing"));
+    if ((await snapshot2(root)).stamp !== before.stamp) fail5(t2("store.changedPreparing"));
     await result.recheck?.();
     for (let i = 0; i < changed.length; i++) {
       const c = changed[i];
       const path3 = join4(root, c.path);
       const stat3 = await info2(path3);
-      if (stat3?.isSymbolicLink() || stat3 && !stat3.isFile() || (stat3 ? decode3(await readFile3(path3)) : null) !== c.before) fail4(t2("store.changedBeforeWrite"));
+      if (stat3?.isSymbolicLink() || stat3 && !stat3.isFile() || (stat3 ? decode3(await readFile3(path3)) : null) !== c.before) fail5(t2("store.changedBeforeWrite"));
       if (c.after === null) await unlink2(path3);
       else await publish(temporary[i], path3);
       published.push(c);
     }
     const after = await snapshot2(root);
-    if (after.stamp !== digest(JSON.stringify([...finalFiles].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) + (before.config ?? ""))) fail4(t2("store.changedWhileWriting"));
+    if (after.stamp !== digest(JSON.stringify([...finalFiles].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) + (before.config ?? ""))) fail5(t2("store.changedWhileWriting"));
     await result.recheck?.();
     await afterPublish?.(after);
     return { ...result.data, stamp: after.stamp, paths: changed.map((c) => c.path), specs: after.specs, wiki: after.wiki, warnings: await workingWarnings(root, after.bundle) };
@@ -25633,7 +25825,7 @@ async function previewTransaction(cwd, expected2, build, publish = rename2, afte
         keepRecovery = true;
       }
     }
-    if (keepRecovery) fail4(t2("store.recoveryIncomplete", { path: lock }));
+    if (keepRecovery) fail5(t2("store.recoveryIncomplete", { path: lock }));
     throw error62;
   } finally {
     for (const path3 of temporary.filter(Boolean)) await unlink2(path3).catch((e) => {
@@ -25650,144 +25842,686 @@ async function previewTransaction(cwd, expected2, build, publish = rename2, afte
   }
 }
 
-// src/server/spec-reader.ts
-function createSpecBrowserReader(root, sessionId, inherited = process.env) {
+// src/server/checkout/checkout-reader.ts
+var tally = (people, name, email3, latest) => {
+  const person = people.get(email3);
+  if (person) person.commits++;
+  else people.set(email3, { name, email: email3, latest, commits: 1 });
+};
+async function settled(reads) {
+  const results = await Promise.allSettled(reads);
+  const failure2 = results.find((r) => r.status === "rejected");
+  if (failure2) throw failure2.reason;
+  return results.map((r) => r.value);
+}
+function createCheckoutReader(root, sessionId, inherited = process.env) {
   const reader = specPreviewReader(root);
   const runner = createGitRunner();
   const env = { ...inherited, GIT_OPTIONAL_LOCKS: "0", GIT_NO_REPLACE_OBJECTS: "1", GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" };
-  const git = async (args, acceptedExitCodes = [0]) => (await runner(["--no-optional-locks", ...args], { cwd: root, env, timeoutMs: 15e3, maxBytes: 16 * 1024 * 1024, acceptedExitCodes })).toString("utf8");
+  const git = async (args, acceptedExitCodes = [0]) => (await runner(["--no-optional-locks", ...args], { cwd: root, env, timeoutMs: 15e3, maxBytes: 32 * 1024 * 1024, acceptedExitCodes })).toString("utf8");
   const readHead = async () => {
     const head = (await git(["rev-parse", "--verify", "--quiet", "HEAD"], [0, 1])).trim();
     if (head && !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(head)) throw new SpecPreviewError(t2("specReader.headUnreadable"));
     if (!head) await reader.baseline();
     return head || null;
   };
-  const snapshots = /* @__PURE__ */ new Map();
-  const snapshot3 = (oid2) => {
-    let value = snapshots.get(oid2);
-    if (!value) {
-      value = reader.readBundle(oid2).catch((e) => {
-        snapshots.delete(oid2);
-        throw e;
-      });
-      snapshots.set(oid2, value);
-    }
-    if (snapshots.size > 128) snapshots.delete(snapshots.keys().next().value);
-    return value;
-  };
-  let peopleCache;
   const pending = /* @__PURE__ */ new Map();
-  async function read(cursor, expectedHead) {
+  async function storeAuthors(head) {
+    const text2 = await git(["log", "--format=%x1e%aN%x00%aE%x00%aI", "-z", "--name-only", "--no-renames", "--max-count=20000", head, "--", ".gitifact", ".tryce"]);
+    const folders = /* @__PURE__ */ new Map();
+    const pages = /* @__PURE__ */ new Map();
+    for (const chunk of text2.split("")) {
+      if (!chunk) continue;
+      const [name, email3, date5, ...paths2] = chunk.split("\0");
+      if (!name || !email3 || !date5) throw new SpecPreviewError(t2("specReader.authorUnreadable"));
+      const seen = /* @__PURE__ */ new Set();
+      for (const raw of paths2) {
+        const path3 = raw.replace(/^\n/, "");
+        if (!path3) continue;
+        const folder = /^\.(?:gitifact|tryce)\/(spec\/[^/]+)\//.exec(path3)?.[1];
+        if (folder && !seen.has(folder)) {
+          seen.add(folder);
+          let entry2 = folders.get(folder);
+          if (!entry2) folders.set(folder, entry2 = { people: /* @__PURE__ */ new Map(), count: 0, latest: date5 });
+          if (entry2.count < 2e3) {
+            entry2.count++;
+            tally(entry2.people, name, email3, date5);
+          }
+        }
+        if (path3.startsWith(WIKI_DIR + "/") && !pages.has(path3)) pages.set(path3, date5);
+      }
+    }
+    return { folders, pages };
+  }
+  async function read() {
     const raw = await readConfigFile(root);
     if (!raw || !("schemaVersion" in parseManagedConfig(raw))) throw new SpecPreviewError(t2("specReader.schemaRequired"));
-    const base = { head: await readHead() };
-    if (cursor > 0 && expectedHead !== base.head) throw new SpecPreviewError(t2("specReader.historyChanged"));
-    const current = await readWorkingPreviewState(root);
-    const bare = current.specs.map(({ history: _history, ...s }) => ({ ...s, contributors: [], updatedAt: null }));
-    const bareDocuments = current.wiki.documents.map((d) => ({ ...d, updatedAt: null }));
-    if (!base.head) return browserSpecsV3.parse({ contract: "browser-specs", version: 3, sessionId, head: null, observedAt: (/* @__PURE__ */ new Date()).toISOString(), working: bare.length > 0 || bareDocuments.length > 0, features: bare, documents: bareDocuments, events: [], contributors: [], contributorsLimited: false, nextCursor: null, boundary: false });
-    const head = base.head;
-    const first = cursor === 0;
-    const features = !first ? void 0 : await Promise.all(bare.map(async (feature2) => {
-      const folder = feature2.path.replace(/^\.(?:gitifact|tryce)\/(spec\/[^/]+)\/requirements\.md$/, "$1");
-      const lines = (await git(["log", "--format=%aN%x00%aE%x00%aI", "--max-count=2000", head, "--", `.gitifact/${folder}`, `.tryce/${folder}`])).trim().split("\n").filter(Boolean);
-      const people = /* @__PURE__ */ new Map();
-      for (const line of lines) {
-        const [name, email3, latest] = line.split("\0");
-        if (!name || !email3 || !latest) throw new SpecPreviewError(t2("specReader.authorUnreadable"));
-        const person = people.get(email3);
-        if (person) person.commits++;
-        else people.set(email3, { name, email: email3, latest, commits: 1 });
-      }
-      return { ...feature2, contributors: [...people.values()].sort((a, b) => b.commits - a.commits), updatedAt: lines[0]?.split("\0")[2] ?? null };
-    }));
-    const documents = !first ? void 0 : await Promise.all(bareDocuments.map(async (doc) => ({ ...doc, updatedAt: (await git(["log", "--format=%aI", "--max-count=1", head, "--", doc.path])).trim() || null })));
-    const documentDirs = [WIKI_DIR];
-    const [rows, dirty] = await Promise.all([
-      git([
-        "log",
-        "--first-parent",
-        "--date-order",
-        "--format=%H%x00%P%x00%aN%x00%aE%x00%aI%x00%cN%x00%s",
-        "--max-count=11",
-        "--skip=" + cursor,
-        head,
-        "--",
-        ...[".gitifact", ".tryce"].flatMap((d) => [`:(glob)${d}/spec/*/requirements.md`, `:(glob)${d}/spec/*/design.md`, `:(glob)${d}/spec/*/history.jsonl`]),
-        ...documentDirs.flatMap((d) => [`:(glob)${d}/**/*.md`, `:(glob)${d}/history.jsonl`])
-      ]),
-      first ? git(["status", "--porcelain=v1", "--", ".gitifact/spec", ...documentDirs]) : Promise.resolve("")
+    const head = await readHead();
+    const [current, dirty, authors, everyone] = await settled([
+      readWorkingPreviewState(root),
+      head ? git(["status", "--porcelain=v1", "--", ".gitifact/spec", WIKI_DIR]) : Promise.resolve(""),
+      head ? storeAuthors(head) : Promise.resolve(void 0),
+      // Git mailmap may change without a new HEAD; refresh names with every observation that carries them.
+      head ? git(["log", "--format=%aN%x00%aE%x00%aI", "--max-count=10001", head]) : Promise.resolve("")
     ]);
-    if (first) {
-      const people = /* @__PURE__ */ new Map();
-      const lines = (await git(["log", "--format=%aN%x00%aE%x00%aI", "--max-count=10001", head])).trim().split("\n").filter(Boolean);
-      for (const line of lines.slice(0, 1e4)) {
-        const [name, email3, latest] = line.split("\0");
-        if (!name || !email3 || !latest) throw new SpecPreviewError(t2("specReader.authorUnreadable"));
-        const person = people.get(email3);
-        if (person) person.commits++;
-        else people.set(email3, { name, email: email3, latest, commits: 1 });
-      }
-      peopleCache = { key: head, data: [...people.values()].sort((a, b) => b.commits - a.commits), limited: lines.length > 1e4 };
-    }
-    const commits = rows.trim().split("\n").filter(Boolean);
-    let boundary = false;
-    const groups = await Promise.all(commits.slice(0, 10).map(async (row) => {
-      const [commit, parents, author, email3, date5, committer, message] = row.split("\0");
-      if (!commit || author === void 0 || email3 === void 0 || !date5 || committer === void 0 || message === void 0) throw new SpecPreviewError(t2("specReader.historyUnreadable"));
-      const after = await snapshot3(commit);
-      let before = emptyBundle();
-      const parent = parents?.split(" ")[0];
-      if (parent) {
-        try {
-          before = await snapshot3(parent);
-        } catch (error62) {
-          if (error62 instanceof LegacyBaselineError) boundary = true;
-          else throw error62;
-        }
-      }
-      return comparePreviewBundles(before, after).changes.map((c) => ({
-        key: commit + ":" + c.id,
-        commit,
-        author,
-        email: email3,
-        date: date5,
-        committer,
-        message,
-        id: c.id,
-        kind: c.kind,
-        types: c.types,
-        before: c.before,
-        after: c.after,
-        reasons: c.reasons.map((r) => r.reason)
-      }));
-    }));
-    if (await readHead() !== head || (await readWorkingPreviewState(root)).stamp !== current.stamp) throw new SpecPreviewError(t2("specReader.projectChanged"));
-    return browserSpecsV3.parse({
+    const people = /* @__PURE__ */ new Map();
+    const lines = everyone.trim().split("\n").filter(Boolean);
+    for (const line of lines.slice(0, 1e4)) {
+      const [name, email3, latest] = line.split("\0");
+      if (!name || !email3 || !latest) throw new SpecPreviewError(t2("specReader.authorUnreadable"));
+      tally(people, name, email3, latest);
+    }
+    const features = current.specs.map(({ history: _history, ...feature2 }) => {
+      const entry2 = authors?.folders.get(feature2.path.replace(/^\.(?:gitifact|tryce)\/(spec\/[^/]+)\/requirements\.md$/, "$1"));
+      return { ...feature2, contributors: entry2 ? [...entry2.people.values()].sort((a, b) => b.commits - a.commits) : [], updatedAt: entry2?.latest ?? null };
+    });
+    const documents = current.wiki.documents.map((doc) => ({ ...doc, updatedAt: authors?.pages.get(doc.path) ?? null }));
+    if (await readHead() !== head) throw new SpecPreviewError(t2("specReader.projectChanged"));
+    const checkout = browserSpecsV4.parse({
       contract: "browser-specs",
-      version: 3,
+      version: 4,
       sessionId,
       head,
       observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      events: groups.flat(),
-      nextCursor: commits.length > 10 ? cursor + 10 : null,
-      boundary,
-      ...first ? { working: !!dirty.trim(), features, documents, contributors: peopleCache?.data ?? [], contributorsLimited: peopleCache?.limited ?? false } : {}
+      working: head ? !!dirty.trim() : features.length > 0 || documents.length > 0,
+      features,
+      documents,
+      contributors: [...people.values()].sort((a, b) => b.commits - a.commits),
+      contributorsLimited: lines.length > 1e4
+    });
+    const search = features.flatMap((f) => [
+      { kind: "feature", ref: f.id, title: f.title, where: f.path.replace(/^\.gitifact\//, ""), body: f.description, featureId: f.id },
+      ...f.requirements.map((r) => ({ kind: "requirement", ref: r.id, title: r.title, where: f.title, body: r.body, featureId: f.id })),
+      ...f.design ? [{ kind: "design", ref: f.id + ":design", title: f.design.title, where: f.title, body: f.design.body, featureId: f.id }] : []
+    ]).concat(documents.map((d) => ({ kind: "document", ref: d.id, title: d.title, where: d.path.replace(/^\.gitifact\/wiki\//, ""), body: d.body, documentId: d.id })));
+    return { checkout, stamp: current.stamp, search };
+  }
+  return () => {
+    let value = pending.get("");
+    if (!value) {
+      value = read().finally(() => pending.delete(""));
+      pending.set("", value);
+    }
+    return value;
+  };
+}
+
+// src/server/history/commit-changes.ts
+var HISTORY_PATHSPECS = [
+  ...STORE_DIRS.flatMap((d) => [`:(glob)${d}/spec/*/requirements.md`, `:(glob)${d}/spec/*/design.md`, `:(glob)${d}/spec/*/history.jsonl`]),
+  `:(glob)${WIKI_DIR}/**/*.md`,
+  `:(glob)${WIKI_HISTORY_PATH}`
+];
+var RECORD_ROOTS = [...STORE_DIRS.map((d) => d + "/spec/"), WIKI_DIR + "/"];
+var isLegacy = (path3) => RECORD_ROOTS.some((root) => path3.startsWith(root)) && path3.endsWith("/tryce.json");
+var isZero = (oid3) => /^0+$/.test(oid3);
+var FORMAT = "%x1e%H%x00%P%x00%aN%x00%aE%x00%aI%x00%cN%x00%s";
+var BATCH = 100;
+function createCommitChanges(root, snapshot3) {
+  const reader = specPreviewReader(root);
+  function parseLog(text2) {
+    return text2.split("").filter((chunk) => chunk.length).map((chunk) => {
+      const parts = chunk.split("\0");
+      const [commit, parents, author, email3, date5, committer, message] = parts;
+      if (!commit || parents === void 0 || author === void 0 || email3 === void 0 || !date5 || committer === void 0 || message === void 0) throw new SpecPreviewError(t2("specReader.historyUnreadable"));
+      const entries = [];
+      for (let i = 7; i < parts.length; i++) {
+        const meta3 = parts[i].replace(/^\n/, "");
+        if (!meta3.startsWith(":")) continue;
+        const [, , oldBlob, newBlob] = meta3.split(" ");
+        const path3 = parts[++i];
+        if (!oldBlob || !newBlob || path3 === void 0) throw new SpecPreviewError(t2("specReader.historyUnreadable"));
+        if (recordPathPattern.test(path3) || isLegacy(path3)) entries.push({ oldBlob, newBlob, path: path3 });
+      }
+      return { commit, parent: parents.split(" ")[0] || void 0, author, email: email3, date: date5, committer, message, entries };
+    });
+  }
+  function wanted(entries) {
+    const folders = /* @__PURE__ */ new Set();
+    const pages = /* @__PURE__ */ new Set();
+    for (const { path: path3 } of entries) {
+      if (isLegacy(path3)) continue;
+      if (path3.startsWith(WIKI_DIR + "/")) {
+        pages.add(path3);
+        pages.add(WIKI_HISTORY_PATH);
+        continue;
+      }
+      folders.add(path3.replace(/\/[^/]+$/, ""));
+    }
+    return [...[...folders].flatMap((f) => ["requirements.md", "design.md", "history.jsonl"].map((n) => f + "/" + n)), ...pages];
+  }
+  async function readBlobs(names) {
+    const found = /* @__PURE__ */ new Map();
+    if (!names.length) return found;
+    const output2 = await reader.run(["cat-file", "--batch"], Buffer.from(names.join("\n") + "\n"));
+    let offset = 0;
+    let total = 0;
+    for (const name of names) {
+      const end = output2.indexOf(10, offset);
+      if (end < 0) throw new SpecPreviewError(t2("reader.blobBoundary"));
+      const header = output2.subarray(offset, end).toString("utf8");
+      if (header.endsWith(" missing")) {
+        offset = end + 1;
+        continue;
+      }
+      const [, type, sizeText] = header.split(" ");
+      const size = Number(sizeText);
+      if (type !== "blob" || !Number.isSafeInteger(size) || size < 0 || size > 1024 * 1024 || output2[end + size + 1] !== 10) throw new SpecPreviewError(t2("reader.blobShape"));
+      total += size;
+      if (total > 64 * 1024 * 1024) throw new SpecPreviewError(t2("reader.totalLimit"));
+      found.set(name, reader.decode(output2.subarray(end + 1, end + 1 + size)));
+      offset = end + size + 2;
+    }
+    if (offset !== output2.length) throw new SpecPreviewError(t2("reader.blobBoundary"));
+    return found;
+  }
+  const eventsOf = (c, changes) => changes.map((change2) => ({
+    key: c.commit + ":" + change2.id,
+    commit: c.commit,
+    author: c.author,
+    email: c.email,
+    date: c.date,
+    committer: c.committer,
+    message: c.message,
+    id: change2.id,
+    kind: change2.kind,
+    types: change2.types,
+    before: change2.before,
+    after: change2.after,
+    reasons: change2.reasons.map((r) => r.reason)
+  }));
+  async function wholeStore(c) {
+    const after = await snapshot3(c.commit);
+    let before = emptyBundle();
+    let boundary = false;
+    if (c.parent) {
+      try {
+        before = await snapshot3(c.parent);
+      } catch (error62) {
+        if (error62 instanceof LegacyBaselineError) boundary = true;
+        else throw error62;
+      }
+    }
+    return { commit: c.commit, events: eventsOf(c, comparePreviewBundles(before, after).changes), boundary };
+  }
+  async function batch(commits) {
+    const names = /* @__PURE__ */ new Map();
+    for (const c of commits.filter((c2) => !c2.entries.some((e) => isLegacy(e.path) && !isZero(e.newBlob)))) {
+      const files = wanted(c.entries);
+      const boundary = c.entries.some((e) => isLegacy(e.path) && !isZero(e.oldBlob));
+      names.set(c, { after: files.map((f) => c.commit + ":" + f), before: c.parent && !boundary ? files.map((f) => c.parent + ":" + f) : [], boundary });
+    }
+    let blobs;
+    try {
+      blobs = await readBlobs([...names.values()].flatMap((n) => [...n.before, ...n.after]));
+    } catch {
+      blobs = void 0;
+    }
+    const result = [];
+    for (const c of commits) {
+      let value;
+      const want = names.get(c);
+      if (want && blobs) {
+        try {
+          const side = (list, rev) => new Map(list.filter((name) => blobs.has(name)).map((name) => [name.slice(rev.length + 1), blobs.get(name)]));
+          const after = parsePreviewBundle(side(want.after, c.commit));
+          const before = want.before.length ? parsePreviewBundle(side(want.before, c.parent)) : emptyBundle();
+          value = { commit: c.commit, events: eventsOf(c, comparePreviewBundles(before, after).changes), boundary: want.boundary };
+        } catch {
+          value = void 0;
+        }
+      }
+      result.push(value ?? await wholeStore(c));
+    }
+    return result;
+  }
+  return {
+    /** The commits of `head`'s first-parent history that touched records, newest first. One Git process. */
+    async lineage(head) {
+      const text2 = reader.decode(await reader.run(["rev-list", "--first-parent", head, "--", ...HISTORY_PATHSPECS]));
+      return text2.split("\n").filter(Boolean);
+    },
+    /** The changes of the given commits, in the given order; two Git processes per hundred commits. */
+    async of(commits) {
+      const out = [];
+      for (let i = 0; i < commits.length; i += BATCH) {
+        const slice = commits.slice(i, i + BATCH);
+        const raw = parseLog(reader.decode(await reader.run(
+          ["log", "--stdin", "--no-walk=unsorted", "--diff-merges=first-parent", "--raw", "-z", "--no-renames", "--no-abbrev", `--format=${FORMAT}`],
+          Buffer.from(slice.join("\n") + "\n")
+        )));
+        const byCommit = new Map(raw.map((c) => [c.commit, c]));
+        const missing2 = slice.find((oid3) => !byCommit.has(oid3));
+        if (missing2) throw new SpecPreviewError(t2("specReader.historyUnreadable"));
+        out.push(...await batch(slice.map((oid3) => byCommit.get(oid3))));
+      }
+      return out;
+    }
+  };
+}
+
+// src/server/history/index-database.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdir as mkdir3, rm } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var INDEX_FORMAT = 1;
+var SCHEMA = `
+  -- Commits already read, and whether the commit's parent was legacy JSON the history does not read past.
+  CREATE TABLE commits (oid TEXT PRIMARY KEY, boundary INTEGER NOT NULL);
+  -- One row per change. 'row' is the list shape as JSON; 'detail' the text on both sides.
+  CREATE TABLE changes (
+    key TEXT PRIMARY KEY, oid TEXT NOT NULL, ord INTEGER NOT NULL,
+    id TEXT NOT NULL, kind TEXT NOT NULL, types TEXT NOT NULL, email TEXT NOT NULL, date TEXT NOT NULL,
+    before_spec TEXT, after_spec TEXT, needle TEXT NOT NULL, row TEXT NOT NULL, detail TEXT NOT NULL);
+  CREATE INDEX changes_by_commit ON changes (oid, ord);
+  -- The commits of one HEAD's first-parent history that touched records, newest first (pos 0).
+  CREATE TABLE lineage (head TEXT NOT NULL, pos INTEGER NOT NULL, oid TEXT NOT NULL, PRIMARY KEY (head, pos));
+  CREATE INDEX lineage_by_commit ON lineage (head, oid);
+  CREATE TABLE heads (head TEXT PRIMARY KEY, seen INTEGER NOT NULL);
+  -- Which checkout of which worktree the search rows describe.
+  CREATE TABLE checkouts (scope TEXT PRIMARY KEY, stamp TEXT NOT NULL);
+  -- Everything the search box finds. The searched columns hold lower-cased text; trigram lets LIKE '%...%' use the
+  -- index from three characters on and scan below that. The rest is carried for display and navigation.
+  CREATE VIRTUAL TABLE search USING fts5(
+    scope UNINDEXED, kind UNINDEXED, ref UNINDEXED, oid UNINDEXED, payload UNINDEXED,
+    title, place, body, tokenize = 'trigram');
+`;
+function prepare(db) {
+  db.exec("PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;");
+  const version2 = db.prepare("PRAGMA user_version").get().user_version;
+  if (version2 === INDEX_FORMAT) return;
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    for (const { name, type } of db.prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'search_%'").all()) {
+      db.exec(`DROP ${type === "view" ? "VIEW" : "TABLE"} IF EXISTS "${name}"`);
+    }
+    db.exec(SCHEMA);
+    db.exec(`PRAGMA user_version = ${INDEX_FORMAT}`);
+    db.exec("COMMIT");
+  } catch (error62) {
+    db.exec("ROLLBACK");
+    throw error62;
+  }
+}
+function createIndexDatabase(root) {
+  let path3;
+  let memory;
+  const usable = (file2) => {
+    try {
+      const probe = new DatabaseSync(file2);
+      try {
+        prepare(probe);
+      } finally {
+        probe.close();
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const locate = () => path3 ??= (async () => {
+    try {
+      const git = specPreviewReader(root);
+      const common = git.decode(await git.run(["rev-parse", "--path-format=absolute", "--git-common-dir"])).trim();
+      const folder = join5(common, "gitifact");
+      await mkdir3(folder, { recursive: true });
+      const file2 = join5(folder, "index.sqlite");
+      if (usable(file2)) return file2;
+      for (const leftover of [file2, file2 + "-wal", file2 + "-shm"]) await rm(leftover, { force: true });
+      return usable(file2) ? file2 : void 0;
+    } catch {
+      return void 0;
+    }
+  })();
+  return {
+    /** Runs `use` on an open database. Everything inside is synchronous, so the connection never outlives the call. */
+    async with(use) {
+      const file2 = await locate();
+      if (!file2) {
+        if (!memory) {
+          memory = new DatabaseSync(":memory:");
+          prepare(memory);
+        }
+        return use(memory);
+      }
+      const db = new DatabaseSync(file2);
+      try {
+        prepare(db);
+        return use(db);
+      } finally {
+        db.close();
+      }
+    },
+    /** Where the index is kept, or undefined when it lives in memory. */
+    location: () => locate()
+  };
+}
+function transaction(db, write) {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const value = write();
+    db.exec("COMMIT");
+    return value;
+  } catch (error62) {
+    db.exec("ROLLBACK");
+    throw error62;
+  }
+}
+
+// src/server/history/search-text.ts
+function plain(body) {
+  return body.replace(/```[\s\S]*?```/g, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/^\s*[#>]+\s*/gm, " ").replace(/^\s*[-*+]\s+/gm, " ").replace(/^\s*\|/gm, " ").replace(/\|/g, " ").replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[*_`]/g, "").replace(/\s+/g, " ").trim();
+}
+function snippet(text2, query) {
+  const at = text2.toLowerCase().indexOf(query);
+  if (at < 0) return text2.slice(0, 90);
+  const from = Math.max(0, at - 30);
+  return (from > 0 ? "\u2026" : "") + text2.slice(from, at + query.length + 70).trim() + (at + query.length + 70 < text2.length ? "\u2026" : "");
+}
+var containing = (query) => "%" + query.replace(/[\\%_]/g, (c) => "\\" + c) + "%";
+
+// src/server/history/history-index.ts
+var listed = (e) => {
+  const reference2 = (s) => s ? { id: s.id, title: s.title, specId: s.specId, path: s.path } : null;
+  return { ...e, before: reference2(e.before), after: reference2(e.after) };
+};
+var titleOf = (e) => (e.after ?? e.before)?.title ?? e.id;
+var DAY = 864e5;
+var KEPT_HEADS = 4;
+var RECENT_COMMITS = 3;
+var RECENT_CHANGES = 12;
+function createHistoryIndex(root, snapshot3) {
+  const changes = createCommitChanges(root, snapshot3);
+  const database = createIndexDatabase(root);
+  const building = /* @__PURE__ */ new Map();
+  const built = /* @__PURE__ */ new Set();
+  function insert(db, commits) {
+    const commit = db.prepare("INSERT OR IGNORE INTO commits (oid, boundary) VALUES (?, ?)");
+    const change2 = db.prepare("INSERT OR IGNORE INTO changes (key, oid, ord, id, kind, types, email, date, before_spec, after_spec, needle, row, detail) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)");
+    const search = db.prepare("INSERT INTO search (scope, kind, ref, oid, payload, title, place, body) VALUES (?,?,?,?,?,?,?,?)");
+    transaction(db, () => {
+      for (const c of commits) {
+        if (!Number(commit.run(c.commit, c.boundary ? 1 : 0).changes)) continue;
+        c.events.forEach((e, ord) => {
+          change2.run(
+            e.key,
+            e.commit,
+            ord,
+            e.id,
+            e.kind,
+            e.types.join(","),
+            e.email,
+            e.date,
+            e.before?.specId ?? null,
+            e.after?.specId ?? null,
+            [e.id, e.before?.title ?? "", e.after?.title ?? ""].join(" ").toLowerCase(),
+            JSON.stringify(listed(e)),
+            JSON.stringify({ before: e.before, after: e.after })
+          );
+          const line = e.reasons.length ? e.reasons.join(" \xB7 ") : e.message;
+          const where2 = e.commit.slice(0, 7) + " \xB7 " + e.author;
+          search.run(
+            "history",
+            "history",
+            e.key,
+            e.commit,
+            JSON.stringify({ title: titleOf(e), where: where2, line }),
+            titleOf(e).toLowerCase(),
+            where2.toLowerCase(),
+            [line, e.message, e.id].join(" ").toLowerCase()
+          );
+        });
+      }
     });
   }
-  return (cursor = 0, head) => {
-    const key = `${cursor}:${head ?? ""}`;
-    let value = pending.get(key);
+  async function build(head) {
+    const lineage = await changes.lineage(head);
+    const known = await database.with((db) => new Set(db.prepare("SELECT oid FROM commits").all().map((r) => r.oid)));
+    const missing2 = lineage.filter((oid3) => !known.has(oid3));
+    for (let i = 0; i < missing2.length; i += 100) {
+      const read = await changes.of(missing2.slice(i, i + 100));
+      await database.with((db) => insert(db, read));
+    }
+    await database.with((db) => transaction(db, () => {
+      db.prepare("DELETE FROM lineage WHERE head = ?").run(head);
+      const row = db.prepare("INSERT INTO lineage (head, pos, oid) VALUES (?, ?, ?)");
+      lineage.forEach((oid3, pos) => row.run(head, pos, oid3));
+      db.prepare("INSERT INTO heads (head, seen) VALUES (?, ?) ON CONFLICT (head) DO UPDATE SET seen = excluded.seen").run(head, Date.now());
+      for (const { head: old } of db.prepare("SELECT head FROM heads ORDER BY seen DESC LIMIT -1 OFFSET ?").all(KEPT_HEADS)) {
+        db.prepare("DELETE FROM lineage WHERE head = ?").run(old);
+        db.prepare("DELETE FROM heads WHERE head = ?").run(old);
+      }
+    }));
+  }
+  function ensure(head) {
+    if (built.has(head)) return Promise.resolve();
+    let pending = building.get(head);
+    if (!pending) {
+      pending = build(head).then(() => {
+        built.add(head);
+      }).finally(() => building.delete(head));
+      building.set(head, pending);
+    }
+    return pending;
+  }
+  function where(filter) {
+    const clauses = [];
+    const params = [];
+    if (filter.kind) {
+      clauses.push("instr(',' || c.types || ',', ?) > 0");
+      params.push("," + filter.kind + ",");
+    }
+    if (filter.document) {
+      clauses.push("c.kind = ?");
+      params.push(filter.document);
+    }
+    if (filter.feature) {
+      clauses.push("(c.before_spec = ? OR c.after_spec = ?)");
+      params.push(filter.feature, filter.feature);
+    }
+    if (filter.author) {
+      clauses.push("c.email = ?");
+      params.push(filter.author);
+    }
+    if (filter.q?.trim()) {
+      clauses.push("instr(c.needle, ?) > 0");
+      params.push(filter.q.trim().toLowerCase());
+    }
+    return { sql: clauses.map((c) => " AND " + c).join(""), params };
+  }
+  return {
+    ensure,
+    /** One page of the changes that match, newest first, with how many match in all. */
+    async page(head, filter, offset, limit) {
+      await ensure(head);
+      return database.with((db) => {
+        const { sql, params } = where(filter);
+        const from = "FROM lineage l JOIN changes c ON c.oid = l.oid WHERE l.head = ?" + sql;
+        const total = Number(db.prepare("SELECT count(*) AS n " + from).get(head, ...params).n);
+        const rows = db.prepare(`SELECT c.row ${from} ORDER BY l.pos, c.ord LIMIT ? OFFSET ?`).all(head, ...params, limit, offset);
+        const boundary = !!db.prepare("SELECT 1 FROM lineage l JOIN commits m ON m.oid = l.oid WHERE l.head = ? AND m.boundary = 1 LIMIT 1").get(head);
+        return { total, events: rows.map((r) => JSON.parse(r.row)), boundary };
+      });
+    },
+    /** Counts over all of history and its newest commits, for the overview. */
+    async summary(head) {
+      await ensure(head);
+      return database.with((db) => {
+        const from = "FROM lineage l JOIN changes c ON c.oid = l.oid WHERE l.head = ?";
+        const count2 = (type) => Number(db.prepare(`SELECT count(*) AS n ${from} AND instr(',' || c.types || ',', ?) > 0`).get(head, "," + type + ",").n);
+        const total = Number(db.prepare(`SELECT count(*) AS n ${from}`).get(head).n);
+        const commits = db.prepare(`SELECT l.oid AS oid, max(c.date) AS date, count(*) AS n ${from} GROUP BY l.pos, l.oid ORDER BY l.pos`).all(head);
+        const newest = Math.max(0, ...commits.map((c) => Date.parse(c.date)).filter(Number.isFinite));
+        const pulse = commits.filter((c) => Date.parse(c.date) >= newest - 22 * DAY).map((c) => ({ date: c.date, count: Number(c.n) }));
+        const recent = commits.slice(0, RECENT_COMMITS).map((c) => ({
+          commit: c.oid,
+          count: Number(c.n),
+          events: db.prepare("SELECT row FROM changes WHERE oid = ? ORDER BY ord LIMIT ?").all(c.oid, RECENT_CHANGES).map((r) => JSON.parse(r.row))
+        }));
+        return { total, byType: { created: count2("created"), modified: count2("modified"), moved: count2("moved"), deleted: count2("deleted") }, pulse, recent };
+      });
+    },
+    /** One change with the text on both sides; a commit the index has not read yet is read now. */
+    async change(key) {
+      const lookup = () => database.with((db) => db.prepare("SELECT row, detail FROM changes WHERE key = ?").get(key));
+      let found = await lookup();
+      if (!found) {
+        const commit = key.slice(0, key.indexOf(":"));
+        const known = await database.with((db) => !!db.prepare("SELECT 1 FROM commits WHERE oid = ?").get(commit));
+        if (known) return void 0;
+        const read = await changes.of([commit]).catch(() => void 0);
+        if (!read) return void 0;
+        await database.with((db) => insert(db, read));
+        found = await lookup();
+      }
+      if (!found) return void 0;
+      const detail = JSON.parse(found.detail);
+      return { event: JSON.parse(found.row), before: detail.before, after: detail.after };
+    },
+    /** Replaces the search rows of one worktree's checkout when it changed since they were written. */
+    async syncCheckout(scope, stamp, documents) {
+      await database.with((db) => {
+        const current = db.prepare("SELECT stamp FROM checkouts WHERE scope = ?").get(scope);
+        if (current?.stamp === stamp) return;
+        transaction(db, () => {
+          db.prepare("DELETE FROM search WHERE scope = ?").run(scope);
+          const row = db.prepare("INSERT INTO search (scope, kind, ref, oid, payload, title, place, body) VALUES (?,?,?,?,?,?,?,?)");
+          for (const d of documents) {
+            const body = plain(d.body);
+            row.run(
+              scope,
+              d.kind,
+              d.ref,
+              null,
+              JSON.stringify({ title: d.title, where: d.where, body, featureId: d.featureId, documentId: d.documentId }),
+              d.title.toLowerCase(),
+              d.where.toLowerCase(),
+              body.toLowerCase()
+            );
+          }
+          db.prepare("INSERT INTO checkouts (scope, stamp) VALUES (?, ?) ON CONFLICT (scope) DO UPDATE SET stamp = excluded.stamp").run(scope, stamp);
+        });
+      });
+    },
+    /**
+     * Records whose title, place or text holds the query. The checkout comes first — a title match before a place
+     * match before a text match — then past changes of `head`'s history, newest first.
+     */
+    async search(scope, head, raw) {
+      const query = raw.trim().toLowerCase();
+      if (!query) return [];
+      if (head) await ensure(head);
+      return database.with((db) => {
+        const literal2 = /[\\%_]/.test(query);
+        const match = (column) => literal2 ? `instr(${column}, ?) > 0` : `${column} LIKE ?`;
+        const needle = literal2 ? query : containing(query);
+        const found = db.prepare(`SELECT kind, ref, payload, title, place, body FROM search WHERE scope = ? AND (${match("title")} OR ${match("place")} OR ${match("body")}) LIMIT 400`).all(scope, needle, needle, needle);
+        const documents = found.map((r) => {
+          const at = r.title.indexOf(query);
+          const rank = at === 0 ? 0 : at > 0 ? 1 : r.place.includes(query) ? 2 : 3;
+          const p = JSON.parse(r.payload);
+          const hit = {
+            id: r.ref,
+            kind: r.kind,
+            title: p.title,
+            where: p.where,
+            line: snippet(p.body, query),
+            ...p.featureId ? { featureId: p.featureId } : {},
+            ...p.documentId ? { documentId: p.documentId } : {}
+          };
+          return { rank, hit };
+        }).sort((a, b) => a.rank - b.rank || a.hit.title.localeCompare(b.hit.title)).slice(0, 24).map((r) => r.hit);
+        const past = !head ? [] : db.prepare(`SELECT s.ref AS ref, s.payload AS payload FROM search s JOIN lineage l ON l.head = ? AND l.oid = s.oid
+          WHERE s.scope = 'history' AND (${match("s.title")} OR ${match("s.body")}) ORDER BY l.pos LIMIT 8`).all(head, needle, needle).map((r) => {
+          const p = JSON.parse(r.payload);
+          return { id: r.ref, kind: "history", title: p.title, where: p.where, line: snippet(p.line, query), key: r.ref };
+        });
+        return [...documents, ...past];
+      });
+    }
+  };
+}
+
+// src/server/routes/record-routes.ts
+var PAGE = 50;
+function recordRoutes(root, sessionId, env) {
+  const reader = specPreviewReader(root);
+  const snapshots = /* @__PURE__ */ new Map();
+  const snapshot3 = (oid3) => {
+    let value = snapshots.get(oid3);
     if (!value) {
-      value = read(cursor, head).finally(() => pending.delete(key));
-      pending.set(key, value);
+      value = reader.readBundle(oid3).catch((e) => {
+        snapshots.delete(oid3);
+        throw e;
+      });
+      snapshots.set(oid3, value);
     }
+    if (snapshots.size > 128) snapshots.delete(snapshots.keys().next().value);
     return value;
   };
+  const readCheckout = createCheckoutReader(root, sessionId, env);
+  const history = createHistoryIndex(root, snapshot3);
+  const scope = "checkout:" + root;
+  const unreadable = t2("server.specsUnreadable");
+  let synced;
+  const checkout = async () => {
+    const read = await readCheckout();
+    synced = history.syncCheckout(scope, read.stamp, read.search);
+    await synced;
+    return read.checkout;
+  };
+  return [
+    route({ method: "GET", path: "/api/v1/specs", session: true, unreadable, handle: async () => {
+      return ok(await checkout());
+    } }),
+    route({ method: "GET", path: "/api/v1/history", session: true, query: browserHistoryQueryV1, unreadable, handle: async ({ query }) => {
+      const offset = query.offset ?? 0;
+      const page = await history.page(query.head, { kind: query.kind, document: query.document, feature: query.feature, author: query.author, q: query.q }, offset, query.limit ?? PAGE);
+      return ok(browserHistoryV1.parse({ contract: "browser-history", version: 1, sessionId, head: query.head, offset, ...page }));
+    } }),
+    route({ method: "GET", path: "/api/v1/history/summary", session: true, query: browserHistorySummaryQueryV1, unreadable, handle: async ({ query }) => ok(browserHistorySummaryV1.parse({ contract: "browser-history-summary", version: 1, sessionId, head: query.head, ...await history.summary(query.head) })) }),
+    route({ method: "GET", path: "/api/v1/change", session: true, query: browserChangeQueryV1, unreadable, handle: async ({ query }) => {
+      const change2 = await history.change(query.key);
+      if (!change2) throw new HttpError(404, "NOT_FOUND", t2("server.changeNotFound"));
+      return ok(browserChangeV1.parse({ contract: "browser-change", version: 1, sessionId, ...change2 }));
+    } }),
+    route({ method: "GET", path: "/api/v1/search", session: true, query: browserSearchQueryV1, unreadable, handle: async ({ query }) => {
+      await (synced ?? checkout()).catch(() => void 0);
+      return ok(browserSearchV1.parse({ contract: "browser-search", version: 1, sessionId, query: query.q, hits: await history.search(scope, query.head ?? null, query.q) }));
+    } })
+  ];
+}
+
+// src/server/routes/asset-routes.ts
+import { lstat as lstat4, readFile as readFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+function assetRoutes(root) {
+  return [
+    route({ method: "GET", path: "/api/v1/assets/*", session: false, handle: async ({ path: path3, response }) => {
+      const relative = path3.slice("/api/v1/assets/".length);
+      const assetPath = ASSETS_DIR + "/" + relative;
+      if (!isAssetPath(assetPath)) throw new HttpError(404, "NOT_FOUND", t2("server.assetNotFound"));
+      const file2 = join6(root, ...assetPath.split("/"));
+      const stat3 = await lstat4(file2).catch(() => void 0);
+      if (!stat3?.isFile() || stat3.isSymbolicLink() || stat3.size > 20 * 1024 * 1024) throw new HttpError(404, "NOT_FOUND", t2("server.assetNotFound"));
+      const bytes = await readFile4(file2);
+      const extension = assetExtension(relative);
+      const inline = ["png", "jpg", "jpeg", "gif", "webp", "svg"].includes(extension);
+      response.writeHead(200, {
+        "Content-Type": contentType("." + extension),
+        "Cache-Control": "no-cache",
+        "Content-Length": bytes.length,
+        "Content-Security-Policy": "default-src 'none'; sandbox",
+        "Content-Disposition": inline ? "inline" : 'attachment; filename="' + encodeURIComponent(relative.split("/").pop()) + '"'
+      });
+      response.end(bytes);
+      return void 0;
+    } })
+  ];
 }
 
 // src/server/browser-server.ts
-var readBundledChangelog = (language) => readFile4(new URL("./i18n/" + language + "/changelog.md", import.meta.url), "utf8").catch((error62) => {
+var readBundledChangelog = (language) => readFile5(new URL("./i18n/" + language + "/changelog.md", import.meta.url), "utf8").catch((error62) => {
   if (error62.code === "ENOENT") return null;
   throw error62;
 });
@@ -25812,127 +26546,24 @@ async function startBrowserServer(options) {
   }
   const store = createStatusSession(initial, () => read(controller.signal), options.cliVersion);
   const sessionId = store.session.sessionId;
-  const readChangelog = options.readChangelog ?? readBundledChangelog;
+  const root = initial.repository.rootPath;
+  const routes = [
+    ...projectRoutes(store, options.readChangelog ?? readBundledChangelog),
+    ...recordRoutes(root, sessionId, options.env),
+    ...assetRoutes(root)
+  ];
   let updatePending;
   let closing = false;
   let origin = "";
-  const readSpecs = createSpecBrowserReader(initial.repository.rootPath, sessionId, options.env);
-  function json2(response, status, value) {
-    response.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
-    response.end(JSON.stringify(value) + "\n");
-  }
-  function fail8(response, status, code, message) {
-    json2(response, status, browserHttpErrorV1.parse({ contract: "browser-http-error", version: 1, error: { code, message } }));
-  }
-  async function handle(request, response) {
-    response.setHeader("X-Content-Type-Options", "nosniff");
-    response.setHeader("X-Frame-Options", "DENY");
-    response.setHeader("Referrer-Policy", "no-referrer");
-    response.setHeader("Content-Security-Policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'");
-    if (closing) return fail8(response, 503, "SERVER_CLOSING", t2("server.closing"));
-    if (request.headers.host !== new URL(origin).host) return fail8(response, 403, "FORBIDDEN", t2("server.forbiddenHost"));
-    const requestOrigin = request.headers.origin;
-    const allowedOrigin = requestOrigin === origin || options.dev && requestOrigin === "http://127.0.0.1:5173";
-    if (requestOrigin && !allowedOrigin) return fail8(response, 403, "FORBIDDEN", t2("server.forbiddenOrigin"));
-    const raw = request.url ?? "/";
-    if (!raw.startsWith("/") || raw.startsWith("//") || raw.includes("\\")) return fail8(response, 400, "BAD_REQUEST", t2("server.badPath"));
-    let url2;
-    let path3;
-    try {
-      url2 = new URL(raw, origin);
-      path3 = decodeURIComponent(url2.pathname);
-    } catch {
-      return fail8(response, 400, "BAD_REQUEST", t2("server.badPath"));
-    }
-    if (path3.includes("\0") || path3.includes("\\") || path3.split("/").some((part) => part === ".." || part === ".")) {
-      return fail8(response, 400, "BAD_REQUEST", t2("server.badPath"));
-    }
-    if (request.headers["transfer-encoding"] || request.headers["content-length"] && request.headers["content-length"] !== "0") {
-      request.resume();
-      return fail8(response, 400, "BAD_REQUEST", t2("server.noBody"));
-    }
-    const api = path3 === "/api" || path3.startsWith("/api/");
-    if (api) {
-      if (request.headers["sec-fetch-site"] === "cross-site" && !allowedOrigin) return fail8(response, 403, "FORBIDDEN", t2("server.crossSite"));
-      if (url2.search && path3 !== "/api/v1/specs" && path3 !== "/api/v1/changelog") return fail8(response, 400, "BAD_REQUEST", t2("server.noQuery"));
-      if (path3.startsWith("/api/v1/assets/")) {
-        const relative = path3.slice("/api/v1/assets/".length);
-        const assetPath2 = ASSETS_DIR + "/" + relative;
-        if (request.method !== "GET") {
-          response.setHeader("Allow", "GET");
-          return fail8(response, 405, "METHOD_NOT_ALLOWED", t2("server.methodNotAllowed"));
-        }
-        if (!isAssetPath(assetPath2)) return fail8(response, 404, "NOT_FOUND", t2("server.assetNotFound"));
-        const file2 = join5(initial.repository.rootPath, ...assetPath2.split("/"));
-        const stat3 = await lstat4(file2).catch(() => void 0);
-        if (!stat3?.isFile() || stat3.isSymbolicLink() || stat3.size > 20 * 1024 * 1024) return fail8(response, 404, "NOT_FOUND", t2("server.assetNotFound"));
-        const bytes = await readFile4(file2);
-        const extension = assetExtension(relative);
-        const inline = ["png", "jpg", "jpeg", "gif", "webp", "svg"].includes(extension);
-        response.writeHead(200, {
-          "Content-Type": contentType("." + extension),
-          "Cache-Control": "no-cache",
-          "Content-Length": bytes.length,
-          "Content-Security-Policy": "default-src 'none'; sandbox",
-          "Content-Disposition": inline ? "inline" : 'attachment; filename="' + encodeURIComponent(relative.split("/").pop()) + '"'
-        });
-        response.end(bytes);
-        return;
-      }
-      const method = path3 === "/api/v1/status/refresh" ? "POST" : "GET";
-      if (!["/api/v1/session", "/api/v1/status", "/api/v1/status/refresh", "/api/v1/specs", "/api/v1/changelog"].includes(path3)) return fail8(response, 404, "NOT_FOUND", t2("server.apiNotFound"));
-      if (request.method !== method) {
-        response.setHeader("Allow", method);
-        return fail8(response, 405, "METHOD_NOT_ALLOWED", t2("server.methodNotAllowed"));
-      }
-      if (path3 === "/api/v1/session") return json2(response, 200, store.session);
-      if (request.headers["x-gitifact-session"] !== sessionId) return fail8(response, 409, "SESSION_CHANGED", t2("server.sessionChanged"));
-      if (path3 === "/api/v1/specs") {
-        const cursor = url2.searchParams.get("cursor") ?? "0";
-        const head = url2.searchParams.get("head");
-        if ([...url2.searchParams.keys()].some((k) => !["cursor", "head"].includes(k)) || url2.searchParams.getAll("cursor").length > 1 || url2.searchParams.getAll("head").length > 1 || !/^(0|[1-9]\d{0,5})$/.test(cursor) || head !== null && !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(head)) return fail8(response, 400, "BAD_REQUEST", t2("server.badRange"));
-        try {
-          json2(response, 200, await readSpecs(Number(cursor), head ?? void 0));
-        } catch (error62) {
-          fail8(response, 503, "INTERNAL_ERROR", error62 instanceof Error ? error62.message : t2("server.specsUnreadable"));
-        }
-        return;
-      }
-      if (path3 === "/api/v1/changelog") {
-        const language = url2.searchParams.get("lang") ?? defaultLanguage2;
-        if ([...url2.searchParams.keys()].some((key) => key !== "lang") || url2.searchParams.getAll("lang").length > 1 || !/^[a-z]{2}(?:-[A-Z]{2})?$/.test(language)) return fail8(response, 400, "BAD_REQUEST", t2("server.badLanguage"));
-        try {
-          const own2 = await readChangelog(language);
-          const text2 = own2 ?? (language === defaultLanguage2 ? null : await readChangelog(defaultLanguage2));
-          if (text2 === null) return fail8(response, 404, "NOT_FOUND", t2("server.changelogNotFound"));
-          json2(response, 200, changelogV1.parse({ contract: "changelog", version: 1, language: own2 === null ? defaultLanguage2 : language, fallback: own2 === null, entries: parseChangelog(text2) }));
-        } catch (error62) {
-          fail8(response, 503, "INTERNAL_ERROR", error62 instanceof Error ? error62.message : t2("server.changelogUnreadable"));
-        }
-        return;
-      }
-      if (method === "POST" && !allowedOrigin) return fail8(response, 403, "FORBIDDEN", t2("server.refreshOrigin"));
-      const value = method === "POST" ? await store.refresh() : store.latest;
-      if (!response.destroyed) json2(response, value.ok ? 200 : 503, value);
-      return;
-    }
-    if (request.method !== "GET" && request.method !== "HEAD") {
-      response.setHeader("Allow", "GET, HEAD");
-      return fail8(response, 405, "METHOD_NOT_ALLOWED", t2("server.methodNotAllowed"));
-    }
-    let asset = assets.get(path3 === "/" ? "/index.html" : path3);
-    let assetPath = path3 === "/" ? "/index.html" : path3;
-    if (!asset && !path3.startsWith("/assets/") && !path3.split("/").some((part) => part.includes(".")) && request.headers.accept?.includes("text/html")) {
-      asset = assets.get("/index.html");
-      assetPath = "/index.html";
-    }
-    if (!asset) return fail8(response, 404, "NOT_FOUND", t2("server.fileNotFound"));
-    response.writeHead(200, { "Content-Type": contentType(assetPath), "Cache-Control": "no-cache", "Content-Length": asset.length });
-    response.end(request.method === "HEAD" ? void 0 : asset);
-  }
   const server = createServer({ requestTimeout: 5e3, headersTimeout: 5e3, maxHeaderSize: 8192 }, (request, response) => {
-    void handle(request, response).catch(() => {
-      if (!response.headersSent && !response.destroyed) fail8(response, 500, "INTERNAL_ERROR", t2("server.internal"));
+    void (async () => {
+      if (closing) return fail4(response, 503, "SERVER_CLOSING", t2("server.closing"));
+      const admitted = admit(request, response, origin, !!options.dev);
+      if (!admitted) return;
+      if (admitted.api) return dispatch(routes, sessionId, admitted.url, admitted.path, request, response, admitted.allowedOrigin);
+      return serveStatic(request, response, admitted.path, assets);
+    })().catch(() => {
+      if (!response.headersSent && !response.destroyed) fail4(response, 500, "INTERNAL_ERROR", t2("server.internal"));
       else response.destroy();
     });
   });
@@ -26039,13 +26670,13 @@ async function runBrowser(options, version2) {
 }
 
 // src/commands/spec-init.ts
-import { mkdir as mkdir4, readdir as readdir4, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { mkdir as mkdir5, readdir as readdir4, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 
 // src/adapters/git/init-repository.ts
 import { createHash as createHash3 } from "node:crypto";
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 function initRepository(cwd, inherited = process.env) {
   const env = { ...inherited, GIT_OPTIONAL_LOCKS: "0", GIT_NO_LAZY_FETCH: "1", GIT_TERMINAL_PROMPT: "0", GIT_LITERAL_PATHSPECS: "1", LC_ALL: "C" };
   const runner = createGitRunner();
@@ -26065,10 +26696,10 @@ function initRepository(cwd, inherited = process.env) {
       const gitDir = locations.length === 2 ? locations[0] : decodeGitLine(await git(["rev-parse", "--absolute-git-dir"], root));
       const indexPath = locations.length === 2 ? locations[1] : decodeGitLine(await git(["rev-parse", "--path-format=absolute", "--git-path", "index"], root));
       for (const marker2 of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merge", "rebase-apply", "sequencer", "BISECT_START", "index.lock"]) {
-        if (await fileInfo(join6(gitDir, marker2))) throw new InitError("GIT_OPERATION_IN_PROGRESS", t2("git.operationInProgress", { marker: marker2 }));
+        if (await fileInfo(join7(gitDir, marker2))) throw new InitError("GIT_OPERATION_IN_PROGRESS", t2("git.operationInProgress", { marker: marker2 }));
       }
       if (state.changes.some((change2) => change2.kind === "unmerged")) throw new InitError("GIT_OPERATION_IN_PROGRESS", t2("git.resolveConflicts"));
-      const index = await readFile5(indexPath).catch((error62) => {
+      const index = await readFile6(indexPath).catch((error62) => {
         if (error62.code === "ENOENT") return Buffer.alloc(0);
         throw error62;
       });
@@ -26102,18 +26733,18 @@ function initRepository(cwd, inherited = process.env) {
 }
 
 // src/adapters/filesystem/managed-file.ts
-import { open as open3, readFile as readFile6, mkdir as mkdir3, realpath as realpath2, rename as rename3, link as link2, unlink as unlink3 } from "node:fs/promises";
-import { join as join7, dirname as dirname2 } from "node:path";
+import { open as open3, readFile as readFile7, mkdir as mkdir4, realpath as realpath2, rename as rename3, link as link2, unlink as unlink3 } from "node:fs/promises";
+import { join as join8, dirname as dirname2 } from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 var DEFAULT_LIMIT = 1024 * 1024;
 async function managedPath(root, path3, create = false) {
   let full = root;
   const parts = path3.split("/");
   for (let i = 0; i < parts.length; i++) {
-    full = join7(full, parts[i]);
+    full = join8(full, parts[i]);
     let info7 = await fileInfo(full);
     if (!info7 && create && i < parts.length - 1) {
-      await mkdir3(full).catch((error62) => {
+      await mkdir4(full).catch((error62) => {
         if (error62.code !== "EEXIST") throw error62;
       });
       info7 = await fileInfo(full);
@@ -26129,7 +26760,7 @@ async function managedRead(root, path3, limit = DEFAULT_LIMIT) {
   const before = await fileInfo(full);
   if (!before) return null;
   if (before.size > limit) throw new InitError("FILE_TOO_LARGE", t2("managedFile.tooLarge", { kib: limit / 1024, path: path3 }));
-  const bytes = await readFile6(full);
+  const bytes = await readFile7(full);
   await managedPath(root, path3);
   const after = await fileInfo(full);
   if (!after || before.ino !== after.ino || before.dev !== after.dev || before.mtimeMs !== after.mtimeMs || bytes.length > limit) {
@@ -26158,7 +26789,7 @@ async function managedWrite(root, path3, previous, next, recheck) {
     if (previous !== null) await unlink3(full);
     return;
   }
-  const temp = join7(directory, ".gitifact-managed-" + randomUUID5() + ".tmp");
+  const temp = join8(directory, ".gitifact-managed-" + randomUUID5() + ".tmp");
   const handle = await open3(temp, "wx", 384);
   const tempOwner = await handle.stat();
   try {
@@ -26170,7 +26801,7 @@ async function managedWrite(root, path3, previous, next, recheck) {
     }
     await recheck();
     await unchanged();
-    if (await managedRead(root, path3) !== previous || await readFile6(temp, "utf8") !== next) throw new InitError("INPUT_CHANGED", t2("managedFile.publishTargetChanged", { path: path3 }));
+    if (await managedRead(root, path3) !== previous || await readFile7(temp, "utf8") !== next) throw new InitError("INPUT_CHANGED", t2("managedFile.publishTargetChanged", { path: path3 }));
     if (previous === null) await link2(temp, full);
     else await rename3(temp, full);
   } finally {
@@ -26181,14 +26812,14 @@ async function managedWrite(root, path3, previous, next, recheck) {
 }
 
 // src/commands/agent-block.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 
 // src/commands/docs.ts
-import { lstat as lstat5, readFile as readFile7 } from "node:fs/promises";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { lstat as lstat5, readFile as readFile8 } from "node:fs/promises";
+import { dirname as dirname3, join as join9 } from "node:path";
 var docTopics = ["workflow", "spec", "design", "wiki", "writing", "commit"];
 var isDocTopic = (value) => docTopics.includes(value);
-var readBundledDoc = (name, lang) => readFile7(new URL("./i18n/" + lang + "/docs/" + name + ".md", import.meta.url), "utf8");
+var readBundledDoc = (name, lang) => readFile8(new URL("./i18n/" + lang + "/docs/" + name + ".md", import.meta.url), "utf8");
 var info3 = (path3) => lstat5(path3).catch((e) => {
   if (e.code === "ENOENT") return void 0;
   throw e;
@@ -26199,16 +26830,16 @@ function listDocTopics(lang = defaultLanguage2) {
 }
 async function findProjectRoot(cwd) {
   for (let dir = cwd; ; dir = dirname3(dir)) {
-    if ((await info3(join8(dir, ".gitifact", "config.json")))?.isFile()) return dir;
+    if ((await info3(join9(dir, ".gitifact", "config.json")))?.isFile()) return dir;
     if (dirname3(dir) === dir) return void 0;
   }
 }
 async function readWikiPolicy(root) {
   if (!root) return void 0;
-  const path3 = join8(root, ...WIKI_ENTRY_PATH.split("/"));
+  const path3 = join9(root, ...WIKI_ENTRY_PATH.split("/"));
   const stat3 = await info3(path3);
   if (!stat3?.isFile() || stat3.size > 1024 * 1024) return void 0;
-  const lines = (await readFile7(path3, "utf8")).replace(/\r\n/g, "\n").split("\n");
+  const lines = (await readFile8(path3, "utf8")).replace(/\r\n/g, "\n").split("\n");
   if (lines[0] === "---") {
     const end = lines.indexOf("---", 1);
     if (end > 0) lines.splice(0, end + 1);
@@ -26260,7 +26891,7 @@ function boilerplateFor(path3) {
   const name = path3 === "AGENTS.md" ? path3 : path3.split("/").pop().replace(/^\./, "").replace(/\.md$/, "");
   return "# " + name + "\n\nProject-specific guidance for AI coding agents.\n";
 }
-var readBundledBlock = (lang) => readFile8(new URL("./i18n/" + lang + "/block.md", import.meta.url), "utf8");
+var readBundledBlock = (lang) => readFile9(new URL("./i18n/" + lang + "/block.md", import.meta.url), "utf8");
 async function renderAgentBlock(version2, controls = {}, lang = defaultLanguage2) {
   const body = await (controls.readBlock ?? readBundledBlock)(lang);
   const filled = body.trimEnd().replace(/\{(version|language|topics)\}/g, (_whole, name) => name === "version" ? version2 : name === "language" ? lang : docTopics.join(", "));
@@ -26419,8 +27050,8 @@ async function initializeSpecProject(cwd, dryRun = false, env = process.env, bef
   const text2 = JSON.stringify(config2, null, 2) + "\n";
   const replaceLegacy = async (before, version2) => {
     const onlyConfig = async () => {
-      const entries = await readdir4(join9(root, ".gitifact"));
-      if (await fileInfo(join9(root, "specs")) || entries.some((name) => name !== "config.json" && !/^\.init-[a-f0-9-]+\.tmp$/.test(name))) {
+      const entries = await readdir4(join10(root, ".gitifact"));
+      if (await fileInfo(join10(root, "specs")) || entries.some((name) => name !== "config.json" && !/^\.init-[a-f0-9-]+\.tmp$/.test(name))) {
         throw new InitError("UNSUPPORTED_SCHEMA", t2("init.legacyRecords", { version: String(version2) }));
       }
     };
@@ -26451,8 +27082,8 @@ async function initializeSpecProject(cwd, dryRun = false, env = process.env, bef
   }
   if (first.trackedConfig) throw new InitError("CONFIG_DELETED", t2("init.configDeleted"));
   const checkRecords = async () => {
-    if (await fileInfo(join9(root, "specs"))) throw new InitError("EXISTING_RECORDS", t2("init.existingSpecs"));
-    const entries = await readdir4(join9(root, ".gitifact")).catch((e) => {
+    if (await fileInfo(join10(root, "specs"))) throw new InitError("EXISTING_RECORDS", t2("init.existingSpecs"));
+    const entries = await readdir4(join10(root, ".gitifact")).catch((e) => {
       if (e.code === "ENOENT") return [];
       throw e;
     });
@@ -26489,7 +27120,7 @@ function legacySchemaVersion(text2) {
   return Number.isInteger(version2) && version2 < SCHEMA_VERSION ? version2 : void 0;
 }
 async function writeWikiPolicy(root, readDoc) {
-  if (await fileInfo(join9(root, ...WIKI_DIR.split("/")))) return;
+  if (await fileInfo(join10(root, ...WIKI_DIR.split("/")))) return;
   const template = await readDoc("wiki.default").catch((e) => {
     if (e.code === "ENOENT") return void 0;
     throw e;
@@ -26498,8 +27129,8 @@ async function writeWikiPolicy(root, readDoc) {
   const doc = { id: generatePreviewId("W"), path: WIKI_ENTRY_PATH, title: t2("init.wikiReadmeTitle"), body: template.trim() };
   const text2 = renderDocument(doc);
   parseDocument(doc.path, text2);
-  await mkdir4(join9(root, ...WIKI_DIR.split("/")), { recursive: true });
-  await writeFile2(join9(root, ...WIKI_ENTRY_PATH.split("/")), text2, { flag: "wx" });
+  await mkdir5(join10(root, ...WIKI_DIR.split("/")), { recursive: true });
+  await writeFile2(join10(root, ...WIKI_ENTRY_PATH.split("/")), text2, { flag: "wx" });
 }
 
 // src/commands/init.ts
@@ -26674,14 +27305,14 @@ async function runUpdate(options, version2) {
 }
 
 // src/commands/spec-preview.ts
-import { join as join14 } from "node:path";
-import { readFile as readFile11, stat as stat2 } from "node:fs/promises";
+import { join as join15 } from "node:path";
+import { readFile as readFile12, stat as stat2 } from "node:fs/promises";
 
 // src/adapters/filesystem/spec-preview-context.ts
 import { lstat as lstat6 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { createHash as createHash4 } from "node:crypto";
-var fail5 = (message) => {
+var fail6 = (message) => {
   throw new SpecPreviewError(message);
 };
 var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
@@ -26692,11 +27323,11 @@ async function readPreviewContext(cwd) {
   const { gitDir } = await reader.location();
   const checkOperation = async () => {
     for (const name of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merge", "rebase-apply"]) {
-      const exists = await lstat6(join10(gitDir, name)).catch((e) => {
+      const exists = await lstat6(join11(gitDir, name)).catch((e) => {
         if (e.code === "ENOENT") return void 0;
         throw e;
       });
-      if (exists) fail5(t2("prepare.integrationInProgress"));
+      if (exists) fail6(t2("prepare.integrationInProgress"));
     }
   };
   await checkOperation();
@@ -26707,7 +27338,7 @@ async function readPreviewContext(cwd) {
   const specs = bundle.specs;
   const recheck = async () => {
     await checkOperation();
-    if (!same(base, await reader.baseline())) fail5(t2("prepare.headChanged"));
+    if (!same(base, await reader.baseline())) fail6(t2("prepare.headChanged"));
   };
   return { reader, base, files, specs, bundle, recheck, working };
 }
@@ -26723,9 +27354,9 @@ async function readFinalPreviewChanges(cwd) {
 
 // src/adapters/filesystem/agent-inputs.ts
 import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
-import { lstat as lstat7, mkdir as mkdir5, readdir as readdir5, realpath as realpath3, unlink as unlink4, writeFile as writeFile3 } from "node:fs/promises";
+import { lstat as lstat7, mkdir as mkdir6, readdir as readdir5, realpath as realpath3, unlink as unlink4, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, dirname as dirname4, join as join11 } from "node:path";
+import { basename, dirname as dirname4, join as join12 } from "node:path";
 var maxAge = 7 * 24 * 60 * 60 * 1e3;
 var info4 = (path3) => lstat7(path3).catch((e) => {
   if (e.code === "ENOENT") return void 0;
@@ -26734,14 +27365,14 @@ var info4 = (path3) => lstat7(path3).catch((e) => {
 var comparable = (path3) => process.platform === "win32" ? path3.toLowerCase() : path3;
 async function candidates(root, controls) {
   const key = createHash5("sha256").update(comparable(await realpath3(root))).digest("hex").slice(0, 16);
-  return { system: join11((controls.tmpdir ?? tmpdir)(), "gitifact", key), project: join11(root, ".gitifact", "tmp") };
+  return { system: join12((controls.tmpdir ?? tmpdir)(), "gitifact", key), project: join12(root, ".gitifact", "tmp") };
 }
 async function writable(directory) {
   try {
-    await mkdir5(directory, { recursive: true });
+    await mkdir6(directory, { recursive: true });
     const stat3 = await info4(directory);
     if (!stat3?.isDirectory() || stat3.isSymbolicLink()) return false;
-    const probe = join11(directory, ".probe-" + randomBytes2(8).toString("hex"));
+    const probe = join12(directory, ".probe-" + randomBytes2(8).toString("hex"));
     await writeFile3(probe, "", { flag: "wx" });
     await unlink4(probe);
     return true;
@@ -26755,7 +27386,7 @@ async function prepareAgentInputs(root, controls = {}) {
   if (await writable(system)) directory = system;
   else if (await writable(project)) {
     directory = project;
-    await writeFile3(join11(project, ".gitignore"), "*\n", { flag: "wx" }).catch((e) => {
+    await writeFile3(join12(project, ".gitignore"), "*\n", { flag: "wx" }).catch((e) => {
       if (e.code !== "EEXIST") throw e;
     });
   }
@@ -26763,10 +27394,10 @@ async function prepareAgentInputs(root, controls = {}) {
   const now = (controls.now ?? Date.now)();
   for (const name of await readdir5(directory).catch(() => [])) {
     if (name === ".gitignore") continue;
-    const stat3 = await info4(join11(directory, name)).catch(() => void 0);
-    if (stat3?.isFile() && now - stat3.mtimeMs > maxAge) await unlink4(join11(directory, name)).catch(() => void 0);
+    const stat3 = await info4(join12(directory, name)).catch(() => void 0);
+    if (stat3?.isFile() && now - stat3.mtimeMs > maxAge) await unlink4(join12(directory, name)).catch(() => void 0);
   }
-  return { save: join11(directory, "save.json"), commit: join11(directory, "commit.json") };
+  return { save: join12(directory, "save.json"), commit: join12(directory, "commit.json") };
 }
 async function discardAgentInput(root, file2, controls = {}) {
   try {
@@ -26788,18 +27419,18 @@ async function discardAgentInput(root, file2, controls = {}) {
 
 // src/commands/spec-commit.ts
 import { createHash as createHash7, randomUUID as randomUUID6 } from "node:crypto";
-import { mkdir as mkdir6, open as open4, readFile as readFile10, rename as rename4, rmdir as rmdir2, unlink as unlink5, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { mkdir as mkdir7, open as open4, readFile as readFile11, rename as rename4, rmdir as rmdir2, unlink as unlink5, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 
 // src/commands/spec-commit-files.ts
 import { createHash as createHash6 } from "node:crypto";
-import { lstat as lstat8, readFile as readFile9 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-var fail6 = (message) => {
+import { lstat as lstat8, readFile as readFile10 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+var fail7 = (message) => {
   throw new SpecPreviewError(message);
 };
 var hash2 = (value) => createHash6("sha256").update(value).digest("hex");
-var optional2 = (path3) => readFile9(path3).catch((e) => {
+var optional2 = (path3) => readFile10(path3).catch((e) => {
   if (e.code === "ENOENT") return null;
   throw e;
 });
@@ -26809,34 +27440,34 @@ var info5 = (path3) => lstat8(path3).catch((e) => {
 });
 var record2 = (path3) => recordPathPattern.test(path3);
 function validPath2(path3) {
-  if (typeof path3 !== "string" || path3.length > 1e3 || /[\\:\x00-\x1f\x7f]/.test(path3) || path3.split("/").some((p) => !p || p === "." || p === ".." || p.toLowerCase() === ".git")) fail6(t2("commitFiles.relativePath"));
+  if (typeof path3 !== "string" || path3.length > 1e3 || /[\\:\x00-\x1f\x7f]/.test(path3) || path3.split("/").some((p) => !p || p === "." || p === ".." || p.toLowerCase() === ".git")) fail7(t2("commitFiles.relativePath"));
 }
 async function fingerprint(root, path3) {
   validPath2(path3);
   const parts = path3.split("/");
   for (let i = 1; i <= parts.length; i++) {
-    const target = join12(root, ...parts.slice(0, i));
+    const target = join13(root, ...parts.slice(0, i));
     const stat3 = await info5(target);
     if (!stat3) return null;
-    if (stat3.isSymbolicLink() || (i < parts.length ? !stat3.isDirectory() : !stat3.isFile())) fail6(t2("commitFiles.linkOrDirectory"));
-    if (i < parts.length && await info5(join12(target, ".git"))) fail6(t2("commitFiles.nestedRepository"));
+    if (stat3.isSymbolicLink() || (i < parts.length ? !stat3.isDirectory() : !stat3.isFile())) fail7(t2("commitFiles.linkOrDirectory"));
+    if (i < parts.length && await info5(join13(target, ".git"))) fail7(t2("commitFiles.nestedRepository"));
     if (i === parts.length) {
-      if (stat3.nlink !== 1 || stat3.size > 16 * 1024 * 1024) fail6(t2("commitFiles.hardLinkOrSize"));
-      return hash2(Buffer.concat([Buffer.from(String(stat3.mode & 73) + "\0"), await readFile9(target)]));
+      if (stat3.nlink !== 1 || stat3.size > 16 * 1024 * 1024) fail7(t2("commitFiles.hardLinkOrSize"));
+      return hash2(Buffer.concat([Buffer.from(String(stat3.mode & 73) + "\0"), await readFile10(target)]));
     }
   }
   return null;
 }
 function object3(input2) {
-  if (!input2 || typeof input2 !== "object" || Array.isArray(input2)) return fail6(t2("commitFiles.invalidInput"));
+  if (!input2 || typeof input2 !== "object" || Array.isArray(input2)) return fail7(t2("commitFiles.invalidInput"));
   return input2;
 }
 function text(value, limit) {
-  if (typeof value !== "string" || !value.trim() || value.length > limit || value.includes("\0")) return fail6(t2("commitFiles.emptyOrTooLong"));
+  if (typeof value !== "string" || !value.trim() || value.length > limit || value.includes("\0")) return fail7(t2("commitFiles.emptyOrTooLong"));
   return value;
 }
 function paths(value, limit = 128) {
-  if (!Array.isArray(value) || !value.length || value.length > limit || value.some((p) => typeof p !== "string")) return fail6(t2("commitFiles.invalidPaths"));
+  if (!Array.isArray(value) || !value.length || value.length > limit || value.some((p) => typeof p !== "string")) return fail7(t2("commitFiles.invalidPaths"));
   const list = [...new Set(value)].sort();
   list.forEach(validPath2);
   return list;
@@ -26853,10 +27484,10 @@ async function checkLegacySelection(root, selected) {
   const legacyJson = /^\.(?:gitifact|tryce)\/(?:spec\/[^/]+\/tryce\.json|notes\/N-[a-f0-9-]+\.json|mode-[a-f0-9-]+\.json|config\.(?:init-1|prototype-1)\.[a-f0-9]+\.json)$|^\.gitifact\/(?:product|guides|overrides)\/.+$/;
   for (const p of selected.filter((p2) => p2.startsWith(".gitifact/") && !record2(p2) && p2 !== ".gitifact/config.json")) {
     if (isAssetPath(p)) continue;
-    if (!legacyJson.test(p) || await fingerprint(root, p) !== null) fail6(t2("commitFiles.legacyDeleteOnly", { path: p }));
+    if (!legacyJson.test(p) || await fingerprint(root, p) !== null) fail7(t2("commitFiles.legacyDeleteOnly", { path: p }));
   }
   for (const p of selected.filter((p2) => p2.startsWith(".tryce/"))) {
-    if (!(record2(p) || p === ".tryce/config.json" || legacyJson.test(p)) || await fingerprint(root, p) !== null) fail6(t2("commitFiles.tryceDeleteOnly", { path: p }));
+    if (!(record2(p) || p === ".tryce/config.json" || legacyJson.test(p)) || await fingerprint(root, p) !== null) fail7(t2("commitFiles.tryceDeleteOnly", { path: p }));
   }
 }
 
@@ -26866,17 +27497,17 @@ var integration = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merg
 var same2 = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 async function specCommit(cwd, input2, dryRun) {
   const request = object3(input2);
-  if (Object.keys(request).some((k) => !fields.includes(k))) fail6(t2("commit.unknownField"));
+  if (Object.keys(request).some((k) => !fields.includes(k))) fail7(t2("commit.unknownField"));
   const selected = paths(request.paths);
   const authorization = object3(request.authorization);
-  if (Object.keys(authorization).sort().join(",") !== "basis,evidence" || !["user-request", "project-policy"].includes(String(authorization.basis))) fail6(t2("commit.authorizationRequired"));
+  if (Object.keys(authorization).sort().join(",") !== "basis,evidence" || !["user-request", "project-policy"].includes(String(authorization.basis))) fail7(t2("commit.authorizationRequired"));
   text(authorization.evidence, 2e3);
   const message = text(request.message, 4e3);
-  if (/^\s*Gitifact-/im.test(message)) fail6(t2("commit.trailerInMessage"));
+  if (/^\s*Gitifact-/im.test(message)) fail7(t2("commit.trailerInMessage"));
   const references = request.requirements ?? [];
-  if (!Array.isArray(references) || references.length > 1e3 || references.some((r) => typeof r !== "string")) fail6(t2("commit.invalidReferences"));
+  if (!Array.isArray(references) || references.length > 1e3 || references.some((r) => typeof r !== "string")) fail7(t2("commit.invalidReferences"));
   const extra = request.policyFiles === void 0 ? [] : paths(request.policyFiles, 1024);
-  if (request.expected !== void 0 && typeof request.expected !== "string") fail6(t2("commit.expectedType"));
+  if (request.expected !== void 0 && typeof request.expected !== "string") fail7(t2("commit.expectedType"));
   const c = await readPreviewContext(cwd);
   const { root, gitDir, indexPath, objectFormat } = await c.reader.location();
   const runner = createGitRunner();
@@ -26899,13 +27530,13 @@ async function specCommit(cwd, input2, dryRun) {
     ...stdin ? { input: stdin } : {}
   });
   const staged = async (index) => (await git(["diff", "--cached", "--ita-visible-in-index", "--name-only", "--no-renames", "-z"], index)).toString("utf8").split("\0").filter(Boolean).sort();
-  const busy = join13(gitDir, "gitifact-spec-commit.lock");
+  const busy = join14(gitDir, "gitifact-spec-commit.lock");
   await failOnLegacyLock(gitDir);
-  if (await info5(busy)) fail6(t2("commit.busy", { path: busy }));
-  if ((await staged()).length) fail6(t2("commit.existingStaging"));
+  if (await info5(busy)) fail7(t2("commit.busy", { path: busy }));
+  if ((await staged()).length) fail7(t2("commit.existingStaging"));
   const indexHash = hash2(await optional2(indexPath) ?? Buffer.alloc(0));
   const current = c.working;
-  if (request.expected !== void 0 && request.expected !== previewExpected(c.base, current.stamp)) fail6(t2("commit.staleInput"));
+  if (request.expected !== void 0 && request.expected !== previewExpected(c.base, current.stamp)) fail7(t2("commit.staleInput"));
   const reasons = request.reasons ?? pendingPreviewReasons(c.bundle, current.bundle).map((h) => ({ requirements: h.requirements, ...h.designs ? { designs: h.designs } : {}, ...h.documents ? { documents: h.documents } : {}, reason: h.reason }));
   const prepared = prepareSpecPreview(c.bundle, current.bundle, c.files, current.files, reasons, () => generatePreviewId("H"));
   const blobId = (text2) => {
@@ -26913,14 +27544,14 @@ async function specCommit(cwd, input2, dryRun) {
     return createHash7(objectFormat).update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
   };
   const present = [...current.files.keys()];
-  if (present.some((p) => p.includes("\n"))) fail6(t2("commit.newlinePath"));
+  if (present.some((p) => p.includes("\n"))) fail7(t2("commit.newlinePath"));
   const stored = present.length ? (await git(["hash-object", "--stdin-paths"], void 0, Buffer.from(present.join("\n") + "\n"))).toString("utf8").split("\n") : [""];
-  if (stored.length !== present.length + 1) fail6(t2("commit.storedShape"));
+  if (stored.length !== present.length + 1) fail7(t2("commit.storedShape"));
   const workingIds = new Map(present.map((p, i) => [p, stored[i]]));
   const writes = new Map([...prepared.writes].filter(([p, next]) => next === null || workingIds.get(p) !== blobId(next)));
   const finalId = (p) => writes.has(p) ? writes.get(p) === null ? void 0 : blobId(writes.get(p)) : workingIds.get(p);
   const pending = [.../* @__PURE__ */ new Set([...c.files.keys(), ...present, ...writes.keys()])].filter((p) => (c.files.has(p) ? blobId(c.files.get(p)) : void 0) !== finalId(p));
-  if (pending.some((p) => !selected.includes(p))) fail6(t2("commit.selectPending"));
+  if (pending.some((p) => !selected.includes(p))) fail7(t2("commit.selectPending"));
   const finalFiles = new Map(current.files);
   for (const [path3, next] of writes) {
     if (next === null) finalFiles.delete(path3);
@@ -26929,7 +27560,7 @@ async function specCommit(cwd, input2, dryRun) {
   await checkLegacySelection(root, selected);
   const stageable = selected.filter((p) => !record2(p) || finalFiles.has(p) || c.files.has(p));
   const known = /* @__PURE__ */ new Set([...current.specs.flatMap((s) => s.requirements.map((r) => r.id)), ...prepared.changes.filter((x) => x.kind === "requirement").map((x) => x.id)]);
-  if (references.some((r) => !known.has(r))) fail6(t2("commit.unknownRequirement"));
+  if (references.some((r) => !known.has(r))) fail7(t2("commit.unknownRequirement"));
   const requirements = [.../* @__PURE__ */ new Set([...references, ...prepared.changes.filter((x) => x.kind === "requirement").map((x) => x.id)])].sort();
   const contextPaths = [.../* @__PURE__ */ new Set([...policyPaths(selected), ...extra])].sort();
   const hashes = async (list) => new Map(await Promise.all(list.map(async (p) => [p, await fingerprint(root, p)])));
@@ -26953,17 +27584,17 @@ async function specCommit(cwd, input2, dryRun) {
     ...prepared.changes.filter((c2) => c2.kind === "design").map((c2) => "Gitifact-Design: " + c2.id),
     ...prepared.changes.filter((c2) => c2.kind === "wiki").map((c2) => "Gitifact-Doc: " + c2.id)
   ];
-  const temporary = join13(gitDir, "gitifact-commit-index-" + randomUUID6());
+  const temporary = join14(gitDir, "gitifact-commit-index-" + randomUUID6());
   let owned = false;
   let uncertain = false;
   let indexLock;
   let committed;
   try {
     try {
-      await mkdir6(busy);
+      await mkdir7(busy);
       owned = true;
     } catch (e) {
-      if (e.code === "EEXIST") fail6(t2("commit.busy", { path: busy }));
+      if (e.code === "EEXIST") fail7(t2("commit.busy", { path: busy }));
       throw e;
     }
     await previewTransaction(cwd, current.stamp, async () => ({ writes, data: {}, recheck: c.recheck }), rename4, async (published) => {
@@ -26971,15 +27602,15 @@ async function specCommit(cwd, input2, dryRun) {
       try {
         const lock = indexLock = await open4(indexPath + ".lock", "wx", 384);
         const original = await optional2(indexPath);
-        if (hash2(original ?? Buffer.alloc(0)) !== indexHash || (await staged()).length) fail6(t2("commit.indexChanged"));
+        if (hash2(original ?? Buffer.alloc(0)) !== indexHash || (await staged()).length) fail7(t2("commit.indexChanged"));
         const locked = await hashes([.../* @__PURE__ */ new Set([...selected, ...contextPaths])]);
-        for (const [path3, value] of started) if (locked.get(path3) !== value) fail6(t2("commit.fileChangedRunning", { path: path3 }));
-        await writeFile4(join13(busy, "recovery.json"), JSON.stringify({ before: c.base, originalIndex: original?.toString("base64") ?? null, temporary, paths: selected, message, requirements }));
+        for (const [path3, value] of started) if (locked.get(path3) !== value) fail7(t2("commit.fileChangedRunning", { path: path3 }));
+        await writeFile4(join14(busy, "recovery.json"), JSON.stringify({ before: c.base, originalIndex: original?.toString("base64") ?? null, temporary, paths: selected, message, requirements }));
         if (original) await writeFile4(temporary, original, { flag: "wx" });
         else await git(["read-tree", "--empty"], temporary);
         await git(["add", "--", ...stageable], temporary);
         const actual = await staged(temporary);
-        if (!actual.length || actual.some((p) => !selected.includes(p))) fail6(t2("commit.unexpectedFiles"));
+        if (!actual.length || actual.some((p) => !selected.includes(p))) fail7(t2("commit.unexpectedFiles"));
         const records = selected.filter((p) => record2(p) && locked.get(p) !== null);
         if (records.length) {
           const output2 = await git(["cat-file", "--batch"], temporary, Buffer.from(records.map((p) => ":" + p).join("\n") + "\n"));
@@ -26988,32 +27619,32 @@ async function specCommit(cwd, input2, dryRun) {
             const end = output2.indexOf(10, offset);
             const header = output2.subarray(offset, end).toString("utf8").split(" ");
             const size = Number(header[2]);
-            if (end < 0 || header[1] !== "blob" || !Number.isSafeInteger(size) || output2[end + 1 + size] !== 10) fail6(t2("commit.stagedUnreadable", { path: path3 }));
+            if (end < 0 || header[1] !== "blob" || !Number.isSafeInteger(size) || output2[end + 1 + size] !== 10) fail7(t2("commit.stagedUnreadable", { path: path3 }));
             const staged2 = output2.subarray(end + 1, end + 1 + size);
-            const file2 = await readFile10(join13(root, path3));
-            if (!staged2.equals(file2) && !staged2.equals(Buffer.from(file2.toString("latin1").replace(/\r\n/g, "\n"), "latin1"))) fail6(t2("commit.filterChanged"));
+            const file2 = await readFile11(join14(root, path3));
+            if (!staged2.equals(file2) && !staged2.equals(Buffer.from(file2.toString("latin1").replace(/\r\n/g, "\n"), "latin1"))) fail7(t2("commit.filterChanged"));
             offset = end + size + 2;
           }
         }
         const again = await hashes([...locked.keys()]);
-        for (const [path3, value] of locked) if (again.get(path3) !== value) fail6(t2("commit.fileChangedPreparing", { path: path3 }));
-        if ((await readLockedPreviewState(root)).stamp !== published.stamp) fail6(t2("commit.specsChangedPreparing"));
-        for (const name of integration) if (await info5(join13(gitDir, name))) fail6(t2("commit.integrationStarted"));
-        if (!same2(c.base, await c.reader.baseline())) fail6(t2("commit.headChanged"));
+        for (const [path3, value] of locked) if (again.get(path3) !== value) fail7(t2("commit.fileChangedPreparing", { path: path3 }));
+        if ((await readLockedPreviewState(root)).stamp !== published.stamp) fail7(t2("commit.specsChangedPreparing"));
+        for (const name of integration) if (await info5(join14(gitDir, name))) fail7(t2("commit.integrationStarted"));
+        if (!same2(c.base, await c.reader.baseline())) fail7(t2("commit.headChanged"));
         const tree = (await git(["write-tree"], temporary)).toString("utf8").trim();
         commitStarted = true;
         await git(["commit", "-m", message.trim() + (trailers.length ? "\n\n" + trailers.join("\n") : "")], temporary);
         const after = await c.reader.baseline();
-        if (!after.head) return fail6(t2("commit.resultUnknown"));
+        if (!after.head) return fail7(t2("commit.resultUnknown"));
         const raw = (await git(["cat-file", "commit", after.head])).toString("utf8");
         const split = raw.indexOf("\n\n");
         const headers = raw.slice(0, split < 0 ? raw.length : split).split("\n");
         const body = split < 0 ? "" : raw.slice(split + 2);
         const parents = headers.filter((h) => h.startsWith("parent ")).map((h) => h.slice(7));
-        if (headers[0] !== "tree " + tree || after.branch !== c.base.branch || !same2(parents, c.base.head ? [c.base.head] : []) || trailers.some((t3) => !body.split(/\r?\n/).includes(t3))) fail6(t2("commit.resultAltered"));
-        if (hash2(await optional2(indexPath) ?? Buffer.alloc(0)) !== indexHash) fail6(t2("commit.indexChangedAfter"));
-        if ((await git(["write-tree"], temporary)).toString("utf8").trim() !== tree) fail6(t2("commit.hookChangedStaging"));
-        await lock.writeFile(await readFile10(temporary));
+        if (headers[0] !== "tree " + tree || after.branch !== c.base.branch || !same2(parents, c.base.head ? [c.base.head] : []) || trailers.some((t3) => !body.split(/\r?\n/).includes(t3))) fail7(t2("commit.resultAltered"));
+        if (hash2(await optional2(indexPath) ?? Buffer.alloc(0)) !== indexHash) fail7(t2("commit.indexChangedAfter"));
+        if ((await git(["write-tree"], temporary)).toString("utf8").trim() !== tree) fail7(t2("commit.hookChangedStaging"));
+        await lock.writeFile(await readFile11(temporary));
         await lock.sync();
         await lock.close();
         await rename4(indexPath + ".lock", indexPath);
@@ -27040,7 +27671,7 @@ async function specCommit(cwd, input2, dryRun) {
       await unlink5(temporary).catch(() => {
       });
       if (owned) {
-        await unlink5(join13(busy, "recovery.json")).catch(() => {
+        await unlink5(join14(busy, "recovery.json")).catch(() => {
         });
         await rmdir2(busy);
       }
@@ -27057,7 +27688,7 @@ async function execute(action, options, controls) {
   try {
     const guard = specPreviewReader(process.cwd());
     const { root, gitDir, objectFormat } = await guard.location();
-    for (const marker2 of operations) if (await fileInfo(join14(gitDir, marker2))) throw new InitError("GIT_OPERATION_IN_PROGRESS", t2("git.operationInProgress", { marker: marker2 }));
+    for (const marker2 of operations) if (await fileInfo(join15(gitDir, marker2))) throw new InitError("GIT_OPERATION_IN_PROGRESS", t2("git.operationInProgress", { marker: marker2 }));
     if (await guard.hasUnmerged()) throw new InitError("GIT_OPERATION_IN_PROGRESS", t2("git.resolveConflicts"));
     const raw = await readConfigFile(root);
     if (raw === void 0) throw new SpecPreviewError(t2("preview.notInitialized"));
@@ -27104,7 +27735,7 @@ async function execute(action, options, controls) {
 async function readInputFile(path3) {
   const source2 = await stat2(path3);
   if (!source2.isFile() || source2.size > 1024 * 1024) throw new SpecPreviewError(t2("preview.inputFile"));
-  return readFile11(path3);
+  return readFile12(path3);
 }
 async function readStdin(stream) {
   const chunks = [];
@@ -27136,8 +27767,8 @@ function narrowWorking(working, options, inputs) {
 }
 
 // src/commands/migrate.ts
-import { lstat as lstat9, readdir as readdir6, readFile as readFile12, rename as rename5, writeFile as writeFile5, unlink as unlink6 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { lstat as lstat9, readdir as readdir6, readFile as readFile13, rename as rename5, writeFile as writeFile5, unlink as unlink6 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 import { randomBytes as randomBytes3 } from "node:crypto";
 var operations2 = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merge", "rebase-apply", "sequencer", "BISECT_START", "index.lock"];
 var info6 = (path3) => lstat9(path3).catch((e) => {
@@ -27145,46 +27776,46 @@ var info6 = (path3) => lstat9(path3).catch((e) => {
   throw e;
 });
 var decode4 = (bytes) => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-var fail7 = (code, message) => {
+var fail8 = (code, message) => {
   throw new InitError(code, message);
 };
 async function migrateStore(cwd, dryRun = false) {
   const reader = specPreviewReader(cwd);
   const { root, gitDir } = await reader.location();
-  for (const marker3 of operations2) if (await info6(join15(gitDir, marker3))) fail7("GIT_OPERATION_IN_PROGRESS", t2("git.operationInProgress", { marker: marker3 }));
-  if (await reader.hasUnmerged()) fail7("GIT_OPERATION_IN_PROGRESS", t2("git.resolveConflicts"));
-  for (const name of [...LEGACY_LOCKS, "gitifact-spec-preview.lock", "gitifact-spec-commit.lock"]) if (await info6(join15(gitDir, name))) fail7("LOCKED", t2("migrate.locked", { path: join15(gitDir, name) }));
-  const from = join15(root, ".tryce");
-  const to = join15(root, ".gitifact");
+  for (const marker3 of operations2) if (await info6(join16(gitDir, marker3))) fail8("GIT_OPERATION_IN_PROGRESS", t2("git.operationInProgress", { marker: marker3 }));
+  if (await reader.hasUnmerged()) fail8("GIT_OPERATION_IN_PROGRESS", t2("git.resolveConflicts"));
+  for (const name of [...LEGACY_LOCKS, "gitifact-spec-preview.lock", "gitifact-spec-commit.lock"]) if (await info6(join16(gitDir, name))) fail8("LOCKED", t2("migrate.locked", { path: join16(gitDir, name) }));
+  const from = join16(root, ".tryce");
+  const to = join16(root, ".gitifact");
   const fromInfo = await info6(from);
-  if (await info6(to)) fail7("ALREADY_MIGRATED", t2("migrate.alreadyMigrated"));
-  if (!fromInfo) return fail7("NOTHING_TO_MIGRATE", t2("migrate.nothingToMigrate"));
-  if (!fromInfo.isDirectory() || fromInfo.isSymbolicLink()) fail7("PATH_CONFLICT", t2("migrate.notDirectory"));
-  const configInfo = await info6(join15(from, "config.json"));
-  if (!configInfo?.isFile() || configInfo.isSymbolicLink()) fail7("NOT_INITIALIZED", t2("migrate.noConfig"));
-  const config2 = parseManagedConfig(decode4(await readFile12(join15(from, "config.json"))));
-  if (!("schemaVersion" in config2)) fail7("UNSUPPORTED_FORMAT", t2("migrate.legacyJson"));
+  if (await info6(to)) fail8("ALREADY_MIGRATED", t2("migrate.alreadyMigrated"));
+  if (!fromInfo) return fail8("NOTHING_TO_MIGRATE", t2("migrate.nothingToMigrate"));
+  if (!fromInfo.isDirectory() || fromInfo.isSymbolicLink()) fail8("PATH_CONFLICT", t2("migrate.notDirectory"));
+  const configInfo = await info6(join16(from, "config.json"));
+  if (!configInfo?.isFile() || configInfo.isSymbolicLink()) fail8("NOT_INITIALIZED", t2("migrate.noConfig"));
+  const config2 = parseManagedConfig(decode4(await readFile13(join16(from, "config.json"))));
+  if (!("schemaVersion" in config2)) fail8("UNSUPPORTED_FORMAT", t2("migrate.legacyJson"));
   const top = (await readdir6(from)).sort();
-  if (top.some((name) => name !== "config.json" && name !== "spec")) fail7("UNSUPPORTED_FORMAT", t2("migrate.extraEntries"));
+  if (top.some((name) => name !== "config.json" && name !== "spec")) fail8("UNSUPPORTED_FORMAT", t2("migrate.extraEntries"));
   const files = /* @__PURE__ */ new Map();
   const rewrites = [];
   const legacyRecords = [];
   const marker2 = /^<!-- tryce-(spec|req|design|ref): /;
   if (top.includes("spec")) {
-    for (const feature2 of (await readdir6(join15(from, "spec"))).sort()) {
-      const dir = join15(from, "spec", feature2);
+    for (const feature2 of (await readdir6(join16(from, "spec"))).sort()) {
+      const dir = join16(from, "spec", feature2);
       const stat3 = await info6(dir);
-      if (!stat3?.isDirectory() || stat3.isSymbolicLink()) fail7("UNSUPPORTED_FORMAT", t2("migrate.notSpecFolder", { feature: feature2 }));
+      if (!stat3?.isDirectory() || stat3.isSymbolicLink()) fail8("UNSUPPORTED_FORMAT", t2("migrate.notSpecFolder", { feature: feature2 }));
       for (const name of (await readdir6(dir)).sort()) {
-        if (!["requirements.md", "design.md", "history.jsonl", "tryce.json"].includes(name)) fail7("UNSUPPORTED_FORMAT", t2("migrate.unsupportedFile", { feature: feature2, name }));
-        const fileStat = await info6(join15(dir, name));
-        if (!fileStat?.isFile() || fileStat.isSymbolicLink() || fileStat.nlink !== 1 || fileStat.size > 1024 * 1024) fail7("UNSUPPORTED_FORMAT", t2("migrate.fileTooLarge", { name }));
+        if (!["requirements.md", "design.md", "history.jsonl", "tryce.json"].includes(name)) fail8("UNSUPPORTED_FORMAT", t2("migrate.unsupportedFile", { feature: feature2, name }));
+        const fileStat = await info6(join16(dir, name));
+        if (!fileStat?.isFile() || fileStat.isSymbolicLink() || fileStat.nlink !== 1 || fileStat.size > 1024 * 1024) fail8("UNSUPPORTED_FORMAT", t2("migrate.fileTooLarge", { name }));
         const newPath = `.gitifact/spec/${feature2}/${name}`;
         if (name === "tryce.json") {
           legacyRecords.push(newPath);
           continue;
         }
-        const text2 = decode4(await readFile12(join15(dir, name)));
+        const text2 = decode4(await readFile13(join16(dir, name)));
         if (name === "history.jsonl") {
           files.set(newPath, text2);
           continue;
@@ -27229,8 +27860,8 @@ async function migrateStore(cwd, dryRun = false) {
   if (dryRun) return result("planned");
   await rename5(from, to);
   for (const r of rewrites) {
-    const full = join15(root, r.path);
-    const temp = join15(root, ".gitifact", "spec", ".gitifact-migrate-" + randomBytes3(8).toString("hex"));
+    const full = join16(root, r.path);
+    const temp = join16(root, ".gitifact", "spec", ".gitifact-migrate-" + randomBytes3(8).toString("hex"));
     await writeFile5(temp, r.content, { flag: "wx" });
     try {
       await rename5(temp, full);
@@ -27253,16 +27884,16 @@ async function runMigrate(options) {
 }
 
 // src/main.ts
-var program2 = new Command().name("gitifact").description(t2("help.program")).version("0.6.0").allowExcessArguments(false).addHelpText("after", "\n" + t2("help.notYet")).action(() => program2.outputHelp());
+var program2 = new Command().name("gitifact").description(t2("help.program")).version("0.6.1").allowExcessArguments(false).addHelpText("after", "\n" + t2("help.notYet")).action(() => program2.outputHelp());
 program2.command("status").description(t2("help.status")).allowExcessArguments(false).addOption(new Option("--format <format>", t2("help.format")).choices(["json", "text"]).default("json")).action(async (options) => {
   await runStatus(options.format);
 });
-program2.command("browser").description(t2("help.browser")).allowExcessArguments(false).option("--port <port>", t2("help.browserPort"), parsePort, 0).option("--dev", t2("help.browserDev")).option("--no-update-check", t2("help.browserNoUpdateCheck")).action((options) => runBrowser(options, "0.6.0"));
-program2.command("init").description(t2("help.init")).allowExcessArguments(false).option("--dry-run", t2("help.initDryRun")).addOption(new Option("--agent <agent>", t2("help.initAgent")).choices([...agentPresetNames])).addOption(new Option("--remove-agents", t2("help.initRemoveAgents")).conflicts("skipAgents")).option("--skip-agents", t2("help.initSkipAgents")).addOption(new Option("--format <format>", t2("help.format")).choices(["json", "text"]).default("json")).action((options) => runInit(options, "0.6.0"));
+program2.command("browser").description(t2("help.browser")).allowExcessArguments(false).option("--port <port>", t2("help.browserPort"), parsePort, 0).option("--dev", t2("help.browserDev")).option("--no-update-check", t2("help.browserNoUpdateCheck")).action((options) => runBrowser(options, "0.6.1"));
+program2.command("init").description(t2("help.init")).allowExcessArguments(false).option("--dry-run", t2("help.initDryRun")).addOption(new Option("--agent <agent>", t2("help.initAgent")).choices([...agentPresetNames])).addOption(new Option("--remove-agents", t2("help.initRemoveAgents")).conflicts("skipAgents")).option("--skip-agents", t2("help.initSkipAgents")).addOption(new Option("--format <format>", t2("help.format")).choices(["json", "text"]).default("json")).action((options) => runInit(options, "0.6.1"));
 program2.command("docs").description(t2("help.docs")).argument("[topic]", t2("help.docsTopic")).allowExcessArguments(false).action(async (topic) => {
   await runDocs(topic);
 });
-program2.command("update").description(t2("help.update")).allowExcessArguments(false).addOption(new Option("--format <format>", t2("help.format")).choices(["json", "text"]).default("json")).option("--commit", t2("help.updateCommit")).action((options) => runUpdate(options, "0.6.0"));
+program2.command("update").description(t2("help.update")).allowExcessArguments(false).addOption(new Option("--format <format>", t2("help.format")).choices(["json", "text"]).default("json")).option("--commit", t2("help.updateCommit")).action((options) => runUpdate(options, "0.6.1"));
 program2.command("migrate").description(t2("help.migrate")).allowExcessArguments(false).option("--dry-run", t2("help.migrateDryRun")).action(runMigrate);
 var spec = program2.command("spec").description(t2("help.spec"));
 spec.command("commit").description(t2("help.specCommit")).allowExcessArguments(false).requiredOption("--file <path>", t2("help.specCommitFile")).option("--dry-run", t2("help.specCommitDryRun")).action((o) => runSpecPreview("commit", o));