@smthrs/plan 0.0.0-stage → 1.0.0-rc.13

package/dist/cjs/internal/SchemaIdentity.js

@@ -0,0 +1,718 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SchemaIdentity_exports = {};
+__export(SchemaIdentity_exports, {
+  SchemaIdentityError: () => SchemaIdentityError,
+  builtinCheckIds: () => builtinCheckIds,
+  fromRepresentation: () => fromRepresentation,
+  representationIdentity: () => representationIdentity,
+  schemaIdentity: () => schemaIdentity
+});
+module.exports = __toCommonJS(SchemaIdentity_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+var SchemaRepresentation = __toESM(require("effect/SchemaRepresentation"), 1);
+class SchemaIdentityError extends Schema.TaggedError()("@smthrs/plan/SchemaIdentityError", {
+  message: Schema.String
+}) {
+}
+const invalid = (message, path) => new SchemaIdentityError({
+  message: path.length === 0 ? message : `${message}
+  at ${path.map((key) => `[${typeof key === "string" ? JSON.stringify(key) : key}]`).join("")}`
+});
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const assignProperty = (target, key, value) => {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+  } else {
+    target[key] = value;
+  }
+};
+const isJson = (value, path = /* @__PURE__ */ new Set()) => {
+  if (typeof value !== "object" || value === null) {
+    return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+  }
+  if (path.has(value)) return false;
+  const members = Array.isArray(value) ? Array.from(value) : plainValues(value);
+  if (members === void 0) return false;
+  const inner = new Set(path).add(value);
+  return members.every((member) => isJson(member, inner));
+};
+const plainValues = (value) => {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null ? Object.values(value) : void 0;
+};
+const sameJson = (left, right) => {
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((member, index) => sameJson(member, right[index]));
+  }
+  if (isObject(left) && isObject(right)) {
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && sameJson(left[key], right[key]));
+  }
+  return left === right || left !== left && right !== right;
+};
+const escapeRegExp = (text) => text.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
+const unescapeToken = (token) => token.replace(/~1/g, "/").replace(/~0/g, "~");
+const definitionReference = (key) => `#/$defs/${encodeURI(key.replace(/~/g, "~0").replace(/\//g, "~1")).replace(/#/g, "%23")}`;
+const decodeUriFragment = (fragment) => {
+  if (fragment.length === 0 || fragment === "#") return "";
+  if (!fragment.startsWith("#")) return void 0;
+  const encoded = fragment.slice(1);
+  try {
+    if (encodeURI(encoded).replace(/%25/g, "%").replace(/#/g, "%23") !== encoded) return void 0;
+    const pointer = decodeURIComponent(encoded);
+    return pointer.startsWith("/") && !/~(?:[^01]|$)/.test(pointer) ? pointer : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const rewriteRefs = (node, rewrite) => {
+  const walk = (value) => isObject(value) ? rewriteRefs(value, rewrite) : value;
+  const out = {};
+  for (const key of Object.keys(node)) {
+    const value = node[key];
+    let transformed = value;
+    switch (key) {
+      case "$defs":
+      case "properties":
+      case "patternProperties":
+      case "dependentSchemas":
+        if (isObject(value)) {
+          const mapped = {};
+          for (const name of Object.keys(value)) assignProperty(mapped, name, walk(value[name]));
+          transformed = mapped;
+        }
+        break;
+      case "allOf":
+      case "anyOf":
+      case "oneOf":
+      case "prefixItems":
+        if (Array.isArray(value)) transformed = value.map(walk);
+        break;
+      case "not":
+      case "additionalProperties":
+      case "propertyNames":
+      case "unevaluatedProperties":
+      case "items":
+      case "contains":
+      case "unevaluatedItems":
+      case "if":
+      case "then":
+      case "else":
+      case "contentSchema":
+        transformed = walk(value);
+    }
+    assignProperty(out, key, transformed);
+  }
+  if (typeof out["$ref"] === "string") out["$ref"] = rewrite(out["$ref"]);
+  if (typeof out["$dynamicRef"] === "string") out["$dynamicRef"] = rewrite(out["$dynamicRef"]);
+  return out;
+};
+const ordinaryAnnotations = (annotations) => {
+  if (annotations === void 0) return void 0;
+  const out = {};
+  if (typeof annotations["title"] === "string") out["title"] = annotations["title"];
+  if (typeof annotations["description"] === "string") out["description"] = annotations["description"];
+  if (isJson(annotations["default"])) out["default"] = annotations["default"];
+  if (Array.isArray(annotations["examples"]) && isJson(annotations["examples"])) {
+    out["examples"] = annotations["examples"];
+  }
+  if (typeof annotations["readOnly"] === "boolean") out["readOnly"] = annotations["readOnly"];
+  if (typeof annotations["writeOnly"] === "boolean") out["writeOnly"] = annotations["writeOnly"];
+  if (typeof annotations["format"] === "string") out["format"] = annotations["format"];
+  if (typeof annotations["contentEncoding"] === "string") out["contentEncoding"] = annotations["contentEncoding"];
+  if (typeof annotations["contentMediaType"] === "string") out["contentMediaType"] = annotations["contentMediaType"];
+  if (isJson(annotations["contentSchema"])) out["contentSchema"] = annotations["contentSchema"];
+  return Object.keys(out).length === 0 ? void 0 : out;
+};
+const finitePattern = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?";
+const stringPattern = "[\\s\\S]*?";
+const bigIntPattern = "^-?\\d+$";
+const symbolPattern = "^Symbol\\(([\\s\\S]*)\\)$";
+const uuidPattern = (version) => version === null ? "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$" : `^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`;
+const field = (id, payload, name, is) => {
+  const value = isObject(payload) ? payload[name] : void 0;
+  if (!is(value)) {
+    throw new SchemaIdentityError({
+      message: `Cannot derive a schema identity: check ${id} carries no usable "${name}" in its payload. The installed effect release describes this check differently from the releases @smthrs/plan supports.`
+    });
+  }
+  return value;
+};
+const isNumber = (value) => typeof value === "number";
+const isString = (value) => typeof value === "string";
+const isVersion = (value) => value === null || typeof value === "number";
+const isFlag = (value) => value === void 0 || typeof value === "boolean";
+const pattern = (source) => () => ({ pattern: source });
+const literalPattern = (name, source) => (id, payload) => ({
+  pattern: new RegExp(source(escapeRegExp(field(id, payload, name, isString)))).source
+});
+const bound = (keyword, name = keyword) => (id, payload) => ({
+  [keyword]: field(id, payload, name, isNumber)
+});
+const length = (name, array, string) => (id, payload, input) => ({
+  [input.type === "array" ? array : string]: field(id, payload, name, isNumber)
+});
+const empty = () => ({});
+const builtinChecks = /* @__PURE__ */ new Map([
+  ["effect/schema/isTrimmed", pattern("^\\S[\\s\\S]*\\S$|^\\S$|^$")],
+  ["effect/schema/isPattern", (id, payload) => ({ pattern: field(id, payload, "source", isString) })],
+  ["effect/schema/isStringFinite", pattern(`^${finitePattern}$`)],
+  ["effect/schema/isStringBigInt", pattern(bigIntPattern)],
+  ["effect/schema/isStringSymbol", pattern(symbolPattern)],
+  ["effect/schema/isUUID", (id, payload) => ({
+    pattern: uuidPattern(field(id, payload, "version", isVersion)),
+    format: "uuid"
+  })],
+  ["effect/schema/isGUID", pattern("^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$")],
+  ["effect/schema/isULID", pattern("^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$")],
+  ["effect/schema/isBase64", pattern("^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$")],
+  ["effect/schema/isBase64Url", pattern("^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$")],
+  ["effect/schema/isStartingWith", literalPattern("startsWith", (escaped) => `^${escaped}`)],
+  ["effect/schema/isEndingWith", literalPattern("endsWith", (escaped) => `${escaped}$`)],
+  ["effect/schema/isIncluding", literalPattern("includes", (escaped) => escaped)],
+  ["effect/schema/isUppercased", pattern("^[^a-z]*$")],
+  ["effect/schema/isLowercased", pattern("^[^A-Z]*$")],
+  ["effect/schema/isCapitalized", pattern("^(?:[^a-z][\\s\\S]*)?$")],
+  ["effect/schema/isUncapitalized", pattern("^(?:[^A-Z][\\s\\S]*)?$")],
+  ["effect/schema/isFinite", () => ({ type: "number" })],
+  ["effect/schema/isInt", () => ({ type: "integer" })],
+  ["effect/schema/isGreaterThan", bound("exclusiveMinimum")],
+  ["effect/schema/isGreaterThanOrEqualTo", bound("minimum")],
+  ["effect/schema/isLessThan", bound("exclusiveMaximum")],
+  ["effect/schema/isLessThanOrEqualTo", bound("maximum")],
+  ["effect/schema/isBetween", (id, payload) => ({
+    [field(id, payload, "exclusiveMinimum", isFlag) ? "exclusiveMinimum" : "minimum"]: field(
+      id,
+      payload,
+      "minimum",
+      isNumber
+    ),
+    [field(id, payload, "exclusiveMaximum", isFlag) ? "exclusiveMaximum" : "maximum"]: field(
+      id,
+      payload,
+      "maximum",
+      isNumber
+    )
+  })],
+  ["effect/schema/isMultipleOf", bound("multipleOf", "divisor")],
+  ["effect/schema/isGreaterThanDate", empty],
+  ["effect/schema/isGreaterThanOrEqualToDate", empty],
+  ["effect/schema/isLessThanDate", empty],
+  ["effect/schema/isLessThanOrEqualToDate", empty],
+  ["effect/schema/isBetweenDate", empty],
+  ["effect/schema/isGreaterThanBigInt", empty],
+  ["effect/schema/isGreaterThanOrEqualToBigInt", empty],
+  ["effect/schema/isLessThanBigInt", empty],
+  ["effect/schema/isLessThanOrEqualToBigInt", empty],
+  ["effect/schema/isBetweenBigInt", empty],
+  ["effect/schema/isMinLength", length("minLength", "minItems", "minLength")],
+  ["effect/schema/isMaxLength", length("maxLength", "maxItems", "maxLength")],
+  ["effect/schema/isBetweenLength", (id, payload, input) => {
+    const minimum = field(id, payload, "minimum", isNumber);
+    const maximum = field(id, payload, "maximum", isNumber);
+    return input.type === "array" ? { allOf: [{ minItems: minimum }, { maxItems: maximum }] } : { allOf: [{ minLength: minimum }, { maxLength: maximum }] };
+  }],
+  ["effect/schema/isMinCodePoints", bound("minLength", "minCodePoints")],
+  ["effect/schema/isMaxCodePoints", bound("maxLength", "maxCodePoints")],
+  ["effect/schema/isBetweenCodePoints", (id, payload) => ({
+    allOf: [
+      { minLength: field(id, payload, "minimum", isNumber) },
+      { maxLength: field(id, payload, "maximum", isNumber) }
+    ]
+  })],
+  ["effect/schema/isMinSize", empty],
+  ["effect/schema/isMaxSize", empty],
+  ["effect/schema/isBetweenSize", empty],
+  ["effect/schema/isMinProperties", bound("minProperties")],
+  ["effect/schema/isMaxProperties", bound("maxProperties")],
+  ["effect/schema/isBetweenProperties", (id, payload) => ({
+    minProperties: field(id, payload, "minimum", isNumber),
+    maxProperties: field(id, payload, "maximum", isNumber)
+  })],
+  ["effect/schema/isPropertyNames", (_id, _payload, input) => ({ propertyNames: input.schemas[0] })],
+  ["effect/schema/isUnique", () => ({ uniqueItems: true })],
+  ["effect/schema/isUniqueKey", null]
+]);
+const builtinCheckIds = [...builtinChecks.keys()];
+const isCheckCallback = (value) => typeof value === "function";
+const isApproximate = (output) => Array.isArray(output);
+const fragmentSource = (check) => {
+  const representation = check.representation;
+  const builtin = representation === void 0 ? void 0 : builtinChecks.get(representation.id);
+  if (representation !== void 0 && builtin !== void 0) {
+    return builtin === null ? void 0 : (input) => builtin(representation.id, representation.payload, input);
+  }
+  const callback = check.annotations?.["toJsonSchema"];
+  if (!isCheckCallback(callback)) return void 0;
+  return (input) => {
+    const output = callback(input);
+    return isApproximate(output) ? output[0] : output;
+  };
+};
+const extractNumberType = (schema) => {
+  let type = schema["type"] === "number" || schema["type"] === "integer" ? schema["type"] : void 0;
+  let out = schema;
+  if (type !== void 0) {
+    out = { ...schema };
+    delete out["type"];
+  }
+  const allOf = out["allOf"];
+  if (Array.isArray(allOf)) {
+    const members = [];
+    let changed = false;
+    for (const member of allOf) {
+      const extracted = extractNumberType(member);
+      if (extracted.type !== void 0) {
+        changed = true;
+        if (type === void 0 || extracted.type === "integer") type = extracted.type;
+      }
+      if (Object.keys(extracted.schema).length > 0) members.push(extracted.schema);
+    }
+    if (changed) {
+      const { allOf: _, ...rest } = out;
+      out = members.length === 0 ? rest : { ...rest, allOf: members };
+    }
+  }
+  return { type, schema: out };
+};
+const isNumberEncoding = (schema) => {
+  const anyOf = schema["anyOf"];
+  if (!Array.isArray(anyOf) || anyOf.length !== 2 || !isObject(anyOf[0]) || anyOf[0]["type"] !== "number") return false;
+  const special = anyOf[1];
+  if (!isObject(special) || special["type"] !== "string") return false;
+  const values = special["enum"];
+  return Array.isArray(values) && values.length === 3 && values.includes("NaN") && values.includes("Infinity") && values.includes("-Infinity");
+};
+const inlineableCheckKeywords = "|type|format|pattern|multipleOf|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength|minItems|maxItems|uniqueItems|minProperties|maxProperties|propertyNames|";
+const promotableAnnotationKeywords = "|title|description|default|examples|readOnly|writeOnly|";
+const inlineableAnnotatedCheckKeywords = inlineableCheckKeywords + promotableAnnotationKeywords;
+const hasOnlyKeywords = (schema, allowed) => Object.keys(schema).every((key) => allowed.includes(`|${key}|`));
+const hasNoCollisions = (left, rightKeys) => typeof left["$ref"] !== "string" && rightKeys.every((key) => !Object.hasOwn(left, key));
+const appendJsonSchema = (left, right, inlineCheck) => {
+  if (Object.keys(left).length === 0) return right;
+  const rightKeys = Object.keys(right);
+  if (rightKeys.length === 0) return left;
+  const leftType = left["type"] === "number" || left["type"] === "integer" ? left["type"] : void 0;
+  const numberEncoding = isNumberEncoding(left);
+  if (leftType !== void 0 || numberEncoding) {
+    const extracted = extractNumberType(right);
+    if (extracted.type !== void 0) {
+      const type = leftType === "integer" || extracted.type === "integer" ? "integer" : "number";
+      const base = { ...left, type };
+      if (numberEncoding) delete base["anyOf"];
+      const extractedKeys = Object.keys(extracted.schema);
+      if (extractedKeys.length === 0) return base;
+      return hasOnlyKeywords(extracted.schema, promotableAnnotationKeywords) && hasNoCollisions(base, extractedKeys) ? { ...base, ...extracted.schema } : appendJsonSchema(base, extracted.schema, inlineCheck);
+    }
+  }
+  if (inlineCheck && hasNoCollisions(left, rightKeys)) return { ...left, ...right };
+  const rightAllOf = right["allOf"];
+  const members = Array.isArray(rightAllOf) && rightKeys.length === 1 ? rightAllOf : [right];
+  const leftAllOf = left["allOf"];
+  if (Array.isArray(leftAllOf)) return { ...left, allOf: [...leftAllOf, ...members] };
+  if (typeof left["$ref"] === "string") return { allOf: [left, ...members] };
+  return { ...left, allOf: members };
+};
+const jsonSchemaTypes = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "array",
+  "object",
+  "null",
+  "integer"
+]);
+const isJsonSchemaType = (input) => jsonSchemaTypes.has(input);
+const compactEnums = (schemas) => {
+  let sharedType = void 0;
+  const values = [];
+  for (const schema of schemas) {
+    const members = schema["enum"];
+    if (Object.keys(schema).length !== 2 || schema["type"] === void 0 || !Array.isArray(members) || members.length === 0) {
+      return void 0;
+    }
+    if (sharedType === void 0) sharedType = schema["type"];
+    else if (schema["type"] !== sharedType) return void 0;
+    for (const value of members) {
+      if (values.includes(value)) return void 0;
+      values.push(value);
+    }
+  }
+  return { type: sharedType, enum: values };
+};
+const partPattern = (part) => {
+  switch (part._tag) {
+    case "Literal":
+      return escapeRegExp(String(part.literal));
+    case "String":
+      return stringPattern;
+    case "Number":
+      return finitePattern;
+    case "TemplateLiteral":
+      return part.parts.map(partPattern).join("");
+    case "Union":
+      return `(?:${part.types.map(partPattern).join("|")})`;
+    default:
+      throw invalid("Invalid schema representation document", []);
+  }
+};
+const neverSchema = { not: {} };
+const unsupported = (representation, path) => {
+  throw invalid(`Unsupported schema representation ${representation._tag}`, path);
+};
+const fromRepresentation = (document, options) => {
+  const closed = options?.onExcessProperty === "error";
+  const references = document.references;
+  const definitionStates = /* @__PURE__ */ new Map();
+  const compiledRepresentations = /* @__PURE__ */ new WeakMap();
+  const fallbackDefinitions = /* @__PURE__ */ new Map();
+  const compileDefinition = (key, path) => {
+    const compiled = definitionStates.get(key);
+    if (compiled !== void 0) return typeof compiled === "string" ? compiled : key;
+    const representation = Object.hasOwn(references, key) ? references[key] : void 0;
+    if (representation === void 0) throw invalid(`Invalid reference ${key}`, [...path, "$ref"]);
+    definitionStates.set(key, null);
+    const schema2 = recur(representation, ["references", key]);
+    const fallback = identifierFallback(representation);
+    if (fallback !== void 0) {
+      const candidates = fallbackDefinitions.get(fallback);
+      const match = candidates?.find((candidate) => sameJson(definitionStates.get(candidate), schema2));
+      if (match === void 0) {
+        if (candidates === void 0) fallbackDefinitions.set(fallback, [key]);
+        else candidates.push(key);
+      } else {
+        definitionStates.set(key, match);
+        return match;
+      }
+    }
+    definitionStates.set(key, schema2);
+    return key;
+  };
+  const finalize = (schema2) => rewriteRefs(schema2, (reference) => {
+    const pointer = decodeUriFragment(reference);
+    if (pointer === void 0) {
+      if (/^#(?:\/|%2f)/i.test(reference)) {
+        throw new SchemaIdentityError({ message: `Invalid JSON Pointer URI fragment ${JSON.stringify(reference)}` });
+      }
+      return reference;
+    }
+    if (!pointer.startsWith("/$defs/")) return reference;
+    const separator = pointer.indexOf("/", 7);
+    const canonical = definitionStates.get(unescapeToken(pointer.slice(7, separator < 0 ? void 0 : separator)));
+    if (typeof canonical !== "string") return reference;
+    return reference.replace(/^#(?:\/|%2f).*?(?:\/|%2f).*?(?=\/|%2f|$)/i, definitionReference(canonical));
+  });
+  const identifierFallback = (representation) => {
+    if (representation._tag === "Reference") return void 0;
+    const last = representation.checks.at(-1);
+    const annotations = last === void 0 ? representation.annotations : last.annotations;
+    const fallback = annotations?.["~identifier"];
+    return typeof annotations?.["identifier"] !== "string" && typeof fallback === "string" ? fallback : void 0;
+  };
+  const compileCheck = (check, type, path) => {
+    const source = fragmentSource(check);
+    if (source !== void 0) {
+      const schemas = check.representation?.schemas?.map(
+        (schema3, index) => recur(schema3, [...path, "representation", "schemas", index])
+      ) ?? [];
+      const fragment = source({ type, schemas });
+      const ordinary2 = ordinaryAnnotations(check.annotations);
+      const schema2 = ordinary2 === void 0 ? fragment : { ...fragment, ...ordinary2 };
+      const allowed = ordinary2 === void 0 ? inlineableCheckKeywords : inlineableAnnotatedCheckKeywords;
+      return check._tag === "Filter" && hasOnlyKeywords(schema2, allowed) && (ordinary2 === void 0 || hasOnlyKeywords(ordinary2, promotableAnnotationKeywords)) ? [schema2, true] : [schema2];
+    }
+    if (check._tag === "Filter") return void 0;
+    const allOf = [];
+    check.checks.forEach((child, index) => {
+      const compiled = compileCheck(child, type, [...path, "checks", index]);
+      if (compiled !== void 0) allOf.push(compiled[0]);
+    });
+    if (allOf.length === 0) return void 0;
+    const ordinary = ordinaryAnnotations(check.annotations);
+    return [ordinary === void 0 ? { allOf } : { allOf, ...ordinary }];
+  };
+  const recur = (representation, path) => {
+    if (representation._tag === "Reference") {
+      return { $ref: definitionReference(compileDefinition(representation.$ref, path)) };
+    }
+    const cached = compiledRepresentations.get(representation);
+    if (cached !== void 0) return cached;
+    let output = on(representation, path);
+    const ordinary = ordinaryAnnotations(representation.annotations);
+    if (ordinary !== void 0) output = { ...output, ...ordinary };
+    representation.checks.forEach((check, index) => {
+      const compiled = compileCheck(
+        check,
+        isJsonSchemaType(output["type"]) ? output["type"] : void 0,
+        [...path, "checks", index]
+      );
+      if (compiled !== void 0) output = appendJsonSchema(output, ...compiled);
+    });
+    compiledRepresentations.set(representation, output);
+    return output;
+  };
+  const annotated = (compiled, annotations) => {
+    const ordinary = ordinaryAnnotations(annotations);
+    return ordinary === void 0 ? compiled : appendJsonSchema(compiled, ordinary);
+  };
+  const on = (representation, path) => {
+    switch (representation._tag) {
+      case "Any":
+      case "Unknown":
+      case "Declaration":
+        return {};
+      case "ObjectKeyword":
+        return { anyOf: [{ type: "object" }, { type: "array" }] };
+      case "Void":
+      case "Undefined":
+      case "Null":
+        return { type: "null" };
+      case "BigInt":
+        return { type: "string", allOf: [{ pattern: bigIntPattern }] };
+      case "Symbol":
+        return { type: "string", allOf: [{ pattern: symbolPattern }] };
+      case "UniqueSymbol":
+        return Symbol.keyFor(representation.symbol) === void 0 ? { not: {} } : { type: "string", enum: [String(representation.symbol)] };
+      case "Suspend":
+        return recur(representation.thunk, [...path, "thunk"]);
+      case "Never":
+        return { not: {} };
+      case "String":
+        return { type: "string" };
+      case "Number":
+        return { anyOf: [{ type: "number" }, { type: "string", enum: ["NaN", "Infinity", "-Infinity"] }] };
+      case "Boolean":
+        return { type: "boolean" };
+      case "Literal": {
+        const literal = representation.literal;
+        return typeof literal === "bigint" ? { type: "string", enum: [String(literal)] } : { type: typeof literal, enum: [literal] };
+      }
+      case "Enum": {
+        const types = representation.enums.map(([title, literal], index) => {
+          if (typeof literal === "number" && !Number.isFinite(literal)) {
+            throw invalid(`Invalid numeric enum value ${String(literal)}`, [...path, "enums", index, 1]);
+          }
+          return { type: typeof literal, enum: [literal], title };
+        });
+        return types.length === 0 ? { not: {} } : { anyOf: types };
+      }
+      case "TemplateLiteral":
+        return { type: "string", pattern: `^${representation.parts.map(partPattern).join("")}$` };
+      case "Arrays": {
+        const rest = representation.rest[0];
+        if (representation.rest.length > 1) {
+          throw invalid("Invalid schema representation document", [...path, "rest"]);
+        }
+        const out = { type: "array" };
+        let minItems = representation.elements.length;
+        const prefixItems = representation.elements.map((element, index) => {
+          if (element.isOptional) minItems--;
+          return annotated(recur(element.type, [...path, "elements", index, "type"]), element.annotations);
+        });
+        if (prefixItems.length > 0) {
+          out["prefixItems"] = prefixItems;
+          out["maxItems"] = representation.elements.length;
+          if (minItems > 0) out["minItems"] = minItems;
+        } else {
+          out["items"] = false;
+        }
+        if (rest !== void 0) {
+          delete out["maxItems"];
+          const items = recur(rest, [...path, "rest", 0]);
+          if (Object.keys(items).length > 0) out["items"] = items;
+          else delete out["items"];
+        }
+        return out;
+      }
+      case "Objects": {
+        if (representation.propertySignatures.length === 0 && representation.indexSignatures.length === 0) {
+          return { not: { type: "null" } };
+        }
+        const out = { type: "object" };
+        const properties = {};
+        const required = [];
+        representation.propertySignatures.forEach((property, index) => {
+          const name = property.name;
+          if (typeof name !== "string") {
+            throw invalid("Invalid schema representation document", [...path, "propertySignatures", index, "name"]);
+          }
+          assignProperty(
+            properties,
+            name,
+            annotated(recur(property.type, [...path, "propertySignatures", index, "type"]), property.annotations)
+          );
+          if (!property.isOptional) required.push(name);
+        });
+        if (representation.propertySignatures.length > 0) out["properties"] = properties;
+        if (required.length > 0) out["required"] = required;
+        const patternProperties = {};
+        const additionalPropertySchemas = [];
+        const indexValueSchemas = [];
+        let hasUnrepresentableIndexPattern = false;
+        representation.indexSignatures.forEach((signature, index) => {
+          const compiled = recur(signature.type, [...path, "indexSignatures", index, "type"]);
+          const type = sameJson(compiled, neverSchema) ? false : compiled;
+          indexValueSchemas.push(type);
+          const patterns = parameterPatterns(
+            signature.parameter,
+            [...path, "indexSignatures", index, "parameter"],
+            /* @__PURE__ */ new Set()
+          );
+          if (patterns === void 0) {
+            hasUnrepresentableIndexPattern = true;
+          } else if (patterns.length === 0) {
+            additionalPropertySchemas.push(type);
+          } else {
+            for (const key of patterns) {
+              const previous = Object.hasOwn(patternProperties, key) ? patternProperties[key] : void 0;
+              assignProperty(
+                patternProperties,
+                key,
+                previous === void 0 ? type : previous === false || type === false ? false : appendJsonSchema(previous, type)
+              );
+            }
+          }
+        });
+        const hasPatternProperties = Object.keys(patternProperties).length > 0;
+        if (hasPatternProperties) out["patternProperties"] = patternProperties;
+        const additional = additionalPropertySchemas.map((type) => ({ type: "object", additionalProperties: type }));
+        if (hasUnrepresentableIndexPattern && closed) {
+          const propertyNames = [];
+          if (representation.propertySignatures.length > 0) propertyNames.push({ enum: Object.keys(properties) });
+          representation.indexSignatures.forEach((signature, index) => {
+            propertyNames.push(recur(signature.parameter, [...path, "indexSignatures", index, "parameter"]));
+          });
+          out["propertyNames"] = propertyNames.length === 1 ? propertyNames[0] : { anyOf: propertyNames };
+          out["additionalProperties"] = indexValueSchemas.length === 1 ? indexValueSchemas[0] : { anyOf: indexValueSchemas };
+          if (additional.length > 0) out["allOf"] = additional;
+        } else if (additional.length === 0) {
+          out["additionalProperties"] = hasUnrepresentableIndexPattern || !closed;
+        } else if (additionalPropertySchemas.length === 1 && representation.propertySignatures.length === 0 && !hasPatternProperties) {
+          out["additionalProperties"] = additionalPropertySchemas[0];
+        } else {
+          out["allOf"] = additional;
+        }
+        const additionalProperties = out["additionalProperties"];
+        if (isObject(additionalProperties) && Object.keys(additionalProperties).length === 0) {
+          delete out["additionalProperties"];
+        }
+        return out;
+      }
+      case "Union": {
+        const types = representation.types.map((type, index) => recur(type, [...path, "types", index]));
+        if (types.length === 0) return { not: {} };
+        const mode = representation.options?.mode ?? "anyOf";
+        if (mode === "anyOf" && types.length > 1) {
+          const compacted = compactEnums(types);
+          if (compacted !== void 0) return compacted;
+        }
+        return mode === "anyOf" ? { anyOf: types } : { oneOf: types };
+      }
+      default:
+        return unsupported(representation, path);
+    }
+  };
+  const parameterPatterns = (parameter, path, seenReferences) => {
+    switch (parameter._tag) {
+      case "Reference": {
+        const target = Object.hasOwn(references, parameter.$ref) ? references[parameter.$ref] : void 0;
+        if (target === void 0) throw invalid(`Invalid reference ${parameter.$ref}`, [...path, "$ref"]);
+        compileDefinition(parameter.$ref, path);
+        if (seenReferences.has(parameter.$ref)) return void 0;
+        return parameterPatterns(target, ["references", parameter.$ref], new Set(seenReferences).add(parameter.$ref));
+      }
+      case "String": {
+        const check = parameter.checks[0];
+        if (check === void 0) return [];
+        if (parameter.checks.length !== 1 || check._tag !== "Filter" || fragmentSource(check) === void 0) {
+          return void 0;
+        }
+        const schema2 = recur(parameter, path);
+        const key = schema2["pattern"];
+        return schema2["type"] === "string" && typeof key === "string" && hasOnlyKeywords(schema2, "|type|pattern|title|description|default|examples|readOnly|writeOnly|") ? [key] : void 0;
+      }
+      case "TemplateLiteral":
+        return parameter.checks.length === 0 ? [`^${parameter.parts.map(partPattern).join("")}$`] : void 0;
+      case "Union": {
+        if (parameter.types.length === 0 || parameter.checks.length > 0 || parameter.options?.mode === "oneOf") {
+          return void 0;
+        }
+        const patterns = [];
+        for (const [index, member] of parameter.types.entries()) {
+          const memberPatterns = parameterPatterns(member, [...path, "types", index], seenReferences);
+          if (memberPatterns === void 0) return void 0;
+          if (memberPatterns.length === 0) return [];
+          patterns.push(...memberPatterns);
+        }
+        return patterns;
+      }
+      default:
+        throw invalid("Invalid schema representation document", path);
+    }
+  };
+  const referenceKeys = Object.keys(references);
+  for (const key of referenceKeys) compileDefinition(key, ["references", key]);
+  const schema = finalize(recur(document.representation, ["representation"]));
+  const definitions = {};
+  for (const key of referenceKeys) {
+    const compiled = definitionStates.get(key);
+    if (isObject(compiled)) assignProperty(definitions, key, finalize(compiled));
+  }
+  return { dialect: "draft-2020-12", schema, definitions };
+};
+const schemaIdentity = (schema, options) => fromRepresentation(Schema.toRepresentation(Schema.toCodecJson(schema)), options);
+const rc115CheckIds = /* @__PURE__ */ new Map([
+  ["effect/schema/isStartingWith", "effect/schema/isStartsWith"],
+  ["effect/schema/isEndingWith", "effect/schema/isEndsWith"],
+  ["effect/schema/isIncluding", "effect/schema/isIncludes"],
+  ["effect/schema/isBetweenLength", "effect/schema/isLengthBetween"],
+  ["effect/schema/isBetweenSize", "effect/schema/isSizeBetween"],
+  ["effect/schema/isBetweenProperties", "effect/schema/isPropertiesLengthBetween"]
+]);
+const withRc115CheckIds = (value, isCheck = false) => {
+  if (Array.isArray(value)) return value.map((member) => withRc115CheckIds(member, isCheck));
+  if (!isObject(value)) return value;
+  const out = {};
+  for (const [key, member] of Object.entries(value)) {
+    if (key === "annotations" || key === "payload") {
+      assignProperty(out, key, member);
+      continue;
+    }
+    const renamed = isCheck && key === "representation" && isObject(member) && typeof member["id"] === "string" ? rc115CheckIds.get(member["id"]) : void 0;
+    assignProperty(
+      out,
+      key,
+      renamed === void 0 ? withRc115CheckIds(member, key === "checks") : withRc115CheckIds({ ...member, id: renamed })
+    );
+  }
+  return out;
+};
+const representationIdentity = (ast) => withRc115CheckIds(SchemaRepresentation.toJson(SchemaRepresentation.toRepresentation(ast)));
+//# sourceMappingURL=SchemaIdentity.js.map