apps 0.0.1-beta.4 → 0.0.1-beta.41

package/js/{chunk-WFSQXYUT.js → chunk-WPBR4AWB.js}

@@ -1,6 +1,7 @@
 import {
+  JsonObject,
   ValidationError
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   Cause_exports,
   Effect_exports,
@@ -9,7 +10,7 @@ import {
   SchemaIssue_exports,
   SchemaParser_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-MXDKXAY4.js";
 
 // ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
@@ -106,9 +107,9 @@ var ignoredKeyword = {
 var initialBaseURI = typeof self !== "undefined" && self.location && self.location.origin !== "null" ? new URL(self.location.origin + self.location.pathname + location.search) : new URL("https://github.com/cfworker");
 function dereference(schema, lookup = /* @__PURE__ */ Object.create(null), baseURI = initialBaseURI, basePointer = "") {
   if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-    const id2 = schema.$id || schema.id;
-    if (id2) {
-      const url = new URL(id2, baseURI.href);
+    const id = schema.$id || schema.id;
+    if (id) {
+      const url = new URL(id, baseURI.href);
       if (url.hash.length > 1) {
         lookup[url.href] = schema;
       } else {
@@ -344,7 +345,7 @@ function validate(instance, schema, draft = "2019-09", lookup = dereference(sche
   if ($recursiveAnchor === true && recursiveAnchor === null) {
     recursiveAnchor = schema;
   }
-  if ($recursiveRef === "#") {
+  if ($recursiveRef !== void 0) {
     const refSchema = recursiveAnchor === null ? lookup[__absolute_recursive_ref__] : recursiveAnchor;
     const keywordLocation = `${schemaLocation}/$recursiveRef`;
     const result = validate(instance, recursiveAnchor === null ? schema : recursiveAnchor, draft, lookup, shortCircuit, refSchema, instanceLocation, keywordLocation, evaluated);
@@ -1068,40 +1069,31 @@ function schemaPattern(pattern) {
 }
 
 // src/implementation/schema.ts
-var StorageField = /* @__PURE__ */ Symbol("apps.StorageField");
 var Decoder = /* @__PURE__ */ Symbol("apps.Schema");
 var decoderOf = (schema) => schema[Decoder];
 var isSchema = (value) => typeof value === "object" && value !== null && Decoder in value;
+var schemaArgument = (value, role) => {
+  if (isSchema(value)) return value;
+  const received = value;
+  throw new TypeError(
+    `${role} must be a schema, such as string() or object({ ... }), but ${typeof received === "function" ? "it is a function. Call it, as in string()." : received === void 0 ? "it is undefined. Check that it is defined and imported before this declaration." : typeof received === "object" && received !== null && Object.getPrototypeOf(received) === Object.prototype ? "it is a plain object. Wrap its fields in object({ ... })." : "no apps schema constructor created it."}`
+  );
+};
 var parse = (decoder, input) => Effect_exports.suspend(() => Schema_exports.decodeUnknownEffect(decoder)(input)).pipe(
   Effect_exports.mapError(() => new ValidationError())
 );
-function wrap(decoder, optionalValue, field) {
+function wrap(decoder, optionalValue) {
   return {
     [Decoder]: decoder,
-    ...field === void 0 ? {} : { [StorageField]: field },
     optionalValue,
     parse: (input) => Effect_exports.runSync(parse(decoder, input)),
-    optional: () => wrap(
-      Schema_exports.optional(decoder),
-      true,
-      field === void 0 ? void 0 : { ...field, optional: true }
-    ),
+    optional: () => wrap(Schema_exports.optional(decoder), true),
     default: (value) => {
       const parsed = Effect_exports.runSync(parse(decoder, value));
       return {
         ...wrap(
           decoder.annotate({ default: parsed }).pipe(Schema_exports.withDecodingDefault(Effect_exports.succeed(parsed))),
-          false,
-          field === void 0 || parsed === void 0 ? void 0 : {
-            ...field,
-            default: Schema_exports.decodeUnknownSync(
-              Schema_exports.Union([
-                Schema_exports.String,
-                Schema_exports.Finite,
-                Schema_exports.Boolean
-              ])
-            )(parsed)
-          }
+          false
         ),
         hasDefault: true,
         inputOptional: optionalValue
@@ -1112,14 +1104,19 @@ function wrap(decoder, optionalValue, field) {
 function string(options = {}) {
   return wrap(
     options.minLength === void 0 ? Schema_exports.String : Schema_exports.String.check(Schema_exports.isMinLength(options.minLength)),
-    false,
-    { kind: "string" }
+    false
   );
 }
-var number = () => wrap(Schema_exports.Finite, false, { kind: "number" });
-var boolean = () => wrap(Schema_exports.Boolean, false, { kind: "boolean" });
+var number = () => wrap(Schema_exports.Finite, false);
+var boolean = () => wrap(Schema_exports.Boolean, false);
 var json = () => wrap(Schema_exports.Json, false);
-var record = (value) => wrap(Schema_exports.Record(Schema_exports.String, decoderOf(value)), false);
+var record = (value) => wrap(
+  Schema_exports.Record(
+    Schema_exports.String,
+    decoderOf(schemaArgument(value, "The record() value"))
+  ),
+  false
+);
 function literal(value) {
   if (typeof value === "number") Effect_exports.runSync(parse(Schema_exports.Finite, value));
   return wrap(
@@ -1127,10 +1124,13 @@ function literal(value) {
     false
   );
 }
-var array = (item) => wrap(Schema_exports.Array(decoderOf(item)), false);
+var array = (item) => wrap(Schema_exports.Array(decoderOf(schemaArgument(item, "The array() item"))), false);
 function object(fields) {
   const entries = Object.entries(fields).map(
-    ([key, field]) => [key, decoderOf(field)]
+    ([key, field]) => [
+      key,
+      decoderOf(schemaArgument(field, `The object() field ${JSON.stringify(key)}`))
+    ]
   );
   const decoder = entries.length === 0 ? withJsonSchemaDocument(
     // Native Struct({}) accepts every non-null value and retains undeclared fields.
@@ -1144,6 +1144,25 @@ function object(fields) {
   ) : Schema_exports.Struct(Object.fromEntries(entries));
   return { ...wrap(decoder, false), fields: Object.freeze({ ...fields }) };
 }
+var Exposure = /* @__PURE__ */ Symbol("apps.FieldExposure");
+var exposureOf = (schema) => Exposure in schema && (schema[Exposure] === "plain" || schema[Exposure] === "raw") ? schema[Exposure] : void 0;
+var expose = (schema, exposure) => (
+  // SAFETY: the copy keeps every member of S, and `optional` and `default` keep the marking.
+  {
+    ...schema,
+    [Exposure]: exposure,
+    optional: () => expose(schema.optional(), exposure),
+    default: (value) => expose(schema.default(value), exposure)
+  }
+);
+var plain = (schema) => expose(schema, "plain");
+var raw = (schema) => expose(schema, "raw");
+var fieldExposure = (fields) => Object.fromEntries(
+  Object.entries(fields).flatMap(([name, field]) => {
+    const exposure = exposureOf(field);
+    return exposure === void 0 ? [] : [[name, exposure]];
+  })
+);
 var ImportedJsonSchema = /* @__PURE__ */ Symbol("apps.JsonSchemaDocument");
 var importedJsonSchema = (decoder) => ImportedJsonSchema in decoder ? decoder[ImportedJsonSchema] : void 0;
 var withJsonSchemaDocument = (decoder, document) => Object.assign(decoder, { [ImportedJsonSchema]: document });
@@ -1273,18 +1292,425 @@ var containerKeywords = /* @__PURE__ */ new Set([
   "else",
   "dependentSchemas"
 ]);
-var jsonSchemaProblems = (errors) => {
-  const problems = errors.flatMap(({ keyword, instanceLocation, error }) => {
-    if (containerKeywords.has(keyword)) return [];
-    const path = instanceLocation.replace(/^#\/?/, "").split("/").filter((segment) => segment !== "").map((segment) => decodeURIComponent(segment).replace(/~1/g, "/").replace(/~0/g, "~")).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
-    const required = keyword === "required" ? /required property "([^"]*)"/.exec(error) : null;
-    const expected = keyword === "type" ? /Expected "([^.]*)"\.?$/.exec(error) : null;
-    const issue = required !== null ? { path: [...path, required[1] ?? ""], issue: "Missing key" } : {
-      path,
-      issue: expected !== null ? `Expected ${(expected[1] ?? "").replace(/"/g, "")}` : keyword === "const" || keyword === "enum" ? "Expected one of the allowed values" : `Failed the "${keyword}" constraint`
+var echoableKey = (key) => /^[A-Za-z_$][\w$-]{0,63}$/.test(key);
+var schemaKey = (name) => echoableKey(name) ? name : JSON.stringify(name.slice(0, 64));
+var maxShapeKeys = 24;
+var objectShape = (keys, open, limit = maxShapeKeys) => {
+  const listed = keys.slice(0, limit).map(({ name, optional }) => `${schemaKey(name)}${optional ? "?" : ""}`);
+  const parts = [
+    ...listed,
+    ...keys.length > limit ? [`${keys.length - limit} more`] : [],
+    ...open ? ["..."] : []
+  ];
+  return parts.length === 0 ? "object {} with no keys" : `object {${parts.join(", ")}}`;
+};
+var maxListedValues = 10;
+var maxValuesText = 200;
+var valueText = (value) => typeof value === "bigint" ? `${value}n` : JSON.stringify(value);
+var allowedValues = (values) => {
+  const texts = [...new Set(values.map(valueText))];
+  const listed = [];
+  for (const text of texts) {
+    if (listed.length === maxListedValues || [...listed, text].join(", ").length > maxValuesText)
+      break;
+    listed.push(text);
+  }
+  const [only] = listed;
+  if (texts.length === 0) return "no value, since the schema allows none";
+  if (only === void 0)
+    return texts.length === 1 ? "a fixed value too long to list" : `one of ${texts.length} values too long to list`;
+  if (texts.length === 1) return only;
+  const rest = texts.length - listed.length;
+  return `one of ${listed.join(", ")}${rest > 0 ? ` and ${rest} more` : ""}`;
+};
+var maxAlternativeKeys = 8;
+var maxAlternativesText = 360;
+var unionShape = (alternatives, selector) => {
+  const listed = [];
+  for (const alternative of alternatives) {
+    if (listed.length > 0 && [...listed, alternative].join(" or ").length > maxAlternativesText)
+      break;
+    listed.push(alternative);
+  }
+  const rest = alternatives.length - listed.length;
+  return `${[...listed, ...rest > 0 ? [`${rest} more`] : []].join(" or ")}${selector === void 0 ? "" : `, told apart by ${schemaKey(selector)}`}`;
+};
+var missingKey = (expected) => expected === void 0 ? missingKeyText : `${missingKeyText}. Expected ${expected}`;
+var missingKeyText = "Missing key";
+var isJsonRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pointerSegments = (pointer) => pointer === "#" || pointer === "" ? [] : pointer.replace(/^#?\//, "").split("/").map((segment) => decodeURIComponent(segment).replace(/~1/g, "/").replace(/~0/g, "~"));
+var resolved = (lookup, uri2) => typeof uri2 === "string" && Object.hasOwn(lookup, uri2) ? lookup[uri2] : void 0;
+var referenced = (lookup, node) => isJsonRecord(node) ? resolved(lookup, Reflect.get(node, "__absolute_ref__") ?? node.$ref) : void 0;
+var memberKeywords = /* @__PURE__ */ new Set([...schemaMaps, ...schemaArrays, "dependencies"]);
+var combinators = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf"]);
+var schemaAt = (document, lookup, segments) => {
+  const anchoredAt = (node2, anchor2) => anchor2 === null && isJsonRecord(node2) && node2.$recursiveAnchor === true ? node2 : anchor2;
+  const pending = [...segments];
+  let node = document;
+  let anchor = anchoredAt(document, null);
+  for (let keyword = pending.shift(); keyword !== void 0; keyword = pending.shift()) {
+    if (!isJsonRecord(node)) return void 0;
+    if (keyword === "$recursiveRef") {
+      const target = anchor === null ? resolved(lookup, Reflect.get(node, "__absolute_recursive_ref__")) : anchor;
+      if (anchor !== null) node = anchor;
+      anchor = target;
+      continue;
+    }
+    if (keyword === "$ref") node = referenced(lookup, node);
+    else {
+      const value = Object.hasOwn(node, keyword) ? node[keyword] : void 0;
+      if (memberKeywords.has(keyword) || keyword === "items" && Array.isArray(value)) {
+        const member = pending.shift();
+        if (member === void 0) return value;
+        if (combinators.has(keyword) && node.$recursiveAnchor !== true) anchor = null;
+        node = Array.isArray(value) ? /^\d+$/.test(member) ? value[Number(member)] : void 0 : isJsonRecord(value) && Object.hasOwn(value, member) ? value[member] : void 0;
+      } else node = value;
+    }
+    anchor = anchoredAt(node, anchor);
+  }
+  return node;
+};
+var jsonObjectShape = (node) => {
+  if (!isJsonRecord(node)) return "object";
+  const properties = isJsonRecord(node.properties) ? Object.keys(node.properties) : [];
+  const required = new Set(Array.isArray(node.required) ? node.required : []);
+  const open = node.additionalProperties !== false || isJsonRecord(node.patternProperties) && Object.keys(node.patternProperties).length > 0;
+  return properties.length === 0 && open ? "object" : objectShape(
+    properties.map((name) => ({ name, optional: !required.has(name) })),
+    open
+  );
+};
+var locationKey = (segments) => JSON.stringify(segments);
+var emptyOutline = {
+  types: void 0,
+  properties: /* @__PURE__ */ new Map(),
+  required: /* @__PURE__ */ new Set(),
+  closed: false,
+  values: void 0
+};
+var commonValues = (a, b) => a === void 0 ? b : b === void 0 ? a : a.filter((value) => b.some((other) => deepCompareStrict(value, other)));
+var strings = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+var commonTypes = (a, b) => new Set(
+  [...a].flatMap(
+    (type) => b.has(type) ? [type] : type === "number" && b.has("integer") || type === "integer" && b.has("number") ? ["integer"] : []
+  )
+);
+var mergeOutlines = (a, b) => ({
+  types: a.types === void 0 ? b.types : b.types === void 0 ? a.types : commonTypes(a.types, b.types),
+  properties: new Map([...a.properties, ...b.properties]),
+  required: /* @__PURE__ */ new Set([...a.required, ...b.required]),
+  closed: a.closed || b.closed,
+  values: commonValues(a.values, b.values)
+});
+var outlineOf = (node, inspection, seen = /* @__PURE__ */ new Set()) => {
+  if (!isJsonRecord(node) || seen.has(node)) return emptyOutline;
+  const within = /* @__PURE__ */ new Set([...seen, node]);
+  const own = {
+    types: typeof node.type === "string" ? /* @__PURE__ */ new Set([node.type]) : Array.isArray(node.type) ? new Set(strings(node.type)) : void 0,
+    properties: new Map(isJsonRecord(node.properties) ? Object.entries(node.properties) : []),
+    required: new Set(strings(node.required)),
+    closed: (node.additionalProperties === false || node.unevaluatedProperties === false) && !(isJsonRecord(node.patternProperties) && Object.keys(node.patternProperties).length > 0),
+    values: commonValues(
+      Object.hasOwn(node, "const") ? [node.const] : void 0,
+      Array.isArray(node.enum) ? node.enum : void 0
+    )
+  };
+  return [inspection.referenced(node), ...Array.isArray(node.allOf) ? node.allOf : []].reduce(
+    (outline, member) => mergeOutlines(outline, outlineOf(member, inspection, within)),
+    own
+  );
+};
+var otherConstraints = "a value with other constraints";
+var outlineText = (outline, limit) => {
+  if (outline.values !== void 0) return allowedValues(outline.values);
+  const names = [
+    ...outline.properties.keys(),
+    ...[...outline.required].filter((name) => !outline.properties.has(name))
+  ];
+  const shape = names.length === 0 && !outline.closed ? "object" : objectShape(
+    names.map((name) => ({ name, optional: !outline.required.has(name) })),
+    !outline.closed,
+    limit
+  );
+  if (outline.types === void 0)
+    return names.length > 0 || outline.closed ? shape : otherConstraints;
+  return [...outline.types].map((type) => type === "object" ? shape : type).join(" or ");
+};
+var describeOutline = (outline) => outlineText(outline, maxAlternativeKeys);
+var typed = (outline) => outline.values !== void 0 || outline.types !== void 0;
+var describeProperty = (node, inspection) => {
+  const target = inspection.referenced(node) ?? node;
+  if (isJsonRecord(target) && Object.hasOwn(target, "oneOf")) return void 0;
+  const outline = outlineOf(node, inspection);
+  if (typed(outline)) return outlineText(outline, maxShapeKeys);
+  const members = isJsonRecord(target) && Array.isArray(target.anyOf) ? target.anyOf : [];
+  const outlines = members.filter((member) => member !== false).map((member) => outlineOf(member, inspection));
+  return outlines.length === 0 || !outlines.every(typed) ? void 0 : unionShape([...new Set(outlines.map(describeOutline))], void 0);
+};
+var maxPatternText = 160;
+var count = (amount, noun) => `${amount} ${noun}${amount === 1 ? "" : "s"}`;
+var constraintProblem = (keyword, node) => {
+  if (!isJsonRecord(node)) return void 0;
+  const value = node[keyword];
+  if (keyword === "pattern")
+    return typeof value !== "string" ? void 0 : value.length <= maxPatternText ? `Expected a string matching the pattern ${JSON.stringify(value)}` : "Expected a string matching the schema's pattern, which is too long to show";
+  if (keyword === "format")
+    return typeof value === "string" ? `Expected a string in the ${JSON.stringify(value.slice(0, 64))} format` : void 0;
+  if (keyword === "uniqueItems") return "Expected an array without repeated items";
+  if (typeof value !== "number") return void 0;
+  switch (keyword) {
+    // Draft 4's boolean `exclusiveMinimum` is not applied: imported schemas validate as draft 7
+    // or 2020-12, where `minimum` and `maximum` always include their bound.
+    case "minimum":
+      return `Expected a number of at least ${value}`;
+    case "maximum":
+      return `Expected a number of at most ${value}`;
+    case "exclusiveMinimum":
+      return `Expected a number greater than ${value}`;
+    case "exclusiveMaximum":
+      return `Expected a number less than ${value}`;
+    case "multipleOf":
+      return `Expected a multiple of ${value}`;
+    case "minLength":
+      return `Expected a string of at least ${count(value, "character")}`;
+    case "maxLength":
+      return `Expected a string of at most ${count(value, "character")}`;
+    case "minItems":
+      return `Expected an array of at least ${count(value, "item")}`;
+    case "maxItems":
+      return `Expected an array of at most ${count(value, "item")}`;
+    case "minProperties":
+      return `Expected an object with at least ${count(value, "key")}`;
+    case "maxProperties":
+      return `Expected an object with at most ${count(value, "key")}`;
+    default:
+      return void 0;
+  }
+};
+var overlap = (outline, value, inspection, depth = 0) => !isJsonRecord(value) || depth > 16 ? 0 : Object.entries(value).reduce((total, [key, item]) => {
+  const property = outline.properties.get(key);
+  return property === void 0 ? total : total + 1 + overlap(outlineOf(property, inspection), item, inspection, depth + 1);
+}, 0);
+var jsonType = (value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value === "object" ? "object" : typeof value;
+var accepted = (outline, value) => {
+  const type = jsonType(value);
+  if (outline.values !== void 0)
+    return outline.values.some((allowed) => jsonType(allowed) === type);
+  if (outline.types === void 0) return true;
+  return outline.types.has(type) || type === "number" && outline.types.has("integer") && Number.isInteger(value);
+};
+var valueAt = (input, location2) => location2.reduce(
+  (value, segment) => Array.isArray(value) ? value[Number(segment)] : isJsonRecord(value) && Object.hasOwn(value, segment) ? value[segment] : void 0,
+  input
+);
+var discriminatorOf = (holder) => isJsonRecord(holder) && isJsonRecord(holder.discriminator) ? holder.discriminator : void 0;
+var definitionName = (reference) => {
+  if (typeof reference !== "string" || !reference.startsWith("#/")) return void 0;
+  const segments = pointerSegments(reference);
+  const container = segments.at(-2);
+  return container === "$defs" || container === "definitions" || container === "schemas" && segments.at(-3) === "components" ? segments.at(-1) : void 0;
+};
+var discriminatedName = (holder, value) => {
+  const discriminator = discriminatorOf(holder);
+  if (discriminator === void 0 || typeof value !== "string") return void 0;
+  const { mapping } = discriminator;
+  const target = isJsonRecord(mapping) && Object.hasOwn(mapping, value) ? mapping[value] : value;
+  if (typeof target !== "string") return void 0;
+  return /^[\w.-]+$/.test(target) ? target : definitionName(target);
+};
+var selectorOf = (holder, alternatives, inspection) => {
+  const declared = discriminatorOf(holder)?.propertyName;
+  if (typeof declared === "string") return declared;
+  const [first] = alternatives;
+  if (first === void 0 || alternatives.length < 2) return void 0;
+  return [...first.properties.keys()].find(
+    (key) => alternatives.every(
+      (alternative) => alternative.properties.has(key) && outlineOf(alternative.properties.get(key), inspection).values !== void 0
+    )
+  );
+};
+var alternativeErrors = (errors, head, schemas) => {
+  const prefix = `${errors[head]?.keywordLocation}/`;
+  const alternatives = /* @__PURE__ */ new Map();
+  const settle = (current2, next) => {
+    const collected = alternatives.get(current2);
+    const rejected = Array.isArray(schemas) ? schemas.slice(current2 + 1, next).filter((schema) => schema === false).length : 0;
+    if (collected !== void 0) collected.splice(collected.length - rejected, rejected);
+  };
+  let index = head + 1;
+  let current = -1;
+  for (; index < errors.length; index++) {
+    const error = errors[index];
+    if (error === void 0) break;
+    if (error.keywordLocation.startsWith(prefix)) {
+      const alternative = Number(error.keywordLocation.slice(prefix.length).split("/")[0]);
+      if (alternative !== current) settle(current, alternative);
+      current = alternative;
+    } else if (error.keyword !== "false") break;
+    if (current >= 0) alternatives.set(current, [...alternatives.get(current) ?? [], error]);
+  }
+  settle(current, Array.isArray(schemas) ? schemas.length : current);
+  return { alternatives, end: index };
+};
+var pathOf = (location2) => location2.map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+var unionProblems = (union, schemas, errorsByAlternative, inspection) => {
+  const location2 = pointerSegments(union.instanceLocation);
+  const path = pathOf(location2);
+  if (!Array.isArray(schemas))
+    return [
+      { path, issue: `Failed the "${union.keyword}" constraint` },
+      ...[...errorsByAlternative.values()].flatMap((errors) => problemsOf(errors, inspection))
+    ];
+  const alternatives = schemas.flatMap(
+    (schema, index) => schema === false ? [] : [
+      {
+        schema,
+        matched: !errorsByAlternative.has(index),
+        problems: () => problemsOf(errorsByAlternative.get(index) ?? [], inspection)
+      }
+    ]
+  );
+  const [only] = alternatives;
+  if (only === void 0) return [{ path, issue: "No value is allowed here" }];
+  if (alternatives.length === 1) return only.problems();
+  const holder = inspection.schemaAt(pointerSegments(union.keywordLocation).slice(0, -1));
+  const shared = outlineOf(holder, inspection);
+  const own = alternatives.map(({ schema }) => outlineOf(schema, inspection));
+  const outlines = own.map((outline) => mergeOutlines(shared, outline));
+  const selector = selectorOf(holder, own, inspection);
+  const expected = `Expected ${unionShape(outlines.map(describeOutline), selector)}`;
+  const matched = alternatives.filter((alternative) => alternative.matched).length;
+  if (union.keyword === "oneOf" && matched > 1)
+    return [{ path, issue: `${expected}. Exactly one may match, but ${matched} do` }];
+  const fixed = outlines.flatMap(({ values }) => values === void 0 ? [] : [values]);
+  if (fixed.length === outlines.length)
+    return [
+      {
+        path,
+        issue: union.keyword === "oneOf" ? `${expected}. Exactly one alternative must match` : `Expected ${allowedValues(fixed.flat())}`
+      }
+    ];
+  const value = valueAt(inspection.input, location2);
+  const selectorValue = selector !== void 0 && isJsonRecord(value) && Object.hasOwn(value, selector) ? { value: value[selector] } : void 0;
+  const named = discriminatedName(holder, selectorValue?.value);
+  const ranked = alternatives.map(({ schema, problems }, index) => {
+    const outline = outlines[index] ?? emptyOutline;
+    const property = own[index]?.properties.get(selector ?? "");
+    return {
+      index,
+      problems: problems(),
+      selected: selectorValue !== void 0 && (named !== void 0 && isJsonRecord(schema) && definitionName(schema.$ref) === named || property !== void 0 && outlineOf(property, inspection).values !== void 0 && inspection.accepts(property, selectorValue.value)),
+      typed: accepted(outline, value),
+      overlap: overlap(outline, value, inspection)
     };
-    return [issue];
   });
+  const closest = ranked.reduce(
+    (best, candidate) => ([
+      Number(candidate.selected) - Number(best.selected),
+      Number(candidate.typed) - Number(best.typed),
+      candidate.overlap - best.overlap,
+      best.problems.length - candidate.problems.length
+    ].find((difference) => difference !== 0) ?? 0) > 0 ? candidate : best
+  );
+  return closest.selected || closest.typed ? [
+    {
+      path,
+      issue: `${expected}. Closest is alternative ${closest.index + 1}, whose problems follow`
+    },
+    ...closest.problems
+  ] : [{ path, issue: expected }];
+};
+var problemsOf = (errors, inspection) => {
+  const closed = /* @__PURE__ */ new Map();
+  const problems = [];
+  for (let index = 0; index < errors.length; index++) {
+    const error = errors[index];
+    if (error === void 0) break;
+    const { keyword, instanceLocation, keywordLocation } = error;
+    if (keyword === "anyOf" || keyword === "oneOf") {
+      const schemas = inspection.schemaAt(pointerSegments(keywordLocation));
+      const { alternatives, end } = alternativeErrors(errors, index, schemas);
+      problems.push(...unionProblems(error, schemas, alternatives, inspection));
+      index = end - 1;
+      continue;
+    }
+    const location2 = pointerSegments(instanceLocation);
+    const path = pathOf(location2);
+    const problem = (issue, at = path) => problems.push({ path: at, issue });
+    const node = () => inspection.schemaAt(pointerSegments(keywordLocation).slice(0, -1));
+    if (keyword === "additionalProperties" || keyword === "unevaluatedProperties") {
+      closed.set(locationKey(location2), node());
+      continue;
+    }
+    if (containerKeywords.has(keyword)) continue;
+    if (keyword === "false") {
+      const key = location2.at(-1);
+      const parent = locationKey(location2.slice(0, -1));
+      if (key === void 0 || !closed.has(parent)) problem("No value is allowed here");
+      else
+        problem(
+          `Unexpected key${echoableKey(key) ? ` "${key}"` : ""}. Expected ${jsonObjectShape(closed.get(parent))}`,
+          path.slice(0, -1)
+        );
+      continue;
+    }
+    const required = keyword === "required" ? /required property "([^"]*)"/.exec(error.error) : null;
+    if (required !== null) {
+      const name = required[1] ?? "";
+      const property = outlineOf(node(), inspection).properties.get(name);
+      problem(
+        missingKey(property === void 0 ? void 0 : describeProperty(property, inspection)),
+        [...path, name]
+      );
+      continue;
+    }
+    const expected = keyword === "type" ? /Expected "([^.]*)"\.?$/.exec(error.error) : null;
+    if (expected !== null) {
+      const types = (expected[1] ?? "").split('", "').map((type) => type === "object" ? jsonObjectShape(node()) : type);
+      problem(`Expected ${types.join(" or ")}`);
+      continue;
+    }
+    if (keyword === "const" || keyword === "enum") {
+      const schema = node();
+      const values = !isJsonRecord(schema) ? void 0 : keyword === "const" ? Object.hasOwn(schema, "const") ? [schema.const] : void 0 : Array.isArray(schema.enum) ? schema.enum : void 0;
+      problem(
+        values === void 0 ? "Expected one of the allowed values" : `Expected ${allowedValues(values)}`
+      );
+      continue;
+    }
+    problem(constraintProblem(keyword, node()) ?? `Failed the "${keyword}" constraint`);
+  }
+  return problems;
+};
+var documentKeys = (document) => {
+  const named = /* @__PURE__ */ new Set();
+  let any = false;
+  const visit = (node, depth) => {
+    if (depth > 64 || typeof node !== "object" || node === null) return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item, depth + 1);
+      return;
+    }
+    const record2 = node;
+    if (isJsonRecord(record2.properties))
+      for (const name of Object.keys(record2.properties)) named.add(name);
+    for (const name of strings(record2.required)) named.add(name);
+    if (isJsonRecord(record2.dependentRequired))
+      for (const [name, names] of Object.entries(record2.dependentRequired)) {
+        named.add(name);
+        for (const other of strings(names)) named.add(other);
+      }
+    if (isJsonRecord(record2.patternProperties) && Object.keys(record2.patternProperties).length > 0 || isJsonRecord(record2.additionalProperties) || isJsonRecord(record2.unevaluatedProperties))
+      any = true;
+    for (const value of Object.values(record2)) visit(value, depth + 1);
+  };
+  visit(document, 0);
+  return (key) => any || named.has(key);
+};
+var importedKeys = /* @__PURE__ */ new WeakMap();
+var importedSchemaKeys = (check) => importedKeys.get(check);
+var jsonSchemaProblems = (errors, inspection) => {
+  const problems = problemsOf(errors, inspection);
   return problems.length === 0 ? false : problems;
 };
 var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
@@ -1311,28 +1737,42 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
             throw new ValidationError();
         }
       }
+      const inspection = (input) => ({
+        schemaAt: (segments) => schemaAt(normalized, lookup, segments),
+        referenced: (node) => referenced(lookup, node),
+        accepts: (node, value) => {
+          if (typeof node !== "boolean" && !isJsonRecord(node)) return false;
+          try {
+            return validate(value, node, draft, lookup).valid;
+          } catch {
+            return false;
+          }
+        },
+        input
+      });
       return {
-        validate: (input) => validate(input, normalized, draft, lookup)
+        validate: (input) => validate(input, normalized, draft, lookup),
+        inspection
       };
     },
     catch: () => new ValidationError()
   });
-  const decoder = Schema_exports.Json.check(
-    Schema_exports.makeFilter(
-      (value) => {
-        try {
-          const result = validator.validate(value);
-          return result.valid || jsonSchemaProblems(result.errors);
-        } catch {
-          return false;
-        }
-      },
-      { expected: "a value matching a supported imported JSON Schema" }
-    )
+  const check = Schema_exports.makeFilter(
+    (value) => {
+      try {
+        const result = validator.validate(value);
+        return result.valid || jsonSchemaProblems(result.errors, validator.inspection(value));
+      } catch {
+        return false;
+      }
+    },
+    { expected: "a value matching a supported imported JSON Schema" }
   );
+  importedKeys.set(check, documentKeys(document));
+  const decoder = Schema_exports.Json.check(check);
   return Object.assign(decoder, { [ImportedJsonSchema]: document });
 });
-var lazyDecoder = (document) => {
+var lazyCompiledDecoder = (document) => {
   const read = once(document);
   let compiled;
   const compile = Effect_exports.suspend(
@@ -1352,9 +1792,11 @@ var lazyDecoder = (document) => {
       Effect_exports.flatMap((schema) => SchemaParser_exports.decodeUnknownEffect(schema)(input, options))
     )
   );
-  return withLazyJsonSchemaDocument(decoder, read);
+  return { decoder: withLazyJsonSchemaDocument(decoder, read), compile };
 };
+var lazyDecoder = (document) => lazyCompiledDecoder(document).decoder;
 var lazyJsonSchemaDecoder = (document) => Effect_exports.sync(() => lazyDecoder(document));
+var preparedJsonSchemaDecoder = (document) => lazyCompiledDecoder(() => document);
 var isJsonValue = Schema_exports.is(Schema_exports.Json);
 var jsonDocument = (input) => {
   if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
@@ -1384,13 +1826,21 @@ var jsonSchema = (input) => {
     false
   );
 };
-var storageFieldOf = (schema) => schema[StorageField];
-var id = (table) => wrap(Schema_exports.NonEmptyString, false, { kind: "id", references: table });
-var userId = () => wrap(Schema_exports.NonEmptyString, false, { kind: "userId" });
+var jsonSchemaDocument = (decoder) => {
+  const imported = importedJsonSchema(decoder);
+  if (imported !== void 0) return Schema_exports.decodeUnknownEffect(JsonObject)(imported);
+  const document = Schema_exports.toJsonSchemaDocument(decoder);
+  return Schema_exports.decodeUnknownEffect(JsonObject)({
+    ...document.schema,
+    $defs: document.definitions,
+    $schema: "https://json-schema.org/draft/2020-12/schema"
+  });
+};
 
 export {
   decoderOf,
   isSchema,
+  schemaArgument,
   parse,
   wrap,
   string,
@@ -1401,15 +1851,25 @@ export {
   literal,
   array,
   object,
+  plain,
+  raw,
+  fieldExposure,
   importedJsonSchema,
   once,
   withLazyJsonSchemaDocument,
   nestJsonSchema,
+  echoableKey,
+  objectShape,
+  allowedValues,
+  maxAlternativeKeys,
+  unionShape,
+  missingKey,
+  missingKeyText,
+  importedSchemaKeys,
   compileJsonSchemaDecoder,
   lazyJsonSchemaDecoder,
+  preparedJsonSchemaDecoder,
   jsonSchemaDecoder,
   jsonSchema,
-  storageFieldOf,
-  id,
-  userId
+  jsonSchemaDocument
 };