@trops/dash-core 0.1.553 → 0.1.556

package/dist/electron/index.js

@@ -5,7 +5,7 @@ var require$$1$1 = require('path');
 var require$$0$2 = require('fs');
 var require$$0$3 = require('crypto');
 var require$$2$1 = require('os');
-var require$$3$1 = require('adm-zip');
+var require$$5 = require('adm-zip');
 var require$$4 = require('url');
 var require$$2 = require('vm');
 var require$$0$4 = require('electron-store');
@@ -13,9 +13,9 @@ var require$$1$2 = require('croner');
 var require$$9$1 = require('objects-to-csv');
 var require$$1$3 = require('readline');
 var require$$2$2 = require('xtreamer');
-var require$$3$2 = require('xml2js');
+var require$$3$1 = require('xml2js');
 var require$$4$1 = require('JSONStream');
-var require$$5 = require('stream');
+var require$$5$1 = require('stream');
 var require$$6 = require('csv-parser');
 var require$$0$5 = require('quickjs-emscripten');
 var require$$11 = require('https');
@@ -24,16 +24,17 @@ var require$$1$4 = require('@modelcontextprotocol/sdk/client/stdio.js');
 var require$$0$6 = require('pkce-challenge');
 var require$$12 = require('child_process');
 var require$$2$3 = require('algoliasearch');
-var require$$3$3 = require('node:path');
+var require$$3$2 = require('node:path');
 var require$$0$8 = require('openai');
 var require$$0$b = require('@anthropic-ai/sdk');
+var require$$2$4 = require('zod-to-json-schema');
 var require$$8$1 = require('zod');
 var require$$0$9 = require('http');
 var require$$1$5 = require('http2');
-var require$$2$4 = require('node-forge');
+var require$$2$5 = require('node-forge');
 var require$$0$a = require('css');
 var require$$1$6 = require('node-vibrant/node');
-var require$$3$4 = require('ws');
+var require$$3$3 = require('ws');
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -460,6 +461,7 @@ const REGISTRY_PUBLISH_WIDGET = "registry:publish-widget";
 const REGISTRY_INSPECT_WIDGET_PACKAGE = "registry:inspect-widget-package";
 const REGISTRY_SCAN_WIDGET_DEFAULTS = "registry:scan-widget-defaults";
 const REGISTRY_PREVIEW_FETCH = "registry:preview-fetch";
