@finchtech/cli 0.3.6 → 0.3.7

package/dist/finch.js

@@ -1075,52 +1075,52 @@ var require_util = __commonJS({
       return hash5;
     }
     exports.toHash = toHash;
-    function alwaysValidSchema(it, schema4) {
-      if (typeof schema4 == "boolean")
-        return schema4;
-      if (Object.keys(schema4).length === 0)
+    function alwaysValidSchema(it, schema5) {
+      if (typeof schema5 == "boolean")
+        return schema5;
+      if (Object.keys(schema5).length === 0)
         return true;
-      checkUnknownRules(it, schema4);
-      return !schemaHasRules(schema4, it.self.RULES.all);
+      checkUnknownRules(it, schema5);
+      return !schemaHasRules(schema5, it.self.RULES.all);
     }
     exports.alwaysValidSchema = alwaysValidSchema;
-    function checkUnknownRules(it, schema4 = it.schema) {
+    function checkUnknownRules(it, schema5 = it.schema) {
       const { opts, self } = it;
       if (!opts.strictSchema)
         return;
-      if (typeof schema4 === "boolean")
+      if (typeof schema5 === "boolean")
         return;
       const rules = self.RULES.keywords;
-      for (const key in schema4) {
+      for (const key in schema5) {
         if (!rules[key])
           checkStrictMode(it, `unknown keyword: "${key}"`);
       }
     }
     exports.checkUnknownRules = checkUnknownRules;
-    function schemaHasRules(schema4, rules) {
-      if (typeof schema4 == "boolean")
-        return !schema4;
-      for (const key in schema4)
+    function schemaHasRules(schema5, rules) {
+      if (typeof schema5 == "boolean")
+        return !schema5;
+      for (const key in schema5)
         if (rules[key])
           return true;
       return false;
     }
     exports.schemaHasRules = schemaHasRules;
-    function schemaHasRulesButRef(schema4, RULES) {
-      if (typeof schema4 == "boolean")
-        return !schema4;
-      for (const key in schema4)
+    function schemaHasRulesButRef(schema5, RULES) {
+      if (typeof schema5 == "boolean")
+        return !schema5;
+      for (const key in schema5)
         if (key !== "$ref" && RULES.all[key])
           return true;
       return false;
     }
     exports.schemaHasRulesButRef = schemaHasRulesButRef;
-    function schemaRefOrVal({ topSchemaRef, schemaPath }, schema4, keyword, $data) {
+    function schemaRefOrVal({ topSchemaRef, schemaPath }, schema5, keyword, $data) {
       if (!$data) {
-        if (typeof schema4 == "number" || typeof schema4 == "boolean")
-          return schema4;
-        if (typeof schema4 == "string")
-          return (0, codegen_1._)`${schema4}`;
+        if (typeof schema5 == "number" || typeof schema5 == "boolean")
+          return schema5;
+        if (typeof schema5 == "string")
+          return (0, codegen_1._)`${schema5}`;
       }
       return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
     }
@@ -1401,10 +1401,10 @@ var require_boolSchema = __commonJS({
       message: "boolean schema is false"
     };
     function topBoolOrEmptySchema(it) {
-      const { gen: gen2, schema: schema4, validateName } = it;
-      if (schema4 === false) {
+      const { gen: gen2, schema: schema5, validateName } = it;
+      if (schema5 === false) {
         falseSchemaError(it, false);
-      } else if (typeof schema4 == "object" && schema4.$async === true) {
+      } else if (typeof schema5 == "object" && schema5.$async === true) {
         gen2.return(names_1.default.data);
       } else {
         gen2.assign((0, codegen_1._)`${validateName}.errors`, null);
@@ -1413,8 +1413,8 @@ var require_boolSchema = __commonJS({
     }
     exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
     function boolOrEmptySchema(it, valid) {
-      const { gen: gen2, schema: schema4 } = it;
-      if (schema4 === false) {
+      const { gen: gen2, schema: schema5 } = it;
+      if (schema5 === false) {
         gen2.var(valid, false);
         falseSchemaError(it);
       } else {
@@ -1476,18 +1476,18 @@ var require_applicability = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
-    function schemaHasRulesForType({ schema: schema4, self }, type) {
+    function schemaHasRulesForType({ schema: schema5, self }, type) {
       const group = self.RULES.types[type];
-      return group && group !== true && shouldUseGroup(schema4, group);
+      return group && group !== true && shouldUseGroup(schema5, group);
     }
     exports.schemaHasRulesForType = schemaHasRulesForType;
-    function shouldUseGroup(schema4, group) {
-      return group.rules.some((rule) => shouldUseRule(schema4, rule));
+    function shouldUseGroup(schema5, group) {
+      return group.rules.some((rule) => shouldUseRule(schema5, rule));
     }
     exports.shouldUseGroup = shouldUseGroup;
-    function shouldUseRule(schema4, rule) {
+    function shouldUseRule(schema5, rule) {
       var _a4;
-      return schema4[rule.keyword] !== void 0 || ((_a4 = rule.definition.implements) === null || _a4 === void 0 ? void 0 : _a4.some((kwd) => schema4[kwd] !== void 0));
+      return schema5[rule.keyword] !== void 0 || ((_a4 = rule.definition.implements) === null || _a4 === void 0 ? void 0 : _a4.some((kwd) => schema5[kwd] !== void 0));
     }
     exports.shouldUseRule = shouldUseRule;
   }
@@ -1509,17 +1509,17 @@ var require_dataType = __commonJS({
       DataType2[DataType2["Correct"] = 0] = "Correct";
       DataType2[DataType2["Wrong"] = 1] = "Wrong";
     })(DataType || (exports.DataType = DataType = {}));
-    function getSchemaTypes(schema4) {
-      const types = getJSONTypes(schema4.type);
+    function getSchemaTypes(schema5) {
+      const types = getJSONTypes(schema5.type);
       const hasNull = types.includes("null");
       if (hasNull) {
-        if (schema4.nullable === false)
+        if (schema5.nullable === false)
           throw new Error("type: null contradicts nullable: false");
       } else {
-        if (!types.length && schema4.nullable !== void 0) {
+        if (!types.length && schema5.nullable !== void 0) {
           throw new Error('"nullable" cannot be used without "type"');
         }
-        if (schema4.nullable === true)
+        if (schema5.nullable === true)
           types.push("null");
       }
       return types;
@@ -1651,8 +1651,8 @@ var require_dataType = __commonJS({
     }
     exports.checkDataTypes = checkDataTypes;
     var typeError = {
-      message: ({ schema: schema4 }) => `must be ${schema4}`,
-      params: ({ schema: schema4, schemaValue }) => typeof schema4 == "string" ? (0, codegen_1._)`{type: ${schema4}}` : (0, codegen_1._)`{type: ${schemaValue}}`
+      message: ({ schema: schema5 }) => `must be ${schema5}`,
+      params: ({ schema: schema5, schemaValue }) => typeof schema5 == "string" ? (0, codegen_1._)`{type: ${schema5}}` : (0, codegen_1._)`{type: ${schemaValue}}`
     };
     function reportTypeError(it) {
       const cxt = getTypeErrorContext(it);
@@ -1660,16 +1660,16 @@ var require_dataType = __commonJS({
     }
     exports.reportTypeError = reportTypeError;
     function getTypeErrorContext(it) {
-      const { gen: gen2, data, schema: schema4 } = it;
-      const schemaCode = (0, util_1.schemaRefOrVal)(it, schema4, "type");
+      const { gen: gen2, data, schema: schema5 } = it;
+      const schemaCode = (0, util_1.schemaRefOrVal)(it, schema5, "type");
       return {
         gen: gen2,
         keyword: "type",
         data,
-        schema: schema4.type,
+        schema: schema5.type,
         schemaCode,
         schemaValue: schemaCode,
-        parentSchema: schema4,
+        parentSchema: schema5,
         params: {},
         it
       };
@@ -1822,15 +1822,15 @@ var require_code2 = __commonJS({
     }
     exports.validateArray = validateArray;
     function validateUnion(cxt) {
-      const { gen: gen2, schema: schema4, keyword, it } = cxt;
-      if (!Array.isArray(schema4))
+      const { gen: gen2, schema: schema5, keyword, it } = cxt;
+      if (!Array.isArray(schema5))
         throw new Error("ajv implementation error");
-      const alwaysValid = schema4.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
+      const alwaysValid = schema5.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
       if (alwaysValid && !it.opts.unevaluated)
         return;
       const valid = gen2.let("valid", false);
       const schValid = gen2.name("_valid");
-      gen2.block(() => schema4.forEach((_sch, i2) => {
+      gen2.block(() => schema5.forEach((_sch, i2) => {
         const schCxt = cxt.subschema({
           keyword,
           schemaProp: i2,
@@ -1858,8 +1858,8 @@ var require_keyword = __commonJS({
     var code_1 = require_code2();
     var errors_1 = require_errors();
     function macroKeywordCode(cxt, def) {
-      const { gen: gen2, keyword, schema: schema4, parentSchema, it } = cxt;
-      const macroSchema = def.macro.call(it.self, schema4, parentSchema, it);
+      const { gen: gen2, keyword, schema: schema5, parentSchema, it } = cxt;
+      const macroSchema = def.macro.call(it.self, schema5, parentSchema, it);
       const schemaRef = useKeyword(gen2, keyword, macroSchema);
       if (it.opts.validateSchema !== false)
         it.self.validateSchema(macroSchema, true);
@@ -1876,9 +1876,9 @@ var require_keyword = __commonJS({
     exports.macroKeywordCode = macroKeywordCode;
     function funcKeywordCode(cxt, def) {
       var _a4;
-      const { gen: gen2, keyword, schema: schema4, parentSchema, $data, it } = cxt;
+      const { gen: gen2, keyword, schema: schema5, parentSchema, $data, it } = cxt;
       checkAsyncKeyword(it, def);
-      const validate6 = !$data && def.compile ? def.compile.call(it.self, schema4, parentSchema, it) : def.validate;
+      const validate6 = !$data && def.compile ? def.compile.call(it.self, schema5, parentSchema, it) : def.validate;
       const validateRef = useKeyword(gen2, keyword, validate6);
       const valid = gen2.let("valid");
       cxt.block$data(valid, validateKeyword);
@@ -1938,20 +1938,20 @@ var require_keyword = __commonJS({
         throw new Error(`keyword "${keyword}" failed to compile`);
       return gen2.scopeValue("keyword", typeof result2 == "function" ? { ref: result2 } : { ref: result2, code: (0, codegen_1.stringify)(result2) });
     }
-    function validSchemaType(schema4, schemaType, allowUndefined = false) {
-      return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema4) : st === "object" ? schema4 && typeof schema4 == "object" && !Array.isArray(schema4) : typeof schema4 == st || allowUndefined && typeof schema4 == "undefined");
+    function validSchemaType(schema5, schemaType, allowUndefined = false) {
+      return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema5) : st === "object" ? schema5 && typeof schema5 == "object" && !Array.isArray(schema5) : typeof schema5 == st || allowUndefined && typeof schema5 == "undefined");
     }
     exports.validSchemaType = validSchemaType;
-    function validateKeywordUsage({ schema: schema4, opts, self, errSchemaPath }, def, keyword) {
+    function validateKeywordUsage({ schema: schema5, opts, self, errSchemaPath }, def, keyword) {
       if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
         throw new Error("ajv implementation error");
       }
       const deps = def.dependencies;
-      if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema4, kwd))) {
+      if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema5, kwd))) {
         throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
       }
       if (def.validateSchema) {
-        const valid = def.validateSchema(schema4[keyword]);
+        const valid = def.validateSchema(schema5[keyword]);
         if (!valid) {
           const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors);
           if (opts.validateSchema === "log")
@@ -1973,8 +1973,8 @@ var require_subschema = __commonJS({
     exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
     var codegen_1 = require_codegen();
     var util_1 = require_util();
-    function getSubschema(it, { keyword, schemaProp, schema: schema4, schemaPath, errSchemaPath, topSchemaRef }) {
-      if (keyword !== void 0 && schema4 !== void 0) {
+    function getSubschema(it, { keyword, schemaProp, schema: schema5, schemaPath, errSchemaPath, topSchemaRef }) {
+      if (keyword !== void 0 && schema5 !== void 0) {
         throw new Error('both "keyword" and "schema" passed, only one allowed');
       }
       if (keyword !== void 0) {
@@ -1989,12 +1989,12 @@ var require_subschema = __commonJS({
           errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
         };
       }
-      if (schema4 !== void 0) {
+      if (schema5 !== void 0) {
         if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
           throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
         }
         return {
-          schema: schema4,
+          schema: schema5,
           schemaPath,
           topSchemaRef,
           errSchemaPath
@@ -2087,7 +2087,7 @@ var require_fast_deep_equal = __commonJS({
 var require_json_schema_traverse = __commonJS({
   "../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js"(exports, module) {
     "use strict";
-    var traverse = module.exports = function(schema4, opts, cb) {
+    var traverse = module.exports = function(schema5, opts, cb) {
       if (typeof opts == "function") {
         cb = opts;
         opts = {};
@@ -2097,7 +2097,7 @@ var require_json_schema_traverse = __commonJS({
       };
       var post = cb.post || function() {
       };
-      _traverse(opts, pre, post, schema4, "", schema4);
+      _traverse(opts, pre, post, schema5, "", schema5);
     };
     traverse.keywords = {
       additionalItems: true,
@@ -2143,26 +2143,26 @@ var require_json_schema_traverse = __commonJS({
       maxProperties: true,
       minProperties: true
     };
-    function _traverse(opts, pre, post, schema4, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
-      if (schema4 && typeof schema4 == "object" && !Array.isArray(schema4)) {
-        pre(schema4, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-        for (var key in schema4) {
-          var sch = schema4[key];
+    function _traverse(opts, pre, post, schema5, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+      if (schema5 && typeof schema5 == "object" && !Array.isArray(schema5)) {
+        pre(schema5, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+        for (var key in schema5) {
+          var sch = schema5[key];
           if (Array.isArray(sch)) {
             if (key in traverse.arrayKeywords) {
               for (var i2 = 0; i2 < sch.length; i2++)
-                _traverse(opts, pre, post, sch[i2], jsonPtr + "/" + key + "/" + i2, rootSchema, jsonPtr, key, schema4, i2);
+                _traverse(opts, pre, post, sch[i2], jsonPtr + "/" + key + "/" + i2, rootSchema, jsonPtr, key, schema5, i2);
             }
           } else if (key in traverse.propsKeywords) {
             if (sch && typeof sch == "object") {
               for (var prop in sch)
-                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema4, prop);
+                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema5, prop);
             }
           } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
-            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema4);
+            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema5);
           }
         }
-        post(schema4, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+        post(schema5, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
       }
     }
     function escapeJsonPtr(str) {
@@ -2198,14 +2198,14 @@ var require_resolve = __commonJS({
       "enum",
       "const"
     ]);
-    function inlineRef(schema4, limit = true) {
-      if (typeof schema4 == "boolean")
+    function inlineRef(schema5, limit = true) {
+      if (typeof schema5 == "boolean")
         return true;
       if (limit === true)
-        return !hasRef(schema4);
+        return !hasRef(schema5);
       if (!limit)
         return false;
-      return countKeys(schema4) <= limit;
+      return countKeys(schema5) <= limit;
     }
     exports.inlineRef = inlineRef;
     var REF_KEYWORDS = /* @__PURE__ */ new Set([
@@ -2215,11 +2215,11 @@ var require_resolve = __commonJS({
       "$dynamicRef",
       "$dynamicAnchor"
     ]);
-    function hasRef(schema4) {
-      for (const key in schema4) {
+    function hasRef(schema5) {
+      for (const key in schema5) {
         if (REF_KEYWORDS.has(key))
           return true;
-        const sch = schema4[key];
+        const sch = schema5[key];
         if (Array.isArray(sch) && sch.some(hasRef))
           return true;
         if (typeof sch == "object" && hasRef(sch))
@@ -2227,16 +2227,16 @@ var require_resolve = __commonJS({
       }
       return false;
     }
-    function countKeys(schema4) {
+    function countKeys(schema5) {
       let count = 0;
-      for (const key in schema4) {
+      for (const key in schema5) {
         if (key === "$ref")
           return Infinity;
         count++;
         if (SIMPLE_INLINED.has(key))
           continue;
-        if (typeof schema4[key] == "object") {
-          (0, util_1.eachItem)(schema4[key], (sch) => count += countKeys(sch));
+        if (typeof schema5[key] == "object") {
+          (0, util_1.eachItem)(schema5[key], (sch) => count += countKeys(sch));
         }
         if (count === Infinity)
           return Infinity;
@@ -2266,16 +2266,16 @@ var require_resolve = __commonJS({
     }
     exports.resolveUrl = resolveUrl;
     var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
-    function getSchemaRefs(schema4, baseId) {
-      if (typeof schema4 == "boolean")
+    function getSchemaRefs(schema5, baseId) {
+      if (typeof schema5 == "boolean")
         return {};
       const { schemaId, uriResolver } = this.opts;
-      const schId = normalizeId(schema4[schemaId] || baseId);
+      const schId = normalizeId(schema5[schemaId] || baseId);
       const baseIds = { "": schId };
       const pathPrefix = getFullPath(uriResolver, schId, false);
       const localRefs = {};
       const schemaRefs = /* @__PURE__ */ new Set();
-      traverse(schema4, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
+      traverse(schema5, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
         if (parentJsonPtr === void 0)
           return;
         const fullPath = pathPrefix + jsonPtr;
@@ -2356,15 +2356,15 @@ var require_validate = __commonJS({
       validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
     }
     exports.validateFunctionCode = validateFunctionCode;
-    function validateFunction({ gen: gen2, validateName, schema: schema4, schemaEnv, opts }, body) {
+    function validateFunction({ gen: gen2, validateName, schema: schema5, schemaEnv, opts }, body) {
       if (opts.code.es5) {
         gen2.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
-          gen2.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema4, opts)}`);
+          gen2.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema5, opts)}`);
           destructureValCxtES5(gen2, opts);
           gen2.code(body);
         });
       } else {
-        gen2.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen2.code(funcSourceUrl(schema4, opts)).code(body));
+        gen2.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen2.code(funcSourceUrl(schema5, opts)).code(body));
       }
     }
     function destructureValCxt(opts) {
@@ -2388,9 +2388,9 @@ var require_validate = __commonJS({
       });
     }
     function topSchemaObjCode(it) {
-      const { schema: schema4, opts, gen: gen2 } = it;
+      const { schema: schema5, opts, gen: gen2 } = it;
       validateFunction(it, () => {
-        if (opts.$comment && schema4.$comment)
+        if (opts.$comment && schema5.$comment)
           commentKeyword(it);
         checkNoDefault(it);
         gen2.let(names_1.default.vErrors, null);
@@ -2408,8 +2408,8 @@ var require_validate = __commonJS({
       gen2.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen2.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
       gen2.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen2.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
     }
-    function funcSourceUrl(schema4, opts) {
-      const schId = typeof schema4 == "object" && schema4[opts.schemaId];
+    function funcSourceUrl(schema5, opts) {
+      const schId = typeof schema5 == "object" && schema5[opts.schemaId];
       return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
     }
     function subschemaCode(it, valid) {
@@ -2422,10 +2422,10 @@ var require_validate = __commonJS({
       }
       (0, boolSchema_1.boolOrEmptySchema)(it, valid);
     }
-    function schemaCxtHasRules({ schema: schema4, self }) {
-      if (typeof schema4 == "boolean")
-        return !schema4;
-      for (const key in schema4)
+    function schemaCxtHasRules({ schema: schema5, self }) {
+      if (typeof schema5 == "boolean")
+        return !schema5;
+      for (const key in schema5)
         if (self.RULES.all[key])
           return true;
       return false;
@@ -2434,8 +2434,8 @@ var require_validate = __commonJS({
       return typeof it.schema != "boolean";
     }
     function subSchemaObjCode(it, valid) {
-      const { schema: schema4, gen: gen2, opts } = it;
-      if (opts.$comment && schema4.$comment)
+      const { schema: schema5, gen: gen2, opts } = it;
+      if (opts.$comment && schema5.$comment)
         commentKeyword(it);
       updateContext(it);
       checkAsyncSchema(it);
@@ -2455,14 +2455,14 @@ var require_validate = __commonJS({
       schemaKeywords(it, types, !checkedTypes, errsCount);
     }
     function checkRefsAndKeywords(it) {
-      const { schema: schema4, errSchemaPath, opts, self } = it;
-      if (schema4.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema4, self.RULES)) {
+      const { schema: schema5, errSchemaPath, opts, self } = it;
+      if (schema5.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema5, self.RULES)) {
         self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
       }
     }
     function checkNoDefault(it) {
-      const { schema: schema4, opts } = it;
-      if (schema4.default !== void 0 && opts.useDefaults && opts.strictSchema) {
+      const { schema: schema5, opts } = it;
+      if (schema5.default !== void 0 && opts.useDefaults && opts.strictSchema) {
         (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
       }
     }
@@ -2475,8 +2475,8 @@ var require_validate = __commonJS({
       if (it.schema.$async && !it.schemaEnv.$async)
         throw new Error("async schema in sync schema");
     }
-    function commentKeyword({ gen: gen2, schemaEnv, schema: schema4, errSchemaPath, opts }) {
-      const msg = schema4.$comment;
+    function commentKeyword({ gen: gen2, schemaEnv, schema: schema5, errSchemaPath, opts }) {
+      const msg = schema5.$comment;
       if (opts.$comment === true) {
         gen2.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
       } else if (typeof opts.$comment == "function") {
@@ -2503,9 +2503,9 @@ var require_validate = __commonJS({
         gen2.assign((0, codegen_1._)`${evaluated}.items`, items);
     }
     function schemaKeywords(it, types, typeErrors, errsCount) {
-      const { gen: gen2, schema: schema4, data, allErrors, opts, self } = it;
+      const { gen: gen2, schema: schema5, data, allErrors, opts, self } = it;
       const { RULES } = self;
-      if (schema4.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema4, RULES))) {
+      if (schema5.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema5, RULES))) {
         gen2.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
         return;
       }
@@ -2517,7 +2517,7 @@ var require_validate = __commonJS({
         groupKeywords(RULES.post);
       });
       function groupKeywords(group) {
-        if (!(0, applicability_1.shouldUseGroup)(schema4, group))
+        if (!(0, applicability_1.shouldUseGroup)(schema5, group))
           return;
         if (group.type) {
           gen2.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
@@ -2535,12 +2535,12 @@ var require_validate = __commonJS({
       }
     }
     function iterateKeywords(it, group) {
-      const { gen: gen2, schema: schema4, opts: { useDefaults } } = it;
+      const { gen: gen2, schema: schema5, opts: { useDefaults } } = it;
       if (useDefaults)
         (0, defaults_1.assignDefaults)(it, group.type);
       gen2.block(() => {
         for (const rule of group.rules) {
-          if ((0, applicability_1.shouldUseRule)(schema4, rule)) {
+          if ((0, applicability_1.shouldUseRule)(schema5, rule)) {
             keywordCode(it, rule.keyword, rule.definition, group.type);
           }
         }
@@ -2885,17 +2885,17 @@ var require_compile = __commonJS({
         var _a4;
         this.refs = {};
         this.dynamicAnchors = {};
-        let schema4;
+        let schema5;
         if (typeof env.schema == "object")
-          schema4 = env.schema;
+          schema5 = env.schema;
         this.schema = env.schema;
         this.schemaId = env.schemaId;
         this.root = env.root || this;
-        this.baseId = (_a4 = env.baseId) !== null && _a4 !== void 0 ? _a4 : (0, resolve_1.normalizeId)(schema4 === null || schema4 === void 0 ? void 0 : schema4[env.schemaId || "$id"]);
+        this.baseId = (_a4 = env.baseId) !== null && _a4 !== void 0 ? _a4 : (0, resolve_1.normalizeId)(schema5 === null || schema5 === void 0 ? void 0 : schema5[env.schemaId || "$id"]);
         this.schemaPath = env.schemaPath;
         this.localRefs = env.localRefs;
         this.meta = env.meta;
-        this.$async = schema4 === null || schema4 === void 0 ? void 0 : schema4.$async;
+        this.$async = schema5 === null || schema5 === void 0 ? void 0 : schema5.$async;
         this.refs = {};
       }
     };
@@ -2994,10 +2994,10 @@ var require_compile = __commonJS({
         return schOrFunc;
       let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
-        const schema4 = (_a4 = root.localRefs) === null || _a4 === void 0 ? void 0 : _a4[ref];
+        const schema5 = (_a4 = root.localRefs) === null || _a4 === void 0 ? void 0 : _a4[ref];
         const { schemaId } = this.opts;
-        if (schema4)
-          _sch = new SchemaEnv({ schema: schema4, schemaId, root, baseId });
+        if (schema5)
+          _sch = new SchemaEnv({ schema: schema5, schemaId, root, baseId });
       }
       if (_sch === void 0)
         return;
@@ -3045,12 +3045,12 @@ var require_compile = __commonJS({
       if (!schOrRef.validate)
         compileSchema.call(this, schOrRef);
       if (id === (0, resolve_1.normalizeId)(ref)) {
-        const { schema: schema4 } = schOrRef;
+        const { schema: schema5 } = schOrRef;
         const { schemaId } = this.opts;
-        const schId = schema4[schemaId];
+        const schId = schema5[schemaId];
         if (schId)
           baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-        return new SchemaEnv({ schema: schema4, schemaId, root, baseId });
+        return new SchemaEnv({ schema: schema5, schemaId, root, baseId });
       }
       return getJsonPointer.call(this, p, schOrRef);
     }
@@ -3062,29 +3062,29 @@ var require_compile = __commonJS({
       "dependencies",
       "definitions"
     ]);
-    function getJsonPointer(parsedRef, { baseId, schema: schema4, root }) {
+    function getJsonPointer(parsedRef, { baseId, schema: schema5, root }) {
       var _a4;
       if (((_a4 = parsedRef.fragment) === null || _a4 === void 0 ? void 0 : _a4[0]) !== "/")
         return;
       for (const part of parsedRef.fragment.slice(1).split("/")) {
-        if (typeof schema4 === "boolean")
+        if (typeof schema5 === "boolean")
           return;
-        const partSchema = schema4[(0, util_1.unescapeFragment)(part)];
+        const partSchema = schema5[(0, util_1.unescapeFragment)(part)];
         if (partSchema === void 0)
           return;
-        schema4 = partSchema;
-        const schId = typeof schema4 === "object" && schema4[this.opts.schemaId];
+        schema5 = partSchema;
+        const schId = typeof schema5 === "object" && schema5[this.opts.schemaId];
         if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
           baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
         }
       }
       let env;
-      if (typeof schema4 != "boolean" && schema4.$ref && !(0, util_1.schemaHasRulesButRef)(schema4, this.RULES)) {
-        const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema4.$ref);
+      if (typeof schema5 != "boolean" && schema5.$ref && !(0, util_1.schemaHasRulesButRef)(schema5, this.RULES)) {
+        const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema5.$ref);
         env = resolveSchema.call(this, root, $ref);
       }
       const { schemaId } = this.opts;
-      env = env || new SchemaEnv({ schema: schema4, schemaId, root, baseId });
+      env = env || new SchemaEnv({ schema: schema5, schemaId, root, baseId });
       if (env.schema !== env.root.schema)
         return env;
       return void 0;
@@ -3784,18 +3784,18 @@ var require_fast_uri = __commonJS({
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
     var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
     var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
-    function getParseError(parsed, matches) {
-      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+    function getParseError(parsed2, matches) {
+      if (matches[2] !== void 0 && parsed2.path && parsed2.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
       }
-      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+      if (typeof parsed2.port === "number" && (parsed2.port < 0 || parsed2.port > 65535)) {
         return "URI port is malformed.";
       }
       return void 0;
     }
     function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
-      const parsed = {
+      const parsed2 = {
         scheme: void 0,
         userinfo: void 0,
         host: "",
@@ -3815,7 +3815,7 @@ var require_fast_uri = __commonJS({
       }
       const authorityMatch = uri.match(AUTHORITY_PREFIX);
       if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
-        parsed.error = "URI authority must not contain a literal backslash.";
+        parsed2.error = "URI authority must not contain a literal backslash.";
         malformedAuthorityOrPort = true;
       }
       const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
@@ -3824,90 +3824,90 @@ var require_fast_uri = __commonJS({
         const normalizedRegion = region.replace(/[\t\n\r]/g, "");
         if (normalizedRegion.length >= 2) {
           if (normalizedRegion.slice(0, 2) !== "//") {
-            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            parsed2.error = parsed2.error || "URI authority must not contain a literal backslash.";
             malformedAuthorityOrPort = true;
           } else if (region.length !== normalizedRegion.length) {
-            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            parsed2.error = parsed2.error || "URI authority introducer must not contain whitespace.";
             malformedAuthorityOrPort = true;
           }
         }
       }
       const matches = uri.match(URI_PARSE);
       if (matches) {
-        parsed.scheme = matches[1];
-        parsed.userinfo = matches[3];
-        parsed.host = matches[4];
-        parsed.port = parseInt(matches[5], 10);
-        parsed.path = matches[6] || "";
-        parsed.query = matches[7];
-        parsed.fragment = matches[8];
-        if (isNaN(parsed.port)) {
-          parsed.port = matches[5];
-        }
-        const parseError = getParseError(parsed, matches);
+        parsed2.scheme = matches[1];
+        parsed2.userinfo = matches[3];
+        parsed2.host = matches[4];
+        parsed2.port = parseInt(matches[5], 10);
+        parsed2.path = matches[6] || "";
+        parsed2.query = matches[7];
+        parsed2.fragment = matches[8];
+        if (isNaN(parsed2.port)) {
+          parsed2.port = matches[5];
+        }
+        const parseError = getParseError(parsed2, matches);
         if (parseError !== void 0) {
-          parsed.error = parsed.error || parseError;
+          parsed2.error = parsed2.error || parseError;
           malformedAuthorityOrPort = true;
         }
-        if (parsed.host) {
-          const ipv4result = isIPv4(parsed.host);
+        if (parsed2.host) {
+          const ipv4result = isIPv4(parsed2.host);
           if (ipv4result === false) {
-            const ipv6result = normalizeIPv6(parsed.host);
-            parsed.host = ipv6result.host.toLowerCase();
+            const ipv6result = normalizeIPv6(parsed2.host);
+            parsed2.host = ipv6result.host.toLowerCase();
             isIP = ipv6result.isIPV6;
           } else {
             isIP = true;
           }
         }
-        if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) {
-          parsed.reference = "same-document";
-        } else if (parsed.scheme === void 0) {
-          parsed.reference = "relative";
-        } else if (parsed.fragment === void 0) {
-          parsed.reference = "absolute";
+        if (parsed2.scheme === void 0 && parsed2.userinfo === void 0 && parsed2.host === void 0 && parsed2.port === void 0 && parsed2.query === void 0 && !parsed2.path) {
+          parsed2.reference = "same-document";
+        } else if (parsed2.scheme === void 0) {
+          parsed2.reference = "relative";
+        } else if (parsed2.fragment === void 0) {
+          parsed2.reference = "absolute";
         } else {
-          parsed.reference = "uri";
+          parsed2.reference = "uri";
         }
-        if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
-          parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
+        if (options.reference && options.reference !== "suffix" && options.reference !== parsed2.reference) {
+          parsed2.error = parsed2.error || "URI is not a " + options.reference + " reference.";
         }
-        const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
+        const schemeHandler = getSchemeHandler(options.scheme || parsed2.scheme);
         if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+          if (parsed2.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed2.host)) {
             try {
-              parsed.host = new URL("http://" + parsed.host).hostname;
+              parsed2.host = new URL("http://" + parsed2.host).hostname;
             } catch (e) {
-              parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+              parsed2.error = parsed2.error || "Host's domain name can not be converted to ASCII: " + e;
             }
           }
         }
         if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
           if (uri.indexOf("%") !== -1) {
-            if (parsed.scheme !== void 0) {
-              parsed.scheme = unescape(parsed.scheme);
+            if (parsed2.scheme !== void 0) {
+              parsed2.scheme = unescape(parsed2.scheme);
             }
-            if (parsed.host !== void 0) {
-              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+            if (parsed2.host !== void 0) {
+              parsed2.host = reescapeHostDelimiters(unescape(parsed2.host), isIP);
             }
           }
-          if (parsed.path) {
-            parsed.path = normalizePathEncoding(parsed.path);
+          if (parsed2.path) {
+            parsed2.path = normalizePathEncoding(parsed2.path);
           }
-          if (parsed.fragment) {
+          if (parsed2.fragment) {
             try {
-              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+              parsed2.fragment = encodeURI(decodeURIComponent(parsed2.fragment));
             } catch {
-              parsed.error = parsed.error || "URI malformed";
+              parsed2.error = parsed2.error || "URI malformed";
             }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
-          schemeHandler.parse(parsed, options);
+          schemeHandler.parse(parsed2, options);
         }
       } else {
-        parsed.error = parsed.error || "URI can not be parsed.";
+        parsed2.error = parsed2.error || "URI can not be parsed.";
       }
-      return { parsed, malformedAuthorityOrPort };
+      return { parsed: parsed2, malformedAuthorityOrPort };
     }
     function parse4(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
@@ -3916,9 +3916,9 @@ var require_fast_uri = __commonJS({
       return normalizeStringWithStatus(uri, opts).normalized;
     }
     function normalizeStringWithStatus(uri, opts) {
-      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      const { parsed: parsed2, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed2, opts),
         malformedAuthorityOrPort
       };
     }
@@ -4126,16 +4126,16 @@ var require_core = __commonJS({
           this.errors = v.errors;
         return valid;
       }
-      compile(schema4, _meta) {
-        const sch = this._addSchema(schema4, _meta);
+      compile(schema5, _meta) {
+        const sch = this._addSchema(schema5, _meta);
         return sch.validate || this._compileSchemaEnv(sch);
       }
-      compileAsync(schema4, meta3) {
+      compileAsync(schema5, meta3) {
         if (typeof this.opts.loadSchema != "function") {
           throw new Error("options.loadSchema should be a function");
         }
         const { loadSchema } = this.opts;
-        return runCompileAsync.call(this, schema4, meta3);
+        return runCompileAsync.call(this, schema5, meta3);
         async function runCompileAsync(_schema, _meta) {
           await loadMetaSchema.call(this, _schema.$schema);
           const sch = this._addSchema(_schema, _meta);
@@ -4181,37 +4181,37 @@ var require_core = __commonJS({
         }
       }
       // Adds schema to the instance
-      addSchema(schema4, key, _meta, _validateSchema = this.opts.validateSchema) {
-        if (Array.isArray(schema4)) {
-          for (const sch of schema4)
+      addSchema(schema5, key, _meta, _validateSchema = this.opts.validateSchema) {
+        if (Array.isArray(schema5)) {
+          for (const sch of schema5)
             this.addSchema(sch, void 0, _meta, _validateSchema);
           return this;
         }
         let id;
-        if (typeof schema4 === "object") {
+        if (typeof schema5 === "object") {
           const { schemaId } = this.opts;
-          id = schema4[schemaId];
+          id = schema5[schemaId];
           if (id !== void 0 && typeof id != "string") {
             throw new Error(`schema ${schemaId} must be string`);
           }
         }
         key = (0, resolve_1.normalizeId)(key || id);
         this._checkUnique(key);
-        this.schemas[key] = this._addSchema(schema4, _meta, key, _validateSchema, true);
+        this.schemas[key] = this._addSchema(schema5, _meta, key, _validateSchema, true);
         return this;
       }
       // Add schema that will be used to validate other schemas
       // options in META_IGNORE_OPTIONS are alway set to false
-      addMetaSchema(schema4, key, _validateSchema = this.opts.validateSchema) {
-        this.addSchema(schema4, key, true, _validateSchema);
+      addMetaSchema(schema5, key, _validateSchema = this.opts.validateSchema) {
+        this.addSchema(schema5, key, true, _validateSchema);
         return this;
       }
       //  Validate schema against its meta-schema
-      validateSchema(schema4, throwOrLogError) {
-        if (typeof schema4 == "boolean")
+      validateSchema(schema5, throwOrLogError) {
+        if (typeof schema5 == "boolean")
           return true;
         let $schema;
-        $schema = schema4.$schema;
+        $schema = schema5.$schema;
         if ($schema !== void 0 && typeof $schema != "string") {
           throw new Error("$schema must be a string");
         }
@@ -4221,7 +4221,7 @@ var require_core = __commonJS({
           this.errors = null;
           return true;
         }
-        const valid = this.validate($schema, schema4);
+        const valid = this.validate($schema, schema5);
         if (!valid && throwOrLogError) {
           const message = "schema is invalid: " + this.errorsText();
           if (this.opts.validateSchema === "log")
@@ -4364,9 +4364,9 @@ var require_core = __commonJS({
             if (typeof rule != "object")
               continue;
             const { $data } = rule.definition;
-            const schema4 = keywords[key];
-            if ($data && schema4)
-              keywords[key] = schemaOrData(schema4);
+            const schema5 = keywords[key];
+            if ($data && schema5)
+              keywords[key] = schemaOrData(schema5);
           }
         }
         return metaSchema;
@@ -4384,23 +4384,23 @@ var require_core = __commonJS({
           }
         }
       }
-      _addSchema(schema4, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+      _addSchema(schema5, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
         let id;
         const { schemaId } = this.opts;
-        if (typeof schema4 == "object") {
-          id = schema4[schemaId];
+        if (typeof schema5 == "object") {
+          id = schema5[schemaId];
         } else {
           if (this.opts.jtd)
             throw new Error("schema must be object");
-          else if (typeof schema4 != "boolean")
+          else if (typeof schema5 != "boolean")
             throw new Error("schema must be object or boolean");
         }
-        let sch = this._cache.get(schema4);
+        let sch = this._cache.get(schema5);
         if (sch !== void 0)
           return sch;
         baseId = (0, resolve_1.normalizeId)(id || baseId);
-        const localRefs = resolve_1.getSchemaRefs.call(this, schema4, baseId);
-        sch = new compile_1.SchemaEnv({ schema: schema4, schemaId, meta: meta3, baseId, localRefs });
+        const localRefs = resolve_1.getSchemaRefs.call(this, schema5, baseId);
+        sch = new compile_1.SchemaEnv({ schema: schema5, schemaId, meta: meta3, baseId, localRefs });
         this._cache.set(sch.schema, sch);
         if (addSchema && !baseId.startsWith("#")) {
           if (baseId)
@@ -4408,7 +4408,7 @@ var require_core = __commonJS({
           this.refs[baseId] = sch;
         }
         if (validateSchema)
-          this.validateSchema(schema4, true);
+          this.validateSchema(schema5, true);
         return sch;
       }
       _checkUnique(id) {
@@ -4562,8 +4562,8 @@ var require_core = __commonJS({
     var $dataRef = {
       $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
     };
-    function schemaOrData(schema4) {
-      return { anyOf: [schema4, $dataRef] };
+    function schemaOrData(schema5) {
+      return { anyOf: [schema5, $dataRef] };
     }
   }
 });
@@ -4863,7 +4863,7 @@ var require_pattern = __commonJS({
       $data: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, data, $data, schema: schema4, schemaCode, it } = cxt;
+        const { gen: gen2, data, $data, schema: schema5, schemaCode, it } = cxt;
         const u = it.opts.unicodeRegExp ? "u" : "";
         if ($data) {
           const { regExp } = it.opts.code;
@@ -4872,7 +4872,7 @@ var require_pattern = __commonJS({
           gen2.try(() => gen2.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen2.assign(valid, false));
           cxt.fail$data((0, codegen_1._)`!${valid}`);
         } else {
-          const regExp = (0, code_1.usePattern)(cxt, schema4);
+          const regExp = (0, code_1.usePattern)(cxt, schema5);
           cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
         }
       }
@@ -4929,11 +4929,11 @@ var require_required = __commonJS({
       $data: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, schema: schema4, schemaCode, data, $data, it } = cxt;
+        const { gen: gen2, schema: schema5, schemaCode, data, $data, it } = cxt;
         const { opts } = it;
-        if (!$data && schema4.length === 0)
+        if (!$data && schema5.length === 0)
           return;
-        const useLoop = schema4.length >= opts.loopRequired;
+        const useLoop = schema5.length >= opts.loopRequired;
         if (it.allErrors)
           allErrorsMode();
         else
@@ -4941,7 +4941,7 @@ var require_required = __commonJS({
         if (opts.strictRequired) {
           const props = cxt.parentSchema.properties;
           const { definedProperties } = cxt.it;
-          for (const requiredKey of schema4) {
+          for (const requiredKey of schema5) {
             if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
               const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
               const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
@@ -4953,7 +4953,7 @@ var require_required = __commonJS({
           if (useLoop || $data) {
             cxt.block$data(codegen_1.nil, loopAllRequired);
           } else {
-            for (const prop of schema4) {
+            for (const prop of schema5) {
               (0, code_1.checkReportMissingProp)(cxt, prop);
             }
           }
@@ -4965,7 +4965,7 @@ var require_required = __commonJS({
             cxt.block$data(valid, () => loopUntilMissing(missing, valid));
             cxt.ok(valid);
           } else {
-            gen2.if((0, code_1.checkMissingProp)(cxt, schema4, missing));
+            gen2.if((0, code_1.checkMissingProp)(cxt, schema5, missing));
             (0, code_1.reportMissingProp)(cxt, missing);
             gen2.else();
           }
@@ -5052,8 +5052,8 @@ var require_uniqueItems = __commonJS({
       $data: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, data, $data, schema: schema4, parentSchema, schemaCode, it } = cxt;
-        if (!$data && !schema4)
+        const { gen: gen2, data, $data, schema: schema5, parentSchema, schemaCode, it } = cxt;
+        if (!$data && !schema5)
           return;
         const valid = gen2.let("valid");
         const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
@@ -5116,11 +5116,11 @@ var require_const = __commonJS({
       $data: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, data, $data, schemaCode, schema: schema4 } = cxt;
-        if ($data || schema4 && typeof schema4 == "object") {
+        const { gen: gen2, data, $data, schemaCode, schema: schema5 } = cxt;
+        if ($data || schema5 && typeof schema5 == "object") {
           cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen2, equal_1.default)}(${data}, ${schemaCode})`);
         } else {
-          cxt.fail((0, codegen_1._)`${schema4} !== ${data}`);
+          cxt.fail((0, codegen_1._)`${schema5} !== ${data}`);
         }
       }
     };
@@ -5146,10 +5146,10 @@ var require_enum = __commonJS({
       $data: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, data, $data, schema: schema4, schemaCode, it } = cxt;
-        if (!$data && schema4.length === 0)
+        const { gen: gen2, data, $data, schema: schema5, schemaCode, it } = cxt;
+        if (!$data && schema5.length === 0)
           throw new Error("enum must have non-empty array");
-        const useLoop = schema4.length >= it.opts.loopEnum;
+        const useLoop = schema5.length >= it.opts.loopEnum;
         let eql;
         const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen2, equal_1.default);
         let valid;
@@ -5157,10 +5157,10 @@ var require_enum = __commonJS({
           valid = gen2.let("valid");
           cxt.block$data(valid, loopEnum);
         } else {
-          if (!Array.isArray(schema4))
+          if (!Array.isArray(schema5))
             throw new Error("ajv implementation error");
           const vSchema = gen2.const("vSchema", schemaCode);
-          valid = (0, codegen_1.or)(...schema4.map((_x, i2) => equalCode(vSchema, i2)));
+          valid = (0, codegen_1.or)(...schema5.map((_x, i2) => equalCode(vSchema, i2)));
         }
         cxt.pass(valid);
         function loopEnum() {
@@ -5168,7 +5168,7 @@ var require_enum = __commonJS({
           gen2.forOf("v", schemaCode, (v) => gen2.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen2.assign(valid, true).break()));
         }
         function equalCode(vSchema, i2) {
-          const sch = schema4[i2];
+          const sch = schema5[i2];
           return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i2}])` : (0, codegen_1._)`${data} === ${sch}`;
         }
       }
@@ -5244,13 +5244,13 @@ var require_additionalItems = __commonJS({
       }
     };
     function validateAdditionalItems(cxt, items) {
-      const { gen: gen2, schema: schema4, data, keyword, it } = cxt;
+      const { gen: gen2, schema: schema5, data, keyword, it } = cxt;
       it.items = true;
       const len = gen2.const("len", (0, codegen_1._)`${data}.length`);
-      if (schema4 === false) {
+      if (schema5 === false) {
         cxt.setParams({ len: items.length });
         cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
-      } else if (typeof schema4 == "object" && !(0, util_1.alwaysValidSchema)(it, schema4)) {
+      } else if (typeof schema5 == "object" && !(0, util_1.alwaysValidSchema)(it, schema5)) {
         const valid = gen2.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
         gen2.if((0, codegen_1.not)(valid), () => validateItems(valid));
         cxt.ok(valid);
@@ -5283,11 +5283,11 @@ var require_items = __commonJS({
       schemaType: ["object", "array", "boolean"],
       before: "uniqueItems",
       code(cxt) {
-        const { schema: schema4, it } = cxt;
-        if (Array.isArray(schema4))
-          return validateTuple(cxt, "additionalItems", schema4);
+        const { schema: schema5, it } = cxt;
+        if (Array.isArray(schema5))
+          return validateTuple(cxt, "additionalItems", schema5);
         it.items = true;
-        if ((0, util_1.alwaysValidSchema)(it, schema4))
+        if ((0, util_1.alwaysValidSchema)(it, schema5))
           return;
         cxt.ok((0, code_1.validateArray)(cxt));
       }
@@ -5362,10 +5362,10 @@ var require_items2020 = __commonJS({
       before: "uniqueItems",
       error: error51,
       code(cxt) {
-        const { schema: schema4, parentSchema, it } = cxt;
+        const { schema: schema5, parentSchema, it } = cxt;
         const { prefixItems } = parentSchema;
         it.items = true;
-        if ((0, util_1.alwaysValidSchema)(it, schema4))
+        if ((0, util_1.alwaysValidSchema)(it, schema5))
           return;
         if (prefixItems)
           (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
@@ -5396,7 +5396,7 @@ var require_contains = __commonJS({
       trackErrors: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, schema: schema4, parentSchema, data, it } = cxt;
+        const { gen: gen2, schema: schema5, parentSchema, data, it } = cxt;
         let min;
         let max2;
         const { minContains, maxContains } = parentSchema;
@@ -5417,7 +5417,7 @@ var require_contains = __commonJS({
           cxt.fail();
           return;
         }
-        if ((0, util_1.alwaysValidSchema)(it, schema4)) {
+        if ((0, util_1.alwaysValidSchema)(it, schema5)) {
           let cond = (0, codegen_1._)`${len} >= ${min}`;
           if (max2 !== void 0)
             cond = (0, codegen_1._)`${cond} && ${len} <= ${max2}`;
@@ -5502,14 +5502,14 @@ var require_dependencies = __commonJS({
         validateSchemaDeps(cxt, schDeps);
       }
     };
-    function splitDependencies({ schema: schema4 }) {
+    function splitDependencies({ schema: schema5 }) {
       const propertyDeps = {};
       const schemaDeps = {};
-      for (const key in schema4) {
+      for (const key in schema5) {
         if (key === "__proto__")
           continue;
-        const deps = Array.isArray(schema4[key]) ? propertyDeps : schemaDeps;
-        deps[key] = schema4[key];
+        const deps = Array.isArray(schema5[key]) ? propertyDeps : schemaDeps;
+        deps[key] = schema5[key];
       }
       return [propertyDeps, schemaDeps];
     }
@@ -5582,8 +5582,8 @@ var require_propertyNames = __commonJS({
       schemaType: ["object", "boolean"],
       error: error51,
       code(cxt) {
-        const { gen: gen2, schema: schema4, data, it } = cxt;
-        if ((0, util_1.alwaysValidSchema)(it, schema4))
+        const { gen: gen2, schema: schema5, data, it } = cxt;
+        if ((0, util_1.alwaysValidSchema)(it, schema5))
           return;
         const valid = gen2.name("valid");
         gen2.forIn("key", data, (key) => {
@@ -5629,12 +5629,12 @@ var require_additionalProperties = __commonJS({
       trackErrors: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, schema: schema4, parentSchema, data, errsCount, it } = cxt;
+        const { gen: gen2, schema: schema5, parentSchema, data, errsCount, it } = cxt;
         if (!errsCount)
           throw new Error("ajv implementation error");
         const { allErrors, opts } = it;
         it.props = true;
-        if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema4))
+        if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema5))
           return;
         const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
         const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
@@ -5667,18 +5667,18 @@ var require_additionalProperties = __commonJS({
           gen2.code((0, codegen_1._)`delete ${data}[${key}]`);
         }
         function additionalPropertyCode(key) {
-          if (opts.removeAdditional === "all" || opts.removeAdditional && schema4 === false) {
+          if (opts.removeAdditional === "all" || opts.removeAdditional && schema5 === false) {
             deleteAdditional(key);
             return;
           }
-          if (schema4 === false) {
+          if (schema5 === false) {
             cxt.setParams({ additionalProperty: key });
             cxt.error();
             if (!allErrors)
               gen2.break();
             return;
           }
-          if (typeof schema4 == "object" && !(0, util_1.alwaysValidSchema)(it, schema4)) {
+          if (typeof schema5 == "object" && !(0, util_1.alwaysValidSchema)(it, schema5)) {
             const valid = gen2.name("valid");
             if (opts.removeAdditional === "failing") {
               applyAdditionalSchema(key, valid, false);
@@ -5728,18 +5728,18 @@ var require_properties = __commonJS({
       type: "object",
       schemaType: "object",
       code(cxt) {
-        const { gen: gen2, schema: schema4, parentSchema, data, it } = cxt;
+        const { gen: gen2, schema: schema5, parentSchema, data, it } = cxt;
         if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) {
           additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
         }
-        const allProps = (0, code_1.allSchemaProperties)(schema4);
+        const allProps = (0, code_1.allSchemaProperties)(schema5);
         for (const prop of allProps) {
           it.definedProperties.add(prop);
         }
         if (it.opts.unevaluated && allProps.length && it.props !== true) {
           it.props = util_1.mergeEvaluated.props(gen2, (0, util_1.toHash)(allProps), it.props);
         }
-        const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema4[p]));
+        const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema5[p]));
         if (properties.length === 0)
           return;
         const valid = gen2.name("valid");
@@ -5757,7 +5757,7 @@ var require_properties = __commonJS({
           cxt.ok(valid);
         }
         function hasDefault(prop) {
-          return it.opts.useDefaults && !it.compositeRule && schema4[prop].default !== void 0;
+          return it.opts.useDefaults && !it.compositeRule && schema5[prop].default !== void 0;
         }
         function applyPropertySchema(prop) {
           cxt.subschema({
@@ -5786,10 +5786,10 @@ var require_patternProperties = __commonJS({
       type: "object",
       schemaType: "object",
       code(cxt) {
-        const { gen: gen2, schema: schema4, data, parentSchema, it } = cxt;
+        const { gen: gen2, schema: schema5, data, parentSchema, it } = cxt;
         const { opts } = it;
-        const patterns = (0, code_1.allSchemaProperties)(schema4);
-        const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema4[p]));
+        const patterns = (0, code_1.allSchemaProperties)(schema5);
+        const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema5[p]));
         if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
           return;
         }
@@ -5857,8 +5857,8 @@ var require_not = __commonJS({
       schemaType: ["object", "boolean"],
       trackErrors: true,
       code(cxt) {
-        const { gen: gen2, schema: schema4, it } = cxt;
-        if ((0, util_1.alwaysValidSchema)(it, schema4)) {
+        const { gen: gen2, schema: schema5, it } = cxt;
+        if ((0, util_1.alwaysValidSchema)(it, schema5)) {
           cxt.fail();
           return;
         }
@@ -5911,12 +5911,12 @@ var require_oneOf = __commonJS({
       trackErrors: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, schema: schema4, parentSchema, it } = cxt;
-        if (!Array.isArray(schema4))
+        const { gen: gen2, schema: schema5, parentSchema, it } = cxt;
+        if (!Array.isArray(schema5))
           throw new Error("ajv implementation error");
         if (it.opts.discriminator && parentSchema.discriminator)
           return;
-        const schArr = schema4;
+        const schArr = schema5;
         const valid = gen2.let("valid", false);
         const passing = gen2.let("passing", null);
         const schValid = gen2.name("_valid");
@@ -5962,11 +5962,11 @@ var require_allOf = __commonJS({
       keyword: "allOf",
       schemaType: "array",
       code(cxt) {
-        const { gen: gen2, schema: schema4, it } = cxt;
-        if (!Array.isArray(schema4))
+        const { gen: gen2, schema: schema5, it } = cxt;
+        if (!Array.isArray(schema5))
           throw new Error("ajv implementation error");
         const valid = gen2.name("valid");
-        schema4.forEach((sch, i2) => {
+        schema5.forEach((sch, i2) => {
           if ((0, util_1.alwaysValidSchema)(it, sch))
             return;
           const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i2 }, valid);
@@ -6041,8 +6041,8 @@ var require_if = __commonJS({
       }
     };
     function hasSchema(it, keyword) {
-      const schema4 = it.schema[keyword];
-      return schema4 !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema4);
+      const schema5 = it.schema[keyword];
+      return schema5 !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema5);
     }
     exports.default = def;
   }
@@ -6131,7 +6131,7 @@ var require_format = __commonJS({
       $data: true,
       error: error51,
       code(cxt, ruleType) {
-        const { gen: gen2, data, $data, schema: schema4, schemaCode, it } = cxt;
+        const { gen: gen2, data, $data, schema: schema5, schemaCode, it } = cxt;
         const { opts, errSchemaPath, schemaEnv, self } = it;
         if (!opts.validateFormats)
           return;
@@ -6161,7 +6161,7 @@ var require_format = __commonJS({
           }
         }
         function validateFormat() {
-          const formatDef = self.formats[schema4];
+          const formatDef = self.formats[schema5];
           if (!formatDef) {
             unknownFormat();
             return;
@@ -6178,12 +6178,12 @@ var require_format = __commonJS({
             }
             throw new Error(unknownMsg());
             function unknownMsg() {
-              return `unknown format "${schema4}" ignored in schema at path "${errSchemaPath}"`;
+              return `unknown format "${schema5}" ignored in schema at path "${errSchemaPath}"`;
             }
           }
           function getFormat(fmtDef) {
-            const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema4)}` : void 0;
-            const fmt = gen2.scopeValue("formats", { key: schema4, ref: fmtDef, code });
+            const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema5)}` : void 0;
+            const fmt = gen2.scopeValue("formats", { key: schema5, ref: fmtDef, code });
             if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
               return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
             }
@@ -6294,15 +6294,15 @@ var require_discriminator = __commonJS({
       schemaType: "object",
       error: error51,
       code(cxt) {
-        const { gen: gen2, data, schema: schema4, parentSchema, it } = cxt;
+        const { gen: gen2, data, schema: schema5, parentSchema, it } = cxt;
         const { oneOf } = parentSchema;
         if (!it.opts.discriminator) {
           throw new Error("discriminator: requires discriminator option");
         }
-        const tagName = schema4.propertyName;
+        const tagName = schema5.propertyName;
         if (typeof tagName != "string")
           throw new Error("discriminator: requires propertyName");
-        if (schema4.mapping)
+        if (schema5.mapping)
           throw new Error("discriminator: mapping is not supported");
         if (!oneOf)
           throw new Error("discriminator: requires oneOf keyword");
@@ -6712,11 +6712,15 @@ async function harden(path2, directory) {
     await chmod(path2, directory ? 448 : 384);
   }
 }
-async function writeExclusiveProtectedFile(path2, value) {
+async function writeExclusiveProtectedFile(path2, value, diagnostic) {
   const target = resolve(path2);
   const parent = dirname(target);
+  const refuse = (code, cause) => new CliStateError(code, {
+    ...cause === void 0 ? {} : { cause },
+    ...diagnostic === void 0 ? {} : { diagnostic }
+  });
   if (!isAbsolute(path2) || parse(target).root === target) {
-    throw new CliStateError("CLI_STATE_PERMISSIONS_INVALID");
+    throw refuse("CLI_STATE_PERMISSIONS_INVALID");
   }
   let handle;
   let created = false;
@@ -6728,14 +6732,14 @@ async function writeExclusiveProtectedFile(path2, value) {
     const opened = await handle.stat();
     const pathAfterOpen = await lstat(target);
     if (!opened.isFile() || opened.nlink !== 1 || !sameIdentity(opened, pathAfterOpen)) {
-      throw new CliStateError("CLI_STATE_PERMISSIONS_INVALID");
+      throw refuse("CLI_STATE_PERMISSIONS_INVALID");
     }
     await defaultPermissionPolicy.hardenNew(target, false);
     await defaultPermissionPolicy.verify(target, false);
     const openedAfterAcl = await handle.stat();
     const pathAfterAcl = await lstat(target);
     if (!sameIdentity(opened, openedAfterAcl) || !sameIdentity(opened, pathAfterAcl) || openedAfterAcl.nlink !== 1) {
-      throw new CliStateError("CLI_STATE_PERMISSIONS_INVALID");
+      throw refuse("CLI_STATE_PERMISSIONS_INVALID");
     }
     await handle.writeFile(value);
     await handle.sync();
@@ -6745,13 +6749,13 @@ async function writeExclusiveProtectedFile(path2, value) {
   } catch (cause) {
     await handle?.close().catch(() => void 0);
     if (cause.code === "EEXIST") {
-      throw new CliStateError("CLI_STATE_CONFLICT", { cause });
+      throw refuse("CLI_STATE_CONFLICT", cause);
     }
     if (created) {
       await rm(target, { force: true }).catch(() => void 0);
       await defaultSyncDirectory(parent).catch(() => void 0);
     }
-    throw permissionFailure(cause);
+    throw permissionFailure(cause, diagnostic);
   }
 }
 async function assertSafeNode(path2, directory) {
@@ -6799,8 +6803,14 @@ async function assertSafePathComponents(path2) {
     }
   }
 }
-function permissionFailure(cause) {
-  return cause instanceof CliStateError ? cause : new CliStateError("CLI_STATE_PERMISSIONS_INVALID", { cause });
+function permissionFailure(cause, diagnostic) {
+  if (cause instanceof CliStateError) {
+    return diagnostic === void 0 || cause.diagnostic !== null ? cause : new CliStateError(cause.code, { cause, diagnostic });
+  }
+  return new CliStateError("CLI_STATE_PERMISSIONS_INVALID", {
+    cause,
+    ...diagnostic === void 0 ? {} : { diagnostic }
+  });
 }
 function sameIdentity(left, right) {
   return left.dev === right.dev && left.ino === right.ino;
@@ -7038,6 +7048,9 @@ $rules = @($acl.Access | ForEach-Object {
 // src/cli-error.ts
 function localFailureMessage(error51) {
   if (error51 instanceof CliStateError) {
+    if (error51.diagnostic === "output_destination") {
+      return error51.code === "CLI_STATE_CONFLICT" ? "The requested output file already exists. Choose a path that does not exist yet; Finch never overwrites one." : "The requested output path is not usable. Pass an absolute file path inside a directory you own with mode 0700 and no symbolic links, for example mkdir -m 700 ~/finch-out. Wallet and login state are not involved in this failure.";
+    }
     if (error51.code === "CLI_STATE_PERMISSIONS_INVALID") {
       return process.platform === "win32" ? "Protected local state has unsafe ownership or ACLs. Restrict it to the current Windows user and retry." : "Protected local state has unsafe permissions. Directories must be mode 0700 and files mode 0600.";
     }
@@ -7073,7 +7086,7 @@ function localFailureMessage(error51) {
   }
   return "Command input does not match the expected schema. Check finch help for this command.";
 }
-var CliAuthorityError, CliProductionUnavailableError, BrowserOpenError, PUBLIC_RECOVERY_COMMAND, CliRecoveryBlockedError, CliSkillSourceError, CliSkillPublicationError;
+var CliAuthorityError, CliProductionUnavailableError, BrowserOpenError, PUBLIC_RECOVERY_COMMAND, CliRecoveryBlockedError, CliSkillSourceError, CliSkillPresentationStaleError, CliSkillRecoveryUncertainError, CliSkillPublicationError;
 var init_cli_error = __esm({
   "src/cli-error.ts"() {
     "use strict";
@@ -7122,6 +7135,26 @@ var init_cli_error = __esm({
       diagnosticCode;
       details;
     };
+    CliSkillPresentationStaleError = class extends Error {
+      constructor(reason, planVersion, liveVersion) {
+        super(`Skill presentation plan for version ${planVersion} no longer matches the Skill on chain.`);
+        this.reason = reason;
+        this.planVersion = planVersion;
+        this.liveVersion = liveVersion;
+        this.name = "CliSkillPresentationStaleError";
+      }
+      reason;
+      planVersion;
+      liveVersion;
+    };
+    CliSkillRecoveryUncertainError = class extends Error {
+      constructor(detail) {
+        super(`Skill recovery stage ${detail.stage} has no receipt and a ${detail.marker} pre-send marker in a version ${detail.journalVersion} journal.`);
+        this.detail = detail;
+        this.name = "CliSkillRecoveryUncertainError";
+      }
+      detail;
+    };
     CliSkillPublicationError = class extends Error {
       constructor(diagnostic, cause) {
         super(cause instanceof Error ? cause.message : "Skill publication failed.", { cause });
@@ -10859,6 +10892,15 @@ var init_esm = __esm({
   }
 });
 
+// ../../packages/skill-content/src/limits.ts
+var MAX_SKILL_PACKAGE_BYTES;
+var init_limits = __esm({
+  "../../packages/skill-content/src/limits.ts"() {
+    "use strict";
+    MAX_SKILL_PACKAGE_BYTES = 30 * 1024 * 1024;
+  }
+});
+
 // ../../packages/skill-content/src/zip.ts
 function crc32(bytes) {
   let crc = 4294967295;
@@ -10992,7 +11034,7 @@ function importZip(bytes, maxEntries = MAX_SKILL_IMPORT_FILES) {
 }
 function readZip(bytes, maxEntries) {
   if (bytes.length > MAX_SKILL_IMPORT_BYTES) throw new SkillZipInvalidError(
-    "ZIP import size exceeds the 10 MiB limit.",
+    `ZIP import size exceeds the ${MAX_SKILL_IMPORT_BYTES} byte limit.`,
     "archive_too_large",
     { actualBytes: bytes.length, maxBytes: MAX_SKILL_IMPORT_BYTES, sizeBasis: "archive" }
   );
@@ -11053,7 +11095,7 @@ function readZip(bytes, maxEntries) {
     }
     total += expanded;
     if (total > MAX_SKILL_IMPORT_BYTES) throw new SkillZipInvalidError(
-      "ZIP expanded content exceeds the 10 MiB limit.",
+      `ZIP expanded content exceeds the ${MAX_SKILL_IMPORT_BYTES} byte limit.`,
       "expanded_content_too_large",
       { actualBytes: total, maxBytes: MAX_SKILL_IMPORT_BYTES, sizeBasis: "declared_expanded", path: path2 }
     );
@@ -11117,8 +11159,9 @@ var init_zip_import = __esm({
   "../../packages/skill-content/src/zip-import.ts"() {
     "use strict";
     init_esm();
+    init_limits();
     init_zip();
-    MAX_SKILL_IMPORT_BYTES = 10 * 1024 * 1024;
+    MAX_SKILL_IMPORT_BYTES = MAX_SKILL_PACKAGE_BYTES;
     MAX_SKILL_IMPORT_FILES = 1024;
     SkillZipSymlinkError = class extends RangeError {
       constructor(path2) {
@@ -11558,6 +11601,13 @@ function detailObject(input, name, expectedMediaType, kind) {
   }
   return { uri: value.uri, hash: value.hash, mediaType: value.mediaType, size: Number(value.size) };
 }
+function detailExternalMediaHosts(input, kind) {
+  if (input === void 0) return void 0;
+  if (!Array.isArray(input) || input.length === 0 || input.length > 20 || input.some((host) => typeof host !== "string" || host !== host.toLowerCase() || !DETAIL_MEDIA_HOST.test(host)) || new Set(input).size !== input.length) {
+    throw new RangeError(`Skill ${kind} external media hosts are invalid.`);
+  }
+  return [...input].sort();
+}
 function buildDetailDocuments(input) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
     throw new RangeError("Skill detail documents are invalid.");
@@ -11575,9 +11625,11 @@ function buildDetailDocuments(input) {
       throw new RangeError(`Skill ${kind} document is invalid.`);
     }
     const document2 = raw;
-    if (Object.keys(document2).sort().join(",") !== "assets,entry,mode" || document2.mode !== "html" || !Array.isArray(document2.assets) || document2.assets.length > 50) {
+    const shape = Object.keys(document2).sort().join(",");
+    if (shape !== "assets,entry,mode" && shape !== "assets,entry,externalMediaHosts,mode" || document2.mode !== "html" || !Array.isArray(document2.assets) || document2.assets.length > 50) {
       throw new RangeError(`Skill ${kind} document is invalid.`);
     }
+    const externalMediaHosts = detailExternalMediaHosts(document2.externalMediaHosts, kind);
     const entry2 = detailObject(document2.entry, `Skill ${kind} HTML`, "text/html", kind);
     const names = /* @__PURE__ */ new Set();
     const assets = document2.assets.map((rawAsset) => {
@@ -11607,7 +11659,7 @@ function buildDetailDocuments(input) {
     if (entry2.size + assets.reduce((sum, asset) => sum + asset.size, 0) > MAX_SKILL_DETAIL_DOCUMENT_BYTES) {
       throw new RangeError(`Skill ${kind} document exceeds 4 MB.`);
     }
-    documents[kind] = { mode: "html", entry: entry2, assets };
+    documents[kind] = externalMediaHosts === void 0 ? { mode: "html", entry: entry2, assets } : { mode: "html", entry: entry2, assets, externalMediaHosts };
   }
   return documents;
 }
@@ -11670,7 +11722,7 @@ function withVersion(manifest4, entry2) {
 function withPresentation(manifest4, presentation) {
   return buildManifest(manifest4.versions, presentation, manifest4.documents);
 }
-var MAX_SKILL_MANIFEST_BYTES, SKILL_MANIFEST_SCHEME, SKILL_DETAIL_KINDS, DETAIL_MEDIA_TYPES, DETAIL_HASH, DETAIL_ASSET_PATH, DETAIL_IPFS_URI, DETAIL_STORAGE_URI, DETAIL_BUCKET_BY_KIND;
+var MAX_SKILL_MANIFEST_BYTES, SKILL_MANIFEST_SCHEME, SKILL_DETAIL_KINDS, DETAIL_MEDIA_TYPES, DETAIL_HASH, DETAIL_ASSET_PATH, DETAIL_IPFS_URI, DETAIL_STORAGE_URI, DETAIL_BUCKET_BY_KIND, DETAIL_MEDIA_HOST;
 var init_manifest = __esm({
   "../../packages/skill-content/src/manifest.ts"() {
     "use strict";
@@ -11699,6 +11751,7 @@ var init_manifest = __esm({
       benchmark: "skill-benchmarks",
       showcase: "skill-showcases"
     });
+    DETAIL_MEDIA_HOST = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))+$/u;
   }
 });
 
@@ -11759,6 +11812,7 @@ var init_src2 = __esm({
     init_delivery_message();
     init_detail_documents();
     init_image_signature();
+    init_limits();
     init_manifest();
     init_packaging();
     init_static_detail();
@@ -11962,8 +12016,9 @@ var init_actions = __esm({
     });
     publishIntentRequestSchema = strictObjectSchema({
       expectedPublicationGeneration: nonNegativeGenerationSchema,
-      retiredOffers: exactOfferRevisionListSchema
-    });
+      retiredOffers: exactOfferRevisionListSchema,
+      reviewRequired: { type: "boolean" }
+    }, ["expectedPublicationGeneration", "retiredOffers"]);
     offerRetirementIntentRequestSchema = strictObjectSchema({
       expectedPublicationGeneration: nonNegativeGenerationSchema
     });
@@ -12345,12 +12400,19 @@ var init_validation_input = __esm({
 });
 
 // ../../packages/agent-market-contracts/src/v1/errors.ts
-var agentMarketErrorCodes, nextActionValues, AGENT_MARKET_ERROR_DEFINITIONS, nullableStringSchema, nullableUuidSchema, nullableRevisionSchema2, agentMarketErrorEnvelopeSchema;
+var creatorRequestReasonCodes, agentMarketErrorCodes, nextActionValues, AGENT_MARKET_ERROR_DEFINITIONS, nullableStringSchema, nullableUuidSchema, nullableRevisionSchema2, agentMarketErrorEnvelopeSchema;
 var init_errors = __esm({
   "../../packages/agent-market-contracts/src/v1/errors.ts"() {
     "use strict";
     init_common2();
     init_validation_input();
+    creatorRequestReasonCodes = [
+      "creator_request_invalid",
+      "creator_field_invalid",
+      "creator_text_too_long",
+      "creator_text_invalid_unicode",
+      "creator_database_constraint"
+    ];
     agentMarketErrorCodes = [
       "AGENT_MARKET_AUTH_REQUIRED",
       "AGENT_MARKET_SCOPE_DENIED",
@@ -12429,15 +12491,16 @@ var init_errors = __esm({
       error: strictObjectSchema({
         code: { type: "string", enum: agentMarketErrorCodes },
         message: { type: "string", minLength: 1, maxLength: 500 },
-        reasonCode: { anyOf: [{ type: "string", enum: validationInputReasonCodes }, { type: "null" }] },
+        reasonCode: { anyOf: [{ type: "string", enum: [...validationInputReasonCodes, ...creatorRequestReasonCodes] }, { type: "null" }] },
         retryable: { type: "boolean" },
         nextAction: { type: "string", enum: nextActionValues },
         state: nullableStringSchema,
         operationId: nullableUuidSchema,
         currentRevision: nullableRevisionSchema2,
         currentEtag: nullableStringSchema,
-        traceId: { type: "string", minLength: 1, maxLength: 128 }
-      })
+        traceId: { type: "string", minLength: 1, maxLength: 128 },
+        field: nullableStringSchema
+      }, ["code", "message", "reasonCode", "retryable", "nextAction", "state", "operationId", "currentRevision", "currentEtag", "traceId"])
     });
   }
 });
@@ -14643,60 +14706,31 @@ var init_direct_connection_test = __esm({
 });
 
 // ../../packages/agent-market-contracts/src/v1/display.ts
-var DISPLAY_TEXT_CODEC_CONTRACT, displayTextSchema, agentMarketDisplayNameSchema, agentMarketDescriptionSchema, agentMarketSupportContactSchema, agentMarketRevisionDisplaySchema;
+var DISPLAY_TEXT_VALID_UNICODE_PATTERN, DISPLAY_TEXT_CODEC_CONTRACT, agentMarketUnicodeTextSchema, agentMarketDisplayNameSchema, agentMarketDescriptionSchema, agentMarketSupportContactSchema, agentMarketRevisionDisplaySchema;
 var init_display = __esm({
   "../../packages/agent-market-contracts/src/v1/display.ts"() {
     "use strict";
     init_common2();
+    DISPLAY_TEXT_VALID_UNICODE_PATTERN = "^[^\\u0000\\ud800-\\udfff]*$";
     DISPLAY_TEXT_CODEC_CONTRACT = Object.freeze({
-      normalization: "NFC",
-      displayNameUtf8Bytes: Object.freeze({ min: 1, max: 120 }),
-      descriptionUtf8Bytes: Object.freeze({ min: 0, max: 2e3 }),
-      edgeAsciiSpaceAllowed: false,
-      internalAsciiSpaceAllowed: true,
-      forbiddenCodePoints: Object.freeze([
-        "U+0000..U+001F",
-        "U+007F..U+009F",
-        "U+00A0",
-        "U+1680",
-        "U+2000..U+200A",
-        "U+2028",
-        "U+2029",
-        "U+202F",
-        "U+205F",
-        "U+3000",
-        "U+FEFF",
-        "U+D800..U+DFFF"
-      ]),
-      descriptionForbiddenCodePoints: Object.freeze([
-        "U+0000..U+0009",
-        "U+000B..U+000C",
-        "U+000E..U+001F",
-        "U+007F..U+009F",
-        "U+00A0",
-        "U+1680",
-        "U+2000..U+200A",
-        "U+2028",
-        "U+2029",
-        "U+202F",
-        "U+205F",
-        "U+3000",
-        "U+FEFF",
-        "U+D800..U+DFFF"
-      ])
-    });
-    displayTextSchema = (minBytes, maxBytes, allowStandardLineBreaks = false) => Object.freeze({
+      normalization: "verbatim",
+      displayNameCharacters: Object.freeze({ min: 1, max: 120 }),
+      descriptionCharacters: Object.freeze({ min: 0, max: 2e3 }),
+      preservesWhitespace: true,
+      supportsEmoji: true,
+      unsupportedCodePoints: Object.freeze(["U+0000", "unpaired UTF-16 surrogate"])
+    });
+    agentMarketUnicodeTextSchema = (minCharacters, maxCharacters) => Object.freeze({
       type: "string",
-      description: `NFC display text containing ${minBytes}..${maxBytes} UTF-8 bytes and no forbidden code points.`,
-      "x-finch-nfc": true,
-      "x-finch-min-utf8-bytes": minBytes,
-      "x-finch-max-utf8-bytes": maxBytes,
-      "x-finch-no-edge-ascii-space": true,
-      "x-finch-forbidden-code-points": allowStandardLineBreaks ? DISPLAY_TEXT_CODEC_CONTRACT.descriptionForbiddenCodePoints : DISPLAY_TEXT_CODEC_CONTRACT.forbiddenCodePoints
-    });
-    agentMarketDisplayNameSchema = displayTextSchema(1, 120);
-    agentMarketDescriptionSchema = displayTextSchema(0, 2e3, true);
-    agentMarketSupportContactSchema = displayTextSchema(1, 500);
+      minLength: minCharacters,
+      maxLength: maxCharacters,
+      pattern: DISPLAY_TEXT_VALID_UNICODE_PATTERN,
+      description: `Verbatim Unicode text containing ${minCharacters}..${maxCharacters} characters. Emoji, whitespace and control characters are preserved; U+0000 and malformed UTF-16 are not storable.`,
+      "x-finch-preserve-verbatim": true
+    });
+    agentMarketDisplayNameSchema = agentMarketUnicodeTextSchema(1, 120);
+    agentMarketDescriptionSchema = agentMarketUnicodeTextSchema(0, 2e3);
+    agentMarketSupportContactSchema = agentMarketUnicodeTextSchema(1, 500);
     agentMarketRevisionDisplaySchema = strictObjectSchema({
       displayName: agentMarketDisplayNameSchema,
       description: agentMarketDescriptionSchema
@@ -15139,17 +15173,18 @@ var init_identity = __esm({
 });
 
 // ../../packages/agent-market-contracts/src/v1/localization.ts
-var text2, listingInputRequestSchema, saveListingRequestSchema, listingSaveResponseSchema;
+var agentMarketMultilineCopySchema, text2, listingInputRequestSchema, saveListingRequestSchema, listingSaveResponseSchema;
 var init_localization = __esm({
   "../../packages/agent-market-contracts/src/v1/localization.ts"() {
     "use strict";
     init_common2();
     init_display();
+    agentMarketMultilineCopySchema = (maxLength) => agentMarketUnicodeTextSchema(0, maxLength);
     text2 = strictObjectSchema({
-      name: { type: "string", minLength: 1, maxLength: 120 },
-      description: { type: "string", maxLength: 5e3 },
-      deliverable: { type: "string", maxLength: 2e3 },
-      serviceBoundary: { type: "string", maxLength: 2e3 }
+      name: agentMarketUnicodeTextSchema(1, 120),
+      description: agentMarketMultilineCopySchema(5e3),
+      deliverable: agentMarketMultilineCopySchema(2e3),
+      serviceBoundary: agentMarketMultilineCopySchema(2e3)
     }, ["name", "description"]);
     listingInputRequestSchema = strictObjectSchema({
       inputLocales: {
@@ -15167,13 +15202,13 @@ var init_localization = __esm({
       integrationFamily: { enum: ["agenton_v2", "direct_api_v1"] },
       displayName: agentMarketDisplayNameSchema,
       description: agentMarketDescriptionSchema,
-      supportContact: { type: "string", minLength: 3, maxLength: 320 },
+      supportContact: agentMarketUnicodeTextSchema(3, 320),
       avatarUri: { type: "string", maxLength: 2048 },
       avatarMediaType: { enum: [null, "image/jpeg", "image/png", "image/webp", "video/mp4", "video/webm"] },
       category: { type: "string", maxLength: 80 },
-      tags: { type: "array", maxItems: 16, items: { type: "string", minLength: 1, maxLength: 80 } },
-      deliverable: { type: "string", maxLength: 1e3 },
-      serviceBoundary: { type: "string", maxLength: 1e3 },
+      tags: { type: "array", maxItems: 16, items: agentMarketUnicodeTextSchema(1, 80) },
+      deliverable: agentMarketMultilineCopySchema(1e3),
+      serviceBoundary: agentMarketMultilineCopySchema(1e3),
       localization: listingInputRequestSchema
     }, ["versionRevision", "integrationFamily", "displayName", "description", "supportContact", "avatarUri", "avatarMediaType", "category", "tags", "deliverable", "serviceBoundary"]);
     listingSaveResponseSchema = strictObjectSchema({
@@ -15926,6 +15961,7 @@ var init_public_catalog = __esm({
     });
     publicAgentOnDetailSchema = strictObjectSchema({
       ...publicSummaryProperties,
+      supportContact: { anyOf: [agentMarketSupportContactSchema, { type: "null" }] },
       integrationFamily: { const: "agenton_v2" },
       runtimeRevision: positiveRevisionSchema,
       runtimeConfigHash: hex32Schema,
@@ -15937,6 +15973,7 @@ var init_public_catalog = __esm({
     });
     publicDirectDetailSchema = strictObjectSchema({
       ...publicSummaryProperties,
+      supportContact: { anyOf: [agentMarketSupportContactSchema, { type: "null" }] },
       integrationFamily: { const: "direct_api_v1" },
       runtimeRevision: positiveRevisionSchema,
       runtimeConfigHash: hex32Schema,
@@ -16919,9 +16956,9 @@ var init_operations = __esm({
         expectedSha256: "0x483944fda693c326c11d8caa70df5c52e9854eb2ec58e50d5f7483b323fdfe7b"
       }),
       publication: Object.freeze({
-        byteLength: 400,
-        preimage: '["finch.agent_market.online_request.v1","publish","22222222-2222-4222-8222-222222222222","production",["/api/v1/agent-market/merchant/versions/{versionId}/publish-intents",[["versionId","11111111-1111-4111-8111-111111111111"]]],{"expectedPublicationGeneration":"7","retiredOffers":[],"revisionPrecondition":{"resourceId":"11111111-1111-4111-8111-111111111111","resourceKind":"version","revision":3}}]',
-        expectedSha256: "0xf4fb64ba801652c19db8770d85a85f170d5883f6d0347a144d2688b7ab8052f1"
+        byteLength: 422,
+        preimage: '["finch.agent_market.online_request.v1","publish","22222222-2222-4222-8222-222222222222","production",["/api/v1/agent-market/merchant/versions/{versionId}/publish-intents",[["versionId","11111111-1111-4111-8111-111111111111"]]],{"expectedPublicationGeneration":"7","retiredOffers":[],"reviewRequired":true,"revisionPrecondition":{"resourceId":"11111111-1111-4111-8111-111111111111","resourceKind":"version","revision":3}}]',
+        expectedSha256: "0xb2bbcd0f6699a5b7c34f1f362eda7a980ba37fb0332786fcc33fcdf31d7e8921"
       }),
       tamperCases: Object.freeze(["operation_kind", "account", "environment", "route_template", "path_binding_name", "path_binding_value", "path_binding_order", "semantic_body", "revision_r1_r2", "publication_generation", "uuid_case"])
     });
@@ -16940,18 +16977,18 @@ var init_operations = __esm({
 });
 
 // ../../packages/agent-market-contracts/src/v1/mcp.ts
-function bodyVariants(schema4) {
-  if (schema4 === void 0) return [{}];
-  const candidate = schema4;
+function bodyVariants(schema5) {
+  if (schema5 === void 0) return [{}];
+  const candidate = schema5;
   if (candidate.oneOf !== void 0) return candidate.oneOf.flatMap((variant) => bodyVariants(variant));
   return [candidate];
 }
 function unionProperties(variants) {
   const candidates = /* @__PURE__ */ new Map();
   for (const { properties } of variants) {
-    for (const [field, schema4] of Object.entries(properties ?? {})) {
+    for (const [field, schema5] of Object.entries(properties ?? {})) {
       const alternatives = candidates.get(field) ?? /* @__PURE__ */ new Map();
-      alternatives.set(JSON.stringify(schema4), schema4);
+      alternatives.set(JSON.stringify(schema5), schema5);
       candidates.set(field, alternatives);
     }
   }
@@ -17057,12 +17094,12 @@ var init_mcp = __esm({
 });
 
 // ../../packages/agent-market-contracts/src/v1/openapi.ts
-function mediaTypeContent(contentType, schema4) {
-  return { content: { [contentType]: { schema: schema4 } } };
+function mediaTypeContent(contentType, schema5) {
+  return { content: { [contentType]: { schema: schema5 } } };
 }
 function responseHeaderObjects(schemas) {
   return Object.fromEntries(
-    Object.entries(schemas).map(([name, schema4]) => [name, { schema: schema4 }])
+    Object.entries(schemas).map(([name, schema5]) => [name, { schema: schema5 }])
   );
 }
 function operationParameters(http3) {
@@ -17072,16 +17109,16 @@ function operationParameters(http3) {
     required: true,
     schema: canonicalUuidSchema
   }));
-  for (const [name, schema4] of Object.entries(http3.querySchema?.properties ?? {})) {
+  for (const [name, schema5] of Object.entries(http3.querySchema?.properties ?? {})) {
     parameters.push({
       name,
       in: "query",
       required: http3.querySchema?.required?.includes(name) ?? false,
-      schema: schema4
+      schema: schema5
     });
   }
-  for (const [name, schema4] of Object.entries(http3.requestHeaders ?? {})) {
-    parameters.push({ name, in: "header", required: true, schema: schema4 });
+  for (const [name, schema5] of Object.entries(http3.requestHeaders ?? {})) {
+    parameters.push({ name, in: "header", required: true, schema: schema5 });
   }
   if (http3.idempotencyRequired) parameters.push({ $ref: "#/components/parameters/IdempotencyKey" });
   if (http3.ifMatchRequired) parameters.push({ $ref: "#/components/parameters/IfMatch" });
@@ -17520,7 +17557,7 @@ var init_schemas = __esm({
     }, ["content"]);
     taskReviewRequestSchema = strictObjectSchema2({
       submissionIds: { type: "array", minItems: 1, maxItems: 100, uniqueItems: true, items: canonicalUuidSchema2 },
-      action: { type: "string", enum: ["approve", "reject", "spam", "favorite", "unfavorite"] },
+      action: { type: "string", enum: ["approve", "cancel_award", "reject", "spam", "favorite", "unfavorite"] },
       spamReason: { type: "string", maxLength: 200 }
     }, ["submissionIds", "action"]);
     signedAwardSchema = strictObjectSchema2({
@@ -17617,24 +17654,24 @@ var init_schemas = __esm({
 function operation2(value) {
   return Object.freeze(value);
 }
-function schemaFields(schema4) {
-  if (schema4 === void 0) return {};
-  const shape = schema4;
+function schemaFields(schema5) {
+  if (schema5 === void 0) return {};
+  const shape = schema5;
   return Object.freeze(Object.assign(
     {},
     shape.properties ?? {},
     ...(shape.oneOf ?? []).map((variant) => schemaFields(variant))
   ));
 }
-function requiredFields(schema4) {
-  return schema4?.required ?? [];
+function requiredFields(schema5) {
+  return schema5?.required ?? [];
 }
 function inputSchema(fields, required4, body) {
-  const schema4 = strictObjectSchema2(fields, required4);
+  const schema5 = strictObjectSchema2(fields, required4);
   const variants = body?.oneOf ?? [];
-  if (variants.length === 0) return schema4;
+  if (variants.length === 0) return schema5;
   return Object.freeze({
-    ...schema4,
+    ...schema5,
     oneOf: variants.map((variant) => Object.freeze({ required: requiredFields(variant) }))
   });
 }
@@ -17937,8 +17974,8 @@ function mergeDefs(...defs) {
   }
   return Object.defineProperties({}, mergedDescriptors);
 }
-function cloneDef(schema4) {
-  return mergeDefs(schema4._zod.def);
+function cloneDef(schema5) {
+  return mergeDefs(schema5._zod.def);
 }
 function getElementAtPath(obj, path2) {
   if (!path2)
@@ -18079,14 +18116,14 @@ function optionalKeys(shape) {
     return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
   });
 }
-function pick(schema4, mask) {
-  const currDef = schema4._zod.def;
+function pick(schema5, mask) {
+  const currDef = schema5._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema4._zod.def, {
+  const def = mergeDefs(schema5._zod.def, {
     get shape() {
       const newShape = {};
       for (const key in mask) {
@@ -18102,18 +18139,18 @@ function pick(schema4, mask) {
     },
     checks: []
   });
-  return clone(schema4, def);
+  return clone(schema5, def);
 }
-function omit(schema4, mask) {
-  const currDef = schema4._zod.def;
+function omit(schema5, mask) {
+  const currDef = schema5._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema4._zod.def, {
+  const def = mergeDefs(schema5._zod.def, {
     get shape() {
-      const newShape = { ...schema4._zod.def.shape };
+      const newShape = { ...schema5._zod.def.shape };
       for (const key in mask) {
         if (!(key in currDef.shape)) {
           throw new Error(`Unrecognized key: "${key}"`);
@@ -18127,43 +18164,43 @@ function omit(schema4, mask) {
     },
     checks: []
   });
-  return clone(schema4, def);
+  return clone(schema5, def);
 }
-function extend(schema4, shape) {
+function extend(schema5, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema4._zod.def.checks;
+  const checks = schema5._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    const existingShape = schema4._zod.def.shape;
+    const existingShape = schema5._zod.def.shape;
     for (const key in shape) {
       if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
   }
-  const def = mergeDefs(schema4._zod.def, {
+  const def = mergeDefs(schema5._zod.def, {
     get shape() {
-      const _shape = { ...schema4._zod.def.shape, ...shape };
+      const _shape = { ...schema5._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema4, def);
+  return clone(schema5, def);
 }
-function safeExtend(schema4, shape) {
+function safeExtend(schema5, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = mergeDefs(schema4._zod.def, {
+  const def = mergeDefs(schema5._zod.def, {
     get shape() {
-      const _shape = { ...schema4._zod.def.shape, ...shape };
+      const _shape = { ...schema5._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema4, def);
+  return clone(schema5, def);
 }
 function merge(a, b) {
   if (a._zod.def.checks?.length) {
@@ -18182,16 +18219,16 @@ function merge(a, b) {
   });
   return clone(a, def);
 }
-function partial(Class2, schema4, mask) {
-  const currDef = schema4._zod.def;
+function partial(Class2, schema5, mask) {
+  const currDef = schema5._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".partial() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema4._zod.def, {
+  const def = mergeDefs(schema5._zod.def, {
     get shape() {
-      const oldShape = schema4._zod.def.shape;
+      const oldShape = schema5._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -18218,12 +18255,12 @@ function partial(Class2, schema4, mask) {
     },
     checks: []
   });
-  return clone(schema4, def);
+  return clone(schema5, def);
 }
-function required(Class2, schema4, mask) {
-  const def = mergeDefs(schema4._zod.def, {
+function required(Class2, schema5, mask) {
+  const def = mergeDefs(schema5._zod.def, {
     get shape() {
-      const oldShape = schema4._zod.def.shape;
+      const oldShape = schema5._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -18249,7 +18286,7 @@ function required(Class2, schema4, mask) {
       return shape;
     }
   });
-  return clone(schema4, def);
+  return clone(schema5, def);
 }
 function aborted(x2, startIndex = 0) {
   if (x2.aborted === true)
@@ -18629,9 +18666,9 @@ var init_parse = __esm({
     init_core();
     init_errors2();
     init_util();
-    _parse = (_Err) => (schema4, value, _ctx, _params) => {
+    _parse = (_Err) => (schema5, value, _ctx, _params) => {
       const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result2 = schema4._zod.run({ value, issues: [] }, ctx);
+      const result2 = schema5._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
@@ -18643,9 +18680,9 @@ var init_parse = __esm({
       return result2.value;
     };
     parse2 = /* @__PURE__ */ _parse($ZodRealError);
-    _parseAsync = (_Err) => async (schema4, value, _ctx, params) => {
+    _parseAsync = (_Err) => async (schema5, value, _ctx, params) => {
       const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-      let result2 = schema4._zod.run({ value, issues: [] }, ctx);
+      let result2 = schema5._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise)
         result2 = await result2;
       if (result2.issues.length) {
@@ -18656,9 +18693,9 @@ var init_parse = __esm({
       return result2.value;
     };
     parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
-    _safeParse = (_Err) => (schema4, value, _ctx) => {
+    _safeParse = (_Err) => (schema5, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result2 = schema4._zod.run({ value, issues: [] }, ctx);
+      const result2 = schema5._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
@@ -18668,9 +18705,9 @@ var init_parse = __esm({
       } : { success: true, data: result2.value };
     };
     safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-    _safeParseAsync = (_Err) => async (schema4, value, _ctx) => {
+    _safeParseAsync = (_Err) => async (schema5, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-      let result2 = schema4._zod.run({ value, issues: [] }, ctx);
+      let result2 = schema5._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise)
         result2 = await result2;
       return result2.issues.length ? {
@@ -18679,40 +18716,40 @@ var init_parse = __esm({
       } : { success: true, data: result2.value };
     };
     safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-    _encode = (_Err) => (schema4, value, _ctx) => {
+    _encode = (_Err) => (schema5, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _parse(_Err)(schema4, value, ctx);
+      return _parse(_Err)(schema5, value, ctx);
     };
     encode5 = /* @__PURE__ */ _encode($ZodRealError);
-    _decode = (_Err) => (schema4, value, _ctx) => {
-      return _parse(_Err)(schema4, value, _ctx);
+    _decode = (_Err) => (schema5, value, _ctx) => {
+      return _parse(_Err)(schema5, value, _ctx);
     };
     decode7 = /* @__PURE__ */ _decode($ZodRealError);
-    _encodeAsync = (_Err) => async (schema4, value, _ctx) => {
+    _encodeAsync = (_Err) => async (schema5, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _parseAsync(_Err)(schema4, value, ctx);
+      return _parseAsync(_Err)(schema5, value, ctx);
     };
     encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
-    _decodeAsync = (_Err) => async (schema4, value, _ctx) => {
-      return _parseAsync(_Err)(schema4, value, _ctx);
+    _decodeAsync = (_Err) => async (schema5, value, _ctx) => {
+      return _parseAsync(_Err)(schema5, value, _ctx);
     };
     decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
-    _safeEncode = (_Err) => (schema4, value, _ctx) => {
+    _safeEncode = (_Err) => (schema5, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _safeParse(_Err)(schema4, value, ctx);
+      return _safeParse(_Err)(schema5, value, ctx);
     };
     safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
-    _safeDecode = (_Err) => (schema4, value, _ctx) => {
-      return _safeParse(_Err)(schema4, value, _ctx);
+    _safeDecode = (_Err) => (schema5, value, _ctx) => {
+      return _safeParse(_Err)(schema5, value, _ctx);
     };
     safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
-    _safeEncodeAsync = (_Err) => async (schema4, value, _ctx) => {
+    _safeEncodeAsync = (_Err) => async (schema5, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _safeParseAsync(_Err)(schema4, value, ctx);
+      return _safeParseAsync(_Err)(schema5, value, ctx);
     };
     safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
-    _safeDecodeAsync = (_Err) => async (schema4, value, _ctx) => {
-      return _safeParseAsync(_Err)(schema4, value, _ctx);
+    _safeDecodeAsync = (_Err) => async (schema5, value, _ctx) => {
+      return _safeParseAsync(_Err)(schema5, value, _ctx);
     };
     safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
   }
@@ -20601,9 +20638,9 @@ var init_schemas2 = __esm({
         for (const key of normalized.keys) {
           const id = ids[key];
           const k = esc(key);
-          const schema4 = shape[key];
-          const isOptionalIn = schema4?._zod?.optin === "optional";
-          const isOptionalOut = schema4?._zod?.optout === "optional";
+          const schema5 = shape[key];
+          const isOptionalIn = schema5?._zod?.optin === "optional";
+          const isOptionalOut = schema5?._zod?.optout === "optional";
           doc.write(`const ${id} = ${parseStr(key)};`);
           if (isOptionalIn && isOptionalOut) {
             doc.write(`
@@ -27933,11 +27970,11 @@ var init_registries = __esm({
         this._map = /* @__PURE__ */ new WeakMap();
         this._idmap = /* @__PURE__ */ new Map();
       }
-      add(schema4, ..._meta) {
+      add(schema5, ..._meta) {
         const meta3 = _meta[0];
-        this._map.set(schema4, meta3);
+        this._map.set(schema5, meta3);
         if (meta3 && typeof meta3 === "object" && "id" in meta3) {
-          this._idmap.set(meta3.id, schema4);
+          this._idmap.set(meta3.id, schema5);
         }
         return this;
       }
@@ -27946,26 +27983,26 @@ var init_registries = __esm({
         this._idmap = /* @__PURE__ */ new Map();
         return this;
       }
-      remove(schema4) {
-        const meta3 = this._map.get(schema4);
+      remove(schema5) {
+        const meta3 = this._map.get(schema5);
         if (meta3 && typeof meta3 === "object" && "id" in meta3) {
           this._idmap.delete(meta3.id);
         }
-        this._map.delete(schema4);
+        this._map.delete(schema5);
         return this;
       }
-      get(schema4) {
-        const p = schema4._zod.parent;
+      get(schema5) {
+        const p = schema5._zod.parent;
         if (p) {
           const pm = { ...this.get(p) ?? {} };
           delete pm.id;
-          const f = { ...pm, ...this._map.get(schema4) };
+          const f = { ...pm, ...this._map.get(schema5) };
           return Object.keys(f).length ? f : void 0;
         }
-        return this._map.get(schema4);
+        return this._map.get(schema5);
       }
-      has(schema4) {
-        return this._map.has(schema4);
+      has(schema5) {
+        return this._map.has(schema5);
       }
     };
     (_a3 = globalThis).__zod_globalRegistry ?? (_a3.__zod_globalRegistry = registry());
@@ -28610,11 +28647,11 @@ function _endsWith(suffix, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _property(property, schema4, params) {
+function _property(property, schema5, params) {
   return new $ZodCheckProperty({
     check: "property",
     property,
-    schema: schema4,
+    schema: schema5,
     ...normalizeParams(params)
   });
 }
@@ -28862,23 +28899,23 @@ function _promise(Class2, innerType) {
 function _custom(Class2, fn, _params) {
   const norm = normalizeParams(_params);
   norm.abort ?? (norm.abort = true);
-  const schema4 = new Class2({
+  const schema5 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...norm
   });
-  return schema4;
+  return schema5;
 }
 // @__NO_SIDE_EFFECTS__
 function _refine(Class2, fn, _params) {
-  const schema4 = new Class2({
+  const schema5 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams(_params)
   });
-  return schema4;
+  return schema5;
 }
 // @__NO_SIDE_EFFECTS__
 function _superRefine(fn, params) {
@@ -29043,40 +29080,40 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process2(schema4, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema5, ctx, _params = { path: [], schemaPath: [] }) {
   var _a4;
-  const def = schema4._zod.def;
-  const seen = ctx.seen.get(schema4);
+  const def = schema5._zod.def;
+  const seen = ctx.seen.get(schema5);
   if (seen) {
     seen.count++;
-    const isCycle = _params.schemaPath.includes(schema4);
+    const isCycle = _params.schemaPath.includes(schema5);
     if (isCycle) {
       seen.cycle = _params.path;
     }
     return seen.schema;
   }
   const result2 = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema4, result2);
-  const overrideSchema = schema4._zod.toJSONSchema?.();
+  ctx.seen.set(schema5, result2);
+  const overrideSchema = schema5._zod.toJSONSchema?.();
   if (overrideSchema) {
     result2.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
-      schemaPath: [..._params.schemaPath, schema4],
+      schemaPath: [..._params.schemaPath, schema5],
       path: _params.path
     };
-    if (schema4._zod.processJSONSchema) {
-      schema4._zod.processJSONSchema(ctx, result2.schema, params);
+    if (schema5._zod.processJSONSchema) {
+      schema5._zod.processJSONSchema(ctx, result2.schema, params);
     } else {
       const _json = result2.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
       }
-      processor(schema4, ctx, _json, params);
+      processor(schema5, ctx, _json, params);
     }
-    const parent = schema4._zod.parent;
+    const parent = schema5._zod.parent;
     if (parent) {
       if (!result2.ref)
         result2.ref = parent;
@@ -29084,21 +29121,21 @@ function process2(schema4, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta3 = ctx.metadataRegistry.get(schema4);
+  const meta3 = ctx.metadataRegistry.get(schema5);
   if (meta3)
     Object.assign(result2.schema, meta3);
-  if (ctx.io === "input" && isTransforming(schema4)) {
+  if (ctx.io === "input" && isTransforming(schema5)) {
     delete result2.schema.examples;
     delete result2.schema.default;
   }
   if (ctx.io === "input" && "_prefault" in result2.schema)
     (_a4 = result2.schema).default ?? (_a4.default = result2.schema._prefault);
   delete result2.schema._prefault;
-  const _result = ctx.seen.get(schema4);
+  const _result = ctx.seen.get(schema5);
   return _result.schema;
 }
-function extractDefs(ctx, schema4) {
-  const root = ctx.seen.get(schema4);
+function extractDefs(ctx, schema5) {
+  const root = ctx.seen.get(schema5);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
@@ -29141,11 +29178,11 @@ function extractDefs(ctx, schema4) {
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
-    const schema5 = seen.schema;
-    for (const key in schema5) {
-      delete schema5[key];
+    const schema6 = seen.schema;
+    for (const key in schema6) {
+      delete schema6[key];
     }
-    schema5.$ref = ref;
+    schema6.$ref = ref;
   };
   if (ctx.cycles === "throw") {
     for (const entry2 of ctx.seen.entries()) {
@@ -29159,13 +29196,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   for (const entry2 of ctx.seen.entries()) {
     const seen = entry2[1];
-    if (schema4 === entry2[0]) {
+    if (schema5 === entry2[0]) {
       extractToDef(entry2);
       continue;
     }
     if (ctx.external) {
       const ext = ctx.external.registry.get(entry2[0])?.id;
-      if (schema4 !== entry2[0] && ext) {
+      if (schema5 !== entry2[0] && ext) {
         extractToDef(entry2);
         continue;
       }
@@ -29187,16 +29224,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
 }
-function finalize(ctx, schema4) {
-  const root = ctx.seen.get(schema4);
+function finalize(ctx, schema5) {
+  const root = ctx.seen.get(schema5);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
     if (seen.ref === null)
       return;
-    const schema5 = seen.def ?? seen.schema;
-    const _cached = { ...schema5 };
+    const schema6 = seen.def ?? seen.schema;
+    const _cached = { ...schema6 };
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
@@ -29204,28 +29241,28 @@ function finalize(ctx, schema4) {
       const refSeen = ctx.seen.get(ref);
       const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
-        schema5.allOf = schema5.allOf ?? [];
-        schema5.allOf.push(refSchema);
+        schema6.allOf = schema6.allOf ?? [];
+        schema6.allOf.push(refSchema);
       } else {
-        Object.assign(schema5, refSchema);
+        Object.assign(schema6, refSchema);
       }
-      Object.assign(schema5, _cached);
+      Object.assign(schema6, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema5) {
+        for (const key in schema6) {
           if (key === "$ref" || key === "allOf")
             continue;
           if (!(key in _cached)) {
-            delete schema5[key];
+            delete schema6[key];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema5) {
+        for (const key in schema6) {
           if (key === "$ref" || key === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema5[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema5[key];
+          if (key in refSeen.def && JSON.stringify(schema6[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema6[key];
           }
         }
       }
@@ -29235,13 +29272,13 @@ function finalize(ctx, schema4) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
-        schema5.$ref = parentSeen.schema.$ref;
+        schema6.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema5) {
+          for (const key in schema6) {
             if (key === "$ref" || key === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema5[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema5[key];
+            if (key in parentSeen.def && JSON.stringify(schema6[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema6[key];
             }
           }
         }
@@ -29249,7 +29286,7 @@ function finalize(ctx, schema4) {
     }
     ctx.override({
       zodSchema,
-      jsonSchema: schema5,
+      jsonSchema: schema6,
       path: seen.path ?? []
     });
   };
@@ -29267,13 +29304,13 @@ function finalize(ctx, schema4) {
   } else {
   }
   if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema4)?.id;
+    const id = ctx.external.registry.get(schema5)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
     result2.$id = ctx.external.uri(id);
   }
   Object.assign(result2, root.def ?? root.schema);
-  const rootMetaId = ctx.metadataRegistry.get(schema4)?.id;
+  const rootMetaId = ctx.metadataRegistry.get(schema5)?.id;
   if (rootMetaId !== void 0 && result2.id === rootMetaId)
     delete result2.id;
   const defs = ctx.external?.defs ?? {};
@@ -29299,10 +29336,10 @@ function finalize(ctx, schema4) {
     const finalized = JSON.parse(JSON.stringify(result2));
     Object.defineProperty(finalized, "~standard", {
       value: {
-        ...schema4["~standard"],
+        ...schema5["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema4, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod(schema4, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod(schema5, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema5, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -29370,18 +29407,18 @@ var createToJSONSchemaMethod, createStandardJSONSchemaMethod;
 var init_to_json_schema = __esm({
   "../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/to-json-schema.js"() {
     init_registries();
-    createToJSONSchemaMethod = (schema4, processors = {}) => (params) => {
+    createToJSONSchemaMethod = (schema5, processors = {}) => (params) => {
       const ctx = initializeContext({ ...params, processors });
-      process2(schema4, ctx);
-      extractDefs(ctx, schema4);
-      return finalize(ctx, schema4);
+      process2(schema5, ctx);
+      extractDefs(ctx, schema5);
+      return finalize(ctx, schema5);
     };
-    createStandardJSONSchemaMethod = (schema4, io, processors = {}) => (params) => {
+    createStandardJSONSchemaMethod = (schema5, io, processors = {}) => (params) => {
       const { libraryOptions, target } = params ?? {};
       const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-      process2(schema4, ctx);
-      extractDefs(ctx, schema4);
-      return finalize(ctx, schema4);
+      process2(schema5, ctx);
+      extractDefs(ctx, schema5);
+      return finalize(ctx, schema5);
     };
   }
 });
@@ -29393,8 +29430,8 @@ function toJSONSchema(input, params) {
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry2 of registry2._idmap.entries()) {
-      const [_, schema4] = entry2;
-      process2(schema4, ctx2);
+      const [_, schema5] = entry2;
+      process2(schema5, ctx2);
     }
     const schemas = {};
     const external = {
@@ -29404,9 +29441,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry2 of registry2._idmap.entries()) {
-      const [key, schema4] = entry2;
-      extractDefs(ctx2, schema4);
-      schemas[key] = finalize(ctx2, schema4);
+      const [key, schema5] = entry2;
+      extractDefs(ctx2, schema5);
+      schemas[key] = finalize(ctx2, schema5);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -29434,10 +29471,10 @@ var init_json_schema_processors = __esm({
       regex: ""
       // do not set
     };
-    stringProcessor = (schema4, ctx, _json, _params) => {
+    stringProcessor = (schema5, ctx, _json, _params) => {
       const json2 = _json;
       json2.type = "string";
-      const { minimum, maximum, format: format3, patterns, contentEncoding } = schema4._zod.bag;
+      const { minimum, maximum, format: format3, patterns, contentEncoding } = schema5._zod.bag;
       if (typeof minimum === "number")
         json2.minLength = minimum;
       if (typeof maximum === "number")
@@ -29466,9 +29503,9 @@ var init_json_schema_processors = __esm({
         }
       }
     };
-    numberProcessor = (schema4, ctx, _json, _params) => {
+    numberProcessor = (schema5, ctx, _json, _params) => {
       const json2 = _json;
-      const { minimum, maximum, format: format3, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema4._zod.bag;
+      const { minimum, maximum, format: format3, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema5._zod.bag;
       if (typeof format3 === "string" && format3.includes("int"))
         json2.type = "integer";
       else
@@ -29543,8 +29580,8 @@ var init_json_schema_processors = __esm({
         throw new Error("Date cannot be represented in JSON Schema");
       }
     };
-    enumProcessor = (schema4, _ctx, json2, _params) => {
-      const def = schema4._zod.def;
+    enumProcessor = (schema5, _ctx, json2, _params) => {
+      const def = schema5._zod.def;
       const values = getEnumValues(def.entries);
       if (values.every((v) => typeof v === "number"))
         json2.type = "number";
@@ -29552,8 +29589,8 @@ var init_json_schema_processors = __esm({
         json2.type = "string";
       json2.enum = values;
     };
-    literalProcessor = (schema4, ctx, json2, _params) => {
-      const def = schema4._zod.def;
+    literalProcessor = (schema5, ctx, json2, _params) => {
+      const def = schema5._zod.def;
       const vals = [];
       for (const val of def.values) {
         if (val === void 0) {
@@ -29597,22 +29634,22 @@ var init_json_schema_processors = __esm({
         throw new Error("NaN cannot be represented in JSON Schema");
       }
     };
-    templateLiteralProcessor = (schema4, _ctx, json2, _params) => {
+    templateLiteralProcessor = (schema5, _ctx, json2, _params) => {
       const _json = json2;
-      const pattern = schema4._zod.pattern;
+      const pattern = schema5._zod.pattern;
       if (!pattern)
         throw new Error("Pattern not found in template literal");
       _json.type = "string";
       _json.pattern = pattern.source;
     };
-    fileProcessor = (schema4, _ctx, json2, _params) => {
+    fileProcessor = (schema5, _ctx, json2, _params) => {
       const _json = json2;
       const file2 = {
         type: "string",
         format: "binary",
         contentEncoding: "binary"
       };
-      const { minimum, maximum, mime } = schema4._zod.bag;
+      const { minimum, maximum, mime } = schema5._zod.bag;
       if (minimum !== void 0)
         file2.minLength = minimum;
       if (maximum !== void 0)
@@ -29657,10 +29694,10 @@ var init_json_schema_processors = __esm({
         throw new Error("Set cannot be represented in JSON Schema");
       }
     };
-    arrayProcessor = (schema4, ctx, _json, params) => {
+    arrayProcessor = (schema5, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema4._zod.def;
-      const { minimum, maximum } = schema4._zod.bag;
+      const def = schema5._zod.def;
+      const { minimum, maximum } = schema5._zod.bag;
       if (typeof minimum === "number")
         json2.minItems = minimum;
       if (typeof maximum === "number")
@@ -29671,9 +29708,9 @@ var init_json_schema_processors = __esm({
         path: [...params.path, "items"]
       });
     };
-    objectProcessor = (schema4, ctx, _json, params) => {
+    objectProcessor = (schema5, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema4._zod.def;
+      const def = schema5._zod.def;
       json2.type = "object";
       json2.properties = {};
       const shape = def.shape;
@@ -29707,8 +29744,8 @@ var init_json_schema_processors = __esm({
         });
       }
     };
-    unionProcessor = (schema4, ctx, json2, params) => {
-      const def = schema4._zod.def;
+    unionProcessor = (schema5, ctx, json2, params) => {
+      const def = schema5._zod.def;
       const isExclusive = def.inclusive === false;
       const options = def.options.map((x2, i2) => process2(x2, ctx, {
         ...params,
@@ -29720,8 +29757,8 @@ var init_json_schema_processors = __esm({
         json2.anyOf = options;
       }
     };
-    intersectionProcessor = (schema4, ctx, json2, params) => {
-      const def = schema4._zod.def;
+    intersectionProcessor = (schema5, ctx, json2, params) => {
+      const def = schema5._zod.def;
       const a = process2(def.left, ctx, {
         ...params,
         path: [...params.path, "allOf", 0]
@@ -29737,9 +29774,9 @@ var init_json_schema_processors = __esm({
       ];
       json2.allOf = allOf;
     };
-    tupleProcessor = (schema4, ctx, _json, params) => {
+    tupleProcessor = (schema5, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema4._zod.def;
+      const def = schema5._zod.def;
       json2.type = "array";
       const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
       const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
@@ -29773,15 +29810,15 @@ var init_json_schema_processors = __esm({
           json2.additionalItems = rest;
         }
       }
-      const { minimum, maximum } = schema4._zod.bag;
+      const { minimum, maximum } = schema5._zod.bag;
       if (typeof minimum === "number")
         json2.minItems = minimum;
       if (typeof maximum === "number")
         json2.maxItems = maximum;
     };
-    recordProcessor = (schema4, ctx, _json, params) => {
+    recordProcessor = (schema5, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema4._zod.def;
+      const def = schema5._zod.def;
       json2.type = "object";
       const keyType = def.keyType;
       const keyBag = keyType._zod.bag;
@@ -29815,10 +29852,10 @@ var init_json_schema_processors = __esm({
         }
       }
     };
-    nullableProcessor = (schema4, ctx, json2, params) => {
-      const def = schema4._zod.def;
+    nullableProcessor = (schema5, ctx, json2, params) => {
+      const def = schema5._zod.def;
       const inner = process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       if (ctx.target === "openapi-3.0") {
         seen.ref = def.innerType;
         json2.nullable = true;
@@ -29826,31 +29863,31 @@ var init_json_schema_processors = __esm({
         json2.anyOf = [inner, { type: "null" }];
       }
     };
-    nonoptionalProcessor = (schema4, ctx, _json, params) => {
-      const def = schema4._zod.def;
+    nonoptionalProcessor = (schema5, ctx, _json, params) => {
+      const def = schema5._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = def.innerType;
     };
-    defaultProcessor = (schema4, ctx, json2, params) => {
-      const def = schema4._zod.def;
+    defaultProcessor = (schema5, ctx, json2, params) => {
+      const def = schema5._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = def.innerType;
       json2.default = JSON.parse(JSON.stringify(def.defaultValue));
     };
-    prefaultProcessor = (schema4, ctx, json2, params) => {
-      const def = schema4._zod.def;
+    prefaultProcessor = (schema5, ctx, json2, params) => {
+      const def = schema5._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = def.innerType;
       if (ctx.io === "input")
         json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
     };
-    catchProcessor = (schema4, ctx, json2, params) => {
-      const def = schema4._zod.def;
+    catchProcessor = (schema5, ctx, json2, params) => {
+      const def = schema5._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = def.innerType;
       let catchValue;
       try {
@@ -29860,37 +29897,37 @@ var init_json_schema_processors = __esm({
       }
       json2.default = catchValue;
     };
-    pipeProcessor = (schema4, ctx, _json, params) => {
-      const def = schema4._zod.def;
+    pipeProcessor = (schema5, ctx, _json, params) => {
+      const def = schema5._zod.def;
       const inIsTransform = def.in._zod.traits.has("$ZodTransform");
       const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
       process2(innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = innerType;
     };
-    readonlyProcessor = (schema4, ctx, json2, params) => {
-      const def = schema4._zod.def;
+    readonlyProcessor = (schema5, ctx, json2, params) => {
+      const def = schema5._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = def.innerType;
       json2.readOnly = true;
     };
-    promiseProcessor = (schema4, ctx, _json, params) => {
-      const def = schema4._zod.def;
+    promiseProcessor = (schema5, ctx, _json, params) => {
+      const def = schema5._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = def.innerType;
     };
-    optionalProcessor = (schema4, ctx, _json, params) => {
-      const def = schema4._zod.def;
+    optionalProcessor = (schema5, ctx, _json, params) => {
+      const def = schema5._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = def.innerType;
     };
-    lazyProcessor = (schema4, ctx, _json, params) => {
-      const innerType = schema4._zod.innerType;
+    lazyProcessor = (schema5, ctx, _json, params) => {
+      const innerType = schema5._zod.innerType;
       process2(innerType, ctx, params);
-      const seen = ctx.seen.get(schema4);
+      const seen = ctx.seen.get(schema5);
       seen.ref = innerType;
     };
     allProcessors = {
@@ -29994,14 +30031,14 @@ var init_json_schema_generator = __esm({
        * Process a schema to prepare it for JSON Schema generation.
        * This must be called before emit().
        */
-      process(schema4, _params = { path: [], schemaPath: [] }) {
-        return process2(schema4, this.ctx, _params);
+      process(schema5, _params = { path: [], schemaPath: [] }) {
+        return process2(schema5, this.ctx, _params);
       }
       /**
        * Emit the final JSON Schema after processing.
        * Must call process() first.
        */
-      emit(schema4, _params) {
+      emit(schema5, _params) {
         if (_params) {
           if (_params.cycles)
             this.ctx.cycles = _params.cycles;
@@ -30010,8 +30047,8 @@ var init_json_schema_generator = __esm({
           if (_params.external)
             this.ctx.external = _params.external;
         }
-        extractDefs(this.ctx, schema4);
-        const result2 = finalize(this.ctx, schema4);
+        extractDefs(this.ctx, schema5);
+        const result2 = finalize(this.ctx, schema5);
         const { "~standard": _, ...plainResult } = result2;
         return plainResult;
       }
@@ -30840,8 +30877,8 @@ function date3(params) {
 function array(element, params) {
   return _array(ZodArray, element, params);
 }
-function keyof(schema4) {
-  const shape = schema4._zod.def.shape;
+function keyof(schema5) {
+  const shape = schema5._zod.def.shape;
   return _enum2(Object.keys(shape));
 }
 function object(shape, params) {
@@ -31156,11 +31193,11 @@ function json(params) {
   });
   return jsonSchema;
 }
-function preprocess(fn, schema4) {
+function preprocess(fn, schema5) {
   return new ZodPreprocess({
     type: "pipe",
     in: transform(fn),
-    out: schema4
+    out: schema5
   });
 }
 var _installedGroups, ZodType, _ZodString, ZodString, ZodStringFormat, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodMAC, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodCustomStringFormat, ZodNumber, ZodNumberFormat, ZodBoolean, ZodBigInt, ZodBigIntFormat, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodDate, ZodArray, ZodObject, ZodUnion, ZodXor, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodEnum, ZodLiteral, ZodFile, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodSuccess, ZodCatch, ZodNaN, ZodPipe, ZodCodec, ZodPreprocess, ZodReadonly, ZodTemplateLiteral, ZodLazy, ZodPromise, ZodFunction, ZodCustom, describe2, meta2, stringbool;
@@ -31984,8 +32021,8 @@ var init_compat = __esm({
 });
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/from-json-schema.js
-function detectVersion(schema4, defaultTarget) {
-  const $schema = schema4.$schema;
+function detectVersion(schema5, defaultTarget) {
+  const $schema = schema5.$schema;
   if ($schema === "https://json-schema.org/draft/2020-12/schema") {
     return "draft-2020-12";
   }
@@ -32015,27 +32052,27 @@ function resolveRef(ref, ctx) {
   }
   throw new Error(`Reference not found: ${ref}`);
 }
-function convertBaseSchema(schema4, ctx) {
-  if (schema4.not !== void 0) {
-    if (typeof schema4.not === "object" && Object.keys(schema4.not).length === 0) {
+function convertBaseSchema(schema5, ctx) {
+  if (schema5.not !== void 0) {
+    if (typeof schema5.not === "object" && Object.keys(schema5.not).length === 0) {
       return z.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
-  if (schema4.unevaluatedItems !== void 0) {
+  if (schema5.unevaluatedItems !== void 0) {
     throw new Error("unevaluatedItems is not supported");
   }
-  if (schema4.unevaluatedProperties !== void 0) {
+  if (schema5.unevaluatedProperties !== void 0) {
     throw new Error("unevaluatedProperties is not supported");
   }
-  if (schema4.if !== void 0 || schema4.then !== void 0 || schema4.else !== void 0) {
+  if (schema5.if !== void 0 || schema5.then !== void 0 || schema5.else !== void 0) {
     throw new Error("Conditional schemas (if/then/else) are not supported");
   }
-  if (schema4.dependentSchemas !== void 0 || schema4.dependentRequired !== void 0) {
+  if (schema5.dependentSchemas !== void 0 || schema5.dependentRequired !== void 0) {
     throw new Error("dependentSchemas and dependentRequired are not supported");
   }
-  if (schema4.$ref) {
-    const refPath = schema4.$ref;
+  if (schema5.$ref) {
+    const refPath = schema5.$ref;
     if (ctx.refs.has(refPath)) {
       return ctx.refs.get(refPath);
     }
@@ -32054,9 +32091,9 @@ function convertBaseSchema(schema4, ctx) {
     ctx.processing.delete(refPath);
     return zodSchema2;
   }
-  if (schema4.enum !== void 0) {
-    const enumValues = schema4.enum;
-    if (ctx.version === "openapi-3.0" && schema4.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+  if (schema5.enum !== void 0) {
+    const enumValues = schema5.enum;
+    if (ctx.version === "openapi-3.0" && schema5.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
       return z.null();
     }
     if (enumValues.length === 0) {
@@ -32074,13 +32111,13 @@ function convertBaseSchema(schema4, ctx) {
     }
     return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (schema4.const !== void 0) {
-    return z.literal(schema4.const);
+  if (schema5.const !== void 0) {
+    return z.literal(schema5.const);
   }
-  const type = schema4.type;
+  const type = schema5.type;
   if (Array.isArray(type)) {
     const typeSchemas = type.map((t) => {
-      const typeSchema = { ...schema4, type: t };
+      const typeSchema = { ...schema5, type: t };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -32098,8 +32135,8 @@ function convertBaseSchema(schema4, ctx) {
   switch (type) {
     case "string": {
       let stringSchema = z.string();
-      if (schema4.format) {
-        const format3 = schema4.format;
+      if (schema5.format) {
+        const format3 = schema5.format;
         if (format3 === "email") {
           stringSchema = stringSchema.check(z.email());
         } else if (format3 === "uri" || format3 === "uri-reference") {
@@ -32148,14 +32185,14 @@ function convertBaseSchema(schema4, ctx) {
           stringSchema = stringSchema.check(z.ksuid());
         }
       }
-      if (typeof schema4.minLength === "number") {
-        stringSchema = stringSchema.min(schema4.minLength);
+      if (typeof schema5.minLength === "number") {
+        stringSchema = stringSchema.min(schema5.minLength);
       }
-      if (typeof schema4.maxLength === "number") {
-        stringSchema = stringSchema.max(schema4.maxLength);
+      if (typeof schema5.maxLength === "number") {
+        stringSchema = stringSchema.max(schema5.maxLength);
       }
-      if (schema4.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema4.pattern));
+      if (schema5.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema5.pattern));
       }
       zodSchema = stringSchema;
       break;
@@ -32163,24 +32200,24 @@ function convertBaseSchema(schema4, ctx) {
     case "number":
     case "integer": {
       let numberSchema = type === "integer" ? z.number().int() : z.number();
-      if (typeof schema4.minimum === "number") {
-        numberSchema = numberSchema.min(schema4.minimum);
+      if (typeof schema5.minimum === "number") {
+        numberSchema = numberSchema.min(schema5.minimum);
       }
-      if (typeof schema4.maximum === "number") {
-        numberSchema = numberSchema.max(schema4.maximum);
+      if (typeof schema5.maximum === "number") {
+        numberSchema = numberSchema.max(schema5.maximum);
       }
-      if (typeof schema4.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema4.exclusiveMinimum);
-      } else if (schema4.exclusiveMinimum === true && typeof schema4.minimum === "number") {
-        numberSchema = numberSchema.gt(schema4.minimum);
+      if (typeof schema5.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema5.exclusiveMinimum);
+      } else if (schema5.exclusiveMinimum === true && typeof schema5.minimum === "number") {
+        numberSchema = numberSchema.gt(schema5.minimum);
       }
-      if (typeof schema4.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema4.exclusiveMaximum);
-      } else if (schema4.exclusiveMaximum === true && typeof schema4.maximum === "number") {
-        numberSchema = numberSchema.lt(schema4.maximum);
+      if (typeof schema5.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema5.exclusiveMaximum);
+      } else if (schema5.exclusiveMaximum === true && typeof schema5.maximum === "number") {
+        numberSchema = numberSchema.lt(schema5.maximum);
       }
-      if (typeof schema4.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema4.multipleOf);
+      if (typeof schema5.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema5.multipleOf);
       }
       zodSchema = numberSchema;
       break;
@@ -32195,15 +32232,15 @@ function convertBaseSchema(schema4, ctx) {
     }
     case "object": {
       const shape = {};
-      const properties = schema4.properties || {};
-      const requiredSet = new Set(schema4.required || []);
+      const properties = schema5.properties || {};
+      const requiredSet = new Set(schema5.required || []);
       for (const [key, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
         shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
       }
-      if (schema4.propertyNames) {
-        const keySchema = convertSchema(schema4.propertyNames, ctx);
-        const valueSchema = schema4.additionalProperties && typeof schema4.additionalProperties === "object" ? convertSchema(schema4.additionalProperties, ctx) : z.any();
+      if (schema5.propertyNames) {
+        const keySchema = convertSchema(schema5.propertyNames, ctx);
+        const valueSchema = schema5.additionalProperties && typeof schema5.additionalProperties === "object" ? convertSchema(schema5.additionalProperties, ctx) : z.any();
         if (Object.keys(shape).length === 0) {
           zodSchema = z.record(keySchema, valueSchema);
           break;
@@ -32213,8 +32250,8 @@ function convertBaseSchema(schema4, ctx) {
         zodSchema = z.intersection(objectSchema2, recordSchema);
         break;
       }
-      if (schema4.patternProperties) {
-        const patternProps = schema4.patternProperties;
+      if (schema5.patternProperties) {
+        const patternProps = schema5.patternProperties;
         const patternKeys = Object.keys(patternProps);
         const looseRecords = [];
         for (const pattern of patternKeys) {
@@ -32241,18 +32278,18 @@ function convertBaseSchema(schema4, ctx) {
         break;
       }
       const objectSchema = z.object(shape);
-      if (schema4.additionalProperties === false) {
+      if (schema5.additionalProperties === false) {
         zodSchema = objectSchema.strict();
-      } else if (typeof schema4.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema(schema4.additionalProperties, ctx));
+      } else if (typeof schema5.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema(schema5.additionalProperties, ctx));
       } else {
         zodSchema = objectSchema.passthrough();
       }
       break;
     }
     case "array": {
-      const prefixItems = schema4.prefixItems;
-      const items = schema4.items;
+      const prefixItems = schema5.prefixItems;
+      const items = schema5.items;
       if (prefixItems && Array.isArray(prefixItems)) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
@@ -32261,34 +32298,34 @@ function convertBaseSchema(schema4, ctx) {
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema4.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema4.minItems));
+        if (typeof schema5.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema5.minItems));
         }
-        if (typeof schema4.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema4.maxItems));
+        if (typeof schema5.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema5.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
-        const rest = schema4.additionalItems && typeof schema4.additionalItems === "object" ? convertSchema(schema4.additionalItems, ctx) : void 0;
+        const rest = schema5.additionalItems && typeof schema5.additionalItems === "object" ? convertSchema(schema5.additionalItems, ctx) : void 0;
         if (rest) {
           zodSchema = z.tuple(tupleItems).rest(rest);
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema4.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema4.minItems));
+        if (typeof schema5.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema5.minItems));
         }
-        if (typeof schema4.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema4.maxItems));
+        if (typeof schema5.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema5.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
         let arraySchema = z.array(element);
-        if (typeof schema4.minItems === "number") {
-          arraySchema = arraySchema.min(schema4.minItems);
+        if (typeof schema5.minItems === "number") {
+          arraySchema = arraySchema.min(schema5.minItems);
         }
-        if (typeof schema4.maxItems === "number") {
-          arraySchema = arraySchema.max(schema4.maxItems);
+        if (typeof schema5.maxItems === "number") {
+          arraySchema = arraySchema.max(schema5.maxItems);
         }
         zodSchema = arraySchema;
       } else {
@@ -32301,76 +32338,76 @@ function convertBaseSchema(schema4, ctx) {
   }
   return zodSchema;
 }
-function convertSchema(schema4, ctx) {
-  if (typeof schema4 === "boolean") {
-    return schema4 ? z.any() : z.never();
+function convertSchema(schema5, ctx) {
+  if (typeof schema5 === "boolean") {
+    return schema5 ? z.any() : z.never();
   }
-  let baseSchema = convertBaseSchema(schema4, ctx);
-  const hasExplicitType = schema4.type || schema4.enum !== void 0 || schema4.const !== void 0;
-  if (schema4.anyOf && Array.isArray(schema4.anyOf)) {
-    const options = schema4.anyOf.map((s) => convertSchema(s, ctx));
+  let baseSchema = convertBaseSchema(schema5, ctx);
+  const hasExplicitType = schema5.type || schema5.enum !== void 0 || schema5.const !== void 0;
+  if (schema5.anyOf && Array.isArray(schema5.anyOf)) {
+    const options = schema5.anyOf.map((s) => convertSchema(s, ctx));
     const anyOfUnion = z.union(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
-  if (schema4.oneOf && Array.isArray(schema4.oneOf)) {
-    const options = schema4.oneOf.map((s) => convertSchema(s, ctx));
+  if (schema5.oneOf && Array.isArray(schema5.oneOf)) {
+    const options = schema5.oneOf.map((s) => convertSchema(s, ctx));
     const oneOfUnion = z.xor(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
-  if (schema4.allOf && Array.isArray(schema4.allOf)) {
-    if (schema4.allOf.length === 0) {
+  if (schema5.allOf && Array.isArray(schema5.allOf)) {
+    if (schema5.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result2 = hasExplicitType ? baseSchema : convertSchema(schema4.allOf[0], ctx);
+      let result2 = hasExplicitType ? baseSchema : convertSchema(schema5.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
-      for (let i2 = startIdx; i2 < schema4.allOf.length; i2++) {
-        result2 = z.intersection(result2, convertSchema(schema4.allOf[i2], ctx));
+      for (let i2 = startIdx; i2 < schema5.allOf.length; i2++) {
+        result2 = z.intersection(result2, convertSchema(schema5.allOf[i2], ctx));
       }
       baseSchema = result2;
     }
   }
-  if (schema4.nullable === true && ctx.version === "openapi-3.0") {
+  if (schema5.nullable === true && ctx.version === "openapi-3.0") {
     baseSchema = z.nullable(baseSchema);
   }
-  if (schema4.readOnly === true) {
+  if (schema5.readOnly === true) {
     baseSchema = z.readonly(baseSchema);
   }
-  if (schema4.default !== void 0) {
-    baseSchema = baseSchema.default(schema4.default);
+  if (schema5.default !== void 0) {
+    baseSchema = baseSchema.default(schema5.default);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
   for (const key of coreMetadataKeys) {
-    if (key in schema4) {
-      extraMeta[key] = schema4[key];
+    if (key in schema5) {
+      extraMeta[key] = schema5[key];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
-    if (key in schema4) {
-      extraMeta[key] = schema4[key];
+    if (key in schema5) {
+      extraMeta[key] = schema5[key];
     }
   }
-  for (const key of Object.keys(schema4)) {
+  for (const key of Object.keys(schema5)) {
     if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema4[key];
+      extraMeta[key] = schema5[key];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
     ctx.registry.add(baseSchema, extraMeta);
   }
-  if (schema4.description) {
-    baseSchema = baseSchema.describe(schema4.description);
+  if (schema5.description) {
+    baseSchema = baseSchema.describe(schema5.description);
   }
   return baseSchema;
 }
-function fromJSONSchema(schema4, params) {
-  if (typeof schema4 === "boolean") {
-    return schema4 ? z.any() : z.never();
+function fromJSONSchema(schema5, params) {
+  if (typeof schema5 === "boolean") {
+    return schema5 ? z.any() : z.never();
   }
   let normalized;
   try {
-    normalized = JSON.parse(JSON.stringify(schema4));
+    normalized = JSON.parse(JSON.stringify(schema5));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
@@ -33073,9 +33110,11 @@ var init_skill_protocol = __esm({
                 name: "Base",
                 explorerUrl: "https://basescan.org",
                 defaultRpcUrls: [
+                  "https://base.gateway.tenderly.co",
+                  "https://base-rpc.publicnode.com",
                   "https://mainnet.base.org"
                 ],
-                maxLogBlockRange: 2e3,
+                maxLogBlockRange: 1e3,
                 maxConcurrentRequests: 3
               },
               sourceRepository: "FinchipAI/finchip-protocol",
@@ -33232,12 +33271,12 @@ function resolveSkillProtocolEnvironment(raw) {
     `FINCH_ENVIRONMENT must explicitly be local, test, or production; received ${received}.`
   );
 }
-function parseTypedRegistry(schema4, value) {
-  const parsed = schema4.safeParse(value);
-  if (!parsed.success) {
-    throw new DeploymentManifestError(`Invalid chain deployment manifest: ${external_exports.prettifyError(parsed.error)}`);
+function parseTypedRegistry(schema5, value) {
+  const parsed2 = schema5.safeParse(value);
+  if (!parsed2.success) {
+    throw new DeploymentManifestError(`Invalid chain deployment manifest: ${external_exports.prettifyError(parsed2.error)}`);
   }
-  return parsed.data;
+  return parsed2.data;
 }
 function activeDeployment(protocol, deployments, environment3) {
   if (environment3 === "local") {
@@ -33654,6 +33693,45 @@ var init_chains = __esm({
   }
 });
 
+// ../../packages/deployment-manifest/src/platform/get-help.json
+var get_help_default;
+var init_get_help = __esm({
+  "../../packages/deployment-manifest/src/platform/get-help.json"() {
+    get_help_default = {
+      schemaVersion: 1,
+      kind: "get_help",
+      environments: {
+        local: { enabled: true, ipHourlyLimit: 5, emailDailyLimit: 10, dailyUploadBytes: 104857600 },
+        test: { enabled: true, ipHourlyLimit: 5, emailDailyLimit: 10, dailyUploadBytes: 104857600 },
+        production: { enabled: false, ipHourlyLimit: 5, emailDailyLimit: 10, dailyUploadBytes: 104857600 }
+      }
+    };
+  }
+});
+
+// ../../packages/deployment-manifest/src/platform/get-help.ts
+var policy, schema, parseGetHelpManifest, parsed;
+var init_get_help2 = __esm({
+  "../../packages/deployment-manifest/src/platform/get-help.ts"() {
+    "use strict";
+    init_zod();
+    init_get_help();
+    policy = external_exports.strictObject({
+      enabled: external_exports.boolean(),
+      ipHourlyLimit: external_exports.number().int().min(1).max(100),
+      emailDailyLimit: external_exports.number().int().min(1).max(100),
+      dailyUploadBytes: external_exports.number().int().min(2097152).max(1073741824)
+    });
+    schema = external_exports.strictObject({
+      schemaVersion: external_exports.literal(1),
+      kind: external_exports.literal("get_help"),
+      environments: external_exports.strictObject({ local: policy, test: policy, production: policy })
+    });
+    parseGetHelpManifest = (value) => schema.parse(value);
+    parsed = parseGetHelpManifest(get_help_default);
+  }
+});
+
 // ../../packages/deployment-manifest/src/platform/passkey-safe.json
 var passkey_safe_default;
 var init_passkey_safe = __esm({
@@ -33681,9 +33759,9 @@ var init_passkey_safe = __esm({
 
 // ../../packages/deployment-manifest/src/platform/passkey-safe.ts
 function parsePasskeySafeManifest(input) {
-  return schema.parse(input);
+  return schema2.parse(input);
 }
-var disabled, enabled, schema, manifest;
+var disabled, enabled, schema2, manifest;
 var init_passkey_safe2 = __esm({
   "../../packages/deployment-manifest/src/platform/passkey-safe.ts"() {
     "use strict";
@@ -33700,7 +33778,7 @@ var init_passkey_safe2 = __esm({
       minimumGasWei: external_exports.string().regex(/^[1-9][0-9]*$/),
       maxGasPerTransaction: external_exports.string().regex(/^[1-9][0-9]*$/)
     });
-    schema = external_exports.strictObject({
+    schema2 = external_exports.strictObject({
       schemaVersion: external_exports.literal(1),
       kind: external_exports.literal("passkey_safe"),
       environments: external_exports.strictObject({
@@ -33934,9 +34012,9 @@ var init_agenton_payout = __esm({
 
 // ../../packages/deployment-manifest/src/platform/agenton-payout.ts
 function parseAgentonPayoutManifest(input) {
-  return schema2.parse(input);
+  return schema3.parse(input);
 }
-var origin, environment, schema2, manifest2;
+var origin, environment, schema3, manifest2;
 var init_agenton_payout2 = __esm({
   "../../packages/deployment-manifest/src/platform/agenton-payout.ts"() {
     "use strict";
@@ -33947,7 +34025,7 @@ var init_agenton_payout2 = __esm({
       return url2.protocol === "https:" && url2.origin === value && !url2.username && !url2.password;
     });
     environment = external_exports.strictObject({ enabled: external_exports.boolean(), mandateId: external_exports.string().min(1).nullable() });
-    schema2 = external_exports.strictObject({
+    schema3 = external_exports.strictObject({
       schemaVersion: external_exports.literal(1),
       kind: external_exports.literal("agenton_payout"),
       agentIdBaseUrl: origin,
@@ -33986,36 +34064,36 @@ var init_merchant_avatar_video = __esm({
 
 // ../../packages/deployment-manifest/src/platform/merchant-avatar-video.ts
 function parseMerchantAvatarVideoManifest(input) {
-  return schema3.parse(input);
+  return schema4.parse(input);
 }
-var policy, schema3, manifest3;
+var policy2, schema4, manifest3;
 var init_merchant_avatar_video2 = __esm({
   "../../packages/deployment-manifest/src/platform/merchant-avatar-video.ts"() {
     "use strict";
     init_zod();
     init_merchant_avatar_video();
-    policy = external_exports.discriminatedUnion("enabled", [
+    policy2 = external_exports.discriminatedUnion("enabled", [
       external_exports.strictObject({ enabled: external_exports.literal(false) }),
       external_exports.strictObject({ enabled: external_exports.literal(true), offerId: external_exports.uuid(), dailyLimit: external_exports.number().int().min(1).max(1e4) })
     ]);
-    schema3 = external_exports.strictObject({
+    schema4 = external_exports.strictObject({
       schemaVersion: external_exports.literal(1),
       kind: external_exports.literal("merchant_avatar_video"),
-      environments: external_exports.strictObject({ local: policy, test: policy, production: policy })
+      environments: external_exports.strictObject({ local: policy2, test: policy2, production: policy2 })
     });
     manifest3 = parseMerchantAvatarVideoManifest(merchant_avatar_video_default);
   }
 });
 
 // ../../packages/deployment-manifest/src/platform/index.ts
-function parseManifest2(label, schema4, value) {
-  const parsed = schema4.safeParse(value);
-  if (!parsed.success) {
+function parseManifest2(label, schema5, value) {
+  const parsed2 = schema5.safeParse(value);
+  if (!parsed2.success) {
     throw new DeploymentManifestError(
-      `Invalid ${label} deployment manifest: ${external_exports.prettifyError(parsed.error)}`
+      `Invalid ${label} deployment manifest: ${external_exports.prettifyError(parsed2.error)}`
     );
   }
-  return parsed.data;
+  return parsed2.data;
 }
 function parseInternalAppsManifest(value) {
   return parseManifest2("internal-apps", internalAppsManifestSchema, value);
@@ -34053,6 +34131,7 @@ var init_platform = __esm({
   "../../packages/deployment-manifest/src/platform/index.ts"() {
     "use strict";
     init_zod();
+    init_get_help2();
     init_passkey_safe2();
     init_web_analytics();
     init_web_localization();
@@ -38200,12 +38279,12 @@ var init_utils3 = __esm({
     getContractAddress = (address2) => address2;
     getUrl = (url2) => {
       try {
-        const parsed = new URL(url2);
-        if (!parsed.username && !parsed.password)
+        const parsed2 = new URL(url2);
+        if (!parsed2.username && !parsed2.password)
           return url2;
-        parsed.username = "";
-        parsed.password = "";
-        return parsed.toString();
+        parsed2.username = "";
+        parsed2.password = "";
+        return parsed2.toString();
       } catch {
         return url2;
       }
@@ -53407,13 +53486,13 @@ var init_validateSiweMessage = __esm({
 // ../../node_modules/.pnpm/viem@2.55.15_bufferutil@4.1_ce20031be19c56210207d462110a7a29/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
 async function verifySiweMessage(client, parameters) {
   const { address: address2, domain: domain2, message, nonce, scheme, signature, time: time3 = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
-  const parsed = parseSiweMessage(message);
-  if (!parsed.address)
+  const parsed2 = parseSiweMessage(message);
+  if (!parsed2.address)
     return false;
   const isValid = validateSiweMessage({
     address: address2,
     domain: domain2,
-    message: parsed,
+    message: parsed2,
     nonce,
     scheme,
     time: time3
@@ -53422,7 +53501,7 @@ async function verifySiweMessage(client, parameters) {
     return false;
   const hash5 = hashMessage(message);
   return verifyHash(client, {
-    address: parsed.address,
+    address: parsed2.address,
     hash: hash5,
     signature,
     ...callRequest
@@ -54905,27 +54984,27 @@ function normalizeCliEvmAddress(value, field = "EVM address") {
 function record3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function variantMatches(schema4, value) {
-  if (!record3(schema4.properties) || !record3(value)) return true;
-  return Object.entries(schema4.properties).every(([key, property]) => {
+function variantMatches(schema5, value) {
+  if (!record3(schema5.properties) || !record3(value)) return true;
+  return Object.entries(schema5.properties).every(([key, property]) => {
     if (!record3(property) || !Object.hasOwn(property, "const")) return true;
     return value[key] === property.const;
   });
 }
-function normalizeCliRequestAddresses(schema4, value) {
-  if ((schema4.pattern === CANONICAL_ADDRESS_PATTERN || schema4.pattern === INPUT_ADDRESS_PATTERN) && typeof value === "string") {
+function normalizeCliRequestAddresses(schema5, value) {
+  if ((schema5.pattern === CANONICAL_ADDRESS_PATTERN || schema5.pattern === INPUT_ADDRESS_PATTERN) && typeof value === "string") {
     return normalizeCliEvmAddress(value);
   }
-  const variants = Array.isArray(schema4.oneOf) ? schema4.oneOf : Array.isArray(schema4.anyOf) ? schema4.anyOf : null;
+  const variants = Array.isArray(schema5.oneOf) ? schema5.oneOf : Array.isArray(schema5.anyOf) ? schema5.anyOf : null;
   if (variants !== null) {
     const selected = variants.find((variant) => record3(variant) && variantMatches(variant, value));
     return selected === void 0 || !record3(selected) ? value : normalizeCliRequestAddresses(selected, value);
   }
-  if (Array.isArray(value) && record3(schema4.items)) {
-    return value.map((item) => normalizeCliRequestAddresses(schema4.items, item));
+  if (Array.isArray(value) && record3(schema5.items)) {
+    return value.map((item) => normalizeCliRequestAddresses(schema5.items, item));
   }
-  if (record3(value) && record3(schema4.properties)) {
-    const properties = schema4.properties;
+  if (record3(value) && record3(schema5.properties)) {
+    const properties = schema5.properties;
     return Object.fromEntries(Object.entries(value).map(([key, entry2]) => {
       const property = properties[key];
       return [key, record3(property) ? normalizeCliRequestAddresses(property, entry2) : entry2];
@@ -54950,18 +55029,19 @@ function skillHttpDiagnostic(response, value) {
   const code = value?.error?.code;
   const platformCode = response.headers.get("x-vercel-error");
   const requestId = response.headers.get("x-vercel-id");
-  const traceId = response.headers.get("x-finch-trace-id");
+  const bodyTraceId = value?.error?.traceId;
+  const traceId = response.headers.get("x-finch-trace-id") ?? (typeof bodyTraceId === "string" ? bodyTraceId : null);
   return {
     ...typeof code === "string" && PUBLIC_SKILL_HTTP_CODES.has(code) ? { remoteCode: code } : platformCode !== null && PUBLIC_SKILL_HTTP_CODES.has(platformCode) ? { remoteCode: platformCode } : {},
     ...requestId !== null && /^[a-z0-9]{3,8}(?:::[a-z0-9]{3,8})?::[a-z0-9]{5}-[0-9]{13}-[a-f0-9]{12}$/u.test(requestId) ? { remoteRequestId: requestId } : {},
-    ...traceId !== null && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/u.test(traceId) ? { remoteTraceId: traceId } : {}
+    ...traceId !== null && TRACE_ID_PATTERN.test(traceId) ? { remoteTraceId: traceId } : {}
   };
 }
-function assertSchema(schema4, value, diagnosticPaths) {
-  let validator = validatorCache.get(schema4);
+function assertSchema(schema5, value, diagnosticPaths) {
+  let validator = validatorCache.get(schema5);
   if (validator === void 0) {
-    const compiled = ajv.compile(schema4);
-    validatorCache.set(schema4, compiled);
+    const compiled = ajv.compile(schema5);
+    validatorCache.set(schema5, compiled);
     validator = compiled;
   }
   if (!validator(value)) {
@@ -54973,20 +55053,20 @@ function assertSchema(schema4, value, diagnosticPaths) {
   }
   return value;
 }
-function assertRequestSchema(schema4, value) {
-  let validator = validatorCache.get(schema4);
+function assertRequestSchema(schema5, value) {
+  let validator = validatorCache.get(schema5);
   if (validator === void 0) {
-    validator = ajv.compile(schema4);
-    validatorCache.set(schema4, validator);
+    validator = ajv.compile(schema5);
+    validatorCache.set(schema5, validator);
   }
   if (!validator(value)) throw new TypeError("Creator request does not match the shared operation schema.");
 }
 function canonicalOrigin2(input) {
-  const parsed = new URL(input);
-  if (parsed.origin !== input || parsed.username !== "" || parsed.password !== "" || parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "" || !["http:", "https:"].includes(parsed.protocol)) {
+  const parsed2 = new URL(input);
+  if (parsed2.origin !== input || parsed2.username !== "" || parsed2.password !== "" || parsed2.pathname !== "/" || parsed2.search !== "" || parsed2.hash !== "" || !["http:", "https:"].includes(parsed2.protocol)) {
     throw new TypeError("AgentCLI origin must be canonical.");
   }
-  return parsed.origin;
+  return parsed2.origin;
 }
 function jsonObject(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -55106,10 +55186,10 @@ async function readBoundedBytes(response, minimumBytes, maximumBytes) {
   }
 }
 function parseRemoteError(contract, response, value, diagnose = false) {
-  const schema4 = contract === "agent_market" ? agentCliErrorEnvelopeSchema : contract === "identity" ? identityErrorEnvelopeSchema : contract === "task_market" ? taskErrorEnvelopeSchema : contract === "skill_market" ? skillErrorEnvelopeSchema : oauthErrorResponseSchema;
+  const schema5 = contract === "agent_market" ? agentCliErrorEnvelopeSchema : contract === "identity" ? identityErrorEnvelopeSchema : contract === "task_market" ? taskErrorEnvelopeSchema : contract === "skill_market" ? skillErrorEnvelopeSchema : oauthErrorResponseSchema;
   let envelope;
   try {
-    envelope = assertSchema(schema4, value, diagnose ? skillErrorDiagnosticPaths : void 0);
+    envelope = assertSchema(schema5, value, diagnose ? skillErrorDiagnosticPaths : void 0);
   } catch (cause) {
     throw new CliHttpError("CLI_RESPONSE_INVALID", response.status, {
       cause,
@@ -55126,7 +55206,7 @@ function parseRemoteError(contract, response, value, diagnose = false) {
   }
   return envelope;
 }
-var import_ajv, CLI_MERCHANT_OPERATION_IDS, PUBLIC_SKILL_HTTP_CODES, CliHttpError, ajv, validatorCache, skillUnsignedIntentResponseSchema, intentDiagnosticPaths, skillErrorDiagnosticPaths, oauthAuthorizationResponseSchema, oauthErrorResponseSchema, AgentCliHttpClient;
+var import_ajv, CLI_MERCHANT_OPERATION_IDS, SKILL_UPLOAD_INLINE_LIMIT_BYTES, PUBLIC_SKILL_HTTP_CODES, TRACE_ID_PATTERN, CliHttpError, ajv, validatorCache, skillUnsignedIntentResponseSchema, intentDiagnosticPaths, skillErrorDiagnosticPaths, oauthAuthorizationResponseSchema, oauthErrorResponseSchema, AgentCliHttpClient;
 var init_api2 = __esm({
   "src/api.ts"() {
     "use strict";
@@ -55159,6 +55239,7 @@ var init_api2 = __esm({
       "merchant_connection_tests.create",
       "merchant_publish_intents.create"
     ]);
+    SKILL_UPLOAD_INLINE_LIMIT_BYTES = 4e6;
     PUBLIC_SKILL_HTTP_CODES = /* @__PURE__ */ new Set([
       "UPLOAD_INVALID",
       "UPLOAD_TOO_LARGE",
@@ -55173,6 +55254,7 @@ var init_api2 = __esm({
       "INTENT_UNAVAILABLE",
       "PUBLICATION_INVALID"
     ]);
+    TRACE_ID_PATTERN = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/u;
     CliHttpError = class extends Error {
       code;
       status;
@@ -55230,16 +55312,12 @@ var init_api2 = __esm({
       }
     };
     AgentCliHttpClient = class {
-      constructor(origin2, fetchImplementation = fetch, warn = (warning) => {
-        process.stderr.write(JSON.stringify({ warning }) + "\n");
-      }) {
-        this.warn = warn;
+      origin;
+      fetchImplementation;
+      constructor(origin2, fetchImplementation = fetch) {
         this.origin = canonicalOrigin2(origin2);
         this.fetchImplementation = fetchImplementation;
       }
-      warn;
-      origin;
-      fetchImplementation;
       async request(options) {
         const headers = new Headers(options.headers);
         if (options.path.split("?")[0] === "/api/v1/skill-market/skills") headers.set("X-Finch-Search-Version", "2");
@@ -55265,13 +55343,41 @@ var init_api2 = __esm({
         } catch (cause) {
           throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", null, { cause });
         }
+        const diagnose = options.errorContract === "skill_market";
         if (response.status !== options.successStatus) {
-          const envelope = parseRemoteError(options.errorContract, response, await readBoundedJson(response));
-          throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", response.status, { envelope });
+          let value2;
+          let envelope;
+          try {
+            value2 = await readBoundedJson(response, 65536, diagnose);
+            envelope = parseRemoteError(options.errorContract, response, value2, diagnose);
+          } catch (cause) {
+            if (!diagnose) throw cause;
+            throw new CliHttpError(cause instanceof CliHttpError ? cause.code : "CLI_RESPONSE_INVALID", response.status, {
+              cause,
+              ...cause instanceof CliHttpError && cause.envelope !== null ? { envelope: cause.envelope } : {},
+              diagnostic: { ...skillHttpDiagnostic(response, value2), ...cause instanceof CliHttpError ? cause.diagnostic : {} }
+            });
+          }
+          throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", response.status, {
+            envelope,
+            ...diagnose ? { diagnostic: skillHttpDiagnostic(response, value2) } : {}
+          });
         }
         if (options.successStatus === 204) return void 0;
-        const value = await readBoundedJson(response);
-        return options.responseSchema === void 0 ? value : assertSchema(options.responseSchema, value);
+        if (!diagnose) {
+          const value2 = await readBoundedJson(response);
+          return options.responseSchema === void 0 ? value2 : assertSchema(options.responseSchema, value2);
+        }
+        let value;
+        try {
+          value = await readBoundedJson(response, 65536, true);
+          return options.responseSchema === void 0 ? value : assertSchema(options.responseSchema, value);
+        } catch (cause) {
+          throw new CliHttpError(cause instanceof CliHttpError ? cause.code : "CLI_RESPONSE_INVALID", response.status, {
+            cause,
+            diagnostic: { ...skillHttpDiagnostic(response, value), ...cause instanceof CliHttpError ? cause.diagnostic : {} }
+          });
+        }
       }
       async skillFetch(path2, init, expectedStatus = 200) {
         let response;
@@ -55283,8 +55389,8 @@ var init_api2 = __esm({
         if (response.status !== expectedStatus) {
           let value;
           try {
-            value = await readBoundedJson(response, 65536, path2 === "/api/skills/intents");
-            const envelope = parseRemoteError("skill_market", response, value, path2 === "/api/skills/intents");
+            value = await readBoundedJson(response, 65536, true);
+            const envelope = parseRemoteError("skill_market", response, value, true);
             throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", response.status, { envelope });
           } catch (cause) {
             throw new CliHttpError(cause instanceof CliHttpError ? cause.code : "CLI_RESPONSE_INVALID", response.status, {
@@ -55387,19 +55493,9 @@ var init_api2 = __esm({
         const encoded = new Response(form);
         const bodyBytes = await encoded.arrayBuffer();
         const requestBytes = bodyBytes.byteLength;
-        if (requestBytes > 45e5) {
-          throw new CliSkillSourceError(
-            "SKILL_UPLOAD_REQUEST_TOO_LARGE",
-            { actualBytes: requestBytes, maxBytes: 45e5 },
-            "Skill upload request exceeds 4.5 MB. Reduce the package size before publishing."
-          );
+        if (requestBytes > SKILL_UPLOAD_INLINE_LIMIT_BYTES) {
+          return await this.uploadStagedSkillObject(input);
         }
-        if (requestBytes > 4e6) this.warn({
-          code: "SKILL_UPLOAD_NEAR_LIMIT",
-          requestBytes,
-          maxBytes: 45e5,
-          message: "Skill upload request exceeds 4 MB and may fail near the platform limit. Continuing."
-        });
         let response;
         let value;
         try {
@@ -55426,6 +55522,121 @@ var init_api2 = __esm({
           });
         }
       }
+      /**
+       * Returns a ticket to the wallet's budget when the upload it authorized will not be finished.
+       *
+       * A ticket is charged when it is issued, not when bytes arrive, so a write that fails leaves one
+       * indistinguishable from a ticket still in use. Four of those and the wallet is held until the
+       * oldest expires, a day later, for a dropped connection.
+       *
+       * Reports rather than throws, because it only ever runs while another failure is being raised
+       * and that failure is the one the publisher has to see. The outcome travels on that error's
+       * diagnostic instead, so a release that did not happen is still visible.
+       */
+      async releaseStagedTicket(path2, bearer) {
+        try {
+          await this.skillFetch("/api/skills/upload-tickets/abandon", {
+            method: "POST",
+            headers: { authorization: `Bearer ${bearer}`, "content-type": "application/json" },
+            body: JSON.stringify({ path: path2 })
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Uploads one object through the staged transport: ask for a signed URL, write the bytes to it
+       * directly, then ask the server to verify and pin what it finds there.
+       *
+       * The signed URL names a storage origin rather than Finch's, so it is checked before any bytes
+       * are written to it: a redirected or credential-bearing URL is refused rather than followed.
+       */
+      async uploadStagedSkillObject(input) {
+        const opened = await this.skillFetch("/api/skills/upload-tickets", {
+          method: "POST",
+          headers: { authorization: `Bearer ${input.bearer}` }
+        });
+        const ticket = await readBoundedJson(opened);
+        if (typeof ticket?.path !== "string" || typeof ticket.signedUrl !== "string") {
+          throw new CliHttpError("CLI_RESPONSE_INVALID", 200);
+        }
+        let signed;
+        try {
+          signed = new URL(ticket.signedUrl);
+        } catch {
+          throw new CliHttpError("CLI_RESPONSE_INVALID", 200);
+        }
+        if (signed.protocol !== "https:" && signed.hostname !== "127.0.0.1" && signed.hostname !== "localhost" || signed.username || signed.password) {
+          throw new CliHttpError("CLI_RESPONSE_INVALID", 200);
+        }
+        let written;
+        try {
+          written = await this.fetchImplementation(signed.toString(), {
+            method: "PUT",
+            redirect: "error",
+            headers: { "content-type": input.mediaType ?? "application/octet-stream" },
+            body: input.bytes
+          });
+        } catch (cause) {
+          const ticketReleased = await this.releaseStagedTicket(ticket.path, input.bearer);
+          throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", null, {
+            cause,
+            diagnostic: {
+              uploadBytes: input.bytes.byteLength,
+              uploadObjectKind: input.objectKind,
+              uploadTransport: "staged",
+              ticketReleased
+            }
+          });
+        }
+        if (!written.ok) {
+          const ticketReleased = await this.releaseStagedTicket(ticket.path, input.bearer);
+          throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", written.status, {
+            diagnostic: {
+              uploadBytes: input.bytes.byteLength,
+              uploadObjectKind: input.objectKind,
+              uploadTransport: "staged",
+              ticketReleased
+            }
+          });
+        }
+        let response;
+        let value;
+        try {
+          response = await this.skillFetch("/api/skills/upload-tickets/complete", {
+            method: "POST",
+            headers: { authorization: `Bearer ${input.bearer}`, "content-type": "application/json" },
+            body: JSON.stringify({
+              path: ticket.path,
+              objectKind: input.objectKind,
+              filename: input.filename,
+              ...input.mediaType === void 0 ? {} : { mediaType: input.mediaType },
+              ...input.sourceKind === void 0 ? {} : { sourceKind: input.sourceKind },
+              ...input.contentMode === void 0 ? {} : { contentMode: input.contentMode }
+            })
+          });
+          value = await readBoundedJson(response);
+          const body = value;
+          if (typeof body?.uri !== "string") throw new CliHttpError("CLI_RESPONSE_INVALID", 200);
+          return Object.freeze({ uri: body.uri });
+        } catch (cause) {
+          if (!(cause instanceof CliHttpError)) throw cause;
+          const ticketReleased = await this.releaseStagedTicket(ticket.path, input.bearer);
+          throw new CliHttpError(cause.code, cause.status, {
+            cause,
+            ...cause.envelope !== null ? { envelope: cause.envelope } : {},
+            diagnostic: {
+              ...response === void 0 ? {} : skillHttpDiagnostic(response, value),
+              ...cause.diagnostic,
+              uploadBytes: input.bytes.byteLength,
+              uploadObjectKind: input.objectKind,
+              uploadTransport: "staged",
+              ticketReleased
+            }
+          });
+        }
+      }
       async requestSkillIntent(body, bearer) {
         let response;
         try {
@@ -55527,7 +55738,7 @@ var init_api2 = __esm({
           headers: bearer === void 0 ? void 0 : { authorization: `Bearer ${bearer}` },
           cache: "no-store"
         });
-        return readBoundedBytes(response, 1, 10 * 1024 * 1024);
+        return readBoundedBytes(response, 1, MAX_SKILL_PACKAGE_BYTES);
       }
       async confirmSkillProjection(chainId, transactionHash3, bearer) {
         let response;
@@ -55567,13 +55778,13 @@ var init_api2 = __esm({
         });
       }
       authorizeMcp(requestPath, bearer) {
-        let parsed;
+        let parsed2;
         try {
-          parsed = new URL(requestPath, this.origin);
+          parsed2 = new URL(requestPath, this.origin);
         } catch {
           throw new TypeError("MCP authorization request path is invalid.");
         }
-        if (parsed.origin !== this.origin || parsed.pathname !== "/oauth/authorize" || parsed.hash !== "" || requestPath !== `${parsed.pathname}${parsed.search}` || parsed.search === "") {
+        if (parsed2.origin !== this.origin || parsed2.pathname !== "/oauth/authorize" || parsed2.hash !== "" || requestPath !== `${parsed2.pathname}${parsed2.search}` || parsed2.search === "") {
           throw new TypeError("MCP authorization request path is invalid.");
         }
         return this.request({
@@ -56224,16 +56435,16 @@ function assertLocalAction(value, command, skillId) {
   }
 }
 function intent(value, walletAddress2) {
-  const parsed = object2(value, "Skill intent");
-  exact2(parsed, ["chainId", "to", "data", "value", "summary", "signingAuthority"], "Skill intent");
-  const chainId = skillChain(parsed.chainId, "Skill intent chain");
+  const parsed2 = object2(value, "Skill intent");
+  exact2(parsed2, ["chainId", "to", "data", "value", "summary", "signingAuthority"], "Skill intent");
+  const chainId = skillChain(parsed2.chainId, "Skill intent chain");
   return Object.freeze({
     chainId,
-    to: string4(parsed.to, "Skill intent target", /^0x[0-9a-fA-F]{40}$/u),
-    data: string4(parsed.data, "Skill intent calldata", /^0x(?:[0-9a-fA-F]{2})+$/u),
-    value: string4(parsed.value, "Skill intent value", DECIMAL),
-    summary: string4(parsed.summary, "Skill intent summary"),
-    signingAuthority: signingAuthority(parsed.signingAuthority, walletAddress2)
+    to: string4(parsed2.to, "Skill intent target", /^0x[0-9a-fA-F]{40}$/u),
+    data: string4(parsed2.data, "Skill intent calldata", /^0x(?:[0-9a-fA-F]{2})+$/u),
+    value: string4(parsed2.value, "Skill intent value", DECIMAL),
+    summary: string4(parsed2.summary, "Skill intent summary"),
+    signingAuthority: signingAuthority(parsed2.signingAuthority, walletAddress2)
   });
 }
 function legacyIntent(value, walletAddress2, authority) {
@@ -56553,6 +56764,14 @@ function recoveryJournal(value, fingerprint2, kind, context) {
   journal.receipts = parsedReceipts;
   return journal;
 }
+function unconfirmedActions(journal) {
+  const actions = /* @__PURE__ */ new Map([
+    ["primary", journal.kind === "version" ? "updateSkill" : "createSkill"]
+  ]);
+  if (journal.kind === "version") actions.set("uri", "setSkillURI");
+  if (journal.contentMode !== "plaintext") actions.set("lit", "setLitData");
+  return [...actions].filter(([stage]) => journal.receipts[stage] === null).map(([, action]) => action);
+}
 var MAX_ENCRYPTED_BYTES, HASH2, IPFS, DECIMAL, UUID, SkillLocalFlow;
 var init_skill_local_flow = __esm({
   "src/skill-local-flow.ts"() {
@@ -56560,7 +56779,7 @@ var init_skill_local_flow = __esm({
     init_src2();
     init_client();
     init_cli_error();
-    MAX_ENCRYPTED_BYTES = 10 * 1024 * 1024;
+    MAX_ENCRYPTED_BYTES = MAX_SKILL_PACKAGE_BYTES;
     HASH2 = /^0x[0-9a-fA-F]{64}$/u;
     IPFS = /^ipfs:\/\/(?:Qm[1-9A-HJ-NP-Za-km-z]{44}|b[a-z2-7]{20,})$/u;
     DECIMAL = /^(?:0|[1-9][0-9]*)$/u;
@@ -56586,15 +56805,23 @@ var init_skill_local_flow = __esm({
           return await work(progress);
         } catch (cause) {
           const journal = progress.journal;
-          if (journal && (journal.pendingStage != null || journal.version !== 6 && (journal.receipts.primary === null || journal.kind === "version" && journal.receipts.uri === null || journal.contentMode !== "plaintext" && journal.receipts.lit === null))) progress.uncertain = true;
-          const transactionHashes = Object.fromEntries(Object.entries(progress.journal?.receipts ?? {}).flatMap(([stage, receipt]) => receipt && HASH2.test(receipt.transactionHash) ? [[stage, receipt.transactionHash]] : []));
+          const unconfirmed = journal ? unconfirmedActions(journal) : [];
+          if (journal && (journal.pendingStage != null || journal.version !== 6 && unconfirmed.length > 0)) {
+            progress.uncertain = true;
+          }
+          const transactionHashes = Object.fromEntries([
+            ...Object.entries(progress.journal?.receipts ?? {}).flatMap(([stage, receipt]) => receipt && HASH2.test(receipt.transactionHash) ? [[stage, receipt.transactionHash]] : []),
+            ...Object.entries(progress.broadcast ?? {}).filter(([, hash5]) => HASH2.test(hash5))
+          ]);
           const fingerprint2 = progress.journal && progress.fingerprint ? progress.fingerprint : null;
           throw new CliSkillPublicationError({
             phase: progress.phase,
             fingerprint: fingerprint2,
             transactionHashes,
+            unconfirmedActions: unconfirmed,
             submissionStatus: progress.uncertain ? "uncertain" : Object.keys(transactionHashes).length ? "hash_known" : "not_attempted",
-            recoveryCommand: progress.journalSaved && !progress.uncertain && progress.phase !== "cleanup" && fingerprint2 ? `finch skill recover publication ${fingerprint2}` : null
+            recoveryCommand: progress.journalSaved && !progress.uncertain && progress.phase !== "cleanup" && fingerprint2 ? `finch skill recover publication ${fingerprint2}` : null,
+            resubmitSafe: progress.resubmitSafe === true
           }, cause);
         }
       }
@@ -56619,7 +56846,7 @@ var init_skill_local_flow = __esm({
       }
       async upload(input) {
         const { bytes } = input;
-        if (bytes.byteLength === 0 || bytes.byteLength > MAX_ENCRYPTED_BYTES) throw new CliSkillSourceError("SKILL_UPLOAD_SIZE_INVALID", { actualBytes: bytes.byteLength, maxBytes: MAX_ENCRYPTED_BYTES }, "Skill upload must be between 1 byte and 10 MiB, including package metadata and encryption overhead.");
+        if (bytes.byteLength === 0 || bytes.byteLength > MAX_ENCRYPTED_BYTES) throw new CliSkillSourceError("SKILL_UPLOAD_SIZE_INVALID", { actualBytes: bytes.byteLength, maxBytes: MAX_ENCRYPTED_BYTES }, `Skill upload must be between 1 byte and ${MAX_ENCRYPTED_BYTES} bytes, including package metadata and encryption overhead.`);
         const result2 = await required2(this.api.uploadSkillObject, "Skill upload").call(this.api, input);
         return string4(result2.uri, "Pinned Skill URI", IPFS);
       }
@@ -56693,8 +56920,8 @@ var init_skill_local_flow = __esm({
           if (error51 instanceof SkillZipInvalidError) {
             const messages = {
               invalid_archive: "Skill ZIP is damaged or unsupported. Rebuild a regular ZIP and try again.",
-              archive_too_large: "Skill ZIP exceeds the 10 MiB compressed import limit. Reduce the archive size and try again.",
-              expanded_content_too_large: "Skill ZIP declares expanded content above the 10 MiB import limit. Reduce the uncompressed content and rebuild the ZIP.",
+              archive_too_large: `Skill ZIP exceeds the ${MAX_SKILL_IMPORT_BYTES} byte compressed import limit. Reduce the archive size and try again.`,
+              expanded_content_too_large: `Skill ZIP declares expanded content above the ${MAX_SKILL_IMPORT_BYTES} byte import limit. Reduce the uncompressed content and rebuild the ZIP.`,
               utf8_flag_missing: "Skill ZIP filenames with non-ASCII characters must declare UTF-8 (bit 11). Rebuild the ZIP with UTF-8 filenames and flags.",
               filename_encoding_invalid: "Skill ZIP filename bytes are not valid UTF-8. Rebuild the ZIP with UTF-8 filenames and flags."
             };
@@ -56775,15 +57002,24 @@ var init_skill_local_flow = __esm({
           await this.project(journal.chainId, journal.receipts[stage].transactionHash, context.bearer);
           return;
         }
-        if (journal.version !== 6 || journal.pendingStage != null) {
+        if (stage !== "uri" && (journal.pendingStage != null || journal.version !== 6)) {
           progress.uncertain = true;
-          throw new Error("Skill transaction submission state is uncertain. Contact support before retrying.");
+          throw new CliSkillRecoveryUncertainError({
+            stage,
+            journalVersion: journal.version,
+            kind: journal.kind,
+            targetVersion: journal.targetVersion,
+            marker: journal.pendingStage != null ? "pending" : "absent"
+          });
         }
         progress.phase = "intent";
         const prepared = await prepare();
         progress.phase = "transaction";
-        journal.pendingStage = stage;
-        await this.save(fingerprint2, journal);
+        const marks = journal.version === 6;
+        if (marks) {
+          journal.pendingStage = stage;
+          await this.save(fingerprint2, journal);
+        }
         progress.uncertain = true;
         journal.receipts[stage] = await this.send(
           context,
@@ -56794,12 +57030,14 @@ var init_skill_local_flow = __esm({
           async ({ transactionHash: transactionHash3 }) => {
             journal.receipts[stage] = { transactionHash: transactionHash3, blockNumber: null };
             await this.save(fingerprint2, journal);
-            journal.pendingStage = null;
-            await this.save(fingerprint2, journal);
+            if (marks) {
+              journal.pendingStage = null;
+              await this.save(fingerprint2, journal);
+            }
             progress.uncertain = false;
           }
         );
-        journal.pendingStage = null;
+        if (marks) journal.pendingStage = null;
         await this.save(fingerprint2, journal);
         progress.uncertain = false;
         progress.phase = "projection";
@@ -57256,15 +57494,30 @@ var init_skill_local_flow = __esm({
         await this.project(plan.chainId, submission.transactionHash, context.bearer);
         return { ...submission, chainId: plan.chainId, skillId: plan.request.skillId, kind };
       }
+      /**
+       * Binds a cover and an introduction to a Skill by replacing its manifest URI.
+       *
+       * Reported through the same publication progress as a publish, so a failure states the phase it
+       * reached and whether a transaction was broadcast. It keeps no recovery journal, because the one
+       * transaction it sends is `setSkillURI`: submitting the same plan again sets the same URI rather
+       * than creating anything, which is why `resubmitSafe` is true here and never true for a publish.
+       */
       async publishPresentation(planValue, context) {
+        return this.publication((progress) => this.publishPresentationWithProgress(planValue, context, progress));
+      }
+      async publishPresentationWithProgress(planValue, context, progress) {
         const plan = presentationPlan(planValue, context.walletAddress);
+        progress.resubmitSafe = true;
         const liveVersion = await required2(this.api.readSkillCurrentVersion, "Skill version API").call(this.api, plan.chainId, plan.skillId, context.bearer);
         if (liveVersion !== plan.currentVersion) {
-          throw new TypeError(`Skill current version ${liveVersion} no longer matches presentation plan version ${plan.currentVersion}.`);
+          throw new CliSkillPresentationStaleError("version_moved", plan.currentVersion, liveVersion);
         }
         const currentBytes = await required2(this.api.fetchSkillStoredContent, "Skill content relay").call(this.api, plan.currentManifestURI, context.bearer);
         const currentManifest = parseManifest(currentBytes);
-        if (currentManifest === null) throw new TypeError("Current Skill URI is not a valid version manifest.");
+        if (currentManifest === null) {
+          throw new CliSkillPresentationStaleError("manifest_unreadable", plan.currentVersion, liveVersion);
+        }
+        progress.phase = "upload";
         const manifestURI = await this.upload({
           bytes: serializeManifest(withPresentation(currentManifest, plan.presentation)),
           filename: `skill-${plan.skillId}.versions.json`,
@@ -57272,14 +57525,24 @@ var init_skill_local_flow = __esm({
           objectKind: "manifest"
         });
         const request = { action: "setSkillURI", chainId: plan.chainId, skillId: plan.skillId, packageURI: manifestURI };
+        progress.phase = "intent";
         const prepared = await required2(this.api.requestSkillIntent, "Skill intent API").call(this.api, request, context.bearer);
+        progress.phase = "transaction";
+        progress.uncertain = true;
         const submission = await this.send(
           context,
           "setSkillURI",
           request,
           prepared,
-          plan.signingAuthority
+          plan.signingAuthority,
+          async ({ transactionHash: transactionHash3 }) => {
+            progress.broadcast = { setSkillURI: transactionHash3 };
+            progress.uncertain = false;
+          }
         );
+        progress.broadcast = { setSkillURI: submission.transactionHash };
+        progress.uncertain = false;
+        progress.phase = "projection";
         await this.project(plan.chainId, submission.transactionHash, context.bearer);
         return { ...submission, chainId: plan.chainId, skillId: plan.skillId, currentVersion: plan.currentVersion, manifestURI };
       }
@@ -58021,14 +58284,14 @@ var init_application = __esm({
       }
       async loginSite(requestUrl) {
         const profile = await this.authorizedProfile();
-        let parsed;
+        let parsed2;
         try {
-          parsed = new URL(requestUrl);
+          parsed2 = new URL(requestUrl);
         } catch {
           throw new TypeError("Browser login request URL is invalid.");
         }
-        const match = /^\/auth\/agent\/request\/([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/u.exec(parsed.pathname);
-        if (parsed.origin !== profile.origin || requestUrl !== `${profile.origin}${parsed.pathname}` || parsed.search !== "" || parsed.hash !== "" || match === null) {
+        const match = /^\/auth\/agent\/request\/([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/u.exec(parsed2.pathname);
+        if (parsed2.origin !== profile.origin || requestUrl !== `${profile.origin}${parsed2.pathname}` || parsed2.search !== "" || parsed2.hash !== "" || match === null) {
           throw new TypeError("Browser login request origin or path does not match the active profile origin.");
         }
         const authority = await this.verifiedAgentCliAuthority();
@@ -58866,7 +59129,7 @@ var init_application = __esm({
         const plan = await readBoundedJsonFile(planFile);
         const context = isPlaintextSkillDelivery(plan) ? null : await this.skillLocalContext();
         const delivered = await required3(this.skillLocalFlow, "skill local flow").download(plan, context);
-        await writeExclusiveProtectedFile(outputFile, delivered.bytes);
+        await writeExclusiveProtectedFile(outputFile, delivered.bytes, "output_destination");
         return { path: outputFile, skillId: delivered.skillId, version: delivered.version, packageHash: delivered.packageHash };
       }
       async showIntent(intentId) {
@@ -58988,7 +59251,7 @@ var init_application = __esm({
         if (decoded.keyId !== material.keyId || claim.expectedKeyId !== null && claim.expectedKeyId !== decoded.keyId) {
           throw new TypeError("Credential material keyId does not match the live claim.");
         }
-        await writeExclusiveProtectedFile(outputFile, material.body);
+        await writeExclusiveProtectedFile(outputFile, material.body, "output_destination");
         return Object.freeze({ keyId: decoded.keyId, path: outputFile });
       }
       async showOperation(operationId) {
@@ -59146,7 +59409,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@finchtech/cli",
-      version: "0.3.6",
+      version: "0.3.7",
       description: "Finch Agent CLI for wallet-owned marketplace and MCP workflows.",
       type: "module",
       bin: {
@@ -60148,12 +60411,12 @@ function environment2(value) {
 }
 function endpointOrigin(value) {
   if (typeof value !== "string" || !URL.canParse(value)) throw new CliStateError("CLI_STATE_CORRUPT");
-  const parsed = new URL(value);
-  const loopbackHttp = parsed.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(parsed.hostname);
-  if (parsed.origin !== value || parsed.username !== "" || parsed.password !== "" || parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "" || parsed.protocol !== "https:" && !loopbackHttp) {
+  const parsed2 = new URL(value);
+  const loopbackHttp = parsed2.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(parsed2.hostname);
+  if (parsed2.origin !== value || parsed2.username !== "" || parsed2.password !== "" || parsed2.pathname !== "/" || parsed2.search !== "" || parsed2.hash !== "" || parsed2.protocol !== "https:" && !loopbackHttp) {
     throw new CliStateError("CLI_STATE_CORRUPT");
   }
-  return parsed.origin;
+  return parsed2.origin;
 }
 function pendingGrantFingerprint(scopes, expiresAt) {
   return createHash4("sha256").update(JSON.stringify({ scopes, expiresAt }), "utf8").digest("hex");
@@ -61211,11 +61474,11 @@ var init_chains2 = __esm({
 
 // src/purchase-sender.ts
 function parseRpcUrl(value) {
-  const parsed = new URL(value);
-  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.hash !== "") {
+  const parsed2 = new URL(value);
+  if (parsed2.protocol !== "https:" || parsed2.username !== "" || parsed2.password !== "" || parsed2.hash !== "") {
     throw new TypeError("The reviewed Agent RPC must be HTTPS without userinfo or fragment.");
   }
-  return parsed.href;
+  return parsed2.href;
 }
 function privateKey2(value) {
   if (!/^0x[0-9a-f]{64}$/u.test(value)) {
@@ -61512,11 +61775,11 @@ var init_purchase_sender = __esm({
 
 // src/task-protocol-sender.ts
 function parseRpcUrl2(value) {
-  const parsed = new URL(value);
-  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.hash !== "") {
+  const parsed2 = new URL(value);
+  if (parsed2.protocol !== "https:" || parsed2.username !== "" || parsed2.password !== "" || parsed2.hash !== "") {
     throw new TypeError("The reviewed Task RPC must be HTTPS without userinfo or fragment.");
   }
-  return parsed.href;
+  return parsed2.href;
 }
 function installedPrivateKey(value) {
   if (!/^0x[0-9a-f]{64}$/u.test(value)) throw new TypeError("The installed wallet private key is invalid.");
@@ -61542,9 +61805,9 @@ function unsigned(value, name) {
 }
 function uint642(value, name) {
   if (!Number.isSafeInteger(value) || Number(value) < 0) throw new TypeError(`${name} is invalid.`);
-  const parsed = BigInt(Number(value));
-  if (parsed > 18446744073709551615n) throw new TypeError(`${name} is invalid.`);
-  return parsed;
+  const parsed2 = BigInt(Number(value));
+  if (parsed2 > 18446744073709551615n) throw new TypeError(`${name} is invalid.`);
+  return parsed2;
 }
 function uint16(value, name) {
   if (!Number.isSafeInteger(value) || Number(value) < 0 || Number(value) > 65535) {
@@ -61894,11 +62157,11 @@ var init_task_protocol_sender = __esm({
 
 // src/skill-intent-sender.ts
 function parseRpcUrl3(value) {
-  const parsed = new URL(value);
-  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.hash !== "") {
+  const parsed2 = new URL(value);
+  if (parsed2.protocol !== "https:" || parsed2.username !== "" || parsed2.password !== "" || parsed2.hash !== "") {
     throw new TypeError("The reviewed Skill RPC must be HTTPS without userinfo or fragment.");
   }
-  return parsed.href;
+  return parsed2.href;
 }
 function installedPrivateKey2(value) {
   if (!/^0x[0-9a-f]{64}$/u.test(value)) throw new TypeError("The installed wallet private key is invalid.");
@@ -62281,6 +62544,18 @@ var output_exports = {};
 __export(output_exports, {
   emitCliOutcome: () => emitCliOutcome
 });
+function resubmitSafeGuidance(diagnostic) {
+  if (diagnostic.submissionStatus === "not_attempted") {
+    return "No transaction was sent. Submitting the same plan again is safe.";
+  }
+  return `${diagnostic.submissionStatus === "uncertain" ? "A transaction may have been broadcast without a returned hash." : "The transaction was broadcast and may still have reverted."} Read the Skill on chain first; resubmitting the same plan cannot apply twice, because it sets the same URI rather than creating anything.`;
+}
+function remoteCallerAction(status) {
+  if (status === 401 || status === 403) return "authenticate";
+  if (status === 400 || status === 422) return "fix_request";
+  if (status === 409 || status === 412 || status === 428) return "refresh_resource";
+  return null;
+}
 function remoteExitCode(status) {
   if (status === 400 || status === 422) return AGENT_CLI_OUTPUT_CONTRACT.exitCodes.usageOrLocalSchema;
   if (status === 401 || status === 403) return AGENT_CLI_OUTPUT_CONTRACT.exitCodes.authenticationOrAuthority;
@@ -62313,6 +62588,23 @@ function failure(error51) {
       message: "This protocol is not available in production."
     };
   }
+  if (error51 instanceof CliSkillPresentationStaleError) {
+    return {
+      code: "AGENT_MARKET_STATE_CONFLICT",
+      exitCode: AGENT_CLI_OUTPUT_CONTRACT.exitCodes.conflictOrPrecondition,
+      message: error51.reason === "version_moved" ? `The Skill is now at version ${error51.liveVersion}; this presentation plan was prepared for version ${error51.planVersion}. Prepare the presentation again against the current version.` : "The Skill URI on chain does not hold a version manifest this CLI can extend. Re-read the Skill, then prepare the presentation again."
+    };
+  }
+  if (error51 instanceof CliSkillRecoveryUncertainError) {
+    const { stage, marker, kind, targetVersion } = error51.detail;
+    const unknown2 = stage === "lit" ? `the delivery key for version ${targetVersion} was set` : kind === "version" ? `version ${targetVersion} was added` : "the Skill was created";
+    const settled = stage === "lit" ? `version ${targetVersion} is already deliverable` : kind === "version" ? `the Skill is already at version ${targetVersion}` : "a Skill is already registered under this slug";
+    return {
+      code: "AGENT_MARKET_STATE_CONFLICT",
+      exitCode: AGENT_CLI_OUTPUT_CONTRACT.exitCodes.conflictOrPrecondition,
+      message: `${marker === "pending" ? "This recovery stopped after the transaction was prepared for sending" : "This recovery journal predates the pre-send marker"}, so whether ${unknown2} cannot be established locally. Read the Skill on chain first: if ${settled}, the transaction landed and only the local journal is behind. Contact support with this state rather than re-running the command.`
+    };
+  }
   if (error51 instanceof CliRecoveryBlockedError) {
     return {
       code: "AGENT_MARKET_STATE_CONFLICT",
@@ -62353,17 +62645,32 @@ function emitCliOutcome(outcome, sinks) {
     const envelope2 = JSON.parse(serialized);
     const source = cause instanceof CliSkillSourceError ? cause : null;
     const remote = cause instanceof CliHttpError && cause.envelope !== null;
+    const uncertainRecovery = cause instanceof CliSkillRecoveryUncertainError;
     const diagnostic = outcome.diagnostic;
+    const inputBound = source !== null || !(cause instanceof CliHttpError) && diagnostic.phase === "validation";
+    const remoteAction = remoteCallerAction(cause instanceof CliHttpError ? cause.status : null);
+    const safeRepeat = diagnostic.resubmitSafe && !inputBound && remoteAction === null;
     envelope2.error.state = JSON.stringify({
       diagnosticCode: source?.diagnosticCode ?? "SKILL_PUBLICATION_FAILED",
       ...source?.details,
       ...diagnostic,
       ...cause instanceof CliHttpError ? { remoteStatus: cause.status, ...cause.diagnostic } : {},
-      ...remote ? { remoteStatus: cause.status, remoteState: envelope2.error.state } : {}
+      // The message is kept beside the state because the branches below rewrite the top-level one:
+      // whatever the Online API said about this failure has to survive somewhere it can be read.
+      ...remote ? { remoteStatus: cause.status, remoteState: envelope2.error.state, remoteMessage: envelope2.error.message } : {}
     });
     envelope2.error.retryable = false;
-    if (!source && !remote && diagnostic.phase !== "validation") envelope2.error.message = `Skill publication failed during ${diagnostic.phase}. ${diagnostic.recoveryCommand ? "Use the recovery command in state; do not resubmit." : diagnostic.submissionStatus === "uncertain" ? "Broadcast outcome or checkpoint is uncertain. Contact support before retrying or recovering." : "Contact support with the public diagnostic state before retrying."}`;
-    envelope2.error.nextAction = diagnostic.submissionStatus === "uncertain" ? "contact_support" : diagnostic.recoveryCommand ? "refresh_resource" : source ? "fix_request" : (remote || diagnostic.phase === "validation") && ["authenticate", "request_scope", "fix_request"].includes(String(envelope2.error.nextAction)) ? envelope2.error.nextAction : "contact_support";
+    if (!source && !remote && !uncertainRecovery && diagnostic.phase !== "validation") envelope2.error.message = `Skill publication failed during ${diagnostic.phase}. ${diagnostic.recoveryCommand ? "Use the recovery command in state; do not resubmit." : safeRepeat ? resubmitSafeGuidance(diagnostic) : diagnostic.submissionStatus === "uncertain" ? "Broadcast outcome or checkpoint is uncertain. Contact support before retrying or recovering." : "Contact support with the public diagnostic state before retrying."}`;
+    envelope2.error.nextAction = diagnostic.recoveryCommand ? "refresh_resource" : inputBound ? envelope2.error.nextAction : remoteAction !== null ? remoteAction : safeRepeat ? "refresh_resource" : diagnostic.submissionStatus === "uncertain" ? "contact_support" : (remote || diagnostic.phase === "validation") && ["authenticate", "request_scope", "fix_request"].includes(String(envelope2.error.nextAction)) ? envelope2.error.nextAction : "contact_support";
+    if (safeRepeat) envelope2.error.retryable = true;
+    if (diagnostic.phase === "projection" && diagnostic.submissionStatus === "hash_known") {
+      const status = cause instanceof CliHttpError ? cause.status : null;
+      const remaining = diagnostic.unconfirmedActions;
+      const repeatNote = diagnostic.resubmitSafe ? "Submitting the same plan again is safe, though unnecessary once the projection lands." : "Do not resubmit the publication.";
+      envelope2.error.message = remaining.length === 0 ? `Skill transactions succeeded; only the marketplace projection did not confirm. ${diagnostic.recoveryCommand ? "Re-read the Skill, then use the recovery command in state to finish the projection." : "Re-read the Skill and retry the projection."} ${repeatNote}` : `The transactions sent so far succeeded, but the publication is not finished: ${remaining.join(", ")} ${remaining.length === 1 ? "has" : "have"} not been sent. ${diagnostic.recoveryCommand ? "Use the recovery command in state to send the remaining transactions." : "Contact support with the public diagnostic state."} ${repeatNote}`;
+      envelope2.error.retryable = true;
+      envelope2.error.nextAction = status === 401 || status === 403 ? "authenticate" : remaining.length === 0 ? "retry_later" : diagnostic.recoveryCommand ? "refresh_resource" : "contact_support";
+    }
     sinks.stdout(`${JSON.stringify(envelope2)}
 `);
     return exitCode;