token-goat 2.6.31 → 2.6.32

package/dist/{token-goat-hook-chunk-2K7FV2ME.mjs → token-goat-hook-chunk-DJZGX27J.mjs}

@@ -8,7 +8,7 @@ import {
   isRewriteWorthwhile,
   resolveMinNetSavingsBytes,
   shlexSplit
-} from "./token-goat-hook-chunk-JVJUBWKT.mjs";
+} from "./token-goat-hook-chunk-VHZECEQD.mjs";
 import {
   BASH_OUTPUT_SUBDIR,
   HOOK_EVENTS,
@@ -26,7 +26,7 @@ import {
   storeBashOutput,
   storeWebOutput,
   summarizeOutputDelta
-} from "./token-goat-hook-chunk-JT5RMRIY.mjs";
+} from "./token-goat-hook-chunk-LFYT4DLB.mjs";
 import {
   BODY_FIRST_TOOL_RESPONSE_KEYS,
   OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
@@ -117,7 +117,7 @@ import {
   wasCliReadThisSession,
   wasFileReadThisSession,
   wasHintShown
-} from "./token-goat-hook-chunk-SJM4BUZQ.mjs";
+} from "./token-goat-hook-chunk-WBTHUYJP.mjs";
 import {
   VERSION,
   detectHarness,
@@ -134,10 +134,10 @@ import {
   runGit,
   shortFingerprint,
   toKB
-} from "./token-goat-hook-chunk-NIVRFAJ4.mjs";
+} from "./token-goat-hook-chunk-DHW6SRHR.mjs";
 import {
   init_define_import_meta_env
-} from "./token-goat-hook-chunk-7WC2H3EW.mjs";
+} from "./token-goat-hook-chunk-K33JMLL7.mjs";
 
 // src/relay.ts
 init_define_import_meta_env();
