@mastra/schema-compat 1.1.3 → 1.2.0

package/dist/chunk-FS3P4V5M.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+// src/standard-schema/adapters/ai-sdk.ts
+var VENDOR = "ai-sdk";
+var AiSdkSchemaWrapper = class {
+  #schema;
+  "~standard";
+  constructor(schema) {
+    this.#schema = schema;
+    this["~standard"] = {
+      version: 1,
+      vendor: VENDOR,
+      validate: this.#validate.bind(this),
+      jsonSchema: {
+        input: this.#toJsonSchema.bind(this),
+        output: this.#toJsonSchema.bind(this)
+      }
+    };
+  }
+  /**
+   * Validates a value against the AI SDK Schema.
+   *
+   * @param value - The value to validate
+   * @returns A result object with either the validated value or validation issues
+   */
+  #validate(value) {
+    if (!this.#schema.validate) {
+      return { value };
+    }
+    try {
+      const result = this.#schema.validate(value);
+      if (result && typeof result === "object" && "then" in result && typeof result.then === "function") {
+        return Promise.resolve(
+          result
+        ).then((res) => this.#convertValidationResult(res)).catch((error) => {
+          const message = error instanceof Error ? error.message : "Unknown validation error";
+          return {
+            issues: [{ message: `Schema validation error: ${message}` }]
+          };
+        });
+      }
+      return this.#convertValidationResult(
+        result
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown validation error";
+      return {
+        issues: [{ message: `Schema validation error: ${message}` }]
+      };
+    }
+  }
+  /**
+   * Converts an AI SDK ValidationResult to a StandardSchemaV1.Result.
+   *
+   * @param result - The AI SDK validation result
+   * @returns A StandardSchemaV1.Result
+   */
+  #convertValidationResult(result) {
+    if (result.success) {
+      return { value: result.value };
+    }
+    const failureResult = result;
+    return {
+      issues: [{ message: failureResult.error.message }]
+    };
+  }
+  /**
+   * Returns the JSON Schema in the requested target format.
+   *
+   * @param options - Options including the target format
+   * @returns The JSON Schema as a Record
+   */
+  #toJsonSchema(options) {
+    const { target } = options;
+    const clonedSchema = JSON.parse(JSON.stringify(this.#schema.jsonSchema));
+    if (!clonedSchema.$schema) {
+      switch (target) {
+        case "draft-07":
+          clonedSchema.$schema = "http://json-schema.org/draft-07/schema#";
+          break;
+        case "draft-2020-12":
+          clonedSchema.$schema = "https://json-schema.org/draft/2020-12/schema";
+          break;
+      }
+    }
+    return clonedSchema;
+  }
+  /**
+   * Returns the original AI SDK Schema.
+   */
+  getSchema() {
+    return this.#schema;
+  }
+  /**
+   * Returns the original JSON Schema from the AI SDK Schema.
+   */
+  getJsonSchema() {
+    return this.#schema.jsonSchema;
+  }
+};
+function toStandardSchema(schema) {
+  return new AiSdkSchemaWrapper(schema);
+}
+
+exports.AiSdkSchemaWrapper = AiSdkSchemaWrapper;
+exports.toStandardSchema = toStandardSchema;
+//# sourceMappingURL=chunk-FS3P4V5M.cjs.map
+//# sourceMappingURL=chunk-FS3P4V5M.cjs.map

