@openclaw/feishu 2026.9.4 → 2026.9.5

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

@@ -3,6 +3,18 @@ import type * as JSONSchema from "./json-schema.js";
 import { type $ZodRegistry, globalRegistry } from "./registries.js";
 import type * as schemas from "./schemas.js";
 import type { StandardJSONSchemaV1, StandardSchemaWithJSONProps } from "./standard-schema.js";
+import { assignProp } from "./util.js";
+
+function assignProps<T extends object>(target: T, ...sources: object[]): T {
+  for (const source of sources) {
+    for (const key of Reflect.ownKeys(source)) {
+      if (Object.prototype.propertyIsEnumerable.call(source, key)) {
+        assignProp(target, key, (source as any)[key]);
+      }
+    }
+  }
+  return target;
+}
 
 export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (
   schema: T,
@@ -11,6 +23,19 @@ export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (
   params: ProcessParams
 ) => void;
 
+/**
+ * Called for each schema that has no JSON Schema equivalent. Return a JSON Schema to use in its
+ * place, `"any"` to fall back to the `unrepresentable: "any"` behavior, or `"throw"`/`undefined` to
+ * throw the default error. Throwing from the handler propagates, so custom errors work too.
+ */
+export type UnrepresentableHandler<T extends schemas.$ZodType = schemas.$ZodType> = (ctx: {
+  zodSchema: T;
+  path: (string | number)[];
+  /** The error Zod would throw. Distinguishes sites that share a `zodSchema`, e.g. an `undefined`
+   *  vs a `bigint` member of the same literal. */
+  message: string;
+}) => JSONSchema.BaseSchema | "throw" | "any" | undefined;
+
 export interface JSONSchemaGeneratorParams {
   processors: Record<string, Processor>;
   /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
@@ -24,8 +49,9 @@ export interface JSONSchemaGeneratorParams {
   target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
   /** How to handle unrepresentable types.
    * - `"throw"` — Default. Unrepresentable types throw an error
-   * - `"any"` — Unrepresentable types become `{}` */
-  unrepresentable?: "throw" | "any";
+   * - `"any"` — Unrepresentable types become `{}`
+   * - A function — called once per unrepresentable schema; see {@link UnrepresentableHandler}. */
+  unrepresentable?: "throw" | "any" | UnrepresentableHandler<schemas.$ZodTypes>;
   /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
   override?: (ctx: {
     zodSchema: schemas.$ZodTypes;
@@ -85,7 +111,8 @@ export interface ToJSONSchemaContext {
   processors: Record<string, Processor>;
   metadataRegistry: $ZodRegistry<Record<string, any>>;
   target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
-  unrepresentable: "throw" | "any";
+  // must be schemas.$ZodType to prevent recursive type resolution error
+  unrepresentable: "throw" | "any" | UnrepresentableHandler;
   override: (ctx: {
     // must be schemas.$ZodType to prevent recursive type resolution error
     zodSchema: schemas.$ZodType;
@@ -95,8 +122,28 @@ export interface ToJSONSchemaContext {
   io: "input" | "output";
   counter: number;
   seen: Map<schemas.$ZodType, Seen>;
+  /** Registry conversions share one `seen` map across every emitted schema. These hold the
+   * `external` the whole-map passes below last ran for, so the passes are not repeated once per
+   * schema — and still re-run if the map grows or `external` is swapped. `sharedEmitDoneFor`
+   * covers both passes in `finalize`: the ref flattening and the `$defs` build.
+   *
+   * The passes are valid only while nothing they read has changed, so both are cleared in
+   * `process()` when the map grows, and in `JSONSchemaGenerator.emit()`, which can also change
+   * the `cycles` and `reused` they branch on.
+   *
+   * One case is deliberately not covered: an `override` callback that writes to
+   * `metadataRegistry` mid-conversion. It runs inside `finalize`, so a registry conversion has
+   * nowhere left to clear the guards, and later schemas keep the ids the first pass saw. That
+   * output was never coherent — before this, whether a shared subschema was inlined or extracted
+   * depended on which registry entry happened to be emitted when the callback fired. */
+  sharedDefsExtractedFor?: ToJSONSchemaContext["external"];
+  sharedEmitDoneFor?: ToJSONSchemaContext["external"];
   cycles: "ref" | "throw";
   reused: "ref" | "inline";
+  /** The `allOf` array of each intersection encountered during traversal, innermost first. `finalize` folds every emitted object holding one; see `foldIntersection`. */
+  intersections: JSONSchema.BaseSchema[][];
+  /** Rewrites a processor deferred to `finalize`, where the flatten has resolved every ref and the union branches are in place. */
+  deferred: (() => void)[];
   external?:
     | {
         registry: $ZodRegistry<{ id?: string | undefined }>;
@@ -125,17 +172,43 @@ export function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSche
     processors: params.processors ?? {},
     metadataRegistry: params?.metadata ?? globalRegistry,
     target,
-    unrepresentable: params?.unrepresentable ?? "throw",
+    unrepresentable: (params?.unrepresentable as ToJSONSchemaContext["unrepresentable"]) ?? "throw",
     override: (params?.override as any) ?? (() => {}),
     io: params?.io ?? "output",
     counter: 0,
     seen: new Map(),
+    sharedDefsExtractedFor: undefined,
+    sharedEmitDoneFor: undefined,
     cycles: params?.cycles ?? "ref",
     reused: params?.reused ?? "inline",
+    intersections: [],
+    deferred: [],
     external: params?.external ?? undefined,
   };
 }
 
+/**
+ * Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws
+ * `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a
+ * custom JSON Schema was written into `json`, in which case the caller must not write its own.
+ */
+export function handleUnrepresentable(
+  schema: schemas.$ZodType,
+  ctx: ToJSONSchemaContext,
+  json: JSONSchema.BaseSchema,
+  params: ProcessParams,
+  message: string
+): boolean {
+  const result =
+    typeof ctx.unrepresentable === "function"
+      ? ctx.unrepresentable({ zodSchema: schema, path: params.path, message })
+      : ctx.unrepresentable;
+  if (result === "any") return false;
+  if (result === undefined || result === "throw") throw new Error(message);
+  Object.assign(json, result);
+  return true;
+}
+
 export function process<T extends schemas.$ZodType>(
   schema: T,
   ctx: ToJSONSchemaContext,
@@ -161,6 +234,8 @@ export function process<T extends schemas.$ZodType>(
   // initialize
   const result: Seen = { schema: {}, count: 1, cycle: undefined, path: _params.path };
   ctx.seen.set(schema, result);
+  ctx.sharedDefsExtractedFor = undefined;
+  ctx.sharedEmitDoneFor = undefined;
 
   // custom method overrides default behavior
   const overrideSchema = schema._zod.toJSONSchema?.();
@@ -196,7 +271,7 @@ export function process<T extends schemas.$ZodType>(
 
   // metadata
   const meta = ctx.metadataRegistry.get(schema);
-  if (meta) Object.assign(result.schema, meta);
+  if (meta) assignProps(result.schema, meta);
 
   if (ctx.io === "input" && isTransforming(schema)) {
     // examples/defaults only apply to output type of pipe
@@ -214,6 +289,11 @@ export function process<T extends schemas.$ZodType>(
   return _result.schema;
 }
 
+// Escape a reference token for use in a JSON Pointer fragment (RFC 6901): `~` becomes `~0` and `/` becomes `~1`. The `~` replacement must run first.
+function encodeJSONPointerSegment(segment: string): string {
+  return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+
 export function extractDefs<T extends schemas.$ZodType>(
   ctx: ToJSONSchemaContext,
   schema: T
@@ -224,6 +304,9 @@ export function extractDefs<T extends schemas.$ZodType>(
 
   if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
 
+  // With `external` set, every registered schema resolves through the external branch of `makeURI`, so the root branch below produces the same ref the external branch would — this pass is identical whichever schema it is called with, and only needs to run once.
+  if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external) return;
+
   // Track ids to detect duplicates across different schemas
   const idToSchema = new Map<string, schemas.$ZodType>();
   for (const entry of ctx.seen.entries()) {
@@ -239,12 +322,9 @@ export function extractDefs<T extends schemas.$ZodType>(
     }
   }
 
-  // returns a ref to the schema
-  // defId will be empty if the ref points to an external schema (or #)
+  // returns a ref to the schema defId will be empty if the ref points to an external schema (or #)
   const makeURI = (entry: [schemas.$ZodType<unknown, unknown>, Seen]): { ref: string; defId?: string } => {
-    // comparing the seen objects because sometimes
-    // multiple schemas map to the same seen object.
-    // e.g. lazy
+    // comparing the seen objects because sometimes multiple schemas map to the same seen object. e.g. lazy
 
     // external is configured
     const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -260,22 +340,23 @@ export function extractDefs<T extends schemas.$ZodType>(
       // otherwise, add to __shared
       const id: string = entry[1].defId ?? (entry[1].schema.id as string) ?? `schema${ctx.counter++}`;
       entry[1].defId = id; // set defId so it will be reused if needed
-      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
+      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${encodeJSONPointerSegment(id)}` };
     }
 
-    if (entry[1] === root) {
-      return { ref: "#" };
+    const uriPrefix = `#`;
+    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
+
+    // an id-less root has nowhere to be extracted to, so it stays inline and self-references as `#`
+    if (entry[1] === root && !entry[1].schema.id) {
+      return { ref: uriPrefix };
     }
 
     // self-contained schema
-    const uriPrefix = `#`;
-    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
     const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
-    return { defId, ref: defUriPrefix + defId };
+    return { defId, ref: defUriPrefix + encodeJSONPointerSegment(defId) };
   };
 
-  // stored cached version in `def` property
-  // remove all properties, set $ref
+  // stored cached version in `def` property remove all properties, set $ref
   const extractToDef = (entry: [schemas.$ZodType<unknown, unknown>, Seen]): void => {
     // if the schema is already a reference, do not extract it
     if (entry[1].schema.$ref) {
@@ -285,8 +366,7 @@ export function extractDefs<T extends schemas.$ZodType>(
     const { ref, defId } = makeURI(entry);
 
     seen.def = { ...seen.schema };
-    // defId won't be set if the schema is a reference to an external schema
-    // or if the schema is the root schema
+    // defId won't be set if the schema is a reference to an external schema or if the schema is the root schema
     if (defId) seen.defId = defId;
     // wipe away all properties except $ref
     const schema = seen.schema;
@@ -354,6 +434,133 @@ export function extractDefs<T extends schemas.$ZodType>(
       }
     }
   }
+
+  if (ctx.external) ctx.sharedDefsExtractedFor = ctx.external;
+}
+
+/** Rewrites `anyOf: [{type: "a"}, {type: "b"}]` to `type: ["a", "b"]`, which every JSON Schema draft treats as equivalent and most consumers render far better for the nullable case. Only branches that are a bare type assertion qualify — anything carrying a constraint, `$ref`, `const` or metadata is left alone. Runs after `flattenRef`, so a branch an override decorated or `$defs` extraction turned into a `$ref` is no longer bare and correctly stays in `anyOf`. `oneOf` is excluded: `integer` and `number` overlap, so "exactly one" and "at least one" are not the same there. OpenAPI 3.0 is excluded: its `type` must be a single string. */
+function compactTypeUnion(schema: JSONSchema.BaseSchema): void {
+  const options = schema.anyOf;
+  if (!Array.isArray(options) || options.length === 0 || schema.type !== undefined) return;
+
+  const types: JSONSchema.SchemaType[] = [];
+  for (const option of options) {
+    if (!option || typeof option !== "object") return;
+    // A branch that is itself a compactible union folds into this one — nested `anyOf` and a flat `type` array say the same thing. Compacting it first also makes the result independent of the order this pass walks the seen map in.
+    compactTypeUnion(option as JSONSchema.BaseSchema);
+    const keys = Object.keys(option);
+    if (keys.length !== 1 || keys[0] !== "type") return;
+    const type = (option as JSONSchema.BaseSchema).type;
+    for (const member of Array.isArray(type) ? type : [type]) {
+      if (typeof member !== "string") return;
+      if (!types.includes(member)) types.push(member);
+    }
+  }
+
+  delete schema.anyOf;
+  // A `type` array must be non-empty and unique (metaschema); a single member is spelled as a bare string.
+  schema.type = types.length === 1 ? types[0] : types;
+}
+
+/** Keywords `foldIntersection` knows how to combine. Anything else — `$ref`, `patternProperties`,
+ * an annotation like `description` — makes a member unfoldable, so a constraint this does not
+ * understand leaves the `allOf` alone instead of being silently dropped or misattributed. */
+const FOLDABLE_KEYS = new Set(["type", "properties", "required", "additionalProperties"]);
+const UNION_KEYS = ["oneOf", "anyOf"] as const;
+
+/** A member's constraint on a key it does not declare itself. A `catchall` states one; `false`, an absent `additionalProperties`, and the empty schema a loose object emits state nothing. */
+function undeclaredConstraint(member: JSONSchema.ObjectSchema): JSONSchema.BaseSchema | null {
+  const extra = member.additionalProperties;
+  if (extra === undefined || extra === false || typeof extra !== "object" || extra === null) return null;
+  return Object.keys(extra).length ? (extra as JSONSchema.BaseSchema) : null;
+}
+
+/** Combines object members into the single object they describe together, or returns `null` if any of them carries a keyword outside {@link FOLDABLE_KEYS}. */
+function foldObjects(members: JSONSchema._JSONSchema[]): JSONSchema.ObjectSchema | null {
+  const objects: JSONSchema.ObjectSchema[] = [];
+  for (const member of members) {
+    // A boolean subschema is legal JSON Schema and carries no keywords to fold.
+    if (typeof member !== "object" || member.type !== "object") return null;
+    for (const key in member) {
+      if (!FOLDABLE_KEYS.has(key)) return null;
+    }
+    objects.push(member as JSONSchema.ObjectSchema);
+  }
+
+  const properties: Record<string, JSONSchema._JSONSchema> = {};
+  const required = new Set<string>();
+  for (const object of objects) {
+    for (const key in object.properties) {
+      // `in` would report a `__proto__` key as already present via the prototype chain and skip it.
+      if (Object.prototype.hasOwnProperty.call(properties, key)) continue;
+      // Every member constrains this key: the ones that declare it say how, and a `catchall` member constrains it too even though it does not name it. The key has to satisfy all of them, which is the same intersection one level down.
+      const parts: JSONSchema._JSONSchema[] = [];
+      for (const other of objects) {
+        const part = other.properties?.[key] ?? undeclaredConstraint(other);
+        if (part === null || part === undefined) continue;
+        if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part))) parts.push(part);
+      }
+      const merged =
+        parts.length === 1
+          ? parts[0]!
+          : (foldObjects(parts) ?? ({ allOf: parts as JSONSchema.BaseSchema[] } as JSONSchema.BaseSchema));
+      assignProp(properties, key, merged);
+    }
+    for (const key of object.required ?? []) required.add(key);
+  }
+
+  const folded: JSONSchema.ObjectSchema = { type: "object", properties };
+  if (required.size) folded.required = [...required];
+  // A key no member declares is rejected only when every member rejects it, so the fold is closed only when every member is. Otherwise it carries whatever the `catchall` members demand of such a key.
+  if (objects.every((object) => object.additionalProperties === false)) {
+    folded.additionalProperties = false;
+  } else {
+    const constraints: JSONSchema.BaseSchema[] = [];
+    for (const object of objects) {
+      const constraint = undeclaredConstraint(object);
+      if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint)))
+        constraints.push(constraint);
+    }
+    if (constraints.length === 1) folded.additionalProperties = constraints[0]!;
+    else if (constraints.length > 1) folded.additionalProperties = { allOf: constraints };
+  }
+  return folded;
+}
+
+/** `additionalProperties` in an `allOf` member sees only that member's own `properties`, so two
+ * closed object members reject each other's keys and the schema validates nothing. Zod's parser
+ * pools the key sets instead — `handleIntersectionResults` reports a key as unrecognized only when
+ * *every* side rejects it — so the emitted schema has to pool them too, and folding the members
+ * into one object is the encoding that says so on every target.
+ *
+ * This runs from `finalize`, after `extractDefs`, which is what keeps it clear of the `$ref`
+ * machinery: a member extracted into `$defs` is already a `$ref` by now and declines to fold, so it
+ * keeps its reference and its own closedness rather than being inlined as a stale copy. */
+function foldIntersection(json: JSONSchema.BaseSchema): void {
+  const allOf = json.allOf;
+  if (!Array.isArray(allOf) || allOf.length < 2) return;
+  // An `override` runs before this pass and may have written object keywords onto the intersection itself. Those are deliberate, so decline rather than overwrite them.
+  for (const key of FOLDABLE_KEYS) if (key in json) return;
+
+  // An intersection distributes over a union: `A & (X | Y)` is `(A & X) | (A & Y)`. Only the first union is distributed over; a second one stays among the members every branch folds against, where it fails the object check and declines the whole intersection rather than multiplying out.
+  const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
+
+  let folded: JSONSchema.BaseSchema | null = null;
+  if (!unions.length) {
+    folded = foldObjects(allOf);
+  } else {
+    const union = unions[0]!;
+    const keyword = UNION_KEYS.find((k) => Array.isArray(union[k]))!;
+    if (Object.keys(union).length !== 1) return;
+    const rest = allOf.filter((m) => m !== union);
+    const branches = (union[keyword] as JSONSchema._JSONSchema[]).map((branch) => foldObjects([...rest, branch]));
+    if (branches.some((b) => !b)) return;
+    folded = { [keyword]: branches } as JSONSchema.BaseSchema;
+  }
+  if (!folded) return;
+
+  delete json.allOf;
+  assignProps(json, folded);
 }
 
 export function finalize<T extends schemas.$ZodType>(
@@ -388,10 +595,10 @@ export function finalize<T extends schemas.$ZodType>(
         schema.allOf = schema.allOf ?? [];
         schema.allOf.push(refSchema);
       } else {
-        Object.assign(schema, refSchema);
+        assignProps(schema, refSchema);
       }
       // restore child's own properties (child wins)
-      Object.assign(schema, _cached);
+      assignProps(schema, _cached);
 
       const isParentRef = zodSchema._zod.parent === ref;
 
@@ -416,9 +623,7 @@ export function finalize<T extends schemas.$ZodType>(
       }
     }
 
-    // If parent was extracted (has $ref), propagate $ref to this schema
-    // This handles cases like: readonly().meta({id}).describe()
-    // where processor sets ref to innerType but parent should be referenced
+    // If parent was extracted (has $ref), propagate $ref to this schema. This handles cases like: readonly().meta({id}).describe() where processor sets ref to innerType but parent should be referenced
     const parent = zodSchema._zod.parent;
     if (parent && parent !== ref) {
       // Ensure parent is processed first so its def has inherited properties
@@ -446,8 +651,36 @@ export function finalize<T extends schemas.$ZodType>(
     });
   };
 
-  for (const entry of [...ctx.seen.entries()].reverse()) {
-    flattenRef(entry[0]);
+  // Flattening walks the whole map and clears each `ref` as it goes, so a second call over the same map is a no-op scan. Skip it outright once it has run for a registry conversion.
+  if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
+    for (const entry of [...ctx.seen.entries()].reverse()) {
+      flattenRef(entry[0]);
+    }
+
+    if (ctx.target !== "openapi-3.0") {
+      for (const entry of ctx.seen.entries()) {
+        compactTypeUnion(entry[1].def ?? entry[1].schema);
+      }
+    }
+
+    for (const rewrite of ctx.deferred) rewrite();
+
+    // After flattening, every member that was extracted is a `$ref`, so the fold sees the final shape. A schema that inherits an intersection — through `z.lazy`, or any `ref` chain — holds the same `allOf` array, so fold by array identity to catch every copy.
+    if (ctx.intersections.length) {
+      const carriers = new Map<JSONSchema.BaseSchema[], JSONSchema.BaseSchema[]>();
+      for (const seen of ctx.seen.values()) {
+        for (const json of [seen.schema, seen.def]) {
+          const allOf = json?.allOf as JSONSchema.BaseSchema[] | undefined;
+          if (!Array.isArray(allOf)) continue;
+          const existing = carriers.get(allOf);
+          if (existing) existing.push(json!);
+          else carriers.set(allOf, [json!]);
+        }
+      }
+      for (const allOf of ctx.intersections) {
+        for (const json of carriers.get(allOf) ?? []) foldIntersection(json);
+      }
+    }
   }
 
   const result: JSONSchema.BaseSchema = {};
@@ -469,24 +702,25 @@ export function finalize<T extends schemas.$ZodType>(
     result.$id = ctx.external.uri(id);
   }
 
-  Object.assign(result, root.def ?? root.schema);
+  // when the root was extracted into $defs, `root.schema` is the `$ref` wrapper and `root.def` is the body that now lives under $defs
+  assignProps(result, root.defId ? root.schema : (root.def ?? root.schema));
 
-  // The `id` in `.meta()` is a Zod-specific registration tag used to extract
-  // schemas into $defs — it is not user-facing JSON Schema metadata. Strip it
-  // from the output body where it would otherwise leak. The id is preserved
-  // implicitly via the $defs key (and via $ref paths).
+  // The `id` in `.meta()` is a Zod-specific registration tag used to extract schemas into $defs — it is not user-facing JSON Schema metadata. Strip it from the output body where it would otherwise leak. The id is preserved implicitly via the $defs key (and via $ref paths).
   const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
   if (rootMetaId !== undefined && result.id === rootMetaId) delete result.id;
 
-  // build defs object
+  // build defs object. With `external`, `defs` is the shared object every schema writes into, so the same entries are reassigned on every call. Without it, `defs` is fresh per call and must be rebuilt.
   const defs: JSONSchema.BaseSchema["$defs"] = ctx.external?.defs ?? {};
-  for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
-    if (seen.def && seen.defId) {
-      if (seen.def.id === seen.defId) delete seen.def.id;
-      defs[seen.defId] = seen.def;
+  if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
+    for (const entry of ctx.seen.entries()) {
+      const seen = entry[1];
+      if (seen.def && seen.defId) {
+        if (seen.def.id === seen.defId) delete seen.def.id;
+        assignProp(defs, seen.defId, seen.def);
+      }
     }
   }
+  if (ctx.external) ctx.sharedEmitDoneFor = ctx.external;
 
   // set definitions in result
   if (ctx.external) {
@@ -501,9 +735,7 @@ export function finalize<T extends schemas.$ZodType>(
   }
 
   try {
-    // this "finalizes" this schema and ensures all cycles are removed
-    // each call to finalize() is functionally independent
-    // though the seen map is shared
+    // this "finalizes" this schema and ensures all cycles are removed each call to finalize() is functionally independent though the seen map is shared
     const finalized = JSON.parse(JSON.stringify(result));
     Object.defineProperty(finalized, "~standard", {
       value: {
@@ -549,7 +781,8 @@ function isTransforming(
     def.type === "nullable" ||
     def.type === "readonly" ||
     def.type === "default" ||
-    def.type === "prefault"
+    def.type === "prefault" ||
+    def.type === "catch"
   ) {
     return isTransforming(def.innerType, ctx);
   }