effect 4.0.0-rc.111 → 4.0.0-rc.113

package/dist/JsonSchema.js

@@ -4,15 +4,13 @@
  * OpenAPI 3.0, and OpenAPI 3.1; conversions normalize through
  * `Document<"draft-2020-12">` before emitting another dialect, including
  * JSON Schema Draft-04. The module also defines document types, meta-schema
- * constants, OpenAPI component-key helpers, and `$ref` resolution utilities.
+ * constants, and OpenAPI component-key helpers.
  *
  * @since 4.0.0
  */
-import * as Arr from "./Array.js";
 import * as InternalRecord from "./internal/record.js";
-import { unescapeToken } from "./JsonPointer.js";
+import { formatUriFragment, parseUriFragment } from "./JsonPointer.js";
 import * as Predicate from "./Predicate.js";
-import * as Rec from "./Record.js";
 /**
  * Represents the `$schema` meta-schema URI for JSON Schema Draft-04.
  *
@@ -65,15 +63,15 @@ export const META_SCHEMA_URI_DRAFT_07 = "http://json-schema.org/draft-07/schema#
  * @since 4.0.0
  */
 export const META_SCHEMA_URI_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
-const RE_DEFINITIONS = /^#\/definitions(?=\/|$)/;
-const RE_DEFS = /^#\/\$defs(?=\/|$)/;
-const RE_COMPONENTS_SCHEMAS = /^#\/components\/schemas(?=\/|$)/;
-const DRAFT_04_COPY_KEYWORDS = /*#__PURE__*/new Set(["$ref", "type", "required", "enum", "title", "description", "default", "format", "pattern", "minLength", "maxLength", "minItems", "maxItems", "minProperties", "maxProperties", "multipleOf", "uniqueItems"]);
-const DRAFT_07_COPY_KEYWORDS = /*#__PURE__*/new Set([...DRAFT_04_COPY_KEYWORDS, "const", "examples", "readOnly", "writeOnly", "minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"]);
-const DRAFT_04_SINGLE_SUBSCHEMA_KEYWORDS = /*#__PURE__*/new Set(["not"]);
-const DRAFT_07_SINGLE_SUBSCHEMA_KEYWORDS = /*#__PURE__*/new Set(["not", "additionalProperties", "propertyNames"]);
-const MAP_SUBSCHEMA_KEYWORDS = /*#__PURE__*/new Set(["properties", "patternProperties"]);
-const ARRAY_SUBSCHEMA_KEYWORDS = /*#__PURE__*/new Set(["allOf", "anyOf", "oneOf"]);
+const META_SCHEMA_URI_OPEN_API_3_1 = "https://spec.openapis.org/oas/3.1/dialect/base";
+function isMetaSchemaUri(value, uri) {
+  return value === uri || value === (uri.endsWith("#") ? uri.slice(0, -1) : `${uri}#`);
+}
+function rewriteOpenApiComponentsReference(reference) {
+  const path = reference.startsWith("#") ? parseUriFragment(reference) : undefined;
+  return path !== undefined && path[0] === "components" && path[1] === "schemas" ? formatUriFragment(["$defs", ...path.slice(2)]) : reference;
+}
+const OPEN_API_31_TARGET_COLLISIONS = ["example", "discriminator", "xml", "externalDocs"];
 /**
  * Parses a raw Draft-07 JSON Schema into a `Document<"draft-2020-12">`.
  *
@@ -85,13 +83,21 @@ const ARRAY_SUBSCHEMA_KEYWORDS = /*#__PURE__*/new Set(["allOf", "anyOf", "oneOf"
  * **Details**
  *
  * This converts Draft-07 tuple syntax (`items` as array plus
- * `additionalItems`) to Draft-2020-12 form (`prefixItems` plus `items`),
- * rewrites `#/definitions/...` refs to `#/$defs/...`, and extracts root-level
- * `definitions` into the `definitions` field.
+ * `additionalItems`) to Draft-2020-12 form (`prefixItems` plus `items`), splits
+ * `dependencies` into `dependentRequired` and `dependentSchemas`, converts
+ * plain-name `$id` fragments to `$anchor`, and extracts root-level
+ * `definitions` into the `definitions` field. Local JSON Pointer refs are
+ * relocated when one of these structural conversions moves its target.
  *
  * **Gotchas**
  *
- * Unsupported keywords, such as `if`/`then`/`else` and `$id`, are dropped.
+ * Unknown and custom keywords are copied as opaque values. Their contents are
+ * not treated as nested schemas. Draft-07 keywords such as `if` / `then` /
+ * `else` and `contains` are preserved and their subschemas are converted.
+ * Siblings of a valid Draft-07 `$ref` are ignored according to Draft-07
+ * semantics. The conversion throws when a Draft-07 `$id` fragment cannot be
+ * represented as a Draft-2020-12 `$anchor`, or when an unknown Draft-07
+ * keyword would become an active Draft-2020-12 keyword after copying.
  *
  * **Example** (Parsing a Draft-07 schema)
  *
@@ -120,65 +126,7 @@ const ARRAY_SUBSCHEMA_KEYWORDS = /*#__PURE__*/new Set(["allOf", "anyOf", "oneOf"
  * @since 4.0.0
  */
 export function fromSchemaDraft07(js) {
-  let definitions;
-  const schema = walk(js, true);
-  return {
-    dialect: "draft-2020-12",
-    schema,
-    definitions: definitions ?? {}
-  };
-  function walk(node, isRoot) {
-    if (Array.isArray(node)) return node.map(walkNested);
-    if (!Predicate.isObject(node)) return node;
-    const out = {};
-    let prefixItems = undefined;
-    let additionalItems = undefined;
-    for (const k of Object.keys(node)) {
-      const v = node[k];
-      if (k === "$ref") {
-        out.$ref = typeof v === "string" ? v.replace(RE_DEFINITIONS, "#/$defs") : v;
-        continue;
-      }
-      if (DRAFT_07_COPY_KEYWORDS.has(k)) {
-        out[k] = v;
-        continue;
-      }
-      if (rewriteSubschemaKeyword(out, k, v, walkNested, DRAFT_07_SINGLE_SUBSCHEMA_KEYWORDS)) continue;
-      switch (k) {
-        case "definitions":
-          {
-            const mapped = mapObject(v, walkNested);
-            if (isRoot) {
-              definitions = mapped;
-            } else {
-              out.definitions = mapped ?? v;
-            }
-            break;
-          }
-        case "items":
-          prefixItems = v;
-          break;
-        case "additionalItems":
-          additionalItems = v;
-          break;
-        default:
-          break;
-      }
-    }
-    // Draft-07 tuples -> 2020-12 tuples
-    if (prefixItems !== undefined) {
-      if (Array.isArray(prefixItems)) {
-        out.prefixItems = prefixItems.map(walkNested);
-        if (additionalItems !== undefined) out.items = walkNested(additionalItems);
-      } else {
-        out.items = walkNested(prefixItems);
-      }
-    }
-    return out;
-  }
-  function walkNested(node) {
-    return walk(node, false);
-  }
+  return fromSchemaDraft2020_12(convertDraft07(js));
 }
 /**
  * Parses a raw Draft-2020-12 JSON Schema into a `Document<"draft-2020-12">`.
@@ -234,8 +182,17 @@ export function fromSchemaDraft2020_12(js) {
  *
  * **Details**
  *
- * This rewrites `#/components/schemas/...` refs to `#/$defs/...`, then delegates
- * to {@link fromSchemaDraft2020_12}.
+ * This rewrites `#/components/schemas/...` refs to `#/$defs/...`, normalizes the
+ * OpenAPI base dialect URI to Draft 2020-12, converts the deprecated singular
+ * `example` field to `examples`, then delegates to
+ * {@link fromSchemaDraft2020_12}.
+ *
+ * **Gotchas**
+ *
+ * When both `example` and `examples` are present, the singular example is
+ * prepended to the array. Custom `$schema` dialect URIs and unknown keywords
+ * are copied opaquely. Component references inside a schema resource identified
+ * by `$id` are left unchanged because they are relative to that resource.
  *
  * **Example** (Parsing an OpenAPI 3.1 schema)
  *
@@ -259,7 +216,20 @@ export function fromSchemaDraft2020_12(js) {
  * @since 4.0.0
  */
 export function fromSchemaOpenApi3_1(js) {
-  const schema = rewriteRefs(js, ref => ref.replace(RE_COMPONENTS_SCHEMAS, "#/$defs"));
+  const isRootResource = createsResource(js.$id);
+  const schema = transformSchema(js, (schema, inEmbeddedResource) => {
+    if (!isRootResource && !inEmbeddedResource) rewriteSchemaRef(schema, rewriteOpenApiComponentsReference);
+    if (isMetaSchemaUri(schema.$schema, META_SCHEMA_URI_OPEN_API_3_1)) {
+      InternalRecord.assignProperty(schema, "$schema", META_SCHEMA_URI_DRAFT_2020_12);
+    }
+    if (Object.hasOwn(schema, "example")) {
+      const examples = schema.examples;
+      if (examples === undefined || Array.isArray(examples)) {
+        InternalRecord.assignProperty(schema, "examples", [schema.example, ...(examples ?? [])]);
+        delete schema.example;
+      }
+    }
+  });
   return fromSchemaDraft2020_12(schema);
 }
 /**
@@ -272,10 +242,19 @@ export function fromSchemaOpenApi3_1(js) {
  *
  * **Details**
  *
- * This handles OpenAPI 3.0 extensions, including `nullable`, singular
- * `example`, and boolean `exclusiveMinimum` or `exclusiveMaximum`. It
- * normalizes the schema to Draft-07 first, then converts to Draft-2020-12 via
- * {@link fromSchemaDraft07}.
+ * This directly converts OpenAPI 3.0 schema objects to Draft-2020-12. It
+ * handles `nullable`, singular `example`, boolean `exclusiveMinimum` and
+ * `exclusiveMaximum`, and OpenAPI component refs. Only values in OpenAPI
+ * schema positions are traversed as schemas.
+ *
+ * **Gotchas**
+ *
+ * OpenAPI 3.0 `nullable` is applied only when the same Schema Object has an
+ * explicit string `type`; other constraints such as `enum` are left
+ * unchanged. Unknown keywords, vendor extensions, and annotation values are
+ * copied opaquely unless their name would become active in Draft 2020-12 and
+ * change meaning, in which case conversion throws. Siblings of a valid
+ * OpenAPI 3.0 `$ref` are ignored.
  *
  * **Example** (Parsing an OpenAPI 3.0 nullable schema)
  *
@@ -297,8 +276,7 @@ export function fromSchemaOpenApi3_1(js) {
  * @since 4.0.0
  */
 export function fromSchemaOpenApi3_0(schema) {
-  const normalized = normalizeOpenApi3_0ToDraft07(schema);
-  return fromSchemaDraft07(normalized);
+  return fromSchemaDraft2020_12(convertOpenApi30(schema));
 }
 /**
  * Converts a `Document<"draft-2020-12">` to a `Document<"draft-07">`.
@@ -312,12 +290,20 @@ export function fromSchemaOpenApi3_0(schema) {
  *
  * This rewrites `#/$defs/...` refs to `#/definitions/...`, converts
  * Draft-2020-12 tuple syntax (`prefixItems` plus `items`) to Draft-07 form
- * (`items` as array plus `additionalItems`), and converts both the root schema
- * and all definitions.
+ * (`items` as array plus `additionalItems`), merges `dependentRequired` and
+ * `dependentSchemas` into `dependencies`, and converts both the root schema
+ * and all definitions. Local JSON Pointer refs are relocated when structural
+ * keywords move.
  *
  * **Gotchas**
  *
- * Unsupported Draft-2020-12 keywords are dropped.
+ * Unknown and custom keywords are copied as opaque values. Known keywords
+ * that Draft-07 cannot represent cause the conversion to throw
+ * instead of being dropped. These include dynamic references,
+ * `unevaluatedProperties`, `unevaluatedItems`, and non-default `minContains`
+ * or `maxContains` constraints. Conversion also throws when an opaque
+ * Draft-2020-12 keyword would collide with an active Draft-07 keyword, or when
+ * `$id` and `$anchor` occur together because Draft-07 cannot preserve both identifiers.
  *
  * **Example** (Converting to Draft-07)
  *
@@ -345,8 +331,7 @@ export function fromSchemaOpenApi3_0(schema) {
 export function toDocumentDraft07(document) {
   return {
     dialect: "draft-07",
-    schema: toSchemaDraft07(document.schema),
-    definitions: Rec.map(document.definitions, toSchemaDraft07)
+    ...convertDocument(document, draft07Adapter)
   };
 }
 /**
@@ -359,14 +344,23 @@ export function toDocumentDraft07(document) {
  *
  * **Details**
  *
- * This rewrites `#/$defs/...` refs to `#/definitions/...`, converts tuple
- * syntax, lowers `const` to `enum`, converts numeric exclusive bounds to the
- * Draft-04 boolean form, and converts both the root schema and all definitions.
+ * This directly rewrites `#/$defs/...` refs to `#/definitions/...`, converts
+ * tuple syntax, merges canonical dependencies, lowers `const` to `enum`,
+ * converts numeric exclusive bounds to the Draft-04 boolean form, lowers
+ * conditionals and basic `contains` through boolean applicators, and converts
+ * both the root schema and all definitions.
  *
  * **Gotchas**
  *
- * Unsupported Draft-2020-12 and Draft-07 keywords are dropped. For example,
- * `propertyNames` has no general Draft-04 equivalent and is omitted.
+ * Unknown and custom keywords are copied as opaque values. Newer annotation
+ * keywords are preserved as Draft-04 extensions. Known keywords
+ * without a Draft-04 equivalent, including `propertyNames`, non-default
+ * `contains` cardinality, dynamic references, and unevaluated constraints,
+ * cause the conversion to throw instead of being dropped. A conditional with
+ * both branches also throws when lowering it would duplicate a nested schema
+ * identifier. Conversion also throws when an opaque Draft-2020-12 keyword
+ * would collide with an active Draft-04 keyword, or when `$id` and `$anchor`
+ * occur together because Draft-04 cannot preserve both identifiers.
  *
  * **Example** (Converting exclusive bounds)
  *
@@ -386,135 +380,14 @@ export function toDocumentDraft07(document) {
  * @since 4.0.0
  */
 export function toDocumentDraft04(document) {
-  const draft07 = toDocumentDraft07(document);
   return {
     dialect: "draft-04",
-    schema: toSchemaDraft04(draft07.schema),
-    definitions: Rec.map(draft07.definitions, toSchemaDraft04)
-  };
-}
-function toSchemaDraft04(schema) {
-  return walk(schema);
-  function walk(node) {
-    if (node === true) return {};
-    if (node === false) return {
-      not: {}
-    };
-    if (Array.isArray(node)) return node.map(walk);
-    if (!Predicate.isObject(node)) return node;
-    const src = node;
-    const out = {};
-    let hasConst = false;
-    let constValue = undefined;
-    for (const k of Object.keys(src)) {
-      const v = src[k];
-      if (DRAFT_04_COPY_KEYWORDS.has(k)) {
-        out[k] = v;
-        continue;
-      }
-      if (rewriteSubschemaKeyword(out, k, v, walk, DRAFT_04_SINGLE_SUBSCHEMA_KEYWORDS)) continue;
-      switch (k) {
-        case "const":
-          hasConst = true;
-          constValue = v;
-          break;
-        case "minimum":
-        case "maximum":
-        case "exclusiveMinimum":
-        case "exclusiveMaximum":
-          break;
-        case "additionalProperties":
-        case "additionalItems":
-          out[k] = typeof v === "boolean" ? v : walk(v);
-          break;
-        case "items":
-          out.items = Array.isArray(v) ? v.map(walk) : walk(v);
-          break;
-        default:
-          break;
-      }
-    }
-    convertExclusiveBound(src, out, "minimum", "exclusiveMinimum", (bound, exclusive) => bound > exclusive);
-    convertExclusiveBound(src, out, "maximum", "exclusiveMaximum", (bound, exclusive) => bound < exclusive);
-    if (hasConst) {
-      const constSchema = {
-        enum: [constValue]
-      };
-      if (Object.hasOwn(src, "enum")) {
-        out.allOf = Array.isArray(out.allOf) ? [...out.allOf, constSchema] : [constSchema];
-      } else {
-        out.enum = constSchema.enum;
-      }
-    }
-    return out;
-  }
-}
-function convertExclusiveBound(src, out, boundKey, exclusiveKey, isBoundStricter) {
-  const bound = src[boundKey];
-  const exclusive = src[exclusiveKey];
-  if (typeof exclusive === "number") {
-    if (typeof bound === "number" && isBoundStricter(bound, exclusive)) {
-      out[boundKey] = bound;
-    } else {
-      out[boundKey] = exclusive;
-      out[exclusiveKey] = true;
-    }
-  } else if (bound !== undefined) {
-    out[boundKey] = bound;
-  }
-}
-function toSchemaDraft07(schema) {
-  return transformSchema(schema, src => {
-    rewriteSchemaRef(src, ref => ref.replace(RE_DEFS, "#/definitions"));
-    const out = {};
-    let prefixItems = undefined;
-    let items = undefined;
-    for (const k of Object.keys(src)) {
-      const v = src[k];
-      if (k === "required" && Array.isArray(v) && v.length === 0) continue;
-      if (DRAFT_07_COPY_KEYWORDS.has(k)) {
-        out[k] = v;
-        continue;
-      }
-      if (MAP_SUBSCHEMA_KEYWORDS.has(k) || ARRAY_SUBSCHEMA_KEYWORDS.has(k) || DRAFT_07_SINGLE_SUBSCHEMA_KEYWORDS.has(k)) {
-        out[k] = v;
-        continue;
-      }
-      switch (k) {
-        // Tuple handling (2020-12 form)
-        case "prefixItems":
-          prefixItems = v;
-          break;
-        case "items":
-          items = v;
-          break;
-        default:
-          // drop everything else (subset)
-          break;
+    ...convertDocument(document, draft04Adapter, {
+      booleanAdapter: schema => schema ? {} : {
+        not: {}
       }
-    }
-    // 2020-12 tuples -> Draft-07 tuples
-    if (prefixItems !== undefined) {
-      if (Array.isArray(prefixItems)) {
-        out.items = prefixItems;
-        if (items !== undefined) out.additionalItems = items;
-      } else {
-        // Non-standard, but keep a reasonable behavior
-        out.items = prefixItems;
-      }
-    } else if (items !== undefined) {
-      // Regular items schema stays as items
-      out.items = items;
-    }
-    const $ref = out.$ref;
-    if (typeof $ref === "string" && Object.keys(out).length > 1) {
-      delete out.$ref;
-      out.allOf = [{
-        $ref
-      }, ...(Array.isArray(out.allOf) ? out.allOf : [])];
-    }
-    return out;
-  });
+    })
+  };
 }
 /**
  * Converts a `MultiDocument<"draft-2020-12">` to a
@@ -537,7 +410,12 @@ function toSchemaDraft07(schema) {
  *
  * **Gotchas**
  *
- * External refs and local refs outside `#/$defs` are left unchanged.
+ * External refs and local refs outside `#/$defs` are left unchanged. Conversion
+ * throws when a custom keyword would become an active OpenAPI keyword and
+ * therefore change meaning. References inside schema resources identified by
+ * `$id` are left unchanged. Conversion throws when an identified root schema
+ * references the detached shared definitions pool because OpenAPI cannot
+ * preserve that fragment reference.
  *
  * **Example** (Converting to OpenAPI 3.1)
  *
@@ -580,21 +458,34 @@ export function toMultiDocumentOpenApi3_1(multiDocument) {
     usedKeys.add(candidate);
     keyMap.set(key, candidate);
   }
-  function rewrite(schema) {
-    return rewriteRefs(schema, $ref => {
-      if (!$ref.startsWith("#/$defs/")) return $ref;
-      const path = $ref.slice("#/$defs/".length);
-      const separatorIndex = path.indexOf("/");
-      const token = separatorIndex === -1 ? path : path.slice(0, separatorIndex);
-      const rest = separatorIndex === -1 ? "" : path.slice(separatorIndex);
-      const key = keyMap.get(unescapeToken(token)) ?? token;
-      return `#/components/schemas/${key}${rest}`;
+  function rewrite(schema, rejectSharedDefinitionRefs = false) {
+    const isRootResource = createsResource(schema.$id);
+    const localDefinitions = Predicate.isObject(schema.$defs) ? schema.$defs : undefined;
+    return transformSchema(schema, (schema, inEmbeddedResource) => {
+      rejectKeywordCollisions(schema, OPEN_API_31_TARGET_COLLISIONS, "OpenAPI 3.1", "Draft 2020-12");
+      rewriteSchemaRef(schema, (reference, keyword) => {
+        const path = reference.startsWith("#") ? parseUriFragment(reference) : undefined;
+        if (path === undefined || path[0] !== "$defs" || path.length < 2) return reference;
+        const key = path[1];
+        if (isRootResource) {
+          if (rejectSharedDefinitionRefs && !inEmbeddedResource && Object.hasOwn(multiDocument.definitions, key) && (localDefinitions === undefined || !Object.hasOwn(localDefinitions, key))) {
+            unsupported(keyword, "OpenAPI 3.1", "a schema resource cannot reference the shared definitions pool");
+          }
+          return reference;
+        }
+        return inEmbeddedResource ? reference : formatUriFragment(["components", "schemas", keyMap.get(key) ?? key, ...path.slice(2)]);
+      });
     });
   }
+  const schemas = multiDocument.schemas.map(schema => rewrite(schema, true));
+  const definitions = {};
+  for (const key of definitionKeys) {
+    InternalRecord.assignProperty(definitions, keyMap.get(key) ?? key, rewrite(multiDocument.definitions[key]));
+  }
   return {
     dialect: "openapi-3.1",
-    schemas: Arr.map(multiDocument.schemas, rewrite),
-    definitions: Rec.mapEntries(multiDocument.definitions, (definition, key) => [keyMap.get(key) ?? key, rewrite(definition)])
+    schemas,
+    definitions
   };
 }
 /** @internal */
@@ -608,10 +499,16 @@ export const VALID_OPEN_API_COMPONENTS_SCHEMAS_KEY_REGEXP = /^[a-zA-Z0-9.\-_]+$/
 export function sanitizeOpenApiComponentsSchemasKey(s) {
   return s.length === 0 ? "_" : s.replace(/[^a-zA-Z0-9._-]/gu, "_");
 }
+/** @internal */
+export function getReferenceKey($ref) {
+  const path = $ref.startsWith("#") ? parseUriFragment($ref) : undefined;
+  return path !== undefined && path.length === 2 && path[0] === "$defs" ? path[1] : undefined;
+}
 function transformSchema(node, transform) {
-  return walk(node);
-  function walk(node) {
+  return walk(node, false, true);
+  function walk(node, inheritedResource, isRoot = false) {
     if (!Predicate.isObject(node)) return node;
+    const inEmbeddedResource = inheritedResource || !isRoot && createsResource(node.$id);
     const out = {};
     for (const key of Object.keys(node)) {
       const value = node[key];
@@ -621,13 +518,13 @@ function transformSchema(node, transform) {
         case "properties":
         case "patternProperties":
         case "dependentSchemas":
-          transformed = mapObject(value, walk) ?? value;
+          transformed = mapObject(value, value => walk(value, inEmbeddedResource)) ?? value;
           break;
         case "allOf":
         case "anyOf":
         case "oneOf":
         case "prefixItems":
-          transformed = Array.isArray(value) ? value.map(walk) : value;
+          transformed = Array.isArray(value) ? value.map(value => walk(value, inEmbeddedResource)) : value;
           break;
         case "not":
         case "additionalProperties":
@@ -640,201 +537,659 @@ function transformSchema(node, transform) {
         case "then":
         case "else":
         case "contentSchema":
-          transformed = walk(value);
+          transformed = walk(value, inEmbeddedResource);
       }
       InternalRecord.assignProperty(out, key, transformed);
     }
-    return transform(out);
+    transform(out, inEmbeddedResource);
+    return out;
   }
 }
 /** @internal */
 export function rewriteRefs(schema, rewrite) {
-  return transformSchema(schema, schema => rewriteSchemaRef(schema, rewrite));
+  return transformSchema(schema, schema => {
+    rewriteSchemaRef(schema, rewrite);
+  });
 }
 function rewriteSchemaRef(schema, rewrite) {
   if (typeof schema.$ref === "string") {
-    InternalRecord.assignProperty(schema, "$ref", rewrite(schema.$ref));
+    InternalRecord.assignProperty(schema, "$ref", rewrite(schema.$ref, "$ref"));
+  }
+  if (typeof schema.$dynamicRef === "string") {
+    InternalRecord.assignProperty(schema, "$dynamicRef", rewrite(schema.$dynamicRef, "$dynamicRef"));
   }
-  return schema;
 }
 function mapObject(value, f) {
-  return Predicate.isObject(value) ? Rec.map(value, f) : undefined;
+  if (!Predicate.isObject(value)) return undefined;
+  const out = {};
+  for (const key of Object.keys(value)) {
+    InternalRecord.assignProperty(out, key, f(value[key], key));
+  }
+  return out;
 }
-function rewriteSubschemaKeyword(out, key, value, rewrite, singleKeywords) {
-  if (MAP_SUBSCHEMA_KEYWORDS.has(key)) {
-    out[key] = mapObject(value, rewrite) ?? value;
-    return true;
+// Adapters decide which values are schemas. The kernel only handles recursion,
+// resource scopes, and reference relocation between structural source/target paths.
+function runConverter(adapter, options, use) {
+  const locations = new Map();
+  const references = [];
+  let rootUri = ROOT_URI;
+  function convert(root, sourcePath = [], targetPath = []) {
+    if (sourcePath.length === 0 && options?.trackIds) {
+      const id = Predicate.isObject(root) ? getResourceId(root) : undefined;
+      rootUri = resolveResourceUri(id, ROOT_URI) ?? ROOT_URI;
+    }
+    return loop(root, sourcePath, targetPath, {
+      sourceRoot: [],
+      targetRoot: [],
+      uri: rootUri
+    });
   }
-  if (ARRAY_SUBSCHEMA_KEYWORDS.has(key)) {
-    out[key] = Array.isArray(value) ? value.map(rewrite) : value;
-    return true;
+  function finish() {
+    for (const [out, value, sourceResource] of references) {
+      let reference = value;
+      const resolved = resolveUrl(value, sourceResource);
+      if (resolved !== undefined) {
+        const sourcePointer = parseUriFragment(resolved.hash);
+        resolved.hash = "";
+        if (sourcePointer !== undefined) {
+          const targetPath = locations.get(locationKey(resolved.href, sourcePointer));
+          if (targetPath !== undefined) reference = relocateReference(value, targetPath);
+        }
+      }
+      InternalRecord.assignProperty(out, "$ref", reference);
+    }
   }
-  if (!singleKeywords.has(key)) return false;
-  out[key] = rewrite(value);
+  const out = use(convert);
+  finish();
+  return out;
+  function loop(node, sourcePath, targetPath, resourceScope) {
+    if (typeof node === "boolean") {
+      recordLocations(sourcePath, targetPath, resourceScope);
+      return options?.booleanAdapter?.(node) ?? node;
+    }
+    if (!Predicate.isObject(node)) return node;
+    let currentResourceScope = resourceScope;
+    const id = getResourceId(node);
+    if (sourcePath.length > 0 && options?.trackIds && createsResource(id)) {
+      const uri = resolveResourceUri(id, resourceScope.uri);
+      if (uri !== undefined) {
+        currentResourceScope = {
+          parent: resourceScope,
+          sourceRoot: sourcePath,
+          targetRoot: targetPath,
+          uri
+        };
+      }
+    }
+    recordLocations(sourcePath, targetPath, currentResourceScope);
+    const currentResource = currentResourceScope.uri;
+    const context = {
+      isDocumentRoot: sourcePath.length === 0,
+      schema(value, sourceKey, targetKey = sourceKey) {
+        return loop(value, [...sourcePath, sourceKey], [...targetPath, targetKey], currentResourceScope);
+      },
+      schemaAt(value, sourceSuffix, targetSuffix) {
+        return loop(value, [...sourcePath, ...sourceSuffix], [...targetPath, ...targetSuffix], currentResourceScope);
+      },
+      schemaArray(value, sourceKey, targetKey = sourceKey) {
+        return Array.isArray(value) ? value.map((item, index) => loop(item, [...sourcePath, sourceKey, String(index)], [...targetPath, targetKey, String(index)], currentResourceScope)) : value;
+      },
+      schemaMap(value, sourceKey, targetKey = sourceKey) {
+        if (!Predicate.isObject(value)) return value;
+        return mapObject(value, (item, key) => loop(item, [...sourcePath, sourceKey, key], [...targetPath, targetKey, key], currentResourceScope));
+      },
+      reference(out, value) {
+        if (typeof value === "string") {
+          references.push([out, value, currentResource]);
+        } else {
+          InternalRecord.assignProperty(out, "$ref", value);
+        }
+      }
+    };
+    return adapter(node, context);
+  }
+  function getResourceId(schema) {
+    return options?.ignoreRefSiblings === true && typeof schema.$ref === "string" ? undefined : schema.$id;
+  }
+  function recordLocations(sourcePath, targetPath, scope) {
+    // A JSON Pointer can address an embedded schema from any containing resource.
+    if (scope.parent !== undefined) recordLocations(sourcePath, targetPath, scope.parent);
+    locations.set(locationKey(scope.uri, sourcePath.slice(scope.sourceRoot.length)), targetPath.slice(scope.targetRoot.length));
+  }
+}
+const ROOT_URI = "https://effect.invalid/.json-schema/";
+function resolveUrl(value, base) {
+  return URL.canParse(value, base) ? new URL(value, base) : undefined;
+}
+function resolveResourceUri(value, base) {
+  if (typeof value !== "string") return undefined;
+  const url = resolveUrl(value, base);
+  if (url === undefined) return undefined;
+  url.hash = "";
+  return url.href;
+}
+function relocateReference(reference, targetPath) {
+  const index = reference.indexOf("#");
+  if (index === -1 && targetPath.length === 0) return reference;
+  const uri = index === -1 ? reference : reference.slice(0, index);
+  return `${uri}${formatUriFragment(targetPath)}`;
+}
+function locationKey(resource, pointer) {
+  return `${resource}\u0000${JSON.stringify(pointer)}`;
+}
+function createsResource(id) {
+  return typeof id === "string" && id.length > 0 && id[0] !== "#";
+}
+function convertSchema(root, adapter, options) {
+  return runConverter(adapter, options, convert => convert(root));
+}
+function convertDocument(document, adapter, options) {
+  return runConverter(adapter, {
+    ...options,
+    trackIds: true
+  }, convert => ({
+    schema: convert(document.schema),
+    definitions: mapObject(document.definitions, (definition, key) => convert(definition, ["$defs", key], ["definitions", key]))
+  }));
+}
+const SCHEMA_MAP_KEYWORDS = /*#__PURE__*/new Set(["properties", "patternProperties"]);
+const SCHEMA_ARRAY_KEYWORDS = /*#__PURE__*/new Set(["allOf", "anyOf", "oneOf"]);
+const JSON_SCHEMA_SINGLE_KEYWORDS = /*#__PURE__*/new Set(["not", "additionalProperties", "propertyNames", "contains", "if", "then", "else", "contentSchema"]);
+const OPEN_API_30_SCHEMA_MAP_KEYWORDS = /*#__PURE__*/new Set(["properties"]);
+const OPEN_API_30_SCHEMA_SINGLE_KEYWORDS = /*#__PURE__*/new Set(["not", "items", "additionalProperties"]);
+const DRAFT_04_SCHEMA_SINGLE_KEYWORDS = /*#__PURE__*/new Set(["not", "additionalProperties", "contentSchema"]);
+function convertSubschemaKeyword(out, key, value, context, singleKeywords, mapKeywords = SCHEMA_MAP_KEYWORDS) {
+  let converted;
+  if (mapKeywords.has(key)) converted = context.schemaMap(value, key);else if (SCHEMA_ARRAY_KEYWORDS.has(key)) converted = context.schemaArray(value, key);else if (singleKeywords.has(key)) converted = context.schema(value, key);else return false;
+  InternalRecord.assignProperty(out, key, converted);
   return true;
 }
-function normalizeOpenApi3_0ToDraft07(node) {
-  if (Array.isArray(node)) return node.map(normalizeOpenApi3_0ToDraft07);
-  if (!Predicate.isObject(node)) return node;
-  const src = node;
-  let out = {};
-  for (const k of Object.keys(src)) {
-    const v = src[k];
-    if (k === "$ref" && typeof v === "string") {
-      InternalRecord.assignProperty(out, k, v.replace(RE_COMPONENTS_SCHEMAS, "#/definitions"));
-    } else if (k === "example") {
-      if (src.examples === undefined) {
-        out.examples = [v];
+const PRE_2020_TO_2020_COLLISIONS = ["$anchor", "$defs", "$dynamicAnchor", "$dynamicRef", "$vocabulary", "contentSchema", "dependentRequired", "dependentSchemas", "maxContains", "minContains", "prefixItems", "unevaluatedItems", "unevaluatedProperties"];
+const DRAFT_07_TO_2020_COLLISIONS = [...PRE_2020_TO_2020_COLLISIONS, "deprecated"];
+const OPEN_API_30_TO_2020_COLLISIONS = [...PRE_2020_TO_2020_COLLISIONS, "$comment", "$id", "$schema", "const", "contains", "contentEncoding", "contentMediaType", "else", "examples", "if", "patternProperties", "propertyNames", "then"];
+const ANCHOR_REGEXP = /^[A-Za-z_][-A-Za-z0-9._]*$/;
+const LEGACY_ID_FRAGMENT_REGEXP = /^[A-Za-z][-A-Za-z0-9._:]*$/;
+function convertDraft07(root) {
+  return convertSchema(root, (source, context) => {
+    const out = {};
+    if (typeof source.$ref === "string") {
+      context.reference(out, source.$ref);
+      if (Object.hasOwn(source, "definitions")) {
+        InternalRecord.assignProperty(out, "$defs", context.schemaMap(source.definitions, "definitions", "$defs"));
       }
-    } else if (Array.isArray(v) || Predicate.isObject(v)) {
-      InternalRecord.assignProperty(out, k, normalizeOpenApi3_0ToDraft07(v));
-    } else {
-      InternalRecord.assignProperty(out, k, v);
+      return out;
+    }
+    rejectKeywordCollisions(source, DRAFT_07_TO_2020_COLLISIONS, "Draft 2020-12", "Draft-07");
+    let items = undefined;
+    let additionalItems = undefined;
+    for (const key of Object.keys(source)) {
+      const value = source[key];
+      if (convertSubschemaKeyword(out, key, value, context, JSON_SCHEMA_SINGLE_KEYWORDS)) continue;
+      switch (key) {
+        case "$schema":
+          InternalRecord.assignProperty(out, key, isMetaSchemaUri(value, META_SCHEMA_URI_DRAFT_07) ? META_SCHEMA_URI_DRAFT_2020_12 : value);
+          break;
+        case "$id":
+          convertDraft07Id(out, value);
+          break;
+        case "definitions":
+          InternalRecord.assignProperty(out, "$defs", context.schemaMap(value, key, "$defs"));
+          break;
+        case "dependencies":
+          {
+            if (!Predicate.isObject(value)) {
+              InternalRecord.assignProperty(out, key, value);
+              break;
+            }
+            const dependentRequired = {};
+            const dependentSchemas = {};
+            for (const dependency of Object.keys(value)) {
+              const dependencyValue = value[dependency];
+              InternalRecord.assignProperty(Array.isArray(dependencyValue) ? dependentRequired : dependentSchemas, dependency, Array.isArray(dependencyValue) ? dependencyValue : context.schemaAt(dependencyValue, ["dependencies", dependency], ["dependentSchemas", dependency]));
+            }
+            if (Object.keys(dependentRequired).length > 0) {
+              InternalRecord.assignProperty(out, "dependentRequired", dependentRequired);
+            }
+            if (Object.keys(dependentSchemas).length > 0) {
+              InternalRecord.assignProperty(out, "dependentSchemas", dependentSchemas);
+            }
+            break;
+          }
+        case "items":
+          items = value;
+          break;
+        case "additionalItems":
+          additionalItems = value;
+          break;
+        default:
+          InternalRecord.assignProperty(out, key, value);
+      }
+    }
+    if (items !== undefined) {
+      if (Array.isArray(items)) {
+        InternalRecord.assignProperty(out, "prefixItems", context.schemaArray(items, "items", "prefixItems"));
+        if (additionalItems !== undefined) {
+          InternalRecord.assignProperty(out, "items", context.schema(additionalItems, "additionalItems", "items"));
+        }
+      } else {
+        InternalRecord.assignProperty(out, "items", context.schema(items, "items"));
+      }
+    }
+    return out;
+  }, {
+    trackIds: true,
+    ignoreRefSiblings: true
+  });
+}
+function convertDraft07Id(out, value) {
+  if (typeof value !== "string" || !value.includes("#")) {
+    InternalRecord.assignProperty(out, "$id", value);
+    return;
+  }
+  const fragmentIndex = value.indexOf("#");
+  const id = value.slice(0, fragmentIndex);
+  const anchor = value.slice(fragmentIndex + 1);
+  if (anchor.length === 0) {
+    if (id.length > 0) InternalRecord.assignProperty(out, "$id", id);
+    return;
+  }
+  if (!ANCHOR_REGEXP.test(anchor)) {
+    unsupported("$id", "Draft 2020-12", `fragment "#${anchor}" is not a valid $anchor`);
+  }
+  if (id.length > 0) InternalRecord.assignProperty(out, "$id", id);
+  InternalRecord.assignProperty(out, "$anchor", anchor);
+}
+function unsupported(keyword, dialect, details) {
+  throw new Error(`Cannot convert JSON Schema keyword "${keyword}" to ${dialect}: ${details}`);
+}
+function rejectKeywordCollisions(source, keywords, targetDialect, sourceDialect) {
+  for (const keyword of keywords) {
+    if (Object.hasOwn(source, keyword)) {
+      unsupported(keyword, targetDialect, `it is not active in ${sourceDialect} but would become active in the target`);
     }
   }
-  // Draft-04-style numeric exclusivity booleans
-  out = adjustExclusivity(out);
-  // OpenAPI 3.0 nullable
-  if (out.nullable === true) {
-    out = applyNullable(out);
+}
+const DRAFT_07_TARGET_COLLISIONS = ["additionalItems", "definitions", "dependencies"];
+function convertMetaSchemaKeyword(out, value, context, targetUri, targetDialect) {
+  if (context.isDocumentRoot) {
+    InternalRecord.assignProperty(out, "$schema", isMetaSchemaUri(value, META_SCHEMA_URI_DRAFT_2020_12) ? targetUri : value);
+  } else if (!isMetaSchemaUri(value, META_SCHEMA_URI_DRAFT_2020_12)) {
+    unsupported("$schema", targetDialect, "an embedded resource cannot declare a different dialect");
   }
-  delete out.nullable;
+}
+function draft07Adapter(source, context) {
+  rejectKeywordCollisions(source, DRAFT_07_TARGET_COLLISIONS, "Draft-07", "Draft 2020-12");
+  const out = {};
+  let reference = undefined;
+  let prefixItems = undefined;
+  let items = undefined;
+  for (const key of Object.keys(source)) {
+    const value = source[key];
+    if (convertSubschemaKeyword(out, key, value, context, JSON_SCHEMA_SINGLE_KEYWORDS)) continue;
+    switch (key) {
+      case "$ref":
+        reference = value;
+        break;
+      case "$schema":
+        convertMetaSchemaKeyword(out, value, context, META_SCHEMA_URI_DRAFT_07, "Draft-07");
+        break;
+      case "$id":
+      case "$anchor":
+        break;
+      case "$defs":
+        InternalRecord.assignProperty(out, "definitions", context.schemaMap(value, key, "definitions"));
+        break;
+      case "prefixItems":
+        prefixItems = value;
+        break;
+      case "items":
+        items = value;
+        break;
+      case "dependentRequired":
+      case "dependentSchemas":
+      case "minContains":
+      case "maxContains":
+        break;
+      case "$dynamicRef":
+      case "$dynamicAnchor":
+      case "$vocabulary":
+      case "unevaluatedProperties":
+      case "unevaluatedItems":
+        unsupported(key, "Draft-07", "the target dialect has no equivalent");
+      case "required":
+        if (Array.isArray(value) && value.length === 0) break;
+        InternalRecord.assignProperty(out, key, value);
+        break;
+      default:
+        InternalRecord.assignProperty(out, key, value);
+    }
+  }
+  convertTuple(out, prefixItems, items, context);
+  if (Object.hasOwn(source, "contains")) {
+    const minContains = source.minContains;
+    const maxContains = source.maxContains;
+    if (minContains !== undefined && minContains !== 1 || maxContains !== undefined) {
+      unsupported("minContains/maxContains", "Draft-07", "contains cardinality cannot be represented");
+    }
+    if (Object.hasOwn(source, "minContains")) InternalRecord.assignProperty(out, "minContains", minContains);
+  } else {
+    if (Object.hasOwn(source, "minContains")) InternalRecord.assignProperty(out, "minContains", source.minContains);
+    if (Object.hasOwn(source, "maxContains")) InternalRecord.assignProperty(out, "maxContains", source.maxContains);
+  }
+  convertDependencies(source, out, context, "draft-07");
+  convertLegacyId(source, out, "$id", "Draft-07");
+  convertReference(out, reference, context);
   return out;
 }
-function adjustExclusivity(node) {
-  return adjustExclusiveBound(adjustExclusiveBound(node, "minimum", "exclusiveMinimum"), "maximum", "exclusiveMaximum");
+function convertTuple(out, prefixItems, items, context) {
+  if (prefixItems === undefined) {
+    if (items !== undefined) InternalRecord.assignProperty(out, "items", context.schema(items, "items"));
+    return;
+  }
+  InternalRecord.assignProperty(out, "items", context.schemaArray(prefixItems, "prefixItems", "items"));
+  if (items !== undefined) {
+    InternalRecord.assignProperty(out, "additionalItems", context.schema(items, "items", "additionalItems"));
+  }
 }
-function adjustExclusiveBound(node, boundKey, exclusiveKey) {
-  const exclusive = node[exclusiveKey];
-  if (typeof exclusive !== "boolean") return node;
-  const out = {
-    ...node
-  };
-  if (exclusive && typeof node[boundKey] === "number") {
-    out[exclusiveKey] = node[boundKey];
-    delete out[boundKey];
+function convertReference(out, reference, context) {
+  if (reference === undefined) return;
+  if (typeof reference === "string" && Object.keys(out).length > 0) {
+    const referenceSchema = {};
+    context.reference(referenceSchema, reference);
+    appendAllOf(out, referenceSchema);
   } else {
-    delete out[exclusiveKey];
+    context.reference(out, reference);
+  }
+}
+function convertDependencies(source, out, context, targetDialect) {
+  const dependentRequired = Predicate.isObject(source.dependentRequired) ? source.dependentRequired : undefined;
+  const dependentSchemas = Predicate.isObject(source.dependentSchemas) ? source.dependentSchemas : undefined;
+  if (dependentRequired === undefined && dependentSchemas === undefined) return;
+  const dependencies = {};
+  const keys = new Set([...Object.keys(dependentRequired ?? {}), ...Object.keys(dependentSchemas ?? {})]);
+  for (const key of keys) {
+    const required = dependentRequired?.[key];
+    const dependency = dependentSchemas?.[key];
+    const omitRequired = targetDialect === "draft-04" && Array.isArray(required) && required.length === 0;
+    if (dependency === undefined) {
+      if (!omitRequired) InternalRecord.assignProperty(dependencies, key, required);
+    } else if (required === undefined || omitRequired) {
+      InternalRecord.assignProperty(dependencies, key, context.schemaAt(dependency, ["dependentSchemas", key], ["dependencies", key]));
+    } else {
+      InternalRecord.assignProperty(dependencies, key, {
+        allOf: [context.schemaAt(dependency, ["dependentSchemas", key], ["dependencies", key, "allOf", "0"]), {
+          required
+        }]
+      });
+    }
+  }
+  if (Object.keys(dependencies).length > 0) InternalRecord.assignProperty(out, "dependencies", dependencies);
+}
+function convertOpenApi30(root) {
+  return convertSchema(root, (source, context) => {
+    const out = {};
+    if (typeof source.$ref === "string") {
+      context.reference(out, rewriteOpenApiComponentsReference(source.$ref));
+      return out;
+    }
+    rejectKeywordCollisions(source, OPEN_API_30_TO_2020_COLLISIONS, "Draft 2020-12", "OpenAPI 3.0");
+    for (const key of Object.keys(source)) {
+      const value = source[key];
+      if (convertSubschemaKeyword(out, key, value, context, OPEN_API_30_SCHEMA_SINGLE_KEYWORDS, OPEN_API_30_SCHEMA_MAP_KEYWORDS)) {
+        continue;
+      }
+      switch (key) {
+        case "example":
+          InternalRecord.assignProperty(out, "examples", [value]);
+          break;
+        case "nullable":
+        case "exclusiveMinimum":
+        case "exclusiveMaximum":
+          break;
+        default:
+          InternalRecord.assignProperty(out, key, value);
+      }
+    }
+    convertOpenApiExclusiveBound(source, out, "minimum");
+    convertOpenApiExclusiveBound(source, out, "maximum");
+    if (source.nullable === true && typeof source.type === "string") {
+      InternalRecord.assignProperty(out, "type", [source.type, "null"]);
+    }
+    return out;
+  });
+}
+function convertOpenApiExclusiveBound(source, out, boundKey) {
+  const exclusiveKey = boundKey === "minimum" ? "exclusiveMinimum" : "exclusiveMaximum";
+  const exclusive = source[exclusiveKey];
+  if (typeof exclusive !== "boolean") {
+    if (exclusive !== undefined) InternalRecord.assignProperty(out, exclusiveKey, exclusive);
+    return;
+  }
+  if (exclusive && typeof source[boundKey] === "number") {
+    InternalRecord.assignProperty(out, exclusiveKey, source[boundKey]);
+    delete out[boundKey];
   }
+}
+const DRAFT_04_TARGET_COLLISIONS = ["additionalItems", "definitions", "dependencies", "id"];
+function draft04Adapter(source, context) {
+  rejectKeywordCollisions(source, DRAFT_04_TARGET_COLLISIONS, "Draft-04", "Draft 2020-12");
+  const out = {};
+  let reference = undefined;
+  let prefixItems = undefined;
+  let items = undefined;
+  let constSchema;
+  for (const key of Object.keys(source)) {
+    const value = source[key];
+    if (convertSubschemaKeyword(out, key, value, context, DRAFT_04_SCHEMA_SINGLE_KEYWORDS)) continue;
+    switch (key) {
+      case "$ref":
+        reference = value;
+        break;
+      case "$schema":
+        convertMetaSchemaKeyword(out, value, context, META_SCHEMA_URI_DRAFT_04, "Draft-04");
+        break;
+      case "$id":
+      case "$anchor":
+        break;
+      case "$defs":
+        InternalRecord.assignProperty(out, "definitions", context.schemaMap(value, key, "definitions"));
+        break;
+      case "prefixItems":
+        prefixItems = value;
+        break;
+      case "items":
+        items = value;
+        break;
+      case "$dynamicRef":
+      case "$dynamicAnchor":
+      case "$vocabulary":
+      case "unevaluatedProperties":
+      case "unevaluatedItems":
+      case "propertyNames":
+        unsupported(key, "Draft-04", "the target dialect has no equivalent");
+      case "dependentRequired":
+      case "dependentSchemas":
+      case "contains":
+      case "minContains":
+      case "maxContains":
+      case "if":
+      case "then":
+      case "else":
+      case "minimum":
+      case "maximum":
+      case "exclusiveMinimum":
+      case "exclusiveMaximum":
+        break;
+      case "const":
+        constSchema = {
+          enum: [value]
+        };
+        break;
+      case "required":
+        if (Array.isArray(value) && value.length === 0) break;
+        InternalRecord.assignProperty(out, key, value);
+        break;
+      default:
+        InternalRecord.assignProperty(out, key, value);
+    }
+  }
+  convertTuple(out, prefixItems, items, context);
+  convertDraft04ExclusiveBound(source, out, "minimum");
+  convertDraft04ExclusiveBound(source, out, "maximum");
+  convertDependencies(source, out, context, "draft-04");
+  convertLegacyId(source, out, "id", "Draft-04");
+  convertDraft04Conditionals(source, out, context);
+  convertDraft04Contains(source, out, context);
+  if (constSchema !== undefined) {
+    if (Object.hasOwn(source, "enum")) {
+      appendAllOf(out, constSchema);
+    } else {
+      InternalRecord.assignProperty(out, "enum", constSchema.enum);
+    }
+  }
+  convertReference(out, reference, context);
   return out;
 }
-function applyNullable(node) {
-  // enum widening
-  if (Array.isArray(node.enum)) {
-    return widenType({
-      ...node,
-      enum: node.enum.includes(null) ? node.enum : [...node.enum, null]
-    });
+function convertDraft04Conditionals(source, out, context) {
+  const hasIf = Object.hasOwn(source, "if");
+  const hasThen = Object.hasOwn(source, "then");
+  const hasElse = Object.hasOwn(source, "else");
+  if (!hasIf || !hasThen && !hasElse) {
+    if (hasIf) InternalRecord.assignProperty(out, "if", context.schema(source.if, "if"));
+    if (hasThen) InternalRecord.assignProperty(out, "then", context.schema(source.then, "then"));
+    if (hasElse) InternalRecord.assignProperty(out, "else", context.schema(source.else, "else"));
+    return;
   }
-  // type widening
-  if (node.type !== undefined) return widenType(node);
-  // const === null
-  if (node.const === null) return node;
-  // fallback
-  return {
-    anyOf: [node, {
-      type: "null"
+  const index = Array.isArray(out.allOf) ? out.allOf.length : 0;
+  const base = ["allOf", String(index), "anyOf"];
+  const convertBranch = (key, targetPath) => context.schemaAt(source[key], [key], [...base, ...targetPath]);
+  let conditional;
+  if (hasThen && hasElse) {
+    if (hasSchemaIdentifier(source.if)) {
+      unsupported("if", "Draft-04", "lowering both branches would duplicate a schema identifier");
+    }
+    // (if AND then) OR ((NOT if) AND else)
+    conditional = {
+      anyOf: [{
+        allOf: [convertBranch("if", ["0", "allOf", "0"]), convertBranch("then", ["0", "allOf", "1"])]
+      }, {
+        allOf: [{
+          not: convertBranch("if", ["1", "allOf", "0", "not"])
+        }, convertBranch("else", ["1", "allOf", "1"])]
+      }]
+    };
+  } else if (hasThen) {
+    // (NOT if) OR then
+    conditional = {
+      anyOf: [{
+        not: convertBranch("if", ["0", "not"])
+      }, convertBranch("then", ["1"])]
+    };
+  } else {
+    // if OR else
+    conditional = {
+      anyOf: [convertBranch("if", ["0"]), convertBranch("else", ["1"])]
+    };
+  }
+  appendAllOf(out, conditional);
+}
+function hasSchemaIdentifier(node) {
+  if (!Predicate.isObject(node)) return false;
+  if (Object.hasOwn(node, "$id") || Object.hasOwn(node, "$anchor")) return true;
+  for (const key of Object.keys(node)) {
+    const value = node[key];
+    switch (key) {
+      case "$defs":
+      case "properties":
+      case "patternProperties":
+      case "dependentSchemas":
+        if (Predicate.isObject(value) && Object.values(value).some(hasSchemaIdentifier)) return true;
+        break;
+      case "allOf":
+      case "anyOf":
+      case "oneOf":
+      case "prefixItems":
+        if (Array.isArray(value) && value.some(hasSchemaIdentifier)) return true;
+        break;
+      case "not":
+      case "additionalProperties":
+      case "propertyNames":
+      case "unevaluatedProperties":
+      case "items":
+      case "contains":
+      case "unevaluatedItems":
+      case "if":
+      case "then":
+      case "else":
+      case "contentSchema":
+        if (hasSchemaIdentifier(value)) return true;
+    }
+  }
+  return false;
+}
+function convertDraft04Contains(source, out, context) {
+  if (!Object.hasOwn(source, "contains")) {
+    if (Object.hasOwn(source, "minContains")) InternalRecord.assignProperty(out, "minContains", source.minContains);
+    if (Object.hasOwn(source, "maxContains")) InternalRecord.assignProperty(out, "maxContains", source.maxContains);
+    return;
+  }
+  const minContains = source.minContains;
+  const maxContains = source.maxContains;
+  if (minContains !== undefined && minContains !== 1 || maxContains !== undefined) {
+    unsupported("minContains/maxContains", "Draft-04", "contains cardinality cannot be represented");
+  }
+  const index = Array.isArray(out.allOf) ? out.allOf.length : 0;
+  const contains = context.schemaAt(source.contains, ["contains"], ["allOf", String(index), "anyOf", "1", "not", "items", "not"]);
+  appendAllOf(out, {
+    anyOf: [{
+      not: {
+        type: "array"
+      }
+    }, {
+      not: {
+        items: {
+          not: contains
+        }
+      }
     }]
-  };
+  });
 }
-function widenType(node) {
-  const t = node.type;
-  if (typeof t === "string") return t === "null" ? node : {
-    ...node,
-    type: [t, "null"]
-  };
-  if (Array.isArray(t)) return t.includes("null") ? node : {
-    ...node,
-    type: [...t, "null"]
-  };
-  return node;
+function appendAllOf(out, schema) {
+  if (Array.isArray(out.allOf)) out.allOf.push(schema);else InternalRecord.assignProperty(out, "allOf", [schema]);
 }
-/**
- * Resolves a `$ref` string by looking up the last path segment in a
- * definitions map.
- *
- * **When to use**
- *
- * Use when you need to dereference a `$ref` pointer to get the JSON Schema
- * object it points to.
- *
- * **Details**
- *
- * This only resolves the final segment of the ref path, such as `"User"` from
- * `"#/$defs/User"`. It returns `undefined` if the definition is not found.
- *
- * **Gotchas**
- *
- * This function does not follow arbitrary JSON Pointer paths.
- *
- * **Example** (Resolving a $ref)
- *
- * ```ts import.meta.vitest
- * import { JsonSchema } from "effect"
- *
- * const definitions: JsonSchema.Definitions = {
- *   User: { type: "object", properties: { name: { type: "string" } } }
- * }
- *
- * JsonSchema.resolve$ref("#/$defs/User", definitions) // => { type: "object", properties: { name: { type: "string" } } }
- * JsonSchema.resolve$ref("#/$defs/Unknown", definitions) // => undefined
- * ```
- *
- * @see {@link resolveTopLevel$ref}
- * @see {@link Definitions}
- * @category getters
- * @since 4.0.0
- */
-export function resolve$ref($ref, definitions) {
-  const tokens = $ref.split("/");
-  const identifier = unescapeToken(tokens[tokens.length - 1]);
-  if (Object.hasOwn(definitions, identifier)) return definitions[identifier];
+function convertLegacyId(source, out, targetKey, dialect) {
+  const id = source.$id;
+  const anchor = source.$anchor;
+  if (anchor === undefined) {
+    if (id !== undefined) InternalRecord.assignProperty(out, targetKey, id);
+    return;
+  }
+  if (typeof anchor !== "string" || !ANCHOR_REGEXP.test(anchor)) {
+    unsupported("$anchor", dialect, "the anchor is not valid");
+  }
+  if (!LEGACY_ID_FRAGMENT_REGEXP.test(anchor)) {
+    unsupported("$anchor", dialect, "the anchor cannot be represented as a plain-name fragment identifier");
+  }
+  if (id === undefined) {
+    InternalRecord.assignProperty(out, targetKey, `#${anchor}`);
+  } else {
+    unsupported("$anchor", dialect, "it cannot be combined with the schema $id");
+  }
 }
-/**
- * Resolves a document whose root schema is a top-level `$ref`.
- *
- * **When to use**
- *
- * Use when you need to dereference a top-level `$ref` before inspecting the
- * root JSON Schema object's properties directly.
- *
- * **Details**
- *
- * This returns the same object if no change is needed, or a shallow copy with
- * the resolved schema.
- *
- * **Example** (Resolving a top-level $ref)
- *
- * ```ts import.meta.vitest
- * import { JsonSchema } from "effect"
- *
- * const doc: JsonSchema.Document<"draft-2020-12"> = {
- *   dialect: "draft-2020-12",
- *   schema: { $ref: "#/$defs/User" },
- *   definitions: {
- *     User: { type: "object", properties: { name: { type: "string" } } }
- *   }
- * }
- *
- * const resolved = JsonSchema.resolveTopLevel$ref(doc)
- * resolved.schema // => { type: "object", properties: { name: { type: "string" } } }
- * ```
- *
- * @see {@link resolve$ref}
- * @see {@link Document}
- * @category transforming
- * @since 4.0.0
- */
-export function resolveTopLevel$ref(document) {
-  if (typeof document.schema.$ref === "string") {
-    const schema = resolve$ref(document.schema.$ref, document.definitions);
-    if (schema !== undefined) {
-      return {
-        ...document,
-        schema
-      };
+function convertDraft04ExclusiveBound(source, out, boundKey) {
+  const exclusiveKey = boundKey === "minimum" ? "exclusiveMinimum" : "exclusiveMaximum";
+  const bound = source[boundKey];
+  const exclusive = source[exclusiveKey];
+  if (typeof exclusive === "number") {
+    const isBoundStricter = typeof bound === "number" && (boundKey === "minimum" ? bound > exclusive : bound < exclusive);
+    if (isBoundStricter) {
+      InternalRecord.assignProperty(out, boundKey, bound);
+    } else {
+      InternalRecord.assignProperty(out, boundKey, exclusive);
+      InternalRecord.assignProperty(out, exclusiveKey, true);
     }
+  } else if (bound !== undefined) {
+    InternalRecord.assignProperty(out, boundKey, bound);
   }
-  return document;
 }
 //# sourceMappingURL=JsonSchema.js.map