package/dist/chunk-FS3P4V5M.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/standard-schema/adapters/ai-sdk.ts"],"names":[],"mappings":"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","file":"chunk-FS3P4V5M.cjs","sourcesContent":["import type { Schema } from '@internal/ai-v6';\nimport type { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';\nimport type { JSONSchema7 } from 'json-schema';\nimport type { StandardSchemaWithJSON, StandardSchemaWithJSONProps } from '../standard-schema.types';\n\n/**\n * Vendor name for AI SDK wrapped schemas.\n */\nconst VENDOR = 'ai-sdk';\n\n/**\n * A wrapper class that makes AI SDK Schema compatible with @standard-schema/spec.\n *\n * This class implements both `StandardSchemaV1` (validation) and `StandardJSONSchemaV1`\n * (JSON Schema conversion) interfaces. It wraps an AI SDK Schema and adapts its\n * validation method and jsonSchema property to the standard-schema interface.\n *\n * @typeParam T - The TypeScript type that the AI SDK Schema represents\n *\n * @example\n * ```typescript\n * import { jsonSchema } from '@internal/ai-v6';\n * import { toStandardSchema } from '@mastra/schema-compat/adapters/ai-sdk';\n *\n * // Create an AI SDK schema\n * const aiSdkSchema = jsonSchema<{ name: string; age: number }>({\n *   type: 'object',\n *   properties: {\n *     name: { type: 'string' },\n *     age: { type: 'number' },\n *   },\n *   required: ['name', 'age'],\n * });\n *\n * // Convert to standard-schema\n * const standardSchema = toStandardSchema(aiSdkSchema);\n *\n * // Use validation (from StandardSchemaV1)\n * const result = standardSchema['~standard'].validate({ name: 'John', age: 30 });\n *\n * // Get JSON Schema (from StandardJSONSchemaV1)\n * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });\n * ```\n */\nexport class AiSdkSchemaWrapper<Input = unknown, Output = Input> implements StandardSchemaWithJSON<Input, Output> {\n  readonly #schema: Schema<Output>;\n  readonly '~standard': StandardSchemaWithJSONProps<Input, Output>;\n\n  constructor(schema: Schema<Output>) {\n    this.#schema = schema;\n\n    // Create the ~standard property\n    this['~standard'] = {\n      version: 1,\n      vendor: VENDOR,\n      validate: this.#validate.bind(this),\n      jsonSchema: {\n        input: this.#toJsonSchema.bind(this),\n        output: this.#toJsonSchema.bind(this),\n      },\n    };\n  }\n\n  /**\n   * Validates a value against the AI SDK Schema.\n   *\n   * @param value - The value to validate\n   * @returns A result object with either the validated value or validation issues\n   */\n  #validate(value: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>> {\n    // Check if the schema has a validate method (it's optional on AI SDK Schema)\n    if (!this.#schema.validate) {\n      // If no validate method, we can't validate - just pass through\n      return { value: value as Output };\n    }\n\n    try {\n      const result = this.#schema.validate(value);\n\n      // Handle both sync and async validation results\n      // The AI SDK Schema.validate returns ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>\n      // We need to check if it's a thenable (promise-like)\n      if (result && typeof result === 'object' && 'then' in result && typeof result.then === 'function') {\n        // Wrap PromiseLike in a proper Promise to satisfy the StandardSchemaV1 interface\n        return Promise.resolve(\n          result as PromiseLike<{ success: true; value: Output } | { success: false; error: Error }>,\n        )\n          .then(res => this.#convertValidationResult(res))\n          .catch((error: unknown) => {\n            // Convert rejected promises to the expected { issues: [...] } shape\n            const message = error instanceof Error ? error.message : 'Unknown validation error';\n            return {\n              issues: [{ message: `Schema validation error: ${message}` }],\n            } as StandardSchemaV1.Result<Output>;\n          });\n      }\n\n      // It's a sync result\n      return this.#convertValidationResult(\n        result as { success: true; value: Output } | { success: false; error: Error },\n      );\n    } catch (error) {\n      // If validation fails unexpectedly, return a validation error\n      const message = error instanceof Error ? error.message : 'Unknown validation error';\n      return {\n        issues: [{ message: `Schema validation error: ${message}` }],\n      };\n    }\n  }\n\n  /**\n   * Converts an AI SDK ValidationResult to a StandardSchemaV1.Result.\n   *\n   * @param result - The AI SDK validation result\n   * @returns A StandardSchemaV1.Result\n   */\n  #convertValidationResult(\n    result: { success: true; value: Output } | { success: false; error: Error },\n  ): StandardSchemaV1.Result<Output> {\n    if (result.success) {\n      return { value: result.value };\n    }\n\n    // Convert the AI SDK error to a Standard Schema issue\n    // Cast to the failure type since TypeScript can't narrow discriminated unions with private field access\n    const failureResult = result as { success: false; error: Error };\n    return {\n      issues: [{ message: failureResult.error.message }],\n    };\n  }\n\n  /**\n   * Returns the JSON Schema in the requested target format.\n   *\n   * @param options - Options including the target format\n   * @returns The JSON Schema as a Record\n   */\n  #toJsonSchema(options: StandardJSONSchemaV1.Options): Record<string, unknown> {\n    const { target } = options;\n\n    // Clone the schema to avoid mutations\n    const clonedSchema = JSON.parse(JSON.stringify(this.#schema.jsonSchema)) as Record<string, unknown>;\n\n    // Add $schema if not present, based on target\n    if (!clonedSchema.$schema) {\n      switch (target) {\n        case 'draft-07':\n          clonedSchema.$schema = 'http://json-schema.org/draft-07/schema#';\n          break;\n        case 'draft-2020-12':\n          clonedSchema.$schema = 'https://json-schema.org/draft/2020-12/schema';\n          break;\n        case 'openapi-3.0':\n          // OpenAPI 3.0 doesn't use $schema\n          break;\n        default:\n          // For unknown targets, don't add $schema\n          break;\n      }\n    }\n\n    return clonedSchema;\n  }\n\n  /**\n   * Returns the original AI SDK Schema.\n   */\n  getSchema(): Schema<Output> {\n    return this.#schema;\n  }\n\n  /**\n   * Returns the original JSON Schema from the AI SDK Schema.\n   */\n  getJsonSchema(): JSONSchema7 {\n    return this.#schema.jsonSchema as JSONSchema7;\n  }\n}\n\n/**\n * Wraps an AI SDK Schema to implement the full @standard-schema/spec interface.\n *\n * This function creates a wrapper that implements both `StandardSchemaV1` (validation)\n * and `StandardJSONSchemaV1` (JSON Schema conversion) interfaces.\n *\n * @typeParam T - The TypeScript type that the AI SDK Schema represents\n * @param schema - The AI SDK Schema to wrap\n * @returns A wrapper implementing StandardSchemaWithJSON\n *\n * @example\n * ```typescript\n * import { jsonSchema } from '@internal/ai-v6';\n * import { toStandardSchema } from '@mastra/schema-compat/adapters/ai-sdk';\n *\n * const aiSdkSchema = jsonSchema<{ name: string; age: number }>({\n *   type: 'object',\n *   properties: {\n *     name: { type: 'string' },\n *     age: { type: 'number' },\n *   },\n *   required: ['name', 'age'],\n * });\n *\n * const standardSchema = toStandardSchema(aiSdkSchema);\n *\n * // Validate data\n * const result = standardSchema['~standard'].validate({ name: 'John', age: 30 });\n *\n * // Get JSON Schema\n * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });\n * ```\n */\nexport function toStandardSchema<T = unknown>(schema: Schema<T>): AiSdkSchemaWrapper<T, T> {\n  return new AiSdkSchemaWrapper<T, T>(schema);\n}\n"]}

package/dist/chunk-I2YUBGXM.js

@@ -0,0 +1,112 @@
+import { toStandardSchema as toStandardSchema$1 } from './chunk-23HDOZLF.js';
+import { toStandardSchema as toStandardSchema$2 } from './chunk-QDRBTCDV.js';
+import { toStandardSchema } from './chunk-IKQO7EW7.js';
+import z3 from 'zod/v3';
+
+function jsonSchemaOverride(ctx) {
+  const zodSchema = ctx.zodSchema;
+  if (ctx.jsonSchema.type === "object" && ctx.jsonSchema.properties !== void 0 && !ctx.jsonSchema.additionalProperties) {
+    ctx.jsonSchema.additionalProperties = false;
+  }
+  if (zodSchema) {
+    if (zodSchema?.type === "date") {
+      ctx.jsonSchema.type = "string";
+      ctx.jsonSchema.format = "date-time";
+    } else if (zodSchema?.type === "object" && zodSchema._zod?.def?.catchall?.type === "unknown") {
+      ctx.jsonSchema.additionalProperties = true;
+    }
+  }
+  return void 0;
+}
+var JSON_SCHEMA_LIBRARY_OPTIONS = {
+  unrepresentable: "any",
+  override: jsonSchemaOverride
+};
+function isVercelSchema(schema) {
+  return typeof schema === "object" && schema !== null && "_type" in schema && "jsonSchema" in schema && typeof schema.jsonSchema === "object";
+}
+function isZodV4(schema) {
+  return typeof schema === "object" && schema !== null && "_zod" in schema;
+}
+function isZodV3(schema) {
+  if (schema === null || typeof schema !== "object") {
+    return false;
+  }
+  if (isZodV4(schema)) {
+    return false;
+  }
+  if ("~standard" in schema) {
+    const std = schema["~standard"];
+    if (typeof std === "object" && std !== null && std.vendor === "zod" && !("jsonSchema" in std)) {
+      return true;
+    }
+  }
+  return schema instanceof z3.ZodType;
+}
+function toStandardSchema4(schema) {
+  if (isStandardSchemaWithJSON(schema)) {
+    return schema;
+  }
+  if (isZodV3(schema)) {
+    return toStandardSchema(schema);
+  }
+  if (isVercelSchema(schema)) {
+    return toStandardSchema$1(schema);
+  }
+  if (schema === null || typeof schema !== "object" && typeof schema !== "function") {
+    throw new Error(`Unsupported schema type: ${typeof schema}`);
+  }
+  if (typeof schema === "function") {
+    throw new Error(`Unsupported schema type: function (schema libraries should implement StandardSchemaWithJSON)`);
+  }
+  return toStandardSchema$2(schema);
+}
+function isStandardSchema(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  if (!("~standard" in value)) {
+    return false;
+  }
+  const std = value["~standard"];
+  return typeof std === "object" && std !== null && "version" in std && std.version === 1 && "vendor" in std && "validate" in std && typeof std.validate === "function";
+}
+function isStandardJSONSchema(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  if (!("~standard" in value)) {
+    return false;
+  }
+  const std = value["~standard"];
+  if (typeof std !== "object" || std === null) {
+    return false;
+  }
+  if (!("version" in std) || std.version !== 1 || !("vendor" in std)) {
+    return false;
+  }
+  if (!("jsonSchema" in std) || typeof std.jsonSchema !== "object") {
+    return false;
+  }
+  return typeof std.jsonSchema.input === "function" && typeof std.jsonSchema.output === "function";
+}
+function isStandardSchemaWithJSON(value) {
+  return isStandardSchema(value) && isStandardJSONSchema(value);
+}
+function standardSchemaToJSONSchema(schema, options = {}) {
+  const { target = "draft-07", io = "output", override = JSON_SCHEMA_LIBRARY_OPTIONS.override } = options;
+  const jsonSchemaFn = schema["~standard"].jsonSchema[io];
+  let jsonSchema = jsonSchemaFn({
+    target,
+    libraryOptions: {
+      ...JSON_SCHEMA_LIBRARY_OPTIONS,
+      override
+    }
+  });
+  jsonSchema = JSON.parse(JSON.stringify(jsonSchema));
+  return jsonSchema;
+}
+
+export { JSON_SCHEMA_LIBRARY_OPTIONS, isStandardJSONSchema, isStandardSchema, isStandardSchemaWithJSON, standardSchemaToJSONSchema, toStandardSchema4 as toStandardSchema };
+//# sourceMappingURL=chunk-I2YUBGXM.js.map
+//# sourceMappingURL=chunk-I2YUBGXM.js.map

package/dist/chunk-I2YUBGXM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/standard-schema/standard-schema.ts"],"names":["toStandardSchema"],"mappings":";;;;;AAgBA,SAAS,mBAAmB,GAAA,EAA6E;AACvG,EAAA,MAAM,YAAY,GAAA,CAAI,SAAA;AAEtB,EAAA,IACE,GAAA,CAAI,UAAA,CAAW,IAAA,KAAS,QAAA,IACxB,GAAA,CAAI,UAAA,CAAW,UAAA,KAAe,MAAA,IAC9B,CAAC,GAAA,CAAI,UAAA,CAAW,oBAAA,EAChB;AACA,IAAA,GAAA,CAAI,WAAW,oBAAA,GAAuB,KAAA;AAAA,EACxC;AAEA,EAAA,IAAI,SAAA,EAAW;AAEb,IAAA,IAAI,SAAA,EAAW,SAAS,MAAA,EAAQ;AAC9B,MAAA,GAAA,CAAI,WAAW,IAAA,GAAO,QAAA;AACtB,MAAA,GAAA,CAAI,WAAW,MAAA,GAAS,WAAA;AAAA,IAE1B,CAAA,MAAA,IAAW,WAAW,IAAA,KAAS,QAAA,IAAY,UAAU,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,IAAA,KAAS,SAAA,EAAW;AAC5F,MAAA,GAAA,CAAI,WAAW,oBAAA,GAAuB,IAAA;AAAA,IACxC;AAAA,EACF;AAEA,EAAA,OAAO,MAAA;AACT;AAOO,IAAM,2BAAA,GAA8B;AAAA,EACzC,eAAA,EAAiB,KAAA;AAAA,EACjB,QAAA,EAAU;AACZ;AAUA,SAAS,eAAe,MAAA,EAAmC;AACzD,EAAA,OACE,OAAO,MAAA,KAAW,QAAA,IAClB,MAAA,KAAW,IAAA,IACX,OAAA,IAAW,MAAA,IACX,YAAA,IAAgB,MAAA,IAChB,OAAQ,MAAA,CAAkB,UAAA,KAAe,QAAA;AAE7C;AAKA,SAAS,QAAQ,MAAA,EAA0B;AACzC,EAAA,OAAO,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,KAAW,QAAQ,MAAA,IAAU,MAAA;AACpE;AAiBA,SAAS,QAAQ,MAAA,EAAoC;AACnD,EAAA,IAAI,MAAA,KAAW,IAAA,IAAQ,OAAO,MAAA,KAAW,QAAA,EAAU;AACjD,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,IAAI,OAAA,CAAQ,MAAM,CAAA,EAAG;AACnB,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,IAAI,eAAe,MAAA,EAAQ;AACzB,IAAA,MAAM,GAAA,GAAO,OAAe,WAAW,CAAA;AACvC,IAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,IAAA,IAAQ,IAAI,MAAA,KAAW,KAAA,IAAS,EAAE,YAAA,IAAgB,GAAA,CAAA,EAAM;AAC7F,MAAA,OAAO,IAAA;AAAA,IACT;AAAA,EACF;AAGA,EAAA,OAAO,kBAAkB,EAAA,CAAG,OAAA;AAC9B;AAEO,SAASA,kBAA8B,MAAA,EAAoD;AAGhG,EAAA,IAAI,wBAAA,CAAyB,MAAM,CAAA,EAAG;AACpC,IAAA,OAAO,MAAA;AAAA,EACT;AAKA,EAAA,IAAI,OAAA,CAAQ,MAAM,CAAA,EAAG;AACnB,IAAA,OAAOA,iBAAsB,MAAiB,CAAA;AAAA,EAChD;AAGA,EAAA,IAAI,cAAA,CAAe,MAAM,CAAA,EAAG;AAC1B,IAAA,OAAOA,mBAAsB,MAAmB,CAAA;AAAA,EAClD;AAIA,EAAA,IAAI,WAAW,IAAA,IAAS,OAAO,WAAW,QAAA,IAAY,OAAO,WAAW,UAAA,EAAa;AACnF,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,yBAAA,EAA4B,OAAO,MAAM,CAAA,CAAE,CAAA;AAAA,EAC7D;AAGA,EAAA,IAAI,OAAO,WAAW,UAAA,EAAY;AAChC,IAAA,MAAM,IAAI,MAAM,CAAA,4FAAA,CAA8F,CAAA;AAAA,EAChH;AAEA,EAAA,OAAOA,mBAA2B,MAAqB,CAAA;AACzD;AAiBO,SAAS,iBAAiB,KAAA,EAA2C;AAE1E,EAAA,IAAI,UAAU,IAAA,IAAS,OAAO,UAAU,QAAA,IAAY,OAAO,UAAU,UAAA,EAAa;AAChF,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,IAAI,EAAE,eAAe,KAAA,CAAA,EAAQ;AAC3B,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,MAAM,GAAA,GAAO,MAAc,WAAW,CAAA;AACtC,EAAA,OACE,OAAO,GAAA,KAAQ,QAAA,IACf,GAAA,KAAQ,IAAA,IACR,aAAa,GAAA,IACb,GAAA,CAAI,OAAA,KAAY,CAAA,IAChB,YAAY,GAAA,IACZ,UAAA,IAAc,GAAA,IACd,OAAO,IAAI,QAAA,KAAa,UAAA;AAE5B;AAiBO,SAAS,qBAAqB,KAAA,EAA+C;AAElF,EAAA,IAAI,UAAU,IAAA,IAAS,OAAO,UAAU,QAAA,IAAY,OAAO,UAAU,UAAA,EAAa;AAChF,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,IAAI,EAAE,eAAe,KAAA,CAAA,EAAQ;AAC3B,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,MAAM,GAAA,GAAO,MAAc,WAAW,CAAA;AACtC,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,IAAA,EAAM;AAC3C,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,IAAI,EAAE,aAAa,GAAA,CAAA,IAAQ,GAAA,CAAI,YAAY,CAAA,IAAK,EAAE,YAAY,GAAA,CAAA,EAAM;AAClE,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,IAAI,EAAE,YAAA,IAAgB,GAAA,CAAA,IAAQ,OAAO,GAAA,CAAI,eAAe,QAAA,EAAU;AAChE,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,OAAO,IAAI,UAAA,CAAW,KAAA,KAAU,cAAc,OAAO,GAAA,CAAI,WAAW,MAAA,KAAW,UAAA;AACxF;AAmBO,SAAS,yBAAyB,KAAA,EAAiD;AACxF,EAAA,OAAO,gBAAA,CAAiB,KAAK,CAAA,IAAK,oBAAA,CAAqB,KAAK,CAAA;AAC9D;AA4BO,SAAS,0BAAA,CACd,MAAA,EACA,OAAA,GAII,EAAC,EACQ;AACb,EAAA,MAAM,EAAE,SAAS,UAAA,EAAY,EAAA,GAAK,UAAU,QAAA,GAAW,2BAAA,CAA4B,UAAS,GAAI,OAAA;AAChG,EAAA,MAAM,YAAA,GAAe,MAAA,CAAO,WAAW,CAAA,CAAE,WAAW,EAAE,CAAA;AACtD,EAAA,IAAI,aAAa,YAAA,CAAa;AAAA,IAC5B,MAAA;AAAA,IACA,cAAA,EAAgB;AAAA,MACd,GAAG,2BAAA;AAAA,MACH;AAAA;AACF,GACD,CAAA;AAGD,EAAA,UAAA,GAAa,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,SAAA,CAAU,UAAU,CAAC,CAAA;AAElD,EAAA,OAAO,UAAA;AACT","file":"chunk-I2YUBGXM.js","sourcesContent":["import type { Schema } from '@internal/ai-v6';\nimport type { StandardJSONSchemaV1, StandardSchemaV1 } from '@standard-schema/spec';\nimport type { JSONSchema7 } from 'json-schema';\nimport z3 from 'zod/v3';\nimport type { ZodType } from 'zod/v3';\nimport type { PublicSchema } from '../schema.types';\nimport { toStandardSchema as toStandardSchemaAiSdk } from './adapters/ai-sdk';\nimport { toStandardSchema as toStandardSchemaJsonSchema } from './adapters/json-schema';\nimport { toStandardSchema as toStandardSchemaZodV3 } from './adapters/zod-v3';\nimport type { StandardSchemaWithJSON } from './standard-schema.types';\n\n/**\n * Override function for JSON Schema conversion.\n * Handles types that Zod v4 cannot natively represent in JSON Schema:\n * - z.date() -> { type: 'string', format: 'date-time' }\n */\nfunction jsonSchemaOverride(ctx: { zodSchema: unknown; jsonSchema: Record<string, unknown> }): undefined {\n  const zodSchema = ctx.zodSchema as { type?: string; _zod?: { def?: { type?: string } }; optional?: () => unknown };\n\n  if (\n    ctx.jsonSchema.type === 'object' &&\n    ctx.jsonSchema.properties !== undefined &&\n    !ctx.jsonSchema.additionalProperties\n  ) {\n    ctx.jsonSchema.additionalProperties = false;\n  }\n\n  if (zodSchema) {\n    // Convert z.date() to JSON Schema string with date-time format\n    if (zodSchema?.type === 'date') {\n      ctx.jsonSchema.type = 'string';\n      ctx.jsonSchema.format = 'date-time';\n      // @ts-expect-error - catchall is a valid property for zod\n    } else if (zodSchema?.type === 'object' && zodSchema._zod?.def?.catchall?.type === 'unknown') {\n      ctx.jsonSchema.additionalProperties = true;\n    }\n  }\n\n  return undefined;\n}\n/**\n * Library options for JSON Schema conversion.\n * - unrepresentable: 'any' allows z.custom() and other unrepresentable types to be converted to {}\n *   instead of throwing \"Custom types cannot be represented in JSON Schema\"\n * - override: converts z.date() to { type: 'string', format: 'date-time' }\n */\nexport const JSON_SCHEMA_LIBRARY_OPTIONS = {\n  unrepresentable: 'any' as const,\n  override: jsonSchemaOverride,\n};\n\nexport type {\n  StandardSchemaWithJSON,\n  StandardSchemaWithJSONProps,\n  InferInput,\n  InferOutput,\n  StandardSchemaIssue,\n} from './standard-schema.types';\n\nfunction isVercelSchema(schema: unknown): schema is Schema {\n  return (\n    typeof schema === 'object' &&\n    schema !== null &&\n    '_type' in schema &&\n    'jsonSchema' in schema &&\n    typeof (schema as Schema).jsonSchema === 'object'\n  );\n}\n\n/**\n * Check if a schema is Zod v4 (has _zod property which is v4-only)\n */\nfunction isZodV4(schema: unknown): boolean {\n  return typeof schema === 'object' && schema !== null && '_zod' in schema;\n}\n\n/**\n * Check if a schema is Zod v3.\n *\n * Zod v3 can come from:\n * 1. The old standalone 'zod-v3' package\n * 2. The 'zod/v3' compat export from modern zod\n *\n * We detect Zod v3 by checking:\n * - Has ~standard.vendor === 'zod' (both v3 and v4 have this)\n * - Does NOT have ~standard.jsonSchema (only Zod v4 has native JSON Schema support)\n * - Does NOT have _zod property (only Zod v4 has this)\n *\n * Note: We can't use instanceof z3.ZodType because the old 'zod-v3' package\n * has a different prototype chain than 'zod/v3'.\n */\nfunction isZodV3(schema: unknown): schema is ZodType {\n  if (schema === null || typeof schema !== 'object') {\n    return false;\n  }\n\n  // Must not be Zod v4\n  if (isZodV4(schema)) {\n    return false;\n  }\n\n  // Check for ~standard with vendor 'zod' but no jsonSchema\n  if ('~standard' in schema) {\n    const std = (schema as any)['~standard'];\n    if (typeof std === 'object' && std !== null && std.vendor === 'zod' && !('jsonSchema' in std)) {\n      return true;\n    }\n  }\n\n  // Fallback: check instanceof for zod/v3 compat export\n  return schema instanceof z3.ZodType;\n}\n\nexport function toStandardSchema<T = unknown>(schema: PublicSchema<T>): StandardSchemaWithJSON<T> {\n  // First check: if already StandardSchemaWithJSON, return as-is\n  // This handles ArkType, Zod v4 (when it has jsonSchema), and pre-wrapped schemas\n  if (isStandardSchemaWithJSON(schema)) {\n    return schema;\n  }\n\n  // Check for Zod v3 schemas (need wrapping to add JSON Schema support)\n  // Important: Must use isZodV3() not instanceof z3.ZodType because\n  // Zod v4 schemas are also instanceof z3.ZodType due to prototype compatibility\n  if (isZodV3(schema)) {\n    return toStandardSchemaZodV3(schema as ZodType);\n  }\n\n  // Check for AI SDK Schema objects (Vercel's jsonSchema wrapper)\n  if (isVercelSchema(schema)) {\n    return toStandardSchemaAiSdk(schema as Schema<T>);\n  }\n\n  // At this point, assume it's a plain JSON Schema object\n  // JSON Schema objects are plain objects with properties like 'type', 'properties', etc.\n  if (schema === null || (typeof schema !== 'object' && typeof schema !== 'function')) {\n    throw new Error(`Unsupported schema type: ${typeof schema}`);\n  }\n\n  // If it's a function that's not StandardSchemaWithJSON, it's not supported\n  if (typeof schema === 'function') {\n    throw new Error(`Unsupported schema type: function (schema libraries should implement StandardSchemaWithJSON)`);\n  }\n\n  return toStandardSchemaJsonSchema(schema as JSONSchema7);\n}\n\n/**\n * Type guard to check if a value implements the StandardSchemaV1 interface.\n *\n * @param value - The value to check\n * @returns True if the value implements StandardSchemaV1\n *\n * @example\n * ```typescript\n * import { isStandardSchema } from '@mastra/schema-compat';\n *\n * if (isStandardSchema(someValue)) {\n *   const result = someValue['~standard'].validate(input);\n * }\n * ```\n */\nexport function isStandardSchema(value: unknown): value is StandardSchemaV1 {\n  // Check for object or function (some libraries like ArkType use callable schemas)\n  if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {\n    return false;\n  }\n  if (!('~standard' in value)) {\n    return false;\n  }\n  const std = (value as any)['~standard'];\n  return (\n    typeof std === 'object' &&\n    std !== null &&\n    'version' in std &&\n    std.version === 1 &&\n    'vendor' in std &&\n    'validate' in std &&\n    typeof std.validate === 'function'\n  );\n}\n\n/**\n * Type guard to check if a value implements the StandardJSONSchemaV1 interface.\n *\n * @param value - The value to check\n * @returns True if the value implements StandardJSONSchemaV1\n *\n * @example\n * ```typescript\n * import { isStandardJSONSchema } from '@mastra/schema-compat';\n *\n * if (isStandardJSONSchema(someValue)) {\n *   const jsonSchema = someValue['~standard'].jsonSchema.output({ target: 'draft-07' });\n * }\n * ```\n */\nexport function isStandardJSONSchema(value: unknown): value is StandardJSONSchemaV1 {\n  // Check for object or function (some libraries like ArkType use callable schemas)\n  if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {\n    return false;\n  }\n  if (!('~standard' in value)) {\n    return false;\n  }\n  const std = (value as any)['~standard'];\n  if (typeof std !== 'object' || std === null) {\n    return false;\n  }\n  if (!('version' in std) || std.version !== 1 || !('vendor' in std)) {\n    return false;\n  }\n  if (!('jsonSchema' in std) || typeof std.jsonSchema !== 'object') {\n    return false;\n  }\n  return typeof std.jsonSchema.input === 'function' && typeof std.jsonSchema.output === 'function';\n}\n\n/**\n * Type guard to check if a value implements both StandardSchemaV1 and StandardJSONSchemaV1.\n *\n * @param value - The value to check\n * @returns True if the value implements both interfaces\n *\n * @example\n * ```typescript\n * import { isStandardSchemaWithJSON } from '@mastra/schema-compat';\n *\n * if (isStandardSchemaWithJSON(someValue)) {\n *   // Can use both validation and JSON Schema conversion\n *   const result = someValue['~standard'].validate(input);\n *   const jsonSchema = someValue['~standard'].jsonSchema.output({ target: 'draft-07' });\n * }\n * ```\n */\nexport function isStandardSchemaWithJSON(value: unknown): value is StandardSchemaWithJSON {\n  return isStandardSchema(value) && isStandardJSONSchema(value);\n}\n\n/**\n * Converts a StandardSchemaWithJSON to a JSON Schema.\n *\n * @param schema - The StandardSchemaWithJSON schema to convert\n * @param options - Conversion options\n * @param options.target - The JSON Schema target version (default: 'draft-07')\n * @param options.io - Whether to use input or output schema (default: 'output')\n *   - 'input': Use for tool parameters, function arguments, request bodies\n *   - 'output': Use for return types, response bodies\n * @returns The JSON Schema representation\n *\n * @example\n * ```typescript\n * import { standardSchemaToJSONSchema, toStandardSchema } from '@mastra/schema-compat';\n * import { z } from 'zod';\n *\n * const zodSchema = z.object({ name: z.string() });\n * const standardSchema = toStandardSchema(zodSchema);\n *\n * // For output types (default)\n * const outputSchema = standardSchemaToJSONSchema(standardSchema);\n *\n * // For input types (tool parameters)\n * const inputSchema = standardSchemaToJSONSchema(standardSchema, { io: 'input' });\n * ```\n */\nexport function standardSchemaToJSONSchema(\n  schema: StandardSchemaWithJSON,\n  options: {\n    target?: StandardJSONSchemaV1.Target;\n    io?: 'input' | 'output';\n    override?: (typeof JSON_SCHEMA_LIBRARY_OPTIONS)['override'];\n  } = {},\n): JSONSchema7 {\n  const { target = 'draft-07', io = 'output', override = JSON_SCHEMA_LIBRARY_OPTIONS.override } = options;\n  const jsonSchemaFn = schema['~standard'].jsonSchema[io];\n  let jsonSchema = jsonSchemaFn({\n    target,\n    libraryOptions: {\n      ...JSON_SCHEMA_LIBRARY_OPTIONS,\n      override,\n    },\n  }) as JSONSchema7;\n\n  // make sure only jsonSchema is left, no standard schema metadata\n  jsonSchema = JSON.parse(JSON.stringify(jsonSchema));\n\n  return jsonSchema;\n}\n"]}

package/dist/chunk-IKQO7EW7.js

@@ -0,0 +1,62 @@
+import { require_json_schema_traverse } from './chunk-K7I3YXWP.js';
+import { __toESM } from './chunk-5WRI5ZAA.js';
+import zodToJsonSchemaOriginal from 'zod-to-json-schema';
+
+// src/standard-schema/adapters/zod-v3.ts
+var import_json_schema_traverse = __toESM(require_json_schema_traverse(), 1);
+var TARGET_MAP = {
+  "draft-07": "jsonSchema7",
+  "openapi-3.0": "openApi3"
+};
+function convertToJsonSchema(zodSchema, options) {
+  const target = TARGET_MAP[options.target];
+  if (!target) {
+    const supportedTargets = Object.keys(TARGET_MAP);
+    throw new Error(
+      `Unsupported JSON Schema target: "${options.target}". Supported targets are: ${supportedTargets.join(", ")}`
+    );
+  }
+  const jsonSchema = zodToJsonSchemaOriginal(zodSchema, {
+    $refStrategy: "none",
+    target
+  });
+  (0, import_json_schema_traverse.default)(jsonSchema, {
+    cb: {
+      pre: (schema) => {
+        if (schema.type === "string" && schema.format === "email") {
+          schema.pattern = `^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$`;
+        }
+      }
+      // post: (schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema) => {
+      //   this.postProcessJSONNode(schema, parentSchema);
+      // },
+    }
+  });
+  return jsonSchema;
+}
+function toStandardSchema(zodSchema) {
+  const wrapper = Object.create(zodSchema);
+  const existingStandard = zodSchema["~standard"];
+  const jsonSchemaConverter = {
+    input: (options) => {
+      return convertToJsonSchema(zodSchema, options);
+    },
+    output: (options) => {
+      return convertToJsonSchema(zodSchema, options);
+    }
+  };
+  Object.defineProperty(wrapper, "~standard", {
+    value: {
+      ...existingStandard,
+      jsonSchema: jsonSchemaConverter
+    },
+    writable: false,
+    enumerable: true,
+    configurable: false
+  });
+  return wrapper;
+}
+
+export { toStandardSchema };
+//# sourceMappingURL=chunk-IKQO7EW7.js.map
+//# sourceMappingURL=chunk-IKQO7EW7.js.map

package/dist/chunk-IKQO7EW7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/standard-schema/adapters/zod-v3.ts"],"names":["traverse"],"mappings":";;;;;AACA,IAAA,2BAAA,GAAqB,OAAA,CAAA,4BAAA,EAAA,EAAA,CAAA,CAAA;AAYrB,IAAM,UAAA,GAAoD;AAAA,EACxD,UAAA,EAAY,aAAA;AAAA,EACZ,aAAA,EAAe;AACjB,CAAA;AAYA,SAAS,mBAAA,CACP,WACA,OAAA,EACyB;AACzB,EAAA,MAAM,MAAA,GAAS,UAAA,CAAW,OAAA,CAAQ,MAAM,CAAA;AAExC,EAAA,IAAI,CAAC,MAAA,EAAQ;AAEX,IAAA,MAAM,gBAAA,GAAmB,MAAA,CAAO,IAAA,CAAK,UAAU,CAAA;AAC/C,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,oCAAoC,OAAA,CAAQ,MAAM,6BAAkC,gBAAA,CAAiB,IAAA,CAAK,IAAI,CAAC,CAAA;AAAA,KACjH;AAAA,EACF;AAEA,EAAA,MAAM,UAAA,GAAa,wBAAwB,SAAA,EAAW;AAAA,IACpD,YAAA,EAAc,MAAA;AAAA,IACd;AAAA,GACD,CAAA;AAED,EAAA,IAAA,2BAAA,CAAAA,SAAS,UAAA,EAAY;AAAA,IACnB,EAAA,EAAI;AAAA,MACF,KAAK,CAAA,MAAA,KAAU;AACb,QAAA,IAAI,MAAA,CAAO,IAAA,KAAS,QAAA,IAAY,MAAA,CAAO,WAAW,OAAA,EAAS;AACzD,UAAA,MAAA,CAAO,OAAA,GAAU,CAAA,uGAAA,CAAA;AAAA,QACnB;AAAA,MACF;AAAA;AAAA;AAAA;AAAA;AAIF,GACD,CAAA;AAED,EAAA,OAAO,UAAA;AACT;AA8BO,SAAS,iBAAoB,SAAA,EAAwE;AAE1G,EAAA,MAAM,OAAA,GAAU,MAAA,CAAO,MAAA,CAAO,SAAS,CAAA;AAGvC,EAAA,MAAM,gBAAA,GAAmB,UAAU,WAAW,CAAA;AAG9C,EAAA,MAAM,mBAAA,GAAsD;AAAA,IAC1D,KAAA,EAAO,CAAC,OAAA,KAAmE;AACzE,MAAA,OAAO,mBAAA,CAAoB,WAAW,OAAO,CAAA;AAAA,IAC/C,CAAA;AAAA,IACA,MAAA,EAAQ,CAAC,OAAA,KAAmE;AAG1E,MAAA,OAAO,mBAAA,CAAoB,WAAW,OAAO,CAAA;AAAA,IAC/C;AAAA,GACF;AAGA,EAAA,MAAA,CAAO,cAAA,CAAe,SAAS,WAAA,EAAa;AAAA,IAC1C,KAAA,EAAO;AAAA,MACL,GAAG,gBAAA;AAAA,MACH,UAAA,EAAY;AAAA,KACd;AAAA,IACA,QAAA,EAAU,KAAA;AAAA,IACV,UAAA,EAAY,IAAA;AAAA,IACZ,YAAA,EAAc;AAAA,GACf,CAAA;AAED,EAAA,OAAO,OAAA;AACT","file":"chunk-IKQO7EW7.js","sourcesContent":["import type { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';\nimport traverse from 'json-schema-traverse';\n// Use zod/v3 types for v3 compatibility (v4's v3-compat layer)\nimport type { ZodType, ZodTypeDef } from 'zod/v3';\nimport zodToJsonSchemaOriginal from 'zod-to-json-schema';\nimport type {\n  StandardSchemaWithJSON,\n  StandardSchemaWithJSONProps,\n  ZodToJsonSchemaTarget,\n} from '../standard-schema.types';\n/**\n * Target mapping from Standard Schema targets to zod-to-json-schema targets.\n */\nconst TARGET_MAP: Record<string, ZodToJsonSchemaTarget> = {\n  'draft-07': 'jsonSchema7',\n  'openapi-3.0': 'openApi3',\n};\n\n/**\n * Converts a Zod schema to JSON Schema using the specified target format.\n *\n * @param zodSchema - The Zod schema to convert\n * @param options - Standard Schema JSON options including the target format\n * @returns The JSON Schema representation\n * @throws Error if the target format is not supported\n *\n * @internal\n */\nfunction convertToJsonSchema<T extends ZodType<any, ZodTypeDef, any>>(\n  zodSchema: T,\n  options: StandardJSONSchemaV1.Options,\n): Record<string, unknown> {\n  const target = TARGET_MAP[options.target];\n\n  if (!target) {\n    // For unknown targets, try to use jsonSchema7 as fallback or throw\n    const supportedTargets = Object.keys(TARGET_MAP);\n    throw new Error(\n      `Unsupported JSON Schema target: \"${options.target}\". ` + `Supported targets are: ${supportedTargets.join(', ')}`,\n    );\n  }\n\n  const jsonSchema = zodToJsonSchemaOriginal(zodSchema, {\n    $refStrategy: 'none',\n    target,\n  });\n\n  traverse(jsonSchema, {\n    cb: {\n      pre: schema => {\n        if (schema.type === 'string' && schema.format === 'email') {\n          schema.pattern = `^(?!\\\\.)(?!.*\\\\.\\\\.)([A-Za-z0-9_'+\\\\-\\\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\\\-]*\\\\.)+[A-Za-z]{2,}$`;\n        }\n      },\n      // post: (schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema) => {\n      //   this.postProcessJSONNode(schema, parentSchema);\n      // },\n    },\n  });\n\n  return jsonSchema as Record<string, unknown>;\n}\n\n/**\n * Wraps a Zod v3 schema to implement the full @standard-schema/spec interface.\n *\n * While Zod v3 natively implements `StandardSchemaV1` (validation), it does not\n * implement `StandardJSONSchemaV1` (JSON Schema conversion). This adapter adds\n * the `jsonSchema` property to provide JSON Schema conversion capabilities.\n *\n * @typeParam T - The Zod schema type\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n * import { toStandardSchema } from '@mastra/schema-compat/adapters/zod-v3';\n *\n * const userSchema = z.object({\n *   name: z.string(),\n *   age: z.number().min(0),\n * });\n *\n * const standardSchema = toStandardSchema(userSchema);\n *\n * // Use validation (from StandardSchemaV1)\n * const result = standardSchema['~standard'].validate({ name: 'John', age: 30 });\n *\n * // Get JSON Schema (from StandardJSONSchemaV1)\n * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });\n * ```\n */\nexport function toStandardSchema<T>(zodSchema: ZodType<T, ZodTypeDef, T>): T & StandardSchemaWithJSON<T, T> {\n  // Create a wrapper object that includes the jsonSchema converter\n  const wrapper = Object.create(zodSchema) as T & StandardSchemaWithJSON<T, T>;\n\n  // Get the existing ~standard property from Zod\n  const existingStandard = zodSchema['~standard'] as StandardSchemaV1.Props<T, T>;\n\n  // Create the JSON Schema converter\n  const jsonSchemaConverter: StandardJSONSchemaV1.Converter = {\n    input: (options: StandardJSONSchemaV1.Options): Record<string, unknown> => {\n      return convertToJsonSchema(zodSchema, options);\n    },\n    output: (options: StandardJSONSchemaV1.Options): Record<string, unknown> => {\n      // For Zod schemas, input and output JSON Schema are typically the same\n      // unless using transforms, which would need special handling\n      return convertToJsonSchema(zodSchema, options);\n    },\n  };\n\n  // Define the enhanced ~standard property\n  Object.defineProperty(wrapper, '~standard', {\n    value: {\n      ...existingStandard,\n      jsonSchema: jsonSchemaConverter,\n    } satisfies StandardSchemaWithJSONProps<T, T>,\n    writable: false,\n    enumerable: true,\n    configurable: false,\n  });\n\n  return wrapper;\n}\n"]}

package/dist/chunk-K7I3YXWP.js

@@ -0,0 +1,92 @@
+import { __commonJS } from './chunk-5WRI5ZAA.js';
+
+// ../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
+var require_json_schema_traverse = __commonJS({
+  "../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js"(exports$1, module) {
+    var traverse = module.exports = function(schema, opts, cb) {
+      if (typeof opts == "function") {
+        cb = opts;
+        opts = {};
+      }
+      cb = opts.cb || cb;
+      var pre = typeof cb == "function" ? cb : cb.pre || function() {
+      };
+      var post = cb.post || function() {
+      };
+      _traverse(opts, pre, post, schema, "", schema);
+    };
+    traverse.keywords = {
+      additionalItems: true,
+      items: true,
+      contains: true,
+      additionalProperties: true,
+      propertyNames: true,
+      not: true,
+      if: true,
+      then: true,
+      else: true
+    };
+    traverse.arrayKeywords = {
+      items: true,
+      allOf: true,
+      anyOf: true,
+      oneOf: true
+    };
+    traverse.propsKeywords = {
+      $defs: true,
+      definitions: true,
+      properties: true,
+      patternProperties: true,
+      dependencies: true
+    };
+    traverse.skipKeywords = {
+      default: true,
+      enum: true,
+      const: true,
+      required: true,
+      maximum: true,
+      minimum: true,
+      exclusiveMaximum: true,
+      exclusiveMinimum: true,
+      multipleOf: true,
+      maxLength: true,
+      minLength: true,
+      pattern: true,
+      format: true,
+      maxItems: true,
+      minItems: true,
+      uniqueItems: true,
+      maxProperties: true,
+      minProperties: true
+    };
+    function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+      if (schema && typeof schema == "object" && !Array.isArray(schema)) {
+        pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+        for (var key in schema) {
+          var sch = schema[key];
+          if (Array.isArray(sch)) {
+            if (key in traverse.arrayKeywords) {
+              for (var i = 0; i < sch.length; i++)
+                _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+            }
+          } else if (key in traverse.propsKeywords) {
+            if (sch && typeof sch == "object") {
+              for (var prop in sch)
+                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+            }
+          } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
+            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+          }
+        }
+        post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      }
+    }
+    function escapeJsonPtr(str) {
+      return str.replace(/~/g, "~0").replace(/\//g, "~1");
+    }
+  }
+});
+
+export { require_json_schema_traverse };
+//# sourceMappingURL=chunk-K7I3YXWP.js.map
+//# sourceMappingURL=chunk-K7I3YXWP.js.map

package/dist/chunk-K7I3YXWP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js"],"names":["exports"],"mappings":"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","file":"chunk-K7I3YXWP.js","sourcesContent":["'use strict';\n\nvar traverse = module.exports = function (schema, opts, cb) {\n  // Legacy support for v0.3.1 and earlier.\n  if (typeof opts == 'function') {\n    cb = opts;\n    opts = {};\n  }\n\n  cb = opts.cb || cb;\n  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};\n  var post = cb.post || function() {};\n\n  _traverse(opts, pre, post, schema, '', schema);\n};\n\n\ntraverse.keywords = {\n  additionalItems: true,\n  items: true,\n  contains: true,\n  additionalProperties: true,\n  propertyNames: true,\n  not: true,\n  if: true,\n  then: true,\n  else: true\n};\n\ntraverse.arrayKeywords = {\n  items: true,\n  allOf: true,\n  anyOf: true,\n  oneOf: true\n};\n\ntraverse.propsKeywords = {\n  $defs: true,\n  definitions: true,\n  properties: true,\n  patternProperties: true,\n  dependencies: true\n};\n\ntraverse.skipKeywords = {\n  default: true,\n  enum: true,\n  const: true,\n  required: true,\n  maximum: true,\n  minimum: true,\n  exclusiveMaximum: true,\n  exclusiveMinimum: true,\n  multipleOf: true,\n  maxLength: true,\n  minLength: true,\n  pattern: true,\n  format: true,\n  maxItems: true,\n  minItems: true,\n  uniqueItems: true,\n  maxProperties: true,\n  minProperties: true\n};\n\n\nfunction _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {\n    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n    for (var key in schema) {\n      var sch = schema[key];\n      if (Array.isArray(sch)) {\n        if (key in traverse.arrayKeywords) {\n          for (var i=0; i<sch.length; i++)\n            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);\n        }\n      } else if (key in traverse.propsKeywords) {\n        if (sch && typeof sch == 'object') {\n          for (var prop in sch)\n            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);\n        }\n      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {\n        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);\n      }\n    }\n    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n  }\n}\n\n\nfunction escapeJsonPtr(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n"]}