npm - dorkos - Versions diffs - 0.34.1 → 0.35.0 - Mend

dorkos 0.34.1 → 0.35.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/bin/cli.js CHANGED Viewed

@@ -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({
@@ -19422,17 +19433,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) {
@@ -19478,22 +19489,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 +19564,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 +20192,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 +20464,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 +20562,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 +20640,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 +20956,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 +21185,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 +21207,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 +21263,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 +21320,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 +21464,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 +21502,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 +21518,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 +21617,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 +21628,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 +21824,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 +21860,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 +21868,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 +22928,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 +23710,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 +23920,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.35.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 +24006,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 +24035,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 +24062,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 +24083,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 +24195,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 +24228,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 +24295,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 +24348,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 +25519,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 +25777,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 +26021,12 @@ Examples:
   process.exit(0);
 }
 if (values.version) {
-  console.log("0.34.1");
+  console.log("0.35.0");
   process.exit(0);
 }
 if (values["post-install-check"]) {
   const claudeFound = checkClaude();
-  console.log(`dorkos ${"0.34.1"}`);
+  console.log(`dorkos ${"0.35.0"}`);
   if (claudeFound) {
     console.log("Installation verified.");
   } else {
@@ -25944,7 +26035,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 +26043,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 +26073,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 +26112,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 +26143,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 +26170,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.35.0"}`);
 console.log(`  Local:   ${link(localUrl, localUrl)}`);
 var nets = networkInterfaces();
 var networkUrl = null;
@@ -26140,9 +26231,9 @@ if (shouldOpenBrowser && process.stdin.isTTY) {
     }
   });
 }
-checkForUpdate("0.34.1").then((latestVersion) => {
+checkForUpdate("0.35.0").then((latestVersion) => {
   if (latestVersion) {
-    const msg = `Update available: ${"0.34.1"} \u2192 ${latestVersion}`;
+    const msg = `Update available: ${"0.35.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`;