@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/tts/index.cjs

@@ -1,335 +1,10 @@
 'use strict';
 
-var stream = require('stream');
-var pino = require('pino');
-var pretty = require('pino-pretty');
-var api = require('@opentelemetry/api');
+var chunkHJPMYDWO_cjs = require('../chunk-HJPMYDWO.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pretty__default = /*#__PURE__*/_interopDefault(pretty);
 
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = msg => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+Object.defineProperty(exports, "MastraTTS", {
   enumerable: true,
-  configurable: true,
-  writable: true,
-  value
-}) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", {
-  value,
-  configurable: true
+  get: function () { return chunkHJPMYDWO_cjs.MastraTTS; }
 });
-var __decoratorStart = base => [,,, __create(base?.[__knownSymbol("metadata")] ?? null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = fn => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({
-  kind: __decoratorStrings[kind],
-  name,
-  metadata,
-  addInitializer: fn => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
-});
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var it,
-    done,
-    ctx,
-    k = flags & 7,
-    p = false;
-  var j = 0;
-  var extraInitializers = array[j] || (array[j] = []);
-  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
-  __name(target, name);
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    it = (0, decorators[i])(target, ctx), done._ = 1;
-    __expectFn(it) && (target = it);
-  }
-  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-var RegisteredLogger = {
-  LLM: "LLM"};
-var LogLevel = {
-  INFO: "info"};
-var Logger = class {
-  logger;
-  transports;
-  constructor(options = {}) {
-    this.transports = options.transports || {};
-    const transportsAry = Object.entries(this.transports);
-    this.logger = pino__default.default({
-      name: options.name || "app",
-      level: options.level || LogLevel.INFO,
-      formatters: {
-        level: label => {
-          return {
-            level: label
-          };
-        }
-      }
-    }, options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty__default.default({
-      colorize: true,
-      levelFirst: true,
-      ignore: "pid,hostname",
-      colorizeObjects: true,
-      translateTime: "SYS:standard",
-      singleLine: false
-    }) : pino__default.default.multistream([...transportsAry.map(([_, transport]) => ({
-      stream: transport,
-      level: options.level || LogLevel.INFO
-    })), {
-      stream: pretty__default.default({
-        colorize: true,
-        levelFirst: true,
-        ignore: "pid,hostname",
-        colorizeObjects: true,
-        translateTime: "SYS:standard",
-        singleLine: false
-      }),
-      level: options.level || LogLevel.INFO
-    }]));
-  }
-  debug(message, args = {}) {
-    this.logger.debug(args, message);
-  }
-  info(message, args = {}) {
-    this.logger.info(args, message);
-  }
-  warn(message, args = {}) {
-    this.logger.warn(args, message);
-  }
-  error(message, args = {}) {
-    this.logger.error(args, message);
-  }
-  // Stream creation for process output handling
-  createStream() {
-    return new stream.Transform({
-      transform: (chunk, _encoding, callback) => {
-        const line = chunk.toString().trim();
-        if (line) {
-          this.info(line);
-        }
-        callback(null, chunk);
-      }
-    });
-  }
-  async getLogs(transportId) {
-    if (!transportId || !this.transports[transportId]) {
-      return [];
-    }
-    return this.transports[transportId].getLogs();
-  }
-  async getLogsByRunId({
-    runId,
-    transportId
-  }) {
-    return this.transports[transportId]?.getLogsByRunId({
-      runId
-    });
-  }
-};
-function createLogger(options) {
-  return new Logger(options);
-}
-
-// src/base.ts
-var MastraBase = class {
-  component = RegisteredLogger.LLM;
-  logger;
-  name;
-  telemetry;
-  constructor({
-    component,
-    name
-  }) {
-    this.component = component || RegisteredLogger.LLM;
-    this.name = name;
-    this.logger = createLogger({
-      name: `${this.component} - ${this.name}`
-    });
-  }
-  /**
-   * Set the logger for the agent
-   * @param logger
-   */
-  __setLogger(logger) {
-    this.logger = logger;
-    this.logger.debug(`Logger updated [component=${this.component}] [name=${this.name}]`);
-  }
-  /**
-   * Set the telemetry for the
-   * @param telemetry
-   */
-  __setTelemetry(telemetry) {
-    this.telemetry = telemetry;
-    this.logger.debug(`Telemetry updated [component=${this.component}] [tracer=${this.telemetry.tracer}]`);
-  }
-  /**
-   * Get the telemetry on the vector
-   * @returns telemetry
-   */
-  __getTelemetry() {
-    return this.telemetry;
-  }
-  /* 
-    get experimental_telemetry config
-    */
-  get experimental_telemetry() {
-    return this.telemetry ? {
-      // tracer: this.telemetry.tracer,
-      tracer: this.telemetry.getBaggageTracer(),
-      isEnabled: !!this.telemetry.tracer
-    } : void 0;
-  }
-};
-function hasActiveTelemetry(tracerName = "default-tracer") {
-  try {
-    return !!api.trace.getTracer(tracerName);
-  } catch {
-    return false;
-  }
-}
-
-// src/telemetry/telemetry.decorators.ts
-function withSpan(options) {
-  return function (_target, propertyKey, descriptor) {
-    if (!descriptor || typeof descriptor === "number") return;
-    const originalMethod = descriptor.value;
-    const methodName = String(propertyKey);
-    descriptor.value = function (...args) {
-      if (options?.skipIfNoTelemetry && !hasActiveTelemetry(options?.tracerName)) {
-        return originalMethod.apply(this, args);
-      }
-      const tracer = api.trace.getTracer(options?.tracerName ?? "default-tracer");
-      let spanName;
-      let spanKind;
-      if (typeof options === "string") {
-        spanName = options;
-      } else if (options) {
-        spanName = options.spanName || methodName;
-        spanKind = options.spanKind;
-      } else {
-        spanName = methodName;
-      }
-      const span = tracer.startSpan(spanName, {
-        kind: spanKind
-      });
-      let ctx = api.trace.setSpan(api.context.active(), span);
-      args.forEach((arg, index) => {
-        try {
-          span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
-        } catch {
-          span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
-        }
-      });
-      const currentBaggage = api.propagation.getBaggage(ctx);
-      if (currentBaggage?.componentName) {
-        span.setAttribute("componentName", currentBaggage?.componentName);
-        span.setAttribute("runId", currentBaggage?.runId);
-      } else if (this && this.name) {
-        span.setAttribute("componentName", this.name);
-        span.setAttribute("runId", this.runId);
-        ctx = api.propagation.setBaggage(ctx, {
-          componentName: this.name,
-          runId: this.runId
-        });
-      }
-      let result;
-      try {
-        result = api.context.with(ctx, () => originalMethod.apply(this, args));
-        if (result instanceof Promise) {
-          return result.then(resolvedValue => {
-            try {
-              span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
-            } catch {
-              span.setAttribute(`${spanName}.result`, "[Not Serializable]");
-            }
-            return resolvedValue;
-          }).finally(() => span.end());
-        }
-        try {
-          span.setAttribute(`${spanName}.result`, JSON.stringify(result));
-        } catch {
-          span.setAttribute(`${spanName}.result`, "[Not Serializable]");
-        }
-        return result;
-      } catch (error) {
-        span.setStatus({
-          code: api.SpanStatusCode.ERROR,
-          message: error instanceof Error ? error.message : "Unknown error"
-        });
-        if (error instanceof Error) {
-          span.recordException(error);
-        }
-        throw error;
-      } finally {
-        if (!(result instanceof Promise)) {
-          span.end();
-        }
-      }
-    };
-    return descriptor;
-  };
-}
-function InstrumentClass(options) {
-  return function (target) {
-    const methods = Object.getOwnPropertyNames(target.prototype);
-    methods.forEach(method => {
-      if (options?.excludeMethods?.includes(method) || method === "constructor") return;
-      if (options?.methodFilter && !options.methodFilter(method)) return;
-      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, method);
-      if (descriptor && typeof descriptor.value === "function") {
-        Object.defineProperty(target.prototype, method, withSpan({
-          spanName: options?.prefix ? `${options.prefix}.${method}` : method,
-          skipIfNoTelemetry: true,
-          spanKind: options?.spanKind || api.SpanKind.INTERNAL,
-          tracerName: options?.tracerName
-        })(target, method, descriptor));
-      }
-    });
-    return target;
-  };
-}
-
-// src/tts/index.ts
-var _MastraTTS_decorators, _init, _a;
-_MastraTTS_decorators = [InstrumentClass({
-  prefix: "tts",
-  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
-})];
-exports.MastraTTS = class MastraTTS extends (_a = MastraBase) {
-  model;
-  constructor({
-    model
-  }) {
-    super({
-      component: "TTS"
-    });
-    this.model = model;
-  }
-  traced(method, methodName) {
-    return this.telemetry?.traceMethod(method, {
-      spanName: `${this.model.name}-tts.${methodName}`,
-      attributes: {
-        "tts.type": `${this.model.name}`
-      }
-    }) ?? method;
-  }
-};
-exports.MastraTTS = /*@__PURE__*/(_ => {
-  _init = __decoratorStart(_a);
-  exports.MastraTTS = __decorateElement(_init, 0, "MastraTTS", _MastraTTS_decorators, exports.MastraTTS);
-  __runInitializers(_init, 1, exports.MastraTTS);
-  return exports.MastraTTS;
-})();

