tesseract-agent 0.6.0 → 0.6.1

package/dist-bundle/cli.js

@@ -4799,12 +4799,12 @@ function prefixIssues(path5, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
-function finalizeIssue(iss, ctx, config2) {
-  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+function finalizeIssue(iss, ctx2, config2) {
+  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx2?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
   const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
   rest.path ?? (rest.path = []);
   rest.message = message;
-  if (ctx?.reportInput) {
+  if (ctx2?.reportInput) {
     rest.input = _input;
   }
   return rest;
@@ -5147,13 +5147,13 @@ var init_parse = __esm({
     init_errors();
     init_util();
     _parse = (_Err) => (schema, value, _ctx, _params) => {
-      const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result2 = schema._zod.run({ value, issues: [] }, ctx);
+      const ctx2 = _ctx ? { ..._ctx, async: false } : { async: false };
+      const result2 = schema._zod.run({ value, issues: [] }, ctx2);
       if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
       if (result2.issues.length) {
-        const e = new (_params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+        const e = new (_params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx2, config())));
         captureStackTrace(e, _params?.callee);
         throw e;
       }
@@ -5161,12 +5161,12 @@ var init_parse = __esm({
     };
     parse = /* @__PURE__ */ _parse($ZodRealError);
     _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
-      const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-      let result2 = schema._zod.run({ value, issues: [] }, ctx);
+      const ctx2 = _ctx ? { ..._ctx, async: true } : { async: true };
+      let result2 = schema._zod.run({ value, issues: [] }, ctx2);
       if (result2 instanceof Promise)
         result2 = await result2;
       if (result2.issues.length) {
-        const e = new (params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+        const e = new (params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx2, config())));
         captureStackTrace(e, params?.callee);
         throw e;
       }
@@ -5174,31 +5174,31 @@ var init_parse = __esm({
     };
     parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
     _safeParse = (_Err) => (schema, value, _ctx) => {
-      const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result2 = schema._zod.run({ value, issues: [] }, ctx);
+      const ctx2 = _ctx ? { ..._ctx, async: false } : { async: false };
+      const result2 = schema._zod.run({ value, issues: [] }, ctx2);
       if (result2 instanceof Promise) {
         throw new $ZodAsyncError();
       }
       return result2.issues.length ? {
         success: false,
-        error: new (_Err ?? $ZodError)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+        error: new (_Err ?? $ZodError)(result2.issues.map((iss) => finalizeIssue(iss, ctx2, config())))
       } : { success: true, data: result2.value };
     };
     safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
     _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
-      const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-      let result2 = schema._zod.run({ value, issues: [] }, ctx);
+      const ctx2 = _ctx ? { ..._ctx, async: true } : { async: true };
+      let result2 = schema._zod.run({ value, issues: [] }, ctx2);
       if (result2 instanceof Promise)
         result2 = await result2;
       return result2.issues.length ? {
         success: false,
-        error: new _Err(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+        error: new _Err(result2.issues.map((iss) => finalizeIssue(iss, ctx2, config())))
       } : { success: true, data: result2.value };
     };
     safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
     _encode = (_Err) => (schema, value, _ctx) => {
-      const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _parse(_Err)(schema, value, ctx);
+      const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+      return _parse(_Err)(schema, value, ctx2);
     };
     encode = /* @__PURE__ */ _encode($ZodRealError);
     _decode = (_Err) => (schema, value, _ctx) => {
@@ -5206,8 +5206,8 @@ var init_parse = __esm({
     };
     decode = /* @__PURE__ */ _decode($ZodRealError);
     _encodeAsync = (_Err) => async (schema, value, _ctx) => {
-      const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _parseAsync(_Err)(schema, value, ctx);
+      const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+      return _parseAsync(_Err)(schema, value, ctx2);
     };
     encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
     _decodeAsync = (_Err) => async (schema, value, _ctx) => {
@@ -5215,8 +5215,8 @@ var init_parse = __esm({
     };
     decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
     _safeEncode = (_Err) => (schema, value, _ctx) => {
-      const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _safeParse(_Err)(schema, value, ctx);
+      const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+      return _safeParse(_Err)(schema, value, ctx2);
     };
     safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
     _safeDecode = (_Err) => (schema, value, _ctx) => {
@@ -5224,8 +5224,8 @@ var init_parse = __esm({
     };
     safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
     _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
-      const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-      return _safeParseAsync(_Err)(schema, value, ctx);
+      const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+      return _safeParseAsync(_Err)(schema, value, ctx2);
     };
     safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
     _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
@@ -6100,7 +6100,7 @@ function normalizeDef(def) {
     optionalKeys: new Set(okeys)
   };
 }
-function handleCatchall(proms, input, payload, ctx, def, inst) {
+function handleCatchall(proms, input, payload, ctx2, def, inst) {
   const unrecognized = [];
   const keySet = def.keySet;
   const _catchall = def.catchall._zod;
@@ -6116,7 +6116,7 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
       unrecognized.push(key2);
       continue;
     }
-    const r = _catchall.run({ value: input[key2], issues: [] }, ctx);
+    const r = _catchall.run({ value: input[key2], issues: [] }, ctx2);
     if (r instanceof Promise) {
       proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
     } else {
@@ -6137,7 +6137,7 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
     return payload;
   });
 }
-function handleUnionResults(results, final, inst, ctx) {
+function handleUnionResults(results, final, inst, ctx2) {
   for (const result2 of results) {
     if (result2.issues.length === 0) {
       final.value = result2.value;
@@ -6153,11 +6153,11 @@ function handleUnionResults(results, final, inst, ctx) {
     code: "invalid_union",
     input: final.value,
     inst,
-    errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx2, config())))
   });
   return final;
 }
-function handleExclusiveUnionResults(results, final, inst, ctx) {
+function handleExclusiveUnionResults(results, final, inst, ctx2) {
   const successes = results.filter((r) => r.issues.length === 0);
   if (successes.length === 1) {
     final.value = successes[0].value;
@@ -6168,7 +6168,7 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
       code: "invalid_union",
       input: final.value,
       inst,
-      errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+      errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx2, config())))
     });
   } else {
     final.issues.push({
@@ -6299,7 +6299,7 @@ function handleTupleResults(itemResults, final, items, input, optoutStart) {
   }
   return final;
 }
-function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx) {
+function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx2) {
   if (keyResult.issues.length) {
     if (propertyKeyTypes.has(typeof key2)) {
       final.issues.push(...prefixIssues(key2, keyResult.issues));
@@ -6309,7 +6309,7 @@ function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx)
         origin: "map",
         input,
         inst,
-        issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+        issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx2, config()))
       });
     }
   }
@@ -6323,7 +6323,7 @@ function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx)
         input,
         inst,
         key: key2,
-        issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+        issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx2, config()))
       });
     }
   }
@@ -6358,39 +6358,39 @@ function handleNonOptionalResult(payload, inst) {
   }
   return payload;
 }
-function handlePipeResult(left, next, ctx) {
+function handlePipeResult(left, next, ctx2) {
   if (left.issues.length) {
     left.aborted = true;
     return left;
   }
-  return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
+  return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx2);
 }