@@ -585,7 +585,7 @@ init_define_import_meta_env();
 var TRACKED_SKILL = "token-goat";
 var MAX_COMMANDS_SHOWN = 8;
 async function currentCommandNames() {
-  const { buildProgram } = await import("./token-goat-hook-chunk-YHRJMMEF.mjs");
+  const { buildProgram } = await import("./token-goat-hook-chunk-6NF4WM2U.mjs");
   return flattenCommandNames(buildCommandManifest(buildProgram()));
 }
 async function recordSkillVersionSnapshot(sessionId, skillName) {
@@ -2470,7 +2470,7 @@ var decodeMap = /* @__PURE__ */ new Map([
 ]);
 var fromCodePoint = (
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
-  (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : (codePoint) => {
+  (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : ((codePoint) => {
     let output = "";
     if (codePoint > 65535) {
       codePoint -= 65536;
@@ -2479,7 +2479,7 @@ var fromCodePoint = (
     }
     output += String.fromCharCode(codePoint);
     return output;
-  }
+  })
 );
 function replaceCodePoint(codePoint) {
   var _a3;
@@ -4883,17 +4883,51 @@ function parseDocument(data, options) {
 // node_modules/deepmerge-ts/dist/index.mjs
 init_define_import_meta_env();
 var actions = {
-  defaultMerge: Symbol("deepmerge-ts: default merge"),
-  skip: Symbol("deepmerge-ts: skip")
+  defaultMerge: /* @__PURE__ */ Symbol("deepmerge-ts: default merge"),
+  skip: /* @__PURE__ */ Symbol("deepmerge-ts: skip")
 };
 var actionsInto = {
   defaultMerge: actions.defaultMerge
 };
-function defaultMetaDataUpdater(previousMeta, metaMeta) {
-  return metaMeta;
+function defaultMetaDataUpdater(previousMeta, mergeInfo) {
+  const ancestor = {
+    key: mergeInfo.key,
+    parents: mergeInfo.parents,
+    values: mergeInfo.values,
+    result: mergeInfo.result
+  };
+  const prevHierarchy = previousMeta?.hierarchy;
+  return {
+    ...ancestor,
+    hierarchy: prevHierarchy === void 0 ? [ancestor] : [...prevHierarchy, ancestor]
+  };
 }
 function defaultFilterValues(values, meta) {
-  return values.filter((value) => value !== void 0);
+  return values.includes(void 0) ? values.filter((value) => value !== void 0) : values;
+}
+function shouldFallbackToDefault(utils, fallback, result) {
+  return result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions[fallback] !== utils.defaultMergeFunctions[fallback];
+}
+function resolveCustomMergeFunctions(options, defaultMergeFunctions) {
+  return {
+    ...defaultMergeFunctions,
+    ...Object.fromEntries(Object.entries(options).filter(([key]) => Object.hasOwn(defaultMergeFunctions, key)).map(([key, option2]) => option2 === false ? [key, defaultMergeFunctions.mergeOthers] : typeof option2 === "function" ? [key, option2] : [key, defaultMergeFunctions[key]]))
+  };
+}
+function mergeArrays$1(values, utils, meta) {
+  return values.flat();
+}
+function mergeSets$1(values, utils, meta) {
+  const result = /* @__PURE__ */ new Set();
+  for (const set of values) {
+    for (const element of set) {
+      result.add(element);
+    }
+  }
+  return result;
+}
+function mergeOthers$1(values, utils, meta) {
+  return values.at(-1);
 }
 var ObjectType;
 (function(ObjectType2) {
@@ -4922,78 +4956,127 @@ function getObjectType(object) {
   }
   return ObjectType.OTHER;
 }
-function getKeys(objects) {
+function getKeysOfObjects(objects) {
   const keys = /* @__PURE__ */ new Set();
-  for (const object of objects) {
-    for (const key of [...Object.keys(object), ...Object.getOwnPropertySymbols(object)]) {
-      keys.add(key);
+  for (const currentObject of objects) {
+    const stringKeys = Object.keys(currentObject);
+    for (const stringKey of stringKeys) {
+      keys.add(stringKey);
+    }
+    const symbols = Object.getOwnPropertySymbols(currentObject);
+    if (symbols.length > 0) {
+      for (const symbol of symbols) {
+        if (Object.prototype.propertyIsEnumerable.call(currentObject, symbol)) {
+          keys.add(symbol);
+        }
+      }
     }
   }
   return keys;
 }
+function getKeysOfObject(object) {
+  const symbols = Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+  return [...Object.keys(object), ...symbols];
+}
 function objectHasProperty(object, property) {
   return typeof object === "object" && Object.prototype.propertyIsEnumerable.call(object, property);
 }
-function getIterableOfIterables(iterables) {
-  let mut_iterablesIndex = 0;
-  let mut_iterator = iterables[0]?.[Symbol.iterator]();
-  return {
-    [Symbol.iterator]() {
-      return {
-        next() {
-          do {
-            if (mut_iterator === void 0) {
-              return { done: true, value: void 0 };
-            }
-            const result = mut_iterator.next();
-            if (result.done === true) {
-              mut_iterablesIndex += 1;
-              mut_iterator = iterables[mut_iterablesIndex]?.[Symbol.iterator]();
-              continue;
-            }
-            return {
-              done: false,
-              value: result.value
-            };
-          } while (true);
-        }
-      };
-    }
-  };
-}
-var validRecordToStringValues = ["[object Object]", "[object Module]"];
 function isRecord(value) {
-  if (!validRecordToStringValues.includes(Object.prototype.toString.call(value))) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype === null || prototype === Object.prototype) {
+    return true;
+  }
+  const objectToString = Object.prototype.toString.call(value);
+  if (objectToString !== "[object Object]" && objectToString !== "[object Module]") {
     return false;
   }
   const { constructor } = value;
   if (constructor === void 0) {
     return true;
   }
-  const prototype = constructor.prototype;
-  if (prototype === null || typeof prototype !== "object" || !validRecordToStringValues.includes(Object.prototype.toString.call(prototype))) {
+  const constructorPrototype = constructor.prototype;
+  if (constructorPrototype === null || typeof constructorPrototype !== "object") {
+    return false;
+  }
+  const constructorToString = Object.prototype.toString.call(constructorPrototype);
+  if (constructorToString !== "[object Object]" && constructorToString !== "[object Module]") {
     return false;
   }
-  if (!prototype.hasOwnProperty("isPrototypeOf")) {
+  if (!Object.hasOwn(constructorPrototype, "isPrototypeOf")) {
     return false;
   }
   return true;
 }
+function getCyclicReferenceDepth(object, hierarchy, index) {
+  if (hierarchy === void 0 || hierarchy.length === 0) {
+    return 0;
+  }
+  let mut_depth = 1;
+  for (let mut_index = hierarchy.length - 1; mut_index >= 0; mut_index--) {
+    const { parents } = hierarchy[mut_index];
+    if (parents[index] === object || parents.includes(object)) {
+      return mut_depth;
+    }
+    mut_depth += 1;
+  }
+  return 0;
+}
+function getMetaDataHierarchy(meta) {
+  return meta?.hierarchy;
+}
 function mergeRecords$1(values, utils, meta) {
+  if (values.length === 2) {
+    const result = {};
+    const mergeProperty = (key, propValues) => {
+      const updatedMeta = utils.metaDataUpdater(meta, {
+        key,
+        parents: values,
+        values: propValues,
+        result
+      });
+      const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);
+      if (propertyResult === actions.skip) {
+        return;
+      }
+      if (key === "__proto__") {
+        Object.defineProperty(result, key, {
+          value: propertyResult,
+          configurable: true,
+          enumerable: true,
+          writable: true
+        });
+      } else {
+        result[key] = propertyResult;
+      }
+    };
+    const firstValue = values[0];
+    const secondValue = values[1];
+    for (const key of getKeysOfObject(firstValue)) {
+      mergeProperty(key, objectHasProperty(secondValue, key) ? [firstValue[key], secondValue[key]] : [firstValue[key]]);
+    }
+    for (const key of getKeysOfObject(secondValue)) {
+      if (!objectHasProperty(firstValue, key)) {
+        mergeProperty(key, [secondValue[key]]);
+      }
+    }
+    return result;
+  }
+  return mergeRecordsGeneral(values, utils, meta);
+}
+function mergeRecordsGeneral(values, utils, meta) {
   const result = {};
-  for (const key of getKeys(values)) {
+  for (const key of getKeysOfObjects(values)) {
     const propValues = [];
     for (const value of values) {
       if (objectHasProperty(value, key)) {
         propValues.push(value[key]);
       }
     }
-    if (propValues.length === 0) {
-      continue;
-    }
     const updatedMeta = utils.metaDataUpdater(meta, {
       key,
-      parents: values
+      parents: values,
+      values: propValues,
+      result
     });
     const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);
     if (propertyResult === actions.skip) {
@@ -5012,43 +5095,112 @@ function mergeRecords$1(values, utils, meta) {
   }
   return result;
 }
-function mergeArrays$1(values) {
-  return values.flat();
-}
-function mergeSets$1(values) {
-  return new Set(getIterableOfIterables(values));
+function mergeMaps$1(values, utils, meta) {
+  const result = /* @__PURE__ */ new Map();
+  const valuesByKey = /* @__PURE__ */ new Map();
+  for (const map2 of values) {
+    for (const [key, value] of map2) {
+      const mut_keyValues = valuesByKey.get(key);
+      if (mut_keyValues === void 0) {
+        valuesByKey.set(key, [value]);
+      } else {
+        mut_keyValues.push(value);
+      }
+    }
+  }
+  for (const [key, keyValues] of valuesByKey) {
+    const updatedMeta = utils.metaDataUpdater(meta, {
+      key,
+      parents: values,
+      values: keyValues,
+      result
+    });
+    const keyResult = mergeUnknowns(keyValues, utils, updatedMeta);
+    if (keyResult === actions.skip) {
+      continue;
+    }
+    result.set(key, keyResult);
+  }
+  return result;
 }
-function mergeMaps$1(values) {
-  return new Map(getIterableOfIterables(values));
+function resolveCyclicReferences(value, utils, meta) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const hierarchy = getMetaDataHierarchy(meta);
+  const depth = getCyclicReferenceDepth(value, hierarchy, 0);
+  if (depth > 0 && hierarchy !== void 0) {
+    return hierarchy[hierarchy.length - depth]?.result;
+  }
+  const type = getObjectType(value);
+  if (type === ObjectType.RECORD) {
+    const record = value;
+    let mut_changed = false;
+    const result = {};
+    for (const key of getKeysOfObject(record)) {
+      const propVal = record[key];
+      const updatedMeta = utils.metaDataUpdater(meta, {
+        key,
+        parents: [record],
+        values: [propVal],
+        result
+      });
+      const resolvedProp = resolveCyclicReferences(propVal, utils, updatedMeta);
+      if (resolvedProp !== propVal) {
+        mut_changed = true;
+      }
+      if (key === "__proto__") {
+        Object.defineProperty(result, key, {
+          value: resolvedProp,
+          configurable: true,
+          enumerable: true,
+          writable: true
+        });
+      } else {
+        result[key] = resolvedProp;
+      }
+    }
+    return mut_changed ? result : value;
+  }
+  return value;
 }
-function mergeOthers$1(values) {
-  return values.at(-1);
+function mergeCircularReferences$1(values, cyclicDepths, utils, meta) {
+  const depth = cyclicDepths[0];
+  const hierarchy = getMetaDataHierarchy(meta);
+  for (let mut_index = 1; mut_index < values.length; mut_index++) {
+    if (cyclicDepths[mut_index] !== depth) {
+      const lastCyclicDepth = cyclicDepths.at(-1);
+      return lastCyclicDepth === 0 ? resolveCyclicReferences(values.at(-1), utils, meta) : hierarchy?.[hierarchy.length - lastCyclicDepth]?.result;
+    }
+  }
+  return hierarchy?.[hierarchy.length - depth]?.result;
 }
 var mergeFunctions = {
   mergeRecords: mergeRecords$1,
   mergeArrays: mergeArrays$1,
   mergeSets: mergeSets$1,
   mergeMaps: mergeMaps$1,
+  mergeCircularReferences: mergeCircularReferences$1,
   mergeOthers: mergeOthers$1
 };
-function deepmergeCustom(options, rootMetaData) {
-  const utils = getUtils(options, customizedDeepmerge);
+function deepmergeCustom(options = {}, rootMetaData) {
+  const utils = getUtils$1(options, customizedDeepmerge);
   function customizedDeepmerge(...objects) {
-    return mergeUnknowns(objects, utils, rootMetaData);
+    return mergeUnknowns(objects, utils, rootMetaData ?? void 0);
   }
   return customizedDeepmerge;
 }
-function getUtils(options, customizedDeepmerge) {
+function getUtils$1(options, customizedDeepmerge) {
+  const defaultMergeFns = mergeFunctions;
+  const defaultMetaDataUpd = defaultMetaDataUpdater;
   return {
-    defaultMergeFunctions: mergeFunctions,
-    mergeFunctions: {
-      ...mergeFunctions,
-      ...Object.fromEntries(Object.entries(options).filter(([key, option2]) => Object.hasOwn(mergeFunctions, key)).map(([key, option2]) => option2 === false ? [key, mergeFunctions.mergeOthers] : [key, option2]))
-    },
-    metaDataUpdater: options.metaDataUpdater ?? defaultMetaDataUpdater,
+    defaultMergeFunctions: defaultMergeFns,
+    mergeFunctions: resolveCustomMergeFunctions(options, defaultMergeFns),
+    metaDataUpdater: typeof options.metaDataUpdater === "function" ? options.metaDataUpdater : defaultMetaDataUpd,
     deepmerge: customizedDeepmerge,
     useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,
-    filterValues: options.filterValues === false ? void 0 : options.filterValues ?? defaultFilterValues,
+    filterValues: options.filterValues === false ? void 0 : typeof options.filterValues === "function" ? options.filterValues : defaultFilterValues,
+    maxDepth: typeof options.maxDepth === "number" && !Number.isNaN(options.maxDepth) && options.maxDepth >= 0 ? options.maxDepth : 1e3,
     actions
   };
 }
@@ -5057,16 +5209,43 @@ function mergeUnknowns(values, utils, meta) {
   if (filteredValues.length === 0) {
     return void 0;
   }
+  const hierarchy = getMetaDataHierarchy(meta);
+  const currentDepth = hierarchy?.length ?? (typeof meta === "number" ? meta : meta?.depth ?? 0);
+  if (utils.maxDepth !== void 0 && currentDepth >= utils.maxDepth) {
+    return mergeOthers(filteredValues, utils, meta);
+  }
   if (filteredValues.length === 1) {
+    if (hierarchy !== void 0) {
+      const depth = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
+      if (depth > 0) {
+        return hierarchy[hierarchy.length - depth]?.result ?? hierarchy[hierarchy.length - depth]?.parents[0];
+      }
+    }
     return mergeOthers(filteredValues, utils, meta);
   }
   const type = getObjectType(filteredValues[0]);
   if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
-    for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
-      if (getObjectType(filteredValues[mut_index]) === type) {
-        continue;
+    if (filteredValues.length === 2) {
+      if (getObjectType(filteredValues[1]) !== type) {
+        return mergeOthers(filteredValues, utils, meta);
+      }
+      const d0 = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
+      const d1 = getCyclicReferenceDepth(filteredValues[1], hierarchy, 1);
+      if (d0 !== 0 || d1 !== 0) {
+        return mergeCircularReferences(filteredValues, [d0, d1], utils, meta);
+      }
+    } else {
+      const cyclicDepths = new Array(filteredValues.length);
+      cyclicDepths[0] = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
+      for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
+        if (getObjectType(filteredValues[mut_index]) !== type) {
+          return mergeOthers(filteredValues, utils, meta);
+        }
+        cyclicDepths[mut_index] = getCyclicReferenceDepth(filteredValues[mut_index], hierarchy, mut_index);
+      }
+      if (cyclicDepths.some((depth) => depth !== 0)) {
+        return mergeCircularReferences(filteredValues, cyclicDepths, utils, meta);
       }
-      return mergeOthers(filteredValues, utils, meta);
     }
   }
   switch (type) {
@@ -5089,35 +5268,42 @@ function mergeUnknowns(values, utils, meta) {
 }
 function mergeRecords(values, utils, meta) {
   const result = utils.mergeFunctions.mergeRecords(values, utils, meta);
-  if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeRecords !== utils.defaultMergeFunctions.mergeRecords) {
+  if (shouldFallbackToDefault(utils, "mergeRecords", result)) {
     return utils.defaultMergeFunctions.mergeRecords(values, utils, meta);
   }
   return result;
 }
 function mergeArrays(values, utils, meta) {
   const result = utils.mergeFunctions.mergeArrays(values, utils, meta);
-  if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeArrays !== utils.defaultMergeFunctions.mergeArrays) {
+  if (shouldFallbackToDefault(utils, "mergeArrays", result)) {
     return utils.defaultMergeFunctions.mergeArrays(values);
   }
   return result;
 }
 function mergeSets(values, utils, meta) {
   const result = utils.mergeFunctions.mergeSets(values, utils, meta);
-  if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeSets !== utils.defaultMergeFunctions.mergeSets) {
+  if (shouldFallbackToDefault(utils, "mergeSets", result)) {
     return utils.defaultMergeFunctions.mergeSets(values);
   }
   return result;
 }
 function mergeMaps(values, utils, meta) {
   const result = utils.mergeFunctions.mergeMaps(values, utils, meta);
-  if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeMaps !== utils.defaultMergeFunctions.mergeMaps) {
-    return utils.defaultMergeFunctions.mergeMaps(values);
+  if (shouldFallbackToDefault(utils, "mergeMaps", result)) {
+    return utils.defaultMergeFunctions.mergeMaps(values, utils, meta);
+  }
+  return result;
+}
+function mergeCircularReferences(values, cyclicDepths, utils, meta) {
+  const result = utils.mergeFunctions.mergeCircularReferences(values, cyclicDepths, utils, meta);
+  if (shouldFallbackToDefault(utils, "mergeCircularReferences", result)) {
+    return utils.defaultMergeFunctions.mergeCircularReferences(values, cyclicDepths, utils, meta);
   }
   return result;
 }
 function mergeOthers(values, utils, meta) {
   const result = utils.mergeFunctions.mergeOthers(values, utils, meta);
-  if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeOthers !== utils.defaultMergeFunctions.mergeOthers) {
+  if (shouldFallbackToDefault(utils, "mergeOthers", result)) {
     return utils.defaultMergeFunctions.mergeOthers(values);
   }
   return result;
@@ -5431,7 +5617,7 @@ var WhitespaceProcessor = class {
     this.newlineOrNonNewlineStringRe = new RegExp(`(\\n|[^\\n]+)`, "g");
     if (options.preserveNewlines) {
       const wordOrNewlineRe = new RegExp(`\\n|[^\\n${whitespaceCodes}]+`, "gm");
-      this.shrinkWrapAdd = function(text, inlineTextBuilder, transform = (str) => str, noWrap = false) {
+      this.shrinkWrapAdd = function(text, inlineTextBuilder, transform = ((str) => str), noWrap = false) {
         if (!text) {
           return;
         }
@@ -5459,7 +5645,7 @@ var WhitespaceProcessor = class {
       };
     } else {
       const wordRe = new RegExp(`[^${whitespaceCodes}]+`, "g");
-      this.shrinkWrapAdd = function(text, inlineTextBuilder, transform = (str) => str, noWrap = false) {
+      this.shrinkWrapAdd = function(text, inlineTextBuilder, transform = ((str) => str), noWrap = false) {
         if (!text) {
           return;
         }
@@ -5624,7 +5810,7 @@ var BlockTextBuilder = class {
   }
   /** @returns { (str: string) => string } */
   _getCombinedWordTransformer() {
-    const wt = this._wordTransformer ? (str) => applyTransformer(str, this._wordTransformer) : void 0;
+    const wt = this._wordTransformer ? ((str) => applyTransformer(str, this._wordTransformer)) : void 0;
     const ce = this.options.encodeCharacters;
     return wt ? ce ? (str) => ce(wt(str)) : wt : ce;
   }
@@ -6205,7 +6391,7 @@ function composeOptions({
 }) {
   const options = deepMergeWithOptionsComposeRules(defaultOptions, userOptions);
   options.formatters = Object.assign({}, genericFormatters2, packageFormatters, options.formatters);
-  options.selectors = mergeDuplicatesPreferLast(options.selectors, (s) => s.selector);
+  options.selectors = mergeDuplicatesPreferLast(options.selectors, ((s) => s.selector));
   if (handleMergedOptions) {
     handleMergedOptions(options);
   }
@@ -6684,7 +6870,7 @@ function handleDeprecatedOptions(options) {
       ([selector, definition]) => ({ ...definition, selector: selector || "*" })
     );
     options.selectors.push(...tagDefinitions);
-    options.selectors = mergeDuplicatesPreferLast(options.selectors, (s) => s.selector);
+    options.selectors = mergeDuplicatesPreferLast(options.selectors, ((s) => s.selector));
   }
   function set(obj, path2, value) {
     const valueKey = path2.pop();

package/dist/{token-goat-hook-chunk-KNVHTGEX.mjs → token-goat-hook-chunk-J2ZK2FYW.mjs}

@@ -2,7 +2,7 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   init_define_import_meta_env
-} from "./token-goat-hook-chunk-7WC2H3EW.mjs";
+} from "./token-goat-hook-chunk-K33JMLL7.mjs";
 
 // src/reset.ts
 init_define_import_meta_env();

package/dist/{token-goat-hook-chunk-7WC2H3EW.mjs → token-goat-hook-chunk-K33JMLL7.mjs}

@@ -12,11 +12,20 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)

package/dist/{token-goat-hook-chunk-JT5RMRIY.mjs → token-goat-hook-chunk-LFYT4DLB.mjs}

@@ -6,7 +6,7 @@ import {
   loadBlob,
   sanitizeFtsQuery,
   storeBlob
-} from "./token-goat-hook-chunk-SJM4BUZQ.mjs";
+} from "./token-goat-hook-chunk-WBTHUYJP.mjs";
 import {
   SYMBOL_BODY_CHAR_CAP,
   extractErrorMessage,
@@ -16,13 +16,13 @@ import {
   redactSecrets,
   runGit,
   shortFingerprint
-} from "./token-goat-hook-chunk-NIVRFAJ4.mjs";
+} from "./token-goat-hook-chunk-DHW6SRHR.mjs";
 import {
   registerReset
-} from "./token-goat-hook-chunk-KNVHTGEX.mjs";
+} from "./token-goat-hook-chunk-J2ZK2FYW.mjs";
 import {
   init_define_import_meta_env
-} from "./token-goat-hook-chunk-7WC2H3EW.mjs";
+} from "./token-goat-hook-chunk-K33JMLL7.mjs";
 
 // src/hooks_cli.ts
 init_define_import_meta_env();

package/dist/{token-goat-hook-chunk-5AQYD2SZ.mjs → token-goat-hook-chunk-PCP4W65Z.mjs}

@@ -2,10 +2,10 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   clearModuleCaches
-} from "./token-goat-hook-chunk-KNVHTGEX.mjs";
+} from "./token-goat-hook-chunk-J2ZK2FYW.mjs";
 import {
   init_define_import_meta_env
-} from "./token-goat-hook-chunk-7WC2H3EW.mjs";
+} from "./token-goat-hook-chunk-K33JMLL7.mjs";
 
 // src/batch_serve.ts
 init_define_import_meta_env();
@@ -23,12 +23,12 @@ function captureOutput() {
   let errText = "";
   const realOut = process.stdout.write.bind(process.stdout);
   const realErr = process.stderr.write.bind(process.stderr);
-  const sink = (append) => (chunk, enc, cb) => {
+  const sink = (append) => ((chunk, enc, cb) => {
     append(typeof chunk === "string" ? chunk : String(chunk));
     const done = typeof enc === "function" ? enc : cb;
     if (typeof done === "function") done();
     return true;
-  };
+  });
   process.stdout.write = sink((s) => {
     out += s;
   });