+const REGISTRY_FETCH_PACKAGE_MANIFEST = "registry:fetch-package-manifest";
 
 var registryEvents$1 = {
   REGISTRY_FETCH_INDEX,
@@ -472,6 +474,7 @@ var registryEvents$1 = {
   REGISTRY_INSPECT_WIDGET_PACKAGE,
   REGISTRY_SCAN_WIDGET_DEFAULTS,
   REGISTRY_PREVIEW_FETCH,
+  REGISTRY_FETCH_PACKAGE_MANIFEST,
 };
 
 /**
@@ -4700,7 +4703,7 @@ var schedulerController_1 = schedulerController$2;
 	const fs = require$$0$2;
 	const path = require$$1$1;
 	const os = require$$2$1;
-	const AdmZip = require$$3$1;
+	const AdmZip = require$$5;
 	const { fileURLToPath } = require$$4;
 	const { app, ipcMain, BrowserWindow } = require$$0$1;
 	const { dynamicWidgetLoader } = dynamicWidgetLoaderExports;
@@ -7313,9 +7316,9 @@ function requireTransform () {
 	var fs = require$$0$2;
 	var readline = require$$1$3;
 	const xtreamer = require$$2$2;
-	var xmlParser = require$$3$2;
+	var xmlParser = require$$3$1;
 	var JSONStream = require$$4$1;
-	const stream = require$$5;
+	const stream = require$$5$1;
 	var csv = require$$6;
 	const path = require$$1$1;
 	const { app } = require$$0$1;
@@ -18848,8 +18851,8 @@ api._coercedBigint = _coercedBigint;
 api._int64 = _int64;
 api._uint64 = _uint64;
 api._symbol = _symbol;
-api._undefined = _undefined$1;
-api._null = _null$1;
+api._undefined = _undefined;
+api._null = _null;
 api._any = _any;
 api._unknown = _unknown;
 api._never = _never;
@@ -18899,17 +18902,17 @@ api._tuple = _tuple;
 api._record = _record;
 api._map = _map;
 api._set = _set;
-api._enum = _enum$2;
+api._enum = _enum$1;
 api._nativeEnum = _nativeEnum;
 api._literal = _literal;
 api._file = _file;
 api._transform = _transform;
 api._optional = _optional;
 api._nullable = _nullable;
-api._default = _default$1;
+api._default = _default;
 api._nonoptional = _nonoptional;
 api._success = _success;
-api._catch = _catch$1;
+api._catch = _catch;
 api._pipe = _pipe;
 api._readonly = _readonly;
 api._templateLiteral = _templateLiteral;
@@ -19289,13 +19292,13 @@ function _symbol(Class, params) {
         ...util$2.normalizeParams(params),
     });
 }
-function _undefined$1(Class, params) {
+function _undefined(Class, params) {
     return new Class({
         type: "undefined",
         ...util$2.normalizeParams(params),
     });
 }
-function _null$1(Class, params) {
+function _null(Class, params) {
     return new Class({
         type: "null",
         ...util$2.normalizeParams(params),
@@ -19593,7 +19596,7 @@ function _set(Class, valueType, params) {
         ...util$2.normalizeParams(params),
     });
 }
-function _enum$2(Class, values, params) {
+function _enum$1(Class, values, params) {
     const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
     // if (Array.isArray(values)) {
     //   for (const value of values) {
@@ -19657,7 +19660,7 @@ function _nullable(Class, innerType) {
         innerType,
     });
 }
-function _default$1(Class, innerType, defaultValue) {
+function _default(Class, innerType, defaultValue) {
     return new Class({
         type: "default",
         innerType,
@@ -19679,7 +19682,7 @@ function _success(Class, innerType) {
         innerType,
     });
 }
-function _catch$1(Class, innerType, catchValue) {
+function _catch(Class, innerType, catchValue) {
     return new Class({
         type: "catch",
         innerType,
@@ -22232,26 +22235,26 @@ var __importStar$3 = (commonjsGlobal && commonjsGlobal.__importStar) || function
     return result;
 };
 Object.defineProperty(coerce$1, "__esModule", { value: true });
-coerce$1.string = string$2;
-coerce$1.number = number$2;
-coerce$1.boolean = boolean$2;
-coerce$1.bigint = bigint$2;
-coerce$1.date = date$2;
+coerce$1.string = string$1;
+coerce$1.number = number$1;
+coerce$1.boolean = boolean$1;
+coerce$1.bigint = bigint$1;
+coerce$1.date = date$1;
 const core$4 = __importStar$3(core$8);
 const schemas$2 = __importStar$3(requireSchemas());
-function string$2(params) {
+function string$1(params) {
     return core$4._coercedString(schemas$2.ZodString, params);
 }
-function number$2(params) {
+function number$1(params) {
     return core$4._coercedNumber(schemas$2.ZodNumber, params);
 }
-function boolean$2(params) {
+function boolean$1(params) {
     return core$4._coercedBoolean(schemas$2.ZodBoolean, params);
 }
-function bigint$2(params) {
+function bigint$1(params) {
     return core$4._coercedBigint(schemas$2.ZodBigInt, params);
 }
-function date$2(params) {
+function date$1(params) {
     return core$4._coercedDate(schemas$2.ZodDate, params);
 }
 
@@ -28750,33 +28753,199 @@ async function getPackage$1(packageName) {
 }
 
 /**
- * Check for updates to installed widgets
+ * Parse an installed widget's id (`@scope/name` or `scope/name` or
+ * `name`) into a `{scope, name}` ref the check-versions endpoint
+ * accepts. Returns null when no scope is present — the new endpoint
+ * needs both fields.
+ */
+function _parseScopedRef(installedId) {
+  if (!installedId || typeof installedId !== "string") return null;
+  if (!installedId.includes("/")) return null;
+  const stripped = installedId.replace(/^@/, "");
+  const parts = stripped.split("/");
+  if (parts.length < 2) return null;
+  const scope = parts[0];
+  const name = parts.slice(1).join("/");
+  if (!scope || !name) return null;
+  return { scope, name };
+}
+
+/**
+ * Check for updates to installed widgets.
+ *
+ * Uses the registry's POST /api/packages/check-versions endpoint, which
+ * returns latest-version-by-id regardless of auth/visibility. Critically,
+ * this means **private packages the user has installed are checked even
+ * when the app launches anonymously** (before sign-in completes / for
+ * users who haven't signed in this session). The previous implementation
+ * fetched the entire registry index, which is visibility-filtered
+ * server-side and so silently hid private packages from anonymous
+ * callers — the user's installed-but-private widgets reported "no
+ * update available" forever until they manually re-checked after
+ * signing in.
+ *
+ * Bare-name (unscoped) installed widgets can't be queried via the new
+ * endpoint (it needs scope+name). For those we fall back to the legacy
+ * index-scan. Same fallback covers the transition period while the
+ * registry-side endpoint is still being deployed — if the endpoint
+ * isn't there yet, we silently degrade to the old behavior.
  *
  * @param {Array<Object>} installedWidgets - Array of { name, version } objects
  * @returns {Promise<Array<Object>>} Widgets with available updates
  */
 async function checkUpdates(installedWidgets = []) {
-  const index = await fetchRegistryIndex();
-  const updates = [];
+  if (!Array.isArray(installedWidgets) || installedWidgets.length === 0) {
+    return [];
+  }
 
+  // Bucket installed widgets by whether they have a scope (and so can
+  // use the new endpoint) or not (fall back to index scan).
+  const scopedRefs = []; // { scope, name, installed }
+  const bareInstalled = []; // { name, version }
   for (const installed of installedWidgets) {
     const installedId = installed.packageId || installed.name;
-    const pkg = (index.packages || []).find((p) => {
-      // Match by scoped ID (e.g. "@trops/slack" === "@trops/slack")
-      const registryId = toPackageId(p.scope, p.name);
-      if (registryId === installedId) return true;
-      // Fallback: bare-name match for pre-migration entries
-      if (p.name === installedId) return true;
-      return false;
+    const ref = _parseScopedRef(installedId);
+    if (ref) {
+      scopedRefs.push({
+        scope: ref.scope,
+        name: ref.name,
+        installed,
+        installedId,
+      });
+    } else {
+      bareInstalled.push(installed);
+    }
+  }
+
+  const updates = [];
+
+  // --- Path A: /api/packages/resolve (covers scoped refs, anon-friendly) ---
+  // The resolve endpoint returns latestVersion per ref for both public
+  // packages AND private packages where the registry's entitlement
+  // check says the caller is allowed (which today includes anonymous
+  // callers for packages with permissive read policies — verified via
+  // curl on 2026-05-19). This means installed-but-private widgets show
+  // up in the update check even at app launch before the user has
+  // signed in, which was the original gap.
+  //
+  // We try check-versions first (a dash-registry PR adds a tighter
+  // endpoint that returns ONLY latestVersion without entitlement
+  // gating); if it's not deployed yet, fall back to /resolve. Both
+  // produce the same shape for our purposes; resolve carries more
+  // metadata but we only read latestVersion.
+  if (scopedRefs.length > 0) {
+    const registryBase =
+      process.env.DASH_REGISTRY_API_URL || DEFAULT_REGISTRY_API_URL;
+    const refsBody = JSON.stringify({
+      refs: scopedRefs.map((r) => ({ scope: r.scope, name: r.name })),
     });
-    if (pkg && pkg.version !== installed.version) {
-      updates.push({
-        name: installed.name,
-        currentVersion: installed.version,
-        latestVersion: pkg.version,
-        downloadUrl: pkg.downloadUrl,
-        changelog: pkg.changelog || null,
+    let endpointAvailable = true;
+    let results = null;
+    // Try check-versions first (returns less data, no entitlement
+    // dependency); fall back to /resolve if it 404s (registry without
+    // the new endpoint deployed).
+    for (const endpointPath of [
+      "/api/packages/check-versions",
+      "/api/packages/resolve",
+    ]) {
+      const url = `${registryBase}${endpointPath}`;
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            // Auth is optional but widens what /resolve returns for
+            // private packages where ownership matters.
+            ...buildAuthHeaders(),
+          },
+          body: refsBody,
+        });
+        if (response.status === 404) {
+          // Endpoint not deployed — try the next one.
+          continue;
+        }
+        if (!response.ok) {
+          throw new Error(
+            `${endpointPath} ${response.status} ${response.statusText}`,
+          );
+        }
+        results = await response.json();
+        endpointAvailable = true;
+        break;
+      } catch (error) {
+        console.warn(
+          `[RegistryController] ${endpointPath} failed:`,
+          error.message,
+        );
+        endpointAvailable = false;
+        // Try next endpoint
+      }
+    }
+
+    if (endpointAvailable && Array.isArray(results)) {
+      // Index results by `scope/name` so we can join back to our
+      // scopedRefs list without depending on Promise.all ordering.
+      const byKey = new Map();
+      for (const r of results) {
+        if (r && r.scope && r.name) {
+          byKey.set(`${r.scope}/${r.name}`, r);
+        }
+      }
+      for (const ref of scopedRefs) {
+        const result = byKey.get(`${ref.scope}/${ref.name}`);
+        if (!result || !result.exists) continue;
+        if (
+          result.latestVersion &&
+          result.latestVersion !== ref.installed.version
+        ) {
+          // Build the download URL deterministically — same shape the
+          // existing index serves (`/api/packages/<scope>/<name>/download?version=<v>`).
+          // Constructed client-side because check-versions intentionally
+          // doesn't return downloadUrl (less to leak; download still
+          // gated by visibility/entitlements at /download).
+          const downloadUrl = `${registryBase}/api/packages/${encodeURIComponent(
+            ref.scope,
+          )}/${encodeURIComponent(ref.name)}/download?version=${encodeURIComponent(
+            result.latestVersion,
+          )}`;
+          updates.push({
+            name: ref.installed.name,
+            currentVersion: ref.installed.version,
+            latestVersion: result.latestVersion,
+            downloadUrl,
+            changelog: null,
+          });
+        }
+      }
+    } else {
+      // Endpoint unavailable — treat scoped refs as bare for the
+      // fallback path so they at least get a public-only check.
+      for (const ref of scopedRefs) {
+        bareInstalled.push(ref.installed);
+      }
+    }
+  }
+
+  // --- Path B: index scan (bare-name widgets + endpoint fallback) ---
+  if (bareInstalled.length > 0) {
+    const index = await fetchRegistryIndex();
+    for (const installed of bareInstalled) {
+      const installedId = installed.packageId || installed.name;
+      const pkg = (index.packages || []).find((p) => {
+        const registryId = toPackageId(p.scope, p.name);
+        if (registryId === installedId) return true;
+        if (p.name === installedId) return true;
+        return false;
       });
+      if (pkg && pkg.version !== installed.version) {
+        updates.push({
+          name: installed.name,
+          currentVersion: installed.version,
+          latestVersion: pkg.version,
+          downloadUrl: pkg.downloadUrl,
+          changelog: pkg.changelog || null,
+        });
+      }
     }
   }
 
@@ -28839,7 +29008,7 @@ async function fetchPackageSource(packageName, componentName = null) {
 
   // adm-zip is only available in the host app's node_modules (dash-electron),
   // so defer loading until the function actually runs.
-  const AdmZip = require$$3$1;
+  const AdmZip = require$$5;
   const { validateZipEntries } = widgetRegistryExports;
 
   const pkg = await getPackage$1(packageName);
@@ -29005,6 +29174,146 @@ async function fetchPackageSource(packageName, componentName = null) {
   }
 }
 
+/**
+ * Fetch the `dash.permissions` block from a registry package WITHOUT
+ * installing it. Powers the pre-install preflight: the update flow
+ * uses this to learn which MCP/fs/network grants a new package
+ * version requires before downloading the install. The user then
+ * approves the delta (declared - already-granted) and the install
+ * proceeds knowing nothing will surprise them after the fact.
+ *
+ * Returns `{ packageId, version, permissions }` where `permissions`
+ * is the `dash.permissions` blob from package.json (or null if the
+ * package declares none). Throws on network / unzip / parse errors —
+ * callers should treat a throw as "couldn't preflight; prompt anyway
+ * post-install via the existing flow" rather than blocking the
+ * update on a transient registry hiccup.
+ *
+ * @param {string} packageName
+ * @returns {Promise<{packageId: string, version: string|null, permissions: object|null}>}
+ */
+async function fetchPackageManifest(packageName) {
+  if (!packageName) {
+    throw new Error("fetchPackageManifest: packageName is required");
+  }
+
+  const AdmZip = require$$5;
+  const { validateZipEntries } = widgetRegistryExports;
+
+  const pkg = await getPackage$1(packageName);
+  if (!pkg) {
+    throw new Error(`Package "${packageName}" not found in the registry`);
+  }
+  if (!pkg.downloadUrl) {
+    throw new Error(`Package "${packageName}" has no downloadUrl`);
+  }
+
+  const parsedUrl = new URL(pkg.downloadUrl);
+  if (parsedUrl.protocol !== "https:") {
+    throw new Error(
+      `Registry downloads must use HTTPS. Refusing to fetch: ${pkg.downloadUrl}`,
+    );
+  }
+
+  const fetchOpts = {};
+  const registryBase =
+    process.env.DASH_REGISTRY_API_URL ||
+    "https://main.d919rwhuzp7rj.amplifyapp.com";
+  if (
+    pkg.downloadUrl.includes(registryBase) ||
+    pkg.downloadUrl.includes("/api/packages/")
+  ) {
+    const auth = getStoredToken$3();
+    if (auth?.token) {
+      fetchOpts.headers = { Authorization: `Bearer ${auth.token}` };
+    }
+  }
+
+  const response = await fetch(pkg.downloadUrl, fetchOpts);
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new Error("Authentication required to fetch this package manifest");
+    }
+    throw new Error(`Failed to fetch package manifest: ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  let buffer = Buffer.from(await response.arrayBuffer());
+  if (buffer.length === 0) {
+    throw new Error("Manifest fetch failed: registry returned an empty body");
+  }
+  if (contentType.includes("application/json")) {
+    const jsonData = JSON.parse(buffer.toString("utf-8"));
+    if (jsonData.error) {
+      throw new Error(`Manifest fetch failed: ${jsonData.error}`);
+    }
+    if (jsonData.downloadUrl) {
+      const zipResponse = await fetch(jsonData.downloadUrl);
+      if (!zipResponse.ok) {
+        throw new Error(
+          `Manifest fetch failed: storage returned ${zipResponse.status} ${zipResponse.statusText}`,
+        );
+      }
+      buffer = Buffer.from(await zipResponse.arrayBuffer());
+    }
+  }
+
+  const zip = new AdmZip(buffer);
+  const safeName = (pkg.name || "pkg").replace(/[^a-zA-Z0-9-_]/g, "_");
+  const tempDir = path$9.join(
+    os.tmpdir(),
+    `dash-registry-manifest-${safeName}-${Date.now()}`,
+  );
+
+  try {
+    validateZipEntries(zip, tempDir);
+    // Only need package.json — extract that single entry instead of
+    // the whole zip to keep this cheap (the full extract in
+    // fetchPackageSource is the right call for previews, but
+    // pre-install preflight is hot path during a 22-widget batch
+    // update so trimming N×(unzip-everything) helps).
+    const pkgJsonEntry = zip.getEntries().find((e) => {
+      const name = e.entryName.replace(/\\/g, "/");
+      return name === "package.json" || name.endsWith("/package.json");
+    });
+    if (!pkgJsonEntry) {
+      // No package.json in the zip — treat as "no declared
+      // permissions" rather than throwing. Callers fall through to
+      // the post-install consent path.
+      return {
+        packageId: toPackageId(pkg.scope, pkg.name),
+        version: pkg.version || null,
+        permissions: null,
+      };
+    }
+    const pkgJsonText = zip.readAsText(pkgJsonEntry);
+    let parsed;
+    try {
+      parsed = JSON.parse(pkgJsonText);
+    } catch (e) {
+      throw new Error(
+        `Manifest fetch failed: invalid package.json (${e.message})`,
+      );
+    }
+    return {
+      packageId: toPackageId(pkg.scope, pkg.name),
+      version: pkg.version || parsed.version || null,
+      permissions: parsed.dash?.permissions || null,
+    };
+  } finally {
+    // tempDir was never actually created (we read in-memory via
+    // zip.readAsText), but validateZipEntries computes paths against
+    // it. Keep the symmetric cleanup defensively in case future
+    // edits switch back to extractAllTo.
+    try {
+      if (fs$7.existsSync(tempDir)) {
+        fs$7.rmSync(tempDir, { recursive: true, force: true });
+      }
+    } catch (_) {
+      // non-fatal
+    }
+  }
+}
+
 var registryController$3 = {
   fetchRegistryIndex,
   searchRegistry: searchRegistry$1,
@@ -29013,12 +29322,13 @@ var registryController$3 = {
   getPackage: getPackage$1,
   checkUpdates,
   fetchPackageSource,
+  fetchPackageManifest,
 };
 
 var fs$6 = require$$0$2;
 var JSONStream = require$$4$1;
 const algoliasearch$1 = require$$2$3;
-const path$8 = require$$3$3;
+const path$8 = require$$3$2;
 const { ensureDirectoryExistence, checkDirectory } = file;
 
 let AlgoliaIndex$1 = class AlgoliaIndex {
@@ -35128,26 +35438,26 @@ var __importStar$2 = (commonjsGlobal && commonjsGlobal.__importStar) || function
     return result;
 };
 Object.defineProperty(coerce, "__esModule", { value: true });
-coerce.string = string$1;
-coerce.number = number$1;
-coerce.boolean = boolean$1;
-coerce.bigint = bigint$1;
-coerce.date = date$1;
+coerce.string = string;
+coerce.number = number;
+coerce.boolean = boolean;
+coerce.bigint = bigint;
+coerce.date = date;
 const core$3 = __importStar$2(core$8);
 const schemas = __importStar$2(schemas$1);
-function string$1(params) {
+function string(params) {
     return core$3._coercedString(schemas.ZodMiniString, params);
 }
-function number$1(params) {
+function number(params) {
     return core$3._coercedNumber(schemas.ZodMiniNumber, params);
 }
-function boolean$1(params) {
+function boolean(params) {
     return core$3._coercedBoolean(schemas.ZodMiniBoolean, params);
 }
-function bigint$1(params) {
+function bigint(params) {
     return core$3._coercedBigint(schemas.ZodMiniBigInt, params);
 }
-function date$1(params) {
+function date(params) {
     return core$3._coercedDate(schemas.ZodMiniDate, params);
 }
 
@@ -35533,1838 +35843,6 @@ function isTerminal(status) {
 
 var zodJsonSchemaCompat = {};
 
-var cjs = {};
-
-var Options = {};
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.getDefaultOptions = exports.defaultOptions = exports.jsonDescription = exports.ignoreOverride = void 0;
-	exports.ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-	const jsonDescription = (jsonSchema, def) => {
-	    if (def.description) {
-	        try {
-	            return {
-	                ...jsonSchema,
-	                ...JSON.parse(def.description),
-	            };
-	        }
-	        catch { }
-	    }
-	    return jsonSchema;
-	};
-	exports.jsonDescription = jsonDescription;
-	exports.defaultOptions = {
-	    name: undefined,
-	    $refStrategy: "root",
-	    basePath: ["#"],
-	    effectStrategy: "input",
-	    pipeStrategy: "all",
-	    dateStrategy: "format:date-time",
-	    mapStrategy: "entries",
-	    removeAdditionalStrategy: "passthrough",
-	    allowedAdditionalProperties: true,
-	    rejectedAdditionalProperties: false,
-	    definitionPath: "definitions",
-	    target: "jsonSchema7",
-	    strictUnions: false,
-	    definitions: {},
-	    errorMessages: false,
-	    markdownDescription: false,
-	    patternStrategy: "escape",
-	    applyRegexFlags: false,
-	    emailStrategy: "format:email",
-	    base64Strategy: "contentEncoding:base64",
-	    nameStrategy: "ref",
-	    openAiAnyTypeName: "OpenAiAnyType"
-	};
-	const getDefaultOptions = (options) => (typeof options === "string"
-	    ? {
-	        ...exports.defaultOptions,
-	        name: options,
-	    }
-	    : {
-	        ...exports.defaultOptions,
-	        ...options,
-	    });
-	exports.getDefaultOptions = getDefaultOptions; 
-} (Options));
-
-var Refs = {};
-
-Object.defineProperty(Refs, "__esModule", { value: true });
-Refs.getRefs = void 0;
-const Options_js_1 = Options;
-const getRefs = (options) => {
-    const _options = (0, Options_js_1.getDefaultOptions)(options);
-    const currentPath = _options.name !== undefined
-        ? [..._options.basePath, _options.definitionPath, _options.name]
-        : _options.basePath;
-    return {
-        ..._options,
-        flags: { hasReferencedOpenAiAnyType: false },
-        currentPath: currentPath,
-        propertyPath: undefined,
-        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-            def._def,
-            {
-                def: def._def,
-                path: [..._options.basePath, _options.definitionPath, name],
-                // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-                jsonSchema: undefined,
-            },
-        ])),
-    };
-};
-Refs.getRefs = getRefs;
-
-var errorMessages = {};
-
-Object.defineProperty(errorMessages, "__esModule", { value: true });
-errorMessages.setResponseValueAndErrors = errorMessages.addErrorMessage = void 0;
-function addErrorMessage(res, key, errorMessage, refs) {
-    if (!refs?.errorMessages)
-        return;
-    if (errorMessage) {
-        res.errorMessage = {
-            ...res.errorMessage,
-            [key]: errorMessage,
-        };
-    }
-}
-errorMessages.addErrorMessage = addErrorMessage;
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
-    res[key] = value;
-    addErrorMessage(res, key, errorMessage, refs);
-}
-errorMessages.setResponseValueAndErrors = setResponseValueAndErrors;
-
-var getRelativePath$1 = {};
-
-Object.defineProperty(getRelativePath$1, "__esModule", { value: true });
-getRelativePath$1.getRelativePath = void 0;
-const getRelativePath = (pathA, pathB) => {
-    let i = 0;
-    for (; i < pathA.length && i < pathB.length; i++) {
-        if (pathA[i] !== pathB[i])
-            break;
-    }
-    return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
-getRelativePath$1.getRelativePath = getRelativePath;
-
-var parseDef = {};
-
-var selectParser = {};
-
-var any = {};
-
-Object.defineProperty(any, "__esModule", { value: true });
-any.parseAnyDef = void 0;
-const getRelativePath_js_1 = getRelativePath$1;
-function parseAnyDef(refs) {
-    if (refs.target !== "openAi") {
-        return {};
-    }
-    const anyDefinitionPath = [
-        ...refs.basePath,
-        refs.definitionPath,
-        refs.openAiAnyTypeName,
-    ];
-    refs.flags.hasReferencedOpenAiAnyType = true;
-    return {
-        $ref: refs.$refStrategy === "relative"
-            ? (0, getRelativePath_js_1.getRelativePath)(anyDefinitionPath, refs.currentPath)
-            : anyDefinitionPath.join("/"),
-    };
-}
-any.parseAnyDef = parseAnyDef;
-
-var array = {};
-
-var hasRequiredArray;
-
-function requireArray () {
-	if (hasRequiredArray) return array;
-	hasRequiredArray = 1;
-	Object.defineProperty(array, "__esModule", { value: true });
-	array.parseArrayDef = void 0;
-	const v3_1 = v3;
-	const errorMessages_js_1 = errorMessages;
-	const parseDef_js_1 = requireParseDef();
-	function parseArrayDef(def, refs) {
-	    const res = {
-	        type: "array",
-	    };
-	    if (def.type?._def &&
-	        def.type?._def?.typeName !== v3_1.ZodFirstPartyTypeKind.ZodAny) {
-	        res.items = (0, parseDef_js_1.parseDef)(def.type._def, {
-	            ...refs,
-	            currentPath: [...refs.currentPath, "items"],
-	        });
-	    }
-	    if (def.minLength) {
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minItems", def.minLength.value, def.minLength.message, refs);
-	    }
-	    if (def.maxLength) {
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
-	    }
-	    if (def.exactLength) {
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
-	    }
-	    return res;
-	}
-	array.parseArrayDef = parseArrayDef;
-	return array;
-}
-
-var bigint = {};
-
-Object.defineProperty(bigint, "__esModule", { value: true });
-bigint.parseBigintDef = void 0;
-const errorMessages_js_1$2 = errorMessages;
-function parseBigintDef(def, refs) {
-    const res = {
-        type: "integer",
-        format: "int64",
-    };
-    if (!def.checks)
-        return res;
-    for (const check of def.checks) {
-        switch (check.kind) {
-            case "min":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        (0, errorMessages_js_1$2.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
-                    }
-                    else {
-                        (0, errorMessages_js_1$2.setResponseValueAndErrors)(res, "exclusiveMinimum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMinimum = true;
-                    }
-                    (0, errorMessages_js_1$2.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
-                }
-                break;
-            case "max":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        (0, errorMessages_js_1$2.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
-                    }
-                    else {
-                        (0, errorMessages_js_1$2.setResponseValueAndErrors)(res, "exclusiveMaximum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMaximum = true;
-                    }
-                    (0, errorMessages_js_1$2.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
-                }
-                break;
-            case "multipleOf":
-                (0, errorMessages_js_1$2.setResponseValueAndErrors)(res, "multipleOf", check.value, check.message, refs);
-                break;
-        }
-    }
-    return res;
-}
-bigint.parseBigintDef = parseBigintDef;
-
-var boolean = {};
-
-Object.defineProperty(boolean, "__esModule", { value: true });
-boolean.parseBooleanDef = void 0;
-function parseBooleanDef() {
-    return {
-        type: "boolean",
-    };
-}
-boolean.parseBooleanDef = parseBooleanDef;
-
-var branded = {};
-
-var hasRequiredBranded;
-
-function requireBranded () {
-	if (hasRequiredBranded) return branded;
-	hasRequiredBranded = 1;
-	Object.defineProperty(branded, "__esModule", { value: true });
-	branded.parseBrandedDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	function parseBrandedDef(_def, refs) {
-	    return (0, parseDef_js_1.parseDef)(_def.type._def, refs);
-	}
-	branded.parseBrandedDef = parseBrandedDef;
-	return branded;
-}
-
-var _catch = {};
-
-var hasRequired_catch;
-
-function require_catch () {
-	if (hasRequired_catch) return _catch;
-	hasRequired_catch = 1;
-	Object.defineProperty(_catch, "__esModule", { value: true });
-	_catch.parseCatchDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const parseCatchDef = (def, refs) => {
-	    return (0, parseDef_js_1.parseDef)(def.innerType._def, refs);
-	};
-	_catch.parseCatchDef = parseCatchDef;
-	return _catch;
-}
-
-var date = {};
-
-Object.defineProperty(date, "__esModule", { value: true });
-date.parseDateDef = void 0;
-const errorMessages_js_1$1 = errorMessages;
-function parseDateDef(def, refs, overrideDateStrategy) {
-    const strategy = overrideDateStrategy ?? refs.dateStrategy;
-    if (Array.isArray(strategy)) {
-        return {
-            anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
-        };
-    }
-    switch (strategy) {
-        case "string":
-        case "format:date-time":
-            return {
-                type: "string",
-                format: "date-time",
-            };
-        case "format:date":
-            return {
-                type: "string",
-                format: "date",
-            };
-        case "integer":
-            return integerDateParser(def, refs);
-    }
-}
-date.parseDateDef = parseDateDef;
-const integerDateParser = (def, refs) => {
-    const res = {
-        type: "integer",
-        format: "unix-time",
-    };
-    if (refs.target === "openApi3") {
-        return res;
-    }
-    for (const check of def.checks) {
-        switch (check.kind) {
-            case "min":
-                (0, errorMessages_js_1$1.setResponseValueAndErrors)(res, "minimum", check.value, // This is in milliseconds
-                check.message, refs);
-                break;
-            case "max":
-                (0, errorMessages_js_1$1.setResponseValueAndErrors)(res, "maximum", check.value, // This is in milliseconds
-                check.message, refs);
-                break;
-        }
-    }
-    return res;
-};
-
-var _default = {};
-
-var hasRequired_default;
-
-function require_default () {
-	if (hasRequired_default) return _default;
-	hasRequired_default = 1;
-	Object.defineProperty(_default, "__esModule", { value: true });
-	_default.parseDefaultDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	function parseDefaultDef(_def, refs) {
-	    return {
-	        ...(0, parseDef_js_1.parseDef)(_def.innerType._def, refs),
-	        default: _def.defaultValue(),
-	    };
-	}
-	_default.parseDefaultDef = parseDefaultDef;
-	return _default;
-}
-
-var effects = {};
-
-var hasRequiredEffects;
-
-function requireEffects () {
-	if (hasRequiredEffects) return effects;
-	hasRequiredEffects = 1;
-	Object.defineProperty(effects, "__esModule", { value: true });
-	effects.parseEffectsDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const any_js_1 = any;
-	function parseEffectsDef(_def, refs) {
-	    return refs.effectStrategy === "input"
-	        ? (0, parseDef_js_1.parseDef)(_def.schema._def, refs)
-	        : (0, any_js_1.parseAnyDef)(refs);
-	}
-	effects.parseEffectsDef = parseEffectsDef;
-	return effects;
-}
-
-var _enum$1 = {};
-
-Object.defineProperty(_enum$1, "__esModule", { value: true });
-_enum$1.parseEnumDef = void 0;
-function parseEnumDef(def) {
-    return {
-        type: "string",
-        enum: Array.from(def.values),
-    };
-}
-_enum$1.parseEnumDef = parseEnumDef;
-
-var intersection = {};
-
-var hasRequiredIntersection;
-
-function requireIntersection () {
-	if (hasRequiredIntersection) return intersection;
-	hasRequiredIntersection = 1;
-	Object.defineProperty(intersection, "__esModule", { value: true });
-	intersection.parseIntersectionDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const isJsonSchema7AllOfType = (type) => {
-	    if ("type" in type && type.type === "string")
-	        return false;
-	    return "allOf" in type;
-	};
-	function parseIntersectionDef(def, refs) {
-	    const allOf = [
-	        (0, parseDef_js_1.parseDef)(def.left._def, {
-	            ...refs,
-	            currentPath: [...refs.currentPath, "allOf", "0"],
-	        }),
-	        (0, parseDef_js_1.parseDef)(def.right._def, {
-	            ...refs,
-	            currentPath: [...refs.currentPath, "allOf", "1"],
-	        }),
-	    ].filter((x) => !!x);
-	    let unevaluatedProperties = refs.target === "jsonSchema2019-09"
-	        ? { unevaluatedProperties: false }
-	        : undefined;
-	    const mergedAllOf = [];
-	    // If either of the schemas is an allOf, merge them into a single allOf
-	    allOf.forEach((schema) => {
-	        if (isJsonSchema7AllOfType(schema)) {
-	            mergedAllOf.push(...schema.allOf);
-	            if (schema.unevaluatedProperties === undefined) {
-	                // If one of the schemas has no unevaluatedProperties set,
-	                // the merged schema should also have no unevaluatedProperties set
-	                unevaluatedProperties = undefined;
-	            }
-	        }
-	        else {
-	            let nestedSchema = schema;
-	            if ("additionalProperties" in schema &&
-	                schema.additionalProperties === false) {
-	                const { additionalProperties, ...rest } = schema;
-	                nestedSchema = rest;
-	            }
-	            else {
-	                // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
-	                unevaluatedProperties = undefined;
-	            }
-	            mergedAllOf.push(nestedSchema);
-	        }
-	    });
-	    return mergedAllOf.length
-	        ? {
-	            allOf: mergedAllOf,
-	            ...unevaluatedProperties,
-	        }
-	        : undefined;
-	}
-	intersection.parseIntersectionDef = parseIntersectionDef;
-	return intersection;
-}
-
-var literal = {};
-
-Object.defineProperty(literal, "__esModule", { value: true });
-literal.parseLiteralDef = void 0;
-function parseLiteralDef(def, refs) {
-    const parsedType = typeof def.value;
-    if (parsedType !== "bigint" &&
-        parsedType !== "number" &&
-        parsedType !== "boolean" &&
-        parsedType !== "string") {
-        return {
-            type: Array.isArray(def.value) ? "array" : "object",
-        };
-    }
-    if (refs.target === "openApi3") {
-        return {
-            type: parsedType === "bigint" ? "integer" : parsedType,
-            enum: [def.value],
-        };
-    }
-    return {
-        type: parsedType === "bigint" ? "integer" : parsedType,
-        const: def.value,
-    };
-}
-literal.parseLiteralDef = parseLiteralDef;
-
-var map = {};
-
-var record = {};
-
-var string = {};
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.parseStringDef = exports.zodPatterns = void 0;
-	const errorMessages_js_1 = errorMessages;
-	let emojiRegex = undefined;
-	/**
-	 * Generated from the regular expressions found here as of 2024-05-22:
-	 * https://github.com/colinhacks/zod/blob/master/src/types.ts.
-	 *
-	 * Expressions with /i flag have been changed accordingly.
-	 */
-	exports.zodPatterns = {
-	    /**
-	     * `c` was changed to `[cC]` to replicate /i flag
-	     */
-	    cuid: /^[cC][^\s-]{8,}$/,
-	    cuid2: /^[0-9a-z]+$/,
-	    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
-	    /**
-	     * `a-z` was added to replicate /i flag
-	     */
-	    email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
-	    /**
-	     * Constructed a valid Unicode RegExp
-	     *
-	     * Lazily instantiate since this type of regex isn't supported
-	     * in all envs (e.g. React Native).
-	     *
-	     * See:
-	     * https://github.com/colinhacks/zod/issues/2433
-	     * Fix in Zod:
-	     * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
-	     */
-	    emoji: () => {
-	        if (emojiRegex === undefined) {
-	            emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
-	        }
-	        return emojiRegex;
-	    },
-	    /**
-	     * Unused
-	     */
-	    uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
-	    /**
-	     * Unused
-	     */
-	    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
-	    ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
-	    /**
-	     * Unused
-	     */
-	    ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
-	    ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
-	    base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
-	    base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
-	    nanoid: /^[a-zA-Z0-9_-]{21}$/,
-	    jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/,
-	};
-	function parseStringDef(def, refs) {
-	    const res = {
-	        type: "string",
-	    };
-	    if (def.checks) {
-	        for (const check of def.checks) {
-	            switch (check.kind) {
-	                case "min":
-	                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minLength", typeof res.minLength === "number"
-	                        ? Math.max(res.minLength, check.value)
-	                        : check.value, check.message, refs);
-	                    break;
-	                case "max":
-	                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxLength", typeof res.maxLength === "number"
-	                        ? Math.min(res.maxLength, check.value)
-	                        : check.value, check.message, refs);
-	                    break;
-	                case "email":
-	                    switch (refs.emailStrategy) {
-	                        case "format:email":
-	                            addFormat(res, "email", check.message, refs);
-	                            break;
-	                        case "format:idn-email":
-	                            addFormat(res, "idn-email", check.message, refs);
-	                            break;
-	                        case "pattern:zod":
-	                            addPattern(res, exports.zodPatterns.email, check.message, refs);
-	                            break;
-	                    }
-	                    break;
-	                case "url":
-	                    addFormat(res, "uri", check.message, refs);
-	                    break;
-	                case "uuid":
-	                    addFormat(res, "uuid", check.message, refs);
-	                    break;
-	                case "regex":
-	                    addPattern(res, check.regex, check.message, refs);
-	                    break;
-	                case "cuid":
-	                    addPattern(res, exports.zodPatterns.cuid, check.message, refs);
-	                    break;
-	                case "cuid2":
-	                    addPattern(res, exports.zodPatterns.cuid2, check.message, refs);
-	                    break;
-	                case "startsWith":
-	                    addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
-	                    break;
-	                case "endsWith":
-	                    addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
-	                    break;
-	                case "datetime":
-	                    addFormat(res, "date-time", check.message, refs);
-	                    break;
-	                case "date":
-	                    addFormat(res, "date", check.message, refs);
-	                    break;
-	                case "time":
-	                    addFormat(res, "time", check.message, refs);
-	                    break;
-	                case "duration":
-	                    addFormat(res, "duration", check.message, refs);
-	                    break;
-	                case "length":
-	                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minLength", typeof res.minLength === "number"
-	                        ? Math.max(res.minLength, check.value)
-	                        : check.value, check.message, refs);
-	                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxLength", typeof res.maxLength === "number"
-	                        ? Math.min(res.maxLength, check.value)
-	                        : check.value, check.message, refs);
-	                    break;
-	                case "includes": {
-	                    addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
-	                    break;
-	                }
-	                case "ip": {
-	                    if (check.version !== "v6") {
-	                        addFormat(res, "ipv4", check.message, refs);
-	                    }
-	                    if (check.version !== "v4") {
-	                        addFormat(res, "ipv6", check.message, refs);
-	                    }
-	                    break;
-	                }
-	                case "base64url":
-	                    addPattern(res, exports.zodPatterns.base64url, check.message, refs);
-	                    break;
-	                case "jwt":
-	                    addPattern(res, exports.zodPatterns.jwt, check.message, refs);
-	                    break;
-	                case "cidr": {
-	                    if (check.version !== "v6") {
-	                        addPattern(res, exports.zodPatterns.ipv4Cidr, check.message, refs);
-	                    }
-	                    if (check.version !== "v4") {
-	                        addPattern(res, exports.zodPatterns.ipv6Cidr, check.message, refs);
-	                    }
-	                    break;
-	                }
-	                case "emoji":
-	                    addPattern(res, exports.zodPatterns.emoji(), check.message, refs);
-	                    break;
-	                case "ulid": {
-	                    addPattern(res, exports.zodPatterns.ulid, check.message, refs);
-	                    break;
-	                }
-	                case "base64": {
-	                    switch (refs.base64Strategy) {
-	                        case "format:binary": {
-	                            addFormat(res, "binary", check.message, refs);
-	                            break;
-	                        }
-	                        case "contentEncoding:base64": {
-	                            (0, errorMessages_js_1.setResponseValueAndErrors)(res, "contentEncoding", "base64", check.message, refs);
-	                            break;
-	                        }
-	                        case "pattern:zod": {
-	                            addPattern(res, exports.zodPatterns.base64, check.message, refs);
-	                            break;
-	                        }
-	                    }
-	                    break;
-	                }
-	                case "nanoid": {
-	                    addPattern(res, exports.zodPatterns.nanoid, check.message, refs);
-	                }
-	            }
-	        }
-	    }
-	    return res;
-	}
-	exports.parseStringDef = parseStringDef;
-	function escapeLiteralCheckValue(literal, refs) {
-	    return refs.patternStrategy === "escape"
-	        ? escapeNonAlphaNumeric(literal)
-	        : literal;
-	}
-	const ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-	function escapeNonAlphaNumeric(source) {
-	    let result = "";
-	    for (let i = 0; i < source.length; i++) {
-	        if (!ALPHA_NUMERIC.has(source[i])) {
-	            result += "\\";
-	        }
-	        result += source[i];
-	    }
-	    return result;
-	}
-	// Adds a "format" keyword to the schema. If a format exists, both formats will be joined in an allOf-node, along with subsequent ones.
-	function addFormat(schema, value, message, refs) {
-	    if (schema.format || schema.anyOf?.some((x) => x.format)) {
-	        if (!schema.anyOf) {
-	            schema.anyOf = [];
-	        }
-	        if (schema.format) {
-	            schema.anyOf.push({
-	                format: schema.format,
-	                ...(schema.errorMessage &&
-	                    refs.errorMessages && {
-	                    errorMessage: { format: schema.errorMessage.format },
-	                }),
-	            });
-	            delete schema.format;
-	            if (schema.errorMessage) {
-	                delete schema.errorMessage.format;
-	                if (Object.keys(schema.errorMessage).length === 0) {
-	                    delete schema.errorMessage;
-	                }
-	            }
-	        }
-	        schema.anyOf.push({
-	            format: value,
-	            ...(message &&
-	                refs.errorMessages && { errorMessage: { format: message } }),
-	        });
-	    }
-	    else {
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "format", value, message, refs);
-	    }
-	}
-	// Adds a "pattern" keyword to the schema. If a pattern exists, both patterns will be joined in an allOf-node, along with subsequent ones.
-	function addPattern(schema, regex, message, refs) {
-	    if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
-	        if (!schema.allOf) {
-	            schema.allOf = [];
-	        }
-	        if (schema.pattern) {
-	            schema.allOf.push({
-	                pattern: schema.pattern,
-	                ...(schema.errorMessage &&
-	                    refs.errorMessages && {
-	                    errorMessage: { pattern: schema.errorMessage.pattern },
-	                }),
-	            });
-	            delete schema.pattern;
-	            if (schema.errorMessage) {
-	                delete schema.errorMessage.pattern;
-	                if (Object.keys(schema.errorMessage).length === 0) {
-	                    delete schema.errorMessage;
-	                }
-	            }
-	        }
-	        schema.allOf.push({
-	            pattern: stringifyRegExpWithFlags(regex, refs),
-	            ...(message &&
-	                refs.errorMessages && { errorMessage: { pattern: message } }),
-	        });
-	    }
-	    else {
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
-	    }
-	}
-	// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true
-	function stringifyRegExpWithFlags(regex, refs) {
-	    if (!refs.applyRegexFlags || !regex.flags) {
-	        return regex.source;
-	    }
-	    // Currently handled flags
-	    const flags = {
-	        i: regex.flags.includes("i"),
-	        m: regex.flags.includes("m"),
-	        s: regex.flags.includes("s"), // `.` matches newlines
-	    };
-	    // The general principle here is to step through each character, one at a time, applying mutations as flags require. We keep track when the current character is escaped, and when it's inside a group /like [this]/ or (also) a range like /[a-z]/. The following is fairly brittle imperative code; edit at your peril!
-	    const source = flags.i ? regex.source.toLowerCase() : regex.source;
-	    let pattern = "";
-	    let isEscaped = false;
-	    let inCharGroup = false;
-	    let inCharRange = false;
-	    for (let i = 0; i < source.length; i++) {
-	        if (isEscaped) {
-	            pattern += source[i];
-	            isEscaped = false;
-	            continue;
-	        }
-	        if (flags.i) {
-	            if (inCharGroup) {
-	                if (source[i].match(/[a-z]/)) {
-	                    if (inCharRange) {
-	                        pattern += source[i];
-	                        pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
-	                        inCharRange = false;
-	                    }
-	                    else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
-	                        pattern += source[i];
-	                        inCharRange = true;
-	                    }
-	                    else {
-	                        pattern += `${source[i]}${source[i].toUpperCase()}`;
-	                    }
-	                    continue;
-	                }
-	            }
-	            else if (source[i].match(/[a-z]/)) {
-	                pattern += `[${source[i]}${source[i].toUpperCase()}]`;
-	                continue;
-	            }
-	        }
-	        if (flags.m) {
-	            if (source[i] === "^") {
-	                pattern += `(^|(?<=[\r\n]))`;
-	                continue;
-	            }
-	            else if (source[i] === "$") {
-	                pattern += `($|(?=[\r\n]))`;
-	                continue;
-	            }
-	        }
-	        if (flags.s && source[i] === ".") {
-	            pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
-	            continue;
-	        }
-	        pattern += source[i];
-	        if (source[i] === "\\") {
-	            isEscaped = true;
-	        }
-	        else if (inCharGroup && source[i] === "]") {
-	            inCharGroup = false;
-	        }
-	        else if (!inCharGroup && source[i] === "[") {
-	            inCharGroup = true;
-	        }
-	    }
-	    try {
-	        new RegExp(pattern);
-	    }
-	    catch {
-	        console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
-	        return regex.source;
-	    }
-	    return pattern;
-	} 
-} (string));
-
-var hasRequiredRecord;
-
-function requireRecord () {
-	if (hasRequiredRecord) return record;
-	hasRequiredRecord = 1;
-	Object.defineProperty(record, "__esModule", { value: true });
-	record.parseRecordDef = void 0;
-	const v3_1 = v3;
-	const parseDef_js_1 = requireParseDef();
-	const string_js_1 = string;
-	const branded_js_1 = requireBranded();
-	const any_js_1 = any;
-	function parseRecordDef(def, refs) {
-	    if (refs.target === "openAi") {
-	        console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
-	    }
-	    if (refs.target === "openApi3" &&
-	        def.keyType?._def.typeName === v3_1.ZodFirstPartyTypeKind.ZodEnum) {
-	        return {
-	            type: "object",
-	            required: def.keyType._def.values,
-	            properties: def.keyType._def.values.reduce((acc, key) => ({
-	                ...acc,
-	                [key]: (0, parseDef_js_1.parseDef)(def.valueType._def, {
-	                    ...refs,
-	                    currentPath: [...refs.currentPath, "properties", key],
-	                }) ?? (0, any_js_1.parseAnyDef)(refs),
-	            }), {}),
-	            additionalProperties: refs.rejectedAdditionalProperties,
-	        };
-	    }
-	    const schema = {
-	        type: "object",
-	        additionalProperties: (0, parseDef_js_1.parseDef)(def.valueType._def, {
-	            ...refs,
-	            currentPath: [...refs.currentPath, "additionalProperties"],
-	        }) ?? refs.allowedAdditionalProperties,
-	    };
-	    if (refs.target === "openApi3") {
-	        return schema;
-	    }
-	    if (def.keyType?._def.typeName === v3_1.ZodFirstPartyTypeKind.ZodString &&
-	        def.keyType._def.checks?.length) {
-	        const { type, ...keyType } = (0, string_js_1.parseStringDef)(def.keyType._def, refs);
-	        return {
-	            ...schema,
-	            propertyNames: keyType,
-	        };
-	    }
-	    else if (def.keyType?._def.typeName === v3_1.ZodFirstPartyTypeKind.ZodEnum) {
-	        return {
-	            ...schema,
-	            propertyNames: {
-	                enum: def.keyType._def.values,
-	            },
-	        };
-	    }
-	    else if (def.keyType?._def.typeName === v3_1.ZodFirstPartyTypeKind.ZodBranded &&
-	        def.keyType._def.type._def.typeName === v3_1.ZodFirstPartyTypeKind.ZodString &&
-	        def.keyType._def.type._def.checks?.length) {
-	        const { type, ...keyType } = (0, branded_js_1.parseBrandedDef)(def.keyType._def, refs);
-	        return {
-	            ...schema,
-	            propertyNames: keyType,
-	        };
-	    }
-	    return schema;
-	}
-	record.parseRecordDef = parseRecordDef;
-	return record;
-}
-
-var hasRequiredMap;
-
-function requireMap () {
-	if (hasRequiredMap) return map;
-	hasRequiredMap = 1;
-	Object.defineProperty(map, "__esModule", { value: true });
-	map.parseMapDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const record_js_1 = requireRecord();
-	const any_js_1 = any;
-	function parseMapDef(def, refs) {
-	    if (refs.mapStrategy === "record") {
-	        return (0, record_js_1.parseRecordDef)(def, refs);
-	    }
-	    const keys = (0, parseDef_js_1.parseDef)(def.keyType._def, {
-	        ...refs,
-	        currentPath: [...refs.currentPath, "items", "items", "0"],
-	    }) || (0, any_js_1.parseAnyDef)(refs);
-	    const values = (0, parseDef_js_1.parseDef)(def.valueType._def, {
-	        ...refs,
-	        currentPath: [...refs.currentPath, "items", "items", "1"],
-	    }) || (0, any_js_1.parseAnyDef)(refs);
-	    return {
-	        type: "array",
-	        maxItems: 125,
-	        items: {
-	            type: "array",
-	            items: [keys, values],
-	            minItems: 2,
-	            maxItems: 2,
-	        },
-	    };
-	}
-	map.parseMapDef = parseMapDef;
-	return map;
-}
-
-var nativeEnum = {};
-
-Object.defineProperty(nativeEnum, "__esModule", { value: true });
-nativeEnum.parseNativeEnumDef = void 0;
-function parseNativeEnumDef(def) {
-    const object = def.values;
-    const actualKeys = Object.keys(def.values).filter((key) => {
-        return typeof object[object[key]] !== "number";
-    });
-    const actualValues = actualKeys.map((key) => object[key]);
-    const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
-    return {
-        type: parsedTypes.length === 1
-            ? parsedTypes[0] === "string"
-                ? "string"
-                : "number"
-            : ["string", "number"],
-        enum: actualValues,
-    };
-}
-nativeEnum.parseNativeEnumDef = parseNativeEnumDef;
-
-var never = {};
-
-Object.defineProperty(never, "__esModule", { value: true });
-never.parseNeverDef = void 0;
-const any_js_1$3 = any;
-function parseNeverDef(refs) {
-    return refs.target === "openAi"
-        ? undefined
-        : {
-            not: (0, any_js_1$3.parseAnyDef)({
-                ...refs,
-                currentPath: [...refs.currentPath, "not"],
-            }),
-        };
-}
-never.parseNeverDef = parseNeverDef;
-
-var _null = {};
-
-Object.defineProperty(_null, "__esModule", { value: true });
-_null.parseNullDef = void 0;
-function parseNullDef(refs) {
-    return refs.target === "openApi3"
-        ? {
-            enum: ["null"],
-            nullable: true,
-        }
-        : {
-            type: "null",
-        };
-}
-_null.parseNullDef = parseNullDef;
-
-var nullable = {};
-
-var union = {};
-
-var hasRequiredUnion;
-
-function requireUnion () {
-	if (hasRequiredUnion) return union;
-	hasRequiredUnion = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.parseUnionDef = exports.primitiveMappings = void 0;
-		const parseDef_js_1 = requireParseDef();
-		exports.primitiveMappings = {
-		    ZodString: "string",
-		    ZodNumber: "number",
-		    ZodBigInt: "integer",
-		    ZodBoolean: "boolean",
-		    ZodNull: "null",
-		};
-		function parseUnionDef(def, refs) {
-		    if (refs.target === "openApi3")
-		        return asAnyOf(def, refs);
-		    const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-		    // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
-		    if (options.every((x) => x._def.typeName in exports.primitiveMappings &&
-		        (!x._def.checks || !x._def.checks.length))) {
-		        // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
-		        const types = options.reduce((types, x) => {
-		            const type = exports.primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43
-		            return type && !types.includes(type) ? [...types, type] : types;
-		        }, []);
-		        return {
-		            type: types.length > 1 ? types : types[0],
-		        };
-		    }
-		    else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-		        // all options literals
-		        const types = options.reduce((acc, x) => {
-		            const type = typeof x._def.value;
-		            switch (type) {
-		                case "string":
-		                case "number":
-		                case "boolean":
-		                    return [...acc, type];
-		                case "bigint":
-		                    return [...acc, "integer"];
-		                case "object":
-		                    if (x._def.value === null)
-		                        return [...acc, "null"];
-		                case "symbol":
-		                case "undefined":
-		                case "function":
-		                default:
-		                    return acc;
-		            }
-		        }, []);
-		        if (types.length === options.length) {
-		            // all the literals are primitive, as far as null can be considered primitive
-		            const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-		            return {
-		                type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-		                enum: options.reduce((acc, x) => {
-		                    return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-		                }, []),
-		            };
-		        }
-		    }
-		    else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-		        return {
-		            type: "string",
-		            enum: options.reduce((acc, x) => [
-		                ...acc,
-		                ...x._def.values.filter((x) => !acc.includes(x)),
-		            ], []),
-		        };
-		    }
-		    return asAnyOf(def, refs);
-		}
-		exports.parseUnionDef = parseUnionDef;
-		const asAnyOf = (def, refs) => {
-		    const anyOf = (def.options instanceof Map
-		        ? Array.from(def.options.values())
-		        : def.options)
-		        .map((x, i) => (0, parseDef_js_1.parseDef)(x._def, {
-		        ...refs,
-		        currentPath: [...refs.currentPath, "anyOf", `${i}`],
-		    }))
-		        .filter((x) => !!x &&
-		        (!refs.strictUnions ||
-		            (typeof x === "object" && Object.keys(x).length > 0)));
-		    return anyOf.length ? { anyOf } : undefined;
-		}; 
-	} (union));
-	return union;
-}
-
-var hasRequiredNullable;
-
-function requireNullable () {
-	if (hasRequiredNullable) return nullable;
-	hasRequiredNullable = 1;
-	Object.defineProperty(nullable, "__esModule", { value: true });
-	nullable.parseNullableDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const union_js_1 = requireUnion();
-	function parseNullableDef(def, refs) {
-	    if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) &&
-	        (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-	        if (refs.target === "openApi3") {
-	            return {
-	                type: union_js_1.primitiveMappings[def.innerType._def.typeName],
-	                nullable: true,
-	            };
-	        }
-	        return {
-	            type: [
-	                union_js_1.primitiveMappings[def.innerType._def.typeName],
-	                "null",
-	            ],
-	        };
-	    }
-	    if (refs.target === "openApi3") {
-	        const base = (0, parseDef_js_1.parseDef)(def.innerType._def, {
-	            ...refs,
-	            currentPath: [...refs.currentPath],
-	        });
-	        if (base && "$ref" in base)
-	            return { allOf: [base], nullable: true };
-	        return base && { ...base, nullable: true };
-	    }
-	    const base = (0, parseDef_js_1.parseDef)(def.innerType._def, {
-	        ...refs,
-	        currentPath: [...refs.currentPath, "anyOf", "0"],
-	    });
-	    return base && { anyOf: [base, { type: "null" }] };
-	}
-	nullable.parseNullableDef = parseNullableDef;
-	return nullable;
-}
-
-var number = {};
-
-Object.defineProperty(number, "__esModule", { value: true });
-number.parseNumberDef = void 0;
-const errorMessages_js_1 = errorMessages;
-function parseNumberDef(def, refs) {
-    const res = {
-        type: "number",
-    };
-    if (!def.checks)
-        return res;
-    for (const check of def.checks) {
-        switch (check.kind) {
-            case "int":
-                res.type = "integer";
-                (0, errorMessages_js_1.addErrorMessage)(res, "type", check.message, refs);
-                break;
-            case "min":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
-                    }
-                    else {
-                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMinimum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMinimum = true;
-                    }
-                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
-                }
-                break;
-            case "max":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
-                    }
-                    else {
-                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMaximum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMaximum = true;
-                    }
-                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
-                }
-                break;
-            case "multipleOf":
-                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "multipleOf", check.value, check.message, refs);
-                break;
-        }
-    }
-    return res;
-}
-number.parseNumberDef = parseNumberDef;
-
-var object = {};
-
-var hasRequiredObject;
-
-function requireObject () {
-	if (hasRequiredObject) return object;
-	hasRequiredObject = 1;
-	Object.defineProperty(object, "__esModule", { value: true });
-	object.parseObjectDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	function parseObjectDef(def, refs) {
-	    const forceOptionalIntoNullable = refs.target === "openAi";
-	    const result = {
-	        type: "object",
-	        properties: {},
-	    };
-	    const required = [];
-	    const shape = def.shape();
-	    for (const propName in shape) {
-	        let propDef = shape[propName];
-	        if (propDef === undefined || propDef._def === undefined) {
-	            continue;
-	        }
-	        let propOptional = safeIsOptional(propDef);
-	        if (propOptional && forceOptionalIntoNullable) {
-	            if (propDef._def.typeName === "ZodOptional") {
-	                propDef = propDef._def.innerType;
-	            }
-	            if (!propDef.isNullable()) {
-	                propDef = propDef.nullable();
-	            }
-	            propOptional = false;
-	        }
-	        const parsedDef = (0, parseDef_js_1.parseDef)(propDef._def, {
-	            ...refs,
-	            currentPath: [...refs.currentPath, "properties", propName],
-	            propertyPath: [...refs.currentPath, "properties", propName],
-	        });
-	        if (parsedDef === undefined) {
-	            continue;
-	        }
-	        result.properties[propName] = parsedDef;
-	        if (!propOptional) {
-	            required.push(propName);
-	        }
-	    }
-	    if (required.length) {
-	        result.required = required;
-	    }
-	    const additionalProperties = decideAdditionalProperties(def, refs);
-	    if (additionalProperties !== undefined) {
-	        result.additionalProperties = additionalProperties;
-	    }
-	    return result;
-	}
-	object.parseObjectDef = parseObjectDef;
-	function decideAdditionalProperties(def, refs) {
-	    if (def.catchall._def.typeName !== "ZodNever") {
-	        return (0, parseDef_js_1.parseDef)(def.catchall._def, {
-	            ...refs,
-	            currentPath: [...refs.currentPath, "additionalProperties"],
-	        });
-	    }
-	    switch (def.unknownKeys) {
-	        case "passthrough":
-	            return refs.allowedAdditionalProperties;
-	        case "strict":
-	            return refs.rejectedAdditionalProperties;
-	        case "strip":
-	            return refs.removeAdditionalStrategy === "strict"
-	                ? refs.allowedAdditionalProperties
-	                : refs.rejectedAdditionalProperties;
-	    }
-	}
-	function safeIsOptional(schema) {
-	    try {
-	        return schema.isOptional();
-	    }
-	    catch {
-	        return true;
-	    }
-	}
-	return object;
-}
-
-var optional = {};
-
-var hasRequiredOptional;
-
-function requireOptional () {
-	if (hasRequiredOptional) return optional;
-	hasRequiredOptional = 1;
-	Object.defineProperty(optional, "__esModule", { value: true });
-	optional.parseOptionalDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const any_js_1 = any;
-	const parseOptionalDef = (def, refs) => {
-	    if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
-	        return (0, parseDef_js_1.parseDef)(def.innerType._def, refs);
-	    }
-	    const innerSchema = (0, parseDef_js_1.parseDef)(def.innerType._def, {
-	        ...refs,
-	        currentPath: [...refs.currentPath, "anyOf", "1"],
-	    });
-	    return innerSchema
-	        ? {
-	            anyOf: [
-	                {
-	                    not: (0, any_js_1.parseAnyDef)(refs),
-	                },
-	                innerSchema,
-	            ],
-	        }
-	        : (0, any_js_1.parseAnyDef)(refs);
-	};
-	optional.parseOptionalDef = parseOptionalDef;
-	return optional;
-}
-
-var pipeline = {};
-
-var hasRequiredPipeline;
-
-function requirePipeline () {
-	if (hasRequiredPipeline) return pipeline;
-	hasRequiredPipeline = 1;
-	Object.defineProperty(pipeline, "__esModule", { value: true });
-	pipeline.parsePipelineDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const parsePipelineDef = (def, refs) => {
-	    if (refs.pipeStrategy === "input") {
-	        return (0, parseDef_js_1.parseDef)(def.in._def, refs);
-	    }
-	    else if (refs.pipeStrategy === "output") {
-	        return (0, parseDef_js_1.parseDef)(def.out._def, refs);
-	    }
-	    const a = (0, parseDef_js_1.parseDef)(def.in._def, {
-	        ...refs,
-	        currentPath: [...refs.currentPath, "allOf", "0"],
-	    });
-	    const b = (0, parseDef_js_1.parseDef)(def.out._def, {
-	        ...refs,
-	        currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"],
-	    });
-	    return {
-	        allOf: [a, b].filter((x) => x !== undefined),
-	    };
-	};
-	pipeline.parsePipelineDef = parsePipelineDef;
-	return pipeline;
-}
-
-var promise = {};
-
-var hasRequiredPromise;
-
-function requirePromise () {
-	if (hasRequiredPromise) return promise;
-	hasRequiredPromise = 1;
-	Object.defineProperty(promise, "__esModule", { value: true });
-	promise.parsePromiseDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	function parsePromiseDef(def, refs) {
-	    return (0, parseDef_js_1.parseDef)(def.type._def, refs);
-	}
-	promise.parsePromiseDef = parsePromiseDef;
-	return promise;
-}
-
-var set = {};
-
-var hasRequiredSet;
-
-function requireSet () {
-	if (hasRequiredSet) return set;
-	hasRequiredSet = 1;
-	Object.defineProperty(set, "__esModule", { value: true });
-	set.parseSetDef = void 0;
-	const errorMessages_js_1 = errorMessages;
-	const parseDef_js_1 = requireParseDef();
-	function parseSetDef(def, refs) {
-	    const items = (0, parseDef_js_1.parseDef)(def.valueType._def, {
-	        ...refs,
-	        currentPath: [...refs.currentPath, "items"],
-	    });
-	    const schema = {
-	        type: "array",
-	        uniqueItems: true,
-	        items,
-	    };
-	    if (def.minSize) {
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "minItems", def.minSize.value, def.minSize.message, refs);
-	    }
-	    if (def.maxSize) {
-	        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
-	    }
-	    return schema;
-	}
-	set.parseSetDef = parseSetDef;
-	return set;
-}
-
-var tuple = {};
-
-var hasRequiredTuple;
-
-function requireTuple () {
-	if (hasRequiredTuple) return tuple;
-	hasRequiredTuple = 1;
-	Object.defineProperty(tuple, "__esModule", { value: true });
-	tuple.parseTupleDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	function parseTupleDef(def, refs) {
-	    if (def.rest) {
-	        return {
-	            type: "array",
-	            minItems: def.items.length,
-	            items: def.items
-	                .map((x, i) => (0, parseDef_js_1.parseDef)(x._def, {
-	                ...refs,
-	                currentPath: [...refs.currentPath, "items", `${i}`],
-	            }))
-	                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
-	            additionalItems: (0, parseDef_js_1.parseDef)(def.rest._def, {
-	                ...refs,
-	                currentPath: [...refs.currentPath, "additionalItems"],
-	            }),
-	        };
-	    }
-	    else {
-	        return {
-	            type: "array",
-	            minItems: def.items.length,
-	            maxItems: def.items.length,
-	            items: def.items
-	                .map((x, i) => (0, parseDef_js_1.parseDef)(x._def, {
-	                ...refs,
-	                currentPath: [...refs.currentPath, "items", `${i}`],
-	            }))
-	                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
-	        };
-	    }
-	}
-	tuple.parseTupleDef = parseTupleDef;
-	return tuple;
-}
-
-var _undefined = {};
-
-Object.defineProperty(_undefined, "__esModule", { value: true });
-_undefined.parseUndefinedDef = void 0;
-const any_js_1$2 = any;
-function parseUndefinedDef(refs) {
-    return {
-        not: (0, any_js_1$2.parseAnyDef)(refs),
-    };
-}
-_undefined.parseUndefinedDef = parseUndefinedDef;
-
-var unknown = {};
-
-Object.defineProperty(unknown, "__esModule", { value: true });
-unknown.parseUnknownDef = void 0;
-const any_js_1$1 = any;
-function parseUnknownDef(refs) {
-    return (0, any_js_1$1.parseAnyDef)(refs);
-}
-unknown.parseUnknownDef = parseUnknownDef;
-
-var readonly = {};
-
-var hasRequiredReadonly;
-
-function requireReadonly () {
-	if (hasRequiredReadonly) return readonly;
-	hasRequiredReadonly = 1;
-	Object.defineProperty(readonly, "__esModule", { value: true });
-	readonly.parseReadonlyDef = void 0;
-	const parseDef_js_1 = requireParseDef();
-	const parseReadonlyDef = (def, refs) => {
-	    return (0, parseDef_js_1.parseDef)(def.innerType._def, refs);
-	};
-	readonly.parseReadonlyDef = parseReadonlyDef;
-	return readonly;
-}
-
-var hasRequiredSelectParser;
-
-function requireSelectParser () {
-	if (hasRequiredSelectParser) return selectParser;
-	hasRequiredSelectParser = 1;
-	Object.defineProperty(selectParser, "__esModule", { value: true });
-	selectParser.selectParser = void 0;
-	const v3_1 = v3;
-	const any_js_1 = any;
-	const array_js_1 = requireArray();
-	const bigint_js_1 = bigint;
-	const boolean_js_1 = boolean;
-	const branded_js_1 = requireBranded();
-	const catch_js_1 = require_catch();
-	const date_js_1 = date;
-	const default_js_1 = require_default();
-	const effects_js_1 = requireEffects();
-	const enum_js_1 = _enum$1;
-	const intersection_js_1 = requireIntersection();
-	const literal_js_1 = literal;
-	const map_js_1 = requireMap();
-	const nativeEnum_js_1 = nativeEnum;
-	const never_js_1 = never;
-	const null_js_1 = _null;
-	const nullable_js_1 = requireNullable();
-	const number_js_1 = number;
-	const object_js_1 = requireObject();
-	const optional_js_1 = requireOptional();
-	const pipeline_js_1 = requirePipeline();
-	const promise_js_1 = requirePromise();
-	const record_js_1 = requireRecord();
-	const set_js_1 = requireSet();
-	const string_js_1 = string;
-	const tuple_js_1 = requireTuple();
-	const undefined_js_1 = _undefined;
-	const union_js_1 = requireUnion();
-	const unknown_js_1 = unknown;
-	const readonly_js_1 = requireReadonly();
-	const selectParser$1 = (def, typeName, refs) => {
-	    switch (typeName) {
-	        case v3_1.ZodFirstPartyTypeKind.ZodString:
-	            return (0, string_js_1.parseStringDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodNumber:
-	            return (0, number_js_1.parseNumberDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodObject:
-	            return (0, object_js_1.parseObjectDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodBigInt:
-	            return (0, bigint_js_1.parseBigintDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodBoolean:
-	            return (0, boolean_js_1.parseBooleanDef)();
-	        case v3_1.ZodFirstPartyTypeKind.ZodDate:
-	            return (0, date_js_1.parseDateDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodUndefined:
-	            return (0, undefined_js_1.parseUndefinedDef)(refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodNull:
-	            return (0, null_js_1.parseNullDef)(refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodArray:
-	            return (0, array_js_1.parseArrayDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodUnion:
-	        case v3_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-	            return (0, union_js_1.parseUnionDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodIntersection:
-	            return (0, intersection_js_1.parseIntersectionDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodTuple:
-	            return (0, tuple_js_1.parseTupleDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodRecord:
-	            return (0, record_js_1.parseRecordDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodLiteral:
-	            return (0, literal_js_1.parseLiteralDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodEnum:
-	            return (0, enum_js_1.parseEnumDef)(def);
-	        case v3_1.ZodFirstPartyTypeKind.ZodNativeEnum:
-	            return (0, nativeEnum_js_1.parseNativeEnumDef)(def);
-	        case v3_1.ZodFirstPartyTypeKind.ZodNullable:
-	            return (0, nullable_js_1.parseNullableDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodOptional:
-	            return (0, optional_js_1.parseOptionalDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodMap:
-	            return (0, map_js_1.parseMapDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodSet:
-	            return (0, set_js_1.parseSetDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodLazy:
-	            return () => def.getter()._def;
-	        case v3_1.ZodFirstPartyTypeKind.ZodPromise:
-	            return (0, promise_js_1.parsePromiseDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodNaN:
-	        case v3_1.ZodFirstPartyTypeKind.ZodNever:
-	            return (0, never_js_1.parseNeverDef)(refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodEffects:
-	            return (0, effects_js_1.parseEffectsDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodAny:
-	            return (0, any_js_1.parseAnyDef)(refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodUnknown:
-	            return (0, unknown_js_1.parseUnknownDef)(refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodDefault:
-	            return (0, default_js_1.parseDefaultDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodBranded:
-	            return (0, branded_js_1.parseBrandedDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodReadonly:
-	            return (0, readonly_js_1.parseReadonlyDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodCatch:
-	            return (0, catch_js_1.parseCatchDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodPipeline:
-	            return (0, pipeline_js_1.parsePipelineDef)(def, refs);
-	        case v3_1.ZodFirstPartyTypeKind.ZodFunction:
-	        case v3_1.ZodFirstPartyTypeKind.ZodVoid:
-	        case v3_1.ZodFirstPartyTypeKind.ZodSymbol:
-	            return undefined;
-	        default:
-	            return ((_) => undefined)();
-	    }
-	};
-	selectParser.selectParser = selectParser$1;
-	return selectParser;
-}
-
-var hasRequiredParseDef;
-
-function requireParseDef () {
-	if (hasRequiredParseDef) return parseDef;
-	hasRequiredParseDef = 1;
-	Object.defineProperty(parseDef, "__esModule", { value: true });
-	parseDef.parseDef = void 0;
-	const Options_js_1 = Options;
-	const selectParser_js_1 = requireSelectParser();
-	const getRelativePath_js_1 = getRelativePath$1;
-	const any_js_1 = any;
-	function parseDef$1(def, refs, forceResolution = false) {
-	    const seenItem = refs.seen.get(def);
-	    if (refs.override) {
-	        const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
-	        if (overrideResult !== Options_js_1.ignoreOverride) {
-	            return overrideResult;
-	        }
-	    }
-	    if (seenItem && !forceResolution) {
-	        const seenSchema = get$ref(seenItem, refs);
-	        if (seenSchema !== undefined) {
-	            return seenSchema;
-	        }
-	    }
-	    const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
-	    refs.seen.set(def, newItem);
-	    const jsonSchemaOrGetter = (0, selectParser_js_1.selectParser)(def, def.typeName, refs);
-	    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)
-	    const jsonSchema = typeof jsonSchemaOrGetter === "function"
-	        ? parseDef$1(jsonSchemaOrGetter(), refs)
-	        : jsonSchemaOrGetter;
-	    if (jsonSchema) {
-	        addMeta(def, refs, jsonSchema);
-	    }
-	    if (refs.postProcess) {
-	        const postProcessResult = refs.postProcess(jsonSchema, def, refs);
-	        newItem.jsonSchema = jsonSchema;
-	        return postProcessResult;
-	    }
-	    newItem.jsonSchema = jsonSchema;
-	    return jsonSchema;
-	}
-	parseDef.parseDef = parseDef$1;
-	const get$ref = (item, refs) => {
-	    switch (refs.$refStrategy) {
-	        case "root":
-	            return { $ref: item.path.join("/") };
-	        case "relative":
-	            return { $ref: (0, getRelativePath_js_1.getRelativePath)(refs.currentPath, item.path) };
-	        case "none":
-	        case "seen": {
-	            if (item.path.length < refs.currentPath.length &&
-	                item.path.every((value, index) => refs.currentPath[index] === value)) {
-	                console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-	                return (0, any_js_1.parseAnyDef)(refs);
-	            }
-	            return refs.$refStrategy === "seen" ? (0, any_js_1.parseAnyDef)(refs) : undefined;
-	        }
-	    }
-	};
-	const addMeta = (def, refs, jsonSchema) => {
-	    if (def.description) {
-	        jsonSchema.description = def.description;
-	        if (refs.markdownDescription) {
-	            jsonSchema.markdownDescription = def.description;
-	        }
-	    }
-	    return jsonSchema;
-	};
-	return parseDef;
-}
-
-var parseTypes = {};
-
-Object.defineProperty(parseTypes, "__esModule", { value: true });
-
-var zodToJsonSchema$1 = {};
-
-Object.defineProperty(zodToJsonSchema$1, "__esModule", { value: true });
-zodToJsonSchema$1.zodToJsonSchema = void 0;
-const parseDef_js_1 = requireParseDef();
-const Refs_js_1 = Refs;
-const any_js_1 = any;
-const zodToJsonSchema = (schema, options) => {
-    const refs = (0, Refs_js_1.getRefs)(options);
-    let definitions = typeof options === "object" && options.definitions
-        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
-            ...acc,
-            [name]: (0, parseDef_js_1.parseDef)(schema._def, {
-                ...refs,
-                currentPath: [...refs.basePath, refs.definitionPath, name],
-            }, true) ?? (0, any_js_1.parseAnyDef)(refs),
-        }), {})
-        : undefined;
-    const name = typeof options === "string"
-        ? options
-        : options?.nameStrategy === "title"
-            ? undefined
-            : options?.name;
-    const main = (0, parseDef_js_1.parseDef)(schema._def, name === undefined
-        ? refs
-        : {
-            ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name],
-        }, false) ?? (0, any_js_1.parseAnyDef)(refs);
-    const title = typeof options === "object" &&
-        options.name !== undefined &&
-        options.nameStrategy === "title"
-        ? options.name
-        : undefined;
-    if (title !== undefined) {
-        main.title = title;
-    }
-    if (refs.flags.hasReferencedOpenAiAnyType) {
-        if (!definitions) {
-            definitions = {};
-        }
-        if (!definitions[refs.openAiAnyTypeName]) {
-            definitions[refs.openAiAnyTypeName] = {
-                // Skipping "object" as no properties can be defined and additionalProperties must be "false"
-                type: ["string", "number", "integer", "boolean", "array", "null"],
-                items: {
-                    $ref: refs.$refStrategy === "relative"
-                        ? "1"
-                        : [
-                            ...refs.basePath,
-                            refs.definitionPath,
-                            refs.openAiAnyTypeName,
-                        ].join("/"),
-                },
-            };
-        }
-    }
-    const combined = name === undefined
-        ? definitions
-            ? {
-                ...main,
-                [refs.definitionPath]: definitions,
-            }
-            : main
-        : {
-            $ref: [
-                ...(refs.$refStrategy === "relative" ? [] : refs.basePath),
-                refs.definitionPath,
-                name,
-            ].join("/"),
-            [refs.definitionPath]: {
-                ...definitions,
-                [name]: main,
-            },
-        };
-    if (refs.target === "jsonSchema7") {
-        combined.$schema = "http://json-schema.org/draft-07/schema#";
-    }
-    else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
-        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-    }
-    if (refs.target === "openAi" &&
-        ("anyOf" in combined ||
-            "oneOf" in combined ||
-            "allOf" in combined ||
-            ("type" in combined && Array.isArray(combined.type)))) {
-        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
-    }
-    return combined;
-};
-zodToJsonSchema$1.zodToJsonSchema = zodToJsonSchema;
-
-(function (exports) {
-	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    var desc = Object.getOwnPropertyDescriptor(m, k);
-	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-	      desc = { enumerable: true, get: function() { return m[k]; } };
-	    }
-	    Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    o[k2] = m[k];
-	}));
-	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	__exportStar(Options, exports);
-	__exportStar(Refs, exports);
-	__exportStar(errorMessages, exports);
-	__exportStar(getRelativePath$1, exports);
-	__exportStar(requireParseDef(), exports);
-	__exportStar(parseTypes, exports);
-	__exportStar(any, exports);
-	__exportStar(requireArray(), exports);
-	__exportStar(bigint, exports);
-	__exportStar(boolean, exports);
-	__exportStar(requireBranded(), exports);
-	__exportStar(require_catch(), exports);
-	__exportStar(date, exports);
-	__exportStar(require_default(), exports);
-	__exportStar(requireEffects(), exports);
-	__exportStar(_enum$1, exports);
-	__exportStar(requireIntersection(), exports);
-	__exportStar(literal, exports);
-	__exportStar(requireMap(), exports);
-	__exportStar(nativeEnum, exports);
-	__exportStar(never, exports);
-	__exportStar(_null, exports);
-	__exportStar(requireNullable(), exports);
-	__exportStar(number, exports);
-	__exportStar(requireObject(), exports);
-	__exportStar(requireOptional(), exports);
-	__exportStar(requirePipeline(), exports);
-	__exportStar(requirePromise(), exports);
-	__exportStar(requireReadonly(), exports);
-	__exportStar(requireRecord(), exports);
-	__exportStar(requireSet(), exports);
-	__exportStar(string, exports);
-	__exportStar(requireTuple(), exports);
-	__exportStar(_undefined, exports);
-	__exportStar(requireUnion(), exports);
-	__exportStar(unknown, exports);
-	__exportStar(requireSelectParser(), exports);
-	__exportStar(zodToJsonSchema$1, exports);
-	const zodToJsonSchema_js_1 = zodToJsonSchema$1;
-	exports.default = zodToJsonSchema_js_1.zodToJsonSchema; 
-} (cjs));
-
 // zod-json-schema-compat.ts
 // ----------------------------------------------------
 // JSON Schema conversion for both Zod v3 and Zod v4 (Mini)
@@ -37399,7 +35877,7 @@ zodJsonSchemaCompat.getMethodLiteral = getMethodLiteral;
 zodJsonSchemaCompat.parseWithCompat = parseWithCompat;
 const z4mini = __importStar(v4Mini);
 const zod_compat_js_1$2 = zodCompat;
-const zod_to_json_schema_1 = cjs;
+const zod_to_json_schema_1 = require$$2$4;
 function mapMiniTarget(t) {
     if (!t)
         return 'draft-7';
@@ -47951,7 +46429,7 @@ var import_node_http22 = require$$1$5;
 
 // src/request.ts
 var import_node_http2 = require$$1$5;
-var import_node_stream = require$$5;
+var import_node_stream = require$$5$1;
 var RequestError = class extends Error {
   constructor(message, options) {
     super(message, options);
@@ -49529,7 +48007,7 @@ streamableHttp.StreamableHTTPServerTransport = StreamableHTTPServerTransport$1;
 
 const fs$4 = require$$0$2;
 const path$6 = require$$1$1;
-const forge = require$$2$4;
+const forge = require$$2$5;
 
 /**
  * Get or create a self-signed TLS certificate for localhost.
@@ -58761,7 +57239,7 @@ function requireWidgetPublishManifest () {
  */
 const path$4 = require$$1$1;
 const { app: app$4, dialog: dialog$2 } = require$$0$1;
-const AdmZip$2 = require$$3$1;
+const AdmZip$2 = require$$5;
 
 const themeController$3 = themeController_1;
 const registryController$1 = registryController$3;
@@ -59500,7 +57978,7 @@ var themeRegistryController$1 = {
 
 const { app: app$3, dialog: dialog$1 } = require$$0$1;
 const path$3 = require$$1$1;
-const AdmZip$1 = require$$3$1;
+const AdmZip$1 = require$$5;
 const { getFileContents: getFileContents$1 } = file;
 const {
   validateDashboardConfig,
@@ -61807,7 +60285,7 @@ var notificationController_1 = notificationController$2;
 const { app: app$2 } = require$$0$1;
 const fs$2 = require$$0$2;
 const path$2 = require$$1$1;
-const WebSocket = require$$3$4;
+const WebSocket = require$$3$3;
 const {
   gateNetworkCall,
   gateNetworkCallWithJit,
@@ -63448,7 +61926,7 @@ var dashboardRatingsController = {
 
 const fs$1 = require$$0$2;
 const path = require$$1$1;
-const AdmZip = require$$3$1;
+const AdmZip = require$$5;
 const { app } = require$$0$1;
 
 const registryApiController$1 = registryApiController$3;
@@ -65765,6 +64243,31 @@ const registryApi$2 = {
       throw error;
     }
   },
+
+  /**
+   * Fetch a registry package's `dash.permissions` block WITHOUT
+   * installing it. Powers the pre-install preflight in the update
+   * flow — the renderer learns what MCP/fs/network grants a new
+   * version would need, diffs against what's already granted, and
+   * asks the user for approval BEFORE downloading the install.
+   *
+   * @param {string} packageName
+   * @returns {Promise<{packageId: string, version: string|null, permissions: object|null}>}
+   */
+  fetchPackageManifest: async (packageName) => {
+    try {
+      return await ipcRenderer$f.invoke(
+        "registry:fetch-package-manifest",
+        packageName,
+      );
+    } catch (error) {
+      console.error(
+        `[RegistryApi] Error fetching package manifest for ${packageName}:`,
+        error,
+      );
+      throw error;
+    }
+  },
 };
 
 var registryApi_1 = registryApi$2;