@openclaw/firecrawl-plugin 2026.9.8 → 2026.10.1-beta.1

package/node_modules/zod/src/v4/core/errors.ts

@@ -1,543 +0,0 @@
-import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
-import { $constructor } from "./core.js";
-import type { $ZodType } from "./schemas.js";
-import type { StandardSchemaV1 } from "./standard-schema.js";
-import * as util from "./util.js";
-
-///////////////////////////
-////     base type     ////
-///////////////////////////
-export interface $ZodIssueBase {
-  readonly code?: string;
-  readonly input?: unknown;
-  readonly path: PropertyKey[];
-  readonly message: string;
-}
-
-////////////////////////////////
-////     issue subtypes     ////
-////////////////////////////////
-export type $ZodInvalidTypeExpected =
-  | "string"
-  | "number"
-  | "int"
-  | "boolean"
-  | "bigint"
-  | "symbol"
-  | "undefined"
-  | "null"
-  | "never"
-  | "void"
-  | "date"
-  | "array"
-  | "object"
-  | "tuple"
-  | "record"
-  | "map"
-  | "set"
-  | "file"
-  | "nonoptional"
-  | "nan"
-  | "function"
-  | (string & {}); // class names for instanceof
-
-export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
-  readonly code: "invalid_type";
-  readonly expected: $ZodInvalidTypeExpected;
-  readonly input?: Input;
-}
-
-export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
-  readonly code: "too_big";
-  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
-  readonly maximum: number | bigint;
-  readonly inclusive?: boolean;
-  readonly exact?: boolean;
-  readonly input?: Input;
-}
-
-export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
-  readonly code: "too_small";
-  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
-  readonly minimum: number | bigint;
-  /** True if the allowable range includes the minimum */
-  readonly inclusive?: boolean;
-  /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
-  readonly exact?: boolean;
-  readonly input?: Input;
-}
-
-export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
-  readonly code: "invalid_format";
-  readonly format: $ZodStringFormats | (string & {});
-  readonly pattern?: string;
-  readonly input?: string;
-}
-
-export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
-  readonly code: "not_multiple_of";
-  readonly divisor: number;
-  readonly input?: Input;
-}
-
-export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
-  readonly code: "unrecognized_keys";
-  readonly keys: string[];
-  readonly input?: Record<string, unknown>;
-}
-
-interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
-  readonly code: "invalid_union";
-  readonly errors: $ZodIssue[][];
-  readonly input?: unknown;
-  readonly discriminator?: string | undefined;
-  readonly options?: util.Primitive[];
-  readonly inclusive?: true;
-}
-
-interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
-  readonly code: "invalid_union";
-  readonly errors: [];
-  readonly input?: unknown;
-  readonly discriminator?: string | undefined;
-  readonly inclusive: false;
-  /** Indices of the options that matched */
-  readonly matches: number[];
-}
-
-export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
-
-export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
-  readonly code: "invalid_key";
-  readonly origin: "map" | "record";
-  readonly issues: $ZodIssue[];
-  readonly input?: Input;
-}
-
-export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
-  readonly code: "invalid_element";
-  readonly origin: "map" | "set";
-  readonly key: unknown;
-  readonly issues: $ZodIssue[];
-  readonly input?: Input;
-}
-
-export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
-  readonly code: "invalid_value";
-  readonly values: util.Primitive[];
-  readonly input?: Input;
-}
-
-export interface $ZodIssueCustom extends $ZodIssueBase {
-  readonly code: "custom";
-  readonly params?: Record<string, any> | undefined;
-  readonly input?: unknown;
-}
-
-////////////////////////////////////////////
-////     first-party string formats     ////
-////////////////////////////////////////////
-
-export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
-  format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
-}
-
-export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
-  format: "regex";
-  pattern: string;
-}
-
-export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
-  format: "jwt";
-  algorithm?: string;
-}
-
-export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
-  format: "starts_with";
-  prefix: string;
-}
-
-export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
-  format: "ends_with";
-  suffix: string;
-}
-
-export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
-  format: "includes";
-  includes: string;
-}
-
-export type $ZodStringFormatIssues =
-  | $ZodIssueStringCommonFormats
-  | $ZodIssueStringInvalidRegex
-  | $ZodIssueStringInvalidJWT
-  | $ZodIssueStringStartsWith
-  | $ZodIssueStringEndsWith
-  | $ZodIssueStringIncludes;
-
-////////////////////////
-////     utils     /////
-////////////////////////
-
-export type $ZodIssue =
-  | $ZodIssueInvalidType
-  | $ZodIssueTooBig
-  | $ZodIssueTooSmall
-  | $ZodIssueInvalidStringFormat
-  | $ZodIssueNotMultipleOf
-  | $ZodIssueUnrecognizedKeys
-  | $ZodIssueInvalidUnion
-  | $ZodIssueInvalidKey
-  | $ZodIssueInvalidElement
-  | $ZodIssueInvalidValue
-  | $ZodIssueCustom;
-
-export type $ZodIssueCode = $ZodIssue["code"];
-
-export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = T extends any
-  ? util.Flatten<
-      util.MakePartial<T, "message" | "path"> & {
-        /** The input data */
-        readonly input: unknown;
-        /** The schema or check that originated this issue. */
-        readonly inst?: $ZodType | $ZodCheck;
-        /** The schema that owns the issue. Equal to `inst` when a schema originated the issue, and the schema the check was attached to when a check did. */
-        readonly schema?: $ZodType | undefined;
-        /** If `true`, Zod will continue executing checks/refinements after this issue. */
-        readonly continue?: boolean | undefined;
-      } & Record<string, unknown>
-    >
-  : never;
-
-export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
-
-export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
-  // biome-ignore lint/style/useShorthandFunctionType: interface form is public API
-  (issue: $ZodRawIssue<T>): { message: string } | string | undefined | null;
-}
-
-////////////////////////    ERROR CLASS   ////////////////////////
-
-// const ZOD_ERROR: symbol = Symbol.for("{{zod.error}}");
-export interface $ZodError<T = unknown> extends Error {
-  type: T;
-  issues: $ZodIssue[];
-  _zod: {
-    output: T;
-    def: $ZodIssue[];
-  };
-  stack?: string;
-  name: string;
-}
-
-/* Computing the message eagerly is expensive (pretty-printed JSON of all
- * issues), so defer it until first read. The accessor functions and
- * descriptors are shared across instances to keep error construction
- * cheap; the computed message is cached on the internals object. The
- * setter preserves plain assignment semantics for consumers that
- * overwrite `message`. */
-function _getMessage(this: $ZodError): string {
-  const internals = this._zod as { def: $ZodIssue[]; message?: string };
-  internals.message ??= JSON.stringify(internals.def, util.jsonStringifyReplacer, 2);
-  return internals.message;
-}
-function _setMessage(this: $ZodError, value: string): void {
-  (this._zod as { message?: string }).message = value;
-}
-const _messageDesc: PropertyDescriptor = {
-  get: _getMessage,
-  set: _setMessage,
-  enumerable: true,
-  configurable: true,
-};
-const _issuesDesc: PropertyDescriptor = { value: undefined, enumerable: false };
-
-/* Prototypes that already carry the lazy `toString`. Seeded with the
- * intrinsics so that `init` on a foreign object — it accepts any object —
- * can never install an accessor onto a prototype we do not own. */
-const _installedToString = /* @__PURE__ */ new WeakSet<object>([Object.prototype, Error.prototype]);
-
-const initializer = (inst: $ZodError, def: $ZodIssue[]): void => {
-  inst.name = "$ZodError";
-  // `_zod` is already non-enumerable: $constructor's init defined it with this same descriptor
-  _issuesDesc.value = def;
-  Object.defineProperty(inst, "issues", _issuesDesc);
-  // Clear the shared slot; a retained `value` pins the last error's issues.
-  _issuesDesc.value = undefined;
-  Object.defineProperty(inst, "message", _messageDesc);
-
-  /* `toString` lives as a non-enumerable lazy getter on the shared
-   * prototype; on first access it caches a per-instance closure so
-   * detached usage still works. */
-  const proto = Object.getPrototypeOf(inst);
-  if (!_installedToString.has(proto)) {
-    _installedToString.add(proto);
-    Object.defineProperty(proto, "toString", {
-      configurable: true,
-      enumerable: false,
-      get(this: $ZodError) {
-        const value = () => this.message;
-        Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
-        return value;
-      },
-      set(this: $ZodError, value: unknown) {
-        Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
-      },
-    });
-  }
-};
-
-export const $ZodError: $constructor<$ZodError> = $constructor("$ZodError", initializer);
-interface $ZodRealError<T = any> extends $ZodError<T> {}
-export const $ZodRealError: $constructor<$ZodRealError> = $constructor("$ZodError", initializer, undefined, {
-  Parent: Error,
-});
-
-///////////////////    ERROR UTILITIES   ////////////////////////
-
-// flatten
-export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
-type _FlattenedError<T, U = string> = {
-  formErrors: U[];
-  fieldErrors: {
-    [P in keyof T]?: U[];
-  };
-};
-
-/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
- * ("toString", "constructor") would otherwise read through to the prototype, and assigning
- * "__proto__" would hit the setter instead of creating a key. */
-function node<T>(obj: any, key: PropertyKey, make: () => T): T {
-  if (!Object.prototype.hasOwnProperty.call(obj, key)) {
-    if (key === "__proto__") {
-      Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
-    } else {
-      obj[key] = make();
-    }
-  }
-  return obj[key];
-}
-
-export function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
-export function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
-export function flattenError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIssue) => issue.message as U) {
-  const fieldErrors: Record<PropertyKey, any> = {};
-  const formErrors: U[] = [];
-  for (const sub of error.issues) {
-    if (sub.path.length > 0) {
-      node<U[]>(fieldErrors, sub.path[0]!, () => []).push(mapper(sub));
-    } else {
-      formErrors.push(mapper(sub));
-    }
-  }
-  return { formErrors, fieldErrors };
-}
-
-type _ZodFormattedError<T, U = string> = T extends [any, ...any[]]
-  ? { [K in keyof T]?: $ZodFormattedError<T[K], U> }
-  : T extends any[]
-    ? { [k: number]: $ZodFormattedError<T[number], U> }
-    : T extends object
-      ? util.Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U> }>
-      : any;
-
-export type $ZodFormattedError<T, U = string> = {
-  _errors: U[];
-} & util.Flatten<_ZodFormattedError<T, U>>;
-
-export function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
-export function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
-export function formatError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIssue) => issue.message as U) {
-  const fieldErrors: $ZodFormattedError<T> = { _errors: [] } as any;
-  const processError = (error: { issues: $ZodIssue[] }, path: PropertyKey[] = []) => {
-    for (const issue of error.issues) {
-      if (issue.code === "invalid_union" && issue.errors.length) {
-        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
-      } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
-      } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
-      } else {
-        const fullpath = [...path, ...issue.path];
-        if (fullpath.length === 0) {
-          (fieldErrors as any)._errors.push(mapper(issue));
-        } else {
-          let curr: any = fieldErrors;
-          let i = 0;
-          while (i < fullpath.length) {
-            const el = fullpath[i]!;
-            const terminal = i === fullpath.length - 1;
-
-            // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
-            if (el === "_errors") {
-              if (terminal) curr._errors.push(mapper(issue));
-              i++;
-              continue;
-            }
-
-            // A path element may collide with an inherited property name such as
-            // "__proto__" or "constructor". Truthiness checks read the prototype
-            // (so no node is created, then ._errors.push throws), and bracket
-            // assignment of "__proto__" hits the setter instead of creating an
-            // own key. Guard the read with hasOwnProperty and create the node
-            // with defineProperty so any path element becomes a real own key.
-            if (!Object.prototype.hasOwnProperty.call(curr, el)) {
-              Object.defineProperty(curr, el, {
-                value: { _errors: [] },
-                enumerable: true,
-                writable: true,
-                configurable: true,
-              });
-            }
-            const node = curr[el];
-            if (terminal) {
-              node._errors.push(mapper(issue));
-            }
-            curr = node;
-            i++;
-          }
-        }
-      }
-    }
-  };
-  processError(error);
-  return fieldErrors;
-}
-
-export type $ZodErrorTree<T, U = string> = T extends util.Primitive
-  ? { errors: U[] }
-  : T extends [any, ...any[]]
-    ? { errors: U[]; items?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
-    : T extends any[]
-      ? { errors: U[]; items?: Array<$ZodErrorTree<T[number], U>> }
-      : T extends object
-        ? {
-            errors: U[];
-            properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U> };
-          }
-        : { errors: U[] };
-
-export function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
-export function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
-export function treeifyError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIssue) => issue.message as U) {
-  const result: $ZodErrorTree<T, U> = { errors: [] } as any;
-  const processError = (error: { issues: $ZodIssue[] }, path: PropertyKey[] = []) => {
-    for (const issue of error.issues) {
-      if (issue.code === "invalid_union" && issue.errors.length) {
-        // regular union error
-        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
-      } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
-      } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
-      } else {
-        const fullpath = [...path, ...issue.path];
-        if (fullpath.length === 0) {
-          result.errors.push(mapper(issue));
-          continue;
-        }
-
-        let curr: any = result;
-        let i = 0;
-        while (i < fullpath.length) {
-          const el = fullpath[i]!;
-
-          const terminal = i === fullpath.length - 1;
-          if (typeof el === "string") {
-            curr.properties ??= {};
-            // el may collide with an inherited property name ("__proto__",
-            // "constructor", ...); ??= reads the prototype so the node is never
-            // created and curr.errors.push throws. Guard with hasOwnProperty and
-            // create the node with defineProperty so "__proto__" becomes a real
-            // own key rather than invoking the prototype setter.
-            if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {
-              Object.defineProperty(curr.properties, el, {
-                value: { errors: [] },
-                enumerable: true,
-                writable: true,
-                configurable: true,
-              });
-            }
-            curr = curr.properties[el];
-          } else {
-            curr.items ??= [];
-            curr.items[el] ??= { errors: [] };
-            curr = curr.items[el];
-          }
-
-          if (terminal) {
-            curr.errors.push(mapper(issue));
-          }
-
-          i++;
-        }
-      }
-    }
-  };
-  processError(error);
-  return result;
-}
-
-/** Format a ZodError as a human-readable string in the following form.
- *
- * From
- *
- * ```ts
- * ZodError {
- *   issues: [
- *     {
- *       expected: 'string',
- *       code: 'invalid_type',
- *       path: [ 'username' ],
- *       message: 'Invalid input: expected string'
- *     },
- *     {
- *       expected: 'number',
- *       code: 'invalid_type',
- *       path: [ 'favoriteNumbers', 1 ],
- *       message: 'Invalid input: expected number'
- *     }
- *   ];
- * }
- * ```
- *
- * to
- *
- * ```
- * username
- *   ✖ Expected number, received string at "username
- * favoriteNumbers[0]
- *   ✖ Invalid input: expected number
- * ```
- */
-export function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string {
-  const segs: string[] = [];
-  const path: PropertyKey[] = _path.map((seg: any) => (typeof seg === "object" ? seg.key : seg));
-  for (const seg of path) {
-    if (typeof seg === "number") segs.push(`[${seg}]`);
-    else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
-    else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
-    else {
-      if (segs.length) segs.push(".");
-      segs.push(seg);
-    }
-  }
-
-  return segs.join("");
-}
-
-export function prettifyError(error: StandardSchemaV1.FailureResult): string {
-  const lines: string[] = [];
-  // sort by path length
-  const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
-
-  // Process each issue
-  for (const issue of issues) {
-    lines.push(`✖ ${issue.message}`);
-    if (issue.path?.length) lines.push(`  → at ${toDotPath(issue.path)}`);
-  }
-
-  // Convert Map to formatted string
-  return lines.join("\n");
-}