package/dist/utils.cjs

@@ -1,314 +1,46 @@
 'use strict';
 
-var jsonSchemaToZod = require('json-schema-to-zod');
-var zod = require('zod');
+var chunk43Y7WG5W_cjs = require('./chunk-43Y7WG5W.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var jsonSchemaToZod__default = /*#__PURE__*/_interopDefault(jsonSchemaToZod);
 
-// src/utils.ts
-
-// src/tools/tool.ts
-var Tool = class {
-  id;
-  description;
-  inputSchema;
-  outputSchema;
-  execute;
-  mastra;
-  constructor(opts) {
-    this.id = opts.id;
-    this.description = opts.description;
-    this.inputSchema = opts.inputSchema;
-    this.outputSchema = opts.outputSchema;
-    this.execute = opts.execute;
-    this.mastra = opts.mastra;
-  }
-};
-
-// src/utils.ts
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function jsonSchemaPropertiesToTSTypes(value) {
-  if (!value.type) {
-    return zod.z.object({});
-  }
-  let zodType;
-  switch (value.type) {
-    case "string":
-      zodType = zod.z.string().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "number":
-      zodType = zod.z.number().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "integer":
-      zodType = zod.z.number().int().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "boolean":
-      zodType = zod.z.boolean().describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "array":
-      zodType = zod.z.array(jsonSchemaPropertiesToTSTypes(value.items)).describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-      break;
-    case "object":
-      zodType = jsonSchemaToModel(value).describe(
-        (value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : "")
-      );
-      break;
-    case "null":
-      zodType = zod.z.null().describe(value.description || "");
-      break;
-    default:
-      throw new Error(`Unsupported JSON schema type: ${value.type}`);
-  }
-  return zodType;
-}
-function jsonSchemaToModel(jsonSchema) {
-  const properties = jsonSchema.properties;
-  const requiredFields = jsonSchema.required || [];
-  if (!properties) {
-    return zod.z.object({});
-  }
-  const zodSchema = {};
-  for (const [key, _] of Object.entries(properties)) {
-    const value = _;
-    let zodType;
-    if (value.anyOf) {
-      const anyOfTypes = value.anyOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
-      zodType = zod.z.union(anyOfTypes).describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-    } else if (value.allOf) {
-      const allOfTypes = value.allOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
-      zodType = zod.z.intersection(
-        allOfTypes[0],
-        allOfTypes.slice(1).reduce((acc, schema) => acc.and(schema), allOfTypes[0])
-      ).describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
-    } else {
-      if (!value.type) {
-        value.type = "string";
-      }
-      zodType = jsonSchemaPropertiesToTSTypes(value);
-    }
-    if (value.description) {
-      zodType = zodType.describe(value.description);
-    }
-    if (requiredFields.includes(key)) {
-      zodSchema[key] = zodType;
-    } else {
-      zodSchema[key] = zodType.nullable().optional();
-    }
-  }
-  return zod.z.object(zodSchema);
-}
-function deepMerge(target, source) {
-  const output = { ...target };
-  if (!source) return output;
-  Object.keys(source).forEach((key) => {
-    const targetValue = output[key];
-    const sourceValue = source[key];
-    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
-      output[key] = sourceValue;
-    } else if (sourceValue instanceof Object && targetValue instanceof Object && !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
-      output[key] = deepMerge(targetValue, sourceValue);
-    } else if (sourceValue !== void 0) {
-      output[key] = sourceValue;
-    }
-  });
-  return output;
-}
-async function* maskStreamTags(stream, tag, options = {}) {
-  const { onStart, onEnd, onMask } = options;
-  const openTag = `<${tag}>`;
-  const closeTag = `</${tag}>`;
-  let buffer = "";
-  let fullContent = "";
-  let isMasking = false;
-  let isBuffering = false;
-  const trimOutsideDelimiter = (text, delimiter, trim) => {
-    if (!text.includes(delimiter)) {
-      return text;
-    }
-    const parts = text.split(delimiter);
-    if (trim === `before-start`) {
-      return `${delimiter}${parts[1]}`;
-    }
-    return `${parts[0]}${delimiter}`;
-  };
-  const startsWith = (text, pattern) => {
-    if (pattern.includes(openTag.substring(0, 3))) {
-      pattern = trimOutsideDelimiter(pattern, `<`, `before-start`);
-    }
-    return text.trim().startsWith(pattern.trim());
-  };
-  for await (const chunk of stream) {
-    fullContent += chunk;
-    if (isBuffering) buffer += chunk;
-    const chunkHasTag = startsWith(chunk, openTag);
-    const bufferHasTag = !chunkHasTag && isBuffering && startsWith(openTag, buffer);
-    let toYieldBeforeMaskedStartTag = ``;
-    if (!isMasking && (chunkHasTag || bufferHasTag)) {
-      isMasking = true;
-      isBuffering = false;
-      const taggedTextToMask = trimOutsideDelimiter(buffer, `<`, `before-start`);
-      if (taggedTextToMask !== buffer.trim()) {
-        toYieldBeforeMaskedStartTag = buffer.replace(taggedTextToMask, ``);
-      }
-      buffer = "";
-      onStart?.();
-    }
-    if (!isMasking && !isBuffering && startsWith(openTag, chunk) && chunk.trim() !== "") {
-      isBuffering = true;
-      buffer += chunk;
-      continue;
-    }
-    if (isBuffering && buffer && !startsWith(openTag, buffer)) {
-      yield buffer;
-      buffer = "";
-      isBuffering = false;
-      continue;
-    }
-    if (isMasking && fullContent.includes(closeTag)) {
-      onMask?.(chunk);
-      onEnd?.();
-      isMasking = false;
-      const lastFullContent = fullContent;
-      fullContent = ``;
-      const textUntilEndTag = trimOutsideDelimiter(lastFullContent, closeTag, "after-end");
-      if (textUntilEndTag !== lastFullContent) {
-        yield lastFullContent.replace(textUntilEndTag, ``);
-      }
-      continue;
-    }
-    if (isMasking) {
-      onMask?.(chunk);
-      if (toYieldBeforeMaskedStartTag) {
-        yield toYieldBeforeMaskedStartTag;
-      }
-      continue;
-    }
-    yield chunk;
-  }
-}
-function resolveSerializedZodOutput(schema) {
-  return Function("z", `"use strict";return (${schema});`)(zod.z);
-}
-function isVercelTool(tool) {
-  return !(tool instanceof Tool);
-}
-function createLogMessageOptions({ agentName, toolName, tool, type }) {
-  if (!agentName) {
-    return {
-      start: `Executing tool ${toolName}`,
-      error: `Failed tool execution`
-    };
-  }
-  const prefix = `[Agent:${agentName}]`;
-  const vercelPrefix = isVercelTool(tool) ? "Vercel " : "";
-  const toolType = type === "toolset" ? "toolset" : "tool";
-  return {
-    start: `${prefix} - Executing ${vercelPrefix}${toolType} ${toolName}`,
-    error: `${prefix} - Failed ${vercelPrefix}${toolType} execution`
-  };
-}
-function createExecute(tool, options, logType) {
-  const { logger, ...rest } = options;
-  const { start, error } = createLogMessageOptions({
-    agentName: options.agentName,
-    toolName: options.name,
-    tool,
-    type: logType
-  });
-  const execFunction = async (args, execOptions) => {
-    if (isVercelTool(tool)) {
-      return tool?.execute?.(args, execOptions) ?? void 0;
-    }
-    return tool?.execute?.(
-      {
-        context: args,
-        threadId: options.threadId,
-        resourceId: options.resourceId,
-        mastra: options.mastra,
-        memory: options.memory,
-        runId: options.runId
-      },
-      execOptions
-    ) ?? void 0;
-  };
-  return async (args, execOptions) => {
-    try {
-      logger.debug(start, { ...rest, args });
-      return await execFunction(args, execOptions);
-    } catch (err) {
-      logger.error(error, { ...rest, error: err, args });
-      throw err;
-    }
-  };
-}
-function makeCoreTool(tool, options, logType) {
-  const getParameters = () => {
-    if (isVercelTool(tool)) {
-      return tool.parameters instanceof zod.z.ZodType ? tool.parameters : resolveSerializedZodOutput(jsonSchemaToZod__default.default(tool.parameters));
-    }
-    return tool.inputSchema;
-  };
-  return {
-    description: tool.description,
-    parameters: getParameters(),
-    execute: tool.execute ? createExecute(tool, { ...options, description: tool.description }, logType) : void 0
-  };
-}
-function createMastraProxy({ mastra, logger }) {
-  return new Proxy(mastra, {
-    get(target, prop) {
-      if (Reflect.has(target, prop)) {
-        return Reflect.get(target, prop);
-      }
-      if (prop === "logger") {
-        logger.warn(`Please use 'getLogger' instead, logger is deprecated`);
-        return Reflect.apply(target.getLogger, target, []);
-      }
-      if (prop === "telemetry") {
-        logger.warn(`Please use 'getTelemetry' instead, telemetry is deprecated`);
-        return Reflect.apply(target.getTelemetry, target, []);
-      }
-      if (prop === "storage") {
-        logger.warn(`Please use 'getStorage' instead, storage is deprecated`);
-        return Reflect.get(target, "storage");
-      }
-      if (prop === "agents") {
-        logger.warn(`Please use 'getAgents' instead, agents is deprecated`);
-        return Reflect.apply(target.getAgents, target, []);
-      }
-      if (prop === "tts") {
-        logger.warn(`Please use 'getTTS' instead, tts is deprecated`);
-        return Reflect.apply(target.getTTS, target, []);
-      }
-      if (prop === "vectors") {
-        logger.warn(`Please use 'getVectors' instead, vectors is deprecated`);
-        return Reflect.apply(target.getVectors, target, []);
-      }
-      if (prop === "memory") {
-        logger.warn(`Please use 'getMemory' instead, memory is deprecated`);
-        return Reflect.get(target, "memory");
-      }
-      return Reflect.get(target, prop);
-    }
-  });
-}
-
-exports.createMastraProxy = createMastraProxy;
-exports.deepMerge = deepMerge;
-exports.delay = delay;
-exports.isVercelTool = isVercelTool;
-exports.jsonSchemaPropertiesToTSTypes = jsonSchemaPropertiesToTSTypes;
-exports.jsonSchemaToModel = jsonSchemaToModel;
-exports.makeCoreTool = makeCoreTool;
-exports.maskStreamTags = maskStreamTags;
-exports.resolveSerializedZodOutput = resolveSerializedZodOutput;
+Object.defineProperty(exports, "createMastraProxy", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.createMastraProxy; }
+});
+Object.defineProperty(exports, "deepMerge", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.deepMerge; }
+});
+Object.defineProperty(exports, "delay", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.delay; }
+});
+Object.defineProperty(exports, "ensureToolProperties", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.ensureToolProperties; }
+});
+Object.defineProperty(exports, "isVercelTool", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.isVercelTool; }
+});
+Object.defineProperty(exports, "jsonSchemaPropertiesToTSTypes", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.jsonSchemaPropertiesToTSTypes; }
+});
+Object.defineProperty(exports, "jsonSchemaToModel", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.jsonSchemaToModel; }
+});
+Object.defineProperty(exports, "makeCoreTool", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.makeCoreTool; }
+});
+Object.defineProperty(exports, "maskStreamTags", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.maskStreamTags; }
+});
+Object.defineProperty(exports, "resolveSerializedZodOutput", {
+  enumerable: true,
+  get: function () { return chunk43Y7WG5W_cjs.resolveSerializedZodOutput; }
+});