-function handleCodecAResult(result2, def, ctx) {
+function handleCodecAResult(result2, def, ctx2) {
   if (result2.issues.length) {
     result2.aborted = true;
     return result2;
   }
-  const direction = ctx.direction || "forward";
+  const direction = ctx2.direction || "forward";
   if (direction === "forward") {
     const transformed = def.transform(result2.value, result2);
     if (transformed instanceof Promise) {
-      return transformed.then((value) => handleCodecTxResult(result2, value, def.out, ctx));
+      return transformed.then((value) => handleCodecTxResult(result2, value, def.out, ctx2));
     }
-    return handleCodecTxResult(result2, transformed, def.out, ctx);
+    return handleCodecTxResult(result2, transformed, def.out, ctx2);
   } else {
     const transformed = def.reverseTransform(result2.value, result2);
     if (transformed instanceof Promise) {
-      return transformed.then((value) => handleCodecTxResult(result2, value, def.in, ctx));
+      return transformed.then((value) => handleCodecTxResult(result2, value, def.in, ctx2));
     }
-    return handleCodecTxResult(result2, transformed, def.in, ctx);
+    return handleCodecTxResult(result2, transformed, def.in, ctx2);
   }
 }
-function handleCodecTxResult(left, value, nextSchema, ctx) {
+function handleCodecTxResult(left, value, nextSchema, ctx2) {
   if (left.issues.length) {
     left.aborted = true;
     return left;
   }
-  return nextSchema._zod.run({ value, issues: left.issues }, ctx);
+  return nextSchema._zod.run({ value, issues: left.issues }, ctx2);
 }
 function handleReadonlyResult(payload) {
   payload.value = Object.freeze(payload.value);
@@ -6445,7 +6445,7 @@ var init_schemas = __esm({
           inst._zod.run = inst._zod.parse;
         });
       } else {
-        const runChecks = (payload, checks2, ctx) => {
+        const runChecks = (payload, checks2, ctx2) => {
           let isAborted = aborted(payload);
           let asyncResult;
           for (const ch of checks2) {
@@ -6460,7 +6460,7 @@ var init_schemas = __esm({
             }
             const currLen = payload.issues.length;
             const _ = ch._zod.check(payload);
-            if (_ instanceof Promise && ctx?.async === false) {
+            if (_ instanceof Promise && ctx2?.async === false) {
               throw new $ZodAsyncError();
             }
             if (asyncResult || _ instanceof Promise) {
@@ -6487,39 +6487,39 @@ var init_schemas = __esm({
           }
           return payload;
         };
-        const handleCanaryResult = (canary, payload, ctx) => {
+        const handleCanaryResult = (canary, payload, ctx2) => {
           if (aborted(canary)) {
             canary.aborted = true;
             return canary;
           }
-          const checkResult = runChecks(payload, checks, ctx);
+          const checkResult = runChecks(payload, checks, ctx2);
           if (checkResult instanceof Promise) {
-            if (ctx.async === false)
+            if (ctx2.async === false)
               throw new $ZodAsyncError();
-            return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
+            return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx2));
           }
-          return inst._zod.parse(checkResult, ctx);
+          return inst._zod.parse(checkResult, ctx2);
         };
-        inst._zod.run = (payload, ctx) => {
-          if (ctx.skipChecks) {
-            return inst._zod.parse(payload, ctx);
+        inst._zod.run = (payload, ctx2) => {
+          if (ctx2.skipChecks) {
+            return inst._zod.parse(payload, ctx2);
           }
-          if (ctx.direction === "backward") {
-            const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+          if (ctx2.direction === "backward") {
+            const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx2, skipChecks: true });
             if (canary instanceof Promise) {
               return canary.then((canary2) => {
-                return handleCanaryResult(canary2, payload, ctx);
+                return handleCanaryResult(canary2, payload, ctx2);
               });
             }
-            return handleCanaryResult(canary, payload, ctx);
+            return handleCanaryResult(canary, payload, ctx2);
           }
-          const result2 = inst._zod.parse(payload, ctx);
+          const result2 = inst._zod.parse(payload, ctx2);
           if (result2 instanceof Promise) {
-            if (ctx.async === false)
+            if (ctx2.async === false)
               throw new $ZodAsyncError();
-            return result2.then((result3) => runChecks(result3, checks, ctx));
+            return result2.then((result3) => runChecks(result3, checks, ctx2));
           }
-          return runChecks(result2, checks, ctx);
+          return runChecks(result2, checks, ctx2);
         };
       }
       defineLazy(inst, "~standard", () => ({
@@ -7002,7 +7002,7 @@ var init_schemas = __esm({
     });
     $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
       $ZodType.init(inst, def);
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const input = payload.value;
         if (!Array.isArray(input)) {
           payload.issues.push({
@@ -7020,7 +7020,7 @@ var init_schemas = __esm({
           const result2 = def.element._zod.run({
             value: item,
             issues: []
-          }, ctx);
+          }, ctx2);
           if (result2 instanceof Promise) {
             proms.push(result2.then((result3) => handleArrayResult(result3, payload, i)));
           } else {
@@ -7065,7 +7065,7 @@ var init_schemas = __esm({
       const isObject2 = isObject;
       const catchall = def.catchall;
       let value;
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         value ?? (value = _normalized.value);
         const input = payload.value;
         if (!isObject2(input)) {
@@ -7084,7 +7084,7 @@ var init_schemas = __esm({
           const el2 = shape[key2];
           const isOptionalIn = el2._zod.optin === "optional";
           const isOptionalOut = el2._zod.optout === "optional";
-          const r = el2._zod.run({ value: input[key2], issues: [] }, ctx);
+          const r = el2._zod.run({ value: input[key2], issues: [] }, ctx2);
           if (r instanceof Promise) {
             proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
           } else {
@@ -7094,7 +7094,7 @@ var init_schemas = __esm({
         if (!catchall) {
           return proms.length ? Promise.all(proms).then(() => payload) : payload;
         }
-        return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+        return handleCatchall(proms, input, payload, ctx2, _normalized.value, inst);
       };
     });
     $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
@@ -7192,7 +7192,7 @@ var init_schemas = __esm({
         doc.write(`payload.value = newResult;`);
         doc.write(`return payload;`);
         const fn = doc.compile();
-        return (payload, ctx) => fn(shape, payload, ctx);
+        return (payload, ctx2) => fn(shape, payload, ctx2);
       };
       let fastpass;
       const isObject2 = isObject;
@@ -7201,7 +7201,7 @@ var init_schemas = __esm({
       const fastEnabled = jit && allowsEval2.value;
       const catchall = def.catchall;
       let value;
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         value ?? (value = _normalized.value);
         const input = payload.value;
         if (!isObject2(input)) {
@@ -7213,15 +7213,15 @@ var init_schemas = __esm({
           });
           return payload;
         }
-        if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+        if (jit && fastEnabled && ctx2?.async === false && ctx2.jitless !== true) {
           if (!fastpass)
             fastpass = generateFastpass(def.shape);
-          payload = fastpass(payload, ctx);
+          payload = fastpass(payload, ctx2);
           if (!catchall)
             return payload;
-          return handleCatchall([], input, payload, ctx, value, inst);
+          return handleCatchall([], input, payload, ctx2, value, inst);
         }
-        return superParse(payload, ctx);
+        return superParse(payload, ctx2);
       };
     });
     $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
@@ -7242,9 +7242,9 @@ var init_schemas = __esm({
         return void 0;
       });
       const first = def.options.length === 1 ? def.options[0]._zod.run : null;
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         if (first) {
-          return first(payload, ctx);
+          return first(payload, ctx2);
         }
         let async = false;
         const results = [];
@@ -7252,7 +7252,7 @@ var init_schemas = __esm({
           const result2 = option._zod.run({
             value: payload.value,
             issues: []
-          }, ctx);
+          }, ctx2);
           if (result2 instanceof Promise) {
             results.push(result2);
             async = true;
@@ -7263,9 +7263,9 @@ var init_schemas = __esm({
           }
         }
         if (!async)
-          return handleUnionResults(results, payload, inst, ctx);
+          return handleUnionResults(results, payload, inst, ctx2);
         return Promise.all(results).then((results2) => {
-          return handleUnionResults(results2, payload, inst, ctx);
+          return handleUnionResults(results2, payload, inst, ctx2);
         });
       };
     });
@@ -7273,9 +7273,9 @@ var init_schemas = __esm({
       $ZodUnion.init(inst, def);
       def.inclusive = false;
       const first = def.options.length === 1 ? def.options[0]._zod.run : null;
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         if (first) {
-          return first(payload, ctx);
+          return first(payload, ctx2);
         }
         let async = false;
         const results = [];
@@ -7283,7 +7283,7 @@ var init_schemas = __esm({
           const result2 = option._zod.run({
             value: payload.value,
             issues: []
-          }, ctx);
+          }, ctx2);
           if (result2 instanceof Promise) {
             results.push(result2);
             async = true;
@@ -7292,9 +7292,9 @@ var init_schemas = __esm({
           }
         }
         if (!async)
-          return handleExclusiveUnionResults(results, payload, inst, ctx);
+          return handleExclusiveUnionResults(results, payload, inst, ctx2);
         return Promise.all(results).then((results2) => {
-          return handleExclusiveUnionResults(results2, payload, inst, ctx);
+          return handleExclusiveUnionResults(results2, payload, inst, ctx2);
         });
       };
     });
@@ -7334,7 +7334,7 @@ var init_schemas = __esm({
         }
         return map2;
       });
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const input = payload.value;
         if (!isObject(input)) {
           payload.issues.push({
@@ -7347,10 +7347,10 @@ var init_schemas = __esm({
         }
         const opt = disc.value.get(input?.[def.discriminator]);
         if (opt) {
-          return opt._zod.run(payload, ctx);
+          return opt._zod.run(payload, ctx2);
         }
-        if (def.unionFallback || ctx.direction === "backward") {
-          return _super(payload, ctx);
+        if (def.unionFallback || ctx2.direction === "backward") {
+          return _super(payload, ctx2);
         }
         payload.issues.push({
           code: "invalid_union",
@@ -7367,10 +7367,10 @@ var init_schemas = __esm({
     });
     $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
       $ZodType.init(inst, def);
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const input = payload.value;
-        const left = def.left._zod.run({ value: input, issues: [] }, ctx);
-        const right = def.right._zod.run({ value: input, issues: [] }, ctx);
+        const left = def.left._zod.run({ value: input, issues: [] }, ctx2);
+        const right = def.right._zod.run({ value: input, issues: [] }, ctx2);
         const async = left instanceof Promise || right instanceof Promise;
         if (async) {
           return Promise.all([left, right]).then(([left2, right2]) => {
@@ -7383,7 +7383,7 @@ var init_schemas = __esm({
     $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
       $ZodType.init(inst, def);
       const items = def.items;
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const input = payload.value;
         if (!Array.isArray(input)) {
           payload.issues.push({
@@ -7423,7 +7423,7 @@ var init_schemas = __esm({
         }
         const itemResults = new Array(items.length);
         for (let i = 0; i < items.length; i++) {
-          const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
+          const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx2);
           if (r instanceof Promise) {
             proms.push(r.then((rr) => {
               itemResults[i] = rr;
@@ -7437,7 +7437,7 @@ var init_schemas = __esm({
           const rest = input.slice(items.length);
           for (const el2 of rest) {
             i++;
-            const result2 = def.rest._zod.run({ value: el2, issues: [] }, ctx);
+            const result2 = def.rest._zod.run({ value: el2, issues: [] }, ctx2);
             if (result2 instanceof Promise) {
               proms.push(result2.then((r) => handleTupleResult(r, payload, i)));
             } else {
@@ -7453,7 +7453,7 @@ var init_schemas = __esm({
     });
     $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       $ZodType.init(inst, def);
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const input = payload.value;
         if (!isPlainObject(input)) {
           payload.issues.push({
@@ -7472,7 +7472,7 @@ var init_schemas = __esm({
           for (const key2 of values) {
             if (typeof key2 === "string" || typeof key2 === "number" || typeof key2 === "symbol") {
               recordKeys.add(typeof key2 === "number" ? key2.toString() : key2);
-              const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
+              const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx2);
               if (keyResult instanceof Promise) {
                 throw new Error("Async schemas not supported in object keys currently");
               }
@@ -7480,7 +7480,7 @@ var init_schemas = __esm({
                 payload.issues.push({
                   code: "invalid_key",
                   origin: "record",
-                  issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                  issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx2, config())),
                   input: key2,
                   path: [key2],
                   inst
@@ -7488,7 +7488,7 @@ var init_schemas = __esm({
                 continue;
               }
               const outKey = keyResult.value;
-              const result2 = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
+              const result2 = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx2);
               if (result2 instanceof Promise) {
                 proms.push(result2.then((result3) => {
                   if (result3.issues.length) {
@@ -7526,13 +7526,13 @@ var init_schemas = __esm({
               continue;
             if (!Object.prototype.propertyIsEnumerable.call(input, key2))
               continue;
-            let keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
+            let keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx2);
             if (keyResult instanceof Promise) {
               throw new Error("Async schemas not supported in object keys currently");
             }
             const checkNumericKey = typeof key2 === "string" && number.test(key2) && keyResult.issues.length;
             if (checkNumericKey) {
-              const retryResult = def.keyType._zod.run({ value: Number(key2), issues: [] }, ctx);
+              const retryResult = def.keyType._zod.run({ value: Number(key2), issues: [] }, ctx2);
               if (retryResult instanceof Promise) {
                 throw new Error("Async schemas not supported in object keys currently");
               }
@@ -7547,7 +7547,7 @@ var init_schemas = __esm({
                 payload.issues.push({
                   code: "invalid_key",
                   origin: "record",
-                  issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                  issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx2, config())),
                   input: key2,
                   path: [key2],
                   inst
@@ -7555,7 +7555,7 @@ var init_schemas = __esm({
               }
               continue;
             }
-            const result2 = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
+            const result2 = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx2);
             if (result2 instanceof Promise) {
               proms.push(result2.then((result3) => {
                 if (result3.issues.length) {
@@ -7579,7 +7579,7 @@ var init_schemas = __esm({
     });
     $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
       $ZodType.init(inst, def);
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const input = payload.value;
         if (!(input instanceof Map)) {
           payload.issues.push({
@@ -7593,14 +7593,14 @@ var init_schemas = __esm({
         const proms = [];
         payload.value = /* @__PURE__ */ new Map();
         for (const [key2, value] of input) {
-          const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
-          const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
+          const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx2);
+          const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx2);
           if (keyResult instanceof Promise || valueResult instanceof Promise) {
             proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
-              handleMapResult(keyResult2, valueResult2, payload, key2, input, inst, ctx);
+              handleMapResult(keyResult2, valueResult2, payload, key2, input, inst, ctx2);
             }));
           } else {
-            handleMapResult(keyResult, valueResult, payload, key2, input, inst, ctx);
+            handleMapResult(keyResult, valueResult, payload, key2, input, inst, ctx2);
           }
         }
         if (proms.length)
@@ -7610,7 +7610,7 @@ var init_schemas = __esm({
     });
     $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
       $ZodType.init(inst, def);
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const input = payload.value;
         if (!(input instanceof Set)) {
           payload.issues.push({
@@ -7624,7 +7624,7 @@ var init_schemas = __esm({
         const proms = [];
         payload.value = /* @__PURE__ */ new Set();
         for (const item of input) {
-          const result2 = def.valueType._zod.run({ value: item, issues: [] }, ctx);
+          const result2 = def.valueType._zod.run({ value: item, issues: [] }, ctx2);
           if (result2 instanceof Promise) {
             proms.push(result2.then((result3) => handleSetResult(result3, payload)));
           } else
@@ -7695,12 +7695,12 @@ var init_schemas = __esm({
     $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
       $ZodType.init(inst, def);
       inst._zod.optin = "optional";
-      inst._zod.parse = (payload, ctx) => {
-        if (ctx.direction === "backward") {
+      inst._zod.parse = (payload, ctx2) => {
+        if (ctx2.direction === "backward") {
           throw new $ZodEncodeError(inst.constructor.name);
         }
         const _out = def.transform(payload.value, payload);
-        if (ctx.async) {
+        if (ctx2.async) {
           const output = _out instanceof Promise ? _out : Promise.resolve(_out);
           return output.then((output2) => {
             payload.value = output2;
@@ -7727,10 +7727,10 @@ var init_schemas = __esm({
         const pattern = def.innerType._zod.pattern;
         return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
       });
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         if (def.innerType._zod.optin === "optional") {
           const input = payload.value;
-          const result2 = def.innerType._zod.run(payload, ctx);
+          const result2 = def.innerType._zod.run(payload, ctx2);
           if (result2 instanceof Promise)
             return result2.then((r) => handleOptionalResult(r, input));
           return handleOptionalResult(result2, input);
@@ -7738,15 +7738,15 @@ var init_schemas = __esm({
         if (payload.value === void 0) {
           return payload;
         }
-        return def.innerType._zod.run(payload, ctx);
+        return def.innerType._zod.run(payload, ctx2);
       };
     });
     $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
       $ZodOptional.init(inst, def);
       defineLazy(inst._zod, "values", () => def.innerType._zod.values);
       defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
-      inst._zod.parse = (payload, ctx) => {
-        return def.innerType._zod.run(payload, ctx);
+      inst._zod.parse = (payload, ctx2) => {
+        return def.innerType._zod.run(payload, ctx2);
       };
     });
     $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
@@ -7760,25 +7760,25 @@ var init_schemas = __esm({
       defineLazy(inst._zod, "values", () => {
         return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
       });
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         if (payload.value === null)
           return payload;
-        return def.innerType._zod.run(payload, ctx);
+        return def.innerType._zod.run(payload, ctx2);
       };
     });
     $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
       $ZodType.init(inst, def);
       inst._zod.optin = "optional";
       defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-      inst._zod.parse = (payload, ctx) => {
-        if (ctx.direction === "backward") {
-          return def.innerType._zod.run(payload, ctx);
+      inst._zod.parse = (payload, ctx2) => {
+        if (ctx2.direction === "backward") {
+          return def.innerType._zod.run(payload, ctx2);
         }
         if (payload.value === void 0) {
           payload.value = def.defaultValue;
           return payload;
         }
-        const result2 = def.innerType._zod.run(payload, ctx);
+        const result2 = def.innerType._zod.run(payload, ctx2);
         if (result2 instanceof Promise) {
           return result2.then((result3) => handleDefaultResult(result3, def));
         }
@@ -7789,14 +7789,14 @@ var init_schemas = __esm({
       $ZodType.init(inst, def);
       inst._zod.optin = "optional";
       defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-      inst._zod.parse = (payload, ctx) => {
-        if (ctx.direction === "backward") {
-          return def.innerType._zod.run(payload, ctx);
+      inst._zod.parse = (payload, ctx2) => {
+        if (ctx2.direction === "backward") {
+          return def.innerType._zod.run(payload, ctx2);
         }
         if (payload.value === void 0) {
           payload.value = def.defaultValue;
         }
-        return def.innerType._zod.run(payload, ctx);
+        return def.innerType._zod.run(payload, ctx2);
       };
     });
     $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
@@ -7805,8 +7805,8 @@ var init_schemas = __esm({
         const v = def.innerType._zod.values;
         return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
       });
-      inst._zod.parse = (payload, ctx) => {
-        const result2 = def.innerType._zod.run(payload, ctx);
+      inst._zod.parse = (payload, ctx2) => {
+        const result2 = def.innerType._zod.run(payload, ctx2);
         if (result2 instanceof Promise) {
           return result2.then((result3) => handleNonOptionalResult(result3, inst));
         }
@@ -7815,11 +7815,11 @@ var init_schemas = __esm({
     });
     $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
       $ZodType.init(inst, def);
-      inst._zod.parse = (payload, ctx) => {
-        if (ctx.direction === "backward") {
+      inst._zod.parse = (payload, ctx2) => {
+        if (ctx2.direction === "backward") {
           throw new $ZodEncodeError("ZodSuccess");
         }
-        const result2 = def.innerType._zod.run(payload, ctx);
+        const result2 = def.innerType._zod.run(payload, ctx2);
         if (result2 instanceof Promise) {
           return result2.then((result3) => {
             payload.value = result3.issues.length === 0;
@@ -7835,11 +7835,11 @@ var init_schemas = __esm({
       inst._zod.optin = "optional";
       defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
       defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-      inst._zod.parse = (payload, ctx) => {
-        if (ctx.direction === "backward") {
-          return def.innerType._zod.run(payload, ctx);
+      inst._zod.parse = (payload, ctx2) => {
+        if (ctx2.direction === "backward") {
+          return def.innerType._zod.run(payload, ctx2);
         }
-        const result2 = def.innerType._zod.run(payload, ctx);
+        const result2 = def.innerType._zod.run(payload, ctx2);
         if (result2 instanceof Promise) {
           return result2.then((result3) => {
             payload.value = result3.value;
@@ -7847,7 +7847,7 @@ var init_schemas = __esm({
               payload.value = def.catchValue({
                 ...payload,
                 error: {
-                  issues: result3.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+                  issues: result3.issues.map((iss) => finalizeIssue(iss, ctx2, config()))
                 },
                 input: payload.value
               });
@@ -7862,7 +7862,7 @@ var init_schemas = __esm({
           payload.value = def.catchValue({
             ...payload,
             error: {
-              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx2, config()))
             },
             input: payload.value
           });
@@ -7893,19 +7893,19 @@ var init_schemas = __esm({
       defineLazy(inst._zod, "optin", () => def.in._zod.optin);
       defineLazy(inst._zod, "optout", () => def.out._zod.optout);
       defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
-      inst._zod.parse = (payload, ctx) => {
-        if (ctx.direction === "backward") {
-          const right = def.out._zod.run(payload, ctx);
+      inst._zod.parse = (payload, ctx2) => {
+        if (ctx2.direction === "backward") {
+          const right = def.out._zod.run(payload, ctx2);
           if (right instanceof Promise) {
-            return right.then((right2) => handlePipeResult(right2, def.in, ctx));
+            return right.then((right2) => handlePipeResult(right2, def.in, ctx2));
           }
-          return handlePipeResult(right, def.in, ctx);
+          return handlePipeResult(right, def.in, ctx2);
         }
-        const left = def.in._zod.run(payload, ctx);
+        const left = def.in._zod.run(payload, ctx2);
         if (left instanceof Promise) {
-          return left.then((left2) => handlePipeResult(left2, def.out, ctx));
+          return left.then((left2) => handlePipeResult(left2, def.out, ctx2));
         }
-        return handlePipeResult(left, def.out, ctx);
+        return handlePipeResult(left, def.out, ctx2);
       };
     });
     $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
@@ -7914,20 +7914,20 @@ var init_schemas = __esm({
       defineLazy(inst._zod, "optin", () => def.in._zod.optin);
       defineLazy(inst._zod, "optout", () => def.out._zod.optout);
       defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
-      inst._zod.parse = (payload, ctx) => {
-        const direction = ctx.direction || "forward";
+      inst._zod.parse = (payload, ctx2) => {
+        const direction = ctx2.direction || "forward";
         if (direction === "forward") {
-          const left = def.in._zod.run(payload, ctx);
+          const left = def.in._zod.run(payload, ctx2);
           if (left instanceof Promise) {
-            return left.then((left2) => handleCodecAResult(left2, def, ctx));
+            return left.then((left2) => handleCodecAResult(left2, def, ctx2));
           }
-          return handleCodecAResult(left, def, ctx);
+          return handleCodecAResult(left, def, ctx2);
         } else {
-          const right = def.out._zod.run(payload, ctx);
+          const right = def.out._zod.run(payload, ctx2);
           if (right instanceof Promise) {
-            return right.then((right2) => handleCodecAResult(right2, def, ctx));
+            return right.then((right2) => handleCodecAResult(right2, def, ctx2));
           }
-          return handleCodecAResult(right, def, ctx);
+          return handleCodecAResult(right, def, ctx2);
         }
       };
     });
@@ -7940,11 +7940,11 @@ var init_schemas = __esm({
       defineLazy(inst._zod, "values", () => def.innerType._zod.values);
       defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
       defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
-      inst._zod.parse = (payload, ctx) => {
-        if (ctx.direction === "backward") {
-          return def.innerType._zod.run(payload, ctx);
+      inst._zod.parse = (payload, ctx2) => {
+        if (ctx2.direction === "backward") {
+          return def.innerType._zod.run(payload, ctx2);
         }
-        const result2 = def.innerType._zod.run(payload, ctx);
+        const result2 = def.innerType._zod.run(payload, ctx2);
         if (result2 instanceof Promise) {
           return result2.then(handleReadonlyResult);
         }
@@ -8075,8 +8075,8 @@ var init_schemas = __esm({
     });
     $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
       $ZodType.init(inst, def);
-      inst._zod.parse = (payload, ctx) => {
-        return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
+      inst._zod.parse = (payload, ctx2) => {
+        return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx2));
       };
     });
     $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
@@ -8091,9 +8091,9 @@ var init_schemas = __esm({
       defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
       defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
       defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0);
-      inst._zod.parse = (payload, ctx) => {
+      inst._zod.parse = (payload, ctx2) => {
         const inner = inst._zod.innerType;
-        return inner._zod.run(payload, ctx);
+        return inner._zod.run(payload, ctx2);
       };
     });
     $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
@@ -15560,10 +15560,10 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx2, _params = { path: [], schemaPath: [] }) {
   var _a3;
   const def = schema._zod.def;
-  const seen = ctx.seen.get(schema);
+  const seen = ctx2.seen.get(schema);
   if (seen) {
     seen.count++;
     const isCycle = _params.schemaPath.includes(schema);
@@ -15573,7 +15573,7 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     return seen.schema;
   }
   const result2 = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema, result2);
+  ctx2.seen.set(schema, result2);
   const overrideSchema = schema._zod.toJSONSchema?.();
   if (overrideSchema) {
     result2.schema = overrideSchema;
@@ -15584,43 +15584,43 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
       path: _params.path
     };
     if (schema._zod.processJSONSchema) {
-      schema._zod.processJSONSchema(ctx, result2.schema, params);
+      schema._zod.processJSONSchema(ctx2, result2.schema, params);
     } else {
       const _json = result2.schema;
-      const processor = ctx.processors[def.type];
+      const processor = ctx2.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
       }
-      processor(schema, ctx, _json, params);
+      processor(schema, ctx2, _json, params);
     }
     const parent = schema._zod.parent;
     if (parent) {
       if (!result2.ref)
         result2.ref = parent;
-      process2(parent, ctx, params);
-      ctx.seen.get(parent).isParent = true;
+      process2(parent, ctx2, params);
+      ctx2.seen.get(parent).isParent = true;
     }
   }
-  const meta4 = ctx.metadataRegistry.get(schema);
+  const meta4 = ctx2.metadataRegistry.get(schema);
   if (meta4)
     Object.assign(result2.schema, meta4);
-  if (ctx.io === "input" && isTransforming(schema)) {
+  if (ctx2.io === "input" && isTransforming(schema)) {
     delete result2.schema.examples;
     delete result2.schema.default;
   }
-  if (ctx.io === "input" && "_prefault" in result2.schema)
+  if (ctx2.io === "input" && "_prefault" in result2.schema)
     (_a3 = result2.schema).default ?? (_a3.default = result2.schema._prefault);
   delete result2.schema._prefault;
-  const _result = ctx.seen.get(schema);
+  const _result = ctx2.seen.get(schema);
   return _result.schema;
 }
-function extractDefs(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function extractDefs(ctx2, schema) {
+  const root = ctx2.seen.get(schema);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
-  for (const entry of ctx.seen.entries()) {
-    const id = ctx.metadataRegistry.get(entry[0])?.id;
+  for (const entry of ctx2.seen.entries()) {
+    const id = ctx2.metadataRegistry.get(entry[0])?.id;
     if (id) {
       const existing = idToSchema.get(id);
       if (existing && existing !== entry[0]) {
@@ -15630,14 +15630,14 @@ function extractDefs(ctx, schema) {
     }
   }
   const makeURI = (entry) => {
-    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
-    if (ctx.external) {
-      const externalId = ctx.external.registry.get(entry[0])?.id;
-      const uriGenerator = ctx.external.uri ?? ((id2) => id2);
+    const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
+    if (ctx2.external) {
+      const externalId = ctx2.external.registry.get(entry[0])?.id;
+      const uriGenerator = ctx2.external.uri ?? ((id2) => id2);
       if (externalId) {
         return { ref: uriGenerator(externalId) };
       }
-      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx2.counter++}`;
       entry[1].defId = id;
       return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
     }
@@ -15646,7 +15646,7 @@ function extractDefs(ctx, schema) {
     }
     const uriPrefix = `#`;
     const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
-    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+    const defId = entry[1].schema.id ?? `__schema${ctx2.counter++}`;
     return { defId, ref: defUriPrefix + defId };
   };
   const extractToDef = (entry) => {
@@ -15664,8 +15664,8 @@ function extractDefs(ctx, schema) {
     }
     schema2.$ref = ref;
   };
-  if (ctx.cycles === "throw") {
-    for (const entry of ctx.seen.entries()) {
+  if (ctx2.cycles === "throw") {
+    for (const entry of ctx2.seen.entries()) {
       const seen = entry[1];
       if (seen.cycle) {
         throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
@@ -15674,20 +15674,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
   }
-  for (const entry of ctx.seen.entries()) {
+  for (const entry of ctx2.seen.entries()) {
     const seen = entry[1];
     if (schema === entry[0]) {
       extractToDef(entry);
       continue;
     }
-    if (ctx.external) {
-      const ext = ctx.external.registry.get(entry[0])?.id;
+    if (ctx2.external) {
+      const ext = ctx2.external.registry.get(entry[0])?.id;
       if (schema !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
     }
-    const id = ctx.metadataRegistry.get(entry[0])?.id;
+    const id = ctx2.metadataRegistry.get(entry[0])?.id;
     if (id) {
       extractToDef(entry);
       continue;
@@ -15697,19 +15697,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       continue;
     }
     if (seen.count > 1) {
-      if (ctx.reused === "ref") {
+      if (ctx2.reused === "ref") {
         extractToDef(entry);
         continue;
       }
     }
   }
 }
-function finalize(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function finalize(ctx2, schema) {
+  const root = ctx2.seen.get(schema);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
-    const seen = ctx.seen.get(zodSchema);
+    const seen = ctx2.seen.get(zodSchema);
     if (seen.ref === null)
       return;
     const schema2 = seen.def ?? seen.schema;
@@ -15718,9 +15718,9 @@ function finalize(ctx, schema) {
     seen.ref = null;
     if (ref) {
       flattenRef(ref);
-      const refSeen = ctx.seen.get(ref);
+      const refSeen = ctx2.seen.get(ref);
       const refSchema = refSeen.schema;
-      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+      if (refSchema.$ref && (ctx2.target === "draft-07" || ctx2.target === "draft-04" || ctx2.target === "openapi-3.0")) {
         schema2.allOf = schema2.allOf ?? [];
         schema2.allOf.push(refSchema);
       } else {
@@ -15750,7 +15750,7 @@ function finalize(ctx, schema) {
     const parent = zodSchema._zod.parent;
     if (parent && parent !== ref) {
       flattenRef(parent);
-      const parentSeen = ctx.seen.get(parent);
+      const parentSeen = ctx2.seen.get(parent);
       if (parentSeen?.schema.$ref) {
         schema2.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
@@ -15764,37 +15764,37 @@ function finalize(ctx, schema) {
         }
       }
     }
-    ctx.override({
+    ctx2.override({
       zodSchema,
       jsonSchema: schema2,
       path: seen.path ?? []
     });
   };
-  for (const entry of [...ctx.seen.entries()].reverse()) {
+  for (const entry of [...ctx2.seen.entries()].reverse()) {
     flattenRef(entry[0]);
   }
   const result2 = {};
-  if (ctx.target === "draft-2020-12") {
+  if (ctx2.target === "draft-2020-12") {
     result2.$schema = "https://json-schema.org/draft/2020-12/schema";
-  } else if (ctx.target === "draft-07") {
+  } else if (ctx2.target === "draft-07") {
     result2.$schema = "http://json-schema.org/draft-07/schema#";
-  } else if (ctx.target === "draft-04") {
+  } else if (ctx2.target === "draft-04") {
     result2.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {
+  } else if (ctx2.target === "openapi-3.0") {
   } else {
   }
-  if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema)?.id;
+  if (ctx2.external?.uri) {
+    const id = ctx2.external.registry.get(schema)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
-    result2.$id = ctx.external.uri(id);
+    result2.$id = ctx2.external.uri(id);
   }
   Object.assign(result2, root.def ?? root.schema);
-  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+  const rootMetaId = ctx2.metadataRegistry.get(schema)?.id;
   if (rootMetaId !== void 0 && result2.id === rootMetaId)
     delete result2.id;
-  const defs = ctx.external?.defs ?? {};
-  for (const entry of ctx.seen.entries()) {
+  const defs = ctx2.external?.defs ?? {};
+  for (const entry of ctx2.seen.entries()) {
     const seen = entry[1];
     if (seen.def && seen.defId) {
       if (seen.def.id === seen.defId)
@@ -15802,10 +15802,10 @@ function finalize(ctx, schema) {
       defs[seen.defId] = seen.def;
     }
   }
-  if (ctx.external) {
+  if (ctx2.external) {
   } else {
     if (Object.keys(defs).length > 0) {
-      if (ctx.target === "draft-2020-12") {
+      if (ctx2.target === "draft-2020-12") {
         result2.$defs = defs;
       } else {
         result2.definitions = defs;
@@ -15818,8 +15818,8 @@ function finalize(ctx, schema) {
       value: {
         ...schema["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod(schema, "input", ctx2.processors),
+          output: createStandardJSONSchemaMethod(schema, "output", ctx2.processors)
         }
       },
       enumerable: false,
@@ -15831,53 +15831,53 @@ function finalize(ctx, schema) {
   }
 }
 function isTransforming(_schema, _ctx) {
-  const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
-  if (ctx.seen.has(_schema))
+  const ctx2 = _ctx ?? { seen: /* @__PURE__ */ new Set() };
+  if (ctx2.seen.has(_schema))
     return false;
-  ctx.seen.add(_schema);
+  ctx2.seen.add(_schema);
   const def = _schema._zod.def;
   if (def.type === "transform")
     return true;
   if (def.type === "array")
-    return isTransforming(def.element, ctx);
+    return isTransforming(def.element, ctx2);
   if (def.type === "set")
-    return isTransforming(def.valueType, ctx);
+    return isTransforming(def.valueType, ctx2);
   if (def.type === "lazy")
-    return isTransforming(def.getter(), ctx);
+    return isTransforming(def.getter(), ctx2);
   if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
-    return isTransforming(def.innerType, ctx);
+    return isTransforming(def.innerType, ctx2);
   }
   if (def.type === "intersection") {
-    return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    return isTransforming(def.left, ctx2) || isTransforming(def.right, ctx2);
   }
   if (def.type === "record" || def.type === "map") {
-    return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    return isTransforming(def.keyType, ctx2) || isTransforming(def.valueType, ctx2);
   }
   if (def.type === "pipe") {
     if (_schema._zod.traits.has("$ZodCodec"))
       return true;
-    return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    return isTransforming(def.in, ctx2) || isTransforming(def.out, ctx2);
   }
   if (def.type === "object") {
     for (const key2 in def.shape) {
-      if (isTransforming(def.shape[key2], ctx))
+      if (isTransforming(def.shape[key2], ctx2))
         return true;
     }
     return false;
   }
   if (def.type === "union") {
     for (const option of def.options) {
-      if (isTransforming(option, ctx))
+      if (isTransforming(option, ctx2))
         return true;
     }
     return false;
   }
   if (def.type === "tuple") {
     for (const item of def.items) {
-      if (isTransforming(item, ctx))
+      if (isTransforming(item, ctx2))
         return true;
     }
-    if (def.rest && isTransforming(def.rest, ctx))
+    if (def.rest && isTransforming(def.rest, ctx2))
       return true;
     return false;
   }
@@ -15888,17 +15888,17 @@ var init_to_json_schema = __esm({
   "../../node_modules/zod/v4/core/to-json-schema.js"() {
     init_registries();
     createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
-      const ctx = initializeContext({ ...params, processors });
-      process2(schema, ctx);
-      extractDefs(ctx, schema);
-      return finalize(ctx, schema);
+      const ctx2 = initializeContext({ ...params, processors });
+      process2(schema, ctx2);
+      extractDefs(ctx2, schema);
+      return finalize(ctx2, schema);
     };
     createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
       const { libraryOptions, target } = params ?? {};
-      const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-      process2(schema, ctx);
-      extractDefs(ctx, schema);
-      return finalize(ctx, schema);
+      const ctx2 = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
+      process2(schema, ctx2);
+      extractDefs(ctx2, schema);
+      return finalize(ctx2, schema);
     };
   }
 });
@@ -15907,11 +15907,11 @@ var init_to_json_schema = __esm({
 function toJSONSchema(input, params) {
   if ("_idmap" in input) {
     const registry2 = input;
-    const ctx2 = initializeContext({ ...params, processors: allProcessors });
+    const ctx3 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process2(schema, ctx2);
+      process2(schema, ctx3);
     }
     const schemas = {};
     const external = {
@@ -15919,24 +15919,24 @@ function toJSONSchema(input, params) {
       uri: params?.uri,
       defs
     };
-    ctx2.external = external;
+    ctx3.external = external;
     for (const entry of registry2._idmap.entries()) {
       const [key2, schema] = entry;
-      extractDefs(ctx2, schema);
-      schemas[key2] = finalize(ctx2, schema);
+      extractDefs(ctx3, schema);
+      schemas[key2] = finalize(ctx3, schema);
     }
     if (Object.keys(defs).length > 0) {
-      const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
+      const defsSegment = ctx3.target === "draft-2020-12" ? "$defs" : "definitions";
       schemas.__shared = {
         [defsSegment]: defs
       };
     }
     return { schemas };
   }
-  const ctx = initializeContext({ ...params, processors: allProcessors });
-  process2(input, ctx);
-  extractDefs(ctx, input);
-  return finalize(ctx, input);
+  const ctx2 = initializeContext({ ...params, processors: allProcessors });
+  process2(input, ctx2);
+  extractDefs(ctx2, input);
+  return finalize(ctx2, input);
 }
 var formatMap, stringProcessor, numberProcessor, booleanProcessor, bigintProcessor, symbolProcessor, nullProcessor, undefinedProcessor, voidProcessor, neverProcessor, anyProcessor, unknownProcessor, dateProcessor, enumProcessor, literalProcessor, nanProcessor, templateLiteralProcessor, fileProcessor, successProcessor, customProcessor, functionProcessor, transformProcessor, mapProcessor, setProcessor, arrayProcessor, objectProcessor, unionProcessor, intersectionProcessor, tupleProcessor, recordProcessor, nullableProcessor, nonoptionalProcessor, defaultProcessor, prefaultProcessor, catchProcessor, pipeProcessor, readonlyProcessor, promiseProcessor, optionalProcessor, lazyProcessor, allProcessors;
 var init_json_schema_processors = __esm({
@@ -15951,7 +15951,7 @@ var init_json_schema_processors = __esm({
       regex: ""
       // do not set
     };
-    stringProcessor = (schema, ctx, _json, _params) => {
+    stringProcessor = (schema, ctx2, _json, _params) => {
       const json3 = _json;
       json3.type = "string";
       const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
@@ -15976,14 +15976,14 @@ var init_json_schema_processors = __esm({
         else if (regexes.length > 1) {
           json3.allOf = [
             ...regexes.map((regex) => ({
-              ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
+              ...ctx2.target === "draft-07" || ctx2.target === "draft-04" || ctx2.target === "openapi-3.0" ? { type: "string" } : {},
               pattern: regex.source
             }))
           ];
         }
       }
     };
-    numberProcessor = (schema, ctx, _json, _params) => {
+    numberProcessor = (schema, ctx2, _json, _params) => {
       const json3 = _json;
       const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
       if (typeof format === "string" && format.includes("int"))
@@ -15992,7 +15992,7 @@ var init_json_schema_processors = __esm({
         json3.type = "number";
       const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
       const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
-      const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
+      const legacy = ctx2.target === "draft-04" || ctx2.target === "openapi-3.0";
       if (exMin) {
         if (legacy) {
           json3.minimum = exclusiveMinimum;
@@ -16019,18 +16019,18 @@ var init_json_schema_processors = __esm({
     booleanProcessor = (_schema, _ctx, json3, _params) => {
       json3.type = "boolean";
     };
-    bigintProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    bigintProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("BigInt cannot be represented in JSON Schema");
       }
     };
-    symbolProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    symbolProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Symbols cannot be represented in JSON Schema");
       }
     };
-    nullProcessor = (_schema, ctx, json3, _params) => {
-      if (ctx.target === "openapi-3.0") {
+    nullProcessor = (_schema, ctx2, json3, _params) => {
+      if (ctx2.target === "openapi-3.0") {
         json3.type = "string";
         json3.nullable = true;
         json3.enum = [null];
@@ -16038,13 +16038,13 @@ var init_json_schema_processors = __esm({
         json3.type = "null";
       }
     };
-    undefinedProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    undefinedProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Undefined cannot be represented in JSON Schema");
       }
     };
-    voidProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    voidProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Void cannot be represented in JSON Schema");
       }
     };
@@ -16055,8 +16055,8 @@ var init_json_schema_processors = __esm({
     };
     unknownProcessor = (_schema, _ctx, _json, _params) => {
     };
-    dateProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    dateProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Date cannot be represented in JSON Schema");
       }
     };
@@ -16069,17 +16069,17 @@ var init_json_schema_processors = __esm({
         json3.type = "string";
       json3.enum = values;
     };
-    literalProcessor = (schema, ctx, json3, _params) => {
+    literalProcessor = (schema, ctx2, json3, _params) => {
       const def = schema._zod.def;
       const vals = [];
       for (const val of def.values) {
         if (val === void 0) {
-          if (ctx.unrepresentable === "throw") {
+          if (ctx2.unrepresentable === "throw") {
             throw new Error("Literal `undefined` cannot be represented in JSON Schema");
           } else {
           }
         } else if (typeof val === "bigint") {
-          if (ctx.unrepresentable === "throw") {
+          if (ctx2.unrepresentable === "throw") {
             throw new Error("BigInt literals cannot be represented in JSON Schema");
           } else {
             vals.push(Number(val));
@@ -16092,7 +16092,7 @@ var init_json_schema_processors = __esm({
       } else if (vals.length === 1) {
         const val = vals[0];
         json3.type = val === null ? "null" : typeof val;
-        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+        if (ctx2.target === "draft-04" || ctx2.target === "openapi-3.0") {
           json3.enum = [val];
         } else {
           json3.const = val;
@@ -16109,8 +16109,8 @@ var init_json_schema_processors = __esm({
         json3.enum = vals;
       }
     };
-    nanProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    nanProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("NaN cannot be represented in JSON Schema");
       }
     };
@@ -16149,32 +16149,32 @@ var init_json_schema_processors = __esm({
     successProcessor = (_schema, _ctx, json3, _params) => {
       json3.type = "boolean";
     };
-    customProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    customProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Custom types cannot be represented in JSON Schema");
       }
     };
-    functionProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    functionProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Function types cannot be represented in JSON Schema");
       }
     };
-    transformProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    transformProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Transforms cannot be represented in JSON Schema");
       }
     };
-    mapProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    mapProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Map cannot be represented in JSON Schema");
       }
     };
-    setProcessor = (_schema, ctx, _json, _params) => {
-      if (ctx.unrepresentable === "throw") {
+    setProcessor = (_schema, ctx2, _json, _params) => {
+      if (ctx2.unrepresentable === "throw") {
         throw new Error("Set cannot be represented in JSON Schema");
       }
     };
-    arrayProcessor = (schema, ctx, _json, params) => {
+    arrayProcessor = (schema, ctx2, _json, params) => {
       const json3 = _json;
       const def = schema._zod.def;
       const { minimum, maximum } = schema._zod.bag;
@@ -16183,19 +16183,19 @@ var init_json_schema_processors = __esm({
       if (typeof maximum === "number")
         json3.maxItems = maximum;
       json3.type = "array";
-      json3.items = process2(def.element, ctx, {
+      json3.items = process2(def.element, ctx2, {
         ...params,
         path: [...params.path, "items"]
       });
     };
-    objectProcessor = (schema, ctx, _json, params) => {
+    objectProcessor = (schema, ctx2, _json, params) => {
       const json3 = _json;
       const def = schema._zod.def;
       json3.type = "object";
       json3.properties = {};
       const shape = def.shape;
       for (const key2 in shape) {
-        json3.properties[key2] = process2(shape[key2], ctx, {
+        json3.properties[key2] = process2(shape[key2], ctx2, {
           ...params,
           path: [...params.path, "properties", key2]
         });
@@ -16203,7 +16203,7 @@ var init_json_schema_processors = __esm({
       const allKeys = new Set(Object.keys(shape));
       const requiredKeys = new Set([...allKeys].filter((key2) => {
         const v = def.shape[key2]._zod;
-        if (ctx.io === "input") {
+        if (ctx2.io === "input") {
           return v.optin === void 0;
         } else {
           return v.optout === void 0;
@@ -16215,19 +16215,19 @@ var init_json_schema_processors = __esm({
       if (def.catchall?._zod.def.type === "never") {
         json3.additionalProperties = false;
       } else if (!def.catchall) {
-        if (ctx.io === "output")
+        if (ctx2.io === "output")
           json3.additionalProperties = false;
       } else if (def.catchall) {
-        json3.additionalProperties = process2(def.catchall, ctx, {
+        json3.additionalProperties = process2(def.catchall, ctx2, {
           ...params,
           path: [...params.path, "additionalProperties"]
         });
       }
     };
-    unionProcessor = (schema, ctx, json3, params) => {
+    unionProcessor = (schema, ctx2, json3, params) => {
       const def = schema._zod.def;
       const isExclusive = def.inclusive === false;
-      const options = def.options.map((x, i) => process2(x, ctx, {
+      const options = def.options.map((x, i) => process2(x, ctx2, {
         ...params,
         path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
       }));
@@ -16237,13 +16237,13 @@ var init_json_schema_processors = __esm({
         json3.anyOf = options;
       }
     };
-    intersectionProcessor = (schema, ctx, json3, params) => {
+    intersectionProcessor = (schema, ctx2, json3, params) => {
       const def = schema._zod.def;
-      const a = process2(def.left, ctx, {
+      const a = process2(def.left, ctx2, {
         ...params,
         path: [...params.path, "allOf", 0]
       });
-      const b = process2(def.right, ctx, {
+      const b = process2(def.right, ctx2, {
         ...params,
         path: [...params.path, "allOf", 1]
       });
@@ -16254,26 +16254,26 @@ var init_json_schema_processors = __esm({
       ];
       json3.allOf = allOf;
     };
-    tupleProcessor = (schema, ctx, _json, params) => {
+    tupleProcessor = (schema, ctx2, _json, params) => {
       const json3 = _json;
       const def = schema._zod.def;
       json3.type = "array";
-      const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
-      const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-      const prefixItems = def.items.map((x, i) => process2(x, ctx, {
+      const prefixPath = ctx2.target === "draft-2020-12" ? "prefixItems" : "items";
+      const restPath = ctx2.target === "draft-2020-12" ? "items" : ctx2.target === "openapi-3.0" ? "items" : "additionalItems";
+      const prefixItems = def.items.map((x, i) => process2(x, ctx2, {
         ...params,
         path: [...params.path, prefixPath, i]
       }));
-      const rest = def.rest ? process2(def.rest, ctx, {
+      const rest = def.rest ? process2(def.rest, ctx2, {
         ...params,
-        path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
+        path: [...params.path, restPath, ...ctx2.target === "openapi-3.0" ? [def.items.length] : []]
       }) : null;
-      if (ctx.target === "draft-2020-12") {
+      if (ctx2.target === "draft-2020-12") {
         json3.prefixItems = prefixItems;
         if (rest) {
           json3.items = rest;
         }
-      } else if (ctx.target === "openapi-3.0") {
+      } else if (ctx2.target === "openapi-3.0") {
         json3.items = {
           anyOf: prefixItems
         };
@@ -16296,7 +16296,7 @@ var init_json_schema_processors = __esm({
       if (typeof maximum === "number")
         json3.maxItems = maximum;
     };
-    recordProcessor = (schema, ctx, _json, params) => {
+    recordProcessor = (schema, ctx2, _json, params) => {
       const json3 = _json;
       const def = schema._zod.def;
       json3.type = "object";
@@ -16304,7 +16304,7 @@ var init_json_schema_processors = __esm({
       const keyBag = keyType._zod.bag;
       const patterns = keyBag?.patterns;
       if (def.mode === "loose" && patterns && patterns.size > 0) {
-        const valueSchema = process2(def.valueType, ctx, {
+        const valueSchema = process2(def.valueType, ctx2, {
           ...params,
           path: [...params.path, "patternProperties", "*"]
         });
@@ -16313,13 +16313,13 @@ var init_json_schema_processors = __esm({
           json3.patternProperties[pattern.source] = valueSchema;
         }
       } else {
-        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-          json3.propertyNames = process2(def.keyType, ctx, {
+        if (ctx2.target === "draft-07" || ctx2.target === "draft-2020-12") {
+          json3.propertyNames = process2(def.keyType, ctx2, {
             ...params,
             path: [...params.path, "propertyNames"]
           });
         }
-        json3.additionalProperties = process2(def.valueType, ctx, {
+        json3.additionalProperties = process2(def.valueType, ctx2, {
           ...params,
           path: [...params.path, "additionalProperties"]
         });
@@ -16332,42 +16332,42 @@ var init_json_schema_processors = __esm({
         }
       }
     };
-    nullableProcessor = (schema, ctx, json3, params) => {
+    nullableProcessor = (schema, ctx2, json3, params) => {
       const def = schema._zod.def;
-      const inner = process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      if (ctx.target === "openapi-3.0") {
+      const inner = process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
+      if (ctx2.target === "openapi-3.0") {
         seen.ref = def.innerType;
         json3.nullable = true;
       } else {
         json3.anyOf = [inner, { type: "null" }];
       }
     };
-    nonoptionalProcessor = (schema, ctx, _json, params) => {
+    nonoptionalProcessor = (schema, ctx2, _json, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = def.innerType;
     };
-    defaultProcessor = (schema, ctx, json3, params) => {
+    defaultProcessor = (schema, ctx2, json3, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = def.innerType;
       json3.default = JSON.parse(JSON.stringify(def.defaultValue));
     };
-    prefaultProcessor = (schema, ctx, json3, params) => {
+    prefaultProcessor = (schema, ctx2, json3, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = def.innerType;
-      if (ctx.io === "input")
+      if (ctx2.io === "input")
         json3._prefault = JSON.parse(JSON.stringify(def.defaultValue));
     };
-    catchProcessor = (schema, ctx, json3, params) => {
+    catchProcessor = (schema, ctx2, json3, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = def.innerType;
       let catchValue;
       try {
@@ -16377,37 +16377,37 @@ var init_json_schema_processors = __esm({
       }
       json3.default = catchValue;
     };
-    pipeProcessor = (schema, ctx, _json, params) => {
+    pipeProcessor = (schema, ctx2, _json, params) => {
       const def = schema._zod.def;
       const inIsTransform = def.in._zod.traits.has("$ZodTransform");
-      const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-      process2(innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      const innerType = ctx2.io === "input" ? inIsTransform ? def.out : def.in : def.out;
+      process2(innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = innerType;
     };
-    readonlyProcessor = (schema, ctx, json3, params) => {
+    readonlyProcessor = (schema, ctx2, json3, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = def.innerType;
       json3.readOnly = true;
     };
-    promiseProcessor = (schema, ctx, _json, params) => {
+    promiseProcessor = (schema, ctx2, _json, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = def.innerType;
     };
-    optionalProcessor = (schema, ctx, _json, params) => {
+    optionalProcessor = (schema, ctx2, _json, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(def.innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = def.innerType;
     };
-    lazyProcessor = (schema, ctx, _json, params) => {
+    lazyProcessor = (schema, ctx2, _json, params) => {
       const innerType = schema._zod.innerType;
-      process2(innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      process2(innerType, ctx2, params);
+      const seen = ctx2.seen.get(schema);
       seen.ref = innerType;
     };
     allProcessors = {
@@ -17823,7 +17823,7 @@ var init_schemas2 = __esm({
     _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
       $ZodString.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => stringProcessor(inst, ctx2, json3, params);
       const bag = inst._zod.bag;
       inst.format = bag.format ?? null;
       inst.minLength = bag.minimum ?? null;
@@ -17998,7 +17998,7 @@ var init_schemas2 = __esm({
     ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
       $ZodNumber.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => numberProcessor(inst, ctx2, json3, params);
       _installLazyMethods(inst, "ZodNumber", {
         gt(value, params) {
           return this.check(_gt(value, params));
@@ -18060,12 +18060,12 @@ var init_schemas2 = __esm({
     ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
       $ZodBoolean.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => booleanProcessor(inst, ctx2, json3, params);
     });
     ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
       $ZodBigInt.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => bigintProcessor(inst, ctx2, json3, params);
       inst.gte = (value, params) => inst.check(_gte(value, params));
       inst.min = (value, params) => inst.check(_gte(value, params));
       inst.gt = (value, params) => inst.check(_gt(value, params));
@@ -18091,42 +18091,42 @@ var init_schemas2 = __esm({
     ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
       $ZodSymbol.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => symbolProcessor(inst, ctx2, json3, params);
     });
     ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
       $ZodUndefined.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => undefinedProcessor(inst, ctx2, json3, params);
     });
     ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
       $ZodNull.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => nullProcessor(inst, ctx2, json3, params);
     });
     ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
       $ZodAny.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => anyProcessor(inst, ctx2, json3, params);
     });
     ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
       $ZodUnknown.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => unknownProcessor(inst, ctx2, json3, params);
     });
     ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
       $ZodNever.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => neverProcessor(inst, ctx2, json3, params);
     });
     ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
       $ZodVoid.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => voidProcessor(inst, ctx2, json3, params);
     });
     ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
       $ZodDate.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => dateProcessor(inst, ctx2, json3, params);
       inst.min = (value, params) => inst.check(_gte(value, params));
       inst.max = (value, params) => inst.check(_lte(value, params));
       const c = inst._zod.bag;
@@ -18136,7 +18136,7 @@ var init_schemas2 = __esm({
     ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
       $ZodArray.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => arrayProcessor(inst, ctx2, json3, params);
       inst.element = def.element;
       _installLazyMethods(inst, "ZodArray", {
         min(n, params) {
@@ -18159,7 +18159,7 @@ var init_schemas2 = __esm({
     ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
       $ZodObjectJIT.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => objectProcessor(inst, ctx2, json3, params);
       util_exports.defineLazy(inst, "shape", () => {
         return def.shape;
       });
@@ -18208,13 +18208,13 @@ var init_schemas2 = __esm({
     ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
       $ZodUnion.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => unionProcessor(inst, ctx2, json3, params);
       inst.options = def.options;
     });
     ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
       ZodUnion.init(inst, def);
       $ZodXor.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => unionProcessor(inst, ctx2, json3, params);
       inst.options = def.options;
     });
     ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
@@ -18224,12 +18224,12 @@ var init_schemas2 = __esm({
     ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
       $ZodIntersection.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => intersectionProcessor(inst, ctx2, json3, params);
     });
     ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
       $ZodTuple.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => tupleProcessor(inst, ctx2, json3, params);
       inst.rest = (rest) => inst.clone({
         ...inst._zod.def,
         rest
@@ -18238,14 +18238,14 @@ var init_schemas2 = __esm({
     ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
       $ZodRecord.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => recordProcessor(inst, ctx2, json3, params);
       inst.keyType = def.keyType;
       inst.valueType = def.valueType;
     });
     ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
       $ZodMap.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => mapProcessor(inst, ctx2, json3, params);
       inst.keyType = def.keyType;
       inst.valueType = def.valueType;
       inst.min = (...args) => inst.check(_minSize(...args));
@@ -18256,7 +18256,7 @@ var init_schemas2 = __esm({
     ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
       $ZodSet.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => setProcessor(inst, ctx2, json3, params);
       inst.min = (...args) => inst.check(_minSize(...args));
       inst.nonempty = (params) => inst.check(_minSize(1, params));
       inst.max = (...args) => inst.check(_maxSize(...args));
@@ -18265,7 +18265,7 @@ var init_schemas2 = __esm({
     ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
       $ZodEnum.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => enumProcessor(inst, ctx2, json3, params);
       inst.enum = def.entries;
       inst.options = Object.values(def.entries);
       const keys = new Set(Object.keys(def.entries));
@@ -18303,7 +18303,7 @@ var init_schemas2 = __esm({
     ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
       $ZodLiteral.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => literalProcessor(inst, ctx2, json3, params);
       inst.values = new Set(def.values);
       Object.defineProperty(inst, "value", {
         get() {
@@ -18317,7 +18317,7 @@ var init_schemas2 = __esm({
     ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
       $ZodFile.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => fileProcessor(inst, ctx2, json3, params);
       inst.min = (size, params) => inst.check(_minSize(size, params));
       inst.max = (size, params) => inst.check(_maxSize(size, params));
       inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
@@ -18325,7 +18325,7 @@ var init_schemas2 = __esm({
     ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
       $ZodTransform.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => transformProcessor(inst, ctx2, json3, params);
       inst._zod.parse = (payload, _ctx) => {
         if (_ctx.direction === "backward") {
           throw new $ZodEncodeError(inst.constructor.name);
@@ -18359,62 +18359,62 @@ var init_schemas2 = __esm({
     ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
       $ZodOptional.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => optionalProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
       $ZodExactOptional.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => optionalProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
       $ZodNullable.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => nullableProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
       $ZodDefault.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => defaultProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
       inst.removeDefault = inst.unwrap;
     });
     ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
       $ZodPrefault.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => prefaultProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
       $ZodNonOptional.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => nonoptionalProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
       $ZodSuccess.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => successProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
       $ZodCatch.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => catchProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
       inst.removeCatch = inst.unwrap;
     });
     ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
       $ZodNaN.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => nanProcessor(inst, ctx2, json3, params);
     });
     ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
       $ZodPipe.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => pipeProcessor(inst, ctx2, json3, params);
       inst.in = def.in;
       inst.out = def.out;
     });
@@ -18429,35 +18429,35 @@ var init_schemas2 = __esm({
     ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
       $ZodReadonly.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => readonlyProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
       $ZodTemplateLiteral.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => templateLiteralProcessor(inst, ctx2, json3, params);
     });
     ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
       $ZodLazy.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => lazyProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.getter();
     });
     ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
       $ZodPromise.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => promiseProcessor(inst, ctx2, json3, params);
       inst.unwrap = () => inst._zod.def.innerType;
     });
     ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
       $ZodFunction.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => functionProcessor(inst, ctx2, json3, params);
     });
     ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
       $ZodCustom.init(inst, def);
       ZodType.init(inst, def);
-      inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
+      inst._zod.processJSONSchema = (ctx2, json3, params) => customProcessor(inst, ctx2, json3, params);
     });
     describe2 = describe;
     meta2 = meta;
@@ -18514,25 +18514,25 @@ function detectVersion(schema, defaultTarget) {
   }
   return defaultTarget ?? "draft-2020-12";
 }
-function resolveRef(ref, ctx) {
+function resolveRef(ref, ctx2) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
   const path5 = ref.slice(1).split("/").filter(Boolean);
   if (path5.length === 0) {
-    return ctx.rootSchema;
+    return ctx2.rootSchema;
   }
-  const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
+  const defsKey = ctx2.version === "draft-2020-12" ? "$defs" : "definitions";
   if (path5[0] === defsKey) {
     const key2 = path5[1];
-    if (!key2 || !ctx.defs[key2]) {
+    if (!key2 || !ctx2.defs[key2]) {
       throw new Error(`Reference not found: ${ref}`);
     }
-    return ctx.defs[key2];
+    return ctx2.defs[key2];
   }
   throw new Error(`Reference not found: ${ref}`);
 }
-function convertBaseSchema(schema, ctx) {
+function convertBaseSchema(schema, ctx2) {
   if (schema.not !== void 0) {
     if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
       return z.never();
@@ -18553,27 +18553,27 @@ function convertBaseSchema(schema, ctx) {
   }
   if (schema.$ref) {
     const refPath = schema.$ref;
-    if (ctx.refs.has(refPath)) {
-      return ctx.refs.get(refPath);
+    if (ctx2.refs.has(refPath)) {
+      return ctx2.refs.get(refPath);
     }
-    if (ctx.processing.has(refPath)) {
+    if (ctx2.processing.has(refPath)) {
       return z.lazy(() => {
-        if (!ctx.refs.has(refPath)) {
+        if (!ctx2.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
-        return ctx.refs.get(refPath);
+        return ctx2.refs.get(refPath);
       });
     }
-    ctx.processing.add(refPath);
-    const resolved = resolveRef(refPath, ctx);
-    const zodSchema2 = convertSchema(resolved, ctx);
-    ctx.refs.set(refPath, zodSchema2);
-    ctx.processing.delete(refPath);
+    ctx2.processing.add(refPath);
+    const resolved = resolveRef(refPath, ctx2);
+    const zodSchema2 = convertSchema(resolved, ctx2);
+    ctx2.refs.set(refPath, zodSchema2);
+    ctx2.processing.delete(refPath);
     return zodSchema2;
   }
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
-    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+    if (ctx2.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
       return z.null();
     }
     if (enumValues.length === 0) {
@@ -18598,7 +18598,7 @@ function convertBaseSchema(schema, ctx) {
   if (Array.isArray(type)) {
     const typeSchemas = type.map((t) => {
       const typeSchema = { ...schema, type: t };
-      return convertBaseSchema(typeSchema, ctx);
+      return convertBaseSchema(typeSchema, ctx2);
     });
     if (typeSchemas.length === 0) {
       return z.never();
@@ -18715,12 +18715,12 @@ function convertBaseSchema(schema, ctx) {
       const properties = schema.properties || {};
       const requiredSet = new Set(schema.required || []);
       for (const [key2, propSchema] of Object.entries(properties)) {
-        const propZodSchema = convertSchema(propSchema, ctx);
+        const propZodSchema = convertSchema(propSchema, ctx2);
         shape[key2] = requiredSet.has(key2) ? propZodSchema : propZodSchema.optional();
       }
       if (schema.propertyNames) {
-        const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
+        const keySchema = convertSchema(schema.propertyNames, ctx2);
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx2) : z.any();
         if (Object.keys(shape).length === 0) {
           zodSchema = z.record(keySchema, valueSchema);
           break;
@@ -18735,7 +18735,7 @@ function convertBaseSchema(schema, ctx) {
         const patternKeys = Object.keys(patternProps);
         const looseRecords = [];
         for (const pattern of patternKeys) {
-          const patternValue = convertSchema(patternProps[pattern], ctx);
+          const patternValue = convertSchema(patternProps[pattern], ctx2);
           const keySchema = z.string().regex(new RegExp(pattern));
           looseRecords.push(z.looseRecord(keySchema, patternValue));
         }
@@ -18761,7 +18761,7 @@ function convertBaseSchema(schema, ctx) {
       if (schema.additionalProperties === false) {
         zodSchema = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx2));
       } else {
         zodSchema = objectSchema.passthrough();
       }
@@ -18771,8 +18771,8 @@ function convertBaseSchema(schema, ctx) {
       const prefixItems = schema.prefixItems;
       const items = schema.items;
       if (prefixItems && Array.isArray(prefixItems)) {
-        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
-        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
+        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx2));
+        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx2) : void 0;
         if (rest) {
           zodSchema = z.tuple(tupleItems).rest(rest);
         } else {
@@ -18785,8 +18785,8 @@ function convertBaseSchema(schema, ctx) {
           zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
-        const tupleItems = items.map((item) => convertSchema(item, ctx));
-        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
+        const tupleItems = items.map((item) => convertSchema(item, ctx2));
+        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx2) : void 0;
         if (rest) {
           zodSchema = z.tuple(tupleItems).rest(rest);
         } else {
@@ -18799,7 +18799,7 @@ function convertBaseSchema(schema, ctx) {
           zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
-        const element = convertSchema(items, ctx);
+        const element = convertSchema(items, ctx2);
         let arraySchema = z.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
@@ -18818,19 +18818,19 @@ function convertBaseSchema(schema, ctx) {
   }
   return zodSchema;
 }
-function convertSchema(schema, ctx) {
+function convertSchema(schema, ctx2) {
   if (typeof schema === "boolean") {
     return schema ? z.any() : z.never();
   }
-  let baseSchema = convertBaseSchema(schema, ctx);
+  let baseSchema = convertBaseSchema(schema, ctx2);
   const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
   if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+    const options = schema.anyOf.map((s) => convertSchema(s, ctx2));
     const anyOfUnion = z.union(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+    const options = schema.oneOf.map((s) => convertSchema(s, ctx2));
     const oneOfUnion = z.xor(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
@@ -18838,15 +18838,15 @@ function convertSchema(schema, ctx) {
     if (schema.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result2 = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      let result2 = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx2);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result2 = z.intersection(result2, convertSchema(schema.allOf[i], ctx));
+        result2 = z.intersection(result2, convertSchema(schema.allOf[i], ctx2));
       }
       baseSchema = result2;
     }
   }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+  if (schema.nullable === true && ctx2.version === "openapi-3.0") {
     baseSchema = z.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
@@ -18874,7 +18874,7 @@ function convertSchema(schema, ctx) {
     }
   }
   if (Object.keys(extraMeta).length > 0) {
-    ctx.registry.add(baseSchema, extraMeta);
+    ctx2.registry.add(baseSchema, extraMeta);
   }
   if (schema.description) {
     baseSchema = baseSchema.describe(schema.description);
@@ -18893,7 +18893,7 @@ function fromJSONSchema(schema, params) {
   }
   const version2 = detectVersion(normalized, params?.defaultTarget);
   const defs = normalized.$defs || normalized.definitions || {};
-  const ctx = {
+  const ctx2 = {
     version: version2,
     defs,
     refs: /* @__PURE__ */ new Map(),
@@ -18901,7 +18901,7 @@ function fromJSONSchema(schema, params) {
     rootSchema: normalized,
     registry: params?.registry ?? globalRegistry
   };
-  return convertSchema(normalized, ctx);
+  return convertSchema(normalized, ctx2);
 }
 var z, RECOGNIZED_KEYS;
 var init_from_json_schema = __esm({
@@ -21840,16 +21840,16 @@ var init_interaction = __esm({
 });
 
 // ../../packages/os-control/dist/registry.js
-function withConsent(tool8, consent) {
-  if (!tool8.destructive)
-    return tool8;
-  const inner = tool8.handler;
+function withConsent(tool9, consent) {
+  if (!tool9.destructive)
+    return tool9;
+  const inner = tool9.handler;
   return {
-    ...tool8,
+    ...tool9,
     handler: async (args) => {
-      const verdict = await consent({ name: tool8.name, destructive: tool8.destructive }, args);
+      const verdict = await consent({ name: tool9.name, destructive: tool9.destructive }, args);
       if (verdict !== true) {
-        return text3(typeof verdict === "string" ? verdict : `Refused: "${tool8.name}" is a state-changing action and is not permitted by the current policy.`, true);
+        return text3(typeof verdict === "string" ? verdict : `Refused: "${tool9.name}" is a state-changing action and is not permitted by the current policy.`, true);
       }
       return inner(args);
     }
@@ -21911,14 +21911,144 @@ var init_os_control_tools = __esm({
   }
 });
 
-// ../../packages/agent-core/dist/report-tools.js
+// ../../packages/agent-core/dist/screen-control-tools.js
 import { tool as tool6 } from "@anthropic-ai/claude-agent-sdk";
+function specParametersJsonSchema(spec) {
+  const properties = {};
+  const required2 = [];
+  for (const [key2, pp] of Object.entries(spec.params)) {
+    properties[key2] = { type: pp.type, description: pp.description, ...pp.enum ? { enum: [...pp.enum] } : {} };
+    if (pp.required)
+      required2.push(key2);
+  }
+  return required2.length ? { type: "object", properties, required: required2 } : { type: "object", properties };
+}
+function zodShapeFromParams(params) {
+  const shape = {};
+  for (const [key2, pp] of Object.entries(params)) {
+    let zt = pp.enum ? external_exports.enum([...pp.enum]) : pp.type === "number" ? external_exports.number() : pp.type === "boolean" ? external_exports.boolean() : external_exports.string();
+    zt = zt.describe(pp.description);
+    shape[key2] = pp.required ? zt : zt.optional();
+  }
+  return shape;
+}
+function buildScreenControlSdkTools(p) {
+  return SCREEN_CONTROL_SPECS.map((spec) => tool6(spec.name, spec.description, zodShapeFromParams(spec.params), async (args) => {
+    const text4 = await p.exec(spec.name, args ?? {});
+    return { content: [{ type: "text", text: text4 || "Done." }] };
+  }));
+}
+var ANNOTATE_STYLES, SCREEN_CONTROL_SPECS;
+var init_screen_control_tools = __esm({
+  "../../packages/agent-core/dist/screen-control-tools.js"() {
+    "use strict";
+    init_zod();
+    ANNOTATE_STYLES = ["auto", "circle", "box", "bracket", "underline", "zigzag", "strike", "highlight", "arrow", "check", "cross", "star", "scribble", "cloud", "caret"];
+    SCREEN_CONTROL_SPECS = [
+      {
+        name: "look_at_screen",
+        description: "Look at the developer's current screen. This gives you the screen IMAGE plus a detailed description from a strong vision model: the focused app/window and its contents, the main page/content, any dialog/menu/notification, any selection or active field, where the MOUSE pointer is, and what it's hovering over. Call it whenever you need to know what's on screen \u2014 'what's on my screen / what do you see / read this / where's my cursor', or to check the result of an action.",
+        params: {}
+      },
+      {
+        name: "figure_out_next",
+        description: "Your GET-UNSTUCK button. Call this whenever you're confused, an action didn't do what you expected, or you've hit something you don't know how to handle (a dialog, a 'See options' / size-or-color picker, a login wall, a page that won't load, an unexpected screen). A stronger model looks at the screen and EVERYTHING you've been doing, then hands you back the goal plus the exact next steps to get past it. Then carry those steps out (with perform_step). Use this BEFORE flailing with random clicks or stopping to ask the developer.",
+        params: {}
+      },
+      {
+        name: "verify",
+        description: "Check whether something is ACTUALLY true on the screen right now \u2014 your CHECKPOINT after an action or plan step. Describe what you expect (e.g. 'a new browser tab is open', 'Google Chrome is the active app', 'the Amazon search results for jeans are showing', 'the item was added to the cart'). A strong vision model looks and answers YES or NO with what it really sees. ALWAYS use this to confirm a step worked before moving on \u2014 never assume or claim a result you haven't verified.",
+        params: { expectation: { type: "string", required: true, description: "What you expect to be true on the screen, in plain words." } }
+      },
+      {
+        name: "perform_step",
+        description: "Do ONE step described in plain words; a stronger model works out the exact sequence of clicks/typing and RUNS it in order for you (so nothing races), then tells you what the screen shows afterward. Use this for ANY step that needs more than one action \u2014 e.g. 'search Amazon for jeans', 'open a new tab and go to gmail.com', 'add the first result to the cart', 'log in with this email and password'. PREFER this over firing click/press_key yourself.",
+        params: { instruction: { type: "string", required: true, description: "The single step to perform, in plain words." } }
+      },
+      {
+        name: "type_into",
+        description: "Type text INTO a field in one reliable action \u2014 it clicks the field to focus it, then types, then optionally presses Enter. Use this for any 'type X in the search box / address bar / field' instead of doing click then typing yourself (which races and the text goes nowhere).",
+        params: {
+          field: { type: "string", required: true, description: 'The field to type into, described (e.g. "the Amazon search box", "the address bar").' },
+          text: { type: "string", required: true, description: "The text to type." },
+          submit: { type: "boolean", description: "Press Enter after typing, to search/go. Default false." }
+        }
+      },
+      {
+        name: "click",
+        description: "Click a UI element by DESCRIBING it in plain words \u2014 do NOT pass coordinates. The system finds its exact location (the macOS accessibility tree first, then a vision model) and clicks it precisely. Be specific and include any visible label/text.",
+        params: {
+          target: { type: "string", required: true, description: 'What to click, described precisely \u2014 e.g. "the Google Chrome icon in the Dock", "the blue Sign in button", "the address bar", "the Submit button at the bottom of the form".' },
+          button: { type: "string", enum: ["left", "right"], description: "Mouse button (default left)." },
+          double: { type: "boolean", description: "Double-click when true." }
+        }
+      },
+      {
+        name: "launch_app",
+        description: 'Open / launch / switch to an application by name (e.g. "Google Chrome", "Safari", "Terminal", "System Settings"). This is the RELIABLE way to open an app \u2014 use it instead of hunting for a Dock icon to click.',
+        params: { name: { type: "string", required: true, description: 'The application name, e.g. "Google Chrome".' } }
+      },
+      {
+        name: "annotate",
+        description: "POINT something out on the developer's screen with a hand-drawn red marker doodle (animated as if drawn live). Use it for 'where is X', 'show me X', 'point at X', 'underline X', 'cross out X', 'check off X', 'highlight X'. It only highlights \u2014 it does NOT click. Pick the style that fits what they asked; omit it for an auto choice based on the item's shape.",
+        params: {
+          target: { type: "string", required: true, description: "What to mark, described precisely." },
+          style: { type: "string", enum: ANNOTATE_STYLES, description: "Which kind of doodle: circle/box/bracket to enclose; underline/zigzag/highlight to emphasise text; arrow to point; check/cross/star to mark; strike to cross through. Default auto." },
+          label: { type: "string", description: 'Optional short text to write next to it, e.g. "Here!".' }
+        }
+      },
+      {
+        name: "remove_annotations",
+        description: "Clear ALL the marker doodles you've drawn on the screen. Call this when you move on to a different topic or the developer asks you to remove them. Annotations otherwise stay on screen.",
+        params: {}
+      },
+      {
+        name: "press_key",
+        description: 'Press a key or combo, e.g. "enter", "esc", "cmd+a", "cmd+c", "tab".',
+        params: { keys: { type: "string", required: true, description: 'Key or combo like "enter" or "cmd+c".' } }
+      },
+      {
+        name: "scroll_screen",
+        description: "Scroll the screen (at the centre). Positive dy scrolls down, negative up.",
+        params: {
+          dy: { type: "number", required: true, description: "Vertical amount; positive scrolls down." },
+          dx: { type: "number", description: "Horizontal amount; positive scrolls right." }
+        }
+      },
+      {
+        name: "draw_shape",
+        description: "DRAW a basic shape on the screen with the mouse (the drawing app's brush/pen/shape tool must already be selected): a line, arrow, rectangle, ellipse, or underline. For rectangle/ellipse/underline give the target to draw on/around; for line/arrow give a start (target) and an end (to). Drawn at a natural human pace.",
+        params: {
+          shape: { type: "string", required: true, enum: ["line", "arrow", "rectangle", "ellipse", "underline"], description: "The shape to draw." },
+          target: { type: "string", required: true, description: "What to draw on/around (rectangle/ellipse/underline), or the START point (line/arrow), in plain words." },
+          to: { type: "string", description: "The END point for a line/arrow, in plain words." }
+        }
+      },
+      {
+        name: "draw_sketch",
+        description: "Freehand-DRAW a simple line sketch of something with the mouse \u2014 e.g. 'a stick figure', 'a house', 'a smiley face', 'a star'. The brush/pen must already be selected in the drawing app. It will be a simple, child-like line drawing made at a natural pace. Optionally say WHERE to draw it.",
+        params: {
+          subject: { type: "string", required: true, description: 'What to draw, e.g. "a stick figure".' },
+          where: { type: "string", description: 'Where to draw it, described (e.g. "the centre of the canvas"). Omit for the centre of the screen.' }
+        }
+      },
+      {
+        name: "release_control",
+        description: "Stop controlling the computer when you've finished the on-screen task. Removes the coral cursor and the 'working with your computer' bar. Call this as soon as you're done acting on the screen.",
+        params: {}
+      }
+    ];
+  }
+});
+
+// ../../packages/agent-core/dist/report-tools.js
+import { tool as tool7 } from "@anthropic-ai/claude-agent-sdk";
 function slug(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "mission";
 }
 function buildReportTools(deps) {
   return [
-    tool6("emit_report", `Deliver the structured findings of a mission playbook run as a Report card in the chat (this is the deliverable \u2014 do NOT just write findings as prose). Call it ONCE near the end with all findings grouped into the playbook's sections. To UPDATE after fixing/verifying a finding (Fix / Re-run), call again with the SAME id and finding ids, changing each finding's status \u2014 it re-renders in place. For "legal" bucket reports, never claim the site is compliant/certified; describe risks and route the verdict to a human.`, {
+    tool7("emit_report", `Deliver the structured findings of a mission playbook run as a Report card in the chat (this is the deliverable \u2014 do NOT just write findings as prose). Call it ONCE near the end with all findings grouped into the playbook's sections. To UPDATE after fixing/verifying a finding (Fix / Re-run), call again with the SAME id and finding ids, changing each finding's status \u2014 it re-renders in place. For "legal" bucket reports, never claim the site is compliant/certified; describe risks and route the verdict to a human.`, {
       id: external_exports.string().optional().describe("Stable report id to UPDATE an existing report; omit on the first call to create one."),
       playbookId: external_exports.string().describe("The playbook id this report belongs to."),
       title: external_exports.string().describe("Report title (usually the playbook name)."),
@@ -21971,10 +22101,10 @@ var init_report_tools = __esm({
 });
 
 // ../../packages/agent-core/dist/interactive-ui-tools.js
-import { tool as tool7 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool8 } from "@anthropic-ai/claude-agent-sdk";
 function buildInteractiveUiTools(deps) {
   return [
-    tool7("ask_form", "Show the user a FORM in the chat and wait for them to fill it in. Use this to collect structured input mid-task (settings, scope, details) instead of asking in prose. Returns the submitted values (or that the user cancelled). Prefer this over free-text questions when the answer is structured.", {
+    tool8("ask_form", "Show the user a FORM in the chat and wait for them to fill it in. Use this to collect structured input mid-task (settings, scope, details) instead of asking in prose. Returns the submitted values (or that the user cancelled). Prefer this over free-text questions when the answer is structured.", {
       title: external_exports.string().describe("Form heading (plain language)."),
       description: external_exports.string().optional().describe("Short explanation shown above the fields."),
       submitLabel: external_exports.string().optional().describe('Submit button label (default "Submit").'),
@@ -21988,7 +22118,7 @@ function buildInteractiveUiTools(deps) {
       return { content: [{ type: "text", text: `The user submitted the form:
 ${JSON.stringify(res.values ?? {}, null, 2)}` }] };
     }),
-    tool7("present_choices", "Show the user a CHOICE picker in the chat and wait for them to choose. Use this to let the user make a decision or pick from options (single or multi-select). Returns the selected value(s) (or cancellation).", {
+    tool8("present_choices", "Show the user a CHOICE picker in the chat and wait for them to choose. Use this to let the user make a decision or pick from options (single or multi-select). Returns the selected value(s) (or cancellation).", {
       title: external_exports.string().describe("The question / heading."),
       description: external_exports.string().optional(),
       options: external_exports.array(choiceOption).min(1),
@@ -22001,7 +22131,7 @@ ${JSON.stringify(res.values ?? {}, null, 2)}` }] };
         return { content: [{ type: "text", text: "The user cancelled the choice (nothing selected)." }] };
       return { content: [{ type: "text", text: `The user selected: ${JSON.stringify(res.selected ?? [])}` }] };
     }),
-    tool7("update_progress", `Update the live Mission card so the user sees ongoing status. Call this whenever you move between stages (and once at the start). Pass the FULL ordered stage list each time with each stage's current status, plus a short "what I'm doing now" note. This is a one-way feedback channel \u2014 it returns immediately, does not wait for the user.`, {
+    tool8("update_progress", `Update the live Mission card so the user sees ongoing status. Call this whenever you move between stages (and once at the start). Pass the FULL ordered stage list each time with each stage's current status, plus a short "what I'm doing now" note. This is a one-way feedback channel \u2014 it returns immediately, does not wait for the user.`, {
       stages: external_exports.array(external_exports.object({
         label: external_exports.string(),
         status: external_exports.enum(["pending", "active", "done"])
@@ -22678,21 +22808,25 @@ var init_session_store = __esm({
        *  Returns the new session id, or null on failure. NOTE: forked sessions start
        *  WITHOUT file-history/undo snapshots (SDK behavior). */
       async forkSession(sessionId, opts) {
-        for (let attempt = 0; ; attempt++) {
-          try {
-            const upToMessageId = opts?.upToMessageId ?? await this.lastResumableMessageId(sessionId, opts?.projectDir);
-            const result2 = await forkSession(sessionId, {
-              ...opts?.projectDir ? { dir: opts.projectDir } : {},
-              ...upToMessageId ? { upToMessageId } : {},
-              ...opts?.title ? { title: opts.title } : {}
-            });
-            return result2.sessionId;
-          } catch {
-            if (attempt >= FORK_RETRY_ATTEMPTS)
-              return null;
-            await delay(FORK_RETRY_DELAY_MS);
+        const dirs = opts?.projectDir ? [opts.projectDir, void 0] : [void 0];
+        for (const dir2 of dirs) {
+          for (let attempt = 0; ; attempt++) {
+            try {
+              const upToMessageId = opts?.upToMessageId ?? await this.lastResumableMessageId(sessionId, dir2);
+              const result2 = await forkSession(sessionId, {
+                ...dir2 ? { dir: dir2 } : {},
+                ...upToMessageId ? { upToMessageId } : {},
+                ...opts?.title ? { title: opts.title } : {}
+              });
+              return result2.sessionId;
+            } catch {
+              if (attempt >= FORK_RETRY_ATTEMPTS)
+                break;
+              await delay(FORK_RETRY_DELAY_MS);
+            }
           }
         }
+        return null;
       }
       /** The uuid of the last transcript message after which NO tool_use is left without
        *  its tool_result — the safe point to fork at. Reads the same on-disk `.jsonl` the
@@ -22937,11 +23071,11 @@ import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile6 } from
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { tmpdir, homedir as homedir4 } from "node:os";
 import { join as join9, dirname as dirname5 } from "node:path";
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { createServer } from "node:net";
-import { spawn as spawn2, execSync } from "node:child_process";
+import { spawn as spawn2, execSync, execFileSync } from "node:child_process";
 function findClaudeCliJs() {
   const require2 = createRequire(import.meta.url);
   const sdkMain = require2.resolve("@anthropic-ai/claude-agent-sdk");
@@ -22951,6 +23085,56 @@ function findClaudeCliJs() {
   }
   return cliJs;
 }
+function newestVersionManagerNode() {
+  const home = homedir4();
+  for (const p of [
+    join9(home, ".volta", "bin", "node"),
+    join9(home, "Library", "pnpm", "node"),
+    join9(home, ".local", "bin", "node")
+  ])
+    if (existsSync2(p))
+      return p;
+  const roots = [
+    { dir: join9(home, ".nvm", "versions", "node"), bin: (v) => join9(v, "bin", "node") },
+    { dir: join9(home, ".local", "share", "fnm", "node-versions"), bin: (v) => join9(v, "installation", "bin", "node") },
+    { dir: join9(home, "Library", "Application Support", "fnm", "node-versions"), bin: (v) => join9(v, "installation", "bin", "node") },
+    { dir: join9(home, "n", "versions", "node"), bin: (v) => join9(v, "bin", "node") }
+  ];
+  let best = null;
+  for (const { dir: dir2, bin } of roots) {
+    let names;
+    try {
+      names = readdirSync(dir2);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const path5 = bin(join9(dir2, name));
+      if (!existsSync2(path5))
+        continue;
+      const parts = name.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10) || 0);
+      const ver = [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+      const gt = !best || ver[0] > best.ver[0] || ver[0] === best.ver[0] && (ver[1] > best.ver[1] || ver[1] === best.ver[1] && ver[2] > best.ver[2]);
+      if (gt)
+        best = { ver, path: path5 };
+    }
+  }
+  return best?.path ?? null;
+}
+function loginShellNode() {
+  if (process.platform === "win32")
+    return null;
+  const shell = process.env.SHELL || "/bin/zsh";
+  if (!existsSync2(shell))
+    return null;
+  try {
+    const out = execFileSync(shell, ["-lic", `printf '<<NODE:%s>>' "$(command -v node 2>/dev/null)"`], { encoding: "utf8", timeout: 4e3, stdio: ["ignore", "pipe", "ignore"] });
+    const path5 = out.match(/<<NODE:(.*?)>>/)?.[1]?.trim();
+    return path5 && existsSync2(path5) ? path5 : null;
+  } catch {
+    return null;
+  }
+}
 function resolveNodeExecutable() {
   if (cachedNodeExe !== void 0)
     return cachedNodeExe;
@@ -22961,13 +23145,25 @@ function resolveNodeExecutable() {
       return cachedNodeExe = p;
   }
   try {
-    const found = execSync(process.platform === "win32" ? "where node" : "command -v node", { encoding: "utf8" }).split(/\r?\n/)[0].trim();
+    const found = execSync(process.platform === "win32" ? "where node" : "command -v node", { encoding: "utf8", timeout: 3e3 }).split(/\r?\n/)[0].trim();
     if (found && existsSync2(found))
       return cachedNodeExe = found;
   } catch {
   }
+  const vm = newestVersionManagerNode();
+  if (vm)
+    return cachedNodeExe = vm;
+  const shellNode = loginShellNode();
+  if (shellNode)
+    return cachedNodeExe = shellNode;
   return cachedNodeExe = null;
 }
+function warnNoRealNodeOnce() {
+  if (warnedNoNode)
+    return;
+  warnedNoNode = true;
+  log("[agent] no real `node` binary found \u2014 running the Claude CLI via the Electron binary (ELECTRON_RUN_AS_NODE).", "A stray window/Dock tile may briefly appear when a session starts.", "Install Node.js or set CCB_NODE_PATH to a node binary to eliminate it.");
+}
 function extractHumanReadable(message) {
   const parts = [];
   for (const key2 of HUMAN_READABLE_FIELDS) {
@@ -23148,7 +23344,7 @@ MOBILE (${fw}):
     return "";
   }
 }
-var cachedNodeExe, HUMAN_READABLE_FIELDS, TOOL_RESULT_CAP, MAX_RESULT_IMAGES, MAX_IMAGE_BASE64, PERMISSION_MODES, EDIT_PREVIEW_CAP, AsyncMessagePump, IDLE_REAP_MS, MODERATE_IDLE_MS, STEER_COALESCE_MS, STOP_HARD_KILL_AFTER_MS, AgentManager;
+var cachedNodeExe, warnedNoNode, HUMAN_READABLE_FIELDS, TOOL_RESULT_CAP, MAX_RESULT_IMAGES, MAX_IMAGE_BASE64, PERMISSION_MODES, EDIT_PREVIEW_CAP, AsyncMessagePump, IDLE_REAP_MS, MODERATE_IDLE_MS, STEER_COALESCE_MS, STOP_HARD_KILL_AFTER_MS, AgentManager;
 var init_agent_manager = __esm({
   "../../packages/agent-core/dist/agent-manager.js"() {
     "use strict";
@@ -23158,6 +23354,7 @@ var init_agent_manager = __esm({
     init_imagegen_tools();
     init_canvas_tools();
     init_os_control_tools();
+    init_screen_control_tools();
     init_report_tools();
     init_interactive_ui_tools();
     init_session_artifacts();
@@ -23169,6 +23366,7 @@ var init_agent_manager = __esm({
     init_session_usage();
     init_kill_tree();
     init_log();
+    warnedNoNode = false;
     HUMAN_READABLE_FIELDS = ["message", "text", "content", "summary", "description", "output", "stdout", "error", "reason", "name"];
     TOOL_RESULT_CAP = 16e3;
     MAX_RESULT_IMAGES = 4;
@@ -23288,6 +23486,7 @@ var init_agent_manager = __esm({
        *  'tesseract-os-control' tools. Default-OFF: the daemon only sets this when the
        *  user enabled computer control. */
       osControlProvider = null;
+      screenControlProvider = null;
       /** M6 — scheduling. Built lazily by setCronConfig when cron is enabled. */
       cronStore = null;
       cronScheduler = null;
@@ -23326,6 +23525,13 @@ var init_agent_manager = __esm({
       setComputerControl(provider) {
         this.osControlProvider = provider;
       }
+      /** Inject the CURATED screen-control bridge (the voice co-pilot's toolset: look_at_screen /
+       *  perform_step / click / annotate / …). When set, conversations get the in-process
+       *  'tesseract-screen' MCP, routed through the daemon's ai-control manager (consent + coral cursor).
+       *  Read per call, so toggling stops new conversations getting the tools without a restart. */
+      setScreenControl(provider) {
+        this.screenControlProvider = provider;
+      }
       /** M6 — enable/disable model-facing scheduling. When enabled, builds a CronStore
        *  (durable at `file`/`storeDir` if given, else session-only), starts the scheduler
        *  whose fires dispatch a turn, and exposes the Cron / Sleep / PushNotification tools
@@ -24172,6 +24378,9 @@ CRITICAL RULES:
                 if (this.osControlProvider) {
                   mcp["tesseract-os-control"] = createSdkMcpServer({ name: "tesseract-os-control", version: "0.1.0", tools: buildOsControlSdkTools(this.osControlProvider) });
                 }
+                if (this.screenControlProvider) {
+                  mcp["tesseract-screen"] = createSdkMcpServer({ name: "tesseract-screen", version: "0.1.0", tools: buildScreenControlSdkTools(this.screenControlProvider) });
+                }
                 {
                   const projectDir = this.projectDir;
                   const canvasTools = buildCanvasTools({
@@ -24351,6 +24560,8 @@ CRITICAL RULES:
               spawnClaudeCodeProcess: (options) => {
                 const cliJs = findClaudeCliJs();
                 const nodeExe2 = resolveNodeExecutable();
+                if (!nodeExe2 && process.versions.electron)
+                  warnNoRealNodeOnce();
                 const exe = nodeExe2 ?? process.execPath;
                 const runAsNode = exe === process.execPath && !!process.versions.electron;
                 const compileCache = process.env.NODE_COMPILE_CACHE || join9(process.env.CCB_TESSERACT_DIR ?? join9(homedir4(), ".tesseract"), "node-compile-cache");
@@ -25201,6 +25412,7 @@ __export(dist_exports, {
   DTCG_TYPES: () => DTCG_TYPES,
   DesignTokensSchema: () => DesignTokensSchema,
   DtcgTokensSchema: () => DtcgTokensSchema,
+  SCREEN_CONTROL_SPECS: () => SCREEN_CONTROL_SPECS,
   SessionStore: () => SessionStore,
   TOKENS_CSS_FILE: () => TOKENS_CSS_FILE,
   TOKENS_FILE: () => TOKENS_FILE,
@@ -25210,6 +25422,7 @@ __export(dist_exports, {
   buildClaudeNarrationLlm: () => buildClaudeNarrationLlm,
   buildImagegenTools: () => buildImagegenTools,
   buildOsControlSdkTools: () => buildOsControlSdkTools,
+  buildScreenControlSdkTools: () => buildScreenControlSdkTools,
   bumpVersion: () => bumpVersion,
   contrastRatio: () => contrastRatio,
   diffTokens: () => diffTokens,
@@ -25224,6 +25437,7 @@ __export(dist_exports, {
   normalizeTokens: () => normalizeTokens,
   parseColorToRgb: () => parseColorToRgb,
   readSessionArtifacts: () => readSessionArtifacts,
+  resolveNodeExecutable: () => resolveNodeExecutable,
   resolveOauthToken: () => resolveOauthToken,
   resolveSessionFile: () => resolveSessionFile,
   sanitizeProjectDir: () => sanitizeProjectDir,
@@ -25232,6 +25446,7 @@ __export(dist_exports, {
   sessionSidecarDir: () => sessionSidecarDir,
   setTokenPath: () => setTokenPath,
   setTokenSegments: () => setTokenSegments,
+  specParametersJsonSchema: () => specParametersJsonSchema,
   stringifyValue: () => stringifyValue,
   tokenCssVarName: () => tokenCssVarName,
   tokensToCss: () => tokensToCss,
@@ -25252,6 +25467,7 @@ var init_dist5 = __esm({
     init_session_artifacts();
     init_imagegen_tools();
     init_os_control_tools();
+    init_screen_control_tools();
     init_design_tokens2();
   }
 });
@@ -45646,6 +45862,7 @@ async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntim
     setNarrationLlm: (cfg2) => manager2.setNarrationLlm(cfg2),
     setImageGen: (runner2) => manager2.setImageGen(runner2),
     setComputerControl: (provider) => manager2.setComputerControl(provider),
+    setScreenControl: (provider) => manager2.setScreenControl(provider),
     setRunMode: (sessionId, opts) => manager2.setRunMode(sessionId, opts),
     setSessionKeepAlive: (sessionId, keep, holder) => manager2.setSessionKeepAlive(sessionId, keep, holder),
     warmSession: (params) => manager2.warmSession(params),
@@ -45716,11 +45933,11 @@ var CliAgentBackend = class {
       return;
     }
     const sessionId = params.sessionId ?? randomUUID3();
-    const ctx = { sessionId, clientRequestId: params.clientRequestId, messageId: randomUUID3() };
+    const ctx2 = { sessionId, clientRequestId: params.clientRequestId, messageId: randomUUID3() };
     if (!params.sessionId)
       emitMsg({ type: "session:created", sessionId, clientRequestId: params.clientRequestId });
     emitMsg({ type: "agent:status", sessionId, clientRequestId: params.clientRequestId, status: "running" });
-    const args = this.adapter.buildArgs(params, ctx);
+    const args = this.adapter.buildArgs(params, ctx2);
     const child = spawn3(spawnCfg.command, args, {
       cwd: params.projectDir,
       // engineEnv carries the resolved runner env + enabled-skill secrets (the desktop
@@ -45733,7 +45950,7 @@ var CliAgentBackend = class {
       // CLI's PID — these engines spawn their own tool subprocesses too.
       detached: process.platform !== "win32"
     });
-    const turn = { child, sessionId, clientRequestId: params.clientRequestId, messageId: ctx.messageId, acc: "", buf: "", errored: false, interrupted: false };
+    const turn = { child, sessionId, clientRequestId: params.clientRequestId, messageId: ctx2.messageId, acc: "", buf: "", errored: false, interrupted: false };
     this.live.set(sessionId, turn);
     const emit = (m) => {
       if (m.type === "chat:stream" && m.kind !== "thinking")
@@ -45752,7 +45969,7 @@ var CliAgentBackend = class {
       } catch {
       }
       try {
-        this.adapter.translate(parsed, trimmed, emit, ctx);
+        this.adapter.translate(parsed, trimmed, emit, ctx2);
       } catch (err) {
         emit({ type: "agent:tool_use", sessionId, clientRequestId: turn.clientRequestId, toolName: "parse", summary: `(unparsed event) ${String(err)}` });
       }
@@ -45874,7 +46091,7 @@ var codexAdapter = {
     const model = params.model;
     return ["exec", "--json", "--dangerously-bypass-approvals-and-sandbox", ...model ? ["-m", model] : [], params.message];
   },
-  translate(event, _raw, emit, ctx) {
+  translate(event, _raw, emit, ctx2) {
     const o = asObj(event);
     if (!o)
       return;
@@ -45882,9 +46099,9 @@ var codexAdapter = {
     const type = String(o.type ?? inner.type ?? "").toLowerCase();
     const itemType = String(asObj(o.item)?.type ?? asObj(o.item)?.item_type ?? inner.type ?? "").toLowerCase();
     const kindHint = `${type} ${itemType}`;
-    const stream = (delta, kind) => emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta, messageId: ctx.messageId, kind });
+    const stream = (delta, kind) => emit({ type: "chat:stream", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, delta, messageId: ctx2.messageId, kind });
     if (kindHint.includes("error")) {
-      emit({ type: "chat:error", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, error: bestEffortText(inner) || bestEffortText(o) || "Codex error." });
+      emit({ type: "chat:error", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, error: bestEffortText(inner) || bestEffortText(o) || "Codex error." });
       return;
     }
     if (kindHint.includes("thread") || kindHint.includes("turn"))
@@ -45900,7 +46117,7 @@ var codexAdapter = {
     }
     if (kindHint.includes("command") || kindHint.includes("exec") || kindHint.includes("tool") || kindHint.includes("patch") || kindHint.includes("file_change")) {
       const cmd = inner.command ?? inner.name ?? inner.tool ?? "command";
-      emit({ type: "agent:tool_use", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, toolName: String(cmd), summary: bestEffortText(inner) || String(cmd) });
+      emit({ type: "agent:tool_use", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, toolName: String(cmd), summary: bestEffortText(inner) || String(cmd) });
       return;
     }
     if (kindHint.includes("assistant") || kindHint.includes("agent_message") || kindHint.includes("message") || kindHint.includes("output_text")) {
@@ -45926,17 +46143,17 @@ var opencodeAdapter = {
   buildArgs(params) {
     return ["run", "--format", "json", params.message];
   },
-  translate(event, _raw, emit, ctx) {
+  translate(event, _raw, emit, ctx2) {
     const o = asObj2(event);
     if (!o)
       return;
     const inner = asObj2(o.part) ?? asObj2(o.data) ?? o;
     const type = String(o.type ?? inner.type ?? "").toLowerCase();
-    const stream = (delta, kind) => emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta, messageId: ctx.messageId, kind });
+    const stream = (delta, kind) => emit({ type: "chat:stream", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, delta, messageId: ctx2.messageId, kind });
     if (type.includes("step"))
       return;
     if (type.includes("error")) {
-      emit({ type: "chat:error", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, error: bestEffortText(inner) || "OpenCode error." });
+      emit({ type: "chat:error", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, error: bestEffortText(inner) || "OpenCode error." });
       return;
     }
     if (type.includes("reason") || type.includes("think")) {
@@ -45947,7 +46164,7 @@ var opencodeAdapter = {
     }
     if (type.includes("tool") || type.includes("command")) {
       const name = inner.tool ?? inner.name ?? asObj2(inner.state)?.title ?? "tool";
-      emit({ type: "agent:tool_use", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, toolName: String(name), summary: bestEffortText(inner) || String(name) });
+      emit({ type: "agent:tool_use", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, toolName: String(name), summary: bestEffortText(inner) || String(name) });
       return;
     }
     if (type.includes("finish") || type.includes("done") || type.includes("complete"))
@@ -45972,16 +46189,16 @@ var geminiAdapter = {
     const model = params.model;
     return ["--yolo", "--skip-trust", "--output-format", "json", ...model ? ["-m", model] : [], "-p", params.message];
   },
-  translate(event, raw, emit, ctx) {
+  translate(event, raw, emit, ctx2) {
     const o = asObj3(event);
     const text4 = o ? typeof o.response === "string" ? o.response : bestEffortText(o) : typeof event === "string" ? event : raw;
     if (text4)
-      emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta: text4, messageId: ctx.messageId, kind: "text" });
+      emit({ type: "chat:stream", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, delta: text4, messageId: ctx2.messageId, kind: "text" });
     const tools = o?.tools;
     if (Array.isArray(tools)) {
       for (const t of tools) {
         const name = asObj3(t)?.name ?? "tool";
-        emit({ type: "agent:tool_use", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, toolName: String(name), summary: bestEffortText(t) || String(name) });
+        emit({ type: "agent:tool_use", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, toolName: String(name), summary: bestEffortText(t) || String(name) });
       }
     }
   }
@@ -45995,11 +46212,11 @@ var openclawAdapter = {
   id: "openclaw",
   capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: false },
   streaming: false,
-  buildArgs(params, ctx) {
+  buildArgs(params, ctx2) {
     const model = params.model;
-    return ["agent", "--local", "--json", "--session-id", ctx.sessionId, ...model ? ["--model", model] : [], "-m", params.message];
+    return ["agent", "--local", "--json", "--session-id", ctx2.sessionId, ...model ? ["--model", model] : [], "-m", params.message];
   },
-  translate(event, raw, emit, ctx) {
+  translate(event, raw, emit, ctx2) {
     const o = asObj4(event);
     const result2 = asObj4(o?.result) ?? o;
     let text4 = "";
@@ -46018,15 +46235,15 @@ var openclawAdapter = {
     if (!text4)
       text4 = o ? bestEffortText(result2 ?? o) : typeof event === "string" ? event : raw;
     if (text4)
-      emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta: text4, messageId: ctx.messageId, kind: "text" });
+      emit({ type: "chat:stream", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, delta: text4, messageId: ctx2.messageId, kind: "text" });
     const status2 = typeof o?.status === "string" ? o.status : void 0;
     if (!text4 && status2 && status2 !== "ok" && status2 !== "accepted") {
       const summary = typeof o?.summary === "string" && o.summary ? o.summary : `OpenClaw run ${status2}.`;
-      emit({ type: "chat:error", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, error: summary });
+      emit({ type: "chat:error", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, error: summary });
     }
     const ds = asObj4(o?.deliveryStatus);
     if (ds && ds.requested === true && ds.succeeded === false) {
-      emit({ type: "chat:error", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, error: `OpenClaw delivery ${String(ds.status ?? "failed")}.` });
+      emit({ type: "chat:error", sessionId: ctx2.sessionId, clientRequestId: ctx2.clientRequestId, error: `OpenClaw delivery ${String(ds.status ?? "failed")}.` });
     }
   }
 };
@@ -46065,12 +46282,28 @@ async function createBackend(engineId, send2, onBrowserRequest, resolver, loadPl
 
 // ../../packages/host-core/dist/session-recorder.js
 import { join as join10 } from "node:path";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, appendFileSync, readdirSync, rmSync, statSync } from "node:fs";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, appendFileSync, readdirSync as readdirSync2, rmSync, statSync } from "node:fs";
 init_dist5();
 var dir = null;
 var seq = 0;
 var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var ctx = [];
+var CTX_MAX = 60;
+function pushCtx(role, text4) {
+  const t = (text4 ?? "").trim();
+  if (!t)
+    return;
+  ctx.push({ role, text: t.length > 300 ? `${t.slice(0, 300)}\u2026` : t });
+  if (ctx.length > CTX_MAX)
+    ctx.splice(0, ctx.length - CTX_MAX);
+}
 function recordEvent(type, data = {}) {
+  if (type === "transcript")
+    pushCtx(data.speaker === "user" ? "User" : "Assistant", String(data.text ?? ""));
+  else if (type === "tool_call")
+    pushCtx("Action", `called ${String(data.name)}(${JSON.stringify(data.args ?? {}).slice(0, 140)})`);
+  else if (type === "tool_result")
+    pushCtx("Result", `${String(data.name)}${data.isError ? " ERROR" : ""}: ${String(data.text ?? "")}`);
   if (!dir)
     return;
   try {
@@ -46084,7 +46317,7 @@ function recordEvent(type, data = {}) {
 init_dist5();
 
 // ../../packages/host-core/dist/plugin-tools.js
-import { existsSync as existsSync7, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync3 } from "node:fs";
 import { join as join17 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 
@@ -46256,8 +46489,8 @@ function createOpenClawAdapter(pluginId, config2, secretResolver, registry2) {
     pluginId,
     config: config2,
     secret: (envKey2) => secretResolver(pluginId, envKey2),
-    registerTool: (tool8) => {
-      const got = typeof tool8 === "function" ? tool8({}) : tool8;
+    registerTool: (tool9) => {
+      const got = typeof tool9 === "function" ? tool9({}) : tool9;
       const arr = Array.isArray(got) ? got : got ? [got] : [];
       for (const t of arr) {
         const c = convertTool(t);
@@ -46326,10 +46559,10 @@ var HostPluginApi = class {
   secret(envKey2) {
     return this.secretResolver(this.pluginId, envKey2);
   }
-  registerTool(tool8) {
+  registerTool(tool9) {
     const prefix = this.pluginId.replace(/[^a-zA-Z0-9_]/g, "_");
-    const name = tool8.name.startsWith(`${prefix}_`) ? tool8.name : `${prefix}_${tool8.name}`;
-    this.registry.tools.push({ ...tool8, name });
+    const name = tool9.name.startsWith(`${prefix}_`) ? tool9.name : `${prefix}_${tool9.name}`;
+    this.registry.tools.push({ ...tool9, name });
   }
   registerHook(reg) {
     this.registry.hooks.push(reg);
@@ -46927,7 +47160,7 @@ function setActiveConfig(id) {
 
 // ../../packages/host-core/dist/daemon-engine-spawn.js
 init_dist2();
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { homedir as homedir8 } from "node:os";
 import { join as join15 } from "node:path";
 function envKey(id) {
@@ -46956,9 +47189,9 @@ function augmentedPath() {
   return parts.join(sep8);
 }
 function which(bin, path5) {
-  const tool8 = process.platform === "win32" ? "where" : "which";
+  const tool9 = process.platform === "win32" ? "where" : "which";
   try {
-    const out = execFileSync(tool8, [bin], { env: { ...process.env, PATH: path5 }, timeout: 4e3, encoding: "utf-8" });
+    const out = execFileSync2(tool9, [bin], { env: { ...process.env, PATH: path5 }, timeout: 4e3, encoding: "utf-8" });
     return out.split(/\r?\n/).map((l) => l.trim()).find(Boolean) || void 0;
   } catch {
     return void 0;
@@ -47076,7 +47309,7 @@ async function loadPluginRuntime(opts) {
   const engines2 = registry2.modelProviders.map((p) => ({
     id: p.id,
     label: p.label,
-    create: async (ctx) => await p.create(ctx)
+    create: async (ctx2) => await p.create(ctx2)
   }));
   registerPluginEngines(engines2);
   pluginTtsProviders = registry2.speechProviders.filter((p) => p.kind === "tts").map((p) => ({ id: p.id, label: p.label, create: p.create }));
@@ -47107,7 +47340,7 @@ function daemonSkillsPluginConfig() {
     return null;
   const enabled = join17(root, "skills");
   try {
-    const hasSkill = readdirSync2(enabled).some((slug2) => existsSync7(join17(enabled, slug2, "SKILL.md")));
+    const hasSkill = readdirSync3(enabled).some((slug2) => existsSync7(join17(enabled, slug2, "SKILL.md")));
     return hasSkill ? { type: "local", path: root } : null;
   } catch {
     return null;
@@ -47399,8 +47632,7 @@ async function closeEnginePage(browserId) {
 import { spawn as spawn5 } from "node:child_process";
 import { promises as fsp2 } from "node:fs";
 import { join as join21, basename as basename2 } from "node:path";
-import { tmpdir as tmpdir2, networkInterfaces, homedir as homedir10 } from "node:os";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { networkInterfaces, homedir as homedir10 } from "node:os";
 
 // ../../packages/host-core/dist/activity/activity-tracker.js
 import { promises as fsp, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync8 } from "node:fs";
@@ -47997,11 +48229,11 @@ async function nutOrThrow() {
 }
 var NUT_BTN = { left: "left", middle: "middle", right: "right" };
 var MOD_ALIAS = {
-  cmd: "command",
-  command: "command",
-  meta: "command",
-  super: "command",
-  win: "command",
+  cmd: "meta",
+  command: "meta",
+  meta: "meta",
+  super: "meta",
+  win: "meta",
   ctrl: "control",
   control: "control",
   alt: "alt",
@@ -48046,11 +48278,6 @@ function loadMacAx2() {
   })();
   return macAxPromise2;
 }
-function pngSize(buf) {
-  if (buf.length < 24 || buf.readUInt32BE(12) !== 1229472850)
-    return null;
-  return { w: buf.readUInt32BE(16), h: buf.readUInt32BE(20) };
-}
 function orderedDisplays() {
   const el2 = electronModule();
   if (!el2)
@@ -48062,60 +48289,11 @@ function orderedDisplays() {
     return null;
   }
 }
-function targetScaleFactor(displayIndex) {
-  const ds = orderedDisplays();
-  if (!ds || !ds.length)
-    return 1;
-  if (displayIndex !== void 0)
-    return ds[displayIndex]?.scaleFactor ?? ds[0].scaleFactor;
-  return (ds.find((d) => d.primary) ?? ds[0]).scaleFactor;
-}
+var injectedGrabber = null;
 async function captureScreenshot(opts) {
-  if (!IS_MAC)
-    throw new Error("Screen capture is currently only implemented on macOS (screencapture).");
-  const file2 = join21(tmpdir2(), `tess-shot-${randomUUID7()}.png`);
-  const args = ["-x", "-t", "png"];
-  let region = opts?.region;
-  if (!region && opts?.display !== void 0) {
-    const d = orderedDisplays()?.[opts.display];
-    if (d)
-      region = { ...d.bounds };
-  }
-  if (region)
-    args.push("-R", `${region.x},${region.y},${region.width},${region.height}`);
-  else if (opts?.display !== void 0)
-    args.push("-D", String(opts.display + 1));
-  args.push(file2);
-  const r = await capture("screencapture", args, { timeoutMs: 15e3 });
-  if (r.code !== 0) {
-    log3(`screenshot FAILED (${r.stderr.trim() || `exit ${r.code}`}) \u2014 Screen Recording permission may be required`);
-    throw new Error(`screencapture failed (Screen Recording permission may be required): ${r.stderr.trim() || `exit ${r.code}`}`);
-  }
-  try {
-    let buf = await fsp2.readFile(file2);
-    const sz = pngSize(buf);
-    let pointW = sz?.w ?? 0, pointH = sz?.h ?? 0;
-    if (region) {
-      pointW = Math.round(region.width);
-      pointH = Math.round(region.height);
-    } else if (sz) {
-      const sf = targetScaleFactor(opts?.display);
-      pointW = Math.round(sz.w / sf);
-      pointH = Math.round(sz.h / sf);
-    }
-    const downscaled = !opts?.fullRes && !!(sz && pointW > 0 && pointH > 0 && (pointW !== sz.w || pointH !== sz.h));
-    if (downscaled) {
-      await capture("sips", ["-z", String(pointH), String(pointW), file2], { timeoutMs: 1e4 });
-      buf = await fsp2.readFile(file2);
-    }
-    const outW = opts?.fullRes && sz ? sz.w : pointW, outH = opts?.fullRes && sz ? sz.h : pointH;
-    const tgt = region ? `region ${region.x},${region.y} ${region.width}\xD7${region.height}` : opts?.display !== void 0 ? `display ${opts.display}` : "main display";
-    log3(`screenshot ${tgt} \u2192 ${outW}\xD7${outH}px${opts?.fullRes ? " (full native res)" : downscaled && sz ? ` (downscaled from ${sz.w}\xD7${sz.h}px native)` : ""}`);
-    return { dataBase64: buf.toString("base64"), mimeType: "image/png", width: outW || void 0, height: outH || void 0 };
-  } finally {
-    void fsp2.unlink(file2).catch(() => {
-    });
-  }
+  if (!injectedGrabber)
+    throw new Error("Screen capture unavailable: the Electron screen grabber is not registered (GUI daemon not running).");
+  return injectedGrabber(opts);
 }
 async function listAppsMac() {
   const script = `tell application "System Events"
@@ -48188,6 +48366,7 @@ function createDaemonOsControlRunner() {
       if (o.at)
         n.moveMouse(Math.round(o.at.x), Math.round(o.at.y));
       n.mouseClick(NUT_BTN[o.button ?? "left"], o.double === true);
+      log3(`${o.button ?? "left"}${o.double ? "-double" : ""}-click${o.at ? ` @ ${Math.round(o.at.x)},${Math.round(o.at.y)}` : ""}`);
     },
     async mouseDrag(from, to, o) {
       const n = await nutOrThrow();
@@ -48200,6 +48379,37 @@ function createDaemonOsControlRunner() {
         n.moveMouse(Math.round(fx + (tx - fx) * i / steps), Math.round(fy + (ty - fy) * i / steps));
       n.mouseToggle("up", btn);
     },
+    async mouseDragPath(points, opts) {
+      if (!points || points.length < 2)
+        return;
+      const n = await nutOrThrow();
+      const btn = NUT_BTN[opts?.button ?? "left"];
+      const stepPx = opts?.stepPx ?? 5, stepMs = opts?.stepMs ?? 12;
+      const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+      const move = (x, y) => {
+        const rx = Math.round(x), ry = Math.round(y);
+        n.moveMouse(rx, ry);
+        opts?.onStep?.({ x: rx, y: ry });
+      };
+      move(points[0].x, points[0].y);
+      await sleep(120);
+      n.mouseToggle("down", btn);
+      try {
+        for (let i = 1; i < points.length; i++) {
+          const a = points[i - 1], b = points[i];
+          const dist = Math.hypot(b.x - a.x, b.y - a.y);
+          const segs = Math.max(1, Math.round(dist / stepPx));
+          for (let s = 1; s <= segs; s++) {
+            if (opts?.signal?.aborted)
+              return;
+            move(a.x + (b.x - a.x) * s / segs, a.y + (b.y - a.y) * s / segs);
+            await sleep(stepMs);
+          }
+        }
+      } finally {
+        n.mouseToggle("up", btn);
+      }
+    },
     async scroll(o) {
       const n = await nutOrThrow();
       if (o.at)
@@ -48214,6 +48424,7 @@ function createDaemonOsControlRunner() {
     async typeText(t) {
       const n = await nutOrThrow();
       n.typeString(t);
+      log3(`type "${t.length > 50 ? `${t.slice(0, 50)}\u2026` : t}"`);
     },
     async pressKeys(combo) {
       const n = await nutOrThrow();
@@ -48221,6 +48432,7 @@ function createDaemonOsControlRunner() {
       if (!key2)
         throw new Error(`Empty key combo: "${combo}"`);
       n.keyTap(key2, modifiers);
+      log3(`key ${combo}`);
     },
     // Screen
     async displays() {
@@ -48471,6 +48683,7 @@ function createDaemonOsControlRunner() {
 // ../../packages/host-core/dist/gui/ai-control.js
 init_dist5();
 var runner = createDaemonOsControlRunner();
+var controlAbort = new AbortController();
 var IDLE_RELEASE_MS = 15 * 6e4;
 var STOP = new Set("the a an in on at of to for and or is it this that with my your please click open press tap select choose go button icon taskbar dock toolbar screen top bottom left right corner side middle center centre near above below first second third".split(" "));
 
@@ -48735,7 +48948,7 @@ async function createElevenLabsAgent(args) {
 }
 
 // ../../packages/voice-core/dist/orchestrator.js
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 
 // ../../packages/voice-core/dist/summarizer.js
 var TURN_SYSTEM = [
@@ -49091,7 +49304,7 @@ Additional context: ${context}` : task;
     this.emitFocusedState();
     const sessionId = track.sessionId || void 0;
     this.deps.emit({ type: "voice:dispatched", text: message, sessionId });
-    const clientRequestId = randomUUID8();
+    const clientRequestId = randomUUID7();
     track.pendingClientRequestId = clientRequestId;
     try {
       const sid = await this.deps.agent.dispatch({ message, clientRequestId, sessionId });
@@ -49124,7 +49337,7 @@ Additional context: ${context}` : task;
     this.emitFocusedState();
     const sessionId = track.sessionId || void 0;
     this.deps.emit({ type: "voice:dispatched", text: message, sessionId });
-    const clientRequestId = randomUUID8();
+    const clientRequestId = randomUUID7();
     track.pendingClientRequestId = clientRequestId;
     try {
       const sid = await this.deps.agent.dispatch({ message, clientRequestId, sessionId });
@@ -49147,7 +49360,7 @@ Additional context: ${context}` : task;
     this.voice?.respondToTool(inv.callId, "Got it \u2014 passing that along.");
     this.focusTrack(track);
     this.deps.emit({ type: "voice:dispatched", text: addendum, sessionId: track.sessionId });
-    const clientRequestId = randomUUID8();
+    const clientRequestId = randomUUID7();
     track.pendingClientRequestId = clientRequestId;
     try {
       await this.deps.agent.dispatch({ message: addendum, sessionId: track.sessionId, clientRequestId });
@@ -49185,7 +49398,7 @@ Additional context: ${context}` : task;
       this.voice?.respondToTool(inv.callId, "Got it \u2014 passing that along.");
       this.focusTrack(track);
       this.deps.emit({ type: "voice:dispatched", text: answer, sessionId: track.sessionId });
-      const clientRequestId = randomUUID8();
+      const clientRequestId = randomUUID7();
       track.pendingClientRequestId = clientRequestId;
       void this.deps.agent.dispatch({ message: answer, sessionId: track.sessionId, clientRequestId }).catch((err) => this.say(`I couldn't send that: ${errMsg(err)}.`, { urgent: true }));
       track.state = "working";
@@ -49612,104 +49825,57 @@ var ClientProxyProvider = class {
 
 // ../../packages/host-core/dist/voice-control.js
 init_dist5();
+init_dist5();
 var OPENAI_REALTIME_MODEL = "gpt-realtime";
 var GEMINI_LIVE_MODEL = "gemini-3.1-flash-live-preview";
+var DEFAULT_GEMINI_VOICE = "Aoede";
 var GATEWAY_OPERATOR_PROMPT = `
 
-Claude Code \u2014 the agent you relay to \u2014 can also SEE and CONTROL this computer: open and switch apps, click, type, browse the web, and operate the screen, on top of writing code. So when the developer asks for ANYTHING on the computer ("open Chrome", "fill in this form", "click that", "search for X", "what's on my screen"), DISPATCH it to Claude Code and relay what happens back in your own short spoken words. You are the voice and ears; Claude Code is the hands and eyes. Don't claim you can't do screen things \u2014 pass them to Claude Code.`;
-var SCREEN_TOOL_NAMES = /* @__PURE__ */ new Set(["request_control_consent", "look_at_screen", "annotate", "remove_annotations", "launch_app", "list_apps", "click", "move_to", "type_text", "press_key", "scroll_screen", "release_control"]);
+YOU ARE THE VOICE LAYER. You talk with the developer, understand what they want, and hand the actual DOING to a powerful agent (Claude Code) that fully controls this Mac \u2014 it takes high-res screenshots, uses the mouse/keyboard, the accessibility tree, processes, files, and every other tool. You do NOT operate the screen yourself.
+
+You also see a LOW-RESOLUTION ~1 fps view of the screen, so you can follow along, describe what's happening, and confirm results in your own words \u2014 but it's just for awareness; never try to act on it.
+
+So whenever the developer asks for ANYTHING on the computer ("open Chrome", "search Amazon for X", "fill in this form", "click that", "what's on my screen", "read this") \u2014 hand it to the agent with dispatch_to_claude_code. You are the ears and voice; the agent is the hands and eyes. Never say you can't do something on screen \u2014 hand it to the agent and report back.
+
+WORK IN SMALL STEPS \u2014 this is important. Break the developer's request into the SMALLEST sensible actions and dispatch them ONE AT A TIME. For "open Chrome and find Levi's jeans on Amazon" you'd dispatch, in order: "open Google Chrome" \u2192 "navigate to amazon.com" \u2192 "search for Levi's jeans" \u2192 "find the search results and outline the first one". Send ONE step, WAIT for the agent to actually finish it and REPLY, tell the developer briefly what the agent reported, THEN send the next step. Do NOT cram the whole goal into one dispatch \u2014 small steps are easier to follow, verify, and correct, and the developer can redirect you between them. All your steps go to the SAME agent session automatically, so it REMEMBERS everything done so far \u2014 you never need to repeat earlier context, just give the next action.
+
+BE HONEST \u2014 NEVER PRETEND TO SEE OR KNOW. Your screen view is LOW-RES and blurry; the AGENT is the one actually looking and doing. So NEVER state specific things like "Amazon is open", "the results are showing", "you're signed in", "it worked" UNLESS the agent told you that in its reply. Do NOT narrate what you imagine or expect happened \u2014 only relay what the agent ACTUALLY reported, in your own short words. After you dispatch a step, WAIT for the agent's reply before saying it's done \u2014 don't announce success the instant you send the task. If you're unsure whether something worked, dispatch a quick check ("check whether amazon.com is loaded") rather than guessing. The developer instantly catches you when you describe something that isn't there \u2014 so only ever say what you actually know from the agent.`;
+var REQUEST_CONSENT_TOOL = {
+  name: "request_control_consent",
+  description: `Ask the developer for permission to interact with their computer. Call this FIRST \u2014 before any annotate / click / type / scroll \u2014 whenever you're about to act on the screen and don't already have permission this call. It pops a permission box on their screen; you must ALSO say out loud, word for word: "I need your permission in order to interact with your computer." and ask them to click Allow. Once they click Allow, call the action tool (annotate/click/\u2026). look_at_screen does NOT need this.`,
+  parameters: { type: "object", properties: {} }
+};
 var SCREEN_CONTROL_TOOLS = [
-  {
-    name: "request_control_consent",
-    description: `Ask the developer for permission to interact with their computer. Call this FIRST \u2014 before any annotate / click / type / scroll \u2014 whenever you're about to act on the screen and don't already have permission this call. It pops a permission box on their screen; you must ALSO say out loud, word for word: "I need your permission in order to interact with your computer." and ask them to click Allow. Once they click Allow, call the action tool (annotate/click/\u2026). look_at_screen does NOT need this.`,
-    parameters: { type: "object", properties: {} }
-  },
-  {
-    name: "look_at_screen",
-    description: "Take a fresh look at the developer's current screen. The screen is NOT streamed to you continuously, so call this whenever you need to SEE what's on screen \u2014 before locating something to click, to verify the result of an action, or when they ask what's on their screen. After you call it, the current screen image is given to you.",
-    parameters: { type: "object", properties: {} }
-  },
-  {
-    name: "click",
-    description: "Click a UI element by DESCRIBING it in plain words \u2014 do NOT pass coordinates. The system finds its exact location (the macOS accessibility tree first, then a vision model) and clicks it precisely. Be specific and include any visible label/text.",
-    parameters: {
-      type: "object",
-      properties: {
-        target: { type: "string", description: 'What to click, described precisely \u2014 e.g. "the Google Chrome icon in the Dock", "the blue Sign in button", "the address bar", "the Submit button at the bottom of the form".' },
-        button: { type: "string", enum: ["left", "right"], description: "Mouse button (default left)." },
-        double: { type: "boolean", description: "Double-click when true." }
-      },
-      required: ["target"]
-    }
-  },
-  {
-    name: "move_to",
-    description: 'Move the cursor OVER a UI element without clicking \u2014 to hover, or to show/verify where something is (use this when the developer says "move the mouse over X" or "point at X"). Describe the target in plain words.',
-    parameters: { type: "object", properties: { target: { type: "string", description: "What to move the cursor over, described precisely." } }, required: ["target"] }
-  },
-  {
-    name: "launch_app",
-    description: 'Open / launch / switch to an application by name (e.g. "Google Chrome", "Safari", "Terminal", "System Settings"). This is the RELIABLE way to open an app \u2014 use it instead of hunting for a Dock icon to click.',
-    parameters: { type: "object", properties: { name: { type: "string", description: 'The application name, e.g. "Google Chrome".' } }, required: ["name"] }
-  },
-  {
-    name: "list_apps",
-    description: "List the apps currently running \u2014 to check whether something opened or is ready before the next step.",
-    parameters: { type: "object", properties: {} }
-  },
-  {
-    name: "annotate",
-    description: "POINT something out on the developer's screen with a hand-drawn red marker doodle (animated as if drawn live). Use it for 'where is X', 'show me X', 'point at X', 'underline X', 'cross out X', 'check off X', 'highlight X'. It only highlights \u2014 it does NOT click. Pick the style that fits what they asked; omit it for an auto choice based on the item's shape.",
-    parameters: {
-      type: "object",
-      properties: {
-        target: { type: "string", description: "What to mark, described precisely." },
-        style: { type: "string", enum: ["auto", "circle", "box", "bracket", "underline", "zigzag", "strike", "highlight", "arrow", "check", "cross", "star", "scribble", "cloud", "caret"], description: "Which kind of doodle: circle/box/bracket to enclose; underline/zigzag/highlight to emphasise text; arrow to point; check/cross/star to mark; strike to cross through. Default auto." },
-        label: { type: "string", description: 'Optional short text to write next to it, e.g. "Here!".' }
-      },
-      required: ["target"]
-    }
-  },
-  {
-    name: "remove_annotations",
-    description: "Clear ALL the marker doodles you've drawn on the screen. Call this when you move on to a different topic or the developer asks you to remove them. Annotations otherwise stay on screen.",
-    parameters: { type: "object", properties: {} }
-  },
-  {
-    name: "type_text",
-    description: "Type text at the current cursor/focus. Click the target field first if it is not focused.",
-    parameters: { type: "object", properties: { text: { type: "string", description: "The text to type." } }, required: ["text"] }
-  },
-  {
-    name: "press_key",
-    description: 'Press a key or combo, e.g. "enter", "esc", "cmd+a", "cmd+c", "tab".',
-    parameters: { type: "object", properties: { keys: { type: "string", description: 'Key or combo like "enter" or "cmd+c".' } }, required: ["keys"] }
-  },
-  {
-    name: "scroll_screen",
-    description: "Scroll the screen (at the centre). Positive dy scrolls down, negative up.",
-    parameters: {
-      type: "object",
-      properties: {
-        dy: { type: "number", description: "Vertical amount; positive scrolls down." },
-        dx: { type: "number", description: "Horizontal amount; positive scrolls right." }
-      },
-      required: ["dy"]
-    }
-  },
-  {
-    name: "release_control",
-    description: "Stop controlling the computer when you've finished the on-screen task. Removes the coral cursor and the 'working with your computer' bar. Call this as soon as you're done acting on the screen.",
-    parameters: { type: "object", properties: {} }
-  }
+  REQUEST_CONSENT_TOOL,
+  ...SCREEN_CONTROL_SPECS.map((s) => ({ name: s.name, description: s.description, parameters: specParametersJsonSchema(s) }))
 ];
+var SCREEN_TOOL_NAMES = /* @__PURE__ */ new Set(["request_control_consent", ...SCREEN_CONTROL_SPECS.map((s) => s.name)]);
 var SCREEN_CONTROL_PROMPT = `
 
-You can SEE and directly CONTROL the developer's screen \u2014 THIS IS YOUR PRIMARY JOB. When they ask you to interact with what's on screen (open/switch apps, click a button/icon/link, type into a field, navigate a website or menu, fill a form, scroll, or anything you can point at and do), DO IT YOURSELF with the look_at_screen / click / move_to / type_text / press_key / scroll_screen tools. Do NOT use dispatch_to_claude_code for on-screen actions \u2014 that's only for writing/editing source code, terminal commands, or multi-step software development.
+You can SEE and directly CONTROL the developer's screen \u2014 THIS IS YOUR PRIMARY JOB. When they ask you to interact with what's on screen (open/switch apps, click a button/icon/link, type into a field, navigate a website or menu, fill a form, scroll, or anything you can point at and do), DO IT YOURSELF: use perform_step for any multi-action step, type_into to type into a field, and look_at_screen / verify / click / press_key / scroll_screen / launch_app as needed.
+
+BE DECISIVE \u2014 JUST DO IT, DON'T ASK: when the developer tells you to do something ("read it", "what does it say", "click that", "find X", "open Y"), DO IT immediately and report the RESULT. NEVER ask permission for HOW you do it \u2014 taking a screenshot, looking closer, zooming in, choosing high- vs low-resolution, picking which tool to use are YOUR internal mechanics and NONE of the developer's concern. Just call look_at_screen / click / annotate / etc. silently and get on with it. Do NOT say things like "should I pull up a high-resolution version?", "would you like me to look closer?", or "which one do you mean?" for the obvious case. Do NOT narrate each step or ask for confirmation between steps \u2014 you are NOT tiptoeing through a minefield; that constant checking is annoying. Make the reasonable choice and act. Only ask a question when the request is GENUINELY ambiguous and you truly cannot proceed (e.g. there really are two equally-likely buttons) \u2014 otherwise pick the most likely interpretation and do it. (Narrating what you're doing out loud is REQUIRED \u2014 see KEEP TALKING below \u2014 but ASKING for confirmation or permission between steps is not. Describe; don't check in.)
+
+OWN THE TASK \u2014 RECOVER FROM ERRORS YOURSELF: you have a toolbox (look_at_screen, figure_out_next, verify, perform_step, type_into, click, press_key, scroll_screen, launch_app, annotate). YOU decide which to use and in what order \u2014 there's almost always more than one way. For a complex task, break it into steps and do them ONE AT A TIME with perform_step (it plans + runs + self-corrects each step). After each step, use verify to CHECK it actually worked (e.g. verify "a new tab is open", verify "the search results are showing") before moving to the next. If verify says NO, fix that step before continuing. The moment you're unsure what to do or you hit an obstacle, call figure_out_next instead of guessing. When something fails or doesn't do what you expected, do NOT stop and ask the developer what to do \u2014 figure it out and try again a different way: if a keyboard shortcut does nothing, click the element instead; if a click misses, look_at_screen and re-aim; if an app isn't where you expect, launch_app it; if a page didn't load, retry or navigate another way. After each action, VERIFY by looking at the screen \u2014 don't assume it worked; check, and if it didn't, fix it. Keep working the problem until the goal is ACTUALLY achieved, then report the outcome. Treat the developer's request as a goal to complete autonomously, not a script to read back. Only come back to them if you're genuinely stuck after really trying alternatives, or you need something only they can give (a password, a choice between real options). Don't ask permission or check in every few seconds \u2014 just get it done.
+
+KEEP TALKING \u2014 NARRATE IN PLAIN WORDS, NEVER GO SILENT WHILE WORKING: your tools run in the background while you keep speaking, so EVERY time you start a tool you MUST first say, out loud, what you're doing \u2014 and say it as the ACTIVITY in everyday words (WHAT you're working on), NEVER the tool's name or any technical jargon. Say "Okay, opening Photoshop now\u2026", "Let me find the brush tool\u2026", "Drawing the star now\u2026", "One sec, searching Amazon for jeans\u2026", "Just taking a look at your screen\u2026" \u2014 NOT "calling launch_app", "running perform_step", "invoking look_at_screen", "executing click". The developer should hear a person describing their work, not a robot reading function names. When a result comes back, say what happened in plain words \u2014 "Done, the results are up" or "Hmm, that didn't work \u2014 let me try another way". If something fails or you switch approach, SAY SO out loud. The developer should NEVER sit in silence wondering what you're doing \u2014 keep them in the loop before, during, and after every single action. A few seconds of silence with no narration is a failure.
+
+HAND THE TURN BACK WHEN YOU'RE IDLE: the moment you've finished what they asked and have nothing else queued to do, tell them OUT LOUD that you're done and waiting for them \u2014 e.g. "All set \u2014 what would you like next?", "Done. Ready when you are.", "Okay, I'm waiting for your input." NEVER finish a task and then just go quiet; always close the loop with a short hand-back so they clearly know it's their turn to speak. Going idle without saying so leaves them wondering whether you're still working or stuck.
+
+TELL THE TRUTH \u2014 VERIFY BEFORE YOU CLAIM: NEVER say something worked, opened, loaded, searched, or that "here are the results" / "you're on X now" unless you JUST confirmed it with verify or look_at_screen. A tool returning "done" only means the click/keystroke was SENT \u2014 NOT that it had the effect you wanted. After any action that should change the screen, call verify (or look_at_screen) and report ONLY what is actually there. Claiming a result you haven't checked is the WORST thing you can do \u2014 it makes you useless and impossible to trust (the developer instantly catches you). If the check says it didn't work, say so plainly and try a different way.
+
+PREFER COMPOSITE STEPS \u2014 NEVER RACE MICRO-ACTIONS: do NOT try to do a multi-action step by firing several quick single calls \u2014 they run out of order. Instead:
+- To put text in a field \u2192 use type_into (it clicks the field, types, and optionally presses Enter, IN THE RIGHT ORDER).
+- For ANY step that needs more than one action ("search Amazon for jeans", "open a new tab and go to gmail.com", "add the first result to the cart") \u2192 use perform_step. A stronger model figures out the exact click/type sequence and RUNS it in order, then tells you the resulting screen. This is far more reliable than you sequencing the actions.
+- Use the single-action tools (click, press_key, scroll_screen) only for a genuinely SINGLE action.
+
+WHEN YOU'RE STUCK OR CONFUSED: if you don't know how to proceed, an action didn't do what you expected, or you hit an obstacle (a dialog, a "See options" / size picker, a login wall, an unexpected screen) \u2014 do NOT flail with random clicks and do NOT just ask the developer. Call figure_out_next: a stronger model looks at the screen + everything you've been doing and hands you back the goal and a short list of the exact next steps to get past it. Then carry those steps out (with perform_step). This is your get-unstuck button \u2014 use it the moment you're unsure.
+
+SEEING THE SCREEN: you do NOT have a continuous video feed. Instead you get a FRESH screen image right after every action you take (click, type_into, perform_step, scroll, etc.) and whenever you call look_at_screen. Between actions, you're working from that last image \u2014 if you haven't acted or looked recently, look_at_screen before you assume anything. For anything you must be SURE about \u2014 reading text, identifying a specific element, confirming a result actually happened \u2014 call look_at_screen (the current image + a detailed written description from a strong vision model: focused app/window + contents, any dialog/menu/notification, any selection, where the mouse is and what it's hovering over) or verify. Whenever the developer asks "what's on my screen / what do you see / read this / where's my cursor", or you need to confirm the state or result of an action, call look_at_screen and relay what it reports \u2014 never describe the screen from memory.
 
-SEEING THE SCREEN: a LOW-resolution image of the screen is streamed to you about once a second, so you always have a general sense of what's happening \u2014 describe it, follow along, react. It's low-res, so for anything that needs DETAIL (reading small text, confirming exactly what an icon is) call look_at_screen for a fresher frame. You don't need to call look_at_screen before click/annotate \u2014 those take their OWN high-resolution screenshot to locate the target precisely.
+NEVER CLAIM A RESULT YOU HAVEN'T SEEN: do NOT say a step "is done", "is ready", "is typed", "was added", etc. until the tool RESULT or a verify/look_at_screen has actually confirmed it. While a tool is running and you're filling the silence, say only what you are DOING ("typing that in now\u2026", "opening it\u2026") \u2014 NEVER the OUTCOME. Sending a click or some keys is NOT proof it worked. If you're not sure, verify or look_at_screen and report ONLY what you truly see \u2014 saying something happened when it didn't is the worst thing you can do.
 
-FINDING / LOCATING: when they ask WHERE something is, to FIND it, point it out, or for its location \u2014 DON'T answer from the low-res ambient stream (it's too coarse and you'll be wrong). ALWAYS use annotate (or click): it takes a HIGH-RESOLUTION screenshot and asks the reasoning model for the exact spot. If the model can't find it, say so and offer to open it (launch_app) \u2014 don't pretend you can see it.
+FINDING / LOCATING: when they ask WHERE something is, to FIND it, point it out, or for its location \u2014 ALWAYS use annotate (or click): it takes a HIGH-RESOLUTION screenshot and asks the reasoning model for the exact spot. If the model can't find it, say so and offer to open it (launch_app) \u2014 don't pretend you can see it.
 
 POINTING THINGS OUT: when they ask "where is X", "show me X", "point at X", "underline X", "cross out X", "check off X", or "highlight X", use annotate \u2014 it draws a hand-drawn red marker doodle around/at the item (circle, box, bracket, underline, zigzag, highlight, arrow, check, cross, star, strike, \u2026), animated as if drawn live, with an optional label like "Here!". Choose the style that matches their words (or omit it to auto-pick from the item's shape). annotate only highlights; it does NOT click \u2014 but it does draw on their screen, so it needs the same permission as control (ask the first time).
 
@@ -49717,11 +49883,13 @@ CLEARING ANNOTATIONS (important): your marker doodles PERSIST on the screen \u20
 
 PERMISSION (read carefully): before you point at, annotate, click, type, or otherwise act on the screen for the FIRST time, you MUST call the request_control_consent tool. Calling it pops a permission box on the developer's screen \u2014 and at the same time you must SAY, word for word: "I need your permission in order to interact with your computer." Then tell them to click Allow on the box. The moment they click Allow, go ahead and call the action tool (annotate / click / \u2026) \u2014 it now works. NEVER just talk about needing permission without calling request_control_consent: if you don't call it, NOTHING appears on their screen and they'll be confused. (look_at_screen never needs permission.) A coral cursor + a top bar appear while you're interacting.
 
-To click or point: DESCRIBE the target in plain words (e.g. "the Google Chrome icon in the Dock", "the blue Sign in button") \u2014 never coordinates; the system locates it from the screen image. To just MOVE the cursor over something without clicking ("move the mouse over X", "point at X", "hover over X"), use move_to (NOT scroll_screen \u2014 that scrolls content, it does not move the cursor).
+To click or point: DESCRIBE the target in plain words (e.g. "the Google Chrome icon in the Dock", "the blue Sign in button") \u2014 never coordinates; the system locates it from the screen image. To point something out for the developer ("where is X", "show me X"), use annotate.
 
-OPENING APPS: to open or switch to an app, use launch_app with its name (e.g. launch_app "Google Chrome") \u2014 that is far more reliable than locating and clicking a Dock icon. Use list_apps and look_at_screen to check whether it opened and is ready before the next step.
+OPENING APPS: to open or switch to an app, use launch_app with its name (e.g. launch_app "Google Chrome") \u2014 that is far more reliable than locating and clicking a Dock icon. Use verify or look_at_screen to check it opened and is ready before the next step.
 
-CLICKS ARE SELF-VERIFYING: after the cursor moves to your target, the system takes ANOTHER screenshot and confirms the cursor is really on it before clicking \u2014 it corrects once if it was off, or refuses to click (and tells you) if it can't confirm. So trust the tool's reply: if it says it clicked, look_at_screen to see the result; if it says it couldn't confirm or find the target, change approach (open the app directly with launch_app, scroll it into view, or re-describe it) instead of repeating the same thing.
+CLICKS: the system locates your described target with a two-pass high-res zoom (accurate), moves the coral cursor there, and clicks. It does NOT know whether the click had the effect you wanted \u2014 so after any click, look_at_screen and report ONLY what actually changed. If it couldn't find the target, change approach (launch_app, scroll it into view, re-describe it, or use the accessibility tools below) \u2014 don't repeat the same click.
+
+MORE TOOLS \u2014 you also have the full computer toolset (os_* tools): read/write/search files (os_fs_*), clipboard (os_clipboard_read/write), run a shell command (os_run), open a file or URL (os_open), manage windows and apps (os_windows, os_window_action, os_app_activate, os_app_quit, os_ps, os_proc_kill), inspect the network (os_net_*, os_http_probe), post a notification (os_notify), and read the macOS ACCESSIBILITY TREE (os_ax_tree gives the exact on-screen elements with their positions + actions; os_ax_action presses/focuses one precisely). When a vision-grounded click keeps missing a NATIVE control (a menu item, button, or Dock icon), use os_ax_tree to find it and os_ax_action to press it \u2014 that's pixel-exact. Anything that changes the machine (write/run/kill/quit/move/delete) asks the developer's permission the first time, exactly like clicking.
 
 BE CAREFUL AND DELIBERATE \u2014 never act hastily:
 1. look_at_screen so you can SEE the current state, and identify the target precisely.
@@ -49730,6 +49898,8 @@ BE CAREFUL AND DELIBERATE \u2014 never act hastily:
 4. If it did NOT work, do NOT give up or blindly repeat \u2014 look again, re-describe the target more precisely, pick a different element, scroll it into view, or try another route. Persist with a better approach.
 
 KEEP CONTROL for the rest of the conversation once granted \u2014 do NOT release between actions or tasks. Call release_control ONLY when the developer EXPLICITLY tells you to stop / let go. (Ending the call releases automatically.) If you genuinely cannot see or find the target, say so and ask. For real coding or multi-step automation, still delegate to Claude Code with the task tools.`;
+var SLOW_TOOL_FIRST = `(System note \u2014 do NOT read this note aloud or mention it. The action you're running is taking a little while. Say ONE short, natural, reassuring spoken sentence to the developer in your own words \u2014 like "this is taking a bit longer, just hold on" or "bear with me a second, still working on it". Do NOT claim it finished or describe any result \u2014 you're still waiting for it.)`;
+var SLOW_TOOL_MORE = `(System note \u2014 do NOT read this note aloud or mention it. That same action is STILL running. Say ONE short, natural reassurance that you're still on it \u2014 like "still working on it, almost there" \u2014 in your own words. Do NOT claim it finished or describe a result yet.)`;
 async function mintOpenAi(apiKey, model, voice) {
   const res = await fetch("https://api.openai.com/v1/realtime/sessions", {
     method: "POST",
@@ -49782,6 +49952,10 @@ var VoiceControl = class {
   /** Agent events tee'd in before the orchestrator subscribes (the connect window)
    *  are buffered and flushed on subscribe so no narration/session-bind is lost. */
   pending = [];
+  /** SERIALIZE screen-control tools. Gemini Live can emit several functionCalls in ONE turn
+   *  (parallel function calling); running them concurrently let `type` fire before `click` landed.
+   *  Chaining each onto the previous makes them run strictly in arrival order, one at a time. */
+  screenQueue = Promise.resolve();
   constructor(deps) {
     this.deps = deps;
   }
@@ -49794,7 +49968,9 @@ var VoiceControl = class {
         if (this.deps.screenControl && this.deps.execScreenControl && SCREEN_TOOL_NAMES.has(msg.name)) {
           log(`voice: tool-call (screen) ${msg.name} ${JSON.stringify(msg.args)}`);
           recordEvent("tool_call", { kind: "screen", name: msg.name, args: msg.args });
-          void this.runScreenControl(msg.callId, msg.name, msg.args);
+          const { callId, name, args } = msg;
+          this.screenQueue = this.screenQueue.then(() => this.runScreenControl(callId, name, args)).catch(() => {
+          });
         } else {
           log(`voice: tool-call (guide) ${msg.name}`);
           recordEvent("tool_call", { kind: "guide", name: msg.name, args: msg.args });
@@ -49836,11 +50012,28 @@ var VoiceControl = class {
   async runScreenControl(callId, name, args) {
     let text4;
     let isError = false;
+    let finished = false, nudges = 0;
+    let slowTimer = null;
+    const scheduleNudge = (ms) => {
+      slowTimer = setTimeout(() => {
+        if (finished)
+          return;
+        nudges++;
+        this.deps.send({ type: "voice:cd:inject", text: nudges === 1 ? SLOW_TOOL_FIRST : SLOW_TOOL_MORE });
+        if (nudges < 4)
+          scheduleNudge(3e4);
+      }, ms);
+    };
+    scheduleNudge(2e4);
     try {
       text4 = await this.deps.execScreenControl(name, args);
     } catch (e) {
       text4 = e instanceof Error ? e.message : "screen action failed";
       isError = true;
+    } finally {
+      finished = true;
+      if (slowTimer)
+        clearTimeout(slowTimer);
     }
     log(`voice: screen-control ${name} \u2192 ${isError ? "ERROR " : ""}${text4}`);
     recordEvent("tool_result", { name, text: text4, isError });
@@ -49936,15 +50129,23 @@ var VoiceControl = class {
       llm = cfg2?.complete ?? null;
     } catch {
     }
+    const priorText = typeof msg.history === "string" ? msg.history.trim() : "";
+    const priorTextPrompt = priorText ? `
+
+CONTEXT \u2014 the developer was just chatting with you in TEXT (typed) and has now switched to VOICE. Here is that conversation so far; you have its FULL context, so continue naturally and never ask them to repeat anything:
+
+${priorText}` : "";
     const realtime = {
       provider: msg.provider,
       apiKey: "",
       // unused: the proxy doesn't open a provider socket (the client does)
-      voice: msg.voice,
+      voice: msg.voice || (msg.provider === "gemini" ? DEFAULT_GEMINI_VOICE : void 0),
+      // fixed female default
       language: msg.language,
       turnSensitivity: msg.turnSensitivity,
-      instructions: buildGuidePrompt({ projectName: projectDir ? basename3(projectDir) : void 0, sessions: msg.sessions }) + (this.deps.screenControl ? SCREEN_CONTROL_PROMPT : "") + (this.deps.dispatchAppendPrompt ? GATEWAY_OPERATOR_PROMPT : ""),
-      greeting: DEFAULT_GREETING
+      instructions: buildGuidePrompt({ projectName: projectDir ? basename3(projectDir) : void 0, sessions: msg.sessions }) + (this.deps.screenControl ? SCREEN_CONTROL_PROMPT : "") + (this.deps.dispatchAppendPrompt ? GATEWAY_OPERATOR_PROMPT : "") + priorTextPrompt,
+      greeting: priorText ? "" : DEFAULT_GREETING
+      // already mid-conversation → don't re-greet
     };
     const orchestrator = new VoiceGuideOrchestrator({
       agent,
@@ -49973,7 +50174,7 @@ var VoiceControl = class {
     };
     const proxy = new ClientProxyProvider(realtime, callbacks, { auth, send: (m) => this.deps.send(m), clientRequestId: msg.clientRequestId });
     this.proxy = proxy;
-    const tools = this.deps.screenControl ? [...GUIDE_TOOLS, ...SCREEN_CONTROL_TOOLS] : GUIDE_TOOLS;
+    const tools = this.deps.screenControl ? [...GUIDE_TOOLS.filter((t) => t.name === "end_call"), ...SCREEN_CONTROL_TOOLS] : GUIDE_TOOLS;
     proxy.setTools(tools);
     log(`voice: tools declared (${tools.length}): ${tools.map((t) => t.name).join(", ")}`);
     orchestrator.attachProvider(proxy);
@@ -50018,7 +50219,7 @@ var VoiceControl = class {
 };
 
 // ../../packages/host-core/dist/image-gen-runner.js
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { join as join22 } from "node:path";
@@ -50281,7 +50482,7 @@ function createDaemonImageGenRunner() {
         const images = await runImageGeneration(provider, { prompt: req.prompt, providerId: id, count: req.count, inputImageB64, inputMime });
         if (!images.length)
           return { ok: false, error: "The provider returned no image." };
-        const dir2 = req.outDir ?? join22(generatedImagesDir(), randomUUID9());
+        const dir2 = req.outDir ?? join22(generatedImagesDir(), randomUUID8());
         mkdirSync9(dir2, { recursive: true });
         const files = images.map((img, i) => {
           const ext = img.mime.split("/")[1]?.split("+")[0] || "png";
@@ -50433,8 +50634,8 @@ var VOICE_GATEWAY = process.env.CCB_VOICE_GATEWAY === "1";
 
 // ../../packages/host-core/dist/fs-remote.js
 import { readdir as readdir3, readFile as readFile8, writeFile as writeFile5, mkdir as mkdir5, cp, rm, rename as renameAsync, stat as stat2 } from "node:fs/promises";
-import { openSync as openSync2, readSync, writeSync, closeSync as closeSync2, statSync as statSync4, existsSync as existsSync10, mkdtempSync, rmSync as rmSync2, readFileSync as readFileSync9, readdirSync as readdirSync3, watch, realpathSync as realpathSync2, constants as fsConstants } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
+import { openSync as openSync2, readSync, writeSync, closeSync as closeSync2, statSync as statSync4, existsSync as existsSync10, mkdtempSync, rmSync as rmSync2, readFileSync as readFileSync9, readdirSync as readdirSync4, watch, realpathSync as realpathSync2, constants as fsConstants } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename4, dirname as dirname8, join as join25, relative as relative4, resolve as resolve5, sep as sep4, isAbsolute as isAbsolute4 } from "node:path";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
@@ -50814,9 +51015,9 @@ async function renderThumbnailImpl(real, maxPx) {
     return { error: "Thumbnails are only available on macOS hosts." };
   let dir2 = null;
   try {
-    dir2 = mkdtempSync(join25(tmpdir3(), "fp-thumb-"));
+    dir2 = mkdtempSync(join25(tmpdir2(), "fp-thumb-"));
     await execFileAsync("qlmanage", ["-t", "-s", String(maxPx), "-o", dir2, real], { timeout: 1e4, killSignal: "SIGKILL" }).catch(() => void 0);
-    const produced = readdirSync3(dir2).find((f) => f.toLowerCase().endsWith(".png"));
+    const produced = readdirSync4(dir2).find((f) => f.toLowerCase().endsWith(".png"));
     if (!produced)
       return { error: "No thumbnail available." };
     return { png: readFileSync9(join25(dir2, produced)).toString("base64") };
@@ -50864,7 +51065,7 @@ function pruneTrash(root) {
     return;
   const cutoff = Date.now() - TRASH_RETENTION_MS;
   try {
-    for (const e of readdirSync3(trashDir, { withFileTypes: true })) {
+    for (const e of readdirSync4(trashDir, { withFileTypes: true })) {
       if (!e.isDirectory())
         continue;
       try {
@@ -51159,7 +51360,7 @@ async function runRemoteFsOp(root, op, args, quotaKey) {
         return [];
       try {
         const out = [];
-        for (const e of readdirSync3(trashDir, { withFileTypes: true })) {
+        for (const e of readdirSync4(trashDir, { withFileTypes: true })) {
           if (!e.isDirectory())
             continue;
           try {
@@ -52343,7 +52544,7 @@ var PeerLinkManager = class {
    * {@link openLink}) and the unsolicited responder (a peer-initiated rendezvous —
    * we just dial/listen and cache the link for the transfer engine to find).
    */
-  onServerMessage(msg, ctx) {
+  onServerMessage(msg, ctx2) {
     if (!("rid" in msg))
       return;
     const pending = this.pendingOpens.get(msg.rid);
@@ -52355,7 +52556,7 @@ var PeerLinkManager = class {
       return;
     }
     if (msg.type === "p2p:go") {
-      this.handleGo(msg).catch((e) => ctx.sendP2p({ type: "p2p:failed", rid: msg.rid, reason: e.message }));
+      this.handleGo(msg).catch((e) => ctx2.sendP2p({ type: "p2p:failed", rid: msg.rid, reason: e.message }));
     }
   }
   /**
@@ -52364,11 +52565,11 @@ var PeerLinkManager = class {
    * dialer/listener once on failure) via {@link onServerMessage}. Rejects if no
    * rung connects within the rendezvous window — NO relay fallback.
    */
-  async openLink(peerHostId, ctx) {
+  async openLink(peerHostId, ctx2) {
     const existing = this.liveLinks.get(peerHostId);
     if (existing)
       return existing;
-    this.attach(ctx);
+    this.attach(ctx2);
     await this.ensureListener();
     const myFingerprint = (await this.identity()).fingerprint256;
     const rid = randomBytes3(8).toString("hex");
@@ -52393,23 +52594,23 @@ var PeerLinkManager = class {
         // tears the rendezvous down — no role-flip) AND reject fast. NO relay fallback.
         onGo: (go) => {
           this.handleGo(go).then((l) => finish(void 0, l)).catch((e) => {
-            ctx.sendP2p({ type: "p2p:failed", rid, reason: e.message });
+            ctx2.sendP2p({ type: "p2p:failed", rid, reason: e.message });
             finish(e);
           });
         },
         onFailed: (reason) => finish(new Error(`peer-link: rendezvous failed (${reason})`))
       });
-      ctx.sendP2p({ type: "p2p:connect", rid, toHost: peerHostId, candidates: myCandidates, tlsFingerprint256: myFingerprint });
+      ctx2.sendP2p({ type: "p2p:connect", rid, toHost: peerHostId, candidates: myCandidates, tlsFingerprint256: myFingerprint });
     });
   }
   /** Install the single standing `p2p`-channel subscription (idempotent). A host
    *  that can be DRIVEN must attach at startup so it answers unsolicited rendezvous
    *  even when it never calls openLink itself. */
-  attach(ctx) {
+  attach(ctx2) {
     if (this.attached)
       return;
     this.attached = true;
-    ctx.onP2p((msg) => this.onServerMessage(msg, ctx));
+    ctx2.onP2p((msg) => this.onServerMessage(msg, ctx2));
   }
   /** Tear down all links + the listener (process shutdown / account change). */
   close() {
@@ -52467,8 +52668,8 @@ function peerLinkManager() {
   }
   return manager;
 }
-async function openPeerLink(peerHostId, ctx) {
-  return peerLinkManager().openLink(peerHostId, ctx);
+async function openPeerLink(peerHostId, ctx2) {
+  return peerLinkManager().openLink(peerHostId, ctx2);
 }
 
 // ../../packages/host-core/dist/active-link/engine.js
@@ -58006,11 +58207,11 @@ async function dispatch(msg, tools) {
       return result(id, { tools: tools.map((t) => ({ name: t.name, description: t.description, inputSchema: jsonSchema(t.schema) })) });
     case "tools/call": {
       const name = params?.name;
-      const tool8 = tools.find((t) => t.name === name);
-      if (!tool8)
+      const tool9 = tools.find((t) => t.name === name);
+      if (!tool9)
         return rpcError(id, -32602, `Unknown tool: ${name}`);
       try {
-        const out = await tool8.handler(params?.arguments ?? {});
+        const out = await tool9.handler(params?.arguments ?? {});
         return result(id, out);
       } catch (e) {
         return result(id, { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: true });
@@ -58025,7 +58226,7 @@ function startOsControlMcpEndpoint(opts) {
   });
   const allowDestructive = opts.allowDestructive ?? true;
   const tools = buildOsControlTools(opts.provider, {
-    consent: (tool8) => allowDestructive || !tool8.destructive ? true : `Refused: "${tool8.name}" changes machine state and the endpoint is in read-only mode.`
+    consent: (tool9) => allowDestructive || !tool9.destructive ? true : `Refused: "${tool9.name}" changes machine state and the endpoint is in read-only mode.`
   });
   const handle2 = async (req, res) => {
     if (!originAllowed2(req.headers.origin)) {
@@ -58632,7 +58833,7 @@ function getServiceController(instanceId) {
 
 // src/auth.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync22, rmSync as rmSync3 } from "node:fs";
 import { join as join41 } from "node:path";
 
@@ -58774,7 +58975,7 @@ async function login(opts) {
       process.exit(1);
     }
   }
-  const deviceId2 = readCredentials()?.deviceId ?? process.env.CCB_DEVICE_ID ?? randomUUID10().slice(0, 8);
+  const deviceId2 = readCredentials()?.deviceId ?? process.env.CCB_DEVICE_ID ?? randomUUID9().slice(0, 8);
   const label = opts.name ?? defaultLabel();
   if (opts.token) {
     const dt = await fetchJson(`${api}/auth/device-token`, {