package/node_modules/zod/src/v4/core/index.ts

@@ -1,19 +0,0 @@
-export * from "./core.js";
-export * from "./parse.js";
-export * from "./errors.js";
-export * from "./schemas.js";
-export * from "./memoizer.js";
-export * from "./checks.js";
-export * from "./versions.js";
-export * as util from "./util.js";
-export { toZod } from "./util.js";
-export * as regexes from "./regexes.js";
-export * as locales from "../locales/index.js";
-export * from "./registries.js";
-export * from "./doc.js";
-export * from "./compile.js";
-export * from "./api.js";
-export * from "./to-json-schema.js";
-export { toJSONSchema } from "./json-schema-processors.js";
-export { JSONSchemaGenerator } from "./json-schema-generator.js";
-export * as JSONSchema from "./json-schema.js";

package/node_modules/zod/src/v4/core/json-schema-generator.ts

@@ -1,131 +0,0 @@
-import { allProcessors } from "./json-schema-processors.js";
-import type * as JSONSchema from "./json-schema.js";
-import type { $ZodRegistry } from "./registries.js";
-import type * as schemas from "./schemas.js";
-import {
-  type JSONSchemaGeneratorParams,
-  type ProcessParams,
-  type Seen,
-  type ToJSONSchemaContext,
-  extractDefs,
-  finalize,
-  initializeContext,
-  processSchema,
-} from "./to-json-schema.js";
-
-/**
- * Parameters for the emit method of JSONSchemaGenerator.
- * @deprecated Use toJSONSchema function instead
- */
-export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
-
-/**
- * Parameters for JSONSchemaGenerator constructor.
- * @deprecated Use toJSONSchema function instead
- */
-type JSONSchemaGeneratorConstructorParams = Pick<
-  JSONSchemaGeneratorParams,
-  "metadata" | "target" | "unrepresentable" | "override" | "io"
->;
-
-/**
- * Legacy class-based interface for JSON Schema generation.
- * This class wraps the new functional implementation to provide backward compatibility.
- *
- * @deprecated Use the `toJSONSchema` function instead for new code.
- *
- * @example
- * ```typescript
- * // Legacy usage (still supported)
- * const gen = new JSONSchemaGenerator({ target: "draft-07" });
- * gen.process(schema);
- * const result = gen.emit(schema);
- *
- * // Preferred modern usage
- * const result = toJSONSchema(schema, { target: "draft-07" });
- * ```
- */
-export class JSONSchemaGenerator {
-  private ctx: ToJSONSchemaContext;
-
-  /** @deprecated Access via ctx instead */
-  get metadataRegistry(): $ZodRegistry<Record<string, any>> {
-    return this.ctx.metadataRegistry;
-  }
-  /** @deprecated Access via ctx instead */
-  get target() {
-    return this.ctx.target;
-  }
-  // annotated so the .d.cts emits an indexed access rather than an inline `import()` of an ESM path
-  /** @deprecated Access via ctx instead */
-  get unrepresentable(): ToJSONSchemaContext["unrepresentable"] {
-    return this.ctx.unrepresentable;
-  }
-  /** @deprecated Access via ctx instead */
-  get override() {
-    return this.ctx.override;
-  }
-  /** @deprecated Access via ctx instead */
-  get io() {
-    return this.ctx.io;
-  }
-  /** @deprecated Access via ctx instead */
-  get counter() {
-    return this.ctx.counter;
-  }
-  set counter(value: number) {
-    this.ctx.counter = value;
-  }
-  /** @deprecated Access via ctx instead */
-  get seen(): Map<schemas.$ZodType, Seen> {
-    return this.ctx.seen;
-  }
-
-  constructor(params?: JSONSchemaGeneratorConstructorParams) {
-    // Normalize target for internal context
-    let normalizedTarget: ToJSONSchemaContext["target"] = params?.target ?? "draft-2020-12";
-    if (normalizedTarget === "draft-4") normalizedTarget = "draft-04";
-    if (normalizedTarget === "draft-7") normalizedTarget = "draft-07";
-
-    this.ctx = initializeContext({
-      processors: allProcessors,
-      target: normalizedTarget,
-      ...(params?.metadata && { metadata: params.metadata }),
-      ...(params?.unrepresentable && { unrepresentable: params.unrepresentable }),
-      ...(params?.override && { override: params.override as any }),
-      ...(params?.io && { io: params.io }),
-    });
-  }
-
-  /**
-   * Process a schema to prepare it for JSON Schema generation.
-   * This must be called before emit().
-   */
-  process(schema: schemas.$ZodType, _params: ProcessParams = { path: [], schemaPath: [] }): JSONSchema.BaseSchema {
-    return processSchema(schema, this.ctx, _params);
-  }
-
-  /**
-   * Emit the final JSON Schema after processing.
-   * Must call process() first.
-   */
-  emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema {
-    // Apply emit params to the context
-    if (_params) {
-      if (_params.cycles) this.ctx.cycles = _params.cycles;
-      if (_params.reused) this.ctx.reused = _params.reused;
-      if (_params.external) this.ctx.external = _params.external;
-    }
-
-    // extractDefs/finalize skip their whole-map passes when they have already run for this `external`, but they also branch on `cycles`, `reused`, `seen.count` and the metadata registry — any of which can change between emits, including with no params at all. Drop the guards so the passes re-run. The registry conversion calls extractDefs/finalize directly and never routes through here, so it keeps skipping them.
-    this.ctx.sharedDefsExtractedFor = undefined;
-    this.ctx.sharedEmitDoneFor = undefined;
-
-    extractDefs(this.ctx, schema);
-    const result = finalize(this.ctx, schema);
-
-    // Strip ~standard property to match old implementation's return type
-    const { "~standard": _, ...plainResult } = result as any;
-    return plainResult as JSONSchema.BaseSchema;
-  }
-}