fathom-cli 0.1.4 → 0.1.7

package/dist/index.js

@@ -789,41 +789,41 @@ var ZodType = class {
   get description() {
     return this._def.description;
   }
-  _getType(input) {
-    return getParsedType(input.data);
+  _getType(input2) {
+    return getParsedType(input2.data);
   }
-  _getOrReturnCtx(input, ctx) {
+  _getOrReturnCtx(input2, ctx) {
     return ctx || {
-      common: input.parent.common,
-      data: input.data,
-      parsedType: getParsedType(input.data),
+      common: input2.parent.common,
+      data: input2.data,
+      parsedType: getParsedType(input2.data),
       schemaErrorMap: this._def.errorMap,
-      path: input.path,
-      parent: input.parent
+      path: input2.path,
+      parent: input2.parent
     };
   }
-  _processInputParams(input) {
+  _processInputParams(input2) {
     return {
       status: new ParseStatus(),
       ctx: {
-        common: input.parent.common,
-        data: input.data,
-        parsedType: getParsedType(input.data),
+        common: input2.parent.common,
+        data: input2.data,
+        parsedType: getParsedType(input2.data),
         schemaErrorMap: this._def.errorMap,
-        path: input.path,
-        parent: input.parent
+        path: input2.path,
+        parent: input2.parent
       }
     };
   }
-  _parseSync(input) {
-    const result = this._parse(input);
+  _parseSync(input2) {
+    const result = this._parse(input2);
     if (isAsync(result)) {
       throw new Error("Synchronous parse encountered promise.");
     }
     return result;
   }
-  _parseAsync(input) {
-    const result = this._parse(input);
+  _parseAsync(input2) {
+    const result = this._parse(input2);
     return Promise.resolve(result);
   }
   parse(data, params) {
@@ -1149,13 +1149,13 @@ function isValidCidr(ip, version) {
   return false;
 }
 var ZodString = class _ZodString extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = String(input.data);
+      input2.data = String(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.string) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.string,
@@ -1167,8 +1167,8 @@ var ZodString = class _ZodString extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input.data.length < check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.length < check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -1180,8 +1180,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input.data.length > check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.length > check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -1193,10 +1193,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "length") {
-        const tooBig = input.data.length > check.value;
-        const tooSmall = input.data.length < check.value;
+        const tooBig = input2.data.length > check.value;
+        const tooSmall = input2.data.length < check.value;
         if (tooBig || tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           if (tooBig) {
             addIssueToContext(ctx, {
               code: ZodIssueCode.too_big,
@@ -1219,8 +1219,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "email") {
-        if (!emailRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!emailRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "email",
             code: ZodIssueCode.invalid_string,
@@ -1232,8 +1232,8 @@ var ZodString = class _ZodString extends ZodType {
         if (!emojiRegex) {
           emojiRegex = new RegExp(_emojiRegex, "u");
         }
-        if (!emojiRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!emojiRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "emoji",
             code: ZodIssueCode.invalid_string,
@@ -1242,8 +1242,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "uuid") {
-        if (!uuidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!uuidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "uuid",
             code: ZodIssueCode.invalid_string,
@@ -1252,8 +1252,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "nanoid") {
-        if (!nanoidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!nanoidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "nanoid",
             code: ZodIssueCode.invalid_string,
@@ -1262,8 +1262,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid") {
-        if (!cuidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!cuidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cuid",
             code: ZodIssueCode.invalid_string,
@@ -1272,8 +1272,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid2") {
-        if (!cuid2Regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!cuid2Regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cuid2",
             code: ZodIssueCode.invalid_string,
@@ -1282,8 +1282,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ulid") {
-        if (!ulidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!ulidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "ulid",
             code: ZodIssueCode.invalid_string,
@@ -1293,9 +1293,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "url") {
         try {
-          new URL(input.data);
+          new URL(input2.data);
         } catch {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "url",
             code: ZodIssueCode.invalid_string,
@@ -1305,9 +1305,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "regex") {
         check.regex.lastIndex = 0;
-        const testResult = check.regex.test(input.data);
+        const testResult = check.regex.test(input2.data);
         if (!testResult) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "regex",
             code: ZodIssueCode.invalid_string,
@@ -1316,10 +1316,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "trim") {
-        input.data = input.data.trim();
+        input2.data = input2.data.trim();
       } else if (check.kind === "includes") {
-        if (!input.data.includes(check.value, check.position)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.includes(check.value, check.position)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { includes: check.value, position: check.position },
@@ -1328,12 +1328,12 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "toLowerCase") {
-        input.data = input.data.toLowerCase();
+        input2.data = input2.data.toLowerCase();
       } else if (check.kind === "toUpperCase") {
-        input.data = input.data.toUpperCase();
+        input2.data = input2.data.toUpperCase();
       } else if (check.kind === "startsWith") {
-        if (!input.data.startsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.startsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { startsWith: check.value },
@@ -1342,8 +1342,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "endsWith") {
-        if (!input.data.endsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.endsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { endsWith: check.value },
@@ -1353,8 +1353,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "datetime") {
         const regex = datetimeRegex(check);
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "datetime",
@@ -1364,8 +1364,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "date") {
         const regex = dateRegex;
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "date",
@@ -1375,8 +1375,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "time") {
         const regex = timeRegex(check);
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "time",
@@ -1385,8 +1385,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "duration") {
-        if (!durationRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!durationRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "duration",
             code: ZodIssueCode.invalid_string,
@@ -1395,8 +1395,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ip") {
-        if (!isValidIP(input.data, check.version)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidIP(input2.data, check.version)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "ip",
             code: ZodIssueCode.invalid_string,
@@ -1405,8 +1405,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "jwt") {
-        if (!isValidJWT(input.data, check.alg)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidJWT(input2.data, check.alg)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "jwt",
             code: ZodIssueCode.invalid_string,
@@ -1415,8 +1415,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cidr") {
-        if (!isValidCidr(input.data, check.version)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidCidr(input2.data, check.version)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cidr",
             code: ZodIssueCode.invalid_string,
@@ -1425,8 +1425,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64") {
-        if (!base64Regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!base64Regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "base64",
             code: ZodIssueCode.invalid_string,
@@ -1435,8 +1435,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64url") {
-        if (!base64urlRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!base64urlRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "base64url",
             code: ZodIssueCode.invalid_string,
@@ -1448,7 +1448,7 @@ var ZodString = class _ZodString extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
   _regex(regex, validation, message) {
     return this.refinement((data) => regex.test(data), {
@@ -1709,13 +1709,13 @@ var ZodNumber = class _ZodNumber extends ZodType {
     this.max = this.lte;
     this.step = this.multipleOf;
   }
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = Number(input.data);
+      input2.data = Number(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.number) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.number,
@@ -1727,8 +1727,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
     const status = new ParseStatus();
     for (const check of this._def.checks) {
       if (check.kind === "int") {
-        if (!util.isInteger(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!util.isInteger(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: "integer",
@@ -1738,9 +1738,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -1752,9 +1752,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -1766,8 +1766,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (floatSafeRemainder(input.data, check.value) !== 0) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (floatSafeRemainder(input2.data, check.value) !== 0) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -1776,8 +1776,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "finite") {
-        if (!Number.isFinite(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!Number.isFinite(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_finite,
             message: check.message
@@ -1788,7 +1788,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
   gte(value, message) {
     return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -1940,25 +1940,25 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
     this.min = this.gte;
     this.max = this.lte;
   }
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
       try {
-        input.data = BigInt(input.data);
+        input2.data = BigInt(input2.data);
       } catch {
-        return this._getInvalidInput(input);
+        return this._getInvalidInput(input2);
       }
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.bigint) {
-      return this._getInvalidInput(input);
+      return this._getInvalidInput(input2);
     }
     let ctx = void 0;
     const status = new ParseStatus();
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             type: "bigint",
@@ -1969,9 +1969,9 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             type: "bigint",
@@ -1982,8 +1982,8 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (input.data % check.value !== BigInt(0)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data % check.value !== BigInt(0)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -1995,10 +1995,10 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
-  _getInvalidInput(input) {
-    const ctx = this._getOrReturnCtx(input);
+  _getInvalidInput(input2) {
+    const ctx = this._getOrReturnCtx(input2);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.bigint,
@@ -2107,13 +2107,13 @@ ZodBigInt.create = (params) => {
   });
 };
 var ZodBoolean = class extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = Boolean(input.data);
+      input2.data = Boolean(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.boolean) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.boolean,
@@ -2121,7 +2121,7 @@ var ZodBoolean = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodBoolean.create = (params) => {
@@ -2132,13 +2132,13 @@ ZodBoolean.create = (params) => {
   });
 };
 var ZodDate = class _ZodDate extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = new Date(input.data);
+      input2.data = new Date(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.date) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.date,
@@ -2146,8 +2146,8 @@ var ZodDate = class _ZodDate extends ZodType {
       });
       return INVALID;
     }
-    if (Number.isNaN(input.data.getTime())) {
-      const ctx2 = this._getOrReturnCtx(input);
+    if (Number.isNaN(input2.data.getTime())) {
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_date
       });
@@ -2157,8 +2157,8 @@ var ZodDate = class _ZodDate extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input.data.getTime() < check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.getTime() < check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             message: check.message,
@@ -2170,8 +2170,8 @@ var ZodDate = class _ZodDate extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input.data.getTime() > check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.getTime() > check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             message: check.message,
@@ -2188,7 +2188,7 @@ var ZodDate = class _ZodDate extends ZodType {
     }
     return {
       status: status.value,
-      value: new Date(input.data.getTime())
+      value: new Date(input2.data.getTime())
     };
   }
   _addCheck(check) {
@@ -2241,10 +2241,10 @@ ZodDate.create = (params) => {
   });
 };
 var ZodSymbol = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.symbol) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.symbol,
@@ -2252,7 +2252,7 @@ var ZodSymbol = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodSymbol.create = (params) => {
@@ -2262,10 +2262,10 @@ ZodSymbol.create = (params) => {
   });
 };
 var ZodUndefined = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.undefined,
@@ -2273,7 +2273,7 @@ var ZodUndefined = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodUndefined.create = (params) => {
@@ -2283,10 +2283,10 @@ ZodUndefined.create = (params) => {
   });
 };
 var ZodNull = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.null) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.null,
@@ -2294,7 +2294,7 @@ var ZodNull = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodNull.create = (params) => {
@@ -2308,8 +2308,8 @@ var ZodAny = class extends ZodType {
     super(...arguments);
     this._any = true;
   }
-  _parse(input) {
-    return OK(input.data);
+  _parse(input2) {
+    return OK(input2.data);
   }
 };
 ZodAny.create = (params) => {
@@ -2323,8 +2323,8 @@ var ZodUnknown = class extends ZodType {
     super(...arguments);
     this._unknown = true;
   }
-  _parse(input) {
-    return OK(input.data);
+  _parse(input2) {
+    return OK(input2.data);
   }
 };
 ZodUnknown.create = (params) => {
@@ -2334,8 +2334,8 @@ ZodUnknown.create = (params) => {
   });
 };
 var ZodNever = class extends ZodType {
-  _parse(input) {
-    const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    const ctx = this._getOrReturnCtx(input2);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.never,
@@ -2351,10 +2351,10 @@ ZodNever.create = (params) => {
   });
 };
 var ZodVoid = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.void,
@@ -2362,7 +2362,7 @@ var ZodVoid = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodVoid.create = (params) => {
@@ -2372,8 +2372,8 @@ ZodVoid.create = (params) => {
   });
 };
 var ZodArray = class _ZodArray extends ZodType {
-  _parse(input) {
-    const { ctx, status } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx, status } = this._processInputParams(input2);
     const def = this._def;
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
@@ -2513,10 +2513,10 @@ var ZodObject = class _ZodObject extends ZodType {
     this._cached = { shape, keys };
     return this._cached;
   }
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.object) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
@@ -2524,7 +2524,7 @@ var ZodObject = class _ZodObject extends ZodType {
       });
       return INVALID;
     }
-    const { status, ctx } = this._processInputParams(input);
+    const { status, ctx } = this._processInputParams(input2);
     const { shape, keys: shapeKeys } = this._getCached();
     const extraKeys = [];
     if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
@@ -2837,8 +2837,8 @@ ZodObject.lazycreate = (shape, params) => {
   });
 };
 var ZodUnion = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const options = this._def.options;
     function handleResults(results) {
       for (const result of results) {
@@ -2959,8 +2959,8 @@ var getDiscriminator = (type2) => {
   }
 };
 var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3073,8 +3073,8 @@ function mergeValues(a, b) {
   }
 }
 var ZodIntersection = class extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     const handleParsed = (parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
@@ -3126,8 +3126,8 @@ ZodIntersection.create = (left, right, params) => {
   });
 };
 var ZodTuple = class _ZodTuple extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3199,8 +3199,8 @@ var ZodRecord = class _ZodRecord extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3252,8 +3252,8 @@ var ZodMap = class extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.map) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3312,8 +3312,8 @@ ZodMap.create = (keyType, valueType, params) => {
   });
 };
 var ZodSet = class _ZodSet extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.set) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3401,8 +3401,8 @@ var ZodFunction = class _ZodFunction extends ZodType {
     super(...arguments);
     this.validate = this.implement;
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.function) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3505,8 +3505,8 @@ var ZodLazy = class extends ZodType {
   get schema() {
     return this._def.getter();
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const lazySchema = this._def.getter();
     return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
   }
@@ -3519,9 +3519,9 @@ ZodLazy.create = (getter, params) => {
   });
 };
 var ZodLiteral = class extends ZodType {
-  _parse(input) {
-    if (input.data !== this._def.value) {
-      const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    if (input2.data !== this._def.value) {
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         received: ctx.data,
         code: ZodIssueCode.invalid_literal,
@@ -3529,7 +3529,7 @@ var ZodLiteral = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return { status: "valid", value: input2.data };
   }
   get value() {
     return this._def.value;
@@ -3550,9 +3550,9 @@ function createZodEnum(values, params) {
   });
 }
 var ZodEnum = class _ZodEnum extends ZodType {
-  _parse(input) {
-    if (typeof input.data !== "string") {
-      const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    if (typeof input2.data !== "string") {
+      const ctx = this._getOrReturnCtx(input2);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         expected: util.joinValues(expectedValues),
@@ -3564,8 +3564,8 @@ var ZodEnum = class _ZodEnum extends ZodType {
     if (!this._cache) {
       this._cache = new Set(this._def.values);
     }
-    if (!this._cache.has(input.data)) {
-      const ctx = this._getOrReturnCtx(input);
+    if (!this._cache.has(input2.data)) {
+      const ctx = this._getOrReturnCtx(input2);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -3574,7 +3574,7 @@ var ZodEnum = class _ZodEnum extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
   get options() {
     return this._def.values;
@@ -3615,9 +3615,9 @@ var ZodEnum = class _ZodEnum extends ZodType {
 };
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     const nativeEnumValues = util.getValidEnumValues(this._def.values);
-    const ctx = this._getOrReturnCtx(input);
+    const ctx = this._getOrReturnCtx(input2);
     if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
@@ -3630,7 +3630,7 @@ var ZodNativeEnum = class extends ZodType {
     if (!this._cache) {
       this._cache = new Set(util.getValidEnumValues(this._def.values));
     }
-    if (!this._cache.has(input.data)) {
+    if (!this._cache.has(input2.data)) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -3639,7 +3639,7 @@ var ZodNativeEnum = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
   get enum() {
     return this._def.values;
@@ -3656,8 +3656,8 @@ var ZodPromise = class extends ZodType {
   unwrap() {
     return this._def.type;
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3689,8 +3689,8 @@ var ZodEffects = class extends ZodType {
   sourceType() {
     return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     const effect = this._def.effect || null;
     const checkCtx = {
       addIssue: (arg) => {
@@ -3822,12 +3822,12 @@ ZodEffects.createWithPreprocess = (preprocess2, schema2, params) => {
   });
 };
 var ZodOptional = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType === ZodParsedType.undefined) {
       return OK(void 0);
     }
-    return this._def.innerType._parse(input);
+    return this._def.innerType._parse(input2);
   }
   unwrap() {
     return this._def.innerType;
@@ -3841,12 +3841,12 @@ ZodOptional.create = (type2, params) => {
   });
 };
 var ZodNullable = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType === ZodParsedType.null) {
       return OK(null);
     }
-    return this._def.innerType._parse(input);
+    return this._def.innerType._parse(input2);
   }
   unwrap() {
     return this._def.innerType;
@@ -3860,8 +3860,8 @@ ZodNullable.create = (type2, params) => {
   });
 };
 var ZodDefault = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     let data = ctx.data;
     if (ctx.parsedType === ZodParsedType.undefined) {
       data = this._def.defaultValue();
@@ -3885,8 +3885,8 @@ ZodDefault.create = (type2, params) => {
   });
 };
 var ZodCatch = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const newCtx = {
       ...ctx,
       common: {
@@ -3938,10 +3938,10 @@ ZodCatch.create = (type2, params) => {
   });
 };
 var ZodNaN = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.nan,
@@ -3949,7 +3949,7 @@ var ZodNaN = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return { status: "valid", value: input2.data };
   }
 };
 ZodNaN.create = (params) => {
@@ -3960,8 +3960,8 @@ ZodNaN.create = (params) => {
 };
 var BRAND = /* @__PURE__ */ Symbol("zod_brand");
 var ZodBranded = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const data = ctx.data;
     return this._def.type._parse({
       data,
@@ -3974,8 +3974,8 @@ var ZodBranded = class extends ZodType {
   }
 };
 var ZodPipeline = class _ZodPipeline extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.common.async) {
       const handleAsync = async () => {
         const inResult = await this._def.in._parseAsync({
@@ -4029,8 +4029,8 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
   }
 };
 var ZodReadonly = class extends ZodType {
-  _parse(input) {
-    const result = this._def.innerType._parse(input);
+  _parse(input2) {
+    const result = this._def.innerType._parse(input2);
     const freeze = (data) => {
       if (isValid(data)) {
         data.value = Object.freeze(data.value);
@@ -4546,10 +4546,10 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set basename(basename2) {
-    assertNonEmpty(basename2, "basename");
-    assertPart(basename2, "basename");
-    this.path = default2.join(this.dirname || "", basename2);
+  set basename(basename3) {
+    assertNonEmpty(basename3, "basename");
+    assertPart(basename3, "basename");
+    this.path = default2.join(this.dirname || "", basename3);
   }
   /**
    * Get the parent path (example: `'~'`).
@@ -4570,9 +4570,9 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set dirname(dirname2) {
+  set dirname(dirname4) {
     assertPath(this.basename, "dirname");
-    this.path = default2.join(dirname2 || "", this.basename);
+    this.path = default2.join(dirname4 || "", this.basename);
   }
   /**
    * Get the extname (including dot) (example: `'.js'`).
@@ -5171,7 +5171,7 @@ var Processor = class _Processor extends CallableInstance {
     assertParser("process", this.parser || this.Parser);
     assertCompiler("process", this.compiler || this.Compiler);
     return done ? executor(void 0, done) : new Promise(executor);
-    function executor(resolve14, reject) {
+    function executor(resolve15, reject) {
       const realFile = vfile(file);
       const parseTree = (
         /** @type {HeadTree extends undefined ? Node : HeadTree} */
@@ -5202,8 +5202,8 @@ var Processor = class _Processor extends CallableInstance {
       function realDone(error, file2) {
         if (error || !file2) {
           reject(error);
-        } else if (resolve14) {
-          resolve14(file2);
+        } else if (resolve15) {
+          resolve15(file2);
         } else {
           ok(done, "`done` is defined if `resolve` is not");
           done(void 0, file2);
@@ -5305,7 +5305,7 @@ var Processor = class _Processor extends CallableInstance {
       file = void 0;
     }
     return done ? executor(void 0, done) : new Promise(executor);
-    function executor(resolve14, reject) {
+    function executor(resolve15, reject) {
       ok(
         typeof file !== "function",
         "`file` can\u2019t be a `done` anymore, we checked"
@@ -5319,8 +5319,8 @@ var Processor = class _Processor extends CallableInstance {
         );
         if (error) {
           reject(error);
-        } else if (resolve14) {
-          resolve14(resultingTree);
+        } else if (resolve15) {
+          resolve15(resultingTree);
         } else {
           ok(done, "`done` is defined if `resolve` is not");
           done(void 0, resultingTree, file2);
@@ -8148,10 +8148,10 @@ function resolveAll(constructs2, events, context) {
   const called = [];
   let index2 = -1;
   while (++index2 < constructs2.length) {
-    const resolve14 = constructs2[index2].resolveAll;
-    if (resolve14 && !called.includes(resolve14)) {
-      events = resolve14(events, context);
-      called.push(resolve14);
+    const resolve15 = constructs2[index2].resolveAll;
+    if (resolve15 && !called.includes(resolve15)) {
+      events = resolve15(events, context);
+      called.push(resolve15);
     }
   }
   return events;
@@ -13149,14 +13149,14 @@ function resolveYamlBinary(data) {
   return bitlen % 8 === 0;
 }
 function constructYamlBinary(data) {
-  var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map2 = BASE64_MAP, bits = 0, result = [];
+  var idx, tailbits, input2 = data.replace(/[\r\n=]/g, ""), max = input2.length, map2 = BASE64_MAP, bits = 0, result = [];
   for (idx = 0; idx < max; idx++) {
     if (idx % 4 === 0 && idx) {
       result.push(bits >> 16 & 255);
       result.push(bits >> 8 & 255);
       result.push(bits & 255);
     }
-    bits = bits << 6 | map2.indexOf(input.charAt(idx));
+    bits = bits << 6 | map2.indexOf(input2.charAt(idx));
   }
   tailbits = max % 4 * 6;
   if (tailbits === 0) {
@@ -13389,8 +13389,8 @@ for (i = 0; i < 256; i++) {
   simpleEscapeMap[i] = simpleEscapeSequence(i);
 }
 var i;
-function State$1(input, options) {
-  this.input = input;
+function State$1(input2, options) {
+  this.input = input2;
   this.filename = options["filename"] || null;
   this.schema = options["schema"] || _default;
   this.onWarning = options["onWarning"] || null;
@@ -13399,7 +13399,7 @@ function State$1(input, options) {
   this.listener = options["listener"] || null;
   this.implicitTypes = this.schema.compiledImplicit;
   this.typeMap = this.schema.compiledTypeMap;
-  this.length = input.length;
+  this.length = input2.length;
   this.position = 0;
   this.line = 0;
   this.lineStart = 0;
@@ -14403,19 +14403,19 @@ function readDocument(state) {
     return;
   }
 }
-function loadDocuments(input, options) {
-  input = String(input);
+function loadDocuments(input2, options) {
+  input2 = String(input2);
   options = options || {};
-  if (input.length !== 0) {
-    if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
-      input += "\n";
+  if (input2.length !== 0) {
+    if (input2.charCodeAt(input2.length - 1) !== 10 && input2.charCodeAt(input2.length - 1) !== 13) {
+      input2 += "\n";
     }
-    if (input.charCodeAt(0) === 65279) {
-      input = input.slice(1);
+    if (input2.charCodeAt(0) === 65279) {
+      input2 = input2.slice(1);
     }
   }
-  var state = new State$1(input, options);
-  var nullpos = input.indexOf("\0");
+  var state = new State$1(input2, options);
+  var nullpos = input2.indexOf("\0");
   if (nullpos !== -1) {
     state.position = nullpos;
     throwError(state, "null byte is not allowed in input");
@@ -14430,12 +14430,12 @@ function loadDocuments(input, options) {
   }
   return state.documents;
 }
-function loadAll$1(input, iterator, options) {
+function loadAll$1(input2, iterator, options) {
   if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
     options = iterator;
     iterator = null;
   }
-  var documents = loadDocuments(input, options);
+  var documents = loadDocuments(input2, options);
   if (typeof iterator !== "function") {
     return documents;
   }
@@ -14443,8 +14443,8 @@ function loadAll$1(input, iterator, options) {
     iterator(documents[index2]);
   }
 }
-function load$1(input, options) {
-  var documents = loadDocuments(input, options);
+function load$1(input2, options) {
+  var documents = loadDocuments(input2, options);
   if (documents.length === 0) {
     return void 0;
   } else if (documents.length === 1) {
@@ -15065,11 +15065,11 @@ function inspectNode(object, objects, duplicatesIndexes) {
     }
   }
 }
-function dump$1(input, options) {
+function dump$1(input2, options) {
   options = options || {};
   var state = new State(options);
-  if (!state.noRefs) getDuplicateReferences(input, state);
-  var value = input;
+  if (!state.noRefs) getDuplicateReferences(input2, state);
+  var value = input2;
   if (state.replacer) {
     value = state.replacer.call({ "": value }, "", value);
   }
@@ -15728,8 +15728,8 @@ var VERSION = "0.1.0";
 
 // src/commands/analyze.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { resolve as resolve3 } from "path";
 import chalk2 from "chalk";
 import Table from "cli-table3";
 
@@ -15905,18 +15905,46 @@ async function syncVelocity(data) {
   }
 }
 
+// src/project-config.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+var CONFIG_PATH = resolve2(process.cwd(), ".claude", "te", "config.json");
+function readProjectConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function updateProjectConfig(updates) {
+  const existing = readProjectConfig() ?? {
+    project: "unnamed",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const merged = { ...existing, ...updates };
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n");
+}
+function getProjectName() {
+  return readProjectConfig()?.project ?? "unnamed";
+}
+function getIntakeDir() {
+  return readProjectConfig()?.intakeDir ?? "intake-specs";
+}
+
 // src/commands/analyze.ts
 var analyzeCommand = new Command("analyze").description("Analyze a spec and generate estimate report + project scaffolding").argument("<spec>", "Path to the spec markdown file").option("-p, --project <name>", "Project name").option("-o, --output <dir>", "Output directory for reports", ".").option("--json", "Output report as JSON").action(async (specPath, options) => {
-  const fullPath = resolve2(specPath);
-  if (!existsSync(fullPath)) {
+  const fullPath = resolve3(specPath);
+  if (!existsSync2(fullPath)) {
     console.error(chalk2.red(`Spec file not found: ${fullPath}`));
     process.exit(1);
   }
-  const content3 = readFileSync2(fullPath, "utf-8");
+  const content3 = readFileSync3(fullPath, "utf-8");
   const data = loadData();
   console.log(chalk2.dim("Parsing spec..."));
   const spec = parseSpec(content3);
-  const projectName = options.project ?? spec.metadata.project ?? "unnamed";
+  const projectName = options.project ?? spec.metadata.project ?? getProjectName();
   if (spec.features.length === 0) {
     console.error(chalk2.red("No features found in spec. Use ### Feature: <name> headings."));
     process.exit(1);
@@ -15932,13 +15960,13 @@ var analyzeCommand = new Command("analyze").description("Analyze a spec and gene
     displayReport(report);
   }
   const registry = generateRegistry(projectName, spec.features, estimates);
-  const outDir = resolve2(options.output);
-  const reportPath = resolve2(outDir, `fathom-estimate-${projectName}.json`);
-  writeFileSync(reportPath, JSON.stringify(report, null, 2));
+  const outDir = resolve3(options.output);
+  const reportPath = resolve3(outDir, `fathom-estimate-${projectName}.json`);
+  writeFileSync2(reportPath, JSON.stringify(report, null, 2));
   console.log(chalk2.dim(`
 Report saved: ${reportPath}`));
-  const registryPath = resolve2(outDir, `fathom-registry-${projectName}.json`);
-  writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+  const registryPath = resolve3(outDir, `fathom-registry-${projectName}.json`);
+  writeFileSync2(registryPath, JSON.stringify(registry, null, 2));
   console.log(chalk2.dim(`Registry saved: ${registryPath}`));
   if (options.project) {
     scaffoldProject(projectName, registry, outDir);
@@ -16005,12 +16033,12 @@ Total: ${report.totals.tokens.toLocaleString()} tokens \u2014 $${report.totals.c
   }
 }
 function scaffoldProject(projectName, registry, baseDir) {
-  const teDir = resolve2(baseDir, ".claude", "te");
-  mkdirSync(teDir, { recursive: true });
-  const registryPath = resolve2(teDir, "registry.json");
-  writeFileSync(registryPath, JSON.stringify(registry, null, 2));
-  const configPath = resolve2(teDir, "config.json");
-  writeFileSync(
+  const teDir = resolve3(baseDir, ".claude", "te");
+  mkdirSync2(teDir, { recursive: true });
+  const registryPath = resolve3(teDir, "registry.json");
+  writeFileSync2(registryPath, JSON.stringify(registry, null, 2));
+  const configPath = resolve3(teDir, "config.json");
+  writeFileSync2(
     configPath,
     JSON.stringify({ project: projectName, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
   );
@@ -16082,13 +16110,13 @@ var pricingCommand = new Command2("pricing").description("Show current model pri
 
 // src/commands/status.ts
 import { Command as Command3 } from "commander";
-import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
-import { resolve as resolve3 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
+import { resolve as resolve4 } from "path";
 import chalk4 from "chalk";
 import Table3 from "cli-table3";
 var statusCommand = new Command3("status").description("Show project status from registry + tracking data").option("-p, --project <name>", "Project name").option("--registry <path>", "Path to registry.json").action((options) => {
-  const registryPath = options.registry ?? resolve3(process.cwd(), ".claude", "te", "registry.json");
-  if (!existsSync2(registryPath)) {
+  const registryPath = options.registry ?? resolve4(process.cwd(), ".claude", "te", "registry.json");
+  if (!existsSync3(registryPath)) {
     console.log(
       chalk4.yellow(
         "No registry found. Run `fathom analyze <spec> --project <name>` first."
@@ -16096,19 +16124,19 @@ var statusCommand = new Command3("status").description("Show project status from
     );
     return;
   }
-  const registry = JSON.parse(readFileSync3(registryPath, "utf-8"));
-  const projectName = options.project ?? registry.project ?? "unknown";
-  const summaryPath = resolve3(
+  const registry = JSON.parse(readFileSync4(registryPath, "utf-8"));
+  const projectName = options.project ?? registry.project ?? getProjectName();
+  const summaryPath = resolve4(
     process.cwd(),
     ".claude",
     "te",
     "tracking",
     "summary.json"
   );
-  const hasTracking = existsSync2(summaryPath);
+  const hasTracking = existsSync3(summaryPath);
   const actuals = /* @__PURE__ */ new Map();
   if (hasTracking) {
-    const summary = JSON.parse(readFileSync3(summaryPath, "utf-8"));
+    const summary = JSON.parse(readFileSync4(summaryPath, "utf-8"));
     for (const s of summary.sessions) {
       if (!s.featureId || s.status === "untagged") continue;
       const existing = actuals.get(s.featureId) ?? { tokens: 0, sessions: 0 };
@@ -16171,13 +16199,13 @@ Total estimated: ${totalEstimated.toLocaleString()} tokens`));
 
 // src/commands/track.ts
 import { Command as Command4 } from "commander";
-import { readFileSync as readFileSync5, existsSync as existsSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve5 } from "path";
 import chalk5 from "chalk";
 import Table4 from "cli-table3";
 
 // ../tracker/dist/index.js
-import { readFileSync as readFileSync4, readdirSync, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync5, readdirSync, existsSync as existsSync4 } from "fs";
 import { join, basename } from "path";
 import { homedir } from "os";
 var SessionMessage = external_exports.object({
@@ -16231,7 +16259,7 @@ var Registry = external_exports.object({
   generatedAt: external_exports.string()
 });
 function parseSessionFile(filePath) {
-  const content3 = readFileSync4(filePath, "utf-8");
+  const content3 = readFileSync5(filePath, "utf-8");
   const lines = content3.trim().split("\n").filter(Boolean);
   if (lines.length === 0) return null;
   let inputTokens = 0;
@@ -16313,7 +16341,7 @@ function parseSessionFile(filePath) {
 }
 function findSessionFiles(projectPath) {
   const baseDir = projectPath ?? join(homedir(), ".claude", "projects");
-  if (!existsSync3(baseDir)) return [];
+  if (!existsSync4(baseDir)) return [];
   const files = [];
   function walk(dir) {
     const entries = readdirSync(dir, { withFileTypes: true });
@@ -16428,8 +16456,8 @@ function matchGlob(text3, pattern) {
 // src/commands/track.ts
 var trackCommand = new Command4("track").description("Import Claude Code sessions and auto-tag to features").option("-p, --project <name>", "Project name").option("--registry <path>", "Path to registry.json").option("--sessions-dir <path>", "Path to sessions directory").option("--backfill", "Process all existing sessions (not just new)").action(
   async (options) => {
-    const registryPath = options.registry ?? resolve4(process.cwd(), ".claude", "te", "registry.json");
-    if (!existsSync4(registryPath)) {
+    const registryPath = options.registry ?? resolve5(process.cwd(), ".claude", "te", "registry.json");
+    if (!existsSync5(registryPath)) {
       console.log(
         chalk5.yellow(
           "No registry found. Run `fathom analyze <spec> --project <name>` first."
@@ -16438,9 +16466,9 @@ var trackCommand = new Command4("track").description("Import Claude Code session
       return;
     }
     const registry = JSON.parse(
-      readFileSync5(registryPath, "utf-8")
+      readFileSync6(registryPath, "utf-8")
     );
-    const projectName = options.project ?? registry.project ?? "unknown";
+    const projectName = options.project ?? registry.project ?? getProjectName();
     console.log(chalk5.dim("Scanning for sessions..."));
     const sessionFiles = findSessionFiles(options.sessionsDir);
     if (sessionFiles.length === 0) {
@@ -16449,14 +16477,14 @@ var trackCommand = new Command4("track").description("Import Claude Code session
       );
       return;
     }
-    const trackingDir = resolve4(
+    const trackingDir = resolve5(
       process.cwd(),
       ".claude",
       "te",
       "tracking",
       "sessions"
     );
-    const summaryPath = resolve4(
+    const summaryPath = resolve5(
       process.cwd(),
       ".claude",
       "te",
@@ -16464,8 +16492,8 @@ var trackCommand = new Command4("track").description("Import Claude Code session
       "summary.json"
     );
     const trackedIds = /* @__PURE__ */ new Set();
-    if (!options.backfill && existsSync4(summaryPath)) {
-      const summary = JSON.parse(readFileSync5(summaryPath, "utf-8"));
+    if (!options.backfill && existsSync5(summaryPath)) {
+      const summary = JSON.parse(readFileSync6(summaryPath, "utf-8"));
       for (const s of summary.sessions ?? []) {
         trackedIds.add(s.sessionId);
       }
@@ -16531,7 +16559,7 @@ Total: ${totalTokens.toLocaleString()} tokens across ${results.length} sessions`
         `Tags: ${autoTagged} auto-tagged, ${likely} likely, ${untagged} untagged`
       )
     );
-    mkdirSync2(trackingDir, { recursive: true });
+    mkdirSync3(trackingDir, { recursive: true });
     const sessionRecords = results.map(({ session, tag }) => ({
       sessionId: session.sessionId,
       featureId: tag.featureId,
@@ -16548,11 +16576,11 @@ Total: ${totalTokens.toLocaleString()} tokens across ${results.length} sessions`
       trackedAt: (/* @__PURE__ */ new Date()).toISOString()
     }));
     let existing = { sessions: [] };
-    if (existsSync4(summaryPath)) {
-      existing = JSON.parse(readFileSync5(summaryPath, "utf-8"));
+    if (existsSync5(summaryPath)) {
+      existing = JSON.parse(readFileSync6(summaryPath, "utf-8"));
     }
     existing.sessions.push(...sessionRecords);
-    writeFileSync2(
+    writeFileSync3(
       summaryPath,
       JSON.stringify(
         {
@@ -16602,20 +16630,20 @@ Tracking saved: ${summaryPath}`));
 
 // src/commands/reconcile.ts
 import { Command as Command5 } from "commander";
-import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
-import { resolve as resolve5 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync6 } from "fs";
+import { resolve as resolve6 } from "path";
 import chalk6 from "chalk";
 import Table5 from "cli-table3";
 var reconcileCommand = new Command5("reconcile").description("Compare estimates vs actuals per feature").option("-p, --project <name>", "Project name").option("--registry <path>", "Path to registry.json").action(async (options) => {
-  const registryPath = options.registry ?? resolve5(process.cwd(), ".claude", "te", "registry.json");
-  const summaryPath = resolve5(
+  const registryPath = options.registry ?? resolve6(process.cwd(), ".claude", "te", "registry.json");
+  const summaryPath = resolve6(
     process.cwd(),
     ".claude",
     "te",
     "tracking",
     "summary.json"
   );
-  if (!existsSync5(registryPath)) {
+  if (!existsSync6(registryPath)) {
     console.log(
       chalk6.yellow(
         "No registry found. Run `fathom analyze <spec> --project <name>` first."
@@ -16623,7 +16651,7 @@ var reconcileCommand = new Command5("reconcile").description("Compare estimates
     );
     return;
   }
-  if (!existsSync5(summaryPath)) {
+  if (!existsSync6(summaryPath)) {
     console.log(
       chalk6.yellow(
         "No tracking data found. Run `fathom track --project <name>` first."
@@ -16631,9 +16659,9 @@ var reconcileCommand = new Command5("reconcile").description("Compare estimates
     );
     return;
   }
-  const registry = JSON.parse(readFileSync6(registryPath, "utf-8"));
-  const summary = JSON.parse(readFileSync6(summaryPath, "utf-8"));
-  const projectName = options.project ?? registry.project ?? "unknown";
+  const registry = JSON.parse(readFileSync7(registryPath, "utf-8"));
+  const summary = JSON.parse(readFileSync7(summaryPath, "utf-8"));
+  const projectName = options.project ?? registry.project ?? getProjectName();
   const data = loadData();
   const actuals = /* @__PURE__ */ new Map();
   for (const session of summary.sessions) {
@@ -16754,8 +16782,8 @@ Overall: ${totalActual.toLocaleString()} / ${totalEstimated.toLocaleString()} to
 
 // src/commands/setup.ts
 import { Command as Command6 } from "commander";
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync6 } from "fs";
-import { resolve as resolve6 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "fs";
+import { resolve as resolve7 } from "path";
 import chalk7 from "chalk";
 var setupCommand = new Command6("setup").description("Scaffold .claude/ skill + hooks + registry for an existing project").option("-p, --project <name>", "Project name", "unnamed").action((options) => {
   const projectName = options.project;
@@ -16763,15 +16791,15 @@ var setupCommand = new Command6("setup").description("Scaffold .claude/ skill +
   console.log(chalk7.bold(`
 Fathom \u2014 Setup: ${projectName}`));
   console.log(chalk7.dim("\u2500".repeat(50)));
-  const teDir = resolve6(baseDir, ".claude", "te");
-  const trackingDir = resolve6(teDir, "tracking", "sessions");
-  const slicesDir = resolve6(teDir, "slices");
-  mkdirSync3(trackingDir, { recursive: true });
-  mkdirSync3(slicesDir, { recursive: true });
+  const teDir = resolve7(baseDir, ".claude", "te");
+  const trackingDir = resolve7(teDir, "tracking", "sessions");
+  const slicesDir = resolve7(teDir, "slices");
+  mkdirSync4(trackingDir, { recursive: true });
+  mkdirSync4(slicesDir, { recursive: true });
   console.log(chalk7.green("  \u2713 .claude/te/ directory structure"));
-  const configPath = resolve6(teDir, "config.json");
-  if (!existsSync6(configPath)) {
-    writeFileSync3(
+  const configPath = resolve7(teDir, "config.json");
+  if (!existsSync7(configPath)) {
+    writeFileSync4(
       configPath,
       JSON.stringify(
         { project: projectName, createdAt: (/* @__PURE__ */ new Date()).toISOString() },
@@ -16783,9 +16811,9 @@ Fathom \u2014 Setup: ${projectName}`));
   } else {
     console.log(chalk7.dim("  \xB7 config.json (exists)"));
   }
-  const registryPath = resolve6(teDir, "registry.json");
-  if (!existsSync6(registryPath)) {
-    writeFileSync3(
+  const registryPath = resolve7(teDir, "registry.json");
+  if (!existsSync7(registryPath)) {
+    writeFileSync4(
       registryPath,
       JSON.stringify(
         {
@@ -16801,9 +16829,9 @@ Fathom \u2014 Setup: ${projectName}`));
   } else {
     console.log(chalk7.dim("  \xB7 registry.json (exists)"));
   }
-  const summaryPath = resolve6(teDir, "tracking", "summary.json");
-  if (!existsSync6(summaryPath)) {
-    writeFileSync3(
+  const summaryPath = resolve7(teDir, "tracking", "summary.json");
+  if (!existsSync7(summaryPath)) {
+    writeFileSync4(
       summaryPath,
       JSON.stringify(
         {
@@ -16819,21 +16847,21 @@ Fathom \u2014 Setup: ${projectName}`));
   } else {
     console.log(chalk7.dim("  \xB7 tracking/summary.json (exists)"));
   }
-  const skillDir = resolve6(baseDir, ".claude", "skills", "fathom");
-  mkdirSync3(skillDir, { recursive: true });
-  const skillPath = resolve6(skillDir, "SKILL.md");
-  if (!existsSync6(skillPath)) {
+  const skillDir = resolve7(baseDir, ".claude", "skills", "fathom");
+  mkdirSync4(skillDir, { recursive: true });
+  const skillPath = resolve7(skillDir, "SKILL.md");
+  if (!existsSync7(skillPath)) {
     const skillContent = generateSkill(projectName);
-    writeFileSync3(skillPath, skillContent);
+    writeFileSync4(skillPath, skillContent);
     console.log(chalk7.green("  \u2713 skills/fathom/SKILL.md"));
   } else {
     console.log(chalk7.dim("  \xB7 skills/fathom/SKILL.md (exists)"));
   }
-  const refsDir = resolve6(skillDir, "references");
-  mkdirSync3(refsDir, { recursive: true });
-  const profilesRefPath = resolve6(refsDir, "task-profiles.md");
-  if (!existsSync6(profilesRefPath)) {
-    writeFileSync3(
+  const refsDir = resolve7(skillDir, "references");
+  mkdirSync4(refsDir, { recursive: true });
+  const profilesRefPath = resolve7(refsDir, "task-profiles.md");
+  if (!existsSync7(profilesRefPath)) {
+    writeFileSync4(
       profilesRefPath,
       "# Task Profiles\n\nCalibrated profiles will appear here after running `fathom calibrate`.\n"
     );
@@ -16841,11 +16869,11 @@ Fathom \u2014 Setup: ${projectName}`));
   } else {
     console.log(chalk7.dim("  \xB7 references/task-profiles.md (exists)"));
   }
-  const hooksDir = resolve6(baseDir, ".claude", "hooks");
-  mkdirSync3(hooksDir, { recursive: true });
-  const hookPath = resolve6(hooksDir, "te-session-sync.sh");
-  if (!existsSync6(hookPath)) {
-    writeFileSync3(
+  const hooksDir = resolve7(baseDir, ".claude", "hooks");
+  mkdirSync4(hooksDir, { recursive: true });
+  const hookPath = resolve7(hooksDir, "te-session-sync.sh");
+  if (!existsSync7(hookPath)) {
+    writeFileSync4(
       hookPath,
       generateHookScript(projectName),
       { mode: 493 }
@@ -16854,8 +16882,8 @@ Fathom \u2014 Setup: ${projectName}`));
   } else {
     console.log(chalk7.dim("  \xB7 hooks/te-session-sync.sh (exists)"));
   }
-  const settingsPath = resolve6(baseDir, ".claude", "settings.json");
-  if (!existsSync6(settingsPath)) {
+  const settingsPath = resolve7(baseDir, ".claude", "settings.json");
+  if (!existsSync7(settingsPath)) {
     console.log(
       chalk7.yellow(
         "\n  \u26A0 No .claude/settings.json found. Add hook config manually if needed."
@@ -16911,20 +16939,20 @@ function generateHookScript(projectName) {
 
 // src/commands/calibrate.ts
 import { Command as Command7 } from "commander";
-import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
-import { resolve as resolve7 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
+import { resolve as resolve8 } from "path";
 import chalk8 from "chalk";
 import Table6 from "cli-table3";
 var calibrateCommand = new Command7("calibrate").description("Show calibration drift and profile adjustment suggestions").option("-p, --project <name>", "Project name").option("--registry <path>", "Path to registry.json").action(async (options) => {
-  const registryPath = options.registry ?? resolve7(process.cwd(), ".claude", "te", "registry.json");
-  const summaryPath = resolve7(
+  const registryPath = options.registry ?? resolve8(process.cwd(), ".claude", "te", "registry.json");
+  const summaryPath = resolve8(
     process.cwd(),
     ".claude",
     "te",
     "tracking",
     "summary.json"
   );
-  if (!existsSync7(registryPath) || !existsSync7(summaryPath)) {
+  if (!existsSync8(registryPath) || !existsSync8(summaryPath)) {
     console.log(
       chalk8.yellow(
         "Need both registry and tracking data. Run `fathom analyze` then `fathom track` first."
@@ -16932,9 +16960,9 @@ var calibrateCommand = new Command7("calibrate").description("Show calibration d
     );
     return;
   }
-  const registry = JSON.parse(readFileSync8(registryPath, "utf-8"));
-  const summary = JSON.parse(readFileSync8(summaryPath, "utf-8"));
-  const projectName = options.project ?? registry.project ?? "unknown";
+  const registry = JSON.parse(readFileSync9(registryPath, "utf-8"));
+  const summary = JSON.parse(readFileSync9(summaryPath, "utf-8"));
+  const projectName = options.project ?? registry.project ?? getProjectName();
   const actuals = /* @__PURE__ */ new Map();
   for (const session of summary.sessions) {
     if (!session.featureId || session.status === "untagged") continue;
@@ -17127,16 +17155,16 @@ var estimateCommand = new Command8("estimate").description("Quick single-feature
 
 // src/commands/validate.ts
 import { Command as Command9 } from "commander";
-import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
-import { resolve as resolve8 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync9 } from "fs";
+import { resolve as resolve9 } from "path";
 import chalk10 from "chalk";
 var validateCommand = new Command9("validate").description("Validate a spec file format without running full analysis").argument("<spec>", "Path to the spec markdown file").action((specPath) => {
-  const fullPath = resolve8(specPath);
-  if (!existsSync8(fullPath)) {
+  const fullPath = resolve9(specPath);
+  if (!existsSync9(fullPath)) {
     console.error(chalk10.red(`Spec file not found: ${fullPath}`));
     process.exit(1);
   }
-  const content3 = readFileSync9(fullPath, "utf-8");
+  const content3 = readFileSync10(fullPath, "utf-8");
   console.log(chalk10.bold("\nFathom \u2014 Validate Spec"));
   console.log(chalk10.dim("\u2500".repeat(50)));
   console.log(chalk10.dim(`File: ${fullPath}`));
@@ -17205,8 +17233,8 @@ var validateCommand = new Command9("validate").description("Validate a spec file
 
 // src/commands/velocity.ts
 import { Command as Command10 } from "commander";
-import { readFileSync as readFileSync10, existsSync as existsSync9 } from "fs";
-import { resolve as resolve9 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync10 } from "fs";
+import { resolve as resolve10 } from "path";
 import chalk11 from "chalk";
 import Table7 from "cli-table3";
 
@@ -17512,15 +17540,15 @@ function percentileRange(values) {
 // src/commands/velocity.ts
 var velocityCommand = new Command10("velocity").description("Show velocity metrics and benchmarks").option("-p, --project <name>", "Project name").option("--registry <path>", "Path to registry.json").option("--benchmarks", "Show benchmarks by complexity + category").action(
   async (options) => {
-    const registryPath = options.registry ?? resolve9(process.cwd(), ".claude", "te", "registry.json");
-    const summaryPath = resolve9(
+    const registryPath = options.registry ?? resolve10(process.cwd(), ".claude", "te", "registry.json");
+    const summaryPath = resolve10(
       process.cwd(),
       ".claude",
       "te",
       "tracking",
       "summary.json"
     );
-    if (!existsSync9(registryPath) || !existsSync9(summaryPath)) {
+    if (!existsSync10(registryPath) || !existsSync10(summaryPath)) {
       console.log(
         chalk11.yellow(
           "Need both registry and tracking data. Run `fathom analyze` then `fathom track` first."
@@ -17528,9 +17556,9 @@ var velocityCommand = new Command10("velocity").description("Show velocity metri
       );
       return;
     }
-    const registry = JSON.parse(readFileSync10(registryPath, "utf-8"));
-    const summary = JSON.parse(readFileSync10(summaryPath, "utf-8"));
-    const projectName = options.project ?? registry.project ?? "unknown";
+    const registry = JSON.parse(readFileSync11(registryPath, "utf-8"));
+    const summary = JSON.parse(readFileSync11(summaryPath, "utf-8"));
+    const projectName = options.project ?? registry.project ?? getProjectName();
     const data = loadData();
     const featureDataMap = /* @__PURE__ */ new Map();
     for (const feature of registry.features) {
@@ -17666,10 +17694,11 @@ Fathom \u2014 Velocity: ${projectName}`));
 
 // src/commands/intake.ts
 import { Command as Command11 } from "commander";
-import { readFileSync as readFileSync11, existsSync as existsSync10 } from "fs";
-import { resolve as resolve10 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync5, existsSync as existsSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync } from "fs";
+import { resolve as resolve11, basename as basename2, dirname as dirname3 } from "path";
 import chalk12 from "chalk";
 import Table8 from "cli-table3";
+import { input, confirm, select } from "@inquirer/prompts";
 
 // ../intake/dist/index.js
 var ExtractedItem = external_exports.object({
@@ -17832,49 +17861,80 @@ function enrichSlices(items, options = {}) {
 function slugify2(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-function formatSlice(slice) {
+function formatSlice(slice, index2) {
+  const modelShort = slice.recommendedModel.replace("claude-", "").replace(/-\d+-\d+$/, "");
   const lines = [
-    "---",
-    `slice_id: "${slice.sliceId}"`,
-    `status: "${slice.status}"`,
-    "---",
+    `### ${index2 + 1}. ${slice.name}`,
+    "",
+    `**Complexity:** ${slice.complexity} | **Category:** ${slice.category} | **Priority:** ${slice.priority}`,
     "",
-    `### Feature: ${slice.name}`,
-    `- **Category**: ${slice.category}`,
-    `- **Priority**: ${slice.priority}`,
-    `- **Complexity**: ${slice.complexity}`,
-    `- **Description**: ${slice.description}`
+    `> ${slice.description}`,
+    ""
   ];
   if (slice.rootCause) {
-    lines.push(`- **Root Cause**: ${slice.rootCause}`);
-  }
-  lines.push(`- **AI Tasks**: ${slice.aiTasks.join(", ")}`);
-  lines.push(`- **Acceptance Criteria**: ${slice.acceptanceCriteria}`);
-  const modelShort = slice.recommendedModel.replace("claude-", "").replace(/-\d+-\d+$/, "");
-  lines.push(
-    `- **Estimate**: ~${slice.estimatedTokens.toLocaleString()} tokens, $${slice.estimatedCost.toFixed(2)}, ${modelShort} recommended`
-  );
+    lines.push(`**Root Cause:** ${slice.rootCause}`, "");
+  }
+  lines.push("#### Tasks");
+  for (const task of slice.aiTasks) {
+    lines.push(`- [ ] ${task}`);
+  }
+  lines.push("");
+  lines.push("#### Acceptance Criteria");
+  const criteria = slice.acceptanceCriteria.split(/[.;]/).map((c) => c.trim()).filter((c) => c.length > 0);
+  for (const criterion of criteria) {
+    lines.push(`- [ ] ${criterion}`);
+  }
+  lines.push("");
+  lines.push("#### Estimate");
+  lines.push(`- **Tokens:** ~${slice.estimatedTokens.toLocaleString()}`);
+  lines.push(`- **Cost:** $${slice.estimatedCost.toFixed(2)}`);
+  lines.push(`- **Recommended model:** ${modelShort}`);
   if (slice.velocityBenchmark) {
     const vb = slice.velocityBenchmark;
     lines.push(
-      `- **Velocity Benchmark**: ${slice.complexity}-complexity ${slice.category.toLowerCase()} tasks average ${vb.avgSessions.toFixed(1)} sessions, ${vb.avgDays.toFixed(1)} days (${vb.dataPoints} data points)`
+      `- **Velocity benchmark:** ~${vb.avgSessions.toFixed(1)} sessions, ~${vb.avgDays.toFixed(1)} days (based on ${vb.dataPoints} similar tasks)`
     );
   }
   return lines.join("\n");
 }
 function formatAsMarkdown(result) {
+  const date = result.createdAt.slice(0, 10);
   const lines = [
-    `# Intake: ${result.project}`,
+    `# ${result.project} \u2014 Spec`,
     "",
-    `> Source: ${result.source} | ${result.createdAt}`,
-    `> Total estimate: ~${result.totalEstimatedTokens.toLocaleString()} tokens, $${result.totalEstimatedCost.toFixed(2)}`,
+    `Generated by Fathom on ${date}`,
     "",
-    `Extracted ${result.slices.length} work item${result.slices.length === 1 ? "" : "s"}:`,
+    "## Summary",
+    "",
+    `| | |`,
+    `|---|---|`,
+    `| **Work items** | ${result.slices.length} |`,
+    `| **Total tokens** | ~${result.totalEstimatedTokens.toLocaleString()} |`,
+    `| **Total cost** | $${result.totalEstimatedCost.toFixed(2)} |`,
+    `| **Source** | ${result.source} |`,
+    "",
+    "## Priority Order",
     ""
   ];
-  for (const slice of result.slices) {
-    lines.push(formatSlice(slice));
+  const p1 = result.slices.filter((s) => s.priority === "P0" || s.priority === "P1");
+  const p2 = result.slices.filter((s) => s.priority === "P2");
+  const p3 = result.slices.filter((s) => s.priority === "P3");
+  if (p1.length > 0) {
+    lines.push(`**Must-have (${p1.length}):** ${p1.map((s) => s.name).join(", ")}`);
+  }
+  if (p2.length > 0) {
+    lines.push(`**Should-have (${p2.length}):** ${p2.map((s) => s.name).join(", ")}`);
+  }
+  if (p3.length > 0) {
+    lines.push(`**Nice-to-have (${p3.length}):** ${p3.map((s) => s.name).join(", ")}`);
+  }
+  lines.push("", "---", "", "## Features", "");
+  for (let i = 0; i < result.slices.length; i++) {
+    lines.push(formatSlice(result.slices[i], i));
     lines.push("");
+    if (i < result.slices.length - 1) {
+      lines.push("---", "");
+    }
   }
   return lines.join("\n");
 }
@@ -17892,30 +17952,108 @@ function formatSliceTable(slices) {
 }
 
 // src/commands/intake.ts
-var intakeCommand = new Command11("intake").description("Extract work items from raw feedback, bug reports, or meeting notes").argument("[text]", "Raw text input to analyze").option("-f, --file <path>", "Read input from a file").option("-p, --project <name>", "Project name", "unnamed").option("--json", "Output as JSON").option("--markdown", "Output as markdown spec slices").action(async (text3, options) => {
+function findLocalMarkdownFiles() {
+  try {
+    const cwd = process.cwd();
+    return readdirSync2(cwd).filter((f) => /\.(md|txt|mdx)$/i.test(f) && !f.startsWith(".")).map((f) => ({ name: f, mtime: statSync(resolve11(cwd, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime).map((f) => f.name);
+  } catch {
+    return [];
+  }
+}
+var intakeCommand = new Command11("intake").description("Extract work items from raw feedback, bug reports, or meeting notes").argument("[text]", "Raw text input to analyze").option("-f, --file <path>", "Read input from a file").option("-p, --project <name>", "Project name").option("-o, --output <path>", "Write markdown spec to file").option("--json", "Output as JSON").option("--markdown", "Output as markdown to stdout").action(async (text3, options) => {
+  const cwd = process.cwd();
+  let projectName = options.project ?? getProjectName();
+  if (projectName === "unnamed") {
+    projectName = await input({
+      message: "Project name:",
+      default: basename2(cwd)
+    });
+    updateProjectConfig({ project: projectName });
+  }
   let rawInput;
+  let source;
   if (options.file) {
-    const filePath = resolve10(options.file);
-    if (!existsSync10(filePath)) {
+    const filePath = resolve11(options.file);
+    if (!existsSync11(filePath)) {
       console.error(chalk12.red(`File not found: ${filePath}`));
       process.exit(1);
     }
-    rawInput = readFileSync11(filePath, "utf-8");
+    rawInput = readFileSync12(filePath, "utf-8");
+    source = "file";
   } else if (text3) {
     rawInput = text3;
+    source = "text";
   } else {
-    console.error(chalk12.red("Provide text argument or --file flag."));
-    console.error(chalk12.dim('  fathom intake "Users want dark mode"'));
-    console.error(chalk12.dim("  fathom intake --file feedback.md"));
-    process.exit(1);
+    const localFiles = findLocalMarkdownFiles();
+    if (localFiles.length > 0) {
+      const fileChoices = localFiles.slice(0, 8).map((f) => ({
+        name: f,
+        value: f
+      }));
+      fileChoices.push(
+        { name: "Other file...", value: "__other__" },
+        { name: "Type/paste text instead", value: "__text__" }
+      );
+      const chosen = await select({
+        message: `Input source (${localFiles.length} file${localFiles.length === 1 ? "" : "s"} found in ${basename2(cwd)}):`,
+        choices: fileChoices
+      });
+      if (chosen === "__text__") {
+        rawInput = await input({
+          message: "Paste your feedback / requirements:"
+        });
+        source = "text";
+      } else if (chosen === "__other__") {
+        const filePath = await input({
+          message: "Path to input file:",
+          default: cwd + "/"
+        });
+        const resolved = resolve11(filePath.trim());
+        if (!existsSync11(resolved)) {
+          console.error(chalk12.red(`File not found: ${resolved}`));
+          process.exit(1);
+        }
+        rawInput = readFileSync12(resolved, "utf-8");
+        source = "file";
+      } else {
+        rawInput = readFileSync12(resolve11(chosen), "utf-8");
+        source = "file";
+      }
+    } else {
+      const inputType = await select({
+        message: "How would you like to provide input?",
+        choices: [
+          { name: "Enter a file path", value: "file" },
+          { name: "Type/paste text", value: "text" }
+        ]
+      });
+      if (inputType === "file") {
+        const filePath = await input({
+          message: "Path to input file:",
+          default: cwd + "/"
+        });
+        const resolved = resolve11(filePath.trim());
+        if (!existsSync11(resolved)) {
+          console.error(chalk12.red(`File not found: ${resolved}`));
+          process.exit(1);
+        }
+        rawInput = readFileSync12(resolved, "utf-8");
+        source = "file";
+      } else {
+        rawInput = await input({
+          message: "Paste your feedback / requirements:"
+        });
+        source = "text";
+      }
+    }
   }
   if (!process.env.ANTHROPIC_API_KEY) {
     console.error(chalk12.red("ANTHROPIC_API_KEY environment variable is required."));
+    console.error(chalk12.dim("  Add it to your .env file or export it:"));
     console.error(chalk12.dim("  export ANTHROPIC_API_KEY=sk-ant-..."));
     process.exit(1);
   }
-  const source = options.file ? "file" : "text";
-  console.log(chalk12.dim("Extracting work items via Claude..."));
+  console.log(chalk12.dim("\nExtracting work items via Claude..."));
   let items;
   try {
     items = await extractWorkItems(rawInput);
@@ -17930,11 +18068,11 @@ var intakeCommand = new Command11("intake").description("Extract work items from
   console.log(chalk12.green(`Extracted ${items.length} work item${items.length === 1 ? "" : "s"}`));
   console.log(chalk12.dim("Enriching with estimates..."));
   const data = loadData();
-  const slices = enrichSlices(items, { data, project: options.project });
+  const slices = enrichSlices(items, { data, project: projectName });
   const totalTokens = slices.reduce((s, sl) => s + sl.estimatedTokens, 0);
   const totalCost = slices.reduce((s, sl) => s + sl.estimatedCost, 0);
   const result = {
-    project: options.project,
+    project: projectName,
     source,
     rawInput,
     slices,
@@ -17946,12 +18084,22 @@ var intakeCommand = new Command11("intake").description("Extract work items from
     console.log(JSON.stringify(result, null, 2));
     return;
   }
+  if (options.output) {
+    const outPath = resolve11(options.output);
+    mkdirSync5(dirname3(outPath), { recursive: true });
+    writeFileSync5(outPath, formatAsMarkdown(result));
+    console.log(chalk12.green(`
+Spec written to ${outPath}`));
+    await doConvexSync(result, rawInput, source, projectName);
+    return;
+  }
   if (options.markdown) {
     console.log(formatAsMarkdown(result));
+    await doConvexSync(result, rawInput, source, projectName);
     return;
   }
   console.log(chalk12.bold(`
-Fathom \u2014 Intake Analysis: ${options.project}`));
+Fathom \u2014 Intake Analysis: ${projectName}`));
   console.log(chalk12.dim("\u2500".repeat(60)));
   const tableRows = formatSliceTable(slices);
   const table = new Table8({
@@ -17984,13 +18132,57 @@ Fathom \u2014 Intake Analysis: ${options.project}`));
     chalk12.bold(`
 Total: ${totalTokens.toLocaleString()} tokens \u2014 $${totalCost.toFixed(2)}`)
   );
-  console.log(chalk12.dim(`
-Use --markdown to generate spec slices, --json for raw output.`));
+  const intakeDir = getIntakeDir();
+  const datestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const defaultFile = `${intakeDir}/${projectName}-intake-${datestamp}.md`;
+  const saveAction = await select({
+    message: "What would you like to do with this spec?",
+    choices: [
+      { name: `Save to ${defaultFile}`, value: "default" },
+      { name: "Save to a custom location", value: "custom" },
+      { name: "Print markdown to console", value: "print" },
+      { name: "Skip (don't save)", value: "skip" }
+    ]
+  });
+  if (saveAction === "default" || saveAction === "custom") {
+    let outPath;
+    if (saveAction === "custom") {
+      const customPath = await input({
+        message: "Output file path:",
+        default: defaultFile
+      });
+      outPath = resolve11(customPath);
+    } else {
+      outPath = resolve11(defaultFile);
+    }
+    mkdirSync5(dirname3(outPath), { recursive: true });
+    writeFileSync5(outPath, formatAsMarkdown(result));
+    console.log(chalk12.green(`
+Spec written to ${outPath}`));
+    const chosenDir = dirname3(outPath);
+    const resolvedDefaultDir = resolve11(intakeDir);
+    if (chosenDir !== resolvedDefaultDir) {
+      const remember = await confirm({
+        message: `Use "${dirname3(outPath).replace(resolve11(".") + "/", "")}" as default output directory next time?`,
+        default: true
+      });
+      if (remember) {
+        const relativeDir = dirname3(outPath).replace(resolve11(".") + "/", "");
+        updateProjectConfig({ intakeDir: relativeDir });
+        console.log(chalk12.dim(`  Saved to .claude/te/config.json`));
+      }
+    }
+  } else if (saveAction === "print") {
+    console.log("\n" + formatAsMarkdown(result));
+  }
+  await doConvexSync(result, rawInput, source, projectName);
+});
+async function doConvexSync(result, rawInput, source, projectName) {
   const synced = await syncIntake({
-    projectName: options.project,
+    projectName,
     rawInput,
     source,
-    extractedSlices: slices.map((s) => ({
+    extractedSlices: result.slices.map((s) => ({
       sliceId: s.sliceId,
       name: s.name,
       category: s.category,
@@ -18004,23 +18196,23 @@ Use --markdown to generate spec slices, --json for raw output.`));
     }))
   });
   logConvexStatus(synced);
-});
+}
 
 // src/commands/init.ts
 import { Command as Command12 } from "commander";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync11 } from "fs";
-import { resolve as resolve11 } from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync12 } from "fs";
+import { resolve as resolve12 } from "path";
 import chalk13 from "chalk";
 var initCommand = new Command12("init").description("Initialize Fathom global config").option("--convex-url <url>", "Convex deployment URL").option("--team <name>", "Team name").action((options) => {
-  const configDir = resolve11(
+  const configDir = resolve12(
     process.env.HOME ?? process.env.USERPROFILE ?? ".",
     ".config",
     "fathom"
   );
-  mkdirSync4(configDir, { recursive: true });
-  const configPath = resolve11(configDir, "config.json");
+  mkdirSync6(configDir, { recursive: true });
+  const configPath = resolve12(configDir, "config.json");
   let existing = {};
-  if (existsSync11(configPath)) {
+  if (existsSync12(configPath)) {
     try {
       existing = JSON.parse(
         __require("fs").readFileSync(configPath, "utf-8")
@@ -18034,7 +18226,7 @@ var initCommand = new Command12("init").description("Initialize Fathom global co
     ...options.team && { team: options.team },
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync4(configPath, JSON.stringify(config, null, 2));
+  writeFileSync6(configPath, JSON.stringify(config, null, 2));
   console.log(chalk13.bold("\nFathom \u2014 Init"));
   console.log(chalk13.dim("\u2500".repeat(40)));
   if (options.convexUrl) {
@@ -18054,50 +18246,50 @@ var initCommand = new Command12("init").description("Initialize Fathom global co
 
 // src/commands/rename.ts
 import { Command as Command13 } from "commander";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync5, existsSync as existsSync12 } from "fs";
-import { resolve as resolve12 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, existsSync as existsSync13 } from "fs";
+import { resolve as resolve13 } from "path";
 import chalk14 from "chalk";
 var renameCommand = new Command13("rename").description("Rename the project in all .claude/te/ config files").argument("<name>", "New project name").action((name) => {
   const baseDir = process.cwd();
-  const teDir = resolve12(baseDir, ".claude", "te");
-  if (!existsSync12(teDir)) {
+  const teDir = resolve13(baseDir, ".claude", "te");
+  if (!existsSync13(teDir)) {
     console.error(
       chalk14.red("\n  Error: .claude/te/ not found. Run `fathom setup` first.\n")
     );
     process.exit(1);
   }
   const jsonFiles = [
-    resolve12(teDir, "config.json"),
-    resolve12(teDir, "registry.json"),
-    resolve12(teDir, "tracking", "summary.json")
+    resolve13(teDir, "config.json"),
+    resolve13(teDir, "registry.json"),
+    resolve13(teDir, "tracking", "summary.json")
   ];
   let oldName = "unnamed";
   let updated = 0;
   for (const filePath of jsonFiles) {
-    if (!existsSync12(filePath)) continue;
-    const data = JSON.parse(readFileSync12(filePath, "utf-8"));
+    if (!existsSync13(filePath)) continue;
+    const data = JSON.parse(readFileSync13(filePath, "utf-8"));
     if (data.project) {
       oldName = data.project;
       data.project = name;
-      writeFileSync5(filePath, JSON.stringify(data, null, 2) + "\n");
+      writeFileSync7(filePath, JSON.stringify(data, null, 2) + "\n");
       updated++;
     }
   }
-  const skillPath = resolve12(baseDir, ".claude", "skills", "fathom", "SKILL.md");
-  if (existsSync12(skillPath)) {
-    const content3 = readFileSync12(skillPath, "utf-8");
+  const skillPath = resolve13(baseDir, ".claude", "skills", "fathom", "SKILL.md");
+  if (existsSync13(skillPath)) {
+    const content3 = readFileSync13(skillPath, "utf-8");
     const newContent = content3.replaceAll(oldName, name);
     if (newContent !== content3) {
-      writeFileSync5(skillPath, newContent);
+      writeFileSync7(skillPath, newContent);
       updated++;
     }
   }
-  const hookPath = resolve12(baseDir, ".claude", "hooks", "te-session-sync.sh");
-  if (existsSync12(hookPath)) {
-    const content3 = readFileSync12(hookPath, "utf-8");
+  const hookPath = resolve13(baseDir, ".claude", "hooks", "te-session-sync.sh");
+  if (existsSync13(hookPath)) {
+    const content3 = readFileSync13(hookPath, "utf-8");
     const newContent = content3.replaceAll(oldName, name);
     if (newContent !== content3) {
-      writeFileSync5(hookPath, newContent);
+      writeFileSync7(hookPath, newContent);
       updated++;
     }
   }
@@ -18110,8 +18302,8 @@ var renameCommand = new Command13("rename").description("Rename the project in a
 
 // src/commands/research.ts
 import { Command as Command14 } from "commander";
-import { writeFileSync as writeFileSync6, existsSync as existsSync13 } from "fs";
-import { resolve as resolve13 } from "path";
+import { writeFileSync as writeFileSync8, existsSync as existsSync14 } from "fs";
+import { resolve as resolve14 } from "path";
 import chalk15 from "chalk";
 
 // src/fetchers/types.ts
@@ -18412,9 +18604,9 @@ function generateAgentsYaml(recommendations) {
 
 // src/commands/research.ts
 function findDataDir2() {
-  const bundled = resolve13(import.meta.dirname ?? __dirname, "data");
-  if (existsSync13(resolve13(bundled, "models.yaml"))) return bundled;
-  return resolve13(import.meta.dirname ?? __dirname, "../../../../data");
+  const bundled = resolve14(import.meta.dirname ?? __dirname, "data");
+  if (existsSync14(resolve14(bundled, "models.yaml"))) return bundled;
+  return resolve14(import.meta.dirname ?? __dirname, "../../../../data");
 }
 var researchCommand = new Command14("research").description("Check and update model pricing data (fetches live data)").option("--update", "Update local data files with latest pricing").option("--sync", "Also sync updated pricing to Convex").option("--check", "Check for differences without updating (default)").option("--offline", "Skip remote fetches, use local data only").option("--verbose", "Show fetch sources and timing details").action(async (options) => {
   console.log(chalk15.bold("\nFathom \u2014 Research: Model Pricing"));
@@ -18464,12 +18656,12 @@ var researchCommand = new Command14("research").description("Check and update mo
   displayRecommendations(mergeResult);
   if (options.update) {
     const dataDir = findDataDir2();
-    const modelsPath = resolve13(dataDir, "models.yaml");
-    const agentsPath = resolve13(dataDir, "agents.yaml");
-    writeFileSync6(modelsPath, generateModelsYaml(mergeResult.models.merged));
+    const modelsPath = resolve14(dataDir, "models.yaml");
+    const agentsPath = resolve14(dataDir, "agents.yaml");
+    writeFileSync8(modelsPath, generateModelsYaml(mergeResult.models.merged));
     console.log(chalk15.green(`
   Updated: ${modelsPath}`));
-    writeFileSync6(agentsPath, generateAgentsYaml(mergeResult.recommendations.merged));
+    writeFileSync8(agentsPath, generateAgentsYaml(mergeResult.recommendations.merged));
     console.log(chalk15.green(`  Updated: ${agentsPath}`));
   }
   if (options.sync) {