@finchtech/cli 0.3.1 → 0.3.3

package/dist/finch.js

@@ -1075,52 +1075,52 @@ var require_util = __commonJS({
       return hash5;
     }
     exports.toHash = toHash;
-    function alwaysValidSchema(it, schema3) {
-      if (typeof schema3 == "boolean")
-        return schema3;
-      if (Object.keys(schema3).length === 0)
+    function alwaysValidSchema(it, schema4) {
+      if (typeof schema4 == "boolean")
+        return schema4;
+      if (Object.keys(schema4).length === 0)
         return true;
-      checkUnknownRules(it, schema3);
-      return !schemaHasRules(schema3, it.self.RULES.all);
+      checkUnknownRules(it, schema4);
+      return !schemaHasRules(schema4, it.self.RULES.all);
     }
     exports.alwaysValidSchema = alwaysValidSchema;
-    function checkUnknownRules(it, schema3 = it.schema) {
+    function checkUnknownRules(it, schema4 = it.schema) {
       const { opts, self } = it;
       if (!opts.strictSchema)
         return;
-      if (typeof schema3 === "boolean")
+      if (typeof schema4 === "boolean")
         return;
       const rules = self.RULES.keywords;
-      for (const key in schema3) {
+      for (const key in schema4) {
         if (!rules[key])
           checkStrictMode(it, `unknown keyword: "${key}"`);
       }
     }
     exports.checkUnknownRules = checkUnknownRules;
-    function schemaHasRules(schema3, rules) {
-      if (typeof schema3 == "boolean")
-        return !schema3;
-      for (const key in schema3)
+    function schemaHasRules(schema4, rules) {
+      if (typeof schema4 == "boolean")
+        return !schema4;
+      for (const key in schema4)
         if (rules[key])
           return true;
       return false;
     }
     exports.schemaHasRules = schemaHasRules;
-    function schemaHasRulesButRef(schema3, RULES) {
-      if (typeof schema3 == "boolean")
-        return !schema3;
-      for (const key in schema3)
+    function schemaHasRulesButRef(schema4, RULES) {
+      if (typeof schema4 == "boolean")
+        return !schema4;
+      for (const key in schema4)
         if (key !== "$ref" && RULES.all[key])
           return true;
       return false;
     }
     exports.schemaHasRulesButRef = schemaHasRulesButRef;
-    function schemaRefOrVal({ topSchemaRef, schemaPath }, schema3, keyword, $data) {
+    function schemaRefOrVal({ topSchemaRef, schemaPath }, schema4, keyword, $data) {
       if (!$data) {
-        if (typeof schema3 == "number" || typeof schema3 == "boolean")
-          return schema3;
-        if (typeof schema3 == "string")
-          return (0, codegen_1._)`${schema3}`;
+        if (typeof schema4 == "number" || typeof schema4 == "boolean")
+          return schema4;
+        if (typeof schema4 == "string")
+          return (0, codegen_1._)`${schema4}`;
       }
       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: schema3, validateName } = it;
-      if (schema3 === false) {
+      const { gen: gen2, schema: schema4, validateName } = it;
+      if (schema4 === false) {
         falseSchemaError(it, false);
-      } else if (typeof schema3 == "object" && schema3.$async === true) {
+      } else if (typeof schema4 == "object" && schema4.$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: schema3 } = it;
-      if (schema3 === false) {
+      const { gen: gen2, schema: schema4 } = it;
+      if (schema4 === 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: schema3, self }, type) {
+    function schemaHasRulesForType({ schema: schema4, self }, type) {
       const group = self.RULES.types[type];
-      return group && group !== true && shouldUseGroup(schema3, group);
+      return group && group !== true && shouldUseGroup(schema4, group);
     }
     exports.schemaHasRulesForType = schemaHasRulesForType;
-    function shouldUseGroup(schema3, group) {
-      return group.rules.some((rule) => shouldUseRule(schema3, rule));
+    function shouldUseGroup(schema4, group) {
+      return group.rules.some((rule) => shouldUseRule(schema4, rule));
     }
     exports.shouldUseGroup = shouldUseGroup;
-    function shouldUseRule(schema3, rule) {
+    function shouldUseRule(schema4, rule) {
       var _a4;
-      return schema3[rule.keyword] !== void 0 || ((_a4 = rule.definition.implements) === null || _a4 === void 0 ? void 0 : _a4.some((kwd) => schema3[kwd] !== void 0));
+      return schema4[rule.keyword] !== void 0 || ((_a4 = rule.definition.implements) === null || _a4 === void 0 ? void 0 : _a4.some((kwd) => schema4[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(schema3) {
-      const types = getJSONTypes(schema3.type);
+    function getSchemaTypes(schema4) {
+      const types = getJSONTypes(schema4.type);
       const hasNull = types.includes("null");
       if (hasNull) {
-        if (schema3.nullable === false)
+        if (schema4.nullable === false)
           throw new Error("type: null contradicts nullable: false");
       } else {
-        if (!types.length && schema3.nullable !== void 0) {
+        if (!types.length && schema4.nullable !== void 0) {
           throw new Error('"nullable" cannot be used without "type"');
         }
-        if (schema3.nullable === true)
+        if (schema4.nullable === true)
           types.push("null");
       }
       return types;
@@ -1651,8 +1651,8 @@ var require_dataType = __commonJS({
     }
     exports.checkDataTypes = checkDataTypes;
     var typeError = {
-      message: ({ schema: schema3 }) => `must be ${schema3}`,
-      params: ({ schema: schema3, schemaValue }) => typeof schema3 == "string" ? (0, codegen_1._)`{type: ${schema3}}` : (0, codegen_1._)`{type: ${schemaValue}}`
+      message: ({ schema: schema4 }) => `must be ${schema4}`,
+      params: ({ schema: schema4, schemaValue }) => typeof schema4 == "string" ? (0, codegen_1._)`{type: ${schema4}}` : (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: schema3 } = it;
-      const schemaCode = (0, util_1.schemaRefOrVal)(it, schema3, "type");
+      const { gen: gen2, data, schema: schema4 } = it;
+      const schemaCode = (0, util_1.schemaRefOrVal)(it, schema4, "type");
       return {
         gen: gen2,
         keyword: "type",
         data,
-        schema: schema3.type,
+        schema: schema4.type,
         schemaCode,
         schemaValue: schemaCode,
-        parentSchema: schema3,
+        parentSchema: schema4,
         params: {},
         it
       };
@@ -1822,15 +1822,15 @@ var require_code2 = __commonJS({
     }
     exports.validateArray = validateArray;
     function validateUnion(cxt) {
-      const { gen: gen2, schema: schema3, keyword, it } = cxt;
-      if (!Array.isArray(schema3))
+      const { gen: gen2, schema: schema4, keyword, it } = cxt;
+      if (!Array.isArray(schema4))
         throw new Error("ajv implementation error");
-      const alwaysValid = schema3.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
+      const alwaysValid = schema4.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(() => schema3.forEach((_sch, i2) => {
+      gen2.block(() => schema4.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: schema3, parentSchema, it } = cxt;
-      const macroSchema = def.macro.call(it.self, schema3, parentSchema, it);
+      const { gen: gen2, keyword, schema: schema4, parentSchema, it } = cxt;
+      const macroSchema = def.macro.call(it.self, schema4, 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: schema3, parentSchema, $data, it } = cxt;
+      const { gen: gen2, keyword, schema: schema4, parentSchema, $data, it } = cxt;
       checkAsyncKeyword(it, def);
-      const validate6 = !$data && def.compile ? def.compile.call(it.self, schema3, parentSchema, it) : def.validate;
+      const validate6 = !$data && def.compile ? def.compile.call(it.self, schema4, 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(schema3, schemaType, allowUndefined = false) {
-      return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema3) : st === "object" ? schema3 && typeof schema3 == "object" && !Array.isArray(schema3) : typeof schema3 == st || allowUndefined && typeof schema3 == "undefined");
+    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");
     }
     exports.validSchemaType = validSchemaType;
-    function validateKeywordUsage({ schema: schema3, opts, self, errSchemaPath }, def, keyword) {
+    function validateKeywordUsage({ schema: schema4, 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(schema3, kwd))) {
+      if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema4, kwd))) {
         throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
       }
       if (def.validateSchema) {
-        const valid = def.validateSchema(schema3[keyword]);
+        const valid = def.validateSchema(schema4[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: schema3, schemaPath, errSchemaPath, topSchemaRef }) {
-      if (keyword !== void 0 && schema3 !== void 0) {
+    function getSubschema(it, { keyword, schemaProp, schema: schema4, schemaPath, errSchemaPath, topSchemaRef }) {
+      if (keyword !== void 0 && schema4 !== 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 (schema3 !== void 0) {
+      if (schema4 !== 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: schema3,
+          schema: schema4,
           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(schema3, opts, cb) {
+    var traverse = module.exports = function(schema4, 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, schema3, "", schema3);
+      _traverse(opts, pre, post, schema4, "", schema4);
     };
     traverse.keywords = {
       additionalItems: true,
@@ -2143,26 +2143,26 @@ var require_json_schema_traverse = __commonJS({
       maxProperties: true,
       minProperties: true
     };
-    function _traverse(opts, pre, post, schema3, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
-      if (schema3 && typeof schema3 == "object" && !Array.isArray(schema3)) {
-        pre(schema3, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-        for (var key in schema3) {
-          var sch = schema3[key];
+    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];
           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, schema3, i2);
+                _traverse(opts, pre, post, sch[i2], jsonPtr + "/" + key + "/" + i2, rootSchema, jsonPtr, key, schema4, 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, schema3, prop);
+                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema4, prop);
             }
           } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
-            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema3);
+            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema4);
           }
         }
-        post(schema3, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+        post(schema4, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
       }
     }
     function escapeJsonPtr(str) {
@@ -2198,14 +2198,14 @@ var require_resolve = __commonJS({
       "enum",
       "const"
     ]);
-    function inlineRef(schema3, limit = true) {
-      if (typeof schema3 == "boolean")
+    function inlineRef(schema4, limit = true) {
+      if (typeof schema4 == "boolean")
         return true;
       if (limit === true)
-        return !hasRef(schema3);
+        return !hasRef(schema4);
       if (!limit)
         return false;
-      return countKeys(schema3) <= limit;
+      return countKeys(schema4) <= limit;
     }
     exports.inlineRef = inlineRef;
     var REF_KEYWORDS = /* @__PURE__ */ new Set([
@@ -2215,11 +2215,11 @@ var require_resolve = __commonJS({
       "$dynamicRef",
       "$dynamicAnchor"
     ]);
-    function hasRef(schema3) {
-      for (const key in schema3) {
+    function hasRef(schema4) {
+      for (const key in schema4) {
         if (REF_KEYWORDS.has(key))
           return true;
-        const sch = schema3[key];
+        const sch = schema4[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(schema3) {
+    function countKeys(schema4) {
       let count = 0;
-      for (const key in schema3) {
+      for (const key in schema4) {
         if (key === "$ref")
           return Infinity;
         count++;
         if (SIMPLE_INLINED.has(key))
           continue;
-        if (typeof schema3[key] == "object") {
-          (0, util_1.eachItem)(schema3[key], (sch) => count += countKeys(sch));
+        if (typeof schema4[key] == "object") {
+          (0, util_1.eachItem)(schema4[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(schema3, baseId) {
-      if (typeof schema3 == "boolean")
+    function getSchemaRefs(schema4, baseId) {
+      if (typeof schema4 == "boolean")
         return {};
       const { schemaId, uriResolver } = this.opts;
-      const schId = normalizeId(schema3[schemaId] || baseId);
+      const schId = normalizeId(schema4[schemaId] || baseId);
       const baseIds = { "": schId };
       const pathPrefix = getFullPath(uriResolver, schId, false);
       const localRefs = {};
       const schemaRefs = /* @__PURE__ */ new Set();
-      traverse(schema3, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
+      traverse(schema4, { 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: schema3, schemaEnv, opts }, body) {
+    function validateFunction({ gen: gen2, validateName, schema: schema4, 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(schema3, opts)}`);
+          gen2.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema4, 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(schema3, opts)).code(body));
+        gen2.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen2.code(funcSourceUrl(schema4, opts)).code(body));
       }
     }
     function destructureValCxt(opts) {
@@ -2388,9 +2388,9 @@ var require_validate = __commonJS({
       });
     }
     function topSchemaObjCode(it) {
-      const { schema: schema3, opts, gen: gen2 } = it;
+      const { schema: schema4, opts, gen: gen2 } = it;
       validateFunction(it, () => {
-        if (opts.$comment && schema3.$comment)
+        if (opts.$comment && schema4.$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(schema3, opts) {
-      const schId = typeof schema3 == "object" && schema3[opts.schemaId];
+    function funcSourceUrl(schema4, opts) {
+      const schId = typeof schema4 == "object" && schema4[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: schema3, self }) {
-      if (typeof schema3 == "boolean")
-        return !schema3;
-      for (const key in schema3)
+    function schemaCxtHasRules({ schema: schema4, self }) {
+      if (typeof schema4 == "boolean")
+        return !schema4;
+      for (const key in schema4)
         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: schema3, gen: gen2, opts } = it;
-      if (opts.$comment && schema3.$comment)
+      const { schema: schema4, gen: gen2, opts } = it;
+      if (opts.$comment && schema4.$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: schema3, errSchemaPath, opts, self } = it;
-      if (schema3.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema3, self.RULES)) {
+      const { schema: schema4, errSchemaPath, opts, self } = it;
+      if (schema4.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema4, self.RULES)) {
         self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
       }
     }
     function checkNoDefault(it) {
-      const { schema: schema3, opts } = it;
-      if (schema3.default !== void 0 && opts.useDefaults && opts.strictSchema) {
+      const { schema: schema4, opts } = it;
+      if (schema4.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: schema3, errSchemaPath, opts }) {
-      const msg = schema3.$comment;
+    function commentKeyword({ gen: gen2, schemaEnv, schema: schema4, errSchemaPath, opts }) {
+      const msg = schema4.$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: schema3, data, allErrors, opts, self } = it;
+      const { gen: gen2, schema: schema4, data, allErrors, opts, self } = it;
       const { RULES } = self;
-      if (schema3.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema3, RULES))) {
+      if (schema4.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema4, 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)(schema3, group))
+        if (!(0, applicability_1.shouldUseGroup)(schema4, 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: schema3, opts: { useDefaults } } = it;
+      const { gen: gen2, schema: schema4, 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)(schema3, rule)) {
+          if ((0, applicability_1.shouldUseRule)(schema4, rule)) {
             keywordCode(it, rule.keyword, rule.definition, group.type);
           }
         }
@@ -2885,17 +2885,17 @@ var require_compile = __commonJS({
         var _a4;
         this.refs = {};
         this.dynamicAnchors = {};
-        let schema3;
+        let schema4;
         if (typeof env.schema == "object")
-          schema3 = env.schema;
+          schema4 = 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)(schema3 === null || schema3 === void 0 ? void 0 : schema3[env.schemaId || "$id"]);
+        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.schemaPath = env.schemaPath;
         this.localRefs = env.localRefs;
         this.meta = env.meta;
-        this.$async = schema3 === null || schema3 === void 0 ? void 0 : schema3.$async;
+        this.$async = schema4 === null || schema4 === void 0 ? void 0 : schema4.$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 schema3 = (_a4 = root.localRefs) === null || _a4 === void 0 ? void 0 : _a4[ref];
+        const schema4 = (_a4 = root.localRefs) === null || _a4 === void 0 ? void 0 : _a4[ref];
         const { schemaId } = this.opts;
-        if (schema3)
-          _sch = new SchemaEnv({ schema: schema3, schemaId, root, baseId });
+        if (schema4)
+          _sch = new SchemaEnv({ schema: schema4, 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: schema3 } = schOrRef;
+        const { schema: schema4 } = schOrRef;
         const { schemaId } = this.opts;
-        const schId = schema3[schemaId];
+        const schId = schema4[schemaId];
         if (schId)
           baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-        return new SchemaEnv({ schema: schema3, schemaId, root, baseId });
+        return new SchemaEnv({ schema: schema4, schemaId, root, baseId });
       }
       return getJsonPointer.call(this, p, schOrRef);
     }
@@ -3062,29 +3062,29 @@ var require_compile = __commonJS({
       "dependencies",
       "definitions"
     ]);
-    function getJsonPointer(parsedRef, { baseId, schema: schema3, root }) {
+    function getJsonPointer(parsedRef, { baseId, schema: schema4, 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 schema3 === "boolean")
+        if (typeof schema4 === "boolean")
           return;
-        const partSchema = schema3[(0, util_1.unescapeFragment)(part)];
+        const partSchema = schema4[(0, util_1.unescapeFragment)(part)];
         if (partSchema === void 0)
           return;
-        schema3 = partSchema;
-        const schId = typeof schema3 === "object" && schema3[this.opts.schemaId];
+        schema4 = partSchema;
+        const schId = typeof schema4 === "object" && schema4[this.opts.schemaId];
         if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
           baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
         }
       }
       let env;
-      if (typeof schema3 != "boolean" && schema3.$ref && !(0, util_1.schemaHasRulesButRef)(schema3, this.RULES)) {
-        const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema3.$ref);
+      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);
         env = resolveSchema.call(this, root, $ref);
       }
       const { schemaId } = this.opts;
-      env = env || new SchemaEnv({ schema: schema3, schemaId, root, baseId });
+      env = env || new SchemaEnv({ schema: schema4, schemaId, root, baseId });
       if (env.schema !== env.root.schema)
         return env;
       return void 0;
@@ -4126,16 +4126,16 @@ var require_core = __commonJS({
           this.errors = v.errors;
         return valid;
       }
-      compile(schema3, _meta) {
-        const sch = this._addSchema(schema3, _meta);
+      compile(schema4, _meta) {
+        const sch = this._addSchema(schema4, _meta);
         return sch.validate || this._compileSchemaEnv(sch);
       }
-      compileAsync(schema3, meta3) {
+      compileAsync(schema4, meta3) {
         if (typeof this.opts.loadSchema != "function") {
           throw new Error("options.loadSchema should be a function");
         }
         const { loadSchema } = this.opts;
-        return runCompileAsync.call(this, schema3, meta3);
+        return runCompileAsync.call(this, schema4, 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(schema3, key, _meta, _validateSchema = this.opts.validateSchema) {
-        if (Array.isArray(schema3)) {
-          for (const sch of schema3)
+      addSchema(schema4, key, _meta, _validateSchema = this.opts.validateSchema) {
+        if (Array.isArray(schema4)) {
+          for (const sch of schema4)
             this.addSchema(sch, void 0, _meta, _validateSchema);
           return this;
         }
         let id;
-        if (typeof schema3 === "object") {
+        if (typeof schema4 === "object") {
           const { schemaId } = this.opts;
-          id = schema3[schemaId];
+          id = schema4[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(schema3, _meta, key, _validateSchema, true);
+        this.schemas[key] = this._addSchema(schema4, _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(schema3, key, _validateSchema = this.opts.validateSchema) {
-        this.addSchema(schema3, key, true, _validateSchema);
+      addMetaSchema(schema4, key, _validateSchema = this.opts.validateSchema) {
+        this.addSchema(schema4, key, true, _validateSchema);
         return this;
       }
       //  Validate schema against its meta-schema
-      validateSchema(schema3, throwOrLogError) {
-        if (typeof schema3 == "boolean")
+      validateSchema(schema4, throwOrLogError) {
+        if (typeof schema4 == "boolean")
           return true;
         let $schema;
-        $schema = schema3.$schema;
+        $schema = schema4.$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, schema3);
+        const valid = this.validate($schema, schema4);
         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 schema3 = keywords[key];
-            if ($data && schema3)
-              keywords[key] = schemaOrData(schema3);
+            const schema4 = keywords[key];
+            if ($data && schema4)
+              keywords[key] = schemaOrData(schema4);
           }
         }
         return metaSchema;
@@ -4384,23 +4384,23 @@ var require_core = __commonJS({
           }
         }
       }
-      _addSchema(schema3, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+      _addSchema(schema4, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
         let id;
         const { schemaId } = this.opts;
-        if (typeof schema3 == "object") {
-          id = schema3[schemaId];
+        if (typeof schema4 == "object") {
+          id = schema4[schemaId];
         } else {
           if (this.opts.jtd)
             throw new Error("schema must be object");
-          else if (typeof schema3 != "boolean")
+          else if (typeof schema4 != "boolean")
             throw new Error("schema must be object or boolean");
         }
-        let sch = this._cache.get(schema3);
+        let sch = this._cache.get(schema4);
         if (sch !== void 0)
           return sch;
         baseId = (0, resolve_1.normalizeId)(id || baseId);
-        const localRefs = resolve_1.getSchemaRefs.call(this, schema3, baseId);
-        sch = new compile_1.SchemaEnv({ schema: schema3, schemaId, meta: meta3, baseId, localRefs });
+        const localRefs = resolve_1.getSchemaRefs.call(this, schema4, baseId);
+        sch = new compile_1.SchemaEnv({ schema: schema4, 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(schema3, true);
+          this.validateSchema(schema4, 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(schema3) {
-      return { anyOf: [schema3, $dataRef] };
+    function schemaOrData(schema4) {
+      return { anyOf: [schema4, $dataRef] };
     }
   }
 });
@@ -4863,7 +4863,7 @@ var require_pattern = __commonJS({
       $data: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, data, $data, schema: schema3, schemaCode, it } = cxt;
+        const { gen: gen2, data, $data, schema: schema4, 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, schema3);
+          const regExp = (0, code_1.usePattern)(cxt, schema4);
           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: schema3, schemaCode, data, $data, it } = cxt;
+        const { gen: gen2, schema: schema4, schemaCode, data, $data, it } = cxt;
         const { opts } = it;
-        if (!$data && schema3.length === 0)
+        if (!$data && schema4.length === 0)
           return;
-        const useLoop = schema3.length >= opts.loopRequired;
+        const useLoop = schema4.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 schema3) {
+          for (const requiredKey of schema4) {
             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 schema3) {
+            for (const prop of schema4) {
               (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, schema3, missing));
+            gen2.if((0, code_1.checkMissingProp)(cxt, schema4, 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: schema3, parentSchema, schemaCode, it } = cxt;
-        if (!$data && !schema3)
+        const { gen: gen2, data, $data, schema: schema4, parentSchema, schemaCode, it } = cxt;
+        if (!$data && !schema4)
           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: schema3 } = cxt;
-        if ($data || schema3 && typeof schema3 == "object") {
+        const { gen: gen2, data, $data, schemaCode, schema: schema4 } = cxt;
+        if ($data || schema4 && typeof schema4 == "object") {
           cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen2, equal_1.default)}(${data}, ${schemaCode})`);
         } else {
-          cxt.fail((0, codegen_1._)`${schema3} !== ${data}`);
+          cxt.fail((0, codegen_1._)`${schema4} !== ${data}`);
         }
       }
     };
@@ -5146,10 +5146,10 @@ var require_enum = __commonJS({
       $data: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, data, $data, schema: schema3, schemaCode, it } = cxt;
-        if (!$data && schema3.length === 0)
+        const { gen: gen2, data, $data, schema: schema4, schemaCode, it } = cxt;
+        if (!$data && schema4.length === 0)
           throw new Error("enum must have non-empty array");
-        const useLoop = schema3.length >= it.opts.loopEnum;
+        const useLoop = schema4.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(schema3))
+          if (!Array.isArray(schema4))
             throw new Error("ajv implementation error");
           const vSchema = gen2.const("vSchema", schemaCode);
-          valid = (0, codegen_1.or)(...schema3.map((_x, i2) => equalCode(vSchema, i2)));
+          valid = (0, codegen_1.or)(...schema4.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 = schema3[i2];
+          const sch = schema4[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: schema3, data, keyword, it } = cxt;
+      const { gen: gen2, schema: schema4, data, keyword, it } = cxt;
       it.items = true;
       const len = gen2.const("len", (0, codegen_1._)`${data}.length`);
-      if (schema3 === false) {
+      if (schema4 === false) {
         cxt.setParams({ len: items.length });
         cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
-      } else if (typeof schema3 == "object" && !(0, util_1.alwaysValidSchema)(it, schema3)) {
+      } else if (typeof schema4 == "object" && !(0, util_1.alwaysValidSchema)(it, schema4)) {
         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: schema3, it } = cxt;
-        if (Array.isArray(schema3))
-          return validateTuple(cxt, "additionalItems", schema3);
+        const { schema: schema4, it } = cxt;
+        if (Array.isArray(schema4))
+          return validateTuple(cxt, "additionalItems", schema4);
         it.items = true;
-        if ((0, util_1.alwaysValidSchema)(it, schema3))
+        if ((0, util_1.alwaysValidSchema)(it, schema4))
           return;
         cxt.ok((0, code_1.validateArray)(cxt));
       }
@@ -5362,10 +5362,10 @@ var require_items2020 = __commonJS({
       before: "uniqueItems",
       error: error51,
       code(cxt) {
-        const { schema: schema3, parentSchema, it } = cxt;
+        const { schema: schema4, parentSchema, it } = cxt;
         const { prefixItems } = parentSchema;
         it.items = true;
-        if ((0, util_1.alwaysValidSchema)(it, schema3))
+        if ((0, util_1.alwaysValidSchema)(it, schema4))
           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: schema3, parentSchema, data, it } = cxt;
+        const { gen: gen2, schema: schema4, 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, schema3)) {
+        if ((0, util_1.alwaysValidSchema)(it, schema4)) {
           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: schema3 }) {
+    function splitDependencies({ schema: schema4 }) {
       const propertyDeps = {};
       const schemaDeps = {};
-      for (const key in schema3) {
+      for (const key in schema4) {
         if (key === "__proto__")
           continue;
-        const deps = Array.isArray(schema3[key]) ? propertyDeps : schemaDeps;
-        deps[key] = schema3[key];
+        const deps = Array.isArray(schema4[key]) ? propertyDeps : schemaDeps;
+        deps[key] = schema4[key];
       }
       return [propertyDeps, schemaDeps];
     }
@@ -5582,8 +5582,8 @@ var require_propertyNames = __commonJS({
       schemaType: ["object", "boolean"],
       error: error51,
       code(cxt) {
-        const { gen: gen2, schema: schema3, data, it } = cxt;
-        if ((0, util_1.alwaysValidSchema)(it, schema3))
+        const { gen: gen2, schema: schema4, data, it } = cxt;
+        if ((0, util_1.alwaysValidSchema)(it, schema4))
           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: schema3, parentSchema, data, errsCount, it } = cxt;
+        const { gen: gen2, schema: schema4, 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, schema3))
+        if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema4))
           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 && schema3 === false) {
+          if (opts.removeAdditional === "all" || opts.removeAdditional && schema4 === false) {
             deleteAdditional(key);
             return;
           }
-          if (schema3 === false) {
+          if (schema4 === false) {
             cxt.setParams({ additionalProperty: key });
             cxt.error();
             if (!allErrors)
               gen2.break();
             return;
           }
-          if (typeof schema3 == "object" && !(0, util_1.alwaysValidSchema)(it, schema3)) {
+          if (typeof schema4 == "object" && !(0, util_1.alwaysValidSchema)(it, schema4)) {
             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: schema3, parentSchema, data, it } = cxt;
+        const { gen: gen2, schema: schema4, 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)(schema3);
+        const allProps = (0, code_1.allSchemaProperties)(schema4);
         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, schema3[p]));
+        const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema4[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 && schema3[prop].default !== void 0;
+          return it.opts.useDefaults && !it.compositeRule && schema4[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: schema3, data, parentSchema, it } = cxt;
+        const { gen: gen2, schema: schema4, data, parentSchema, it } = cxt;
         const { opts } = it;
-        const patterns = (0, code_1.allSchemaProperties)(schema3);
-        const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema3[p]));
+        const patterns = (0, code_1.allSchemaProperties)(schema4);
+        const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema4[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: schema3, it } = cxt;
-        if ((0, util_1.alwaysValidSchema)(it, schema3)) {
+        const { gen: gen2, schema: schema4, it } = cxt;
+        if ((0, util_1.alwaysValidSchema)(it, schema4)) {
           cxt.fail();
           return;
         }
@@ -5911,12 +5911,12 @@ var require_oneOf = __commonJS({
       trackErrors: true,
       error: error51,
       code(cxt) {
-        const { gen: gen2, schema: schema3, parentSchema, it } = cxt;
-        if (!Array.isArray(schema3))
+        const { gen: gen2, schema: schema4, parentSchema, it } = cxt;
+        if (!Array.isArray(schema4))
           throw new Error("ajv implementation error");
         if (it.opts.discriminator && parentSchema.discriminator)
           return;
-        const schArr = schema3;
+        const schArr = schema4;
         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: schema3, it } = cxt;
-        if (!Array.isArray(schema3))
+        const { gen: gen2, schema: schema4, it } = cxt;
+        if (!Array.isArray(schema4))
           throw new Error("ajv implementation error");
         const valid = gen2.name("valid");
-        schema3.forEach((sch, i2) => {
+        schema4.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 schema3 = it.schema[keyword];
-      return schema3 !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema3);
+      const schema4 = it.schema[keyword];
+      return schema4 !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema4);
     }
     exports.default = def;
   }
@@ -6131,7 +6131,7 @@ var require_format = __commonJS({
       $data: true,
       error: error51,
       code(cxt, ruleType) {
-        const { gen: gen2, data, $data, schema: schema3, schemaCode, it } = cxt;
+        const { gen: gen2, data, $data, schema: schema4, 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[schema3];
+          const formatDef = self.formats[schema4];
           if (!formatDef) {
             unknownFormat();
             return;
@@ -6178,12 +6178,12 @@ var require_format = __commonJS({
             }
             throw new Error(unknownMsg());
             function unknownMsg() {
-              return `unknown format "${schema3}" ignored in schema at path "${errSchemaPath}"`;
+              return `unknown format "${schema4}" 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)(schema3)}` : void 0;
-            const fmt = gen2.scopeValue("formats", { key: schema3, 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)(schema4)}` : void 0;
+            const fmt = gen2.scopeValue("formats", { key: schema4, 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: schema3, parentSchema, it } = cxt;
+        const { gen: gen2, data, schema: schema4, parentSchema, it } = cxt;
         const { oneOf } = parentSchema;
         if (!it.opts.discriminator) {
           throw new Error("discriminator: requires discriminator option");
         }
-        const tagName = schema3.propertyName;
+        const tagName = schema4.propertyName;
         if (typeof tagName != "string")
           throw new Error("discriminator: requires propertyName");
-        if (schema3.mapping)
+        if (schema4.mapping)
           throw new Error("discriminator: mapping is not supported");
         if (!oneOf)
           throw new Error("discriminator: requires oneOf keyword");
@@ -6606,6 +6606,66 @@ var require_ajv = __commonJS({
   }
 });
 
+// src/cli-error.ts
+var CliAuthorityError, CliProductionUnavailableError, BrowserOpenError, PUBLIC_RECOVERY_COMMAND, CliRecoveryBlockedError, CliSkillSourceError, CliSkillPublicationError;
+var init_cli_error = __esm({
+  "src/cli-error.ts"() {
+    "use strict";
+    CliAuthorityError = class extends Error {
+      code = "MCP_CLI_WALLET_MISMATCH";
+      constructor(code = "MCP_CLI_WALLET_MISMATCH") {
+        super(code);
+        this.name = "CliAuthorityError";
+      }
+    };
+    CliProductionUnavailableError = class extends Error {
+      code = "PRODUCTION_NOT_AVAILABLE";
+      constructor() {
+        super("PRODUCTION_NOT_AVAILABLE");
+        this.name = "CliProductionUnavailableError";
+      }
+    };
+    BrowserOpenError = class extends Error {
+      code = "BROWSER_OPEN_FAILED";
+      constructor() {
+        super("BROWSER_OPEN_FAILED");
+        this.name = "BrowserOpenError";
+      }
+    };
+    PUBLIC_RECOVERY_COMMAND = /^(?:finch purchase (?:submit|recover-approval) [0-9a-f-]+(?: --transaction-hash 0x[0-9a-f]{64})?|finch task recover [0-9a-f-]+ (?:publish|award|reclaim)|finch skill recover (?:publication|intent) [0-9a-f]{64})$/u;
+    CliRecoveryBlockedError = class extends Error {
+      code = "CLI_RECOVERY_BLOCKED";
+      recoveryCommands;
+      constructor(recoveryCommands) {
+        if (recoveryCommands.length === 0 || recoveryCommands.some((command) => !PUBLIC_RECOVERY_COMMAND.test(command))) {
+          throw new TypeError("Recovery commands must contain only supported public recovery syntax.");
+        }
+        super("CLI_RECOVERY_BLOCKED");
+        this.name = "CliRecoveryBlockedError";
+        this.recoveryCommands = Object.freeze([...new Set(recoveryCommands)].sort());
+      }
+    };
+    CliSkillSourceError = class extends TypeError {
+      constructor(diagnosticCode, details, message) {
+        super(message);
+        this.diagnosticCode = diagnosticCode;
+        this.details = details;
+        this.name = "CliSkillSourceError";
+      }
+      diagnosticCode;
+      details;
+    };
+    CliSkillPublicationError = class extends Error {
+      constructor(diagnostic, cause) {
+        super(cause instanceof Error ? cause.message : "Skill publication failed.", { cause });
+        this.diagnostic = diagnostic;
+        this.name = "CliSkillPublicationError";
+      }
+      diagnostic;
+    };
+  }
+});
+
 // ../../packages/skill-content/src/crypto.ts
 async function sha256Hex(bytes) {
   const digest = await crypto.subtle.digest("SHA-256", bytes);
@@ -10424,8 +10484,31 @@ function assertSkillPath(path2) {
     throw new RangeError(`Unsafe Skill package path: ${path2}`);
   }
 }
+function diagnosticPath(bytes) {
+  try {
+    const path2 = new TextDecoder("utf-8", { fatal: true }).decode(bytes).replace(/\/$/u, "");
+    assertSkillPath(path2);
+    return { path: path2 };
+  } catch {
+    return {};
+  }
+}
 function importZip(bytes, maxEntries = MAX_SKILL_IMPORT_FILES) {
-  if (bytes.length < 22 || bytes.length > MAX_SKILL_IMPORT_BYTES) throw new RangeError("ZIP import size exceeds the 10 MiB limit or is truncated.");
+  try {
+    return readZip(bytes, maxEntries);
+  } catch (error51) {
+    if (error51 instanceof SkillZipSymlinkError || error51 instanceof SkillZipInvalidError) throw error51;
+    if (error51 instanceof RangeError || error51 instanceof TypeError) throw new SkillZipInvalidError(error51.message);
+    throw error51;
+  }
+}
+function readZip(bytes, maxEntries) {
+  if (bytes.length > MAX_SKILL_IMPORT_BYTES) throw new SkillZipInvalidError(
+    "ZIP import size exceeds the 10 MiB limit.",
+    "archive_too_large",
+    { actualBytes: bytes.length, maxBytes: MAX_SKILL_IMPORT_BYTES, sizeBasis: "archive" }
+  );
+  if (bytes.length < 22) throw new SkillZipInvalidError("ZIP import is truncated.");
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const u162 = (at) => view.getUint16(at, true);
   const u322 = (at) => view.getUint32(at, true);
@@ -10459,21 +10542,36 @@ function importZip(bytes, maxEntries = MAX_SKILL_IMPORT_FILES) {
       throw new RangeError("ZIP entry is truncated, encrypted, or uses unsupported compression.");
     }
     const nameBytes = bytes.subarray(cursor + 46, cursor + 46 + nameSize);
-    if (!(flags & 2048) && nameBytes.some((value) => value > 127)) throw new RangeError("ZIP paths must declare UTF-8 for non-ASCII names.");
-    const name = new TextDecoder("utf-8", { fatal: true }).decode(nameBytes);
+    if (!(flags & 2048) && nameBytes.some((value) => value > 127)) throw new SkillZipInvalidError(
+      "ZIP paths must declare UTF-8 for non-ASCII names.",
+      "utf8_flag_missing",
+      diagnosticPath(nameBytes)
+    );
+    let name;
+    try {
+      name = new TextDecoder("utf-8", { fatal: true }).decode(nameBytes);
+    } catch {
+      throw new SkillZipInvalidError("ZIP path bytes must be valid UTF-8.", "filename_encoding_invalid");
+    }
     const directory = name.endsWith("/");
     const path2 = directory ? name.slice(0, -1) : name;
     assertSkillPath(path2);
     if (names.has(path2)) throw new RangeError(`Duplicate ZIP path: ${path2}`);
     names.add(path2);
     const unixType = u322(cursor + 38) >>> 16 & 61440;
+    if (u162(cursor + 4) >>> 8 === 3 && unixType === 40960) throw new SkillZipSymlinkError(path2);
     if (u162(cursor + 4) >>> 8 === 3 && unixType !== 0 && unixType !== (directory ? 16384 : 32768)) {
       throw new RangeError(`ZIP path must be a regular file or directory, not a symbolic link: ${path2}`);
     }
     total += expanded;
-    if (total > MAX_SKILL_IMPORT_BYTES || size5 > MAX_SKILL_IMPORT_BYTES || directory && expanded !== 0) {
-      throw new RangeError("ZIP expanded content exceeds the 10 MiB limit or declares directory content.");
-    }
+    if (total > MAX_SKILL_IMPORT_BYTES) throw new SkillZipInvalidError(
+      "ZIP expanded content exceeds the 10 MiB limit.",
+      "expanded_content_too_large",
+      { actualBytes: total, maxBytes: MAX_SKILL_IMPORT_BYTES, sizeBasis: "declared_expanded", path: path2 }
+    );
+    if (size5 > MAX_SKILL_IMPORT_BYTES || directory && expanded !== 0) throw new SkillZipInvalidError(
+      "ZIP entry exceeds the compressed size limit or declares directory content."
+    );
     const local = u322(cursor + 42);
     if (local + 30 > central || u322(local) !== 67324752 || u162(local + 6) !== flags || u162(local + 8) !== method2) {
       throw new RangeError("ZIP local header does not match its directory.");
@@ -10514,7 +10612,11 @@ function importZip(bytes, maxEntries = MAX_SKILL_IMPORT_FILES) {
         written += chunk.length;
       });
       for (let at = 0; at < compressed.length; at += 256) {
-        inflate.push(compressed.subarray(at, at + 256), at + 256 >= compressed.length);
+        try {
+          inflate.push(compressed.subarray(at, at + 256), at + 256 >= compressed.length);
+        } catch {
+          throw new SkillZipInvalidError("ZIP DEFLATE stream is invalid.");
+        }
       }
       if (written !== entry2.expanded) throw new RangeError("ZIP expanded size does not match its directory.");
     }
@@ -10522,7 +10624,7 @@ function importZip(bytes, maxEntries = MAX_SKILL_IMPORT_FILES) {
     return { path: entry2.path, content };
   });
 }
-var MAX_SKILL_IMPORT_BYTES, MAX_SKILL_IMPORT_FILES;
+var MAX_SKILL_IMPORT_BYTES, MAX_SKILL_IMPORT_FILES, SkillZipSymlinkError, SkillZipInvalidError;
 var init_zip_import = __esm({
   "../../packages/skill-content/src/zip-import.ts"() {
     "use strict";
@@ -10530,10 +10632,32 @@ var init_zip_import = __esm({
     init_zip();
     MAX_SKILL_IMPORT_BYTES = 10 * 1024 * 1024;
     MAX_SKILL_IMPORT_FILES = 1024;
+    SkillZipSymlinkError = class extends RangeError {
+      constructor(path2) {
+        super(`ZIP path must be a regular file or directory, not a symbolic link: ${path2}`);
+        this.path = path2;
+        this.name = "SkillZipSymlinkError";
+      }
+      path;
+    };
+    SkillZipInvalidError = class extends RangeError {
+      constructor(message, reason = "invalid_archive", details = {}) {
+        super(message);
+        this.reason = reason;
+        this.details = details;
+        this.name = "SkillZipInvalidError";
+      }
+      reason;
+      details;
+    };
   }
 });
 
 // ../../packages/skill-content/src/packaging.ts
+function isExcludedSkillPath(path2) {
+  const parts = path2.replaceAll("\\", "/").split("/").filter(Boolean).map((part) => part.toLowerCase());
+  return parts.some((part) => EXCLUDED_PATH_PARTS.has(part)) || EXCLUDED_FILENAMES.some((pattern) => pattern.test(parts.at(-1) ?? ""));
+}
 function filterPublishableFiles(files) {
   const included = [];
   const excluded = [];
@@ -10543,9 +10667,7 @@ function filterPublishableFiles(files) {
     if (names.has(file2.path)) throw new RangeError(`Duplicate Skill package path: ${file2.path}`);
     names.add(file2.path);
     const parts = file2.path.replaceAll("\\", "/").split("/").filter(Boolean);
-    const foldedParts = parts.map((part) => part.toLowerCase());
-    const filename = foldedParts.at(-1) ?? "";
-    const blocked = foldedParts.some((part) => EXCLUDED_PATH_PARTS.has(part)) || EXCLUDED_FILENAMES.some((pattern) => pattern.test(filename));
+    const blocked = isExcludedSkillPath(file2.path);
     if (blocked) excluded.push(file2.path);
     else included.push({ path: parts.join("/"), content: file2.content });
   }
@@ -10561,7 +10683,7 @@ function packageRoot(files) {
   return files.every((file2) => file2.path.startsWith(prefix)) ? prefix : "";
 }
 function locatePrimaryDocument(files) {
-  if (files.length === 0) throw new RangeError("The Skill package contains no primary Markdown document.");
+  if (files.length === 0) throw new SkillPrimaryDocumentError("The Skill package contains no primary Markdown document.");
   const root = packageRoot(files);
   const atRoot = new Map(files.filter((file2) => file2.path.startsWith(root) && !file2.path.slice(root.length).includes("/")).map((file2) => [file2.path.slice(root.length), file2]));
   for (const candidate of ["SKILL.md", "README.md"]) {
@@ -10570,7 +10692,7 @@ function locatePrimaryDocument(files) {
   }
   const markdown = [...atRoot.entries()].filter(([name]) => /\.(?:md|markdown)$/iu.test(name));
   if (markdown.length === 1) return markdown[0][1];
-  throw new RangeError(
+  throw new SkillPrimaryDocumentError(
     "A Skill must carry one primary Markdown document: add SKILL.md or README.md at the package root, or keep exactly one root-level Markdown file."
   );
 }
@@ -10579,7 +10701,7 @@ async function primaryDocument(files) {
   try {
     new TextDecoder("utf-8", { fatal: true }).decode(found.content);
   } catch {
-    throw new RangeError(`The primary Markdown document ${found.path} is not valid UTF-8.`);
+    throw new SkillPrimaryDocumentError(`The primary Markdown document ${found.path} is not valid UTF-8.`);
   }
   return { path: found.path, mdHash: await sha256Hex(found.content) };
 }
@@ -10592,7 +10714,7 @@ async function archivePackage(files, buildArchive) {
 async function prepareRootPackage(files, buildArchive) {
   return { ...await archivePackage(files, buildArchive), contentKeyBase64: toBase64(generateContentKey()) };
 }
-var EXCLUDED_PATH_PARTS, EXCLUDED_FILENAMES;
+var EXCLUDED_PATH_PARTS, EXCLUDED_FILENAMES, SkillPrimaryDocumentError;
 var init_packaging = __esm({
   "../../packages/skill-content/src/packaging.ts"() {
     "use strict";
@@ -10600,6 +10722,8 @@ var init_packaging = __esm({
     init_zip_import();
     EXCLUDED_PATH_PARTS = /* @__PURE__ */ new Set([".git", "node_modules", ".next", ".nuxt", ".svelte-kit", ".cache", ".turbo", "coverage", "dist", "build", "out", "target", "__pycache__", ".venv", "venv", ".aws", ".ssh", "__macosx"]);
     EXCLUDED_FILENAMES = [/^\.env($|\.)/u, /^\.(npmrc|pypirc|netrc|ds_store)$/u, /^\._/u, /^id_(rsa|ed25519|ecdsa)$/u, /\.(pem|p12|keystore|key)$/u];
+    SkillPrimaryDocumentError = class extends RangeError {
+    };
   }
 });
 
@@ -10697,7 +10821,7 @@ async function buildSkillRoot(input) {
     if (contentKey !== null) encrypted[file2.path] = { ciphertext: cid.toString(), plaintextHash: await sha256Hex(file2.content) };
   }
   if (!md) throw new RangeError("SkillRoot primary document is missing.");
-  const manifest3 = jsonBytes({
+  const manifest4 = jsonBytes({
     schemaVersion: "1.0",
     name: input.name,
     skillVersion: String(input.version),
@@ -10706,7 +10830,7 @@ async function buildSkillRoot(input) {
   });
   const root = {
     md,
-    manifest: await put(manifest3),
+    manifest: await put(manifest4),
     entry: { ...md, profile: ENTRY_PROFILE },
     ...Object.keys(files).length ? { files } : {},
     ...input.previousHash === void 0 ? {} : { prev: hashCID(input.previousHash, 113) }
@@ -10720,7 +10844,7 @@ async function buildSkillRoot(input) {
   const proof = {
     scheme: SKILL_ROOT_SCHEME,
     root: toBase64(rootBytes),
-    manifest: toBase64(manifest3),
+    manifest: toBase64(manifest4),
     ...confidentiality === void 0 ? {} : { confidentiality: toBase64(confidentiality) }
   };
   const packageHash = await sha256Hex(rootBytes);
@@ -10757,8 +10881,8 @@ async function verifySkillRootProof(proof, packageHash, version6, previousHash)
   const paths = Object.keys(refs);
   if (paths.length > MAX_SKILL_IMPORT_FILES || paths.some((name) => paths.some((other) => other.startsWith(`${name}/`)))) throw new RangeError("SkillRoot file paths exceed limits or conflict.");
   if (!refs[executable.path]?.equals(executable.cid)) throw new RangeError("SkillRoot entrypoint is outside the committed files.");
-  const manifest3 = await authenticatedJSON(proof.manifest, CID.asCID(root.manifest));
-  if (manifest3.schemaVersion !== "1.0" || typeof manifest3.name !== "string" || typeof manifest3.summary !== "string" || manifest3.skillVersion !== String(version6) || manifest3.entrypoint !== executable.path) throw new RangeError("Invalid SkillRoot manifest.");
+  const manifest4 = await authenticatedJSON(proof.manifest, CID.asCID(root.manifest));
+  if (manifest4.schemaVersion !== "1.0" || typeof manifest4.name !== "string" || typeof manifest4.summary !== "string" || manifest4.skillVersion !== String(version6) || manifest4.entrypoint !== executable.path) throw new RangeError("Invalid SkillRoot manifest.");
   const hashes = /* @__PURE__ */ Object.create(null);
   if (root.confidentiality === void 0) {
     if (proof.confidentiality !== void 0) throw new RangeError("Public SkillRoot declares encrypted transport.");
@@ -10781,8 +10905,8 @@ async function verifySkillRootProof(proof, packageHash, version6, previousHash)
     mdHash: hashes[md.path],
     primaryPath: md.path,
     plaintext: root.confidentiality === void 0,
-    name: manifest3.name,
-    summary: manifest3.summary,
+    name: manifest4.name,
+    summary: manifest4.summary,
     fileHashes: hashes
   };
 }
@@ -11026,8 +11150,8 @@ function buildManifest(entries, presentation, documents) {
     ...normalizedDocuments === void 0 ? {} : { documents: normalizedDocuments }
   };
 }
-function serializeManifest(manifest3) {
-  return new TextEncoder().encode(JSON.stringify(manifest3));
+function serializeManifest(manifest4) {
+  return new TextEncoder().encode(JSON.stringify(manifest4));
 }
 function parseManifest(bytes) {
   let value;
@@ -11049,21 +11173,22 @@ function parseManifest(bytes) {
     return null;
   }
 }
-function packageForVersion(manifest3, version6) {
-  return manifest3.versions.find((entry2) => entry2.version === version6) ?? null;
+function packageForVersion(manifest4, version6) {
+  return manifest4.versions.find((entry2) => entry2.version === version6) ?? null;
 }
-function withVersion(manifest3, entry2) {
-  return buildManifest([...manifest3?.versions ?? [], entry2], manifest3?.presentation, manifest3?.documents);
+function withVersion(manifest4, entry2) {
+  return buildManifest([...manifest4?.versions ?? [], entry2], manifest4?.presentation, manifest4?.documents);
 }
-function withPresentation(manifest3, presentation) {
-  return buildManifest(manifest3.versions, presentation, manifest3.documents);
+function withPresentation(manifest4, presentation) {
+  return buildManifest(manifest4.versions, presentation, manifest4.documents);
 }
-var 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;
 var init_manifest = __esm({
   "../../packages/skill-content/src/manifest.ts"() {
     "use strict";
     init_static_detail();
     init_skill_root();
+    MAX_SKILL_MANIFEST_BYTES = 3 * 1024 * 1024;
     SKILL_MANIFEST_SCHEME = "finch-skill-versions-v1";
     SKILL_DETAIL_KINDS = ["information", "instruction", "benchmark", "showcase"];
     DETAIL_MEDIA_TYPES = /* @__PURE__ */ new Map([
@@ -11894,7 +12019,7 @@ function decodeAgentCliMcpAuthorizationRequest(requestToken) {
   }
   return requestUrl;
 }
-var booleanSchema, timestampSchema, agentCliMcpAuthorizationRequestTokenPrefix, agentCliMcpAuthorizationRequestMaximumUrlBytes, agentCliMcpAuthorizationRequestMaximumPayloadCharacters, base64UrlAlphabet, AGENT_CLI_MCP_AUTHORIZATION_REQUEST_TOKEN, LOCAL_SIGNING_ABANDON_CONTRACT, localSigningAbandonReceiptSchema, authorizationBase, browserAuthorizationBase, signingStatusSchema, agentCliSigningIntentSchema, browserPublicationSigningIntentSchema, agentCliSigningApproveRequestSchema, agentCliSigningDenyRequestSchema, agentCliSigningDecisionResponseSchema, agentCliCredentialClaimSchema, agentCliCredentialSetupSchema, agentCliCredentialFulfillmentReceiptSchema, CLI_AGENTON_CREDENTIAL_MATERIAL_DOWNLOAD_CONTRACT, AGENT_CLI_V1_HTTP_OPERATIONS, AGENT_CLI_OUTPUT_CONTRACT, agentCliErrorEnvelopeSchema, cliHttpErrorCodes, agentCliLocalErrorCodes, nullableCliStringSchema, cliLocalErrorEnvelopeSchema, AGENT_CLI_RECOVERY_CONTRACT;
+var booleanSchema, timestampSchema, agentCliMcpAuthorizationRequestTokenPrefix, agentCliMcpAuthorizationRequestMaximumUrlBytes, agentCliMcpAuthorizationRequestMaximumPayloadCharacters, base64UrlAlphabet, AGENT_CLI_MCP_AUTHORIZATION_REQUEST_TOKEN, LOCAL_SIGNING_ABANDON_CONTRACT, localSigningAbandonReceiptSchema, authorizationBase, browserAuthorizationBase, signingStatusSchema, agentCliSigningIntentSchema, browserPublicationSigningIntentSchema, browserPurchaseSigningIntentSchema, agentCliSigningApproveRequestSchema, agentCliSigningDenyRequestSchema, agentCliSigningDecisionResponseSchema, agentCliCredentialClaimSchema, agentCliCredentialSetupSchema, agentCliCredentialFulfillmentReceiptSchema, CLI_AGENTON_CREDENTIAL_MATERIAL_DOWNLOAD_CONTRACT, AGENT_CLI_V1_HTTP_OPERATIONS, AGENT_CLI_OUTPUT_CONTRACT, agentCliErrorEnvelopeSchema, cliHttpErrorCodes, agentCliLocalErrorCodes, nullableCliStringSchema, cliLocalErrorEnvelopeSchema, AGENT_CLI_RECOVERY_CONTRACT;
 var init_agent_cli = __esm({
   "../../packages/agent-market-contracts/src/v1/agent-cli.ts"() {
     "use strict";
@@ -12003,6 +12128,20 @@ var init_agent_cli = __esm({
       approvable: booleanSchema,
       deniable: booleanSchema
     });
+    browserPurchaseSigningIntentSchema = strictObjectSchema({
+      signingRequestId: canonicalUuidSchema,
+      operationId: canonicalUuidSchema,
+      actionKind: { const: "local_purchase" },
+      status: signingStatusSchema,
+      authorization: strictObjectSchema({
+        ...browserAuthorizationBase,
+        actionKind: { const: "local_purchase" },
+        authorizedMethod: { const: "finch.agent_market.local_purchase.v1" }
+      }),
+      plan: localPurchasePlanV1Schema,
+      approvable: booleanSchema,
+      deniable: booleanSchema
+    });
     agentCliSigningApproveRequestSchema = strictObjectSchema({
       signature: { type: "string", pattern: "^0x[0-9a-fA-F]{130}$" }
     });
@@ -12693,9 +12832,6 @@ function parseAgentMarketAuthorization(input) {
   if (candidate.audience !== "agent_cli" && candidate.audience !== "web" || candidate.nativeValueAtomic !== "0") {
     return reject4("Authorization must target agent_cli or web with zero native value.");
   }
-  if (candidate.audience === "web" && candidate.actionKind !== "publication") {
-    return reject4("Browser authorization is restricted to publication.");
-  }
   if (typeof candidate.walletAddress !== "string" || !EVM_ADDRESS_PATTERN2.test(candidate.walletAddress)) {
     return reject4("walletAddress must be a lowercase EVM address.");
   }
@@ -16234,18 +16370,18 @@ var init_operations = __esm({
 });
 
 // ../../packages/agent-market-contracts/src/v1/mcp.ts
-function bodyVariants(schema3) {
-  if (schema3 === void 0) return [{}];
-  const candidate = schema3;
+function bodyVariants(schema4) {
+  if (schema4 === void 0) return [{}];
+  const candidate = schema4;
   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, schema3] of Object.entries(properties ?? {})) {
+    for (const [field, schema4] of Object.entries(properties ?? {})) {
       const alternatives = candidates.get(field) ?? /* @__PURE__ */ new Map();
-      alternatives.set(JSON.stringify(schema3), schema3);
+      alternatives.set(JSON.stringify(schema4), schema4);
       candidates.set(field, alternatives);
     }
   }
@@ -16351,12 +16487,12 @@ var init_mcp = __esm({
 });
 
 // ../../packages/agent-market-contracts/src/v1/openapi.ts
-function mediaTypeContent(contentType, schema3) {
-  return { content: { [contentType]: { schema: schema3 } } };
+function mediaTypeContent(contentType, schema4) {
+  return { content: { [contentType]: { schema: schema4 } } };
 }
 function responseHeaderObjects(schemas) {
   return Object.fromEntries(
-    Object.entries(schemas).map(([name, schema3]) => [name, { schema: schema3 }])
+    Object.entries(schemas).map(([name, schema4]) => [name, { schema: schema4 }])
   );
 }
 function operationParameters(http3) {
@@ -16366,16 +16502,16 @@ function operationParameters(http3) {
     required: true,
     schema: canonicalUuidSchema
   }));
-  for (const [name, schema3] of Object.entries(http3.querySchema?.properties ?? {})) {
+  for (const [name, schema4] of Object.entries(http3.querySchema?.properties ?? {})) {
     parameters.push({
       name,
       in: "query",
       required: http3.querySchema?.required?.includes(name) ?? false,
-      schema: schema3
+      schema: schema4
     });
   }
-  for (const [name, schema3] of Object.entries(http3.requestHeaders ?? {})) {
-    parameters.push({ name, in: "header", required: true, schema: schema3 });
+  for (const [name, schema4] of Object.entries(http3.requestHeaders ?? {})) {
+    parameters.push({ name, in: "header", required: true, schema: schema4 });
   }
   if (http3.idempotencyRequired) parameters.push({ $ref: "#/components/parameters/IdempotencyKey" });
   if (http3.ifMatchRequired) parameters.push({ $ref: "#/components/parameters/IfMatch" });
@@ -16909,24 +17045,24 @@ var init_schemas = __esm({
 function operation2(value) {
   return Object.freeze(value);
 }
-function schemaFields(schema3) {
-  if (schema3 === void 0) return {};
-  const shape = schema3;
+function schemaFields(schema4) {
+  if (schema4 === void 0) return {};
+  const shape = schema4;
   return Object.freeze(Object.assign(
     {},
     shape.properties ?? {},
     ...(shape.oneOf ?? []).map((variant) => schemaFields(variant))
   ));
 }
-function requiredFields(schema3) {
-  return schema3?.required ?? [];
+function requiredFields(schema4) {
+  return schema4?.required ?? [];
 }
 function inputSchema(fields, required4, body) {
-  const schema3 = strictObjectSchema2(fields, required4);
+  const schema4 = strictObjectSchema2(fields, required4);
   const variants = body?.oneOf ?? [];
-  if (variants.length === 0) return schema3;
+  if (variants.length === 0) return schema4;
   return Object.freeze({
-    ...schema3,
+    ...schema4,
     oneOf: variants.map((variant) => Object.freeze({ required: requiredFields(variant) }))
   });
 }
@@ -17229,8 +17365,8 @@ function mergeDefs(...defs) {
   }
   return Object.defineProperties({}, mergedDescriptors);
 }
-function cloneDef(schema3) {
-  return mergeDefs(schema3._zod.def);
+function cloneDef(schema4) {
+  return mergeDefs(schema4._zod.def);
 }
 function getElementAtPath(obj, path2) {
   if (!path2)
@@ -17371,14 +17507,14 @@ function optionalKeys(shape) {
     return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
   });
 }
-function pick(schema3, mask) {
-  const currDef = schema3._zod.def;
+function pick(schema4, mask) {
+  const currDef = schema4._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(schema3._zod.def, {
+  const def = mergeDefs(schema4._zod.def, {
     get shape() {
       const newShape = {};
       for (const key in mask) {
@@ -17394,18 +17530,18 @@ function pick(schema3, mask) {
     },
     checks: []
   });
-  return clone(schema3, def);
+  return clone(schema4, def);
 }
-function omit(schema3, mask) {
-  const currDef = schema3._zod.def;
+function omit(schema4, mask) {
+  const currDef = schema4._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(schema3._zod.def, {
+  const def = mergeDefs(schema4._zod.def, {
     get shape() {
-      const newShape = { ...schema3._zod.def.shape };
+      const newShape = { ...schema4._zod.def.shape };
       for (const key in mask) {
         if (!(key in currDef.shape)) {
           throw new Error(`Unrecognized key: "${key}"`);
@@ -17419,43 +17555,43 @@ function omit(schema3, mask) {
     },
     checks: []
   });
-  return clone(schema3, def);
+  return clone(schema4, def);
 }
-function extend(schema3, shape) {
+function extend(schema4, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema3._zod.def.checks;
+  const checks = schema4._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    const existingShape = schema3._zod.def.shape;
+    const existingShape = schema4._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(schema3._zod.def, {
+  const def = mergeDefs(schema4._zod.def, {
     get shape() {
-      const _shape = { ...schema3._zod.def.shape, ...shape };
+      const _shape = { ...schema4._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema3, def);
+  return clone(schema4, def);
 }
-function safeExtend(schema3, shape) {
+function safeExtend(schema4, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = mergeDefs(schema3._zod.def, {
+  const def = mergeDefs(schema4._zod.def, {
     get shape() {
-      const _shape = { ...schema3._zod.def.shape, ...shape };
+      const _shape = { ...schema4._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema3, def);
+  return clone(schema4, def);
 }
 function merge(a, b) {
   if (a._zod.def.checks?.length) {
@@ -17474,16 +17610,16 @@ function merge(a, b) {
   });
   return clone(a, def);
 }
-function partial(Class2, schema3, mask) {
-  const currDef = schema3._zod.def;
+function partial(Class2, schema4, mask) {
+  const currDef = schema4._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(schema3._zod.def, {
+  const def = mergeDefs(schema4._zod.def, {
     get shape() {
-      const oldShape = schema3._zod.def.shape;
+      const oldShape = schema4._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -17510,12 +17646,12 @@ function partial(Class2, schema3, mask) {
     },
     checks: []
   });
-  return clone(schema3, def);
+  return clone(schema4, def);
 }
-function required(Class2, schema3, mask) {
-  const def = mergeDefs(schema3._zod.def, {
+function required(Class2, schema4, mask) {
+  const def = mergeDefs(schema4._zod.def, {
     get shape() {
-      const oldShape = schema3._zod.def.shape;
+      const oldShape = schema4._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -17541,7 +17677,7 @@ function required(Class2, schema3, mask) {
       return shape;
     }
   });
-  return clone(schema3, def);
+  return clone(schema4, def);
 }
 function aborted(x2, startIndex = 0) {
   if (x2.aborted === true)
@@ -17921,9 +18057,9 @@ var init_parse = __esm({
     init_core();
     init_errors2();
     init_util();
-    _parse = (_Err) => (schema3, value, _ctx, _params) => {
+    _parse = (_Err) => (schema4, value, _ctx, _params) => {
       const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result2 = schema3._zod.run({ value, issues: [] }, ctx);
+      const result2 = schema4._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
@@ -17935,9 +18071,9 @@ var init_parse = __esm({
       return result2.value;
     };
     parse = /* @__PURE__ */ _parse($ZodRealError);
-    _parseAsync = (_Err) => async (schema3, value, _ctx, params) => {
+    _parseAsync = (_Err) => async (schema4, value, _ctx, params) => {
       const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-      let result2 = schema3._zod.run({ value, issues: [] }, ctx);
+      let result2 = schema4._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise)
         result2 = await result2;
       if (result2.issues.length) {
@@ -17948,9 +18084,9 @@ var init_parse = __esm({
       return result2.value;
     };
     parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
-    _safeParse = (_Err) => (schema3, value, _ctx) => {
+    _safeParse = (_Err) => (schema4, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result2 = schema3._zod.run({ value, issues: [] }, ctx);
+      const result2 = schema4._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
@@ -17960,9 +18096,9 @@ var init_parse = __esm({
       } : { success: true, data: result2.value };
     };
     safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-    _safeParseAsync = (_Err) => async (schema3, value, _ctx) => {
+    _safeParseAsync = (_Err) => async (schema4, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-      let result2 = schema3._zod.run({ value, issues: [] }, ctx);
+      let result2 = schema4._zod.run({ value, issues: [] }, ctx);
       if (result2 instanceof Promise)
         result2 = await result2;
       return result2.issues.length ? {
@@ -17971,40 +18107,40 @@ var init_parse = __esm({
       } : { success: true, data: result2.value };
     };
     safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-    _encode = (_Err) => (schema3, value, _ctx) => {
+    _encode = (_Err) => (schema4, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _parse(_Err)(schema3, value, ctx);
+      return _parse(_Err)(schema4, value, ctx);
     };
     encode5 = /* @__PURE__ */ _encode($ZodRealError);
-    _decode = (_Err) => (schema3, value, _ctx) => {
-      return _parse(_Err)(schema3, value, _ctx);
+    _decode = (_Err) => (schema4, value, _ctx) => {
+      return _parse(_Err)(schema4, value, _ctx);
     };
     decode7 = /* @__PURE__ */ _decode($ZodRealError);
-    _encodeAsync = (_Err) => async (schema3, value, _ctx) => {
+    _encodeAsync = (_Err) => async (schema4, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _parseAsync(_Err)(schema3, value, ctx);
+      return _parseAsync(_Err)(schema4, value, ctx);
     };
     encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
-    _decodeAsync = (_Err) => async (schema3, value, _ctx) => {
-      return _parseAsync(_Err)(schema3, value, _ctx);
+    _decodeAsync = (_Err) => async (schema4, value, _ctx) => {
+      return _parseAsync(_Err)(schema4, value, _ctx);
     };
     decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
-    _safeEncode = (_Err) => (schema3, value, _ctx) => {
+    _safeEncode = (_Err) => (schema4, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _safeParse(_Err)(schema3, value, ctx);
+      return _safeParse(_Err)(schema4, value, ctx);
     };
     safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
-    _safeDecode = (_Err) => (schema3, value, _ctx) => {
-      return _safeParse(_Err)(schema3, value, _ctx);
+    _safeDecode = (_Err) => (schema4, value, _ctx) => {
+      return _safeParse(_Err)(schema4, value, _ctx);
     };
     safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
-    _safeEncodeAsync = (_Err) => async (schema3, value, _ctx) => {
+    _safeEncodeAsync = (_Err) => async (schema4, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _safeParseAsync(_Err)(schema3, value, ctx);
+      return _safeParseAsync(_Err)(schema4, value, ctx);
     };
     safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
-    _safeDecodeAsync = (_Err) => async (schema3, value, _ctx) => {
-      return _safeParseAsync(_Err)(schema3, value, _ctx);
+    _safeDecodeAsync = (_Err) => async (schema4, value, _ctx) => {
+      return _safeParseAsync(_Err)(schema4, value, _ctx);
     };
     safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
   }
@@ -19893,9 +20029,9 @@ var init_schemas2 = __esm({
         for (const key of normalized.keys) {
           const id = ids[key];
           const k = esc(key);
-          const schema3 = shape[key];
-          const isOptionalIn = schema3?._zod?.optin === "optional";
-          const isOptionalOut = schema3?._zod?.optout === "optional";
+          const schema4 = shape[key];
+          const isOptionalIn = schema4?._zod?.optin === "optional";
+          const isOptionalOut = schema4?._zod?.optout === "optional";
           doc.write(`const ${id} = ${parseStr(key)};`);
           if (isOptionalIn && isOptionalOut) {
             doc.write(`
@@ -27225,11 +27361,11 @@ var init_registries = __esm({
         this._map = /* @__PURE__ */ new WeakMap();
         this._idmap = /* @__PURE__ */ new Map();
       }
-      add(schema3, ..._meta) {
+      add(schema4, ..._meta) {
         const meta3 = _meta[0];
-        this._map.set(schema3, meta3);
+        this._map.set(schema4, meta3);
         if (meta3 && typeof meta3 === "object" && "id" in meta3) {
-          this._idmap.set(meta3.id, schema3);
+          this._idmap.set(meta3.id, schema4);
         }
         return this;
       }
@@ -27238,26 +27374,26 @@ var init_registries = __esm({
         this._idmap = /* @__PURE__ */ new Map();
         return this;
       }
-      remove(schema3) {
-        const meta3 = this._map.get(schema3);
+      remove(schema4) {
+        const meta3 = this._map.get(schema4);
         if (meta3 && typeof meta3 === "object" && "id" in meta3) {
           this._idmap.delete(meta3.id);
         }
-        this._map.delete(schema3);
+        this._map.delete(schema4);
         return this;
       }
-      get(schema3) {
-        const p = schema3._zod.parent;
+      get(schema4) {
+        const p = schema4._zod.parent;
         if (p) {
           const pm = { ...this.get(p) ?? {} };
           delete pm.id;
-          const f = { ...pm, ...this._map.get(schema3) };
+          const f = { ...pm, ...this._map.get(schema4) };
           return Object.keys(f).length ? f : void 0;
         }
-        return this._map.get(schema3);
+        return this._map.get(schema4);
       }
-      has(schema3) {
-        return this._map.has(schema3);
+      has(schema4) {
+        return this._map.has(schema4);
       }
     };
     (_a3 = globalThis).__zod_globalRegistry ?? (_a3.__zod_globalRegistry = registry());
@@ -27902,11 +28038,11 @@ function _endsWith(suffix, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _property(property, schema3, params) {
+function _property(property, schema4, params) {
   return new $ZodCheckProperty({
     check: "property",
     property,
-    schema: schema3,
+    schema: schema4,
     ...normalizeParams(params)
   });
 }
@@ -28154,23 +28290,23 @@ function _promise(Class2, innerType) {
 function _custom(Class2, fn, _params) {
   const norm = normalizeParams(_params);
   norm.abort ?? (norm.abort = true);
-  const schema3 = new Class2({
+  const schema4 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...norm
   });
-  return schema3;
+  return schema4;
 }
 // @__NO_SIDE_EFFECTS__
 function _refine(Class2, fn, _params) {
-  const schema3 = new Class2({
+  const schema4 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams(_params)
   });
-  return schema3;
+  return schema4;
 }
 // @__NO_SIDE_EFFECTS__
 function _superRefine(fn, params) {
@@ -28335,40 +28471,40 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process2(schema3, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema4, ctx, _params = { path: [], schemaPath: [] }) {
   var _a4;
-  const def = schema3._zod.def;
-  const seen = ctx.seen.get(schema3);
+  const def = schema4._zod.def;
+  const seen = ctx.seen.get(schema4);
   if (seen) {
     seen.count++;
-    const isCycle = _params.schemaPath.includes(schema3);
+    const isCycle = _params.schemaPath.includes(schema4);
     if (isCycle) {
       seen.cycle = _params.path;
     }
     return seen.schema;
   }
   const result2 = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema3, result2);
-  const overrideSchema = schema3._zod.toJSONSchema?.();
+  ctx.seen.set(schema4, result2);
+  const overrideSchema = schema4._zod.toJSONSchema?.();
   if (overrideSchema) {
     result2.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
-      schemaPath: [..._params.schemaPath, schema3],
+      schemaPath: [..._params.schemaPath, schema4],
       path: _params.path
     };
-    if (schema3._zod.processJSONSchema) {
-      schema3._zod.processJSONSchema(ctx, result2.schema, params);
+    if (schema4._zod.processJSONSchema) {
+      schema4._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(schema3, ctx, _json, params);
+      processor(schema4, ctx, _json, params);
     }
-    const parent = schema3._zod.parent;
+    const parent = schema4._zod.parent;
     if (parent) {
       if (!result2.ref)
         result2.ref = parent;
@@ -28376,21 +28512,21 @@ function process2(schema3, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta3 = ctx.metadataRegistry.get(schema3);
+  const meta3 = ctx.metadataRegistry.get(schema4);
   if (meta3)
     Object.assign(result2.schema, meta3);
-  if (ctx.io === "input" && isTransforming(schema3)) {
+  if (ctx.io === "input" && isTransforming(schema4)) {
     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(schema3);
+  const _result = ctx.seen.get(schema4);
   return _result.schema;
 }
-function extractDefs(ctx, schema3) {
-  const root = ctx.seen.get(schema3);
+function extractDefs(ctx, schema4) {
+  const root = ctx.seen.get(schema4);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
@@ -28433,11 +28569,11 @@ function extractDefs(ctx, schema3) {
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
-    const schema4 = seen.schema;
-    for (const key in schema4) {
-      delete schema4[key];
+    const schema5 = seen.schema;
+    for (const key in schema5) {
+      delete schema5[key];
     }
-    schema4.$ref = ref;
+    schema5.$ref = ref;
   };
   if (ctx.cycles === "throw") {
     for (const entry2 of ctx.seen.entries()) {
@@ -28451,13 +28587,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 (schema3 === entry2[0]) {
+    if (schema4 === entry2[0]) {
       extractToDef(entry2);
       continue;
     }
     if (ctx.external) {
       const ext = ctx.external.registry.get(entry2[0])?.id;
-      if (schema3 !== entry2[0] && ext) {
+      if (schema4 !== entry2[0] && ext) {
         extractToDef(entry2);
         continue;
       }
@@ -28479,16 +28615,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
 }
-function finalize(ctx, schema3) {
-  const root = ctx.seen.get(schema3);
+function finalize(ctx, schema4) {
+  const root = ctx.seen.get(schema4);
   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 schema4 = seen.def ?? seen.schema;
-    const _cached = { ...schema4 };
+    const schema5 = seen.def ?? seen.schema;
+    const _cached = { ...schema5 };
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
@@ -28496,28 +28632,28 @@ function finalize(ctx, schema3) {
       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")) {
-        schema4.allOf = schema4.allOf ?? [];
-        schema4.allOf.push(refSchema);
+        schema5.allOf = schema5.allOf ?? [];
+        schema5.allOf.push(refSchema);
       } else {
-        Object.assign(schema4, refSchema);
+        Object.assign(schema5, refSchema);
       }
-      Object.assign(schema4, _cached);
+      Object.assign(schema5, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema4) {
+        for (const key in schema5) {
           if (key === "$ref" || key === "allOf")
             continue;
           if (!(key in _cached)) {
-            delete schema4[key];
+            delete schema5[key];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema4) {
+        for (const key in schema5) {
           if (key === "$ref" || key === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema4[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema4[key];
+          if (key in refSeen.def && JSON.stringify(schema5[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema5[key];
           }
         }
       }
@@ -28527,13 +28663,13 @@ function finalize(ctx, schema3) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
-        schema4.$ref = parentSeen.schema.$ref;
+        schema5.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema4) {
+          for (const key in schema5) {
             if (key === "$ref" || key === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema4[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema4[key];
+            if (key in parentSeen.def && JSON.stringify(schema5[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema5[key];
             }
           }
         }
@@ -28541,7 +28677,7 @@ function finalize(ctx, schema3) {
     }
     ctx.override({
       zodSchema,
-      jsonSchema: schema4,
+      jsonSchema: schema5,
       path: seen.path ?? []
     });
   };
@@ -28559,13 +28695,13 @@ function finalize(ctx, schema3) {
   } else {
   }
   if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema3)?.id;
+    const id = ctx.external.registry.get(schema4)?.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(schema3)?.id;
+  const rootMetaId = ctx.metadataRegistry.get(schema4)?.id;
   if (rootMetaId !== void 0 && result2.id === rootMetaId)
     delete result2.id;
   const defs = ctx.external?.defs ?? {};
@@ -28591,10 +28727,10 @@ function finalize(ctx, schema3) {
     const finalized = JSON.parse(JSON.stringify(result2));
     Object.defineProperty(finalized, "~standard", {
       value: {
-        ...schema3["~standard"],
+        ...schema4["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema3, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod(schema3, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod(schema4, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema4, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -28662,18 +28798,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 = (schema3, processors = {}) => (params) => {
+    createToJSONSchemaMethod = (schema4, processors = {}) => (params) => {
       const ctx = initializeContext({ ...params, processors });
-      process2(schema3, ctx);
-      extractDefs(ctx, schema3);
-      return finalize(ctx, schema3);
+      process2(schema4, ctx);
+      extractDefs(ctx, schema4);
+      return finalize(ctx, schema4);
     };
-    createStandardJSONSchemaMethod = (schema3, io, processors = {}) => (params) => {
+    createStandardJSONSchemaMethod = (schema4, io, processors = {}) => (params) => {
       const { libraryOptions, target } = params ?? {};
       const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-      process2(schema3, ctx);
-      extractDefs(ctx, schema3);
-      return finalize(ctx, schema3);
+      process2(schema4, ctx);
+      extractDefs(ctx, schema4);
+      return finalize(ctx, schema4);
     };
   }
 });
@@ -28685,8 +28821,8 @@ function toJSONSchema(input, params) {
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry2 of registry2._idmap.entries()) {
-      const [_, schema3] = entry2;
-      process2(schema3, ctx2);
+      const [_, schema4] = entry2;
+      process2(schema4, ctx2);
     }
     const schemas = {};
     const external = {
@@ -28696,9 +28832,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry2 of registry2._idmap.entries()) {
-      const [key, schema3] = entry2;
-      extractDefs(ctx2, schema3);
-      schemas[key] = finalize(ctx2, schema3);
+      const [key, schema4] = entry2;
+      extractDefs(ctx2, schema4);
+      schemas[key] = finalize(ctx2, schema4);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -28726,10 +28862,10 @@ var init_json_schema_processors = __esm({
       regex: ""
       // do not set
     };
-    stringProcessor = (schema3, ctx, _json, _params) => {
+    stringProcessor = (schema4, ctx, _json, _params) => {
       const json2 = _json;
       json2.type = "string";
-      const { minimum, maximum, format: format3, patterns, contentEncoding } = schema3._zod.bag;
+      const { minimum, maximum, format: format3, patterns, contentEncoding } = schema4._zod.bag;
       if (typeof minimum === "number")
         json2.minLength = minimum;
       if (typeof maximum === "number")
@@ -28758,9 +28894,9 @@ var init_json_schema_processors = __esm({
         }
       }
     };
-    numberProcessor = (schema3, ctx, _json, _params) => {
+    numberProcessor = (schema4, ctx, _json, _params) => {
       const json2 = _json;
-      const { minimum, maximum, format: format3, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema3._zod.bag;
+      const { minimum, maximum, format: format3, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema4._zod.bag;
       if (typeof format3 === "string" && format3.includes("int"))
         json2.type = "integer";
       else
@@ -28835,8 +28971,8 @@ var init_json_schema_processors = __esm({
         throw new Error("Date cannot be represented in JSON Schema");
       }
     };
-    enumProcessor = (schema3, _ctx, json2, _params) => {
-      const def = schema3._zod.def;
+    enumProcessor = (schema4, _ctx, json2, _params) => {
+      const def = schema4._zod.def;
       const values = getEnumValues(def.entries);
       if (values.every((v) => typeof v === "number"))
         json2.type = "number";
@@ -28844,8 +28980,8 @@ var init_json_schema_processors = __esm({
         json2.type = "string";
       json2.enum = values;
     };
-    literalProcessor = (schema3, ctx, json2, _params) => {
-      const def = schema3._zod.def;
+    literalProcessor = (schema4, ctx, json2, _params) => {
+      const def = schema4._zod.def;
       const vals = [];
       for (const val of def.values) {
         if (val === void 0) {
@@ -28889,22 +29025,22 @@ var init_json_schema_processors = __esm({
         throw new Error("NaN cannot be represented in JSON Schema");
       }
     };
-    templateLiteralProcessor = (schema3, _ctx, json2, _params) => {
+    templateLiteralProcessor = (schema4, _ctx, json2, _params) => {
       const _json = json2;
-      const pattern = schema3._zod.pattern;
+      const pattern = schema4._zod.pattern;
       if (!pattern)
         throw new Error("Pattern not found in template literal");
       _json.type = "string";
       _json.pattern = pattern.source;
     };
-    fileProcessor = (schema3, _ctx, json2, _params) => {
+    fileProcessor = (schema4, _ctx, json2, _params) => {
       const _json = json2;
       const file2 = {
         type: "string",
         format: "binary",
         contentEncoding: "binary"
       };
-      const { minimum, maximum, mime } = schema3._zod.bag;
+      const { minimum, maximum, mime } = schema4._zod.bag;
       if (minimum !== void 0)
         file2.minLength = minimum;
       if (maximum !== void 0)
@@ -28949,10 +29085,10 @@ var init_json_schema_processors = __esm({
         throw new Error("Set cannot be represented in JSON Schema");
       }
     };
-    arrayProcessor = (schema3, ctx, _json, params) => {
+    arrayProcessor = (schema4, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema3._zod.def;
-      const { minimum, maximum } = schema3._zod.bag;
+      const def = schema4._zod.def;
+      const { minimum, maximum } = schema4._zod.bag;
       if (typeof minimum === "number")
         json2.minItems = minimum;
       if (typeof maximum === "number")
@@ -28963,9 +29099,9 @@ var init_json_schema_processors = __esm({
         path: [...params.path, "items"]
       });
     };
-    objectProcessor = (schema3, ctx, _json, params) => {
+    objectProcessor = (schema4, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema3._zod.def;
+      const def = schema4._zod.def;
       json2.type = "object";
       json2.properties = {};
       const shape = def.shape;
@@ -28999,8 +29135,8 @@ var init_json_schema_processors = __esm({
         });
       }
     };
-    unionProcessor = (schema3, ctx, json2, params) => {
-      const def = schema3._zod.def;
+    unionProcessor = (schema4, ctx, json2, params) => {
+      const def = schema4._zod.def;
       const isExclusive = def.inclusive === false;
       const options = def.options.map((x2, i2) => process2(x2, ctx, {
         ...params,
@@ -29012,8 +29148,8 @@ var init_json_schema_processors = __esm({
         json2.anyOf = options;
       }
     };
-    intersectionProcessor = (schema3, ctx, json2, params) => {
-      const def = schema3._zod.def;
+    intersectionProcessor = (schema4, ctx, json2, params) => {
+      const def = schema4._zod.def;
       const a = process2(def.left, ctx, {
         ...params,
         path: [...params.path, "allOf", 0]
@@ -29029,9 +29165,9 @@ var init_json_schema_processors = __esm({
       ];
       json2.allOf = allOf;
     };
-    tupleProcessor = (schema3, ctx, _json, params) => {
+    tupleProcessor = (schema4, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema3._zod.def;
+      const def = schema4._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";
@@ -29065,15 +29201,15 @@ var init_json_schema_processors = __esm({
           json2.additionalItems = rest;
         }
       }
-      const { minimum, maximum } = schema3._zod.bag;
+      const { minimum, maximum } = schema4._zod.bag;
       if (typeof minimum === "number")
         json2.minItems = minimum;
       if (typeof maximum === "number")
         json2.maxItems = maximum;
     };
-    recordProcessor = (schema3, ctx, _json, params) => {
+    recordProcessor = (schema4, ctx, _json, params) => {
       const json2 = _json;
-      const def = schema3._zod.def;
+      const def = schema4._zod.def;
       json2.type = "object";
       const keyType = def.keyType;
       const keyBag = keyType._zod.bag;
@@ -29107,10 +29243,10 @@ var init_json_schema_processors = __esm({
         }
       }
     };
-    nullableProcessor = (schema3, ctx, json2, params) => {
-      const def = schema3._zod.def;
+    nullableProcessor = (schema4, ctx, json2, params) => {
+      const def = schema4._zod.def;
       const inner = process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       if (ctx.target === "openapi-3.0") {
         seen.ref = def.innerType;
         json2.nullable = true;
@@ -29118,31 +29254,31 @@ var init_json_schema_processors = __esm({
         json2.anyOf = [inner, { type: "null" }];
       }
     };
-    nonoptionalProcessor = (schema3, ctx, _json, params) => {
-      const def = schema3._zod.def;
+    nonoptionalProcessor = (schema4, ctx, _json, params) => {
+      const def = schema4._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = def.innerType;
     };
-    defaultProcessor = (schema3, ctx, json2, params) => {
-      const def = schema3._zod.def;
+    defaultProcessor = (schema4, ctx, json2, params) => {
+      const def = schema4._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = def.innerType;
       json2.default = JSON.parse(JSON.stringify(def.defaultValue));
     };
-    prefaultProcessor = (schema3, ctx, json2, params) => {
-      const def = schema3._zod.def;
+    prefaultProcessor = (schema4, ctx, json2, params) => {
+      const def = schema4._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = def.innerType;
       if (ctx.io === "input")
         json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
     };
-    catchProcessor = (schema3, ctx, json2, params) => {
-      const def = schema3._zod.def;
+    catchProcessor = (schema4, ctx, json2, params) => {
+      const def = schema4._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = def.innerType;
       let catchValue;
       try {
@@ -29152,37 +29288,37 @@ var init_json_schema_processors = __esm({
       }
       json2.default = catchValue;
     };
-    pipeProcessor = (schema3, ctx, _json, params) => {
-      const def = schema3._zod.def;
+    pipeProcessor = (schema4, ctx, _json, params) => {
+      const def = schema4._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(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = innerType;
     };
-    readonlyProcessor = (schema3, ctx, json2, params) => {
-      const def = schema3._zod.def;
+    readonlyProcessor = (schema4, ctx, json2, params) => {
+      const def = schema4._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = def.innerType;
       json2.readOnly = true;
     };
-    promiseProcessor = (schema3, ctx, _json, params) => {
-      const def = schema3._zod.def;
+    promiseProcessor = (schema4, ctx, _json, params) => {
+      const def = schema4._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = def.innerType;
     };
-    optionalProcessor = (schema3, ctx, _json, params) => {
-      const def = schema3._zod.def;
+    optionalProcessor = (schema4, ctx, _json, params) => {
+      const def = schema4._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = def.innerType;
     };
-    lazyProcessor = (schema3, ctx, _json, params) => {
-      const innerType = schema3._zod.innerType;
+    lazyProcessor = (schema4, ctx, _json, params) => {
+      const innerType = schema4._zod.innerType;
       process2(innerType, ctx, params);
-      const seen = ctx.seen.get(schema3);
+      const seen = ctx.seen.get(schema4);
       seen.ref = innerType;
     };
     allProcessors = {
@@ -29286,14 +29422,14 @@ var init_json_schema_generator = __esm({
        * Process a schema to prepare it for JSON Schema generation.
        * This must be called before emit().
        */
-      process(schema3, _params = { path: [], schemaPath: [] }) {
-        return process2(schema3, this.ctx, _params);
+      process(schema4, _params = { path: [], schemaPath: [] }) {
+        return process2(schema4, this.ctx, _params);
       }
       /**
        * Emit the final JSON Schema after processing.
        * Must call process() first.
        */
-      emit(schema3, _params) {
+      emit(schema4, _params) {
         if (_params) {
           if (_params.cycles)
             this.ctx.cycles = _params.cycles;
@@ -29302,8 +29438,8 @@ var init_json_schema_generator = __esm({
           if (_params.external)
             this.ctx.external = _params.external;
         }
-        extractDefs(this.ctx, schema3);
-        const result2 = finalize(this.ctx, schema3);
+        extractDefs(this.ctx, schema4);
+        const result2 = finalize(this.ctx, schema4);
         const { "~standard": _, ...plainResult } = result2;
         return plainResult;
       }
@@ -30132,8 +30268,8 @@ function date3(params) {
 function array(element, params) {
   return _array(ZodArray, element, params);
 }
-function keyof(schema3) {
-  const shape = schema3._zod.def.shape;
+function keyof(schema4) {
+  const shape = schema4._zod.def.shape;
   return _enum2(Object.keys(shape));
 }
 function object(shape, params) {
@@ -30448,11 +30584,11 @@ function json(params) {
   });
   return jsonSchema;
 }
-function preprocess(fn, schema3) {
+function preprocess(fn, schema4) {
   return new ZodPreprocess({
     type: "pipe",
     in: transform(fn),
-    out: schema3
+    out: schema4
   });
 }
 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;
@@ -31276,8 +31412,8 @@ var init_compat = __esm({
 });
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/from-json-schema.js
-function detectVersion(schema3, defaultTarget) {
-  const $schema = schema3.$schema;
+function detectVersion(schema4, defaultTarget) {
+  const $schema = schema4.$schema;
   if ($schema === "https://json-schema.org/draft/2020-12/schema") {
     return "draft-2020-12";
   }
@@ -31307,27 +31443,27 @@ function resolveRef(ref, ctx) {
   }
   throw new Error(`Reference not found: ${ref}`);
 }
-function convertBaseSchema(schema3, ctx) {
-  if (schema3.not !== void 0) {
-    if (typeof schema3.not === "object" && Object.keys(schema3.not).length === 0) {
+function convertBaseSchema(schema4, ctx) {
+  if (schema4.not !== void 0) {
+    if (typeof schema4.not === "object" && Object.keys(schema4.not).length === 0) {
       return z.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
-  if (schema3.unevaluatedItems !== void 0) {
+  if (schema4.unevaluatedItems !== void 0) {
     throw new Error("unevaluatedItems is not supported");
   }
-  if (schema3.unevaluatedProperties !== void 0) {
+  if (schema4.unevaluatedProperties !== void 0) {
     throw new Error("unevaluatedProperties is not supported");
   }
-  if (schema3.if !== void 0 || schema3.then !== void 0 || schema3.else !== void 0) {
+  if (schema4.if !== void 0 || schema4.then !== void 0 || schema4.else !== void 0) {
     throw new Error("Conditional schemas (if/then/else) are not supported");
   }
-  if (schema3.dependentSchemas !== void 0 || schema3.dependentRequired !== void 0) {
+  if (schema4.dependentSchemas !== void 0 || schema4.dependentRequired !== void 0) {
     throw new Error("dependentSchemas and dependentRequired are not supported");
   }
-  if (schema3.$ref) {
-    const refPath = schema3.$ref;
+  if (schema4.$ref) {
+    const refPath = schema4.$ref;
     if (ctx.refs.has(refPath)) {
       return ctx.refs.get(refPath);
     }
@@ -31346,9 +31482,9 @@ function convertBaseSchema(schema3, ctx) {
     ctx.processing.delete(refPath);
     return zodSchema2;
   }
-  if (schema3.enum !== void 0) {
-    const enumValues = schema3.enum;
-    if (ctx.version === "openapi-3.0" && schema3.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+  if (schema4.enum !== void 0) {
+    const enumValues = schema4.enum;
+    if (ctx.version === "openapi-3.0" && schema4.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
       return z.null();
     }
     if (enumValues.length === 0) {
@@ -31366,13 +31502,13 @@ function convertBaseSchema(schema3, ctx) {
     }
     return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (schema3.const !== void 0) {
-    return z.literal(schema3.const);
+  if (schema4.const !== void 0) {
+    return z.literal(schema4.const);
   }
-  const type = schema3.type;
+  const type = schema4.type;
   if (Array.isArray(type)) {
     const typeSchemas = type.map((t) => {
-      const typeSchema = { ...schema3, type: t };
+      const typeSchema = { ...schema4, type: t };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -31390,8 +31526,8 @@ function convertBaseSchema(schema3, ctx) {
   switch (type) {
     case "string": {
       let stringSchema = z.string();
-      if (schema3.format) {
-        const format3 = schema3.format;
+      if (schema4.format) {
+        const format3 = schema4.format;
         if (format3 === "email") {
           stringSchema = stringSchema.check(z.email());
         } else if (format3 === "uri" || format3 === "uri-reference") {
@@ -31440,14 +31576,14 @@ function convertBaseSchema(schema3, ctx) {
           stringSchema = stringSchema.check(z.ksuid());
         }
       }
-      if (typeof schema3.minLength === "number") {
-        stringSchema = stringSchema.min(schema3.minLength);
+      if (typeof schema4.minLength === "number") {
+        stringSchema = stringSchema.min(schema4.minLength);
       }
-      if (typeof schema3.maxLength === "number") {
-        stringSchema = stringSchema.max(schema3.maxLength);
+      if (typeof schema4.maxLength === "number") {
+        stringSchema = stringSchema.max(schema4.maxLength);
       }
-      if (schema3.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema3.pattern));
+      if (schema4.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema4.pattern));
       }
       zodSchema = stringSchema;
       break;
@@ -31455,24 +31591,24 @@ function convertBaseSchema(schema3, ctx) {
     case "number":
     case "integer": {
       let numberSchema = type === "integer" ? z.number().int() : z.number();
-      if (typeof schema3.minimum === "number") {
-        numberSchema = numberSchema.min(schema3.minimum);
+      if (typeof schema4.minimum === "number") {
+        numberSchema = numberSchema.min(schema4.minimum);
       }
-      if (typeof schema3.maximum === "number") {
-        numberSchema = numberSchema.max(schema3.maximum);
+      if (typeof schema4.maximum === "number") {
+        numberSchema = numberSchema.max(schema4.maximum);
       }
-      if (typeof schema3.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema3.exclusiveMinimum);
-      } else if (schema3.exclusiveMinimum === true && typeof schema3.minimum === "number") {
-        numberSchema = numberSchema.gt(schema3.minimum);
+      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 schema3.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema3.exclusiveMaximum);
-      } else if (schema3.exclusiveMaximum === true && typeof schema3.maximum === "number") {
-        numberSchema = numberSchema.lt(schema3.maximum);
+      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 schema3.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema3.multipleOf);
+      if (typeof schema4.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema4.multipleOf);
       }
       zodSchema = numberSchema;
       break;
@@ -31487,15 +31623,15 @@ function convertBaseSchema(schema3, ctx) {
     }
     case "object": {
       const shape = {};
-      const properties = schema3.properties || {};
-      const requiredSet = new Set(schema3.required || []);
+      const properties = schema4.properties || {};
+      const requiredSet = new Set(schema4.required || []);
       for (const [key, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
         shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
       }
-      if (schema3.propertyNames) {
-        const keySchema = convertSchema(schema3.propertyNames, ctx);
-        const valueSchema = schema3.additionalProperties && typeof schema3.additionalProperties === "object" ? convertSchema(schema3.additionalProperties, ctx) : z.any();
+      if (schema4.propertyNames) {
+        const keySchema = convertSchema(schema4.propertyNames, ctx);
+        const valueSchema = schema4.additionalProperties && typeof schema4.additionalProperties === "object" ? convertSchema(schema4.additionalProperties, ctx) : z.any();
         if (Object.keys(shape).length === 0) {
           zodSchema = z.record(keySchema, valueSchema);
           break;
@@ -31505,8 +31641,8 @@ function convertBaseSchema(schema3, ctx) {
         zodSchema = z.intersection(objectSchema2, recordSchema);
         break;
       }
-      if (schema3.patternProperties) {
-        const patternProps = schema3.patternProperties;
+      if (schema4.patternProperties) {
+        const patternProps = schema4.patternProperties;
         const patternKeys = Object.keys(patternProps);
         const looseRecords = [];
         for (const pattern of patternKeys) {
@@ -31533,18 +31669,18 @@ function convertBaseSchema(schema3, ctx) {
         break;
       }
       const objectSchema = z.object(shape);
-      if (schema3.additionalProperties === false) {
+      if (schema4.additionalProperties === false) {
         zodSchema = objectSchema.strict();
-      } else if (typeof schema3.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema(schema3.additionalProperties, ctx));
+      } else if (typeof schema4.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema(schema4.additionalProperties, ctx));
       } else {
         zodSchema = objectSchema.passthrough();
       }
       break;
     }
     case "array": {
-      const prefixItems = schema3.prefixItems;
-      const items = schema3.items;
+      const prefixItems = schema4.prefixItems;
+      const items = schema4.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;
@@ -31553,34 +31689,34 @@ function convertBaseSchema(schema3, ctx) {
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema3.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema3.minItems));
+        if (typeof schema4.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema4.minItems));
         }
-        if (typeof schema3.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema3.maxItems));
+        if (typeof schema4.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema4.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
-        const rest = schema3.additionalItems && typeof schema3.additionalItems === "object" ? convertSchema(schema3.additionalItems, ctx) : void 0;
+        const rest = schema4.additionalItems && typeof schema4.additionalItems === "object" ? convertSchema(schema4.additionalItems, ctx) : void 0;
         if (rest) {
           zodSchema = z.tuple(tupleItems).rest(rest);
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema3.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema3.minItems));
+        if (typeof schema4.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema4.minItems));
         }
-        if (typeof schema3.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema3.maxItems));
+        if (typeof schema4.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema4.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
         let arraySchema = z.array(element);
-        if (typeof schema3.minItems === "number") {
-          arraySchema = arraySchema.min(schema3.minItems);
+        if (typeof schema4.minItems === "number") {
+          arraySchema = arraySchema.min(schema4.minItems);
         }
-        if (typeof schema3.maxItems === "number") {
-          arraySchema = arraySchema.max(schema3.maxItems);
+        if (typeof schema4.maxItems === "number") {
+          arraySchema = arraySchema.max(schema4.maxItems);
         }
         zodSchema = arraySchema;
       } else {
@@ -31593,76 +31729,76 @@ function convertBaseSchema(schema3, ctx) {
   }
   return zodSchema;
 }
-function convertSchema(schema3, ctx) {
-  if (typeof schema3 === "boolean") {
-    return schema3 ? z.any() : z.never();
+function convertSchema(schema4, ctx) {
+  if (typeof schema4 === "boolean") {
+    return schema4 ? z.any() : z.never();
   }
-  let baseSchema = convertBaseSchema(schema3, ctx);
-  const hasExplicitType = schema3.type || schema3.enum !== void 0 || schema3.const !== void 0;
-  if (schema3.anyOf && Array.isArray(schema3.anyOf)) {
-    const options = schema3.anyOf.map((s) => convertSchema(s, ctx));
+  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));
     const anyOfUnion = z.union(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
-  if (schema3.oneOf && Array.isArray(schema3.oneOf)) {
-    const options = schema3.oneOf.map((s) => convertSchema(s, ctx));
+  if (schema4.oneOf && Array.isArray(schema4.oneOf)) {
+    const options = schema4.oneOf.map((s) => convertSchema(s, ctx));
     const oneOfUnion = z.xor(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
-  if (schema3.allOf && Array.isArray(schema3.allOf)) {
-    if (schema3.allOf.length === 0) {
+  if (schema4.allOf && Array.isArray(schema4.allOf)) {
+    if (schema4.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result2 = hasExplicitType ? baseSchema : convertSchema(schema3.allOf[0], ctx);
+      let result2 = hasExplicitType ? baseSchema : convertSchema(schema4.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
-      for (let i2 = startIdx; i2 < schema3.allOf.length; i2++) {
-        result2 = z.intersection(result2, convertSchema(schema3.allOf[i2], ctx));
+      for (let i2 = startIdx; i2 < schema4.allOf.length; i2++) {
+        result2 = z.intersection(result2, convertSchema(schema4.allOf[i2], ctx));
       }
       baseSchema = result2;
     }
   }
-  if (schema3.nullable === true && ctx.version === "openapi-3.0") {
+  if (schema4.nullable === true && ctx.version === "openapi-3.0") {
     baseSchema = z.nullable(baseSchema);
   }
-  if (schema3.readOnly === true) {
+  if (schema4.readOnly === true) {
     baseSchema = z.readonly(baseSchema);
   }
-  if (schema3.default !== void 0) {
-    baseSchema = baseSchema.default(schema3.default);
+  if (schema4.default !== void 0) {
+    baseSchema = baseSchema.default(schema4.default);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
   for (const key of coreMetadataKeys) {
-    if (key in schema3) {
-      extraMeta[key] = schema3[key];
+    if (key in schema4) {
+      extraMeta[key] = schema4[key];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
-    if (key in schema3) {
-      extraMeta[key] = schema3[key];
+    if (key in schema4) {
+      extraMeta[key] = schema4[key];
     }
   }
-  for (const key of Object.keys(schema3)) {
+  for (const key of Object.keys(schema4)) {
     if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema3[key];
+      extraMeta[key] = schema4[key];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
     ctx.registry.add(baseSchema, extraMeta);
   }
-  if (schema3.description) {
-    baseSchema = baseSchema.describe(schema3.description);
+  if (schema4.description) {
+    baseSchema = baseSchema.describe(schema4.description);
   }
   return baseSchema;
 }
-function fromJSONSchema(schema3, params) {
-  if (typeof schema3 === "boolean") {
-    return schema3 ? z.any() : z.never();
+function fromJSONSchema(schema4, params) {
+  if (typeof schema4 === "boolean") {
+    return schema4 ? z.any() : z.never();
   }
   let normalized;
   try {
-    normalized = JSON.parse(JSON.stringify(schema3));
+    normalized = JSON.parse(JSON.stringify(schema4));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
@@ -32339,7 +32475,7 @@ var init_skill_protocol = __esm({
                   "https://bsc-dataseed.binance.org",
                   "https://bsc-dataseed1.defibit.io"
                 ],
-                maxLogBlockRange: 5e3
+                maxLogBlockRange: 500
               },
               sourceRepository: "FinchipAI/finchip-protocol",
               sourceCommit: "89e54d6ff46dbfba61122e90c5e77f409f02fe5e",
@@ -32367,7 +32503,8 @@ var init_skill_protocol = __esm({
                 defaultRpcUrls: [
                   "https://mainnet.base.org",
                   "https://base.drpc.org"
-                ]
+                ],
+                maxLogBlockRange: 2e3
               },
               sourceRepository: "FinchipAI/finchip-protocol",
               sourceCommit: "89e54d6ff46dbfba61122e90c5e77f409f02fe5e",
@@ -32523,8 +32660,8 @@ function resolveSkillProtocolEnvironment(raw) {
     `FINCH_ENVIRONMENT must explicitly be local, test, or production; received ${received}.`
   );
 }
-function parseTypedRegistry(schema3, value) {
-  const parsed = schema3.safeParse(value);
+function parseTypedRegistry(schema4, value) {
+  const parsed = schema4.safeParse(value);
   if (!parsed.success) {
     throw new DeploymentManifestError(`Invalid chain deployment manifest: ${external_exports.prettifyError(parsed.error)}`);
   }
@@ -32933,6 +33070,65 @@ var init_chains = __esm({
   }
 });
 
+// ../../packages/deployment-manifest/src/platform/passkey-safe.json
+var passkey_safe_default;
+var init_passkey_safe = __esm({
+  "../../packages/deployment-manifest/src/platform/passkey-safe.json"() {
+    passkey_safe_default = {
+      schemaVersion: 1,
+      kind: "passkey_safe",
+      environments: {
+        local: { enabled: false },
+        test: {
+          enabled: true,
+          larkAlertsEnabled: true,
+          chainId: 84532,
+          platformOwner: "0xa6244488cf4660618d054b5f69d6e60c807df9cb",
+          safeVersion: "1.4.1",
+          verifierAddress: "0x0000000000000000000000000000000000000100",
+          minimumGasWei: "1000000000000000",
+          maxGasPerTransaction: "3000000"
+        },
+        production: { enabled: false }
+      }
+    };
+  }
+});
+
+// ../../packages/deployment-manifest/src/platform/passkey-safe.ts
+function parsePasskeySafeManifest(input) {
+  return schema.parse(input);
+}
+var disabled, enabled, schema, manifest;
+var init_passkey_safe2 = __esm({
+  "../../packages/deployment-manifest/src/platform/passkey-safe.ts"() {
+    "use strict";
+    init_zod();
+    init_passkey_safe();
+    disabled = external_exports.strictObject({ enabled: external_exports.literal(false) });
+    enabled = external_exports.strictObject({
+      enabled: external_exports.literal(true),
+      chainId: external_exports.literal(84532),
+      larkAlertsEnabled: external_exports.boolean(),
+      platformOwner: external_exports.string().regex(/^0x[0-9a-f]{40}$/).refine((v) => BigInt(v) !== BigInt(0)),
+      safeVersion: external_exports.literal("1.4.1"),
+      verifierAddress: external_exports.string().regex(/^0x[0-9a-f]{40}$/).refine((v) => BigInt(v) > BigInt(0) && BigInt(v) <= BigInt(65535)),
+      minimumGasWei: external_exports.string().regex(/^[1-9][0-9]*$/),
+      maxGasPerTransaction: external_exports.string().regex(/^[1-9][0-9]*$/)
+    });
+    schema = external_exports.strictObject({
+      schemaVersion: external_exports.literal(1),
+      kind: external_exports.literal("passkey_safe"),
+      environments: external_exports.strictObject({
+        local: disabled,
+        test: external_exports.discriminatedUnion("enabled", [disabled, enabled]),
+        production: disabled
+      })
+    });
+    manifest = parsePasskeySafeManifest(passkey_safe_default);
+  }
+});
+
 // ../../packages/deployment-manifest/src/platform/web-analytics.json
 var web_analytics_default;
 var init_web_analytics = __esm({
@@ -32980,16 +33176,31 @@ var init_internal_apps = __esm({
       kind: "internal_apps",
       environments: {
         local: {
-          data: { sessionTtlSeconds: 28800 },
-          ops: { sessionTtlSeconds: 28800 }
+          data: {
+            sessionTtlSeconds: 28800
+          },
+          ops: {
+            sessionTtlSeconds: 28800,
+            webOrigin: "http://localhost:3000"
+          }
         },
         test: {
-          data: { sessionTtlSeconds: 28800 },
-          ops: { sessionTtlSeconds: 28800 }
+          data: {
+            sessionTtlSeconds: 28800
+          },
+          ops: {
+            sessionTtlSeconds: 28800,
+            webOrigin: "https://finch-site.vercel.app"
+          }
         },
         production: {
-          data: { sessionTtlSeconds: 28800 },
-          ops: { sessionTtlSeconds: 28800 }
+          data: {
+            sessionTtlSeconds: 28800
+          },
+          ops: {
+            sessionTtlSeconds: 28800,
+            webOrigin: "https://www.finchtech.ai"
+          }
         }
       }
     };
@@ -33139,9 +33350,9 @@ var init_agenton_payout = __esm({
 
 // ../../packages/deployment-manifest/src/platform/agenton-payout.ts
 function parseAgentonPayoutManifest(input) {
-  return schema.parse(input);
+  return schema2.parse(input);
 }
-var origin, environment, schema, manifest;
+var origin, environment, schema2, manifest2;
 var init_agenton_payout2 = __esm({
   "../../packages/deployment-manifest/src/platform/agenton-payout.ts"() {
     "use strict";
@@ -33152,14 +33363,14 @@ 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() });
-    schema = external_exports.strictObject({
+    schema2 = external_exports.strictObject({
       schemaVersion: external_exports.literal(1),
       kind: external_exports.literal("agenton_payout"),
       agentIdBaseUrl: origin,
       walletApiBaseUrl: origin,
       environments: external_exports.strictObject({ local: environment, test: environment, production: environment })
     });
-    manifest = parseAgentonPayoutManifest(agenton_payout_default);
+    manifest2 = parseAgentonPayoutManifest(agenton_payout_default);
   }
 });
 
@@ -33171,9 +33382,19 @@ var init_merchant_avatar_video = __esm({
       schemaVersion: 1,
       kind: "merchant_avatar_video",
       environments: {
-        local: { enabled: false },
-        test: { enabled: false },
-        production: { enabled: false }
+        local: {
+          enabled: false
+        },
+        test: {
+          enabled: true,
+          offerId: "e72aeda7-da44-5685-b5a0-4d90cfa63c2d",
+          dailyLimit: 10
+        },
+        production: {
+          enabled: true,
+          offerId: "1cf22f74-a451-54f0-894a-baff6221693d",
+          dailyLimit: 10
+        }
       }
     };
   }
@@ -33181,9 +33402,9 @@ var init_merchant_avatar_video = __esm({
 
 // ../../packages/deployment-manifest/src/platform/merchant-avatar-video.ts
 function parseMerchantAvatarVideoManifest(input) {
-  return schema2.parse(input);
+  return schema3.parse(input);
 }
-var policy, schema2, manifest2;
+var policy, schema3, manifest3;
 var init_merchant_avatar_video2 = __esm({
   "../../packages/deployment-manifest/src/platform/merchant-avatar-video.ts"() {
     "use strict";
@@ -33193,18 +33414,18 @@ var init_merchant_avatar_video2 = __esm({
       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) })
     ]);
-    schema2 = external_exports.strictObject({
+    schema3 = 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 })
     });
-    manifest2 = parseMerchantAvatarVideoManifest(merchant_avatar_video_default);
+    manifest3 = parseMerchantAvatarVideoManifest(merchant_avatar_video_default);
   }
 });
 
 // ../../packages/deployment-manifest/src/platform/index.ts
-function parseManifest2(label, schema3, value) {
-  const parsed = schema3.safeParse(value);
+function parseManifest2(label, schema4, value) {
+  const parsed = schema4.safeParse(value);
   if (!parsed.success) {
     throw new DeploymentManifestError(
       `Invalid ${label} deployment manifest: ${external_exports.prettifyError(parsed.error)}`
@@ -33248,6 +33469,7 @@ var init_platform = __esm({
   "../../packages/deployment-manifest/src/platform/index.ts"() {
     "use strict";
     init_zod();
+    init_passkey_safe2();
     init_web_analytics();
     init_web_localization();
     init_chains();
@@ -33262,7 +33484,10 @@ var init_platform = __esm({
     });
     internalAppsEnvironmentSchema = external_exports.strictObject({
       data: internalAppSchema,
-      ops: internalAppSchema
+      ops: internalAppSchema.extend({ webOrigin: external_exports.url().refine((value) => {
+        const url2 = new URL(value);
+        return url2.origin === value && (url2.protocol === "https:" || value === "http://localhost:3000");
+      }, "An exact reviewed Web origin is required.") })
     });
     internalAppsManifestSchema = external_exports.strictObject({
       schemaVersion: external_exports.literal(1),
@@ -47908,8 +48133,8 @@ var init_verifyAuthorization = __esm({
 });
 
 // ../../node_modules/.pnpm/viem@2.55.15_bufferutil@4.1_ce20031be19c56210207d462110a7a29/node_modules/viem/_esm/utils/promise/withDedupe.js
-function withDedupe(fn, { enabled = true, id }) {
-  if (!enabled || !id)
+function withDedupe(fn, { enabled: enabled2 = true, id }) {
+  if (!enabled2 || !id)
     return fn();
   if (promiseCache2.get(id))
     return promiseCache2.get(id);
@@ -54100,27 +54325,27 @@ function normalizeCliEvmAddress(value, field = "EVM address") {
 function record3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function variantMatches(schema3, value) {
-  if (!record3(schema3.properties) || !record3(value)) return true;
-  return Object.entries(schema3.properties).every(([key, property]) => {
+function variantMatches(schema4, value) {
+  if (!record3(schema4.properties) || !record3(value)) return true;
+  return Object.entries(schema4.properties).every(([key, property]) => {
     if (!record3(property) || !Object.hasOwn(property, "const")) return true;
     return value[key] === property.const;
   });
 }
-function normalizeCliRequestAddresses(schema3, value) {
-  if ((schema3.pattern === CANONICAL_ADDRESS_PATTERN || schema3.pattern === INPUT_ADDRESS_PATTERN) && typeof value === "string") {
+function normalizeCliRequestAddresses(schema4, value) {
+  if ((schema4.pattern === CANONICAL_ADDRESS_PATTERN || schema4.pattern === INPUT_ADDRESS_PATTERN) && typeof value === "string") {
     return normalizeCliEvmAddress(value);
   }
-  const variants = Array.isArray(schema3.oneOf) ? schema3.oneOf : Array.isArray(schema3.anyOf) ? schema3.anyOf : null;
+  const variants = Array.isArray(schema4.oneOf) ? schema4.oneOf : Array.isArray(schema4.anyOf) ? schema4.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(schema3.items)) {
-    return value.map((item) => normalizeCliRequestAddresses(schema3.items, item));
+  if (Array.isArray(value) && record3(schema4.items)) {
+    return value.map((item) => normalizeCliRequestAddresses(schema4.items, item));
   }
-  if (record3(value) && record3(schema3.properties)) {
-    const properties = schema3.properties;
+  if (record3(value) && record3(schema4.properties)) {
+    const properties = schema4.properties;
     return Object.fromEntries(Object.entries(value).map(([key, entry2]) => {
       const property = properties[key];
       return [key, record3(property) ? normalizeCliRequestAddresses(property, entry2) : entry2];
@@ -54141,21 +54366,38 @@ var init_address3 = __esm({
 });
 
 // src/api.ts
-function assertSchema(schema3, value) {
-  let validator = validatorCache.get(schema3);
+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");
+  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 } : {}
+  };
+}
+function assertSchema(schema4, value, diagnosticPaths) {
+  let validator = validatorCache.get(schema4);
   if (validator === void 0) {
-    const compiled = ajv.compile(schema3);
-    validatorCache.set(schema3, compiled);
+    const compiled = ajv.compile(schema4);
+    validatorCache.set(schema4, compiled);
     validator = compiled;
   }
-  if (!validator(value)) throw new CliHttpError("CLI_RESPONSE_INVALID");
+  if (!validator(value)) {
+    const schemaIssues = diagnosticPaths === void 0 ? void 0 : (validator.errors ?? []).slice(0, 8).map((error51) => {
+      const candidate = error51.keyword === "required" ? `${error51.instancePath}/${error51.params.missingProperty}` : error51.instancePath;
+      return { path: diagnosticPaths.includes(candidate) ? candidate : "", keyword: error51.keyword };
+    });
+    throw new CliHttpError("CLI_RESPONSE_INVALID", null, schemaIssues === void 0 ? void 0 : { diagnostic: { responseIssue: "schema_mismatch", schemaIssues } });
+  }
   return value;
 }
-function assertRequestSchema(schema3, value) {
-  let validator = validatorCache.get(schema3);
+function assertRequestSchema(schema4, value) {
+  let validator = validatorCache.get(schema4);
   if (validator === void 0) {
-    validator = ajv.compile(schema3);
-    validatorCache.set(schema3, validator);
+    validator = ajv.compile(schema4);
+    validatorCache.set(schema4, validator);
   }
   if (!validator(value)) throw new TypeError("Creator request does not match the shared operation schema.");
 }
@@ -54193,13 +54435,14 @@ function protectedResourceMetadataAuthority(authenticate, origin2, resourcePath)
     resource: metadata.pathname === rootPath ? `${origin2}/` : `${origin2}${resourcePath}`
   });
 }
-async function readBoundedJson(response, maximumBytes = 65536) {
+async function readBoundedJson(response, maximumBytes = 65536, diagnose = false) {
+  const failure2 = (code, responseIssue, cause) => new CliHttpError(code, response.status, { cause, ...diagnose ? { diagnostic: { responseIssue } } : {} });
   const length2 = response.headers.get("content-length");
   if (length2 !== null && (!/^(?:0|[1-9][0-9]*)$/u.test(length2) || Number(length2) > maximumBytes)) {
     await response.body?.cancel().catch(() => void 0);
-    throw new CliHttpError("CLI_RESPONSE_INVALID", response.status);
+    throw failure2("CLI_RESPONSE_INVALID", /^(?:0|[1-9][0-9]*)$/u.test(length2) ? "response_too_large" : "invalid_content_length");
   }
-  if (response.body === null) throw new CliHttpError("CLI_RESPONSE_INVALID", response.status);
+  if (response.body === null) throw failure2("CLI_RESPONSE_INVALID", "empty_body");
   const reader = response.body.getReader();
   const chunks = [];
   let total = 0;
@@ -54209,16 +54452,17 @@ async function readBoundedJson(response, maximumBytes = 65536) {
       try {
         chunk = await reader.read();
       } catch (cause) {
-        throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", response.status, { cause });
+        throw failure2("CLI_REMOTE_UNAVAILABLE", "body_read_failed", cause);
       }
       if (chunk.done) break;
       total += chunk.value.byteLength;
       if (total > maximumBytes) {
         await reader.cancel().catch(() => void 0);
-        throw new CliHttpError("CLI_RESPONSE_INVALID", response.status);
+        throw failure2("CLI_RESPONSE_INVALID", "response_too_large");
       }
       chunks.push(chunk.value);
     }
+    if (total === 0) throw failure2("CLI_RESPONSE_INVALID", "empty_body");
     const body = new Uint8Array(total);
     let offset = 0;
     for (const chunk of chunks) {
@@ -54228,11 +54472,11 @@ async function readBoundedJson(response, maximumBytes = 65536) {
     try {
       return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(body));
     } catch (cause) {
-      throw new CliHttpError("CLI_RESPONSE_INVALID", response.status, { cause });
+      throw failure2("CLI_RESPONSE_INVALID", "invalid_json", cause);
     }
   } catch (cause) {
     if (cause instanceof CliHttpError) throw cause;
-    throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", response.status, { cause });
+    throw failure2("CLI_REMOTE_UNAVAILABLE", "body_read_failed", cause);
   } finally {
     reader.releaseLock();
   }
@@ -54281,13 +54525,16 @@ async function readBoundedBytes(response, minimumBytes, maximumBytes) {
     reader.releaseLock();
   }
 }
-function parseRemoteError(contract, response, value) {
-  const schema3 = contract === "agent_market" ? agentCliErrorEnvelopeSchema : contract === "identity" ? identityErrorEnvelopeSchema : contract === "task_market" ? taskErrorEnvelopeSchema : contract === "skill_market" ? skillErrorEnvelopeSchema : oauthErrorResponseSchema;
+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;
   let envelope;
   try {
-    envelope = assertSchema(schema3, value);
+    envelope = assertSchema(schema4, value, diagnose ? skillErrorDiagnosticPaths : void 0);
   } catch (cause) {
-    throw new CliHttpError("CLI_RESPONSE_INVALID", response.status, { cause });
+    throw new CliHttpError("CLI_RESPONSE_INVALID", response.status, {
+      cause,
+      ...cause instanceof CliHttpError && cause.diagnostic !== null ? { diagnostic: cause.diagnostic } : {}
+    });
   }
   if (contract === "agent_market") {
     const error51 = envelope.error;
@@ -54299,11 +54546,12 @@ function parseRemoteError(contract, response, value) {
   }
   return envelope;
 }
-var import_ajv, CLI_MERCHANT_OPERATION_IDS, CliHttpError, ajv, validatorCache, oauthAuthorizationResponseSchema, oauthErrorResponseSchema, AgentCliHttpClient;
+var import_ajv, CLI_MERCHANT_OPERATION_IDS, PUBLIC_SKILL_HTTP_CODES, CliHttpError, ajv, validatorCache, skillUnsignedIntentResponseSchema, intentDiagnosticPaths, skillErrorDiagnosticPaths, oauthAuthorizationResponseSchema, oauthErrorResponseSchema, AgentCliHttpClient;
 var init_api2 = __esm({
   "src/api.ts"() {
     "use strict";
     import_ajv = __toESM(require_ajv(), 1);
+    init_cli_error();
     init_src2();
     init_v1();
     init_src3();
@@ -54331,22 +54579,52 @@ var init_api2 = __esm({
       "merchant_connection_tests.create",
       "merchant_publish_intents.create"
     ]);
+    PUBLIC_SKILL_HTTP_CODES = /* @__PURE__ */ new Set([
+      "UPLOAD_INVALID",
+      "UPLOAD_TOO_LARGE",
+      "UPLOAD_UNAUTHENTICATED",
+      "WALLET_REQUIRED",
+      "UPLOAD_PROVIDER_UNAVAILABLE",
+      "UPLOAD_UNAVAILABLE",
+      "FUNCTION_PAYLOAD_TOO_LARGE",
+      "FUNCTION_INVOCATION_TIMEOUT",
+      "FUNCTION_INVOCATION_FAILED",
+      "INTENT_INVALID",
+      "INTENT_UNAVAILABLE",
+      "PUBLICATION_INVALID"
+    ]);
     CliHttpError = class extends Error {
       code;
       status;
       envelope;
+      diagnostic;
       constructor(code, status = null, options) {
         super(code, options);
         this.name = "CliHttpError";
         this.code = code;
         this.status = status;
         this.envelope = options?.envelope ?? null;
+        this.diagnostic = options?.diagnostic ?? null;
       }
     };
     ajv = new import_ajv.default({ allErrors: true, strict: false });
     ajv.addFormat("date-time", (value) => Number.isFinite(Date.parse(value)));
     ajv.addFormat("uri", (value) => URL.canParse(value));
     validatorCache = /* @__PURE__ */ new WeakMap();
+    skillUnsignedIntentResponseSchema = {
+      type: "object",
+      additionalProperties: false,
+      required: ["chainId", "to", "data", "value", "summary"],
+      properties: {
+        chainId: { type: "integer", enum: SKILL_V3_CHAIN_IDS },
+        to: { type: "string", pattern: "^0x[0-9a-fA-F]{40}$" },
+        data: { type: "string", pattern: "^0x(?:[0-9a-fA-F]{2})+$" },
+        value: { type: "string", pattern: "^(?:0|[1-9][0-9]*)$" },
+        summary: { type: "string", minLength: 1 }
+      }
+    };
+    intentDiagnosticPaths = Object.keys(skillUnsignedIntentResponseSchema.properties).map((field) => `/${field}`);
+    skillErrorDiagnosticPaths = ["/error", "/error/code", "/error/message", "/error/traceId"];
     oauthAuthorizationResponseSchema = {
       type: "object",
       additionalProperties: false,
@@ -54371,12 +54649,16 @@ var init_api2 = __esm({
       }
     };
     AgentCliHttpClient = class {
-      origin;
-      fetchImplementation;
-      constructor(origin2, fetchImplementation = fetch) {
+      constructor(origin2, fetchImplementation = fetch, warn = (warning) => {
+        process.stderr.write(JSON.stringify({ warning }) + "\n");
+      }) {
+        this.warn = warn;
         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");
@@ -54418,12 +54700,17 @@ var init_api2 = __esm({
           throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", null, { cause });
         }
         if (response.status !== expectedStatus) {
+          let value;
           try {
-            const envelope = parseRemoteError("skill_market", response, await readBoundedJson(response));
+            value = await readBoundedJson(response, 65536, path2 === "/api/skills/intents");
+            const envelope = parseRemoteError("skill_market", response, value, path2 === "/api/skills/intents");
             throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", response.status, { envelope });
           } catch (cause) {
-            if (cause instanceof CliHttpError) throw cause;
-            throw new CliHttpError("CLI_RESPONSE_INVALID", response.status, { 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, value), ...cause instanceof CliHttpError ? cause.diagnostic : {} }
+            });
           }
         }
         return response;
@@ -54479,17 +54766,17 @@ var init_api2 = __esm({
           await manifestResponse.body?.cancel().catch(() => void 0);
           throw new CliHttpError("CLI_REMOTE_UNAVAILABLE", manifestResponse.status);
         }
-        const manifest3 = jsonObject(await readBoundedJson(manifestResponse));
-        const mcp = jsonObject(manifest3.mcp);
-        const source = jsonObject(manifest3.source);
-        if (!Array.isArray(manifest3.clients) || manifest3.clients.length !== 1) {
+        const manifest4 = jsonObject(await readBoundedJson(manifestResponse));
+        const mcp = jsonObject(manifest4.mcp);
+        const source = jsonObject(manifest4.source);
+        if (!Array.isArray(manifest4.clients) || manifest4.clients.length !== 1) {
           throw new CliHttpError("CLI_RESPONSE_INVALID", manifestResponse.status);
         }
-        const client = jsonObject(manifest3.clients[0]);
+        const client = jsonObject(manifest4.clients[0]);
         const install = jsonObject(client.install);
         const authorize = jsonObject(client.authorize);
         const verify = jsonObject(client.verify);
-        if (manifest3.schemaVersion !== 3 || manifest3.manifestId !== "finch.remote-mcp-clients" || mcp.serverName !== "finch" || mcp.url !== mcpUrl || mcp.transport !== "streamable_http" || mcp.authorization !== "oauth" || source.repository !== "https://github.com/FinchipAI/Finch-Site" || source.path !== "apps/mcp/src/client-compatibility.ts" || client.id !== "codex" || client.supportLevel !== "verified" || install.kind !== "native_cli" || install.executable !== "codex" || JSON.stringify(install.arguments) !== JSON.stringify(["mcp", "add", "finch", "--url", mcpUrl]) || authorize.kind !== "native_cli" || authorize.executable !== "codex" || JSON.stringify(authorize.arguments) !== JSON.stringify(["mcp", "login", "finch"]) || verify.kind !== "harness_ui" || verify.surface !== "mcp_tools" || client.reload !== "new_session") {
+        if (manifest4.schemaVersion !== 3 || manifest4.manifestId !== "finch.remote-mcp-clients" || mcp.serverName !== "finch" || mcp.url !== mcpUrl || mcp.transport !== "streamable_http" || mcp.authorization !== "oauth" || source.repository !== "https://github.com/FinchipAI/Finch-Site" || source.path !== "apps/mcp/src/client-compatibility.ts" || client.id !== "codex" || client.supportLevel !== "verified" || install.kind !== "native_cli" || install.executable !== "codex" || JSON.stringify(install.arguments) !== JSON.stringify(["mcp", "add", "finch", "--url", mcpUrl]) || authorize.kind !== "native_cli" || authorize.executable !== "codex" || JSON.stringify(authorize.arguments) !== JSON.stringify(["mcp", "login", "finch"]) || verify.kind !== "harness_ui" || verify.surface !== "mcp_tools" || client.reload !== "new_session") {
           throw new CliHttpError("CLI_RESPONSE_INVALID", manifestResponse.status);
         }
         return Object.freeze({
@@ -54501,6 +54788,13 @@ var init_api2 = __esm({
         });
       }
       async uploadSkillObject(input) {
+        if (input.objectKind === "manifest" && input.bytes.byteLength > MAX_SKILL_MANIFEST_BYTES) {
+          throw new CliSkillSourceError(
+            "SKILL_MANIFEST_SIZE_INVALID",
+            { actualBytes: input.bytes.byteLength, maxBytes: MAX_SKILL_MANIFEST_BYTES },
+            "Skill manifest exceeds the 3 MiB limit."
+          );
+        }
         const form = new FormData();
         form.append("file", new Blob([input.bytes], {
           type: input.mediaType ?? "application/octet-stream"
@@ -54509,21 +54803,70 @@ var init_api2 = __esm({
         form.append("objectKind", input.objectKind);
         if (input.sourceKind !== void 0) form.append("sourceKind", input.sourceKind);
         if (input.contentMode !== void 0) form.append("contentMode", input.contentMode);
-        const value = await readBoundedJson(await this.skillFetch("/api/skills/ipfs", {
-          method: "POST",
-          headers: { authorization: `Bearer ${input.bearer}` },
-          body: form
-        }));
-        const body = value;
-        if (typeof body?.uri !== "string") throw new CliHttpError("CLI_RESPONSE_INVALID", 200);
-        return Object.freeze({ uri: body.uri });
+        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 > 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 {
+          response = await this.skillFetch("/api/skills/ipfs", {
+            method: "POST",
+            headers: { authorization: `Bearer ${input.bearer}`, "content-type": encoded.headers.get("content-type") },
+            body: bodyBytes
+          });
+          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;
+          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
+            }
+          });
+        }
       }
       async requestSkillIntent(body, bearer) {
-        return readBoundedJson(await this.skillFetch("/api/skills/intents", {
-          method: "POST",
-          headers: { authorization: `Bearer ${bearer}`, "content-type": "application/json" },
-          body: JSON.stringify(body)
-        }));
+        let response;
+        try {
+          response = await this.skillFetch("/api/skills/intents", {
+            method: "POST",
+            headers: { authorization: `Bearer ${bearer}`, "content-type": "application/json" },
+            body: JSON.stringify(body)
+          });
+          return assertSchema(skillUnsignedIntentResponseSchema, await readBoundedJson(response, 65536, true), intentDiagnosticPaths);
+        } catch (cause) {
+          if (!(cause instanceof CliHttpError)) throw cause;
+          throw new CliHttpError(cause.code, cause.status ?? response?.status ?? null, {
+            cause,
+            ...cause.envelope !== null ? { envelope: cause.envelope } : {},
+            diagnostic: {
+              ...response === void 0 ? {} : skillHttpDiagnostic(response, void 0),
+              ...cause.diagnostic,
+              ...cause.status === null && response === void 0 ? { responseIssue: "transport_failed" } : {},
+              remotePath: "/api/skills/intents"
+            }
+          });
+        }
       }
       async resolveSkillId(chainId, slug, bearer) {
         let response;
@@ -55748,26 +56091,43 @@ function legacyIntent(value, walletAddress2, authority) {
 }
 async function readPublishablePath(inputPath) {
   const root = resolve2(inputPath);
-  const rootStat = await lstat2(root);
-  if (rootStat.isSymbolicLink()) throw new TypeError("Skill publication path cannot be a symbolic link.");
+  const unreadable = (path2) => new CliSkillSourceError("SKILL_SOURCE_UNREADABLE", { path: path2 }, "Skill source cannot be read. Check the selected path and filesystem permissions.");
+  const rootStat = await lstat2(root).catch(() => {
+    throw unreadable(".");
+  });
+  if (rootStat.isSymbolicLink()) throw new CliSkillSourceError("SKILL_SOURCE_SYMLINK_UNSUPPORTED", { path: "." }, "Skill source does not support symbolic links, including broken links.");
   if (rootStat.isFile()) return {
     sourceKind: "file",
-    files: [{ path: basename(root), content: new Uint8Array(await readFile2(root)) }]
+    files: [{ path: basename(root), content: new Uint8Array(await readFile2(root).catch(() => {
+      throw unreadable(".");
+    })) }],
+    excluded: []
   };
   if (!rootStat.isDirectory()) throw new TypeError("Skill publication path must be one regular file or directory.");
   const files = [];
+  const excluded = [];
   const prefix = basename(root);
   const walk3 = async (directory) => {
-    const entries = (await readdir(directory, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name, "en"));
+    const entries = (await readdir(directory, { withFileTypes: true }).catch(() => {
+      throw unreadable(relative2(root, directory).split(sep2).join("/") || ".");
+    })).sort((left, right) => left.name.localeCompare(right.name, "en"));
     for (const entry2 of entries) {
       const path2 = join2(directory, entry2.name);
-      if (entry2.isSymbolicLink()) throw new TypeError(`Skill publication path contains a symbolic link: ${entry2.name}`);
+      const relativePath = relative2(root, path2).split(sep2).join("/");
+      const packagePath = `${prefix}/${relativePath}`;
+      if (isExcludedSkillPath(packagePath)) {
+        excluded.push(packagePath);
+        continue;
+      }
+      if (entry2.isSymbolicLink()) throw new CliSkillSourceError("SKILL_SOURCE_SYMLINK_UNSUPPORTED", { path: relativePath }, "Skill source does not support symbolic links, including broken links.");
       if (entry2.isDirectory()) await walk3(path2);
-      else if (entry2.isFile()) files.push({ path: `${prefix}/${relative2(root, path2).split(sep2).join("/")}`, content: new Uint8Array(await readFile2(path2)) });
+      else if (entry2.isFile()) files.push({ path: packagePath, content: new Uint8Array(await readFile2(path2).catch(() => {
+        throw unreadable(relativePath);
+      })) });
     }
   };
   await walk3(root);
-  return { sourceKind: "directory", files };
+  return { sourceKind: "directory", files, excluded };
 }
 function sourceKind(value) {
   if (value !== "file" && value !== "directory") throw new TypeError("Skill sourceKind is invalid.");
@@ -55993,16 +56353,20 @@ function recoveryJournal(value, fingerprint2, kind, context) {
     "targetVersion",
     "requests",
     "receipts",
-    ...journal.version === 5 ? ["sourceHash"] : []
+    ...journal.version === 5 || journal.version === 6 ? ["sourceHash"] : [],
+    ...journal.version === 6 ? ["pendingStage"] : []
   ], "Skill publication recovery");
   const chainId = skillChain(journal.chainId, "Skill recovery chain");
-  if (journal.version !== 4 && journal.version !== 5 || journal.kind !== kind || journal.fingerprint !== fingerprint2 || !/^[0-9a-f]{64}$/u.test(fingerprint2) || typeof journal.walletAddress !== "string" || journal.walletAddress.toLowerCase() !== context.walletAddress.toLowerCase()) throw new TypeError("Skill publication recovery authority does not match this command.");
+  if (journal.version !== 4 && journal.version !== 5 && journal.version !== 6 || journal.kind !== kind || journal.fingerprint !== fingerprint2 || !/^[0-9a-f]{64}$/u.test(fingerprint2) || typeof journal.walletAddress !== "string" || journal.walletAddress.toLowerCase() !== context.walletAddress.toLowerCase()) throw new TypeError("Skill publication recovery authority does not match this command.");
   const recoveredAuthority = assertPublicationAuthority(
     signingAuthority(journal.signingAuthority, context.walletAddress),
     context
   );
   string4(journal.packageHash, "Skill recovery package hash", HASH2);
-  if (journal.version === 5) string4(journal.sourceHash, "Skill recovery source hash", HASH2);
+  if (journal.version === 5 || journal.version === 6) string4(journal.sourceHash, "Skill recovery source hash", HASH2);
+  if (journal.version === 6 && journal.pendingStage !== null && !["primary", "uri", "lit"].includes(String(journal.pendingStage))) {
+    throw new TypeError("Skill recovery pending stage is invalid.");
+  }
   const encodedPackage = string4(journal.packageBytesBase64, "Skill recovery package bytes");
   const packageBytes = Buffer.from(encodedPackage, "base64");
   if (packageBytes.byteLength < 1 || packageBytes.byteLength > MAX_ENCRYPTED_BYTES || packageBytes.toString("base64") !== encodedPackage) throw new TypeError("Skill recovery package bytes are invalid.");
@@ -56052,6 +56416,7 @@ var init_skill_local_flow = __esm({
     "use strict";
     init_src2();
     init_client();
+    init_cli_error();
     MAX_ENCRYPTED_BYTES = 10 * 1024 * 1024;
     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;
@@ -56072,6 +56437,33 @@ var init_skill_local_flow = __esm({
       pause;
       nonce;
       recovery;
+      async publication(work) {
+        const progress = { phase: "validation", journalSaved: false, uncertain: false };
+        try {
+          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 fingerprint2 = progress.journal && progress.fingerprint ? progress.fingerprint : null;
+          throw new CliSkillPublicationError({
+            phase: progress.phase,
+            fingerprint: fingerprint2,
+            transactionHashes,
+            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
+          }, cause);
+        }
+      }
+      async publish(path2, plan, context) {
+        return this.publication((progress) => this.publishWithProgress(path2, plan, context, progress));
+      }
+      async publishVersion(path2, plan, context) {
+        return this.publication((progress) => this.publishVersionWithProgress(path2, plan, context, progress));
+      }
+      async recoverPublication(fingerprint2, context) {
+        return this.publication((progress) => this.recoverWithProgress(fingerprint2, context, progress));
+      }
       async send(context, action, request, prepared, authority, onBroadcast) {
         return required2(this.sender.submitPrepared, "Skill prepared-intent sender").call(this.sender, {
           privateKey: context.privateKey,
@@ -56084,7 +56476,7 @@ var init_skill_local_flow = __esm({
       }
       async upload(input) {
         const { bytes } = input;
-        if (bytes.byteLength === 0 || bytes.byteLength > MAX_ENCRYPTED_BYTES) throw new RangeError("Skill upload must be between 1 byte and 10 MiB.");
+        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.");
         const result2 = await required2(this.api.uploadSkillObject, "Skill upload").call(this.api, input);
         return string4(result2.uri, "Pinned Skill URI", IPFS);
       }
@@ -56129,25 +56521,49 @@ var init_skill_local_flow = __esm({
         if ("delivery" in grant && grant.delivery === "oracle-v2") return openOracleKey(grant, device.privateKey);
         throw new TypeError("Encrypted Skill downloads require an Oracle V2 sealed grant. Update the gateway.");
       }
-      async package(files, mode) {
-        if (mode === "plaintext") {
-          const archived = await archivePackage(files, buildZip);
+      async package(files, mode, excluded = []) {
+        try {
+          if (mode === "plaintext") {
+            const archived = await archivePackage(files, buildZip);
+            return Object.freeze({
+              archive: archived,
+              contentKey: null,
+              packageHash: archived.packageHash,
+              mdHash: archived.primary.mdHash,
+              excluded: [...excluded, ...archived.excluded]
+            });
+          }
+          const sealed = await prepareRootPackage(files, buildZip);
           return Object.freeze({
-            archive: archived,
-            contentKey: null,
-            packageHash: archived.packageHash,
-            mdHash: archived.primary.mdHash,
-            excluded: archived.excluded
+            archive: sealed,
+            contentKey: sealed.contentKeyBase64,
+            packageHash: sealed.packageHash,
+            mdHash: sealed.primary.mdHash,
+            excluded: [...excluded, ...sealed.excluded]
           });
+        } catch (error51) {
+          if (error51 instanceof SkillZipSymlinkError) throw new CliSkillSourceError(
+            "SKILL_SOURCE_SYMLINK_UNSUPPORTED",
+            { path: error51.path },
+            "Skill source does not support symbolic links, including ZIP entries."
+          );
+          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.",
+              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."
+            };
+            throw new CliSkillSourceError("SKILL_SOURCE_ZIP_INVALID", { zipReason: error51.reason, ...error51.details }, messages[error51.reason]);
+          }
+          if (error51 instanceof SkillPrimaryDocumentError) throw new CliSkillSourceError(
+            "SKILL_SOURCE_PRIMARY_DOCUMENT_INVALID",
+            {},
+            "Skill package needs a valid UTF-8 SKILL.md or README.md at its root, or exactly one root Markdown file."
+          );
+          throw error51;
         }
-        const sealed = await prepareRootPackage(files, buildZip);
-        return Object.freeze({
-          archive: sealed,
-          contentKey: sealed.contentKeyBase64,
-          packageHash: sealed.packageHash,
-          mdHash: sealed.primary.mdHash,
-          excluded: sealed.excluded
-        });
       }
       async protectedEnvelope(context, chainId, skillId, version6, mode, packageContentKey) {
         if (mode === "finchip_v2") {
@@ -56201,15 +56617,31 @@ var init_skill_local_flow = __esm({
       async project(chainId, transactionHash3, bearer) {
         await this.api.confirmSkillProjection?.(chainId, transactionHash3, bearer);
       }
-      async stage(context, fingerprint2, journal, stage, action, request, prepare) {
+      async stage(progress, context, fingerprint2, journal, stage, action, request, prepare) {
+        progress.journal = journal;
+        progress.fingerprint = fingerprint2;
+        progress.journalSaved = true;
+        progress.phase = "transaction";
         const existing = journal.receipts[stage];
         if (existing !== null) {
           journal.receipts[stage] = await this.verify(context, action, request, existing);
+          if (journal.pendingStage === stage) journal.pendingStage = null;
           await this.save(fingerprint2, journal);
+          progress.uncertain = false;
+          progress.phase = "projection";
           await this.project(journal.chainId, journal.receipts[stage].transactionHash, context.bearer);
           return;
         }
+        if (journal.version !== 6 || journal.pendingStage != null) {
+          progress.uncertain = true;
+          throw new Error("Skill transaction submission state is uncertain. Contact support before retrying.");
+        }
+        progress.phase = "intent";
         const prepared = await prepare();
+        progress.phase = "transaction";
+        journal.pendingStage = stage;
+        await this.save(fingerprint2, journal);
+        progress.uncertain = true;
         journal.receipts[stage] = await this.send(
           context,
           action,
@@ -56219,12 +56651,19 @@ 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);
+            progress.uncertain = false;
           }
         );
+        journal.pendingStage = null;
         await this.save(fingerprint2, journal);
+        progress.uncertain = false;
+        progress.phase = "projection";
         await this.project(journal.chainId, journal.receipts[stage].transactionHash, context.bearer);
       }
-      async recoverPublication(fingerprint2, context) {
+      async recoverWithProgress(fingerprint2, context, progress) {
+        progress.phase = "recovery";
         if (!/^[0-9a-f]{64}$/u.test(fingerprint2)) throw new TypeError("Skill publication recovery fingerprint is invalid.");
         const store = required2(this.recovery, "Skill publication recovery");
         const stored = await store.readSkillPublicationRecovery(fingerprint2);
@@ -56232,8 +56671,12 @@ var init_skill_local_flow = __esm({
         const candidate = object2(stored, "Skill publication recovery");
         if (candidate.kind !== "publish" && candidate.kind !== "version") throw new TypeError("Skill publication recovery kind is invalid.");
         const journal = recoveryJournal(stored, fingerprint2, candidate.kind, context);
+        progress.journal = journal;
+        progress.fingerprint = fingerprint2;
+        progress.journalSaved = true;
         if (journal.kind === "publish") {
           await this.stage(
+            progress,
             context,
             fingerprint2,
             journal,
@@ -56258,6 +56701,7 @@ var init_skill_local_flow = __esm({
           journal.skillId = skillId2;
           if (journal.contentMode !== "plaintext") {
             if (journal.requests.lit === null) {
+              progress.phase = "key_custody";
               journal.requests.lit = await this.protectedEnvelope(
                 context,
                 journal.chainId,
@@ -56270,6 +56714,7 @@ var init_skill_local_flow = __esm({
             }
             const litRequest = required2(journal.requests.lit, "Skill Lit recovery request");
             await this.stage(
+              progress,
               context,
               fingerprint2,
               journal,
@@ -56279,6 +56724,7 @@ var init_skill_local_flow = __esm({
               () => required2(this.api.requestSkillIntent, "Skill intent API").call(this.api, litRequest, context.bearer)
             );
           }
+          progress.phase = "cleanup";
           await store.clearSkillPublicationRecovery(fingerprint2);
           return {
             chainId: journal.chainId,
@@ -56297,6 +56743,7 @@ var init_skill_local_flow = __esm({
         }
         const skillId = required2(journal.skillId, "Skill recovery id");
         await this.stage(
+          progress,
           context,
           fingerprint2,
           journal,
@@ -56316,6 +56763,7 @@ var init_skill_local_flow = __esm({
         );
         const uriRequest = required2(journal.requests.uri, "Skill URI recovery request");
         await this.stage(
+          progress,
           context,
           fingerprint2,
           journal,
@@ -56326,6 +56774,7 @@ var init_skill_local_flow = __esm({
         );
         if (journal.contentMode !== "plaintext") {
           if (journal.requests.lit === null) {
+            progress.phase = "key_custody";
             journal.requests.lit = await this.protectedEnvelope(
               context,
               journal.chainId,
@@ -56338,6 +56787,7 @@ var init_skill_local_flow = __esm({
           }
           const litRequest = required2(journal.requests.lit, "Skill Lit recovery request");
           await this.stage(
+            progress,
             context,
             fingerprint2,
             journal,
@@ -56347,6 +56797,7 @@ var init_skill_local_flow = __esm({
             () => required2(this.api.requestSkillIntent, "Skill intent API").call(this.api, litRequest, context.bearer)
           );
         }
+        progress.phase = "cleanup";
         await store.clearSkillPublicationRecovery(fingerprint2);
         return {
           chainId: journal.chainId,
@@ -56364,23 +56815,32 @@ var init_skill_local_flow = __esm({
           }
         };
       }
-      async publish(path2, planValue, context) {
+      async publishWithProgress(path2, planValue, context, progress) {
         const plan = publishPlan(planValue, context);
         const request = plan.request;
         const fingerprint2 = recoveryFingerprint("publish", planValue, context.walletAddress);
         const store = required2(this.recovery, "Skill publication recovery");
+        progress.phase = "recovery";
+        const prior = await store.readSkillPublicationRecovery(fingerprint2);
+        if (prior !== null) {
+          progress.journal = recoveryJournal(prior, fingerprint2, "publish", context);
+          progress.fingerprint = fingerprint2;
+          progress.journalSaved = true;
+        }
+        progress.phase = "source";
         const selected = await readPublishablePath(path2);
         const expectedSourceKind = sourceKind(request.sourceKind);
         const mode = contentMode(request.contentMode);
         if (selected.sourceKind !== expectedSourceKind) throw new TypeError(`Skill plan requires a ${expectedSourceKind} source.`);
-        const prior = await store.readSkillPublicationRecovery(fingerprint2);
-        const packaged = await this.package(selected.files, prior === null ? mode : "plaintext");
+        progress.phase = "packaging";
+        const packaged = await this.package(selected.files, prior === null ? mode : "plaintext", selected.excluded);
         let journal;
         if (prior !== null) {
           journal = recoveryJournal(prior, fingerprint2, "publish", context);
           if (journal.sourceKind !== expectedSourceKind || journal.contentMode !== mode || (journal.sourceHash ?? journal.packageHash).toLowerCase() !== packaged.packageHash.toLowerCase() || canonical(journal.excluded) !== canonical(packaged.excluded)) throw new TypeError("Skill publication content no longer matches its protected recovery.");
         } else {
           let publishedBytes;
+          progress.phase = "packaging";
           const entry2 = await buildPublicationEntry({
             files: selected.files,
             archive: packaged.archive,
@@ -56389,6 +56849,7 @@ var init_skill_local_flow = __esm({
             summary: request.summary === void 0 ? "" : String(request.summary),
             pinBundle: async (bytes) => {
               publishedBytes = bytes;
+              progress.phase = "upload";
               return this.upload({
                 bytes,
                 filename: `${request.slug}.skillroot.zip`,
@@ -56418,7 +56879,8 @@ var init_skill_local_flow = __esm({
             packageURI: manifestURI
           };
           journal = {
-            version: 5,
+            version: 6,
+            pendingStage: null,
             sourceHash: packaged.packageHash,
             kind: "publish",
             fingerprint: fingerprint2,
@@ -56438,9 +56900,14 @@ var init_skill_local_flow = __esm({
             requests: { primary: createRequest, uri: null, lit: null },
             receipts: { primary: null, uri: null, lit: null }
           };
+          progress.journal = journal;
+          progress.fingerprint = fingerprint2;
+          progress.phase = "recovery";
           await this.save(fingerprint2, journal);
+          progress.journalSaved = true;
         }
         await this.stage(
+          progress,
           context,
           fingerprint2,
           journal,
@@ -56464,6 +56931,7 @@ var init_skill_local_flow = __esm({
         journal.skillId = skillId;
         if (journal.contentMode !== "plaintext") {
           if (journal.requests.lit === null) {
+            progress.phase = "key_custody";
             journal.requests.lit = await this.protectedEnvelope(
               context,
               journal.chainId,
@@ -56476,6 +56944,7 @@ var init_skill_local_flow = __esm({
           }
           const litRequest = required2(journal.requests.lit, "Skill Lit recovery request");
           await this.stage(
+            progress,
             context,
             fingerprint2,
             journal,
@@ -56485,14 +56954,21 @@ var init_skill_local_flow = __esm({
             () => required2(this.api.requestSkillIntent, "Skill intent API").call(this.api, litRequest, context.bearer)
           );
         }
+        progress.phase = "cleanup";
         await store.clearSkillPublicationRecovery(fingerprint2);
         return { chainId: journal.chainId, skillId, version: 1, contentMode: journal.contentMode, packageHash: journal.packageHash, excluded: journal.excluded, transactions: { create: required2(journal.receipts.primary, "Skill create receipt").transactionHash, ...journal.contentMode === "plaintext" ? {} : { setLitData: required2(journal.receipts.lit, "Skill Lit receipt").transactionHash } } };
       }
-      async publishVersion(path2, planValue, context) {
+      async publishVersionWithProgress(path2, planValue, context, progress) {
         const plan = versionPlan(planValue, context);
         const fingerprint2 = recoveryFingerprint("version", planValue, context.walletAddress);
+        progress.phase = "recovery";
         const store = required2(this.recovery, "Skill publication recovery");
         const prior = await store.readSkillPublicationRecovery(fingerprint2);
+        if (prior !== null) {
+          progress.journal = recoveryJournal(prior, fingerprint2, "version", context);
+          progress.fingerprint = fingerprint2;
+          progress.journalSaved = true;
+        }
         const observedVersion = await required2(this.api.readSkillCurrentVersion, "Skill version API").call(
           this.api,
           plan.chainId,
@@ -56502,9 +56978,11 @@ var init_skill_local_flow = __esm({
         if (prior === null && observedVersion !== plan.currentVersion) {
           throw new TypeError(`Skill current version ${observedVersion} no longer matches plan version ${plan.currentVersion}.`);
         }
+        progress.phase = "source";
         const selected = await readPublishablePath(path2);
         if (selected.sourceKind !== plan.sourceKind) throw new TypeError(`Skill plan requires a ${plan.sourceKind} source.`);
-        const packaged = await this.package(selected.files, prior === null ? plan.contentMode : "plaintext");
+        progress.phase = "packaging";
+        const packaged = await this.package(selected.files, prior === null ? plan.contentMode : "plaintext", selected.excluded);
         let journal;
         if (prior !== null) {
           journal = recoveryJournal(prior, fingerprint2, "version", context);
@@ -56516,6 +56994,7 @@ var init_skill_local_flow = __esm({
           const previous = packageForVersion(currentManifest, plan.currentVersion);
           if (previous === null) throw new TypeError("Current Skill version is missing from its manifest.");
           let publishedBytes;
+          progress.phase = "packaging";
           const entry2 = await buildPublicationEntry({
             files: selected.files,
             archive: packaged.archive,
@@ -56523,9 +57002,10 @@ var init_skill_local_flow = __esm({
             previous,
             pinBundle: async (bytes, legacy) => {
               publishedBytes = bytes;
+              progress.phase = "upload";
               return this.upload({
                 bytes,
-                filename: `skill-${plan.request.skillId}-v${plan.nextVersion}.skillroot.zip`,
+                filename: `skill-${plan.request.skillId}-v${plan.nextVersion}${legacy ? plan.contentMode === "plaintext" ? ".zip" : ".enc" : ".skillroot.zip"}`,
                 bearer: context.bearer,
                 objectKind: "package",
                 sourceKind: legacy ? plan.sourceKind : "file",
@@ -56543,7 +57023,8 @@ var init_skill_local_flow = __esm({
           const updateRequest = { action: "updateSkill", chainId: plan.chainId, skillId: plan.request.skillId, mdHash: packaged.mdHash, packageHash: entry2.packageHash, packageURI: manifestURI };
           const uriRequest2 = { action: "setSkillURI", chainId: plan.chainId, skillId: plan.request.skillId, packageURI: manifestURI };
           journal = {
-            version: 5,
+            version: 6,
+            pendingStage: null,
             sourceHash: packaged.packageHash,
             kind: "version",
             fingerprint: fingerprint2,
@@ -56563,9 +57044,14 @@ var init_skill_local_flow = __esm({
             requests: { primary: updateRequest, uri: uriRequest2, lit: null },
             receipts: { primary: null, uri: null, lit: null }
           };
+          progress.journal = journal;
+          progress.fingerprint = fingerprint2;
+          progress.phase = "recovery";
           await this.save(fingerprint2, journal);
+          progress.journalSaved = true;
         }
         await this.stage(
+          progress,
           context,
           fingerprint2,
           journal,
@@ -56582,6 +57068,7 @@ var init_skill_local_flow = __esm({
         ) === plan.nextVersion, `Skill ${plan.request.skillId} version ${plan.nextVersion}`);
         const uriRequest = required2(journal.requests.uri, "Skill URI recovery request");
         await this.stage(
+          progress,
           context,
           fingerprint2,
           journal,
@@ -56592,6 +57079,7 @@ var init_skill_local_flow = __esm({
         );
         if (journal.contentMode !== "plaintext") {
           if (journal.requests.lit === null) {
+            progress.phase = "key_custody";
             journal.requests.lit = await this.protectedEnvelope(
               context,
               journal.chainId,
@@ -56604,6 +57092,7 @@ var init_skill_local_flow = __esm({
           }
           const litRequest = required2(journal.requests.lit, "Skill Lit recovery request");
           await this.stage(
+            progress,
             context,
             fingerprint2,
             journal,
@@ -56613,6 +57102,7 @@ var init_skill_local_flow = __esm({
             () => required2(this.api.requestSkillIntent, "Skill intent API").call(this.api, litRequest, context.bearer)
           );
         }
+        progress.phase = "cleanup";
         await store.clearSkillPublicationRecovery(fingerprint2);
         return { chainId: journal.chainId, skillId: plan.request.skillId, version: plan.nextVersion, contentMode: journal.contentMode, packageHash: journal.packageHash, excluded: journal.excluded, transactions: { update: required2(journal.receipts.primary, "Skill update receipt").transactionHash, setSkillURI: required2(journal.receipts.uri, "Skill URI receipt").transactionHash, ...journal.contentMode === "plaintext" ? {} : { setLitData: required2(journal.receipts.lit, "Skill Lit receipt").transactionHash } } };
       }
@@ -56673,12 +57163,12 @@ var init_skill_local_flow = __esm({
       async download(planValue, context) {
         const plan = deliveryPlan(planValue, context);
         const located = await this.fetchDeliveryContent(plan.packageURI, context?.bearer);
-        const manifest3 = parseManifest(located);
+        const manifest4 = parseManifest(located);
         let stored = located;
         const expectedHash = plan.packageHash;
-        const root = manifest3 === null ? void 0 : packageForVersion(manifest3, plan.version)?.skillRoot;
-        if (manifest3 !== null) {
-          const entry2 = packageForVersion(manifest3, plan.version);
+        const root = manifest4 === null ? void 0 : packageForVersion(manifest4, plan.version)?.skillRoot;
+        if (manifest4 !== null) {
+          const entry2 = packageForVersion(manifest4, plan.version);
           if (entry2 === null) throw new TypeError(`Skill manifest does not list version ${plan.version}.`);
           if (entry2.packageHash.toLowerCase() !== plan.packageHash.toLowerCase()) throw new TypeError("Skill manifest package hash does not match chain authority.");
           stored = await this.fetchDeliveryContent(entry2.packageURI, context?.bearer);
@@ -56857,48 +57347,6 @@ var init_skill_buyer_intent_journal = __esm({
   }
 });
 
-// src/cli-error.ts
-var CliAuthorityError, CliProductionUnavailableError, BrowserOpenError, PUBLIC_RECOVERY_COMMAND, CliRecoveryBlockedError;
-var init_cli_error = __esm({
-  "src/cli-error.ts"() {
-    "use strict";
-    CliAuthorityError = class extends Error {
-      code = "MCP_CLI_WALLET_MISMATCH";
-      constructor(code = "MCP_CLI_WALLET_MISMATCH") {
-        super(code);
-        this.name = "CliAuthorityError";
-      }
-    };
-    CliProductionUnavailableError = class extends Error {
-      code = "PRODUCTION_NOT_AVAILABLE";
-      constructor() {
-        super("PRODUCTION_NOT_AVAILABLE");
-        this.name = "CliProductionUnavailableError";
-      }
-    };
-    BrowserOpenError = class extends Error {
-      code = "BROWSER_OPEN_FAILED";
-      constructor() {
-        super("BROWSER_OPEN_FAILED");
-        this.name = "BrowserOpenError";
-      }
-    };
-    PUBLIC_RECOVERY_COMMAND = /^(?:finch purchase (?:submit|recover-approval) [0-9a-f-]+(?: --transaction-hash 0x[0-9a-f]{64})?|finch task recover [0-9a-f-]+ (?:publish|award|reclaim)|finch skill recover (?:publication|intent) [0-9a-f]{64})$/u;
-    CliRecoveryBlockedError = class extends Error {
-      code = "CLI_RECOVERY_BLOCKED";
-      recoveryCommands;
-      constructor(recoveryCommands) {
-        if (recoveryCommands.length === 0 || recoveryCommands.some((command) => !PUBLIC_RECOVERY_COMMAND.test(command))) {
-          throw new TypeError("Recovery commands must contain only supported public recovery syntax.");
-        }
-        super("CLI_RECOVERY_BLOCKED");
-        this.name = "CliRecoveryBlockedError";
-        this.recoveryCommands = Object.freeze([...new Set(recoveryCommands)].sort());
-      }
-    };
-  }
-});
-
 // src/application.ts
 import { createHash as createHash3, randomUUID } from "node:crypto";
 import { open as open2 } from "node:fs/promises";
@@ -57665,6 +58113,11 @@ var init_application = __esm({
         }
         return Object.freeze({
           ready: true,
+          readinessScope: "cli_session_and_mcp_discovery",
+          harnessOAuth: Object.freeze({
+            status: "not_checked",
+            guidance: "Verify the connected MCP identity with identity_actor_get and compare it with finch status. If the Harness reports missing or expired OAuth credentials, reauthorize through its native MCP login flow."
+          }),
           environment: session.environment,
           origin: profile.origin,
           loginChainId: session.loginChainId,
@@ -58484,7 +58937,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@finchtech/cli",
-      version: "0.3.1",
+      version: "0.3.3",
       description: "Finch Agent CLI for wallet-owned marketplace and MCP workflows.",
       type: "module",
       bin: {
@@ -59543,6 +59996,8 @@ function hasAgentPurchaseCheckpoint(value) {
 }
 function hasSkillPublicationCheckpoint(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const journal = value;
+  if (journal.version === 6 && ["primary", "uri", "lit"].includes(String(journal.pendingStage))) return true;
   const receipts = value.receipts;
   if (typeof receipts !== "object" || receipts === null || Array.isArray(receipts)) return false;
   const stages = receipts;
@@ -61620,6 +62075,14 @@ function localFailureMessage(error51) {
   return "Command input does not match the expected schema. Check finch help for this command.";
 }
 function failure(error51) {
+  if (error51 instanceof CliSkillSourceError) {
+    return {
+      code: "AGENT_MARKET_REQUEST_INVALID",
+      exitCode: 2,
+      message: error51.message,
+      state: JSON.stringify({ diagnosticCode: error51.diagnosticCode, ...error51.details })
+    };
+  }
   if (error51 instanceof CliAuthorityError) {
     return {
       code: error51.code,
@@ -61662,6 +62125,30 @@ function emitCliOutcome(outcome, sinks) {
 `);
     return AGENT_CLI_OUTPUT_CONTRACT.exitCodes.success;
   }
+  if (outcome instanceof CliSkillPublicationError) {
+    let serialized = "";
+    const cause = outcome.cause instanceof Error ? outcome.cause : new Error("Skill publication failed.");
+    const exitCode = emitCliOutcome(cause, { stdout: (value) => {
+      serialized = value;
+    }, stderr: sinks.stderr });
+    const envelope2 = JSON.parse(serialized);
+    const source = cause instanceof CliSkillSourceError ? cause : null;
+    const remote = cause instanceof CliHttpError && cause.envelope !== null;
+    const diagnostic = outcome.diagnostic;
+    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 } : {}
+    });
+    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";
+    sinks.stdout(`${JSON.stringify(envelope2)}
+`);
+    return exitCode;
+  }
   if (outcome instanceof BrowserOpenError) {
     sinks.stdout(`${JSON.stringify({ error: {
       code: outcome.code,
@@ -61692,7 +62179,7 @@ function emitCliOutcome(outcome, sinks) {
       reasonCode: null,
       retryable: definition.retryable,
       nextAction: definition.nextAction,
-      state: mapped.state ?? null,
+      state: mapped.state ?? (outcome instanceof CliHttpError && outcome.diagnostic !== null ? JSON.stringify({ remoteStatus: outcome.status, ...outcome.diagnostic }) : null),
       operationId: null,
       currentRevision: null,
       currentEtag: null,