dorkos 0.34.1 → 0.36.0

package/dist/bin/cli.js

@@ -290,10 +290,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path14) {
-  if (!path14)
+function getElementAtPath(obj, path15) {
+  if (!path15)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -605,11 +605,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path14, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -850,8 +850,8 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
   return fieldErrors;
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
-  const result = { errors: [] };
-  const processError = (error49, path14 = []) => {
+  const result2 = { errors: [] };
+  const processError = (error49, path15 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -861,12 +861,12 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
-          result.errors.push(mapper(issue2));
+          result2.errors.push(mapper(issue2));
           continue;
         }
-        let curr = result;
+        let curr = result2;
         let i2 = 0;
         while (i2 < fullpath.length) {
           const el = fullpath[i2];
@@ -889,12 +889,12 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
     }
   };
   processError(error48);
-  return result;
+  return result2;
 }
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -954,52 +954,52 @@ var init_parse = __esm({
     init_util();
     _parse = (_Err) => (schema, value, _ctx, _params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
-      const result = schema._zod.run({ value, issues: [] }, ctx);
-      if (result instanceof Promise) {
+      const result2 = schema._zod.run({ value, issues: [] }, ctx);
+      if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
-      if (result.issues.length) {
-        const e2 = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+      if (result2.issues.length) {
+        const e2 = new (_params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
         captureStackTrace(e2, _params?.callee);
         throw e2;
       }
-      return result.value;
+      return result2.value;
     };
     parse = /* @__PURE__ */ _parse($ZodRealError);
     _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-      let result = schema._zod.run({ value, issues: [] }, ctx);
-      if (result instanceof Promise)
-        result = await result;
-      if (result.issues.length) {
-        const e2 = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+      let result2 = schema._zod.run({ value, issues: [] }, ctx);
+      if (result2 instanceof Promise)
+        result2 = await result2;
+      if (result2.issues.length) {
+        const e2 = new (params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
         captureStackTrace(e2, params?.callee);
         throw e2;
       }
-      return result.value;
+      return result2.value;
     };
     parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
     _safeParse = (_Err) => (schema, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result = schema._zod.run({ value, issues: [] }, ctx);
-      if (result instanceof Promise) {
+      const result2 = schema._zod.run({ value, issues: [] }, ctx);
+      if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
-      return result.issues.length ? {
+      return result2.issues.length ? {
         success: false,
-        error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-      } : { success: true, data: result.value };
+        error: new (_Err ?? $ZodError)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+      } : { success: true, data: result2.value };
     };
     safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
     _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-      let result = schema._zod.run({ value, issues: [] }, ctx);
-      if (result instanceof Promise)
-        result = await result;
-      return result.issues.length ? {
+      let result2 = schema._zod.run({ value, issues: [] }, ctx);
+      if (result2 instanceof Promise)
+        result2 = await result2;
+      return result2.issues.length ? {
         success: false,
-        error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-      } : { success: true, data: result.value };
+        error: new _Err(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+      } : { success: true, data: result2.value };
     };
     safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
     _encode = (_Err) => (schema, value, _ctx) => {
@@ -1205,9 +1205,9 @@ var init_regexes = __esm({
 });
 
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
-function handleCheckPropertyResult(result, payload, property) {
-  if (result.issues.length) {
-    payload.issues.push(...prefixIssues(property, result.issues));
+function handleCheckPropertyResult(result2, payload, property) {
+  if (result2.issues.length) {
+    payload.issues.push(...prefixIssues(property, result2.issues));
   }
 }
 var $ZodCheck, numericOriginMap, $ZodCheckLessThan, $ZodCheckGreaterThan, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckBigIntFormat, $ZodCheckMaxSize, $ZodCheckMinSize, $ZodCheckSizeEquals, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckLengthEquals, $ZodCheckStringFormat, $ZodCheckRegex, $ZodCheckLowerCase, $ZodCheckUpperCase, $ZodCheckIncludes, $ZodCheckStartsWith, $ZodCheckEndsWith, $ZodCheckProperty, $ZodCheckMimeType, $ZodCheckOverwrite;
@@ -1722,14 +1722,14 @@ var init_checks = __esm({
     $ZodCheckProperty = /* @__PURE__ */ $constructor("$ZodCheckProperty", (inst, def) => {
       $ZodCheck.init(inst, def);
       inst._zod.check = (payload) => {
-        const result = def.schema._zod.run({
+        const result2 = def.schema._zod.run({
           value: payload.value[def.property],
           issues: []
         }, {});
-        if (result instanceof Promise) {
-          return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property));
+        if (result2 instanceof Promise) {
+          return result2.then((result3) => handleCheckPropertyResult(result3, payload, def.property));
         }
-        handleCheckPropertyResult(result, payload, def.property);
+        handleCheckPropertyResult(result2, payload, def.property);
         return;
       };
     });
@@ -1853,25 +1853,25 @@ function isValidJWT(token, algorithm = null) {
     return false;
   }
 }
-function handleArrayResult(result, final, index) {
-  if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+function handleArrayResult(result2, final, index) {
+  if (result2.issues.length) {
+    final.issues.push(...prefixIssues(index, result2.issues));
   }
-  final.value[index] = result.value;
+  final.value[index] = result2.value;
 }
-function handlePropertyResult(result, final, key, input2, isOptionalOut) {
-  if (result.issues.length) {
+function handlePropertyResult(result2, final, key, input2, isOptionalOut) {
+  if (result2.issues.length) {
     if (isOptionalOut && !(key in input2)) {
       return;
     }
-    final.issues.push(...prefixIssues(key, result.issues));
+    final.issues.push(...prefixIssues(key, result2.issues));
   }
-  if (result.value === void 0) {
+  if (result2.value === void 0) {
     if (key in input2) {
       final.value[key] = void 0;
     }
   } else {
-    final.value[key] = result.value;
+    final.value[key] = result2.value;
   }
 }
 function normalizeDef(def) {
@@ -1925,9 +1925,9 @@ function handleCatchall(proms, input2, payload, ctx, def, inst) {
   });
 }
 function handleUnionResults(results, final, inst, ctx) {
-  for (const result of results) {
-    if (result.issues.length === 0) {
-      final.value = result.value;
+  for (const result2 of results) {
+    if (result2.issues.length === 0) {
+      final.value = result2.value;
       return final;
     }
   }
@@ -1940,7 +1940,7 @@ function handleUnionResults(results, final, inst, ctx) {
     code: "invalid_union",
     input: final.value,
     inst,
-    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
   });
   return final;
 }
@@ -1955,7 +1955,7 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
       code: "invalid_union",
       input: final.value,
       inst,
-      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+      errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
     });
   } else {
     final.issues.push({
@@ -2012,7 +2012,7 @@ function mergeValues(a2, b2) {
   }
   return { valid: false, mergeErrorPath: [] };
 }
-function handleIntersectionResults(result, left, right) {
+function handleIntersectionResults(result2, left, right) {
   const unrecKeys = /* @__PURE__ */ new Map();
   let unrecIssue;
   for (const iss of left.issues) {
@@ -2024,7 +2024,7 @@ function handleIntersectionResults(result, left, right) {
         unrecKeys.get(k2).l = true;
       }
     } else {
-      result.issues.push(iss);
+      result2.issues.push(iss);
     }
   }
   for (const iss of right.issues) {
@@ -2035,27 +2035,27 @@ function handleIntersectionResults(result, left, right) {
         unrecKeys.get(k2).r = true;
       }
     } else {
-      result.issues.push(iss);
+      result2.issues.push(iss);
     }
   }
   const bothKeys = [...unrecKeys].filter(([, f3]) => f3.l && f3.r).map(([k2]) => k2);
   if (bothKeys.length && unrecIssue) {
-    result.issues.push({ ...unrecIssue, keys: bothKeys });
+    result2.issues.push({ ...unrecIssue, keys: bothKeys });
   }
-  if (aborted(result))
-    return result;
+  if (aborted(result2))
+    return result2;
   const merged = mergeValues(left.value, right.value);
   if (!merged.valid) {
     throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
   }
-  result.value = merged.data;
-  return result;
+  result2.value = merged.data;
+  return result2;
 }
-function handleTupleResult(result, final, index) {
-  if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+function handleTupleResult(result2, final, index) {
+  if (result2.issues.length) {
+    final.issues.push(...prefixIssues(index, result2.issues));
   }
-  final.value[index] = result.value;
+  final.value[index] = result2.value;
 }
 function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx) {
   if (keyResult.issues.length) {
@@ -2087,17 +2087,17 @@ function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx)
   }
   final.value.set(keyResult.value, valueResult.value);
 }
-function handleSetResult(result, final) {
-  if (result.issues.length) {
-    final.issues.push(...result.issues);
+function handleSetResult(result2, final) {
+  if (result2.issues.length) {
+    final.issues.push(...result2.issues);
   }
-  final.value.add(result.value);
+  final.value.add(result2.value);
 }
-function handleOptionalResult(result, input2) {
-  if (result.issues.length && input2 === void 0) {
+function handleOptionalResult(result2, input2) {
+  if (result2.issues.length && input2 === void 0) {
     return { issues: [], value: void 0 };
   }
-  return result;
+  return result2;
 }
 function handleDefaultResult(payload, def) {
   if (payload.value === void 0) {
@@ -2123,24 +2123,24 @@ function handlePipeResult(left, next, ctx) {
   }
   return next._zod.run({ value: left.value, issues: left.issues }, ctx);
 }
-function handleCodecAResult(result, def, ctx) {
-  if (result.issues.length) {
-    result.aborted = true;
-    return result;
+function handleCodecAResult(result2, def, ctx) {
+  if (result2.issues.length) {
+    result2.aborted = true;
+    return result2;
   }
   const direction = ctx.direction || "forward";
   if (direction === "forward") {
-    const transformed = def.transform(result.value, result);
+    const transformed = def.transform(result2.value, result2);
     if (transformed instanceof Promise) {
-      return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
+      return transformed.then((value) => handleCodecTxResult(result2, value, def.out, ctx));
     }
-    return handleCodecTxResult(result, transformed, def.out, ctx);
+    return handleCodecTxResult(result2, transformed, def.out, ctx);
   } else {
-    const transformed = def.reverseTransform(result.value, result);
+    const transformed = def.reverseTransform(result2.value, result2);
     if (transformed instanceof Promise) {
-      return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
+      return transformed.then((value) => handleCodecTxResult(result2, value, def.in, ctx));
     }
-    return handleCodecTxResult(result, transformed, def.in, ctx);
+    return handleCodecTxResult(result2, transformed, def.in, ctx);
   }
 }
 function handleCodecTxResult(left, value, nextSchema, ctx) {
@@ -2154,8 +2154,8 @@ function handleReadonlyResult(payload) {
   payload.value = Object.freeze(payload.value);
   return payload;
 }
-function handleRefineResult(result, payload, input2, inst) {
-  if (!result) {
+function handleRefineResult(result2, payload, input2, inst) {
+  if (!result2) {
     const _iss = {
       code: "custom",
       input: input2,
@@ -2269,13 +2269,13 @@ var init_schemas = __esm({
             }
             return handleCanaryResult(canary, payload, ctx);
           }
-          const result = inst._zod.parse(payload, ctx);
-          if (result instanceof Promise) {
+          const result2 = inst._zod.parse(payload, ctx);
+          if (result2 instanceof Promise) {
             if (ctx.async === false)
               throw new $ZodAsyncError();
-            return result.then((result2) => runChecks(result2, checks, ctx));
+            return result2.then((result3) => runChecks(result3, checks, ctx));
           }
-          return runChecks(result, checks, ctx);
+          return runChecks(result2, checks, ctx);
         };
       }
       defineLazy(inst, "~standard", () => ({
@@ -2762,14 +2762,14 @@ var init_schemas = __esm({
         const proms = [];
         for (let i2 = 0; i2 < input2.length; i2++) {
           const item = input2[i2];
-          const result = def.element._zod.run({
+          const result2 = def.element._zod.run({
             value: item,
             issues: []
           }, ctx);
-          if (result instanceof Promise) {
-            proms.push(result.then((result2) => handleArrayResult(result2, payload, i2)));
+          if (result2 instanceof Promise) {
+            proms.push(result2.then((result3) => handleArrayResult(result3, payload, i2)));
           } else {
-            handleArrayResult(result, payload, i2);
+            handleArrayResult(result2, payload, i2);
           }
         }
         if (proms.length) {
@@ -2966,17 +2966,17 @@ var init_schemas = __esm({
         let async = false;
         const results = [];
         for (const option of def.options) {
-          const result = option._zod.run({
+          const result2 = option._zod.run({
             value: payload.value,
             issues: []
           }, ctx);
-          if (result instanceof Promise) {
-            results.push(result);
+          if (result2 instanceof Promise) {
+            results.push(result2);
             async = true;
           } else {
-            if (result.issues.length === 0)
-              return result;
-            results.push(result);
+            if (result2.issues.length === 0)
+              return result2;
+            results.push(result2);
           }
         }
         if (!async)
@@ -2998,15 +2998,15 @@ var init_schemas = __esm({
         let async = false;
         const results = [];
         for (const option of def.options) {
-          const result = option._zod.run({
+          const result2 = option._zod.run({
             value: payload.value,
             issues: []
           }, ctx);
-          if (result instanceof Promise) {
-            results.push(result);
+          if (result2 instanceof Promise) {
+            results.push(result2);
             async = true;
           } else {
-            results.push(result);
+            results.push(result2);
           }
         }
         if (!async)
@@ -3135,28 +3135,28 @@ var init_schemas = __esm({
             if (i2 >= optStart)
               continue;
           }
-          const result = item._zod.run({
+          const result2 = item._zod.run({
             value: input2[i2],
             issues: []
           }, ctx);
-          if (result instanceof Promise) {
-            proms.push(result.then((result2) => handleTupleResult(result2, payload, i2)));
+          if (result2 instanceof Promise) {
+            proms.push(result2.then((result3) => handleTupleResult(result3, payload, i2)));
           } else {
-            handleTupleResult(result, payload, i2);
+            handleTupleResult(result2, payload, i2);
           }
         }
         if (def.rest) {
           const rest = input2.slice(items.length);
           for (const el of rest) {
             i2++;
-            const result = def.rest._zod.run({
+            const result2 = def.rest._zod.run({
               value: el,
               issues: []
             }, ctx);
-            if (result instanceof Promise) {
-              proms.push(result.then((result2) => handleTupleResult(result2, payload, i2)));
+            if (result2 instanceof Promise) {
+              proms.push(result2.then((result3) => handleTupleResult(result3, payload, i2)));
             } else {
-              handleTupleResult(result, payload, i2);
+              handleTupleResult(result2, payload, i2);
             }
           }
         }
@@ -3186,19 +3186,19 @@ var init_schemas = __esm({
           for (const key of values2) {
             if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
               recordKeys.add(typeof key === "number" ? key.toString() : key);
-              const result = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
-              if (result instanceof Promise) {
-                proms.push(result.then((result2) => {
-                  if (result2.issues.length) {
-                    payload.issues.push(...prefixIssues(key, result2.issues));
+              const result2 = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
+              if (result2 instanceof Promise) {
+                proms.push(result2.then((result3) => {
+                  if (result3.issues.length) {
+                    payload.issues.push(...prefixIssues(key, result3.issues));
                   }
-                  payload.value[key] = result2.value;
+                  payload.value[key] = result3.value;
                 }));
               } else {
-                if (result.issues.length) {
-                  payload.issues.push(...prefixIssues(key, result.issues));
+                if (result2.issues.length) {
+                  payload.issues.push(...prefixIssues(key, result2.issues));
                 }
-                payload.value[key] = result.value;
+                payload.value[key] = result2.value;
               }
             }
           }
@@ -3251,19 +3251,19 @@ var init_schemas = __esm({
               }
               continue;
             }
-            const result = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
-            if (result instanceof Promise) {
-              proms.push(result.then((result2) => {
-                if (result2.issues.length) {
-                  payload.issues.push(...prefixIssues(key, result2.issues));
+            const result2 = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
+            if (result2 instanceof Promise) {
+              proms.push(result2.then((result3) => {
+                if (result3.issues.length) {
+                  payload.issues.push(...prefixIssues(key, result3.issues));
                 }
-                payload.value[keyResult.value] = result2.value;
+                payload.value[keyResult.value] = result3.value;
               }));
             } else {
-              if (result.issues.length) {
-                payload.issues.push(...prefixIssues(key, result.issues));
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
               }
-              payload.value[keyResult.value] = result.value;
+              payload.value[keyResult.value] = result2.value;
             }
           }
         }
@@ -3320,11 +3320,11 @@ var init_schemas = __esm({
         const proms = [];
         payload.value = /* @__PURE__ */ new Set();
         for (const item of input2) {
-          const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
-          if (result instanceof Promise) {
-            proms.push(result.then((result2) => handleSetResult(result2, payload)));
+          const result2 = def.valueType._zod.run({ value: item, issues: [] }, ctx);
+          if (result2 instanceof Promise) {
+            proms.push(result2.then((result3) => handleSetResult(result3, payload)));
           } else
-            handleSetResult(result, payload);
+            handleSetResult(result2, payload);
         }
         if (proms.length)
           return Promise.all(proms).then(() => payload);
@@ -3422,10 +3422,10 @@ var init_schemas = __esm({
       });
       inst._zod.parse = (payload, ctx) => {
         if (def.innerType._zod.optin === "optional") {
-          const result = def.innerType._zod.run(payload, ctx);
-          if (result instanceof Promise)
-            return result.then((r3) => handleOptionalResult(r3, payload.value));
-          return handleOptionalResult(result, payload.value);
+          const result2 = def.innerType._zod.run(payload, ctx);
+          if (result2 instanceof Promise)
+            return result2.then((r3) => handleOptionalResult(r3, payload.value));
+          return handleOptionalResult(result2, payload.value);
         }
         if (payload.value === void 0) {
           return payload;
@@ -3470,11 +3470,11 @@ var init_schemas = __esm({
           payload.value = def.defaultValue;
           return payload;
         }
-        const result = def.innerType._zod.run(payload, ctx);
-        if (result instanceof Promise) {
-          return result.then((result2) => handleDefaultResult(result2, def));
+        const result2 = def.innerType._zod.run(payload, ctx);
+        if (result2 instanceof Promise) {
+          return result2.then((result3) => handleDefaultResult(result3, def));
         }
-        return handleDefaultResult(result, def);
+        return handleDefaultResult(result2, def);
       };
     });
     $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
@@ -3498,11 +3498,11 @@ var init_schemas = __esm({
         return v2 ? new Set([...v2].filter((x2) => x2 !== void 0)) : void 0;
       });
       inst._zod.parse = (payload, ctx) => {
-        const result = def.innerType._zod.run(payload, ctx);
-        if (result instanceof Promise) {
-          return result.then((result2) => handleNonOptionalResult(result2, inst));
+        const result2 = def.innerType._zod.run(payload, ctx);
+        if (result2 instanceof Promise) {
+          return result2.then((result3) => handleNonOptionalResult(result3, inst));
         }
-        return handleNonOptionalResult(result, inst);
+        return handleNonOptionalResult(result2, inst);
       };
     });
     $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
@@ -3511,14 +3511,14 @@ var init_schemas = __esm({
         if (ctx.direction === "backward") {
           throw new $ZodEncodeError("ZodSuccess");
         }
-        const result = def.innerType._zod.run(payload, ctx);
-        if (result instanceof Promise) {
-          return result.then((result2) => {
-            payload.value = result2.issues.length === 0;
+        const result2 = def.innerType._zod.run(payload, ctx);
+        if (result2 instanceof Promise) {
+          return result2.then((result3) => {
+            payload.value = result3.issues.length === 0;
             return payload;
           });
         }
-        payload.value = result.issues.length === 0;
+        payload.value = result2.issues.length === 0;
         return payload;
       };
     });
@@ -3531,15 +3531,15 @@ var init_schemas = __esm({
         if (ctx.direction === "backward") {
           return def.innerType._zod.run(payload, ctx);
         }
-        const result = def.innerType._zod.run(payload, ctx);
-        if (result instanceof Promise) {
-          return result.then((result2) => {
-            payload.value = result2.value;
-            if (result2.issues.length) {
+        const result2 = def.innerType._zod.run(payload, ctx);
+        if (result2 instanceof Promise) {
+          return result2.then((result3) => {
+            payload.value = result3.value;
+            if (result3.issues.length) {
               payload.value = def.catchValue({
                 ...payload,
                 error: {
-                  issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+                  issues: result3.issues.map((iss) => finalizeIssue(iss, ctx, config()))
                 },
                 input: payload.value
               });
@@ -3548,12 +3548,12 @@ var init_schemas = __esm({
             return payload;
           });
         }
-        payload.value = result.value;
-        if (result.issues.length) {
+        payload.value = result2.value;
+        if (result2.issues.length) {
           payload.value = def.catchValue({
             ...payload,
             error: {
-              issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
             },
             input: payload.value
           });
@@ -3631,11 +3631,11 @@ var init_schemas = __esm({
         if (ctx.direction === "backward") {
           return def.innerType._zod.run(payload, ctx);
         }
-        const result = def.innerType._zod.run(payload, ctx);
-        if (result instanceof Promise) {
-          return result.then(handleReadonlyResult);
+        const result2 = def.innerType._zod.run(payload, ctx);
+        if (result2 instanceof Promise) {
+          return result2.then(handleReadonlyResult);
         }
-        return handleReadonlyResult(result);
+        return handleReadonlyResult(result2);
       };
     });
     $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
@@ -3693,11 +3693,11 @@ var init_schemas = __esm({
         }
         return function(...args) {
           const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
-          const result = Reflect.apply(func, this, parsedArgs);
+          const result2 = Reflect.apply(func, this, parsedArgs);
           if (inst._def.output) {
-            return parse(inst._def.output, result);
+            return parse(inst._def.output, result2);
           }
-          return result;
+          return result2;
         };
       };
       inst.implementAsync = (func) => {
@@ -3706,11 +3706,11 @@ var init_schemas = __esm({
         }
         return async function(...args) {
           const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
-          const result = await Reflect.apply(func, this, parsedArgs);
+          const result2 = await Reflect.apply(func, this, parsedArgs);
           if (inst._def.output) {
-            return await parseAsync(inst._def.output, result);
+            return await parseAsync(inst._def.output, result2);
           }
-          return result;
+          return result2;
         };
       };
       inst._zod.parse = (payload, _ctx) => {
@@ -7008,12 +7008,12 @@ var init_lt = __esm({
         }
       };
       function getSizing(origin, unitType, inclusive, targetShouldBe) {
-        const result = Sizable[origin] ?? null;
-        if (result === null)
-          return result;
+        const result2 = Sizable[origin] ?? null;
+        if (result2 === null)
+          return result2;
         return {
-          unit: result.unit[unitType],
-          verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
+          unit: result2.unit[unitType],
+          verb: result2.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
         };
       }
       const FormatDictionary = {
@@ -10855,11 +10855,11 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     }
     return seen.schema;
   }
-  const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema, result);
+  const result2 = { schema: {}, count: 1, cycle: void 0, path: _params.path };
+  ctx.seen.set(schema, result2);
   const overrideSchema = schema._zod.toJSONSchema?.();
   if (overrideSchema) {
-    result.schema = overrideSchema;
+    result2.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
@@ -10867,9 +10867,9 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
       path: _params.path
     };
     if (schema._zod.processJSONSchema) {
-      schema._zod.processJSONSchema(ctx, result.schema, params);
+      schema._zod.processJSONSchema(ctx, result2.schema, params);
     } else {
-      const _json = result.schema;
+      const _json = result2.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
@@ -10878,22 +10878,22 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     }
     const parent = schema._zod.parent;
     if (parent) {
-      if (!result.ref)
-        result.ref = parent;
+      if (!result2.ref)
+        result2.ref = parent;
       process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
   const meta3 = ctx.metadataRegistry.get(schema);
   if (meta3)
-    Object.assign(result.schema, meta3);
+    Object.assign(result2.schema, meta3);
   if (ctx.io === "input" && isTransforming(schema)) {
-    delete result.schema.examples;
-    delete result.schema.default;
+    delete result2.schema.examples;
+    delete result2.schema.default;
   }
-  if (ctx.io === "input" && result.schema._prefault)
-    (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
-  delete result.schema._prefault;
+  if (ctx.io === "input" && result2.schema._prefault)
+    (_a2 = result2.schema).default ?? (_a2.default = result2.schema._prefault);
+  delete result2.schema._prefault;
   const _result = ctx.seen.get(schema);
   return _result.schema;
 }
@@ -11056,13 +11056,13 @@ function finalize(ctx, schema) {
   for (const entry of [...ctx.seen.entries()].reverse()) {
     flattenRef(entry[0]);
   }
-  const result = {};
+  const result2 = {};
   if (ctx.target === "draft-2020-12") {
-    result.$schema = "https://json-schema.org/draft/2020-12/schema";
+    result2.$schema = "https://json-schema.org/draft/2020-12/schema";
   } else if (ctx.target === "draft-07") {
-    result.$schema = "http://json-schema.org/draft-07/schema#";
+    result2.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
-    result.$schema = "http://json-schema.org/draft-04/schema#";
+    result2.$schema = "http://json-schema.org/draft-04/schema#";
   } else if (ctx.target === "openapi-3.0") {
   } else {
   }
@@ -11070,9 +11070,9 @@ function finalize(ctx, schema) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
-    result.$id = ctx.external.uri(id);
+    result2.$id = ctx.external.uri(id);
   }
-  Object.assign(result, root.def ?? root.schema);
+  Object.assign(result2, root.def ?? root.schema);
   const defs = ctx.external?.defs ?? {};
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
@@ -11084,14 +11084,14 @@ function finalize(ctx, schema) {
   } else {
     if (Object.keys(defs).length > 0) {
       if (ctx.target === "draft-2020-12") {
-        result.$defs = defs;
+        result2.$defs = defs;
       } else {
-        result.definitions = defs;
+        result2.definitions = defs;
       }
     }
   }
   try {
-    const finalized = JSON.parse(JSON.stringify(result));
+    const finalized = JSON.parse(JSON.stringify(result2));
     Object.defineProperty(finalized, "~standard", {
       value: {
         ...schema["~standard"],
@@ -11811,8 +11811,8 @@ var init_json_schema_generator = __esm({
             this.ctx.external = _params.external;
         }
         extractDefs(this.ctx, schema);
-        const result = finalize(this.ctx, schema);
-        const { "~standard": _3, ...plainResult } = result;
+        const result2 = finalize(this.ctx, schema);
+        const { "~standard": _3, ...plainResult } = result2;
         return plainResult;
       }
     };
@@ -13588,13 +13588,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -13819,11 +13819,11 @@ function convertBaseSchema(schema, ctx) {
         } else if (schemasToIntersect.length === 1) {
           zodSchema = schemasToIntersect[0];
         } else {
-          let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result2 = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i2 = 2; i2 < schemasToIntersect.length; i2++) {
-            result = z.intersection(result, schemasToIntersect[i2]);
+            result2 = z.intersection(result2, schemasToIntersect[i2]);
           }
-          zodSchema = result;
+          zodSchema = result2;
         }
         break;
       }
@@ -13914,12 +13914,12 @@ function convertSchema(schema, ctx) {
     if (schema.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      let result2 = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i2 = startIdx; i2 < schema.allOf.length; i2++) {
-        result = z.intersection(result, convertSchema(schema.allOf[i2], ctx));
+        result2 = z.intersection(result2, convertSchema(schema.allOf[i2], ctx));
       }
-      baseSchema = result;
+      baseSchema = result2;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
@@ -14926,8 +14926,8 @@ var init_parseUtil = __esm({
     init_errors3();
     init_en2();
     makeIssue = (params) => {
-      const { data, path: path14, errorMaps, issueData } = params;
-      const fullPath = [...path14, ...issueData.path || []];
+      const { data, path: path15, errorMaps, issueData } = params;
+      const fullPath = [...path15, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -15235,11 +15235,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path14, key) {
+      constructor(parent, value, path15, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path14;
+        this._path = path15;
         this._key = key;
       }
       get path() {
@@ -15253,9 +15253,9 @@ var init_types = __esm({
         return this._cachedPath;
       }
     };
-    handleResult = (ctx, result) => {
-      if (isValid(result)) {
-        return { success: true, data: result.value };
+    handleResult = (ctx, result2) => {
+      if (isValid(result2)) {
+        return { success: true, data: result2.value };
       } else {
         if (!ctx.common.issues.length) {
           throw new Error("Validation failed but no issues detected.");
@@ -15303,21 +15303,21 @@ var init_types = __esm({
         };
       }
       _parseSync(input2) {
-        const result = this._parse(input2);
-        if (isAsync(result)) {
+        const result2 = this._parse(input2);
+        if (isAsync(result2)) {
           throw new Error("Synchronous parse encountered promise.");
         }
-        return result;
+        return result2;
       }
       _parseAsync(input2) {
-        const result = this._parse(input2);
-        return Promise.resolve(result);
+        const result2 = this._parse(input2);
+        return Promise.resolve(result2);
       }
       parse(data, params) {
-        const result = this.safeParse(data, params);
-        if (result.success)
-          return result.data;
-        throw result.error;
+        const result2 = this.safeParse(data, params);
+        if (result2.success)
+          return result2.data;
+        throw result2.error;
       }
       safeParse(data, params) {
         const ctx = {
@@ -15332,8 +15332,8 @@ var init_types = __esm({
           data,
           parsedType: getParsedType2(data)
         };
-        const result = this._parseSync({ data, path: ctx.path, parent: ctx });
-        return handleResult(ctx, result);
+        const result2 = this._parseSync({ data, path: ctx.path, parent: ctx });
+        return handleResult(ctx, result2);
       }
       "~validate"(data) {
         const ctx = {
@@ -15349,9 +15349,9 @@ var init_types = __esm({
         };
         if (!this["~standard"].async) {
           try {
-            const result = this._parseSync({ data, path: [], parent: ctx });
-            return isValid(result) ? {
-              value: result.value
+            const result2 = this._parseSync({ data, path: [], parent: ctx });
+            return isValid(result2) ? {
+              value: result2.value
             } : {
               issues: ctx.common.issues
             };
@@ -15365,17 +15365,17 @@ var init_types = __esm({
             };
           }
         }
-        return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
-          value: result.value
+        return this._parseAsync({ data, path: [], parent: ctx }).then((result2) => isValid(result2) ? {
+          value: result2.value
         } : {
           issues: ctx.common.issues
         });
       }
       async parseAsync(data, params) {
-        const result = await this.safeParseAsync(data, params);
-        if (result.success)
-          return result.data;
-        throw result.error;
+        const result2 = await this.safeParseAsync(data, params);
+        if (result2.success)
+          return result2.data;
+        throw result2.error;
       }
       async safeParseAsync(data, params) {
         const ctx = {
@@ -15391,8 +15391,8 @@ var init_types = __esm({
           parsedType: getParsedType2(data)
         };
         const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
-        const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
-        return handleResult(ctx, result);
+        const result2 = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+        return handleResult(ctx, result2);
       }
       refine(check2, message) {
         const getIssueProperties = (val) => {
@@ -15405,13 +15405,13 @@ var init_types = __esm({
           }
         };
         return this._refinement((val, ctx) => {
-          const result = check2(val);
+          const result2 = check2(val);
           const setError = () => ctx.addIssue({
             code: ZodIssueCode2.custom,
             ...getIssueProperties(val)
           });
-          if (typeof Promise !== "undefined" && result instanceof Promise) {
-            return result.then((data) => {
+          if (typeof Promise !== "undefined" && result2 instanceof Promise) {
+            return result2.then((data) => {
               if (!data) {
                 setError();
                 return false;
@@ -15420,7 +15420,7 @@ var init_types = __esm({
               }
             });
           }
-          if (!result) {
+          if (!result2) {
             setError();
             return false;
           } else {
@@ -16844,14 +16844,14 @@ var init_types = __esm({
         if (ctx.common.async) {
           return Promise.all([...ctx.data].map((item, i2) => {
             return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i2));
-          })).then((result2) => {
-            return ParseStatus.mergeArray(status, result2);
+          })).then((result3) => {
+            return ParseStatus.mergeArray(status, result3);
           });
         }
-        const result = [...ctx.data].map((item, i2) => {
+        const result2 = [...ctx.data].map((item, i2) => {
           return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i2));
         });
-        return ParseStatus.mergeArray(status, result);
+        return ParseStatus.mergeArray(status, result2);
       }
       get element() {
         return this._def.type;
@@ -17231,18 +17231,18 @@ var init_types = __esm({
         const { ctx } = this._processInputParams(input2);
         const options = this._def.options;
         function handleResults(results) {
-          for (const result of results) {
-            if (result.result.status === "valid") {
-              return result.result;
+          for (const result2 of results) {
+            if (result2.result.status === "valid") {
+              return result2.result;
             }
           }
-          for (const result of results) {
-            if (result.result.status === "dirty") {
-              ctx.common.issues.push(...result.ctx.common.issues);
-              return result.result;
+          for (const result2 of results) {
+            if (result2.result.status === "dirty") {
+              ctx.common.issues.push(...result2.ctx.common.issues);
+              return result2.result;
             }
           }
-          const unionErrors = results.map((result) => new ZodError2(result.ctx.common.issues));
+          const unionErrors = results.map((result2) => new ZodError2(result2.ctx.common.issues));
           addIssueToContext(ctx, {
             code: ZodIssueCode2.invalid_union,
             unionErrors
@@ -17280,15 +17280,15 @@ var init_types = __esm({
               },
               parent: null
             };
-            const result = option._parseSync({
+            const result2 = option._parseSync({
               data: ctx.data,
               path: ctx.path,
               parent: childCtx
             });
-            if (result.status === "valid") {
-              return result;
-            } else if (result.status === "dirty" && !dirty) {
-              dirty = { result, ctx: childCtx };
+            if (result2.status === "valid") {
+              return result2;
+            } else if (result2.status === "dirty" && !dirty) {
+              dirty = { result: result2, ctx: childCtx };
             }
             if (childCtx.common.issues.length) {
               issues.push(childCtx.common.issues);
@@ -17795,9 +17795,9 @@ var init_types = __esm({
               error48.addIssue(makeArgsIssue(args, e2));
               throw error48;
             });
-            const result = await Reflect.apply(fn, this, parsedArgs);
-            const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e2) => {
-              error48.addIssue(makeReturnsIssue(result, e2));
+            const result2 = await Reflect.apply(fn, this, parsedArgs);
+            const parsedReturns = await me._def.returns._def.type.parseAsync(result2, params).catch((e2) => {
+              error48.addIssue(makeReturnsIssue(result2, e2));
               throw error48;
             });
             return parsedReturns;
@@ -17809,10 +17809,10 @@ var init_types = __esm({
             if (!parsedArgs.success) {
               throw new ZodError2([makeArgsIssue(args, parsedArgs.error)]);
             }
-            const result = Reflect.apply(fn, this, parsedArgs.data);
-            const parsedReturns = me._def.returns.safeParse(result, params);
+            const result2 = Reflect.apply(fn, this, parsedArgs.data);
+            const parsedReturns = me._def.returns.safeParse(result2, params);
             if (!parsedReturns.success) {
-              throw new ZodError2([makeReturnsIssue(result, parsedReturns.error)]);
+              throw new ZodError2([makeReturnsIssue(result2, parsedReturns.error)]);
             }
             return parsedReturns.data;
           });
@@ -18057,43 +18057,43 @@ var init_types = __esm({
             return Promise.resolve(processed).then(async (processed2) => {
               if (status.value === "aborted")
                 return INVALID;
-              const result = await this._def.schema._parseAsync({
+              const result2 = await this._def.schema._parseAsync({
                 data: processed2,
                 path: ctx.path,
                 parent: ctx
               });
-              if (result.status === "aborted")
+              if (result2.status === "aborted")
                 return INVALID;
-              if (result.status === "dirty")
-                return DIRTY(result.value);
+              if (result2.status === "dirty")
+                return DIRTY(result2.value);
               if (status.value === "dirty")
-                return DIRTY(result.value);
-              return result;
+                return DIRTY(result2.value);
+              return result2;
             });
           } else {
             if (status.value === "aborted")
               return INVALID;
-            const result = this._def.schema._parseSync({
+            const result2 = this._def.schema._parseSync({
               data: processed,
               path: ctx.path,
               parent: ctx
             });
-            if (result.status === "aborted")
+            if (result2.status === "aborted")
               return INVALID;
-            if (result.status === "dirty")
-              return DIRTY(result.value);
+            if (result2.status === "dirty")
+              return DIRTY(result2.value);
             if (status.value === "dirty")
-              return DIRTY(result.value);
-            return result;
+              return DIRTY(result2.value);
+            return result2;
           }
         }
         if (effect.type === "refinement") {
           const executeRefinement = (acc) => {
-            const result = effect.refinement(acc, checkCtx);
+            const result2 = effect.refinement(acc, checkCtx);
             if (ctx.common.async) {
-              return Promise.resolve(result);
+              return Promise.resolve(result2);
             }
-            if (result instanceof Promise) {
+            if (result2 instanceof Promise) {
               throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
             }
             return acc;
@@ -18131,18 +18131,18 @@ var init_types = __esm({
             });
             if (!isValid(base))
               return INVALID;
-            const result = effect.transform(base.value, checkCtx);
-            if (result instanceof Promise) {
+            const result2 = effect.transform(base.value, checkCtx);
+            if (result2 instanceof Promise) {
               throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
             }
-            return { status: status.value, value: result };
+            return { status: status.value, value: result2 };
           } else {
             return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
               if (!isValid(base))
                 return INVALID;
-              return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+              return Promise.resolve(effect.transform(base.value, checkCtx)).then((result2) => ({
                 status: status.value,
-                value: result
+                value: result2
               }));
             });
           }
@@ -18239,18 +18239,18 @@ var init_types = __esm({
             issues: []
           }
         };
-        const result = this._def.innerType._parse({
+        const result2 = this._def.innerType._parse({
           data: newCtx.data,
           path: newCtx.path,
           parent: {
             ...newCtx
           }
         });
-        if (isAsync(result)) {
-          return result.then((result2) => {
+        if (isAsync(result2)) {
+          return result2.then((result3) => {
             return {
               status: "valid",
-              value: result2.status === "valid" ? result2.value : this._def.catchValue({
+              value: result3.status === "valid" ? result3.value : this._def.catchValue({
                 get error() {
                   return new ZodError2(newCtx.common.issues);
                 },
@@ -18261,7 +18261,7 @@ var init_types = __esm({
         } else {
           return {
             status: "valid",
-            value: result.status === "valid" ? result.value : this._def.catchValue({
+            value: result2.status === "valid" ? result2.value : this._def.catchValue({
               get error() {
                 return new ZodError2(newCtx.common.issues);
               },
@@ -18375,14 +18375,14 @@ var init_types = __esm({
     };
     ZodReadonly2 = class extends ZodType2 {
       _parse(input2) {
-        const result = this._def.innerType._parse(input2);
+        const result2 = this._def.innerType._parse(input2);
         const freeze = (data) => {
           if (isValid(data)) {
             data.value = Object.freeze(data.value);
           }
           return data;
         };
-        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+        return isAsync(result2) ? result2.then((data) => freeze(data)) : freeze(result2);
       }
       unwrap() {
         return this._def.innerType;
@@ -18765,13 +18765,13 @@ ${USAGE_LINE}`);
   let type;
   const rawType = values2.type;
   if (typeof rawType === "string" && rawType.length > 0) {
-    const result = PackageTypeSchema.safeParse(rawType);
-    if (!result.success) {
+    const result2 = PackageTypeSchema.safeParse(rawType);
+    if (!result2.success) {
       throw new Error(
         `Invalid --type value: '${rawType}'. Allowed: ${ALLOWED_PACKAGE_TYPES.join(", ")}`
       );
     }
-    type = result.data;
+    type = result2.data;
   }
   return {
     name,
@@ -18783,7 +18783,7 @@ ${USAGE_LINE}`);
   };
 }
 async function runPackageInit(args) {
-  const result = await createPackage({
+  const result2 = await createPackage({
     parentDir: args.parentDir ?? process.cwd(),
     name: args.name,
     type: args.type ?? "plugin",
@@ -18791,9 +18791,9 @@ async function runPackageInit(args) {
     author: args.author,
     adapterType: args.adapterType
   });
-  console.log(`Created package at: ${result.packagePath}`);
+  console.log(`Created package at: ${result2.packagePath}`);
   console.log("Files written:");
-  for (const file2 of result.filesWritten) {
+  for (const file2 of result2.filesWritten) {
     console.log(`  - ${file2}`);
   }
 }
@@ -18842,17 +18842,17 @@ function parseSkillFile(filePath, content, schema) {
       filePath
     };
   }
-  const result = schema.safeParse(data);
-  if (!result.success) {
+  const result2 = schema.safeParse(data);
+  if (!result2.success) {
     return {
       ok: false,
-      error: `Invalid frontmatter: ${result.error.message}`,
+      error: `Invalid frontmatter: ${result2.error.message}`,
       filePath
     };
   }
   const dirPath = path2.dirname(filePath);
   const dirName = path2.basename(dirPath);
-  const meta3 = result.data;
+  const meta3 = result2.data;
   if (typeof meta3.name === "string" && meta3.name !== dirName) {
     return {
       ok: false,
@@ -18864,7 +18864,7 @@ function parseSkillFile(filePath, content, schema) {
     ok: true,
     definition: {
       name: dirName,
-      meta: result.data,
+      meta: result2.data,
       body,
       filePath,
       dirPath
@@ -19246,14 +19246,14 @@ function parseMarketplaceJson(content) {
       error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const result = MarketplaceJsonSchema.safeParse(parsed);
-  if (!result.success) {
+  const result2 = MarketplaceJsonSchema.safeParse(parsed);
+  if (!result2.success) {
     return {
       ok: false,
-      error: `marketplace.json validation failed: ${formatZodIssues(result.error.issues)}`
+      error: `marketplace.json validation failed: ${formatZodIssues(result2.error.issues)}`
     };
   }
-  return { ok: true, marketplace: result.data };
+  return { ok: true, marketplace: result2.data };
 }
 function parseDorkosSidecar(content) {
   let parsed;
@@ -19265,34 +19265,45 @@ function parseDorkosSidecar(content) {
       error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const result = DorkosSidecarSchema.safeParse(parsed);
-  if (!result.success) {
+  const result2 = DorkosSidecarSchema.safeParse(parsed);
+  if (!result2.success) {
     return {
       ok: false,
-      error: `dorkos.json validation failed: ${formatZodIssues(result.error.issues)}`
+      error: `dorkos.json validation failed: ${formatZodIssues(result2.error.issues)}`
     };
   }
-  return { ok: true, sidecar: result.data };
+  return { ok: true, sidecar: result2.data };
 }
 function formatZodIssues(issues) {
   return issues.map((i2) => `${i2.path.join(".") || "<root>"}: ${i2.message}`).join("; ");
 }
+var LenientMarketplaceEnvelopeSchema, LenientPluginEntrySchema;
 var init_marketplace_json_parser = __esm({
   "../marketplace/dist/marketplace-json-parser.js"() {
     "use strict";
+    init_zod2();
     init_marketplace_json_schema();
     init_dorkos_sidecar_schema();
     init_merge_marketplace();
+    LenientMarketplaceEnvelopeSchema = external_exports2.object({
+      name: external_exports2.string().min(1).regex(/^[a-z0-9][a-z0-9.-]*$/, "Must be kebab-case (letters, digits, dots, hyphens)"),
+      owner: OwnerSchema,
+      metadata: MetadataSchema.optional(),
+      plugins: external_exports2.array(external_exports2.unknown())
+    }).passthrough();
+    LenientPluginEntrySchema = MarketplaceJsonEntrySchema.extend({
+      name: external_exports2.string().min(1).regex(/^[a-z0-9][a-z0-9.-]*$/, "Must be kebab-case (letters, digits, dots, hyphens)")
+    });
   }
 });
 
 // ../marketplace/dist/cc-validator.js
 function validateAgainstCcSchema(raw) {
-  const result = CcMarketplaceJsonSchema.safeParse(raw);
-  if (result.success) {
+  const result2 = CcMarketplaceJsonSchema.safeParse(raw);
+  if (result2.success) {
     return { ok: true };
   }
-  return { ok: false, errors: result.error.issues };
+  return { ok: false, errors: result2.error.issues };
 }
 var CcSourceSchema, CcAuthorSchema, CcOwnerSchema, CcMetadataSchema, CcMarketplaceJsonEntrySchema, CcMarketplaceJsonSchema;
 var init_cc_validator = __esm({
@@ -19347,30 +19358,40 @@ import { promises as fs3 } from "node:fs";
 import path5 from "node:path";
 async function validatePackage(packagePath) {
   const issues = [];
-  const manifestPath = path5.join(packagePath, PACKAGE_MANIFEST_PATH);
-  let manifestContent;
+  let manifestRaw;
+  let manifestSource;
+  const dorkManifestPath = path5.join(packagePath, PACKAGE_MANIFEST_PATH);
+  let dorkManifestContent = null;
   try {
-    manifestContent = await fs3.readFile(manifestPath, "utf-8");
+    dorkManifestContent = await fs3.readFile(dorkManifestPath, "utf-8");
   } catch {
-    issues.push({
-      level: "error",
-      code: "MANIFEST_MISSING",
-      message: `Required file missing: ${PACKAGE_MANIFEST_PATH}`,
-      path: PACKAGE_MANIFEST_PATH
-    });
-    return { ok: false, issues };
   }
-  let manifestRaw;
-  try {
-    manifestRaw = JSON.parse(manifestContent);
-  } catch (err) {
-    issues.push({
-      level: "error",
-      code: "MANIFEST_INVALID_JSON",
-      message: `Invalid JSON in manifest: ${err instanceof Error ? err.message : String(err)}`,
-      path: PACKAGE_MANIFEST_PATH
-    });
-    return { ok: false, issues };
+  if (dorkManifestContent !== null) {
+    try {
+      manifestRaw = JSON.parse(dorkManifestContent);
+    } catch (err) {
+      issues.push({
+        level: "error",
+        code: "MANIFEST_INVALID_JSON",
+        message: `Invalid JSON in manifest: ${err instanceof Error ? err.message : String(err)}`,
+        path: PACKAGE_MANIFEST_PATH
+      });
+      return { ok: false, issues };
+    }
+    manifestSource = PACKAGE_MANIFEST_PATH;
+  } else {
+    const synthesized = await synthesizeFromCcManifest(packagePath);
+    if (!synthesized) {
+      issues.push({
+        level: "error",
+        code: "MANIFEST_MISSING",
+        message: `Required file missing: ${PACKAGE_MANIFEST_PATH} (no ${CLAUDE_PLUGIN_MANIFEST_PATH} fallback found either)`,
+        path: PACKAGE_MANIFEST_PATH
+      });
+      return { ok: false, issues };
+    }
+    manifestRaw = synthesized;
+    manifestSource = CLAUDE_PLUGIN_MANIFEST_PATH;
   }
   const parseResult = MarketplacePackageManifestSchema.safeParse(manifestRaw);
   if (!parseResult.success) {
@@ -19379,7 +19400,7 @@ async function validatePackage(packagePath) {
         level: "error",
         code: "MANIFEST_SCHEMA_INVALID",
         message: `${issue2.path.join(".") || "<root>"}: ${issue2.message}`,
-        path: PACKAGE_MANIFEST_PATH
+        path: manifestSource
       });
     }
     return { ok: false, issues };
@@ -19422,17 +19443,17 @@ async function validateSkillsInDirectory(fullDir, packagePath, issues) {
   const scanResults = await scanSkillDirectory(fullDir, PermissiveSkillFrontmatterSchema, {
     includeMissing: false
   });
-  for (const result of scanResults) {
-    if (!result.ok) {
+  for (const result2 of scanResults) {
+    if (!result2.ok) {
       issues.push({
         level: "error",
         code: "SKILL_INVALID",
-        message: result.error,
-        path: path5.relative(packagePath, result.filePath)
+        message: result2.error,
+        path: path5.relative(packagePath, result2.filePath)
       });
       continue;
     }
-    const { dirPath, filePath } = result.definition;
+    const { dirPath, filePath } = result2.definition;
     const structureResult = await validateSkillStructure(dirPath);
     if (!structureResult.valid) {
       for (const err of structureResult.errors) {
@@ -19446,6 +19467,32 @@ async function validateSkillsInDirectory(fullDir, packagePath, issues) {
     }
   }
 }
+async function synthesizeFromCcManifest(packagePath) {
+  const ccPath = path5.join(packagePath, CLAUDE_PLUGIN_MANIFEST_PATH);
+  let content;
+  try {
+    content = await fs3.readFile(ccPath, "utf-8");
+  } catch {
+    return null;
+  }
+  let cc;
+  try {
+    cc = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  return {
+    schemaVersion: 1,
+    name: cc.name,
+    version: cc.version ?? "0.0.0",
+    type: "plugin",
+    description: cc.description ?? String(cc.name ?? "CC plugin"),
+    tags: [],
+    layers: [],
+    requires: [],
+    extensions: []
+  };
+}
 var SKILL_SOURCE_DIRS, PermissiveSkillFrontmatterSchema;
 var init_package_validator = __esm({
   "../marketplace/dist/package-validator.js"() {
@@ -19478,22 +19525,22 @@ __export(package_validate_command_exports, {
 import path6 from "node:path";
 async function runPackageValidate(args) {
   const packagePath = path6.resolve(args.packagePath ?? process.cwd());
-  const result = await validatePackage(packagePath);
-  if (result.manifest) {
+  const result2 = await validatePackage(packagePath);
+  if (result2.manifest) {
     console.log(
-      `Package: ${result.manifest.name}@${result.manifest.version} (${result.manifest.type})`
+      `Package: ${result2.manifest.name}@${result2.manifest.version} (${result2.manifest.type})`
     );
   }
-  if (result.issues.length === 0) {
+  if (result2.issues.length === 0) {
     console.log("\u2713 Package is valid");
     return 0;
   }
-  for (const issue2 of result.issues) {
+  for (const issue2 of result2.issues) {
     const prefix = issue2.level === "error" ? "\u2717" : "\u26A0";
     const location = issue2.path ? ` (${issue2.path})` : "";
     console.log(`${prefix} [${issue2.code}] ${issue2.message}${location}`);
   }
-  if (result.ok) {
+  if (result2.ok) {
     console.log("\u2713 Package is valid (with warnings)");
     return 0;
   }
@@ -19553,16 +19600,16 @@ function resolveRelativePath(source, context) {
     throw new ResolvePluginSourceError('Relative paths must not contain ".."');
   }
   const startsWithDotSlash = source.startsWith("./");
-  let path14;
+  let path15;
   if (startsWithDotSlash) {
-    path14 = stripLeadingDotSlash(source);
+    path15 = stripLeadingDotSlash(source);
   } else {
     const pluginRoot = normalizePluginRoot(context.pluginRoot);
-    path14 = pluginRoot ? `${pluginRoot}/${source}` : source;
+    path15 = pluginRoot ? `${pluginRoot}/${source}` : source;
   }
   return {
     type: "relative-path",
-    path: path14,
+    path: path15,
     marketplaceRoot: context.marketplaceRoot
   };
 }
@@ -20181,14 +20228,14 @@ async function runCacheList() {
 async function runCachePrune(args) {
   try {
     const body = args.keepLastN !== void 0 ? { keepLastN: args.keepLastN } : {};
-    const result = await apiCall("POST", "/api/marketplace/cache/prune", body);
-    const count = result.removed.length;
+    const result2 = await apiCall("POST", "/api/marketplace/cache/prune", body);
+    const count = result2.removed.length;
     if (count === 0) {
       console.log("Nothing to prune \u2014 cache is already minimal.");
       return 0;
     }
     const noun = count === 1 ? "package" : "packages";
-    console.log(`Pruned ${count} cached ${noun}, freed ${formatBytes(result.freedBytes)}.`);
+    console.log(`Pruned ${count} cached ${noun}, freed ${formatBytes(result2.freedBytes)}.`);
     return 0;
   } catch (err) {
     if (err instanceof ApiError) {
@@ -20453,14 +20500,14 @@ async function runInstall(args) {
         return 0;
       }
     }
-    const result = await apiCall(
+    const result2 = await apiCall(
       "POST",
       `/api/marketplace/packages/${encodeURIComponent(args.name)}/install`,
       buildRequestBody(args)
     );
-    console.log(`Installed ${result.packageName}@${result.version} to ${result.installPath}`);
-    if (result.warnings && result.warnings.length > 0) {
-      for (const warning of result.warnings) {
+    console.log(`Installed ${result2.packageName}@${result2.version} to ${result2.installPath}`);
+    if (result2.warnings && result2.warnings.length > 0) {
+      for (const warning of result2.warnings) {
         console.log(`  warning: ${warning}`);
       }
     }
@@ -20551,16 +20598,16 @@ async function runUninstall(args) {
     const body = {};
     if (args.purge) body.purge = true;
     if (args.projectPath) body.projectPath = args.projectPath;
-    const result = await apiCall(
+    const result2 = await apiCall(
       "POST",
       `/api/marketplace/packages/${encodeURIComponent(args.name)}/uninstall`,
       body
     );
-    console.log(`Uninstalled ${result.packageName} (${result.removedFiles} entries removed)`);
-    if (!args.purge && result.preservedData.length > 0) {
+    console.log(`Uninstalled ${result2.packageName} (${result2.removedFiles} entries removed)`);
+    if (!args.purge && result2.preservedData.length > 0) {
       console.log("Preserved:");
-      for (const path14 of result.preservedData) {
-        console.log(`  ${path14}`);
+      for (const path15 of result2.preservedData) {
+        console.log(`  ${path15}`);
       }
     }
     return 0;
@@ -20629,13 +20676,13 @@ async function runUpdate(args) {
     for (const name of targets) {
       const body = { apply: Boolean(args.apply) };
       if (args.projectPath) body.projectPath = args.projectPath;
-      const result = await apiCall(
+      const result2 = await apiCall(
         "POST",
         `/api/marketplace/packages/${encodeURIComponent(name)}/update`,
         body
       );
-      allChecks.push(...result.checks);
-      allApplied.push(...result.applied);
+      allChecks.push(...result2.checks);
+      allApplied.push(...result2.applied);
     }
     renderUpdateChecks(allChecks, Boolean(args.apply));
     if (args.apply && allApplied.length > 0) {
@@ -20945,11 +20992,11 @@ function countPackages(marketplace) {
   return 0;
 }
 async function refreshOne(name) {
-  const result = await apiCall(
+  const result2 = await apiCall(
     "POST",
     `/api/marketplace/sources/${encodeURIComponent(name)}/refresh`
   );
-  return countPackages(result.marketplace);
+  return countPackages(result2.marketplace);
 }
 function formatSuccess(name, count) {
   return `Refreshed ${name}: ${count} ${count === 1 ? "package" : "packages"}.`;
@@ -21174,20 +21221,20 @@ var require_file_uri_to_path = __commonJS({
       var rest = decodeURI(uri.substring(7));
       var firstSlash = rest.indexOf("/");
       var host = rest.substring(0, firstSlash);
-      var path14 = rest.substring(firstSlash + 1);
+      var path15 = rest.substring(firstSlash + 1);
       if ("localhost" == host) host = "";
       if (host) {
         host = sep2 + sep2 + host;
       }
-      path14 = path14.replace(/^(.+)\|/, "$1:");
+      path15 = path15.replace(/^(.+)\|/, "$1:");
       if (sep2 == "\\") {
-        path14 = path14.replace(/\//g, "\\");
+        path15 = path15.replace(/\//g, "\\");
       }
-      if (/^.+\:/.test(path14)) {
+      if (/^.+\:/.test(path15)) {
       } else {
-        path14 = sep2 + path14;
+        path15 = sep2 + path15;
       }
-      return host + path14;
+      return host + path15;
     }
   }
 });
@@ -21196,18 +21243,18 @@ var require_file_uri_to_path = __commonJS({
 var require_bindings = __commonJS({
   "../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports, module) {
     var fs10 = __require("fs");
-    var path14 = __require("path");
-    var fileURLToPath2 = require_file_uri_to_path();
-    var join2 = path14.join;
-    var dirname2 = path14.dirname;
-    var exists = fs10.accessSync && function(path15) {
+    var path15 = __require("path");
+    var fileURLToPath3 = require_file_uri_to_path();
+    var join2 = path15.join;
+    var dirname2 = path15.dirname;
+    var exists = fs10.accessSync && function(path16) {
       try {
-        fs10.accessSync(path15);
+        fs10.accessSync(path16);
       } catch (e2) {
         return false;
       }
       return true;
-    } || fs10.existsSync || path14.existsSync;
+    } || fs10.existsSync || path15.existsSync;
     var defaults = {
       arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
       compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
@@ -21252,7 +21299,7 @@ var require_bindings = __commonJS({
       if (!opts.module_root) {
         opts.module_root = exports.getRoot(exports.getFileName());
       }
-      if (path14.extname(opts.bindings) != ".node") {
+      if (path15.extname(opts.bindings) != ".node") {
         opts.bindings += ".node";
       }
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
@@ -21309,7 +21356,7 @@ var require_bindings = __commonJS({
       Error.stackTraceLimit = origSTL;
       var fileSchema = "file://";
       if (fileName.indexOf(fileSchema) === 0) {
-        fileName = fileURLToPath2(fileName);
+        fileName = fileURLToPath3(fileName);
       }
       return fileName;
     };
@@ -21453,12 +21500,12 @@ var require_transaction = __commonJS({
       }
       before.run();
       try {
-        const result = apply.call(fn, this, arguments);
-        if (result && typeof result.then === "function") {
+        const result2 = apply.call(fn, this, arguments);
+        if (result2 && typeof result2.then === "function") {
           throw new TypeError("Transaction function cannot return a promise");
         }
         after.run();
-        return result;
+        return result2;
       } catch (ex) {
         if (db.inTransaction) {
           undo.run();
@@ -21491,7 +21538,7 @@ var require_backup = __commonJS({
   "../../node_modules/.pnpm/better-sqlite3@12.8.0/node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
     "use strict";
     var fs10 = __require("fs");
-    var path14 = __require("path");
+    var path15 = __require("path");
     var { promisify } = __require("util");
     var { cppdb } = require_util();
     var fsAccess = promisify(fs10.access);
@@ -21507,7 +21554,7 @@ var require_backup = __commonJS({
       if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
       if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
       if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
-      await fsAccess(path14.dirname(filename)).catch(() => {
+      await fsAccess(path15.dirname(filename)).catch(() => {
         throw new TypeError("Cannot save backup because the directory does not exist");
       });
       const isNewFile = await fsAccess(filename).then(() => false, () => true);
@@ -21606,7 +21653,7 @@ var require_aggregate = __commonJS({
       const start = "start" in options ? options.start : null;
       const step = getFunctionOption(options, "step", true);
       const inverse = getFunctionOption(options, "inverse", false);
-      const result = getFunctionOption(options, "result", false);
+      const result2 = getFunctionOption(options, "result", false);
       const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
       const deterministic = getBooleanOption(options, "deterministic");
       const directOnly = getBooleanOption(options, "directOnly");
@@ -21617,7 +21664,7 @@ var require_aggregate = __commonJS({
         if (argCount > 0) argCount -= 1;
         if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
       }
-      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      this[cppdb].aggregate(start, step, inverse, result2, name, argCount, safeIntegers, deterministic, directOnly);
       return this;
     };
     var getFunctionOption = (options, key, required2) => {
@@ -21813,7 +21860,7 @@ var require_database = __commonJS({
   "../../node_modules/.pnpm/better-sqlite3@12.8.0/node_modules/better-sqlite3/lib/database.js"(exports, module) {
     "use strict";
     var fs10 = __require("fs");
-    var path14 = __require("path");
+    var path15 = __require("path");
     var util2 = require_util();
     var SqliteError = require_sqlite_error();
     var DEFAULT_ADDON;
@@ -21849,7 +21896,7 @@ var require_database = __commonJS({
         addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
       } else if (typeof nativeBinding === "string") {
         const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
-        addon = requireFunc(path14.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+        addon = requireFunc(path15.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
       } else {
         addon = nativeBinding;
       }
@@ -21857,7 +21904,7 @@ var require_database = __commonJS({
         addon.setErrorConstructor(SqliteError);
         addon.isInitialized = true;
       }
-      if (!anonymous && !filename.startsWith("file:") && !fs10.existsSync(path14.dirname(filename))) {
+      if (!anonymous && !filename.startsWith("file:") && !fs10.existsSync(path15.dirname(filename))) {
         throw new TypeError("Cannot open database because the directory does not exist");
       }
       Object.defineProperties(this, {
@@ -22917,20 +22964,20 @@ function requireSrc() {
 function requirePicocolors() {
   if (hasRequiredPicocolors) return picocolors.exports;
   hasRequiredPicocolors = 1;
-  let p = process || {}, argv2 = p.argv || [], env3 = p.env || {};
-  let isColorSupported2 = !(!!env3.NO_COLOR || argv2.includes("--no-color")) && (!!env3.FORCE_COLOR || argv2.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env3.TERM !== "dumb" || !!env3.CI);
+  let p = process || {}, argv2 = p.argv || [], env4 = p.env || {};
+  let isColorSupported2 = !(!!env4.NO_COLOR || argv2.includes("--no-color")) && (!!env4.FORCE_COLOR || argv2.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env4.TERM !== "dumb" || !!env4.CI);
   let formatter = (open, close, replace = open) => (input2) => {
     let string4 = "" + input2, index = string4.indexOf(close, open.length);
     return ~index ? open + replaceClose2(string4, close, replace, index) + close : open + string4 + close;
   };
   let replaceClose2 = (string4, close, replace, index) => {
-    let result = "", cursor = 0;
+    let result2 = "", cursor = 0;
     do {
-      result += string4.substring(cursor, index) + replace;
+      result2 += string4.substring(cursor, index) + replace;
       cursor = index + close.length;
       index = string4.indexOf(close, cursor);
     } while (~index);
-    return result + string4.substring(cursor);
+    return result2 + string4.substring(cursor);
   };
   let createColors2 = (enabled = isColorSupported2) => {
     let f3 = enabled ? formatter : () => String;
@@ -23699,12 +23746,12 @@ function stringWidth$1(string4, options = {}) {
   return width;
 }
 function isUnicodeSupported() {
-  const { env: env3 } = g$1;
-  const { TERM, TERM_PROGRAM } = env3;
+  const { env: env4 } = g$1;
+  const { TERM, TERM_PROGRAM } = env4;
   if (g$1.platform !== "win32") {
     return TERM !== "linux";
   }
-  return Boolean(env3.WT_SESSION) || Boolean(env3.TERMINUS_SUBLIME) || env3.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env3.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+  return Boolean(env4.WT_SESSION) || Boolean(env4.TERMINUS_SUBLIME) || env4.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env4.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 function stringWidth(str) {
   const hasICU = typeof Intl === "object";
@@ -23909,6 +23956,84 @@ var init_logger = __esm({
   }
 });
 
+// ../../apps/server/src/env.ts
+var boolFlag, serverEnvSchema, result, env3;
+var init_env = __esm({
+  "../../apps/server/src/env.ts"() {
+    "use strict";
+    init_zod();
+    boolFlag = external_exports.enum(["true", "false"]).default("false").transform((v2) => v2 === "true");
+    serverEnvSchema = external_exports.object({
+      // System
+      HOME: external_exports.string().optional(),
+      GITHUB_TOKEN: external_exports.string().optional(),
+      // Runtime
+      NODE_ENV: external_exports.enum(["development", "production", "test"]).default("development"),
+      DORKOS_PORT: external_exports.coerce.number().int().min(1).max(65535).default(4242),
+      DORKOS_HOST: external_exports.string().default("localhost"),
+      DORKOS_DEFAULT_CWD: external_exports.string().optional(),
+      DORKOS_BOUNDARY: external_exports.string().optional(),
+      DORKOS_LOG_LEVEL: external_exports.coerce.number().int().min(0).max(5).optional(),
+      DORK_HOME: external_exports.string().optional(),
+      DORKOS_VERSION_OVERRIDE: external_exports.string().optional(),
+      CLIENT_DIST_PATH: external_exports.string().optional(),
+      // MCP external server — optional API key for authenticated access
+      MCP_API_KEY: external_exports.string().optional(),
+      // Marketplace MCP — when '1', auto-approves every install/uninstall/create
+      // confirmation request without prompting the user. Used by CI and tests.
+      MARKETPLACE_AUTO_APPROVE: external_exports.string().optional(),
+      // Feature flags (boolean after transform)
+      DORKOS_A2A_ENABLED: boolFlag,
+      DORKOS_TASKS_ENABLED: boolFlag,
+      DORKOS_RELAY_ENABLED: boolFlag,
+      // Activity feed — retention period for pruning (defaults to 30 days in service)
+      DORKOS_ACTIVITY_RETENTION_DAYS: external_exports.coerce.number().int().min(1).optional(),
+      // Test mode — TestModeRuntime is registered instead of ClaudeCodeRuntime
+      DORKOS_TEST_RUNTIME: external_exports.string().optional().transform((v2) => v2 === "true"),
+      // Tunnel (ngrok integration — all optional)
+      TUNNEL_ENABLED: boolFlag,
+      TUNNEL_PORT: external_exports.coerce.number().int().min(1).max(65535).optional(),
+      TUNNEL_AUTH: external_exports.string().optional(),
+      TUNNEL_DOMAIN: external_exports.string().optional(),
+      NGROK_AUTHTOKEN: external_exports.string().optional()
+    });
+    result = serverEnvSchema.safeParse(process.env);
+    if (!result.success) {
+      console.error("\n  Missing or invalid environment variables:\n");
+      result.error.issues.forEach((i2) => console.error(`  - ${i2.path.join(".")}: ${i2.message}`));
+      console.error("\n  Copy .env.example to .env\n");
+      process.exit(1);
+    }
+    env3 = result.data;
+  }
+});
+
+// ../../apps/server/src/lib/version.ts
+import { readFileSync } from "fs";
+import path11 from "path";
+import { fileURLToPath } from "url";
+function resolveVersion() {
+  if (env3.DORKOS_VERSION_OVERRIDE) return env3.DORKOS_VERSION_OVERRIDE;
+  if (true) return "0.36.0";
+  const pkgPath = path11.join(path11.dirname(fileURLToPath(import.meta.url)), "../../package.json");
+  return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+}
+function checkDevBuild(version2) {
+  if (env3.DORKOS_VERSION_OVERRIDE) return false;
+  if (true) return false;
+  return DEV_VERSION_PATTERN.test(version2);
+}
+var DEV_VERSION_PATTERN, SERVER_VERSION, IS_DEV_BUILD;
+var init_version = __esm({
+  "../../apps/server/src/lib/version.ts"() {
+    "use strict";
+    init_env();
+    DEV_VERSION_PATTERN = /^0\.0\.0/;
+    SERVER_VERSION = resolveVersion();
+    IS_DEV_BUILD = checkDevBuild(SERVER_VERSION);
+  }
+});
+
 // ../../apps/server/src/services/core/config-manager.ts
 var config_manager_exports = {};
 __export(config_manager_exports, {
@@ -23917,17 +24042,25 @@ __export(config_manager_exports, {
 });
 import Conf from "conf";
 import fs7 from "fs";
-import path11 from "path";
+import path12 from "path";
 function initConfigManager(dorkHome) {
   configManager = new ConfigManager(dorkHome);
   return configManager;
 }
-var jsonSchemaFull, jsonSchemaProperties, confSchema, ConfigManager, configManager;
+var CONFIG_MIGRATIONS, jsonSchemaFull, jsonSchemaProperties, confSchema, ConfigManager, configManager;
 var init_config_manager = __esm({
   "../../apps/server/src/services/core/config-manager.ts"() {
     init_zod();
     init_config_schema();
     init_logger();
+    init_version();
+    CONFIG_MIGRATIONS = {
+      "1.0.0": (store) => {
+        if (!store.has("version")) {
+          store.set("version", 1);
+        }
+      }
+    };
     jsonSchemaFull = external_exports.toJSONSchema(UserConfigSchema, {
       target: "jsonSchema2019-09"
     });
@@ -23938,24 +24071,24 @@ var init_config_manager = __esm({
       _isFirstRun = false;
       constructor(dorkHome) {
         const configDir = dorkHome;
-        const configPath = path11.join(configDir, "config.json");
+        const configPath = path12.join(configDir, "config.json");
         this._isFirstRun = !fs7.existsSync(configPath);
+        const confOptions = {
+          configName: "config",
+          cwd: configDir,
+          schema: confSchema,
+          defaults: USER_CONFIG_DEFAULTS,
+          clearInvalidConfig: false,
+          // `projectVersion` is the app version — sourced from the canonical
+          // version resolver (`lib/version.ts`) which honors
+          // `DORKOS_VERSION_OVERRIDE`, the esbuild-injected CLI version, and the
+          // package.json dev fallback in that order. Migration keys in
+          // CONFIG_MIGRATIONS must be semver strings matching real releases.
+          projectVersion: SERVER_VERSION,
+          migrations: CONFIG_MIGRATIONS
+        };
         try {
-          this.store = new Conf({
-            configName: "config",
-            cwd: configDir,
-            schema: confSchema,
-            defaults: USER_CONFIG_DEFAULTS,
-            clearInvalidConfig: false,
-            projectVersion: "1.0.0",
-            migrations: {
-              "1.0.0": (store) => {
-                if (!store.has("version")) {
-                  store.set("version", 1);
-                }
-              }
-            }
-          });
+          this.store = new Conf(confOptions);
           logger.info(`[Config] Loaded from ${configPath} (first run: ${this._isFirstRun})`);
         } catch (_error) {
           if (fs7.existsSync(configPath)) {
@@ -23965,13 +24098,7 @@ var init_config_manager = __esm({
             logger.warn(`Corrupt config backed up to ${backupPath}`);
             logger.warn("Creating fresh config with defaults.");
           }
-          this.store = new Conf({
-            configName: "config",
-            cwd: configDir,
-            schema: confSchema,
-            defaults: USER_CONFIG_DEFAULTS,
-            clearInvalidConfig: false
-          });
+          this.store = new Conf(confOptions);
         }
       }
       /** Whether this is the first time the config file has been created */
@@ -23992,12 +24119,12 @@ var init_config_manager = __esm({
       }
       /** Set a nested value via dot-path. Returns warning if key is sensitive. */
       setDot(key, value) {
-        const result = {};
+        const result2 = {};
         if (SENSITIVE_CONFIG_KEYS.includes(key)) {
-          result.warning = `'${key}' contains sensitive data. Consider using environment variables instead.`;
+          result2.warning = `'${key}' contains sensitive data. Consider using environment variables instead.`;
         }
         this.store.set(key, value);
-        return result;
+        return result2;
       }
       /** Get the full config object */
       getAll() {
@@ -24104,9 +24231,9 @@ function handleConfigGet(store, key) {
 }
 function handleConfigSet(store, key, rawValue) {
   const value = parseConfigValue(rawValue);
-  const result = store.setDot(key, value);
-  if (result.warning) {
-    console.warn(`\u26A0  ${result.warning}`);
+  const result2 = store.setDot(key, value);
+  if (result2.warning) {
+    console.warn(`\u26A0  ${result2.warning}`);
   }
   console.log(`Set ${key} = ${value === null ? "null" : String(value)}`);
 }
@@ -24137,13 +24264,13 @@ function handleConfigPath(store) {
   console.log(store.path);
 }
 function handleConfigValidate(store) {
-  const result = store.validate();
-  if (result.valid) {
+  const result2 = store.validate();
+  if (result2.valid) {
     console.log("Config is valid");
     process.exit(0);
   } else {
     console.error("Config validation failed:");
-    for (const err of result.errors ?? []) {
+    for (const err of result2.errors ?? []) {
       console.error(`  - ${err}`);
     }
     process.exit(1);
@@ -24204,10 +24331,10 @@ __export(init_wizard_exports, {
 });
 import { input, select, confirm as confirm3 } from "@inquirer/prompts";
 import fs8 from "fs";
-import path12 from "path";
+import path13 from "path";
 async function runInitWizard(options) {
   const { yes, dorkHome, store } = options;
-  const configPath = path12.join(dorkHome, "config.json");
+  const configPath = path13.join(dorkHome, "config.json");
   if (yes) {
     store.reset();
     console.log(`Config initialized with defaults at ${configPath}`);
@@ -24257,7 +24384,7 @@ async function runInitWizard(options) {
   store.setDot("ui.theme", theme);
   store.setDot("tunnel.enabled", tunnelEnabled);
   if (cwd && cwd.trim() !== "") {
-    store.setDot("server.cwd", path12.resolve(cwd));
+    store.setDot("server.cwd", path13.resolve(cwd));
   }
   console.log(`
 Config saved to ${configPath}`);
@@ -25428,8 +25555,8 @@ var require_main = __commonJS({
 // src/cli.ts
 import { parseArgs as parseArgs10 } from "node:util";
 import os3, { networkInterfaces } from "os";
-import path13 from "path";
-import { fileURLToPath } from "url";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import fs9 from "fs";
 
 // src/check-claude.ts
@@ -25686,7 +25813,7 @@ if (nodeVersionIssue) {
   console.error(formatDiagnostic(nodeVersionIssue));
   process.exit(1);
 }
-var __dirname = path13.dirname(fileURLToPath(import.meta.url));
+var __dirname = path14.dirname(fileURLToPath2(import.meta.url));
 if (process.argv[2] === "package") {
   const packageSubcommand = process.argv[3];
   const subArgs = process.argv.slice(4);
@@ -25930,12 +26057,12 @@ Examples:
   process.exit(0);
 }
 if (values.version) {
-  console.log("0.34.1");
+  console.log("0.36.0");
   process.exit(0);
 }
 if (values["post-install-check"]) {
   const claudeFound = checkClaude();
-  console.log(`dorkos ${"0.34.1"}`);
+  console.log(`dorkos ${"0.36.0"}`);
   if (claudeFound) {
     console.log("Installation verified.");
   } else {
@@ -25944,7 +26071,7 @@ if (values["post-install-check"]) {
   }
   process.exit(0);
 }
-var DORK_HOME = env.DORK_HOME || path13.join(os3.homedir(), ".dork");
+var DORK_HOME = env.DORK_HOME || path14.join(os3.homedir(), ".dork");
 var subcommand = positionals[0];
 if (subcommand === "cleanup") {
   const { runCleanup: runCleanup2 } = await Promise.resolve().then(() => (init_cleanup_command(), cleanup_command_exports));
@@ -25952,7 +26079,7 @@ if (subcommand === "cleanup") {
   process.exit(process.exitCode ?? 0);
 }
 fs9.mkdirSync(DORK_HOME, { recursive: true });
-fs9.mkdirSync(path13.join(DORK_HOME, "logs"), { recursive: true });
+fs9.mkdirSync(path14.join(DORK_HOME, "logs"), { recursive: true });
 process.env.DORK_HOME = DORK_HOME;
 if (subcommand === "config") {
   const { initConfigManager: initConfigManager3 } = await Promise.resolve().then(() => (init_config_manager(), config_manager_exports));
@@ -25982,7 +26109,7 @@ if (cliPort) {
   process.env.DORKOS_PORT = configPort ? String(configPort) : String(DEFAULT_PORT);
 }
 process.env.NODE_ENV = "production";
-process.env.CLIENT_DIST_PATH = path13.join(__dirname, "../client");
+process.env.CLIENT_DIST_PATH = path14.join(__dirname, "../client");
 if (values.tunnel) {
   process.env.TUNNEL_ENABLED = "true";
 } else if (!process.env.TUNNEL_ENABLED && cfgMgr.getDot("tunnel.enabled")) {
@@ -26021,30 +26148,30 @@ if (!process.env.DORKOS_RELAY_ENABLED && cfgMgr.getDot("relay.enabled")) {
 }
 var cliDir = values.dir;
 if (cliDir) {
-  process.env.DORKOS_DEFAULT_CWD = path13.resolve(cliDir);
+  process.env.DORKOS_DEFAULT_CWD = path14.resolve(cliDir);
 } else if (!process.env.DORKOS_DEFAULT_CWD) {
   const configCwd = cfgMgr.getDot("server.cwd");
-  process.env.DORKOS_DEFAULT_CWD = configCwd ? path13.resolve(configCwd) : process.cwd();
+  process.env.DORKOS_DEFAULT_CWD = configCwd ? path14.resolve(configCwd) : process.cwd();
 }
 var cliBoundary = values.boundary;
 if (cliBoundary) {
-  process.env.DORKOS_BOUNDARY = path13.resolve(cliBoundary);
+  process.env.DORKOS_BOUNDARY = path14.resolve(cliBoundary);
 } else if (!process.env.DORKOS_BOUNDARY) {
   const configBoundary = cfgMgr.getDot("server.boundary");
   if (configBoundary) {
-    process.env.DORKOS_BOUNDARY = path13.resolve(configBoundary);
+    process.env.DORKOS_BOUNDARY = path14.resolve(configBoundary);
   }
 }
 var boundaryVal = process.env.DORKOS_BOUNDARY;
 var home = os3.homedir();
-if (boundaryVal && !boundaryVal.startsWith(home + path13.sep) && boundaryVal !== home) {
+if (boundaryVal && !boundaryVal.startsWith(home + path14.sep) && boundaryVal !== home) {
   console.warn(
     `[Warning] Directory boundary "${boundaryVal}" is above home directory "${home}". This grants access to system directories.`
   );
 }
 var effectiveBoundary = process.env.DORKOS_BOUNDARY || home;
 var resolvedDir = process.env.DORKOS_DEFAULT_CWD;
-if (resolvedDir !== effectiveBoundary && !resolvedDir.startsWith(effectiveBoundary + path13.sep)) {
+if (resolvedDir !== effectiveBoundary && !resolvedDir.startsWith(effectiveBoundary + path14.sep)) {
   console.warn(
     `[Warning] Default CWD "${resolvedDir}" is outside boundary "${effectiveBoundary}". Falling back to boundary root.`
   );
@@ -26052,7 +26179,7 @@ if (resolvedDir !== effectiveBoundary && !resolvedDir.startsWith(effectiveBounda
 }
 var logLevelName = values["log-level"] || env.LOG_LEVEL || cfgMgr.getDot("logging.level") || (env.NODE_ENV === "production" ? "info" : "debug");
 process.env.DORKOS_LOG_LEVEL = String(LOG_LEVEL_MAP[logLevelName] ?? 3);
-var envPath = path13.join(process.env.DORKOS_DEFAULT_CWD, ".env");
+var envPath = path14.join(process.env.DORKOS_DEFAULT_CWD, ".env");
 if (fs9.existsSync(envPath)) {
   const dotenv = await import("dotenv");
   dotenv.config({ path: envPath, override: false });
@@ -26079,7 +26206,7 @@ var ansiReset = "\x1B[0m";
 console.log("");
 console.log(`${purple}${logo}${ansiReset}`);
 console.log("");
-console.log(`  DorkOS v${"0.34.1"}`);
+console.log(`  DorkOS v${"0.36.0"}`);
 console.log(`  Local:   ${link(localUrl, localUrl)}`);
 var nets = networkInterfaces();
 var networkUrl = null;
@@ -26140,9 +26267,9 @@ if (shouldOpenBrowser && process.stdin.isTTY) {
     }
   });
 }
-checkForUpdate("0.34.1").then((latestVersion) => {
+checkForUpdate("0.36.0").then((latestVersion) => {
   if (latestVersion) {
-    const msg = `Update available: ${"0.34.1"} \u2192 ${latestVersion}`;
+    const msg = `Update available: ${"0.36.0"} \u2192 ${latestVersion}`;
     const cmd = "Run npm install -g dorkos@latest to update";
     const width = Math.max(msg.length, cmd.length) + 6;
     const pad = (s2) => `\u2502   ${s2}${" ".repeat(width - s2.length - 6)}   \u2502`;