apps 0.0.1-beta.3 → 0.0.1-beta.31

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

@@ -1,6 +1,7 @@
 import {
+  JsonObject,
   ValidationError
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-FBBXFFFJ.js";
 import {
   Cause_exports,
   Effect_exports,
@@ -9,7 +10,7 @@ import {
   SchemaIssue_exports,
   SchemaParser_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.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) {
@@ -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);
@@ -1144,6 +1145,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 +1293,334 @@ 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 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 describeOutline = (outline) => {
+  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,
+    maxAlternativeKeys
+  );
+  if (outline.types === void 0)
+    return names.length > 0 || outline.closed ? shape : "a value with other constraints";
+  return [...outline.types].map((type) => type === "object" ? shape : type).join(" or ");
+};
+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 fixed = outlines.flatMap(({ values }) => values === void 0 ? [] : [values]);
+  if (fixed.length === outlines.length)
+    return [{ path, issue: `Expected ${allowedValues(fixed.flat())}` }];
+  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 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) {
+      problem("Missing key", [...path, required[1] ?? ""]);
+      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(`Failed the "${keyword}" constraint`);
+  }
+  return problems;
+};
+var jsonSchemaProblems = (errors, inspection) => {
+  const problems = problemsOf(errors, inspection);
   return problems.length === 0 ? false : problems;
 };
 var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
@@ -1311,8 +1647,22 @@ 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()
@@ -1322,7 +1672,7 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
       (value) => {
         try {
           const result = validator.validate(value);
-          return result.valid || jsonSchemaProblems(result.errors);
+          return result.valid || jsonSchemaProblems(result.errors, validator.inspection(value));
         } catch {
           return false;
         }
@@ -1332,7 +1682,7 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
   );
   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 +1702,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;
@@ -1387,6 +1739,16 @@ var jsonSchema = (input) => {
 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,
@@ -1401,15 +1763,25 @@ export {
   literal,
   array,
   object,
+  plain,
+  raw,
+  fieldExposure,
   importedJsonSchema,
   once,
   withLazyJsonSchemaDocument,
   nestJsonSchema,
+  echoableKey,
+  objectShape,
+  allowedValues,
+  maxAlternativeKeys,
+  unionShape,
   compileJsonSchemaDecoder,
   lazyJsonSchemaDecoder,
+  preparedJsonSchemaDecoder,
   jsonSchemaDecoder,
   jsonSchema,
   storageFieldOf,
   id,
-  userId
+  userId,
+  jsonSchemaDocument
 };