@modootoday/datalab-extension-mcp 1.5.1 → 1.7.0

package/dist/{chunk-XSYBSML4.js → chunk-NYUIYZG6.js}

@@ -2,7 +2,10 @@ import {
   __export
 } from "./chunk-MLKGABMK.js";
 
-// ../mcp-server/dist/chunk-TPEUGB2T.js
+// ../mcp-server/dist/chunk-U4D7XAUO.js
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { join } from "path";
 import {
   createServer
 } from "http";
@@ -17,11 +20,12 @@ import {
   statSync
 } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 import { createConnection } from "net";
 import { spawn } from "child_process";
 import { closeSync } from "fs";
 import { createRequire } from "module";
+import { join as join3 } from "path";
 var __defProp = Object.defineProperty;
 var __export2 = (target, all) => {
   for (var name in all)
@@ -783,8 +787,8 @@ function mergeDefs(...defs) {
   }
   return Object.defineProperties({}, mergedDescriptors);
 }
-function cloneDef(schema) {
-  return mergeDefs(schema._zod.def);
+function cloneDef(schema2) {
+  return mergeDefs(schema2._zod.def);
 }
 function getElementAtPath(obj, path) {
   if (!path)
@@ -1006,14 +1010,14 @@ var BIGINT_FORMAT_RANGES = {
   int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
   uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
 };
-function pick(schema, mask) {
-  const currDef = schema._zod.def;
+function pick(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
       const newShape = {};
       for (const key in mask) {
@@ -1029,18 +1033,18 @@ function pick(schema, mask) {
     },
     checks: []
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function omit(schema, mask) {
-  const currDef = schema._zod.def;
+function omit(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const newShape = { ...schema._zod.def.shape };
+      const newShape = { ...schema2._zod.def.shape };
       for (const key in mask) {
         if (!(key in currDef.shape)) {
           throw new Error(`Unrecognized key: "${key}"`);
@@ -1054,43 +1058,43 @@ function omit(schema, mask) {
     },
     checks: []
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function extend(schema, shape) {
+function extend(schema2, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema._zod.def.checks;
+  const checks = schema2._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    const existingShape = schema._zod.def.shape;
+    const existingShape = schema2._zod.def.shape;
     for (const key in shape) {
       if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
+      const _shape = { ...schema2._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function safeExtend(schema, shape) {
+function safeExtend(schema2, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
+      const _shape = { ...schema2._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
 function merge(a, b) {
   if (a._zod.def.checks?.length) {
@@ -1109,16 +1113,16 @@ function merge(a, b) {
   });
   return clone(a, def);
 }
-function partial(Class22, schema, mask) {
-  const currDef = schema._zod.def;
+function partial(Class22, schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".partial() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema._zod.def, {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const oldShape = schema._zod.def.shape;
+      const oldShape = schema2._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -1145,12 +1149,12 @@ function partial(Class22, schema, mask) {
     },
     checks: []
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
-function required(Class22, schema, mask) {
-  const def = mergeDefs(schema._zod.def, {
+function required(Class22, schema2, mask) {
+  const def = mergeDefs(schema2._zod.def, {
     get shape() {
-      const oldShape = schema._zod.def.shape;
+      const oldShape = schema2._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -1176,7 +1180,7 @@ function required(Class22, schema, mask) {
       return shape;
     }
   });
-  return clone(schema, def);
+  return clone(schema2, def);
 }
 function aborted(x, startIndex = 0) {
   if (x.aborted === true)
@@ -1451,9 +1455,9 @@ function prettifyError(error512) {
   }
   return lines.join("\n");
 }
-var _parse = (_Err) => (schema, value, _ctx, _params) => {
+var _parse = (_Err) => (schema2, value, _ctx, _params) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
+  const result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
@@ -1465,9 +1469,9 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
   return result.value;
 };
 var parse = /* @__PURE__ */ _parse($ZodRealError);
-var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+var _parseAsync = (_Err) => async (schema2, value, _ctx, params) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   if (result.issues.length) {
@@ -1478,9 +1482,9 @@ var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   return result.value;
 };
 var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
-var _safeParse = (_Err) => (schema, value, _ctx) => {
+var _safeParse = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
+  const result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
@@ -1490,9 +1494,9 @@ var _safeParse = (_Err) => (schema, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+var _safeParseAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   return result.issues.length ? {
@@ -1501,40 +1505,40 @@ var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-var _encode = (_Err) => (schema, value, _ctx) => {
+var _encode = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parse(_Err)(schema, value, ctx);
+  return _parse(_Err)(schema2, value, ctx);
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
-var _decode = (_Err) => (schema, value, _ctx) => {
-  return _parse(_Err)(schema, value, _ctx);
+var _decode = (_Err) => (schema2, value, _ctx) => {
+  return _parse(_Err)(schema2, value, _ctx);
 };
 var decode = /* @__PURE__ */ _decode($ZodRealError);
-var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+var _encodeAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parseAsync(_Err)(schema, value, ctx);
+  return _parseAsync(_Err)(schema2, value, ctx);
 };
 var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
-var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
-  return _parseAsync(_Err)(schema, value, _ctx);
+var _decodeAsync = (_Err) => async (schema2, value, _ctx) => {
+  return _parseAsync(_Err)(schema2, value, _ctx);
 };
 var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
-var _safeEncode = (_Err) => (schema, value, _ctx) => {
+var _safeEncode = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParse(_Err)(schema, value, ctx);
+  return _safeParse(_Err)(schema2, value, ctx);
 };
 var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
-var _safeDecode = (_Err) => (schema, value, _ctx) => {
-  return _safeParse(_Err)(schema, value, _ctx);
+var _safeDecode = (_Err) => (schema2, value, _ctx) => {
+  return _safeParse(_Err)(schema2, value, _ctx);
 };
 var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
-var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+var _safeEncodeAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParseAsync(_Err)(schema, value, ctx);
+  return _safeParseAsync(_Err)(schema2, value, ctx);
 };
 var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
-var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
-  return _safeParseAsync(_Err)(schema, value, _ctx);
+var _safeDecodeAsync = (_Err) => async (schema2, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema2, value, _ctx);
 };
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 var regexes_exports = {};
@@ -3100,9 +3104,9 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     for (const key of normalized.keys) {
       const id = ids[key];
       const k = esc(key);
-      const schema = shape[key];
-      const isOptionalIn = schema?._zod?.optin === "optional";
-      const isOptionalOut = schema?._zod?.optout === "optional";
+      const schema2 = shape[key];
+      const isOptionalIn = schema2?._zod?.optin === "optional";
+      const isOptionalOut = schema2?._zod?.optout === "optional";
       doc.write(`const ${id} = ${parseStr(key)};`);
       if (isOptionalIn && isOptionalOut) {
         doc.write(`
@@ -10227,11 +10231,11 @@ var $ZodRegistry = class {
     this._map = /* @__PURE__ */ new WeakMap();
     this._idmap = /* @__PURE__ */ new Map();
   }
-  add(schema, ..._meta) {
+  add(schema2, ..._meta) {
     const meta32 = _meta[0];
-    this._map.set(schema, meta32);
+    this._map.set(schema2, meta32);
     if (meta32 && typeof meta32 === "object" && "id" in meta32) {
-      this._idmap.set(meta32.id, schema);
+      this._idmap.set(meta32.id, schema2);
     }
     return this;
   }
@@ -10240,26 +10244,26 @@ var $ZodRegistry = class {
     this._idmap = /* @__PURE__ */ new Map();
     return this;
   }
-  remove(schema) {
-    const meta32 = this._map.get(schema);
+  remove(schema2) {
+    const meta32 = this._map.get(schema2);
     if (meta32 && typeof meta32 === "object" && "id" in meta32) {
       this._idmap.delete(meta32.id);
     }
-    this._map.delete(schema);
+    this._map.delete(schema2);
     return this;
   }
-  get(schema) {
-    const p = schema._zod.parent;
+  get(schema2) {
+    const p = schema2._zod.parent;
     if (p) {
       const pm = { ...this.get(p) ?? {} };
       delete pm.id;
-      const f = { ...pm, ...this._map.get(schema) };
+      const f = { ...pm, ...this._map.get(schema2) };
       return Object.keys(f).length ? f : void 0;
     }
-    return this._map.get(schema);
+    return this._map.get(schema2);
   }
-  has(schema) {
-    return this._map.has(schema);
+  has(schema2) {
+    return this._map.has(schema2);
   }
 };
 function registry() {
@@ -10910,11 +10914,11 @@ function _endsWith(suffix, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _property(property, schema, params) {
+function _property(property, schema2, params) {
   return new $ZodCheckProperty({
     check: "property",
     property,
-    schema,
+    schema: schema2,
     ...normalizeParams(params)
   });
 }
@@ -11162,23 +11166,23 @@ function _promise(Class22, innerType) {
 function _custom(Class22, fn, _params) {
   const norm = normalizeParams(_params);
   norm.abort ?? (norm.abort = true);
-  const schema = new Class22({
+  const schema2 = new Class22({
     type: "custom",
     check: "custom",
     fn,
     ...norm
   });
-  return schema;
+  return schema2;
 }
 // @__NO_SIDE_EFFECTS__
 function _refine(Class22, fn, _params) {
-  const schema = new Class22({
+  const schema2 = new Class22({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams(_params)
   });
-  return schema;
+  return schema2;
 }
 // @__NO_SIDE_EFFECTS__
 function _superRefine(fn, params) {
@@ -11325,40 +11329,40 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema2, ctx, _params = { path: [], schemaPath: [] }) {
   var _a32;
-  const def = schema._zod.def;
-  const seen = ctx.seen.get(schema);
+  const def = schema2._zod.def;
+  const seen = ctx.seen.get(schema2);
   if (seen) {
     seen.count++;
-    const isCycle = _params.schemaPath.includes(schema);
+    const isCycle = _params.schemaPath.includes(schema2);
     if (isCycle) {
       seen.cycle = _params.path;
     }
     return seen.schema;
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema, result);
-  const overrideSchema = schema._zod.toJSONSchema?.();
+  ctx.seen.set(schema2, result);
+  const overrideSchema = schema2._zod.toJSONSchema?.();
   if (overrideSchema) {
     result.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
-      schemaPath: [..._params.schemaPath, schema],
+      schemaPath: [..._params.schemaPath, schema2],
       path: _params.path
     };
-    if (schema._zod.processJSONSchema) {
-      schema._zod.processJSONSchema(ctx, result.schema, params);
+    if (schema2._zod.processJSONSchema) {
+      schema2._zod.processJSONSchema(ctx, result.schema, params);
     } else {
       const _json = result.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
       }
-      processor(schema, ctx, _json, params);
+      processor(schema2, ctx, _json, params);
     }
-    const parent = schema._zod.parent;
+    const parent = schema2._zod.parent;
     if (parent) {
       if (!result.ref)
         result.ref = parent;
@@ -11366,21 +11370,21 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta32 = ctx.metadataRegistry.get(schema);
+  const meta32 = ctx.metadataRegistry.get(schema2);
   if (meta32)
     Object.assign(result.schema, meta32);
-  if (ctx.io === "input" && isTransforming(schema)) {
+  if (ctx.io === "input" && isTransforming(schema2)) {
     delete result.schema.examples;
     delete result.schema.default;
   }
   if (ctx.io === "input" && "_prefault" in result.schema)
     (_a32 = result.schema).default ?? (_a32.default = result.schema._prefault);
   delete result.schema._prefault;
-  const _result = ctx.seen.get(schema);
+  const _result = ctx.seen.get(schema2);
   return _result.schema;
 }
-function extractDefs(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function extractDefs(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
@@ -11423,11 +11427,11 @@ function extractDefs(ctx, schema) {
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
-    const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    const schema3 = seen.schema;
+    for (const key in schema3) {
+      delete schema3[key];
     }
-    schema2.$ref = ref;
+    schema3.$ref = ref;
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
@@ -11441,13 +11445,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
-    if (schema === entry[0]) {
+    if (schema2 === entry[0]) {
       extractToDef(entry);
       continue;
     }
     if (ctx.external) {
       const ext = ctx.external.registry.get(entry[0])?.id;
-      if (schema !== entry[0] && ext) {
+      if (schema2 !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
@@ -11469,16 +11473,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
 }
-function finalize(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function finalize(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
     if (seen.ref === null)
       return;
-    const schema2 = seen.def ?? seen.schema;
-    const _cached = { ...schema2 };
+    const schema3 = seen.def ?? seen.schema;
+    const _cached = { ...schema3 };
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
@@ -11486,28 +11490,28 @@ function finalize(ctx, schema) {
       const refSeen = ctx.seen.get(ref);
       const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
-        schema2.allOf = schema2.allOf ?? [];
-        schema2.allOf.push(refSchema);
+        schema3.allOf = schema3.allOf ?? [];
+        schema3.allOf.push(refSchema);
       } else {
-        Object.assign(schema2, refSchema);
+        Object.assign(schema3, refSchema);
       }
-      Object.assign(schema2, _cached);
+      Object.assign(schema3, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
           if (!(key in _cached)) {
-            delete schema2[key];
+            delete schema3[key];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key in refSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema3[key];
           }
         }
       }
@@ -11517,13 +11521,13 @@ function finalize(ctx, schema) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
-        schema2.$ref = parentSeen.schema.$ref;
+        schema3.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
+          for (const key in schema3) {
             if (key === "$ref" || key === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key in parentSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema3[key];
             }
           }
         }
@@ -11531,7 +11535,7 @@ function finalize(ctx, schema) {
     }
     ctx.override({
       zodSchema,
-      jsonSchema: schema2,
+      jsonSchema: schema3,
       path: seen.path ?? []
     });
   };
@@ -11549,13 +11553,13 @@ function finalize(ctx, schema) {
   } else {
   }
   if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema)?.id;
+    const id = ctx.external.registry.get(schema2)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id);
   }
   Object.assign(result, root.def ?? root.schema);
-  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+  const rootMetaId = ctx.metadataRegistry.get(schema2)?.id;
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
   const defs = ctx.external?.defs ?? {};
@@ -11581,10 +11585,10 @@ function finalize(ctx, schema) {
     const finalized = JSON.parse(JSON.stringify(result));
     Object.defineProperty(finalized, "~standard", {
       value: {
-        ...schema["~standard"],
+        ...schema2["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod(schema2, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema2, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -11648,18 +11652,18 @@ function isTransforming(_schema, _ctx) {
   }
   return false;
 }
-var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
+var createToJSONSchemaMethod = (schema2, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process2(schema, ctx);
-  extractDefs(ctx, schema);
-  return finalize(ctx, schema);
+  process2(schema2, ctx);
+  extractDefs(ctx, schema2);
+  return finalize(ctx, schema2);
 };
-var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
+var createStandardJSONSchemaMethod = (schema2, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process2(schema, ctx);
-  extractDefs(ctx, schema);
-  return finalize(ctx, schema);
+  process2(schema2, ctx);
+  extractDefs(ctx, schema2);
+  return finalize(ctx, schema2);
 };
 var formatMap = {
   guid: "uuid",
@@ -11669,10 +11673,10 @@ var formatMap = {
   regex: ""
   // do not set
 };
-var stringProcessor = (schema, ctx, _json, _params) => {
+var stringProcessor = (schema2, ctx, _json, _params) => {
   const json32 = _json;
   json32.type = "string";
-  const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+  const { minimum, maximum, format, patterns, contentEncoding } = schema2._zod.bag;
   if (typeof minimum === "number")
     json32.minLength = minimum;
   if (typeof maximum === "number")
@@ -11701,9 +11705,9 @@ var stringProcessor = (schema, ctx, _json, _params) => {
     }
   }
 };
-var numberProcessor = (schema, ctx, _json, _params) => {
+var numberProcessor = (schema2, ctx, _json, _params) => {
   const json32 = _json;
-  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema2._zod.bag;
   if (typeof format === "string" && format.includes("int"))
     json32.type = "integer";
   else
@@ -11778,8 +11782,8 @@ var dateProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-var enumProcessor = (schema, _ctx, json32, _params) => {
-  const def = schema._zod.def;
+var enumProcessor = (schema2, _ctx, json32, _params) => {
+  const def = schema2._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v) => typeof v === "number"))
     json32.type = "number";
@@ -11787,8 +11791,8 @@ var enumProcessor = (schema, _ctx, json32, _params) => {
     json32.type = "string";
   json32.enum = values;
 };
-var literalProcessor = (schema, ctx, json32, _params) => {
-  const def = schema._zod.def;
+var literalProcessor = (schema2, ctx, json32, _params) => {
+  const def = schema2._zod.def;
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
@@ -11832,22 +11836,22 @@ var nanProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-var templateLiteralProcessor = (schema, _ctx, json32, _params) => {
+var templateLiteralProcessor = (schema2, _ctx, json32, _params) => {
   const _json = json32;
-  const pattern = schema._zod.pattern;
+  const pattern = schema2._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx, json32, _params) => {
+var fileProcessor = (schema2, _ctx, json32, _params) => {
   const _json = json32;
   const file22 = {
     type: "string",
     format: "binary",
     contentEncoding: "binary"
   };
-  const { minimum, maximum, mime } = schema._zod.bag;
+  const { minimum, maximum, mime } = schema2._zod.bag;
   if (minimum !== void 0)
     file22.minLength = minimum;
   if (maximum !== void 0)
@@ -11892,10 +11896,10 @@ var setProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Set cannot be represented in JSON Schema");
   }
 };
-var arrayProcessor = (schema, ctx, _json, params) => {
+var arrayProcessor = (schema2, ctx, _json, params) => {
   const json32 = _json;
-  const def = schema._zod.def;
-  const { minimum, maximum } = schema._zod.bag;
+  const def = schema2._zod.def;
+  const { minimum, maximum } = schema2._zod.bag;
   if (typeof minimum === "number")
     json32.minItems = minimum;
   if (typeof maximum === "number")
@@ -11906,9 +11910,9 @@ var arrayProcessor = (schema, ctx, _json, params) => {
     path: [...params.path, "items"]
   });
 };
-var objectProcessor = (schema, ctx, _json, params) => {
+var objectProcessor = (schema2, ctx, _json, params) => {
   const json32 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json32.type = "object";
   json32.properties = {};
   const shape = def.shape;
@@ -11942,8 +11946,8 @@ var objectProcessor = (schema, ctx, _json, params) => {
     });
   }
 };
-var unionProcessor = (schema, ctx, json32, params) => {
-  const def = schema._zod.def;
+var unionProcessor = (schema2, ctx, json32, params) => {
+  const def = schema2._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
@@ -11955,8 +11959,8 @@ var unionProcessor = (schema, ctx, json32, params) => {
     json32.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json32, params) => {
-  const def = schema._zod.def;
+var intersectionProcessor = (schema2, ctx, json32, params) => {
+  const def = schema2._zod.def;
   const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
@@ -11972,9 +11976,9 @@ var intersectionProcessor = (schema, ctx, json32, params) => {
   ];
   json32.allOf = allOf;
 };
-var tupleProcessor = (schema, ctx, _json, params) => {
+var tupleProcessor = (schema2, ctx, _json, params) => {
   const json32 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json32.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";
@@ -12008,15 +12012,15 @@ var tupleProcessor = (schema, ctx, _json, params) => {
       json32.additionalItems = rest;
     }
   }
-  const { minimum, maximum } = schema._zod.bag;
+  const { minimum, maximum } = schema2._zod.bag;
   if (typeof minimum === "number")
     json32.minItems = minimum;
   if (typeof maximum === "number")
     json32.maxItems = maximum;
 };
-var recordProcessor = (schema, ctx, _json, params) => {
+var recordProcessor = (schema2, ctx, _json, params) => {
   const json32 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json32.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
@@ -12050,10 +12054,10 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   }
 };
-var nullableProcessor = (schema, ctx, json32, params) => {
-  const def = schema._zod.def;
+var nullableProcessor = (schema2, ctx, json32, params) => {
+  const def = schema2._zod.def;
   const inner = process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
     json32.nullable = true;
@@ -12061,31 +12065,31 @@ var nullableProcessor = (schema, ctx, json32, params) => {
     json32.anyOf = [inner, { type: "null" }];
   }
 };
-var nonoptionalProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var nonoptionalProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var defaultProcessor = (schema, ctx, json32, params) => {
-  const def = schema._zod.def;
+var defaultProcessor = (schema2, ctx, json32, params) => {
+  const def = schema2._zod.def;
   process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   json32.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var prefaultProcessor = (schema, ctx, json32, params) => {
-  const def = schema._zod.def;
+var prefaultProcessor = (schema2, ctx, json32, params) => {
+  const def = schema2._zod.def;
   process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   if (ctx.io === "input")
     json32._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var catchProcessor = (schema, ctx, json32, params) => {
-  const def = schema._zod.def;
+var catchProcessor = (schema2, ctx, json32, params) => {
+  const def = schema2._zod.def;
   process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   let catchValue;
   try {
@@ -12095,37 +12099,37 @@ var catchProcessor = (schema, ctx, json32, params) => {
   }
   json32.default = catchValue;
 };
-var pipeProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var pipeProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._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 seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json32, params) => {
-  const def = schema._zod.def;
+var readonlyProcessor = (schema2, ctx, json32, params) => {
+  const def = schema2._zod.def;
   process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   json32.readOnly = true;
 };
-var promiseProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var promiseProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var optionalProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var optionalProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process2(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var lazyProcessor = (schema, ctx, _json, params) => {
-  const innerType = schema._zod.innerType;
+var lazyProcessor = (schema2, ctx, _json, params) => {
+  const innerType = schema2._zod.innerType;
   process2(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
 var allProcessors = {
@@ -12175,8 +12179,8 @@ function toJSONSchema(input, params) {
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry of registry22._idmap.entries()) {
-      const [_, schema] = entry;
-      process2(schema, ctx2);
+      const [_, schema2] = entry;
+      process2(schema2, ctx2);
     }
     const schemas = {};
     const external = {
@@ -12186,9 +12190,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry of registry22._idmap.entries()) {
-      const [key, schema] = entry;
-      extractDefs(ctx2, schema);
-      schemas[key] = finalize(ctx2, schema);
+      const [key, schema2] = entry;
+      extractDefs(ctx2, schema2);
+      schemas[key] = finalize(ctx2, schema2);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -12254,14 +12258,14 @@ var JSONSchemaGenerator = class {
    * Process a schema to prepare it for JSON Schema generation.
    * This must be called before emit().
    */
-  process(schema, _params = { path: [], schemaPath: [] }) {
-    return process2(schema, this.ctx, _params);
+  process(schema2, _params = { path: [], schemaPath: [] }) {
+    return process2(schema2, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
    * Must call process() first.
    */
-  emit(schema, _params) {
+  emit(schema2, _params) {
     if (_params) {
       if (_params.cycles)
         this.ctx.cycles = _params.cycles;
@@ -12270,8 +12274,8 @@ var JSONSchemaGenerator = class {
       if (_params.external)
         this.ctx.external = _params.external;
     }
-    extractDefs(this.ctx, schema);
-    const result = finalize(this.ctx, schema);
+    extractDefs(this.ctx, schema2);
+    const result = finalize(this.ctx, schema2);
     const { "~standard": _, ...plainResult } = result;
     return plainResult;
   }
@@ -13222,8 +13226,8 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 function array(element, params) {
   return /* @__PURE__ */ _array(ZodArray, element, params);
 }
-function keyof(schema) {
-  const shape = schema._zod.def.shape;
+function keyof(schema2) {
+  const shape = schema2._zod.def.shape;
   return _enum2(Object.keys(shape));
 }
 var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
@@ -13848,11 +13852,11 @@ function json(params) {
   });
   return jsonSchema;
 }
-function preprocess(fn, schema) {
+function preprocess(fn, schema2) {
   return new ZodPreprocess({
     type: "pipe",
     in: transform(fn),
-    out: schema
+    out: schema2
   });
 }
 var ZodIssueCode = {
@@ -13955,8 +13959,8 @@ var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
   "nullable",
   "readOnly"
 ]);
-function detectVersion(schema, defaultTarget) {
-  const $schema = schema.$schema;
+function detectVersion(schema2, defaultTarget) {
+  const $schema = schema2.$schema;
   if ($schema === "https://json-schema.org/draft/2020-12/schema") {
     return "draft-2020-12";
   }
@@ -13986,27 +13990,27 @@ function resolveRef(ref, ctx) {
   }
   throw new Error(`Reference not found: ${ref}`);
 }
-function convertBaseSchema(schema, ctx) {
-  if (schema.not !== void 0) {
-    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
+function convertBaseSchema(schema2, ctx) {
+  if (schema2.not !== void 0) {
+    if (typeof schema2.not === "object" && Object.keys(schema2.not).length === 0) {
       return z.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
-  if (schema.unevaluatedItems !== void 0) {
+  if (schema2.unevaluatedItems !== void 0) {
     throw new Error("unevaluatedItems is not supported");
   }
-  if (schema.unevaluatedProperties !== void 0) {
+  if (schema2.unevaluatedProperties !== void 0) {
     throw new Error("unevaluatedProperties is not supported");
   }
-  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
+  if (schema2.if !== void 0 || schema2.then !== void 0 || schema2.else !== void 0) {
     throw new Error("Conditional schemas (if/then/else) are not supported");
   }
-  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
+  if (schema2.dependentSchemas !== void 0 || schema2.dependentRequired !== void 0) {
     throw new Error("dependentSchemas and dependentRequired are not supported");
   }
-  if (schema.$ref) {
-    const refPath = schema.$ref;
+  if (schema2.$ref) {
+    const refPath = schema2.$ref;
     if (ctx.refs.has(refPath)) {
       return ctx.refs.get(refPath);
     }
@@ -14025,9 +14029,9 @@ function convertBaseSchema(schema, ctx) {
     ctx.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 (schema2.enum !== void 0) {
+    const enumValues = schema2.enum;
+    if (ctx.version === "openapi-3.0" && schema2.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
       return z.null();
     }
     if (enumValues.length === 0) {
@@ -14045,13 +14049,13 @@ function convertBaseSchema(schema, ctx) {
     }
     return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (schema.const !== void 0) {
-    return z.literal(schema.const);
+  if (schema2.const !== void 0) {
+    return z.literal(schema2.const);
   }
-  const type = schema.type;
+  const type = schema2.type;
   if (Array.isArray(type)) {
     const typeSchemas = type.map((t) => {
-      const typeSchema = { ...schema, type: t };
+      const typeSchema = { ...schema2, type: t };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -14069,8 +14073,8 @@ function convertBaseSchema(schema, ctx) {
   switch (type) {
     case "string": {
       let stringSchema = z.string();
-      if (schema.format) {
-        const format = schema.format;
+      if (schema2.format) {
+        const format = schema2.format;
         if (format === "email") {
           stringSchema = stringSchema.check(z.email());
         } else if (format === "uri" || format === "uri-reference") {
@@ -14119,14 +14123,14 @@ function convertBaseSchema(schema, ctx) {
           stringSchema = stringSchema.check(z.ksuid());
         }
       }
-      if (typeof schema.minLength === "number") {
-        stringSchema = stringSchema.min(schema.minLength);
+      if (typeof schema2.minLength === "number") {
+        stringSchema = stringSchema.min(schema2.minLength);
       }
-      if (typeof schema.maxLength === "number") {
-        stringSchema = stringSchema.max(schema.maxLength);
+      if (typeof schema2.maxLength === "number") {
+        stringSchema = stringSchema.max(schema2.maxLength);
       }
-      if (schema.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+      if (schema2.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema2.pattern));
       }
       zodSchema = stringSchema;
       break;
@@ -14134,24 +14138,24 @@ function convertBaseSchema(schema, ctx) {
     case "number":
     case "integer": {
       let numberSchema = type === "integer" ? z.number().int() : z.number();
-      if (typeof schema.minimum === "number") {
-        numberSchema = numberSchema.min(schema.minimum);
+      if (typeof schema2.minimum === "number") {
+        numberSchema = numberSchema.min(schema2.minimum);
       }
-      if (typeof schema.maximum === "number") {
-        numberSchema = numberSchema.max(schema.maximum);
+      if (typeof schema2.maximum === "number") {
+        numberSchema = numberSchema.max(schema2.maximum);
       }
-      if (typeof schema.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
-      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
-        numberSchema = numberSchema.gt(schema.minimum);
+      if (typeof schema2.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema2.exclusiveMinimum);
+      } else if (schema2.exclusiveMinimum === true && typeof schema2.minimum === "number") {
+        numberSchema = numberSchema.gt(schema2.minimum);
       }
-      if (typeof schema.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
-      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
-        numberSchema = numberSchema.lt(schema.maximum);
+      if (typeof schema2.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema2.exclusiveMaximum);
+      } else if (schema2.exclusiveMaximum === true && typeof schema2.maximum === "number") {
+        numberSchema = numberSchema.lt(schema2.maximum);
       }
-      if (typeof schema.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema.multipleOf);
+      if (typeof schema2.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema2.multipleOf);
       }
       zodSchema = numberSchema;
       break;
@@ -14166,15 +14170,15 @@ function convertBaseSchema(schema, ctx) {
     }
     case "object": {
       const shape = {};
-      const properties = schema.properties || {};
-      const requiredSet = new Set(schema.required || []);
+      const properties = schema2.properties || {};
+      const requiredSet = new Set(schema2.required || []);
       for (const [key, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
         shape[key] = requiredSet.has(key) ? 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();
+      if (schema2.propertyNames) {
+        const keySchema = convertSchema(schema2.propertyNames, ctx);
+        const valueSchema = schema2.additionalProperties && typeof schema2.additionalProperties === "object" ? convertSchema(schema2.additionalProperties, ctx) : z.any();
         if (Object.keys(shape).length === 0) {
           zodSchema = z.record(keySchema, valueSchema);
           break;
@@ -14184,8 +14188,8 @@ function convertBaseSchema(schema, ctx) {
         zodSchema = z.intersection(objectSchema2, recordSchema);
         break;
       }
-      if (schema.patternProperties) {
-        const patternProps = schema.patternProperties;
+      if (schema2.patternProperties) {
+        const patternProps = schema2.patternProperties;
         const patternKeys = Object.keys(patternProps);
         const looseRecords = [];
         for (const pattern of patternKeys) {
@@ -14212,18 +14216,18 @@ function convertBaseSchema(schema, ctx) {
         break;
       }
       const objectSchema = z.object(shape);
-      if (schema.additionalProperties === false) {
+      if (schema2.additionalProperties === false) {
         zodSchema = objectSchema.strict();
-      } else if (typeof schema.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+      } else if (typeof schema2.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema(schema2.additionalProperties, ctx));
       } else {
         zodSchema = objectSchema.passthrough();
       }
       break;
     }
     case "array": {
-      const prefixItems = schema.prefixItems;
-      const items = schema.items;
+      const prefixItems = schema2.prefixItems;
+      const items = schema2.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;
@@ -14232,34 +14236,34 @@ function convertBaseSchema(schema, ctx) {
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        if (typeof schema2.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema2.minItems));
         }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        if (typeof schema2.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema2.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 rest = schema2.additionalItems && typeof schema2.additionalItems === "object" ? convertSchema(schema2.additionalItems, ctx) : void 0;
         if (rest) {
           zodSchema = z.tuple(tupleItems).rest(rest);
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        if (typeof schema2.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema2.minItems));
         }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        if (typeof schema2.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema2.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
         let arraySchema = z.array(element);
-        if (typeof schema.minItems === "number") {
-          arraySchema = arraySchema.min(schema.minItems);
+        if (typeof schema2.minItems === "number") {
+          arraySchema = arraySchema.min(schema2.minItems);
         }
-        if (typeof schema.maxItems === "number") {
-          arraySchema = arraySchema.max(schema.maxItems);
+        if (typeof schema2.maxItems === "number") {
+          arraySchema = arraySchema.max(schema2.maxItems);
         }
         zodSchema = arraySchema;
       } else {
@@ -14272,76 +14276,76 @@ function convertBaseSchema(schema, ctx) {
   }
   return zodSchema;
 }
-function convertSchema(schema, ctx) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
+function convertSchema(schema2, ctx) {
+  if (typeof schema2 === "boolean") {
+    return schema2 ? z.any() : z.never();
   }
-  let baseSchema = convertBaseSchema(schema, ctx);
-  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));
+  let baseSchema = convertBaseSchema(schema2, ctx);
+  const hasExplicitType = schema2.type || schema2.enum !== void 0 || schema2.const !== void 0;
+  if (schema2.anyOf && Array.isArray(schema2.anyOf)) {
+    const options = schema2.anyOf.map((s) => convertSchema(s, ctx));
     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));
+  if (schema2.oneOf && Array.isArray(schema2.oneOf)) {
+    const options = schema2.oneOf.map((s) => convertSchema(s, ctx));
     const oneOfUnion = z.xor(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    if (schema.allOf.length === 0) {
+  if (schema2.allOf && Array.isArray(schema2.allOf)) {
+    if (schema2.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      let result = hasExplicitType ? baseSchema : convertSchema(schema2.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
-      for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+      for (let i = startIdx; i < schema2.allOf.length; i++) {
+        result = z.intersection(result, convertSchema(schema2.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+  if (schema2.nullable === true && ctx.version === "openapi-3.0") {
     baseSchema = z.nullable(baseSchema);
   }
-  if (schema.readOnly === true) {
+  if (schema2.readOnly === true) {
     baseSchema = z.readonly(baseSchema);
   }
-  if (schema.default !== void 0) {
-    baseSchema = baseSchema.default(schema.default);
+  if (schema2.default !== void 0) {
+    baseSchema = baseSchema.default(schema2.default);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
   for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+    if (key in schema2) {
+      extraMeta[key] = schema2[key];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+    if (key in schema2) {
+      extraMeta[key] = schema2[key];
     }
   }
-  for (const key of Object.keys(schema)) {
+  for (const key of Object.keys(schema2)) {
     if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema[key];
+      extraMeta[key] = schema2[key];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
     ctx.registry.add(baseSchema, extraMeta);
   }
-  if (schema.description) {
-    baseSchema = baseSchema.describe(schema.description);
+  if (schema2.description) {
+    baseSchema = baseSchema.describe(schema2.description);
   }
   return baseSchema;
 }
-function fromJSONSchema(schema, params) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
+function fromJSONSchema(schema2, params) {
+  if (typeof schema2 === "boolean") {
+    return schema2 ? z.any() : z.never();
   }
   let normalized;
   try {
-    normalized = JSON.parse(JSON.stringify(schema));
+    normalized = JSON.parse(JSON.stringify(schema2));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
@@ -14464,19 +14468,24 @@ var BridgeRequestSchema = external_exports.discriminatedUnion("method", [
     args: external_exports.record(external_exports.string(), external_exports.unknown())
   })
 ]);
+var elapsedMs = external_exports.number().nonnegative().optional();
 var BridgeResultSchema = external_exports.union([
   external_exports.object({
     t: external_exports.literal("res"),
     id: external_exports.string(),
     ok: external_exports.literal(true),
-    result: external_exports.unknown()
+    result: external_exports.unknown(),
+    ms: elapsedMs
   }),
   external_exports.object({
     t: external_exports.literal("res"),
     id: external_exports.string(),
     ok: external_exports.literal(false),
     reason: external_exports.string(),
-    message: external_exports.string()
+    message: external_exports.string(),
+    // 🔴 Carried on failure too: the timing of a call that FAILED is exactly
+    // what tells a timeout apart from a refusal.
+    ms: elapsedMs
   })
 ]);
 var BridgeHeartbeatSchema = external_exports.object({
@@ -14499,7 +14508,7 @@ var BridgeUpstreamSchema = external_exports.union([
 ]);
 var UPSTREAM_FRAME_TYPES = ["res", "tools"];
 var FrameEnvelopeSchema = external_exports.object({ t: external_exports.string() });
-function classifyFrame(schema, knownTypes, raw) {
+function classifyFrame(schema2, knownTypes, raw) {
   const envelope = FrameEnvelopeSchema.safeParse(raw);
   if (!envelope.success) {
     return { kind: "malformed", message: "frame has no string `t` field" };
@@ -14507,7 +14516,7 @@ function classifyFrame(schema, knownTypes, raw) {
   if (!knownTypes.includes(envelope.data.t)) {
     return { kind: "unknown", frameType: envelope.data.t };
   }
-  const parsed = schema.safeParse(raw);
+  const parsed = schema2.safeParse(raw);
   if (!parsed.success) {
     return {
       kind: "malformed",
@@ -14833,7 +14842,12 @@ var TOOL_TIERS = Object.freeze({
   video_image_add_from_gallery: "write",
   video_scene_update: "write",
   video_background_set: "write",
-  video_canvas_resize: "write",
+  // 🔴 destructive, unlike the photo editor's same-named tool. There it
+  // retargets the page you are looking at; here the encoder reads one size off
+  // the first scene and renders the whole video at it, so one wrong value
+  // reflows every scene. Bulk is what makes it destructive, and no tool here
+  // can undo it — the agent has no undo to call.
+  video_canvas_resize: "destructive",
   video_scene_reorder: "write",
   video_text_add: "write",
   video_image_add: "write",
@@ -14869,6 +14883,12 @@ var TOOL_TIERS = Object.freeze({
   // 🔴 Insertion appends, so it never passes through the overwrite prompt; the
   // tier is the only barrier, and the user approves each image's source.
   editor_insert_image: "destructive",
+  // 🔴 destructive, and one confirm covers the whole plan on purpose. What the
+  // user approves is "make the post look like this", not each keystroke inside
+  // it — and asking per step would defeat the unattended sequence this exists
+  // for. Reach is the five document-assembly steps; the runner refuses anything
+  // else.
+  editor_apply_manifest: "destructive",
   editor_set_title: "write",
   editor_undo: "write",
   editor_replace: "destructive"
@@ -14940,7 +14960,14 @@ var REASON_POLICY = Object.freeze({
   editor_busy: Object.freeze({ retryable: false }),
   // --- The connection itself must be repaired ---
   not_connected: Object.freeze({ retryable: false }),
-  unauthorized: Object.freeze({ retryable: false })
+  unauthorized: Object.freeze({ retryable: false }),
+  // --- Staging: the request must change, except where nobody knows yet ---
+  stale_fence: Object.freeze({ retryable: false }),
+  already_sealed: Object.freeze({ retryable: false }),
+  hash_mismatch: Object.freeze({ retryable: false }),
+  upload_expired: Object.freeze({ retryable: false }),
+  capacity_unavailable: Object.freeze({ retryable: true }),
+  uploads_unproven: Object.freeze({ retryable: true })
 });
 function policyFor(reason) {
   return Object.hasOwn(REASON_POLICY, reason) ? REASON_POLICY[reason] : { retryable: false };
@@ -15066,6 +15093,9 @@ var EDITOR_CONTROL = [
   // names the tool to use instead when the body is occupied.
   "editor_place_draft",
   "editor_set_title",
+  // The whole plan in one call, for a run nobody is watching. Same group as the
+  // steps it contains — a model that reached for those should see this too.
+  "editor_apply_manifest",
   // Both act on the open draft: title_optimize proposes titles for it, and
   // internal_links reads it.
   "title_optimize",
@@ -15317,7 +15347,7 @@ function discoveryDescriptors(entries) {
 function sessionStateDescriptor() {
   return {
     name: SESSION_STATE_TOOL,
-    description: "\uC9C0\uAE08 \uC774 \uBE0C\uB77C\uC6B0\uC800\uC5D0\uC11C \uD655\uC778 \uCC3D \uC5C6\uC774 \uC5BC\uB9C8\uB098 \uB354 \uC791\uC5C5\uD560 \uC218 \uC788\uB294\uC9C0 \uC54C\uB824\uC900\uB2E4. \uC5EC\uB7EC \uBC88\uC758 \uD3B8\uC9D1\uC774\uB098 \uBC30\uCE58\uB97C \uC2DC\uC791\uD558\uAE30 \uC804\uC5D0 \uBA3C\uC800 \uBD80\uB978\uB2E4 \u2014 \uB0A8\uC740 \uC2DC\uAC04\uC774 \uC9E7\uC73C\uBA74 \uB3C4\uC911\uC5D0 \uD655\uC778 \uCC3D\uC774 \uB728\uAE30 \uC2DC\uC791\uD558\uACE0, \uC0AC\uC6A9\uC790\uAC00 \uC790\uB9AC\uC5D0 \uC5C6\uC73C\uBA74 \uAC70\uAE30\uC11C \uBA48\uCD98\uB2E4.",
+    description: "\uC9C0\uAE08 \uC774 \uBE0C\uB77C\uC6B0\uC800\uC5D0\uC11C \uD655\uC778 \uCC3D \uC5C6\uC774 \uC5BC\uB9C8\uB098 \uB354 \uC791\uC5C5\uD560 \uC218 \uC788\uB294\uC9C0, \uADF8\uB9AC\uACE0 \uC791\uC5C5\uD560 \uB300\uC0C1\uC774 \uC2E4\uC81C\uB85C \uC5F4\uB824 \uC788\uB294\uC9C0 \uC54C\uB824\uC900\uB2E4. \uC5EC\uB7EC \uBC88\uC758 \uD3B8\uC9D1\uC774\uB098 \uBC30\uCE58\uB97C \uC2DC\uC791\uD558\uAE30 \uC804\uC5D0 \uBA3C\uC800 \uBD80\uB978\uB2E4 \u2014 \uB0A8\uC740 \uC2DC\uAC04\uC774 \uC9E7\uC73C\uBA74 \uB3C4\uC911\uC5D0 \uD655\uC778 \uCC3D\uC774 \uB728\uAE30 \uC2DC\uC791\uD558\uACE0, \uC0AC\uC6A9\uC790\uAC00 \uC790\uB9AC\uC5D0 \uC5C6\uC73C\uBA74 \uAC70\uAE30\uC11C \uBA48\uCD98\uB2E4. surfaces \uB294 \uAE00\uC4F0\uAE30 \uCC3D\xB7\uC0AC\uC9C4 \uD3B8\uC9D1\uAE30\xB7\uC601\uC0C1 \uD3B8\uC9D1\uAE30\uAC00 \uAC01\uAC01 \uC900\uBE44\uB410\uB294\uC9C0 \uB9D0\uD574\uC900\uB2E4. ready \uAC00 \uC544\uB2CC \uD45C\uBA74\uC744 \uC4F0\uB294 \uACC4\uD68D\uC740 \uB9E4 \uD638\uCD9C\uC774 \uC2E4\uD328\uD558\uB2C8, \uACC4\uD68D\uC744 \uC138\uC6B0\uAE30 \uC804\uC5D0 \uD655\uC778\uD558\uACE0 \uD544\uC694\uD558\uBA74 \uC0AC\uC6A9\uC790\uC5D0\uAC8C \uC5F4\uC5B4 \uB2EC\uB77C\uACE0 \uC548\uB0B4\uD55C\uB2E4.",
     inputSchema: {
       type: "object",
       properties: {},
@@ -15632,12 +15662,17 @@ var Bridge = class {
       return;
     }
     if (frame.ok) {
-      this.#pending.settle(frame.id, { ok: true, result: frame.result });
+      this.#pending.settle(frame.id, {
+        ok: true,
+        result: frame.result,
+        ...frame.ms === void 0 ? {} : { ms: frame.ms }
+      });
     } else {
       this.#pending.settle(frame.id, {
         ok: false,
         reason: frame.reason,
-        message: frame.message
+        message: frame.message,
+        ...frame.ms === void 0 ? {} : { ms: frame.ms }
       });
     }
   }
@@ -15675,15 +15710,33 @@ var Bridge = class {
     }
     return { tools, rejected: rejected.map((r) => r.name) };
   }
-  /** Invoke a tool by name. The server never inspects or executes it. */
+  /**
+   * Invoke a tool by name. The server never inspects or executes it.
+   *
+   * 🔴 Returns timing beside the result rather than folded into it. `toolMs` is
+   * what the panel spent executing; `bridgeMs` is this whole round trip, so
+   * `bridgeMs - toolMs` is the transport and the queue. A single total cannot
+   * tell a slow tool from a slow wire, and that is the question being asked.
+   */
   async callTool(name, args) {
+    const startedAt = (this.#deps.now ?? Date.now)();
     const out = await this.#request({
       method: "tools/call",
       name,
       args
     });
-    if (!out.ok) throw new BridgeError(out.reason, out.message);
-    return out.result;
+    const bridgeMs = (this.#deps.now ?? Date.now)() - startedAt;
+    if (!out.ok) {
+      throw new BridgeError(out.reason, out.message, {
+        ...out.ms === void 0 ? {} : { toolMs: out.ms },
+        bridgeMs
+      });
+    }
+    return {
+      result: out.result,
+      ...out.ms === void 0 ? {} : { toolMs: out.ms },
+      bridgeMs
+    };
   }
   /**
    * Refill-then-take on the session's token bucket. The refill is computed
@@ -15739,12 +15792,360 @@ var Bridge = class {
 };
 var BridgeError = class extends Error {
   reason;
-  constructor(reason, message) {
+  /** Optional so every existing throw site still compiles unchanged. */
+  timing;
+  constructor(reason, message, timing) {
     super(message);
     this.name = "BridgeError";
     this.reason = reason;
+    if (timing) this.timing = timing;
+  }
+};
+var MAX_STAGE_BYTES = 10 * 1024 * 1024;
+var DEFAULT_TOKEN_TTL_MS = 30 * 60 * 1e3;
+var STAGE_CAPABILITY = "datalab-mcp-stage-v1";
+function refuse(reason, retryable, message) {
+  return { state: "REFUSED", reason, retryable, message };
+}
+function segment(...parts) {
+  return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
+}
+function createMediaStage(opts) {
+  const now = opts.now ?? Date.now;
+  const ttl = opts.tokenTtlMs ?? DEFAULT_TOKEN_TTL_MS;
+  const ledgerDir = join(opts.root, "ledger");
+  const blobDir = join(opts.root, "blob");
+  const tokens = /* @__PURE__ */ new Map();
+  const active = /* @__PURE__ */ new Map();
+  const keyOf = (j) => segment(j.blogId, j.runId, j.actionId, j.jobId);
+  const ledgerPath = (key) => join(ledgerDir, `${key}.json`);
+  const blobPath = (key) => join(blobDir, key);
+  async function readRow(key) {
+    try {
+      const raw = await readFile(ledgerPath(key), "utf8");
+      return JSON.parse(raw);
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return "unreadable";
+    }
   }
-};
+  async function writeRow(key, row) {
+    await mkdir(ledgerDir, { recursive: true });
+    await writeFile(ledgerPath(key), JSON.stringify(row), "utf8");
+  }
+  return {
+    async begin(req) {
+      const key = keyOf(req);
+      const row = await readRow(key);
+      if (row === "unreadable") {
+        return refuse("uploads_unproven", true, "\uC791\uC5C5 \uC0C1\uD0DC\uB97C \uC77D\uC9C0 \uBABB\uD588\uC5B4\uC694.");
+      }
+      if (row) {
+        if (req.fence < row.fence) {
+          return refuse(
+            "stale_fence",
+            false,
+            "\uB354 \uC0C8\uB85C\uC6B4 \uC2DC\uB3C4\uAC00 \uC774\uBBF8 \uC9C4\uD589\uB410\uC5B4\uC694."
+          );
+        }
+        if (row.state === "SEALED") {
+          return refuse("already_sealed", false, "\uC774\uBBF8 \uBD09\uC778\uB41C \uC790\uC0B0\uC774\uC5D0\uC694.");
+        }
+        if (row.state === "OPEN") {
+          for (const [token2, held] of tokens) {
+            if (held.key === key && held.expiresAt > now()) {
+              return {
+                state: "OPEN",
+                jobId: req.jobId,
+                uploadToken: token2,
+                expiresAt: held.expiresAt,
+                capabilityVersion: STAGE_CAPABILITY
+              };
+            }
+          }
+        }
+      }
+      const token = randomUUID();
+      const expiresAt = now() + ttl;
+      tokens.set(token, { key, expiresAt });
+      await writeRow(key, {
+        state: "OPEN",
+        fence: req.fence,
+        jobId: req.jobId,
+        at: now()
+      });
+      return {
+        state: "OPEN",
+        jobId: req.jobId,
+        uploadToken: token,
+        expiresAt,
+        capabilityVersion: STAGE_CAPABILITY
+      };
+    },
+    async receiveUpload(token, body) {
+      const held = tokens.get(token);
+      if (!held) return { ok: false, reason: "upload_expired" };
+      if (held.expiresAt <= now()) {
+        tokens.delete(token);
+        return { ok: false, reason: "upload_expired" };
+      }
+      active.set(held.key, (active.get(held.key) ?? 0) + 1);
+      try {
+        await mkdir(blobDir, { recursive: true });
+        const chunks = [];
+        let total = 0;
+        for await (const chunk of body) {
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          total += buf.byteLength;
+          if (total > MAX_STAGE_BYTES) {
+            return { ok: false, reason: "too_large" };
+          }
+          chunks.push(buf);
+        }
+        await writeFile(blobPath(held.key), Buffer.concat(chunks));
+        return { ok: true, bytes: total };
+      } finally {
+        const left = (active.get(held.key) ?? 1) - 1;
+        if (left <= 0) active.delete(held.key);
+        else active.set(held.key, left);
+      }
+    },
+    async commit(req) {
+      const key = keyOf(req);
+      const row = await readRow(key);
+      if (row === "unreadable") {
+        return refuse("uploads_unproven", true, "\uC791\uC5C5 \uC0C1\uD0DC\uB97C \uC77D\uC9C0 \uBABB\uD588\uC5B4\uC694.");
+      }
+      if (!row) return refuse("upload_expired", false, "\uC5F4\uB9B0 \uC790\uB9AC\uAC00 \uC5C6\uC5B4\uC694.");
+      if (req.fence < row.fence) {
+        return refuse(
+          "stale_fence",
+          false,
+          "\uB354 \uC0C8\uB85C\uC6B4 \uC2DC\uB3C4\uAC00 \uC774\uBBF8 \uC9C4\uD589\uB410\uC5B4\uC694."
+        );
+      }
+      if (row.state === "SEALED") {
+        if (row.sha256 === req.sha256 && row.handle) {
+          return {
+            state: "SEALED",
+            handle: row.handle,
+            bytes: row.bytes ?? 0,
+            sha256: row.sha256,
+            capabilityVersion: STAGE_CAPABILITY
+          };
+        }
+        return refuse("already_sealed", false, "\uC774\uBBF8 \uBD09\uC778\uB41C \uC790\uC0B0\uC774\uC5D0\uC694.");
+      }
+      let received;
+      try {
+        received = await readFile(blobPath(key));
+      } catch {
+        return refuse("upload_expired", false, "\uBC1B\uC740 \uBC14\uC774\uD2B8\uAC00 \uC5C6\uC5B4\uC694.");
+      }
+      const actual = createHash("sha256").update(received).digest("hex");
+      if (actual !== req.sha256 || received.byteLength !== req.bytes) {
+        return refuse(
+          "hash_mismatch",
+          false,
+          "\uBC1B\uC740 \uBC14\uC774\uD2B8\uAC00 \uC54C\uB824\uC8FC\uC2E0 \uAC83\uACFC \uB2EC\uB77C\uC694."
+        );
+      }
+      const handle = `stage:${key}`;
+      await writeRow(key, {
+        state: "SEALED",
+        fence: req.fence,
+        jobId: req.jobId,
+        sha256: actual,
+        bytes: received.byteLength,
+        handle,
+        at: now()
+      });
+      return {
+        state: "SEALED",
+        handle,
+        bytes: received.byteLength,
+        sha256: actual,
+        capabilityVersion: STAGE_CAPABILITY
+      };
+    },
+    async status(req) {
+      const key = keyOf(req);
+      const row = await readRow(key);
+      const base = {
+        jobId: req.jobId,
+        activeUploads: active.get(key) ?? 0,
+        capabilityVersion: STAGE_CAPABILITY
+      };
+      if (row === "unreadable") {
+        return { ...base, state: "STATE_UNKNOWN", bytesReceived: 0 };
+      }
+      let bytesReceived = 0;
+      try {
+        bytesReceived = (await readFile(blobPath(key))).byteLength;
+      } catch {
+        bytesReceived = 0;
+      }
+      if (!row) return { ...base, state: "STATE_UNKNOWN", bytesReceived };
+      return { ...base, state: row.state, bytesReceived };
+    },
+    async cancel(req) {
+      const key = keyOf(req);
+      const row = await readRow(key);
+      if (row === "unreadable") {
+        return {
+          state: "STATE_UNKNOWN",
+          reason: "uploads_unproven",
+          retryable: true
+        };
+      }
+      if (row?.state === "SEALED") {
+        return refuse("already_sealed", false, "\uC774\uBBF8 \uBD09\uC778\uB41C \uC790\uC0B0\uC774\uC5D0\uC694.");
+      }
+      if ((active.get(key) ?? 0) > 0) {
+        return {
+          state: "STATE_UNKNOWN",
+          reason: "uploads_unproven",
+          retryable: true
+        };
+      }
+      await writeRow(key, {
+        state: "CANCELLED",
+        fence: req.fence,
+        jobId: req.jobId,
+        at: now()
+      });
+      await rm(blobPath(key), { force: true });
+      return {
+        state: "CANCELLED",
+        activeUploads: 0,
+        capabilityVersion: STAGE_CAPABILITY
+      };
+    },
+    async readSealed(handle) {
+      return readFile(blobPath(handle.replace(/^stage:/, "")));
+    },
+    async assetCount() {
+      try {
+        return (await readdir(blobDir)).length;
+      } catch {
+        return 0;
+      }
+    },
+    async debugWrittenPaths() {
+      const out = [];
+      for (const dir of [ledgerDir, blobDir]) {
+        try {
+          for (const name of await readdir(dir)) out.push(join(dir, name));
+        } catch {
+        }
+      }
+      return out;
+    }
+  };
+}
+var MEDIA_TOOL_NAMES = [
+  "media_stage_begin",
+  "media_stage_commit",
+  "media_stage_status",
+  "media_stage_cancel"
+];
+function isMediaTool(name) {
+  return MEDIA_TOOL_NAMES.includes(name);
+}
+var JOB_PROPERTIES = {
+  blogId: { type: "string" },
+  runId: { type: "string" },
+  slot: { type: "string" },
+  actionId: { type: "string" },
+  fence: { type: "integer", description: "\uC2DC\uB3C4 \uBC88\uD638. \uD074\uC218\uB85D \uC0C8\uAC83" },
+  jobId: { type: "string", description: "\uC790\uC0B0 \uD558\uB098\uC758 \uC2DD\uBCC4\uC790" }
+};
+var JOB_REQUIRED = [
+  "blogId",
+  "runId",
+  "slot",
+  "actionId",
+  "fence",
+  "jobId"
+];
+var schema = (extra = {}, more = []) => ({
+  type: "object",
+  properties: { ...JOB_PROPERTIES, ...extra },
+  required: [...JOB_REQUIRED, ...more],
+  additionalProperties: false
+});
+function mediaToolDescriptors() {
+  return [
+    {
+      name: "media_stage_begin",
+      description: "\uC774\uBBF8\uC9C0\uB97C \uC62C\uB9B4 \uC790\uB9AC\uB97C \uC5F0\uB2E4. \uBC14\uC774\uD2B8\uB294 \uC5EC\uAE30\uB85C \uBCF4\uB0B4\uC9C0 \uC54A\uACE0, \uB3CC\uB824\uBC1B\uC740 uploadUrl \uC5D0 uploadToken \uC744 \uC2E4\uC5B4 \uC2A4\uD2B8\uB9BC\uC73C\uB85C \uBCF4\uB0B8\uB2E4. \uAC19\uC740 jobId \uB85C \uB2E4\uC2DC \uBD88\uB7EC\uB3C4 \uC790\uB9AC\uB294 \uD558\uB098\uB2E4.",
+      inputSchema: schema(
+        {
+          declaredBytes: { type: "integer" },
+          declaredMime: { type: "string" }
+        },
+        ["declaredBytes"]
+      )
+    },
+    {
+      name: "media_stage_commit",
+      description: "\uC62C\uB9B0 \uBC14\uC774\uD2B8\uB97C \uAC80\uC99D\uD558\uACE0 \uBD09\uC778\uD55C\uB2E4. \uBC1B\uC740 \uAC83\uC774 \uC54C\uB824\uC900 \uD574\uC2DC\xB7\uD06C\uAE30\uC640 \uB2E4\uB974\uBA74 \uBD09\uC778\uD558\uC9C0 \uC54A\uB294\uB2E4. \uAC19\uC740 \uBC14\uC774\uD2B8\uB85C \uB2E4\uC2DC \uBD80\uB974\uBA74 \uAC19\uC740 handle \uC744 \uB3CC\uB824\uC900\uB2E4.",
+      inputSchema: schema(
+        { sha256: { type: "string" }, bytes: { type: "integer" } },
+        ["sha256", "bytes"]
+      )
+    },
+    {
+      name: "media_stage_status",
+      description: "\uC774 \uC790\uC0B0\uC774 \uC9C0\uAE08 \uC5B4\uB5A4 \uC0C1\uD0DC\uC778\uC9C0 \uBB3B\uB294\uB2E4. \uC0C1\uD0DC\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC73C\uBA74 STATE_UNKNOWN \uC744 \uB3CC\uB824\uC8FC\uBA70, \uADF8\uAC83\uC740 \uC2E4\uD328\uAC00 \uC544\uB2C8\uB77C \uBAA8\uB978\uB2E4\uB294 \uB73B\uC774\uB2E4.",
+      inputSchema: schema()
+    },
+    {
+      name: "media_stage_cancel",
+      description: "\uC790\uB9AC\uB97C \uCDE8\uC18C\uD55C\uB2E4. \uC62C\uB77C\uC624\uB294 \uC911\uC778 \uC2A4\uD2B8\uB9BC\uC774 \uBAA8\uB450 \uB2EB\uD614\uC74C\uC744 \uD655\uC778\uD588\uC744 \uB54C\uB9CC \uC131\uACF5\uC774\uACE0, \uD655\uC778\uD558\uC9C0 \uBABB\uD558\uBA74 STATE_UNKNOWN \uC774\uB2E4. \uC774\uBBF8 \uBD09\uC778\uB41C \uAC83\uC740 \uCDE8\uC18C\uB418\uC9C0 \uC54A\uB294\uB2E4.",
+      inputSchema: schema()
+    }
+  ];
+}
+function jobFrom(args) {
+  const str = (k) => typeof args[k] === "string" && args[k] ? args[k] : null;
+  const blogId = str("blogId");
+  const runId = str("runId");
+  const slot = str("slot");
+  const actionId = str("actionId");
+  const jobId = str("jobId");
+  const fence = args["fence"];
+  if (!blogId || !runId || !slot || !actionId || !jobId) return null;
+  if (typeof fence !== "number" || !Number.isInteger(fence)) return null;
+  return { blogId, runId, slot, actionId, jobId, fence };
+}
+async function callMediaTool(stage, name, args) {
+  const job = jobFrom(args);
+  if (!job) {
+    return {
+      state: "REFUSED",
+      reason: "invalid_args",
+      retryable: false,
+      message: "\uC5EC\uC12F \uAC1C \uC2DD\uBCC4\uC790\uAC00 \uBAA8\uB450 \uD544\uC694\uD574\uC694.",
+      capabilityVersion: STAGE_CAPABILITY
+    };
+  }
+  switch (name) {
+    case "media_stage_begin": {
+      const declaredBytes = typeof args["declaredBytes"] === "number" ? args["declaredBytes"] : 0;
+      return stage.begin({ ...job, declaredBytes });
+    }
+    case "media_stage_commit": {
+      const sha256 = typeof args["sha256"] === "string" ? args["sha256"] : "";
+      const bytes = typeof args["bytes"] === "number" ? args["bytes"] : -1;
+      return stage.commit({ ...job, sha256, bytes });
+    }
+    case "media_stage_status":
+      return stage.status(job);
+    case "media_stage_cancel":
+      return stage.cancel(job);
+  }
+}
 var CODE_METHOD_NOT_FOUND = -32601;
 var CODE_INVALID_PARAMS = -32602;
 var CODE_INTERNAL = -32603;
@@ -15754,6 +16155,22 @@ function bridgeErrorText(err) {
   }
   return err.message;
 }
+var CAPABILITY = "datalab-mcp-timing-v1";
+function timingMeta(timing) {
+  return {
+    _meta: {
+      capabilityVersion: CAPABILITY,
+      bridgeMs: timing.bridgeMs,
+      ...timing.toolMs === void 0 ? {} : { toolMs: timing.toolMs },
+      // What the wire and the queue cost, which is the whole reason the two
+      // numbers are reported apart.
+      ...timing.toolMs === void 0 ? {} : { transportMs: Math.max(0, timing.bridgeMs - timing.toolMs) }
+    }
+  };
+}
+function ownTools(stage) {
+  return stage ? mediaToolDescriptors() : [];
+}
 function rpcToolError(id, err) {
   const policy = policyFor(err.reason);
   const payload = {
@@ -15765,7 +16182,8 @@ function rpcToolError(id, err) {
   };
   return rpcResult(id, {
     content: [{ type: "text", text: JSON.stringify(payload) }],
-    isError: true
+    isError: true,
+    ...err.timing ? timingMeta(err.timing) : {}
   });
 }
 function frameMcpResponse(payload, accept) {
@@ -15802,26 +16220,35 @@ function rpcResult(id, result) {
 function rpcError(id, code, message) {
   return { jsonrpc: "2.0", id: id ?? null, error: { code, message } };
 }
-async function handleMcpRequest(bridge, body, accept) {
+async function handleMcpRequest(bridge, body, accept, stage) {
   const req = typeof body === "object" && body !== null ? body : {};
   const id = req.id;
   const method = req.method;
   if (method === "tools/list") {
     if (!bridge.connected) {
-      if (bridge.lastKnownTools.length === 0) return coldCatalog(id, accept);
+      const own = ownTools(stage);
+      if (bridge.lastKnownTools.length === 0 && own.length === 0) {
+        return coldCatalog(id, accept);
+      }
       return frameMcpResponse(
-        rpcResult(id, { tools: bridge.lastKnownTools }),
+        rpcResult(id, { tools: [...bridge.lastKnownTools, ...own] }),
         accept
       );
     }
     try {
       const { tools } = await bridge.listTools();
-      return frameMcpResponse(rpcResult(id, { tools }), accept);
+      return frameMcpResponse(
+        rpcResult(id, { tools: [...tools, ...ownTools(stage)] }),
+        accept
+      );
     } catch (err) {
       if (err instanceof BridgeError) {
-        if (bridge.lastKnownTools.length === 0) return coldCatalog(id, accept);
+        const own = ownTools(stage);
+        if (bridge.lastKnownTools.length === 0 && own.length === 0) {
+          return coldCatalog(id, accept);
+        }
         return frameMcpResponse(
-          rpcResult(id, { tools: bridge.lastKnownTools }),
+          rpcResult(id, { tools: [...bridge.lastKnownTools, ...own] }),
           accept
         );
       }
@@ -15838,11 +16265,26 @@ async function handleMcpRequest(bridge, body, accept) {
       );
     }
     const args = typeof params.arguments === "object" && params.arguments !== null ? params.arguments : {};
+    if (stage && isMediaTool(params.name)) {
+      const startedAt = Date.now();
+      const result = await callMediaTool(stage, params.name, args);
+      return frameMcpResponse(
+        rpcResult(id, {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          ...timingMeta({
+            toolMs: Date.now() - startedAt,
+            bridgeMs: Date.now() - startedAt
+          })
+        }),
+        accept
+      );
+    }
     try {
-      const result = await bridge.callTool(params.name, args);
+      const call = await bridge.callTool(params.name, args);
       return frameMcpResponse(
         rpcResult(id, {
-          content: [{ type: "text", text: JSON.stringify(result) }]
+          content: [{ type: "text", text: JSON.stringify(call.result) }],
+          ...timingMeta(call)
         }),
         accept
       );
@@ -16031,11 +16473,23 @@ function createHttpBridge(opts) {
     const origin = req.headers.origin;
     if (req.method === "POST" && url22.pathname === "/mcp") {
       lifecycle?.bump?.();
-      void readJson(req, MAX_MCP_BODY_BYTES2).then((body) => handleMcpRequest(opts.bridge, body, req.headers.accept)).catch(
+      void readJson(req, MAX_MCP_BODY_BYTES2).then(
+        (body) => handleMcpRequest(
+          opts.bridge,
+          body,
+          req.headers.accept,
+          opts.mediaStage
+        )
+      ).catch(
         () => (
           // An unparseable or oversized body still owes a JSON-RPC answer, not
           // a dropped socket; a null body routes through as method-not-found.
-          handleMcpRequest(opts.bridge, null, req.headers.accept)
+          handleMcpRequest(
+            opts.bridge,
+            null,
+            req.headers.accept,
+            opts.mediaStage
+          )
         )
       ).then((out) => {
         writeSafely(res, out.status, out.headers, out.body);
@@ -16159,6 +16613,33 @@ function createHttpBridge(opts) {
       });
       return;
     }
+    if (req.method === "POST" && url22.pathname === "/media/upload") {
+      const stage = opts.mediaStage;
+      if (!stage) {
+        json2(res, 404, { error: "not found" });
+        return;
+      }
+      const auth = req.headers.authorization ?? "";
+      const token = auth.startsWith("Bearer ") ? auth.slice(7).trim() : "";
+      if (!token) {
+        json2(res, 403, { error: "unauthorized" });
+        return;
+      }
+      void stage.receiveUpload(token, req).then((out) => {
+        if (out.ok) {
+          json2(res, 202, { ok: true, bytes: out.bytes });
+          return;
+        }
+        const status = out.reason === "upload_expired" ? 403 : 400;
+        json2(res, status, { error: out.reason });
+      }).catch((err) => {
+        opts.log?.(
+          `media upload failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        json2(res, 500, { error: "upload_failed" });
+      });
+      return;
+    }
     if (req.method === "POST" && url22.pathname === "/bridge/result") {
       if (!opts.bridge.connected) {
         json2(res, 403, { error: "handshake required" });
@@ -16279,10 +16760,10 @@ var LOG_MAX_BYTES = 1024 * 1024;
 var DIR_NAME = ".datalab-mcp";
 var FILE_NAME = "connector.log";
 function logDir(home = homedir()) {
-  return join(home, DIR_NAME);
+  return join2(home, DIR_NAME);
 }
 function logPath(home = homedir()) {
-  return join(logDir(home), FILE_NAME);
+  return join2(logDir(home), FILE_NAME);
 }
 function rolledLogPath(home = homedir()) {
   return `${logPath(home)}.1`;
@@ -16458,10 +16939,12 @@ function runDaemon(env, deps = {}) {
     rateLimit: deps.rateLimit,
     log
   });
+  const mediaStage = createMediaStage({ root: join3(logDir(), "media") });
   const http = createHttpBridge({
     bridge,
     port,
     host,
+    mediaStage,
     heartbeatMs: deps.heartbeatMs,
     identity: { name: NAME, version: version22 },
     log,
@@ -17283,8 +17766,8 @@ function mergeDefs2(...defs) {
   }
   return Object.defineProperties({}, mergedDescriptors);
 }
-function cloneDef2(schema) {
-  return mergeDefs2(schema._zod.def);
+function cloneDef2(schema2) {
+  return mergeDefs2(schema2._zod.def);
 }
 function getElementAtPath2(obj, path) {
   if (!path)
@@ -17506,14 +17989,14 @@ var BIGINT_FORMAT_RANGES2 = {
   int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
   uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
 };
-function pick2(schema, mask) {
-  const currDef = schema._zod.def;
+function pick2(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs2(schema._zod.def, {
+  const def = mergeDefs2(schema2._zod.def, {
     get shape() {
       const newShape = {};
       for (const key in mask) {
@@ -17529,18 +18012,18 @@ function pick2(schema, mask) {
     },
     checks: []
   });
-  return clone2(schema, def);
+  return clone2(schema2, def);
 }
-function omit2(schema, mask) {
-  const currDef = schema._zod.def;
+function omit2(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs2(schema._zod.def, {
+  const def = mergeDefs2(schema2._zod.def, {
     get shape() {
-      const newShape = { ...schema._zod.def.shape };
+      const newShape = { ...schema2._zod.def.shape };
       for (const key in mask) {
         if (!(key in currDef.shape)) {
           throw new Error(`Unrecognized key: "${key}"`);
@@ -17554,43 +18037,43 @@ function omit2(schema, mask) {
     },
     checks: []
   });
-  return clone2(schema, def);
+  return clone2(schema2, def);
 }
-function extend2(schema, shape) {
+function extend2(schema2, shape) {
   if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema._zod.def.checks;
+  const checks = schema2._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    const existingShape = schema._zod.def.shape;
+    const existingShape = schema2._zod.def.shape;
     for (const key in shape) {
       if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
   }
-  const def = mergeDefs2(schema._zod.def, {
+  const def = mergeDefs2(schema2._zod.def, {
     get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
+      const _shape = { ...schema2._zod.def.shape, ...shape };
       assignProp2(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone2(schema, def);
+  return clone2(schema2, def);
 }
-function safeExtend2(schema, shape) {
+function safeExtend2(schema2, shape) {
   if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = mergeDefs2(schema._zod.def, {
+  const def = mergeDefs2(schema2._zod.def, {
     get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
+      const _shape = { ...schema2._zod.def.shape, ...shape };
       assignProp2(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone2(schema, def);
+  return clone2(schema2, def);
 }
 function merge2(a, b) {
   if (a._zod.def.checks?.length) {
@@ -17609,16 +18092,16 @@ function merge2(a, b) {
   });
   return clone2(a, def);
 }
-function partial2(Class3, schema, mask) {
-  const currDef = schema._zod.def;
+function partial2(Class3, schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".partial() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs2(schema._zod.def, {
+  const def = mergeDefs2(schema2._zod.def, {
     get shape() {
-      const oldShape = schema._zod.def.shape;
+      const oldShape = schema2._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -17645,12 +18128,12 @@ function partial2(Class3, schema, mask) {
     },
     checks: []
   });
-  return clone2(schema, def);
+  return clone2(schema2, def);
 }
-function required2(Class3, schema, mask) {
-  const def = mergeDefs2(schema._zod.def, {
+function required2(Class3, schema2, mask) {
+  const def = mergeDefs2(schema2._zod.def, {
     get shape() {
-      const oldShape = schema._zod.def.shape;
+      const oldShape = schema2._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -17676,7 +18159,7 @@ function required2(Class3, schema, mask) {
       return shape;
     }
   });
-  return clone2(schema, def);
+  return clone2(schema2, def);
 }
 function aborted2(x, startIndex = 0) {
   if (x.aborted === true)
@@ -17955,9 +18438,9 @@ function prettifyError2(error101) {
 }
 
 // ../node_modules/zod/v4/core/parse.js
-var _parse2 = (_Err) => (schema, value, _ctx, _params) => {
+var _parse2 = (_Err) => (schema2, value, _ctx, _params) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
+  const result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError2();
   }
@@ -17969,9 +18452,9 @@ var _parse2 = (_Err) => (schema, value, _ctx, _params) => {
   return result.value;
 };
 var parse3 = /* @__PURE__ */ _parse2($ZodRealError2);
-var _parseAsync2 = (_Err) => async (schema, value, _ctx, params) => {
+var _parseAsync2 = (_Err) => async (schema2, value, _ctx, params) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   if (result.issues.length) {
@@ -17982,9 +18465,9 @@ var _parseAsync2 = (_Err) => async (schema, value, _ctx, params) => {
   return result.value;
 };
 var parseAsync3 = /* @__PURE__ */ _parseAsync2($ZodRealError2);
-var _safeParse2 = (_Err) => (schema, value, _ctx) => {
+var _safeParse2 = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
+  const result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError2();
   }
@@ -17994,9 +18477,9 @@ var _safeParse2 = (_Err) => (schema, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 var safeParse3 = /* @__PURE__ */ _safeParse2($ZodRealError2);
-var _safeParseAsync2 = (_Err) => async (schema, value, _ctx) => {
+var _safeParseAsync2 = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   return result.issues.length ? {
@@ -18005,40 +18488,40 @@ var _safeParseAsync2 = (_Err) => async (schema, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 var safeParseAsync3 = /* @__PURE__ */ _safeParseAsync2($ZodRealError2);
-var _encode2 = (_Err) => (schema, value, _ctx) => {
+var _encode2 = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parse2(_Err)(schema, value, ctx);
+  return _parse2(_Err)(schema2, value, ctx);
 };
 var encode3 = /* @__PURE__ */ _encode2($ZodRealError2);
-var _decode2 = (_Err) => (schema, value, _ctx) => {
-  return _parse2(_Err)(schema, value, _ctx);
+var _decode2 = (_Err) => (schema2, value, _ctx) => {
+  return _parse2(_Err)(schema2, value, _ctx);
 };
 var decode3 = /* @__PURE__ */ _decode2($ZodRealError2);
-var _encodeAsync2 = (_Err) => async (schema, value, _ctx) => {
+var _encodeAsync2 = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parseAsync2(_Err)(schema, value, ctx);
+  return _parseAsync2(_Err)(schema2, value, ctx);
 };
 var encodeAsync3 = /* @__PURE__ */ _encodeAsync2($ZodRealError2);
-var _decodeAsync2 = (_Err) => async (schema, value, _ctx) => {
-  return _parseAsync2(_Err)(schema, value, _ctx);
+var _decodeAsync2 = (_Err) => async (schema2, value, _ctx) => {
+  return _parseAsync2(_Err)(schema2, value, _ctx);
 };
 var decodeAsync3 = /* @__PURE__ */ _decodeAsync2($ZodRealError2);
-var _safeEncode2 = (_Err) => (schema, value, _ctx) => {
+var _safeEncode2 = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParse2(_Err)(schema, value, ctx);
+  return _safeParse2(_Err)(schema2, value, ctx);
 };
 var safeEncode3 = /* @__PURE__ */ _safeEncode2($ZodRealError2);
-var _safeDecode2 = (_Err) => (schema, value, _ctx) => {
-  return _safeParse2(_Err)(schema, value, _ctx);
+var _safeDecode2 = (_Err) => (schema2, value, _ctx) => {
+  return _safeParse2(_Err)(schema2, value, _ctx);
 };
 var safeDecode3 = /* @__PURE__ */ _safeDecode2($ZodRealError2);
-var _safeEncodeAsync2 = (_Err) => async (schema, value, _ctx) => {
+var _safeEncodeAsync2 = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParseAsync2(_Err)(schema, value, ctx);
+  return _safeParseAsync2(_Err)(schema2, value, ctx);
 };
 var safeEncodeAsync3 = /* @__PURE__ */ _safeEncodeAsync2($ZodRealError2);
-var _safeDecodeAsync2 = (_Err) => async (schema, value, _ctx) => {
-  return _safeParseAsync2(_Err)(schema, value, _ctx);
+var _safeDecodeAsync2 = (_Err) => async (schema2, value, _ctx) => {
+  return _safeParseAsync2(_Err)(schema2, value, _ctx);
 };
 var safeDecodeAsync3 = /* @__PURE__ */ _safeDecodeAsync2($ZodRealError2);
 
@@ -19614,9 +20097,9 @@ var $ZodObjectJIT2 = /* @__PURE__ */ $constructor2("$ZodObjectJIT", (inst, def)
     for (const key of normalized.keys) {
       const id = ids[key];
       const k = esc2(key);
-      const schema = shape[key];
-      const isOptionalIn = schema?._zod?.optin === "optional";
-      const isOptionalOut = schema?._zod?.optout === "optional";
+      const schema2 = shape[key];
+      const isOptionalIn = schema2?._zod?.optin === "optional";
+      const isOptionalOut = schema2?._zod?.optout === "optional";
       doc.write(`const ${id} = ${parseStr(key)};`);
       if (isOptionalIn && isOptionalOut) {
         doc.write(`
@@ -26849,11 +27332,11 @@ var $ZodRegistry2 = class {
     this._map = /* @__PURE__ */ new WeakMap();
     this._idmap = /* @__PURE__ */ new Map();
   }
-  add(schema, ..._meta) {
+  add(schema2, ..._meta) {
     const meta5 = _meta[0];
-    this._map.set(schema, meta5);
+    this._map.set(schema2, meta5);
     if (meta5 && typeof meta5 === "object" && "id" in meta5) {
-      this._idmap.set(meta5.id, schema);
+      this._idmap.set(meta5.id, schema2);
     }
     return this;
   }
@@ -26862,26 +27345,26 @@ var $ZodRegistry2 = class {
     this._idmap = /* @__PURE__ */ new Map();
     return this;
   }
-  remove(schema) {
-    const meta5 = this._map.get(schema);
+  remove(schema2) {
+    const meta5 = this._map.get(schema2);
     if (meta5 && typeof meta5 === "object" && "id" in meta5) {
       this._idmap.delete(meta5.id);
     }
-    this._map.delete(schema);
+    this._map.delete(schema2);
     return this;
   }
-  get(schema) {
-    const p = schema._zod.parent;
+  get(schema2) {
+    const p = schema2._zod.parent;
     if (p) {
       const pm = { ...this.get(p) ?? {} };
       delete pm.id;
-      const f = { ...pm, ...this._map.get(schema) };
+      const f = { ...pm, ...this._map.get(schema2) };
       return Object.keys(f).length ? f : void 0;
     }
-    return this._map.get(schema);
+    return this._map.get(schema2);
   }
-  has(schema) {
-    return this._map.has(schema);
+  has(schema2) {
+    return this._map.has(schema2);
   }
 };
 function registry2() {
@@ -27534,11 +28017,11 @@ function _endsWith2(suffix, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _property2(property, schema, params) {
+function _property2(property, schema2, params) {
   return new $ZodCheckProperty2({
     check: "property",
     property,
-    schema,
+    schema: schema2,
     ...normalizeParams2(params)
   });
 }
@@ -27786,23 +28269,23 @@ function _promise2(Class3, innerType) {
 function _custom2(Class3, fn, _params) {
   const norm = normalizeParams2(_params);
   norm.abort ?? (norm.abort = true);
-  const schema = new Class3({
+  const schema2 = new Class3({
     type: "custom",
     check: "custom",
     fn,
     ...norm
   });
-  return schema;
+  return schema2;
 }
 // @__NO_SIDE_EFFECTS__
 function _refine2(Class3, fn, _params) {
-  const schema = new Class3({
+  const schema2 = new Class3({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams2(_params)
   });
-  return schema;
+  return schema2;
 }
 // @__NO_SIDE_EFFECTS__
 function _superRefine2(fn, params) {
@@ -27951,40 +28434,40 @@ function initializeContext2(params) {
     external: params?.external ?? void 0
   };
 }
-function process3(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process3(schema2, ctx, _params = { path: [], schemaPath: [] }) {
   var _a5;
-  const def = schema._zod.def;
-  const seen = ctx.seen.get(schema);
+  const def = schema2._zod.def;
+  const seen = ctx.seen.get(schema2);
   if (seen) {
     seen.count++;
-    const isCycle = _params.schemaPath.includes(schema);
+    const isCycle = _params.schemaPath.includes(schema2);
     if (isCycle) {
       seen.cycle = _params.path;
     }
     return seen.schema;
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema, result);
-  const overrideSchema = schema._zod.toJSONSchema?.();
+  ctx.seen.set(schema2, result);
+  const overrideSchema = schema2._zod.toJSONSchema?.();
   if (overrideSchema) {
     result.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
-      schemaPath: [..._params.schemaPath, schema],
+      schemaPath: [..._params.schemaPath, schema2],
       path: _params.path
     };
-    if (schema._zod.processJSONSchema) {
-      schema._zod.processJSONSchema(ctx, result.schema, params);
+    if (schema2._zod.processJSONSchema) {
+      schema2._zod.processJSONSchema(ctx, result.schema, params);
     } else {
       const _json = result.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
       }
-      processor(schema, ctx, _json, params);
+      processor(schema2, ctx, _json, params);
     }
-    const parent = schema._zod.parent;
+    const parent = schema2._zod.parent;
     if (parent) {
       if (!result.ref)
         result.ref = parent;
@@ -27992,21 +28475,21 @@ function process3(schema, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta5 = ctx.metadataRegistry.get(schema);
+  const meta5 = ctx.metadataRegistry.get(schema2);
   if (meta5)
     Object.assign(result.schema, meta5);
-  if (ctx.io === "input" && isTransforming2(schema)) {
+  if (ctx.io === "input" && isTransforming2(schema2)) {
     delete result.schema.examples;
     delete result.schema.default;
   }
   if (ctx.io === "input" && "_prefault" in result.schema)
     (_a5 = result.schema).default ?? (_a5.default = result.schema._prefault);
   delete result.schema._prefault;
-  const _result = ctx.seen.get(schema);
+  const _result = ctx.seen.get(schema2);
   return _result.schema;
 }
-function extractDefs2(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function extractDefs2(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
@@ -28049,11 +28532,11 @@ function extractDefs2(ctx, schema) {
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
-    const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    const schema3 = seen.schema;
+    for (const key in schema3) {
+      delete schema3[key];
     }
-    schema2.$ref = ref;
+    schema3.$ref = ref;
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
@@ -28067,13 +28550,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
-    if (schema === entry[0]) {
+    if (schema2 === entry[0]) {
       extractToDef(entry);
       continue;
     }
     if (ctx.external) {
       const ext = ctx.external.registry.get(entry[0])?.id;
-      if (schema !== entry[0] && ext) {
+      if (schema2 !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
@@ -28095,16 +28578,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
 }
-function finalize2(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function finalize2(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
     if (seen.ref === null)
       return;
-    const schema2 = seen.def ?? seen.schema;
-    const _cached = { ...schema2 };
+    const schema3 = seen.def ?? seen.schema;
+    const _cached = { ...schema3 };
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
@@ -28112,28 +28595,28 @@ function finalize2(ctx, schema) {
       const refSeen = ctx.seen.get(ref);
       const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
-        schema2.allOf = schema2.allOf ?? [];
-        schema2.allOf.push(refSchema);
+        schema3.allOf = schema3.allOf ?? [];
+        schema3.allOf.push(refSchema);
       } else {
-        Object.assign(schema2, refSchema);
+        Object.assign(schema3, refSchema);
       }
-      Object.assign(schema2, _cached);
+      Object.assign(schema3, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
           if (!(key in _cached)) {
-            delete schema2[key];
+            delete schema3[key];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key in refSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema3[key];
           }
         }
       }
@@ -28143,13 +28626,13 @@ function finalize2(ctx, schema) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
-        schema2.$ref = parentSeen.schema.$ref;
+        schema3.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
+          for (const key in schema3) {
             if (key === "$ref" || key === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key in parentSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema3[key];
             }
           }
         }
@@ -28157,7 +28640,7 @@ function finalize2(ctx, schema) {
     }
     ctx.override({
       zodSchema,
-      jsonSchema: schema2,
+      jsonSchema: schema3,
       path: seen.path ?? []
     });
   };
@@ -28175,13 +28658,13 @@ function finalize2(ctx, schema) {
   } else {
   }
   if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema)?.id;
+    const id = ctx.external.registry.get(schema2)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id);
   }
   Object.assign(result, root.def ?? root.schema);
-  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+  const rootMetaId = ctx.metadataRegistry.get(schema2)?.id;
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
   const defs = ctx.external?.defs ?? {};
@@ -28207,10 +28690,10 @@ function finalize2(ctx, schema) {
     const finalized = JSON.parse(JSON.stringify(result));
     Object.defineProperty(finalized, "~standard", {
       value: {
-        ...schema["~standard"],
+        ...schema2["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod2(schema, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod2(schema, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod2(schema2, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod2(schema2, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -28274,18 +28757,18 @@ function isTransforming2(_schema, _ctx) {
   }
   return false;
 }
-var createToJSONSchemaMethod2 = (schema, processors = {}) => (params) => {
+var createToJSONSchemaMethod2 = (schema2, processors = {}) => (params) => {
   const ctx = initializeContext2({ ...params, processors });
-  process3(schema, ctx);
-  extractDefs2(ctx, schema);
-  return finalize2(ctx, schema);
+  process3(schema2, ctx);
+  extractDefs2(ctx, schema2);
+  return finalize2(ctx, schema2);
 };
-var createStandardJSONSchemaMethod2 = (schema, io, processors = {}) => (params) => {
+var createStandardJSONSchemaMethod2 = (schema2, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext2({ ...libraryOptions ?? {}, target, io, processors });
-  process3(schema, ctx);
-  extractDefs2(ctx, schema);
-  return finalize2(ctx, schema);
+  process3(schema2, ctx);
+  extractDefs2(ctx, schema2);
+  return finalize2(ctx, schema2);
 };
 
 // ../node_modules/zod/v4/core/json-schema-processors.js
@@ -28297,10 +28780,10 @@ var formatMap2 = {
   regex: ""
   // do not set
 };
-var stringProcessor2 = (schema, ctx, _json, _params) => {
+var stringProcessor2 = (schema2, ctx, _json, _params) => {
   const json4 = _json;
   json4.type = "string";
-  const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+  const { minimum, maximum, format, patterns, contentEncoding } = schema2._zod.bag;
   if (typeof minimum === "number")
     json4.minLength = minimum;
   if (typeof maximum === "number")
@@ -28329,9 +28812,9 @@ var stringProcessor2 = (schema, ctx, _json, _params) => {
     }
   }
 };
-var numberProcessor2 = (schema, ctx, _json, _params) => {
+var numberProcessor2 = (schema2, ctx, _json, _params) => {
   const json4 = _json;
-  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema2._zod.bag;
   if (typeof format === "string" && format.includes("int"))
     json4.type = "integer";
   else
@@ -28406,8 +28889,8 @@ var dateProcessor2 = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-var enumProcessor2 = (schema, _ctx, json4, _params) => {
-  const def = schema._zod.def;
+var enumProcessor2 = (schema2, _ctx, json4, _params) => {
+  const def = schema2._zod.def;
   const values = getEnumValues2(def.entries);
   if (values.every((v) => typeof v === "number"))
     json4.type = "number";
@@ -28415,8 +28898,8 @@ var enumProcessor2 = (schema, _ctx, json4, _params) => {
     json4.type = "string";
   json4.enum = values;
 };
-var literalProcessor2 = (schema, ctx, json4, _params) => {
-  const def = schema._zod.def;
+var literalProcessor2 = (schema2, ctx, json4, _params) => {
+  const def = schema2._zod.def;
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
@@ -28460,22 +28943,22 @@ var nanProcessor2 = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-var templateLiteralProcessor2 = (schema, _ctx, json4, _params) => {
+var templateLiteralProcessor2 = (schema2, _ctx, json4, _params) => {
   const _json = json4;
-  const pattern = schema._zod.pattern;
+  const pattern = schema2._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor2 = (schema, _ctx, json4, _params) => {
+var fileProcessor2 = (schema2, _ctx, json4, _params) => {
   const _json = json4;
   const file3 = {
     type: "string",
     format: "binary",
     contentEncoding: "binary"
   };
-  const { minimum, maximum, mime } = schema._zod.bag;
+  const { minimum, maximum, mime } = schema2._zod.bag;
   if (minimum !== void 0)
     file3.minLength = minimum;
   if (maximum !== void 0)
@@ -28520,10 +29003,10 @@ var setProcessor2 = (_schema, ctx, _json, _params) => {
     throw new Error("Set cannot be represented in JSON Schema");
   }
 };
-var arrayProcessor2 = (schema, ctx, _json, params) => {
+var arrayProcessor2 = (schema2, ctx, _json, params) => {
   const json4 = _json;
-  const def = schema._zod.def;
-  const { minimum, maximum } = schema._zod.bag;
+  const def = schema2._zod.def;
+  const { minimum, maximum } = schema2._zod.bag;
   if (typeof minimum === "number")
     json4.minItems = minimum;
   if (typeof maximum === "number")
@@ -28534,9 +29017,9 @@ var arrayProcessor2 = (schema, ctx, _json, params) => {
     path: [...params.path, "items"]
   });
 };
-var objectProcessor2 = (schema, ctx, _json, params) => {
+var objectProcessor2 = (schema2, ctx, _json, params) => {
   const json4 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json4.type = "object";
   json4.properties = {};
   const shape = def.shape;
@@ -28570,8 +29053,8 @@ var objectProcessor2 = (schema, ctx, _json, params) => {
     });
   }
 };
-var unionProcessor2 = (schema, ctx, json4, params) => {
-  const def = schema._zod.def;
+var unionProcessor2 = (schema2, ctx, json4, params) => {
+  const def = schema2._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => process3(x, ctx, {
     ...params,
@@ -28583,8 +29066,8 @@ var unionProcessor2 = (schema, ctx, json4, params) => {
     json4.anyOf = options;
   }
 };
-var intersectionProcessor2 = (schema, ctx, json4, params) => {
-  const def = schema._zod.def;
+var intersectionProcessor2 = (schema2, ctx, json4, params) => {
+  const def = schema2._zod.def;
   const a = process3(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
@@ -28600,9 +29083,9 @@ var intersectionProcessor2 = (schema, ctx, json4, params) => {
   ];
   json4.allOf = allOf;
 };
-var tupleProcessor2 = (schema, ctx, _json, params) => {
+var tupleProcessor2 = (schema2, ctx, _json, params) => {
   const json4 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json4.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";
@@ -28636,15 +29119,15 @@ var tupleProcessor2 = (schema, ctx, _json, params) => {
       json4.additionalItems = rest;
     }
   }
-  const { minimum, maximum } = schema._zod.bag;
+  const { minimum, maximum } = schema2._zod.bag;
   if (typeof minimum === "number")
     json4.minItems = minimum;
   if (typeof maximum === "number")
     json4.maxItems = maximum;
 };
-var recordProcessor2 = (schema, ctx, _json, params) => {
+var recordProcessor2 = (schema2, ctx, _json, params) => {
   const json4 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json4.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
@@ -28678,10 +29161,10 @@ var recordProcessor2 = (schema, ctx, _json, params) => {
     }
   }
 };
-var nullableProcessor2 = (schema, ctx, json4, params) => {
-  const def = schema._zod.def;
+var nullableProcessor2 = (schema2, ctx, json4, params) => {
+  const def = schema2._zod.def;
   const inner = process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
     json4.nullable = true;
@@ -28689,31 +29172,31 @@ var nullableProcessor2 = (schema, ctx, json4, params) => {
     json4.anyOf = [inner, { type: "null" }];
   }
 };
-var nonoptionalProcessor2 = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var nonoptionalProcessor2 = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var defaultProcessor2 = (schema, ctx, json4, params) => {
-  const def = schema._zod.def;
+var defaultProcessor2 = (schema2, ctx, json4, params) => {
+  const def = schema2._zod.def;
   process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   json4.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var prefaultProcessor2 = (schema, ctx, json4, params) => {
-  const def = schema._zod.def;
+var prefaultProcessor2 = (schema2, ctx, json4, params) => {
+  const def = schema2._zod.def;
   process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   if (ctx.io === "input")
     json4._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var catchProcessor2 = (schema, ctx, json4, params) => {
-  const def = schema._zod.def;
+var catchProcessor2 = (schema2, ctx, json4, params) => {
+  const def = schema2._zod.def;
   process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   let catchValue;
   try {
@@ -28723,37 +29206,37 @@ var catchProcessor2 = (schema, ctx, json4, params) => {
   }
   json4.default = catchValue;
 };
-var pipeProcessor2 = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var pipeProcessor2 = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
   process3(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
-var readonlyProcessor2 = (schema, ctx, json4, params) => {
-  const def = schema._zod.def;
+var readonlyProcessor2 = (schema2, ctx, json4, params) => {
+  const def = schema2._zod.def;
   process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   json4.readOnly = true;
 };
-var promiseProcessor2 = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var promiseProcessor2 = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var optionalProcessor2 = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var optionalProcessor2 = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   process3(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var lazyProcessor2 = (schema, ctx, _json, params) => {
-  const innerType = schema._zod.innerType;
+var lazyProcessor2 = (schema2, ctx, _json, params) => {
+  const innerType = schema2._zod.innerType;
   process3(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
 var allProcessors2 = {
@@ -28803,8 +29286,8 @@ function toJSONSchema2(input, params) {
     const ctx2 = initializeContext2({ ...params, processors: allProcessors2 });
     const defs = {};
     for (const entry of registry3._idmap.entries()) {
-      const [_, schema] = entry;
-      process3(schema, ctx2);
+      const [_, schema2] = entry;
+      process3(schema2, ctx2);
     }
     const schemas = {};
     const external = {
@@ -28814,9 +29297,9 @@ function toJSONSchema2(input, params) {
     };
     ctx2.external = external;
     for (const entry of registry3._idmap.entries()) {
-      const [key, schema] = entry;
-      extractDefs2(ctx2, schema);
-      schemas[key] = finalize2(ctx2, schema);
+      const [key, schema2] = entry;
+      extractDefs2(ctx2, schema2);
+      schemas[key] = finalize2(ctx2, schema2);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -28884,14 +29367,14 @@ var JSONSchemaGenerator2 = class {
    * Process a schema to prepare it for JSON Schema generation.
    * This must be called before emit().
    */
-  process(schema, _params = { path: [], schemaPath: [] }) {
-    return process3(schema, this.ctx, _params);
+  process(schema2, _params = { path: [], schemaPath: [] }) {
+    return process3(schema2, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
    * Must call process() first.
    */
-  emit(schema, _params) {
+  emit(schema2, _params) {
     if (_params) {
       if (_params.cycles)
         this.ctx.cycles = _params.cycles;
@@ -28900,8 +29383,8 @@ var JSONSchemaGenerator2 = class {
       if (_params.external)
         this.ctx.external = _params.external;
     }
-    extractDefs2(this.ctx, schema);
-    const result = finalize2(this.ctx, schema);
+    extractDefs2(this.ctx, schema2);
+    const result = finalize2(this.ctx, schema2);
     const { "~standard": _, ...plainResult } = result;
     return plainResult;
   }
@@ -29866,8 +30349,8 @@ var ZodArray2 = /* @__PURE__ */ $constructor2("ZodArray", (inst, def) => {
 function array2(element, params) {
   return _array2(ZodArray2, element, params);
 }
-function keyof2(schema) {
-  const shape = schema._zod.def.shape;
+function keyof2(schema2) {
+  const shape = schema2._zod.def.shape;
   return _enum4(Object.keys(shape));
 }
 var ZodObject2 = /* @__PURE__ */ $constructor2("ZodObject", (inst, def) => {
@@ -30492,11 +30975,11 @@ function json3(params) {
   });
   return jsonSchema;
 }
-function preprocess2(fn, schema) {
+function preprocess2(fn, schema2) {
   return new ZodPreprocess2({
     type: "pipe",
     in: transform2(fn),
-    out: schema
+    out: schema2
   });
 }
 
@@ -30603,8 +31086,8 @@ var RECOGNIZED_KEYS2 = /* @__PURE__ */ new Set([
   "nullable",
   "readOnly"
 ]);
-function detectVersion2(schema, defaultTarget) {
-  const $schema = schema.$schema;
+function detectVersion2(schema2, defaultTarget) {
+  const $schema = schema2.$schema;
   if ($schema === "https://json-schema.org/draft/2020-12/schema") {
     return "draft-2020-12";
   }
@@ -30634,27 +31117,27 @@ function resolveRef2(ref, ctx) {
   }
   throw new Error(`Reference not found: ${ref}`);
 }
-function convertBaseSchema2(schema, ctx) {
-  if (schema.not !== void 0) {
-    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
+function convertBaseSchema2(schema2, ctx) {
+  if (schema2.not !== void 0) {
+    if (typeof schema2.not === "object" && Object.keys(schema2.not).length === 0) {
       return z2.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
-  if (schema.unevaluatedItems !== void 0) {
+  if (schema2.unevaluatedItems !== void 0) {
     throw new Error("unevaluatedItems is not supported");
   }
-  if (schema.unevaluatedProperties !== void 0) {
+  if (schema2.unevaluatedProperties !== void 0) {
     throw new Error("unevaluatedProperties is not supported");
   }
-  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
+  if (schema2.if !== void 0 || schema2.then !== void 0 || schema2.else !== void 0) {
     throw new Error("Conditional schemas (if/then/else) are not supported");
   }
-  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
+  if (schema2.dependentSchemas !== void 0 || schema2.dependentRequired !== void 0) {
     throw new Error("dependentSchemas and dependentRequired are not supported");
   }
-  if (schema.$ref) {
-    const refPath = schema.$ref;
+  if (schema2.$ref) {
+    const refPath = schema2.$ref;
     if (ctx.refs.has(refPath)) {
       return ctx.refs.get(refPath);
     }
@@ -30673,9 +31156,9 @@ function convertBaseSchema2(schema, ctx) {
     ctx.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 (schema2.enum !== void 0) {
+    const enumValues = schema2.enum;
+    if (ctx.version === "openapi-3.0" && schema2.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
       return z2.null();
     }
     if (enumValues.length === 0) {
@@ -30693,13 +31176,13 @@ function convertBaseSchema2(schema, ctx) {
     }
     return z2.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (schema.const !== void 0) {
-    return z2.literal(schema.const);
+  if (schema2.const !== void 0) {
+    return z2.literal(schema2.const);
   }
-  const type = schema.type;
+  const type = schema2.type;
   if (Array.isArray(type)) {
     const typeSchemas = type.map((t) => {
-      const typeSchema = { ...schema, type: t };
+      const typeSchema = { ...schema2, type: t };
       return convertBaseSchema2(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -30717,8 +31200,8 @@ function convertBaseSchema2(schema, ctx) {
   switch (type) {
     case "string": {
       let stringSchema = z2.string();
-      if (schema.format) {
-        const format = schema.format;
+      if (schema2.format) {
+        const format = schema2.format;
         if (format === "email") {
           stringSchema = stringSchema.check(z2.email());
         } else if (format === "uri" || format === "uri-reference") {
@@ -30767,14 +31250,14 @@ function convertBaseSchema2(schema, ctx) {
           stringSchema = stringSchema.check(z2.ksuid());
         }
       }
-      if (typeof schema.minLength === "number") {
-        stringSchema = stringSchema.min(schema.minLength);
+      if (typeof schema2.minLength === "number") {
+        stringSchema = stringSchema.min(schema2.minLength);
       }
-      if (typeof schema.maxLength === "number") {
-        stringSchema = stringSchema.max(schema.maxLength);
+      if (typeof schema2.maxLength === "number") {
+        stringSchema = stringSchema.max(schema2.maxLength);
       }
-      if (schema.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+      if (schema2.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema2.pattern));
       }
       zodSchema = stringSchema;
       break;
@@ -30782,24 +31265,24 @@ function convertBaseSchema2(schema, ctx) {
     case "number":
     case "integer": {
       let numberSchema = type === "integer" ? z2.number().int() : z2.number();
-      if (typeof schema.minimum === "number") {
-        numberSchema = numberSchema.min(schema.minimum);
+      if (typeof schema2.minimum === "number") {
+        numberSchema = numberSchema.min(schema2.minimum);
       }
-      if (typeof schema.maximum === "number") {
-        numberSchema = numberSchema.max(schema.maximum);
+      if (typeof schema2.maximum === "number") {
+        numberSchema = numberSchema.max(schema2.maximum);
       }
-      if (typeof schema.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
-      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
-        numberSchema = numberSchema.gt(schema.minimum);
+      if (typeof schema2.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema2.exclusiveMinimum);
+      } else if (schema2.exclusiveMinimum === true && typeof schema2.minimum === "number") {
+        numberSchema = numberSchema.gt(schema2.minimum);
       }
-      if (typeof schema.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
-      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
-        numberSchema = numberSchema.lt(schema.maximum);
+      if (typeof schema2.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema2.exclusiveMaximum);
+      } else if (schema2.exclusiveMaximum === true && typeof schema2.maximum === "number") {
+        numberSchema = numberSchema.lt(schema2.maximum);
       }
-      if (typeof schema.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema.multipleOf);
+      if (typeof schema2.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema2.multipleOf);
       }
       zodSchema = numberSchema;
       break;
@@ -30814,15 +31297,15 @@ function convertBaseSchema2(schema, ctx) {
     }
     case "object": {
       const shape = {};
-      const properties = schema.properties || {};
-      const requiredSet = new Set(schema.required || []);
+      const properties = schema2.properties || {};
+      const requiredSet = new Set(schema2.required || []);
       for (const [key, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema2(propSchema, ctx);
         shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
       }
-      if (schema.propertyNames) {
-        const keySchema = convertSchema2(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema2(schema.additionalProperties, ctx) : z2.any();
+      if (schema2.propertyNames) {
+        const keySchema = convertSchema2(schema2.propertyNames, ctx);
+        const valueSchema = schema2.additionalProperties && typeof schema2.additionalProperties === "object" ? convertSchema2(schema2.additionalProperties, ctx) : z2.any();
         if (Object.keys(shape).length === 0) {
           zodSchema = z2.record(keySchema, valueSchema);
           break;
@@ -30832,8 +31315,8 @@ function convertBaseSchema2(schema, ctx) {
         zodSchema = z2.intersection(objectSchema2, recordSchema);
         break;
       }
-      if (schema.patternProperties) {
-        const patternProps = schema.patternProperties;
+      if (schema2.patternProperties) {
+        const patternProps = schema2.patternProperties;
         const patternKeys = Object.keys(patternProps);
         const looseRecords = [];
         for (const pattern of patternKeys) {
@@ -30860,18 +31343,18 @@ function convertBaseSchema2(schema, ctx) {
         break;
       }
       const objectSchema = z2.object(shape);
-      if (schema.additionalProperties === false) {
+      if (schema2.additionalProperties === false) {
         zodSchema = objectSchema.strict();
-      } else if (typeof schema.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema2(schema.additionalProperties, ctx));
+      } else if (typeof schema2.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema2(schema2.additionalProperties, ctx));
       } else {
         zodSchema = objectSchema.passthrough();
       }
       break;
     }
     case "array": {
-      const prefixItems = schema.prefixItems;
-      const items = schema.items;
+      const prefixItems = schema2.prefixItems;
+      const items = schema2.items;
       if (prefixItems && Array.isArray(prefixItems)) {
         const tupleItems = prefixItems.map((item) => convertSchema2(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema2(items, ctx) : void 0;
@@ -30880,34 +31363,34 @@ function convertBaseSchema2(schema, ctx) {
         } else {
           zodSchema = z2.tuple(tupleItems);
         }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+        if (typeof schema2.minItems === "number") {
+          zodSchema = zodSchema.check(z2.minLength(schema2.minItems));
         }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+        if (typeof schema2.maxItems === "number") {
+          zodSchema = zodSchema.check(z2.maxLength(schema2.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema2(item, ctx));
-        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema2(schema.additionalItems, ctx) : void 0;
+        const rest = schema2.additionalItems && typeof schema2.additionalItems === "object" ? convertSchema2(schema2.additionalItems, ctx) : void 0;
         if (rest) {
           zodSchema = z2.tuple(tupleItems).rest(rest);
         } else {
           zodSchema = z2.tuple(tupleItems);
         }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+        if (typeof schema2.minItems === "number") {
+          zodSchema = zodSchema.check(z2.minLength(schema2.minItems));
         }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+        if (typeof schema2.maxItems === "number") {
+          zodSchema = zodSchema.check(z2.maxLength(schema2.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema2(items, ctx);
         let arraySchema = z2.array(element);
-        if (typeof schema.minItems === "number") {
-          arraySchema = arraySchema.min(schema.minItems);
+        if (typeof schema2.minItems === "number") {
+          arraySchema = arraySchema.min(schema2.minItems);
         }
-        if (typeof schema.maxItems === "number") {
-          arraySchema = arraySchema.max(schema.maxItems);
+        if (typeof schema2.maxItems === "number") {
+          arraySchema = arraySchema.max(schema2.maxItems);
         }
         zodSchema = arraySchema;
       } else {
@@ -30920,76 +31403,76 @@ function convertBaseSchema2(schema, ctx) {
   }
   return zodSchema;
 }
-function convertSchema2(schema, ctx) {
-  if (typeof schema === "boolean") {
-    return schema ? z2.any() : z2.never();
+function convertSchema2(schema2, ctx) {
+  if (typeof schema2 === "boolean") {
+    return schema2 ? z2.any() : z2.never();
   }
-  let baseSchema = convertBaseSchema2(schema, ctx);
-  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) => convertSchema2(s, ctx));
+  let baseSchema = convertBaseSchema2(schema2, ctx);
+  const hasExplicitType = schema2.type || schema2.enum !== void 0 || schema2.const !== void 0;
+  if (schema2.anyOf && Array.isArray(schema2.anyOf)) {
+    const options = schema2.anyOf.map((s) => convertSchema2(s, ctx));
     const anyOfUnion = z2.union(options);
     baseSchema = hasExplicitType ? z2.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
-  if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const options = schema.oneOf.map((s) => convertSchema2(s, ctx));
+  if (schema2.oneOf && Array.isArray(schema2.oneOf)) {
+    const options = schema2.oneOf.map((s) => convertSchema2(s, ctx));
     const oneOfUnion = z2.xor(options);
     baseSchema = hasExplicitType ? z2.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    if (schema.allOf.length === 0) {
+  if (schema2.allOf && Array.isArray(schema2.allOf)) {
+    if (schema2.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z2.any();
     } else {
-      let result = hasExplicitType ? baseSchema : convertSchema2(schema.allOf[0], ctx);
+      let result = hasExplicitType ? baseSchema : convertSchema2(schema2.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
-      for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z2.intersection(result, convertSchema2(schema.allOf[i], ctx));
+      for (let i = startIdx; i < schema2.allOf.length; i++) {
+        result = z2.intersection(result, convertSchema2(schema2.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+  if (schema2.nullable === true && ctx.version === "openapi-3.0") {
     baseSchema = z2.nullable(baseSchema);
   }
-  if (schema.readOnly === true) {
+  if (schema2.readOnly === true) {
     baseSchema = z2.readonly(baseSchema);
   }
-  if (schema.default !== void 0) {
-    baseSchema = baseSchema.default(schema.default);
+  if (schema2.default !== void 0) {
+    baseSchema = baseSchema.default(schema2.default);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
   for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+    if (key in schema2) {
+      extraMeta[key] = schema2[key];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+    if (key in schema2) {
+      extraMeta[key] = schema2[key];
     }
   }
-  for (const key of Object.keys(schema)) {
+  for (const key of Object.keys(schema2)) {
     if (!RECOGNIZED_KEYS2.has(key)) {
-      extraMeta[key] = schema[key];
+      extraMeta[key] = schema2[key];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
     ctx.registry.add(baseSchema, extraMeta);
   }
-  if (schema.description) {
-    baseSchema = baseSchema.describe(schema.description);
+  if (schema2.description) {
+    baseSchema = baseSchema.describe(schema2.description);
   }
   return baseSchema;
 }
-function fromJSONSchema2(schema, params) {
-  if (typeof schema === "boolean") {
-    return schema ? z2.any() : z2.never();
+function fromJSONSchema2(schema2, params) {
+  if (typeof schema2 === "boolean") {
+    return schema2 ? z2.any() : z2.never();
   }
   let normalized;
   try {
-    normalized = JSON.parse(JSON.stringify(schema));
+    normalized = JSON.parse(JSON.stringify(schema2));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
@@ -31116,19 +31599,24 @@ var BridgeRequestSchema2 = external_exports2.discriminatedUnion("method", [
     args: external_exports2.record(external_exports2.string(), external_exports2.unknown())
   })
 ]);
+var elapsedMs2 = external_exports2.number().nonnegative().optional();
 var BridgeResultSchema2 = external_exports2.union([
   external_exports2.object({
     t: external_exports2.literal("res"),
     id: external_exports2.string(),
     ok: external_exports2.literal(true),
-    result: external_exports2.unknown()
+    result: external_exports2.unknown(),
+    ms: elapsedMs2
   }),
   external_exports2.object({
     t: external_exports2.literal("res"),
     id: external_exports2.string(),
     ok: external_exports2.literal(false),
     reason: external_exports2.string(),
-    message: external_exports2.string()
+    message: external_exports2.string(),
+    // 🔴 Carried on failure too: the timing of a call that FAILED is exactly
+    // what tells a timeout apart from a refusal.
+    ms: elapsedMs2
   })
 ]);
 var BridgeHeartbeatSchema2 = external_exports2.object({
@@ -31383,7 +31871,12 @@ var TOOL_TIERS2 = Object.freeze({
   video_image_add_from_gallery: "write",
   video_scene_update: "write",
   video_background_set: "write",
-  video_canvas_resize: "write",
+  // 🔴 destructive, unlike the photo editor's same-named tool. There it
+  // retargets the page you are looking at; here the encoder reads one size off
+  // the first scene and renders the whole video at it, so one wrong value
+  // reflows every scene. Bulk is what makes it destructive, and no tool here
+  // can undo it — the agent has no undo to call.
+  video_canvas_resize: "destructive",
   video_scene_reorder: "write",
   video_text_add: "write",
   video_image_add: "write",
@@ -31419,6 +31912,12 @@ var TOOL_TIERS2 = Object.freeze({
   // 🔴 Insertion appends, so it never passes through the overwrite prompt; the
   // tier is the only barrier, and the user approves each image's source.
   editor_insert_image: "destructive",
+  // 🔴 destructive, and one confirm covers the whole plan on purpose. What the
+  // user approves is "make the post look like this", not each keystroke inside
+  // it — and asking per step would defeat the unattended sequence this exists
+  // for. Reach is the five document-assembly steps; the runner refuses anything
+  // else.
+  editor_apply_manifest: "destructive",
   editor_set_title: "write",
   editor_undo: "write",
   editor_replace: "destructive"
@@ -31490,7 +31989,14 @@ var REASON_POLICY2 = Object.freeze({
   editor_busy: Object.freeze({ retryable: false }),
   // --- The connection itself must be repaired ---
   not_connected: Object.freeze({ retryable: false }),
-  unauthorized: Object.freeze({ retryable: false })
+  unauthorized: Object.freeze({ retryable: false }),
+  // --- Staging: the request must change, except where nobody knows yet ---
+  stale_fence: Object.freeze({ retryable: false }),
+  already_sealed: Object.freeze({ retryable: false }),
+  hash_mismatch: Object.freeze({ retryable: false }),
+  upload_expired: Object.freeze({ retryable: false }),
+  capacity_unavailable: Object.freeze({ retryable: true }),
+  uploads_unproven: Object.freeze({ retryable: true })
 });
 var BRIDGE_USER_MESSAGES2 = Object.freeze({
   /** Tool call arrived while no panel is connected. */