@hyperjump/json-schema 1.10.1 → 1.12.0

package/README.md

@@ -201,6 +201,9 @@ Schema, such as `@hyperjump/json-schema/draft-2020-12`.
 * **unregisterSchema**: (uri: string) => void
 
     Remove a schema from the local schema registry.
+* **getAllRegisteredSchemaUris**: () => string[]
+
+    This function returns the URIs of all registered schemas
 * **hasSchema**: (uri: string) => boolean
 
     Check if a schema with the given URI is already registered.
@@ -399,9 +402,9 @@ addKeyword({
     // );
   },
 
-  interpret: (implies, instance, ast, dynamicAnchors, quiet) => {
+  interpret: (implies, instance, context) => {
     return implies.reduce((valid, schema) => {
-      return !valid || Validation.interpret(schema, instance, ast, dynamicAnchors, quiet);
+      return !valid || Validation.interpret(schema, instance, context);
     }, true);
   }
 });
@@ -521,23 +524,40 @@ These are available from the `@hyperjump/json-schema/experimental` export.
           is needed for compiling sub-schemas. The `parentSchema` parameter is
           primarily useful for looking up the value of an adjacent keyword that
           might effect this one.
-      * interpret: (compiledKeywordValue: any, instance: JsonNode, ast: AST, dynamicAnchors: object, quiet: boolean, schemaLocation: string) => boolean
+      * interpret: (compiledKeywordValue: any, instance: JsonNode, context: ValidationContext) => boolean
 
           This function takes the value returned by the `compile` function and
           the instance value that is being validated and returns whether the
           value is valid or not. The other parameters are only needed for
           validating sub-schemas.
-      * collectEvaluatedProperties?: (compiledKeywordValue: any, instance: JsonNode, ast: AST, dynamicAnchors: object) => Set\<string> | false
+      * simpleApplicator?: boolean
+
+          Some applicator keywords just apply schemas and don't do any
+          validation of its own. In these cases, it isn't helpful to include
+          them in BASIC output. This flag is used to trim those nodes from the
+          output.
+      * collectEvaluatedProperties?: (compiledKeywordValue: any, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set\<string> | false
 
           If the keyword is an applicator, it will need to implement this
           function for `unevaluatedProperties` to work as expected.
-      * collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, ast: AST, dynamicAnchors: object) => Set\<number> | false
+      * collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set\<number> | false
 
           If the keyword is an applicator, it will need to implement this
           function for `unevaluatedItems` to work as expected.
       * collectExternalIds?: (visited: Set\<string>, parentSchema: Browser, schema: Browser) => Set\<string>
           If the keyword is an applicator, it will need to implement this
-      function to work properly with the [bundle](#bundling) feature.
+          function to work properly with the [bundle](#bundling) feature.
+      * annotation?: (compiledKeywordValue: any) => any
+
+          If the keyword is an annotation, it will need to implement this
+          function to return the annotation.
+
+    * **ValidationContext**: object
+      * ast: AST
+      * dynamicAnchors: object
+      * schemaUrl: string
+      * errors: OutputUnit[]
+      * annotations: OutputUnit[]
 * **defineVocabulary**: (id: string, keywords: { [keyword: string]: string }) => void
 
     Define a vocabulary that maps keyword name to keyword URIs defined using
@@ -680,7 +700,7 @@ Schema.
 
 ### Usage
 An annotated JSON document is represented as a
-(JsonNode)[#/instance-api-experimental] AST. You can use this AST to traverse
+(JsonNode)[#instance-api-experimental] AST. You can use this AST to traverse
 the data structure and get annotations for the values it represents.
 
 ```javascript

package/annotations/annotated-instance.d.ts

@@ -1,4 +1,3 @@
-export const setAnnotation: (keywordUri: string, schemaLocation: string, value: string) => void;
 export const annotation: <A>(instance: JsonNode, keyword: string, dialectUri?: string) => A[];
 export const annotatedWith: <A extends JsonNode>(instance: A, keyword: string, dialectUri?: string) => A[];
 

package/annotations/annotated-instance.js

@@ -5,13 +5,6 @@ import { getKeywordId } from "../lib/keywords.js";
 
 const defaultDialectId = "https://json-schema.org/validation";
 
-export const setAnnotation = (node, keywordUri, schemaLocation, value) => {
-  if (!(keywordUri in node.annotations)) {
-    node.annotations[keywordUri] = {};
-  }
-  node.annotations[keywordUri][schemaLocation] = value;
-};
-
 export const annotation = (node, keyword, dialect = defaultDialectId) => {
   const keywordUri = getKeywordId(keyword, dialect);
 

package/annotations/index.js

@@ -1,5 +1,7 @@
+import { FLAG } from "../lib/index.js";
 import { ValidationError } from "./validation-error.js";
-import { getSchema, compile, interpret as validate, BASIC } from "../lib/experimental.js";
+import { getSchema, compile, BASIC } from "../lib/experimental.js";
+import Validation from "../lib/keywords/validation.js";
 import * as Instance from "../lib/instance.js";
 
 
@@ -12,11 +14,25 @@ export const annotate = async (schemaUri, json = undefined, outputFormat = undef
 };
 
 export const interpret = ({ ast, schemaUri }, instance, outputFormat = BASIC) => {
-  const result = validate({ ast, schemaUri }, instance, outputFormat);
-  if (!result.valid) {
+  const errors = [];
+  const annotations = [];
+  const context = { ast, dynamicAnchors: {}, errors, annotations, outputFormat };
+  const valid = Validation.interpret(schemaUri, instance, context);
+
+  if (!valid) {
+    const result = outputFormat === FLAG || valid ? { valid } : { valid, errors };
     throw new ValidationError(result);
   }
 
+  for (const annotation of annotations) {
+    const node = Instance.get(annotation.instanceLocation, instance);
+    const keyword = annotation.keyword;
+    if (!node.annotations[keyword]) {
+      node.annotations[keyword] = [];
+    }
+    node.annotations[keyword].push(annotation.annotation);
+  }
+
   return instance;
 };
 

package/draft-04/additionalItems.js

@@ -14,7 +14,7 @@ const compile = async (schema, ast, parentSchema) => {
   return [numberOfItems, await Validation.compile(schema, ast)];
 };
 
-const interpret = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors, quiet) => {
+const interpret = ([numberOfItems, additionalItems], instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
@@ -22,12 +22,12 @@ const interpret = ([numberOfItems, additionalItems], instance, ast, dynamicAncho
   return pipe(
     Instance.iter(instance),
     drop(numberOfItems),
-    every((item) => Validation.interpret(additionalItems, item, ast, dynamicAnchors, quiet))
+    every((item) => Validation.interpret(additionalItems, item, context))
   );
 };
 
-const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  if (!interpret(keywordValue, instance, ast, dynamicAnchors, true)) {
+const collectEvaluatedItems = (keywordValue, instance, context) => {
+  if (!interpret(keywordValue, instance, context)) {
     return false;
   }
 

package/draft-04/dependencies.js

@@ -15,7 +15,7 @@ const compile = (schema, ast) => pipe(
   asyncCollectArray
 );
 
-const interpret = (dependencies, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (dependencies, instance, context) => {
   const value = Instance.value(instance);
 
   return Instance.typeOf(instance) !== "object" || dependencies.every(([propertyName, dependency]) => {
@@ -26,7 +26,7 @@ const interpret = (dependencies, instance, ast, dynamicAnchors, quiet) => {
     if (Array.isArray(dependency)) {
       return dependency.every((key) => key in value);
     } else {
-      return Validation.interpret(dependency, instance, ast, dynamicAnchors, quiet);
+      return Validation.interpret(dependency, instance, context);
     }
   });
 };

package/draft-04/items.js

@@ -18,24 +18,24 @@ const compile = (schema, ast) => {
   }
 };
 
-const interpret = (items, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (items, instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 
   if (typeof items === "string") {
-    return every((itemValue) => Validation.interpret(items, itemValue, ast, dynamicAnchors, quiet), Instance.iter(instance));
+    return every((itemValue) => Validation.interpret(items, itemValue, context), Instance.iter(instance));
   } else {
     return pipe(
       zip(items, Instance.iter(instance)),
       take(Instance.length(instance)),
-      every(([prefixItem, item]) => Validation.interpret(prefixItem, item, ast, dynamicAnchors, quiet))
+      every(([prefixItem, item]) => Validation.interpret(prefixItem, item, context))
     );
   }
 };
 
-const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
-  return interpret(items, instance, ast, dynamicAnchors, true) && (typeof items === "string"
+const collectEvaluatedItems = (items, instance, context) => {
+  return interpret(items, instance, context) && (typeof items === "string"
     ? collectSet(range(0, Instance.length(instance)))
     : collectSet(range(0, items.length)));
 };

package/draft-06/contains.js

@@ -7,8 +7,9 @@ const id = "https://json-schema.org/keyword/draft-06/contains";
 
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
-const interpret = (contains, instance, ast, dynamicAnchors, quiet) => {
-  return Instance.typeOf(instance) !== "array" || some((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet), Instance.iter(instance));
+const interpret = (contains, instance, context) => {
+  return Instance.typeOf(instance) !== "array"
+    || some((item) => Validation.interpret(contains, item, context), Instance.iter(instance));
 };
 
 export default { id, compile, interpret };

package/draft-2020-12/dynamicRef.js

@@ -12,12 +12,12 @@ const compile = async (dynamicRef, ast) => {
   return [referencedSchema.document.baseUri, fragment, canonicalUri(referencedSchema)];
 };
 
-const evaluate = (strategy, [id, fragment, ref], instance, ast, dynamicAnchors, quiet) => {
-  if (fragment in ast.metaData[id].dynamicAnchors) {
-    dynamicAnchors = { ...ast.metaData[id].dynamicAnchors, ...dynamicAnchors };
-    return strategy(dynamicAnchors[fragment], instance, ast, dynamicAnchors, quiet);
+const evaluate = (strategy, [id, fragment, ref], instance, context) => {
+  if (fragment in context.ast.metaData[id].dynamicAnchors) {
+    context.dynamicAnchors = { ...context.ast.metaData[id].dynamicAnchors, ...context.dynamicAnchors };
+    return strategy(context.dynamicAnchors[fragment], instance, context);
   } else {
-    return strategy(ref, instance, ast, dynamicAnchors, quiet);
+    return strategy(ref, instance, context);
   }
 };
 

package/lib/core.js

@@ -11,10 +11,9 @@ import { InvalidSchemaError } from "./invalid-schema-error.js";
 import { getSchema, registerSchema, unregisterSchema as schemaUnregister } from "./schema.js";
 import { getKeywordName } from "./keywords.js";
 import Validation from "./keywords/validation.js";
-import { toOutputFormat } from "./output.js";
 
 
-export const FLAG = "FLAG", BASIC = "BASIC";
+export const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED";
 setMetaSchemaOutputFormat(FLAG);
 
 export const validate = async (url, value = undefined, outputFormat = undefined) => {
@@ -32,8 +31,10 @@ export const compile = async (schema) => {
 };
 
 export const interpret = curry(({ ast, schemaUri }, instance, outputFormat = FLAG) => {
-  Validation.interpret(schemaUri, instance, ast, {});
-  return toOutputFormat(instance, outputFormat);
+  const errors = [];
+  const context = { ast, dynamicAnchors: {}, errors, annotations: [], outputFormat };
+  const valid = Validation.interpret(schemaUri, instance, context);
+  return outputFormat === FLAG || valid ? { valid } : { valid, errors };
 });
 
 const metaValidators = {};

package/lib/experimental.d.ts

@@ -32,6 +32,7 @@ type Anchors = Record<string, string>;
 
 // Output Formats
 export const BASIC: "BASIC";
+export const DETAILED: "DETAILED";
 
 // Schema
 export const getSchema: (uri: string, browser?: Browser) => Promise<Browser<SchemaDocument>>;
@@ -67,11 +68,19 @@ export const hasDialect: (dialectId: string) => boolean;
 export type Keyword<A> = {
   id: string;
   compile: (schema: Browser<SchemaDocument>, ast: AST, parentSchema: Browser<SchemaDocument>) => Promise<A>;
-  interpret: (compiledKeywordValue: A, instance: JsonNode, ast: AST, dynamicAnchors: Anchors, quiet: boolean, schemaLocation: string) => boolean;
-  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonNode, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<string> | false;
-  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<number> | false;
+  interpret: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext) => boolean;
+  simpleApplicator: boolean;
+  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set<string> | false;
+  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set<number> | false;
   collectExternalIds?: (visited: Set<string>, parentSchema: Browser<SchemaDocument>, schema: Browser<SchemaDocument>) => Promise<Set<string>>;
   annotation?: <B>(compiledKeywordValue: A) => B;
 };
 
+export type ValidationContext = {
+  ast: AST;
+  dynamicAnchors: Anchors;
+  errors: OutputUnit[];
+  annotations: OutputUnit[];
+};
+
 export const Validation: Keyword<string>;

package/lib/experimental.js

@@ -1,4 +1,4 @@
-export { compile, interpret, BASIC } from "./core.js";
+export { compile, interpret, BASIC, DETAILED } from "./core.js";
 export {
   addKeyword, getKeyword, getKeywordByName, getKeywordName, getKeywordId,
   defineVocabulary,

package/lib/index.d.ts

@@ -2,13 +2,14 @@ import type { Json } from "@hyperjump/json-pointer";
 
 
 export type SchemaFragment = string | number | boolean | null | SchemaObject | SchemaFragment[];
-export type SchemaObject = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+export type SchemaObject = {
   [keyword: string]: SchemaFragment;
 };
 
 export const registerSchema: (schema: SchemaObject | boolean, retrievalUri?: string, contextDialectId?: string) => void;
 export const unregisterSchema: (retrievalUri: string) => void;
 export const hasSchema: (uri: string) => boolean;
+export const getAllRegisteredSchemaUris: () => string[];
 
 /**
  * @deprecated since 1.7.0. Use registerSchema instead.
@@ -28,6 +29,7 @@ export type OutputUnit = {
   absoluteKeywordLocation: string;
   instanceLocation: string;
   valid: boolean;
+  annotation?: unknown;
   errors?: OutputUnit[];
 };
 

package/lib/index.js

@@ -130,7 +130,7 @@ addKeyword(vocabulary);
 addKeyword(writeOnly);
 
 export { addSchema, unregisterSchema, validate, FLAG } from "./core.js";
-export { registerSchema, hasSchema } from "./schema.js";
+export { registerSchema, hasSchema, getAllRegisteredSchemaUris } from "./schema.js";
 export {
   getMetaSchemaOutputFormat,
   setMetaSchemaOutputFormat,

package/lib/instance.d.ts

@@ -32,8 +32,6 @@ export type JsonNode = {
   children: JsonNode[];
   parent?: JsonNode;
   root: JsonNode;
-  valid: boolean;
-  errors: Record<string, string>;
   annotations: Record<string, Record<string, unknown>>;
 };
 

package/lib/instance.js

@@ -49,8 +49,6 @@ export const cons = (baseUri, pointer, value, type, children, parent) => {
     type: type,
     children: children,
     parent: parent,
-    valid: true,
-    errors: {},
     annotations: {}
   };
   node.root = parent?.root ?? node;

package/lib/keywords/additionalProperties.js

@@ -31,7 +31,7 @@ const regexEscape = (string) => string
   .replace(/[|\\{}()[\]^$+*?.]/g, "\\$&")
   .replace(/-/g, "\\x2d");
 
-const interpret = ([isDefinedProperty, additionalProperties], instance, ast, dynamicAnchors, quiet) => {
+const interpret = ([isDefinedProperty, additionalProperties], instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
@@ -39,7 +39,7 @@ const interpret = ([isDefinedProperty, additionalProperties], instance, ast, dyn
   let isValid = true;
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
-    if (!isDefinedProperty.test(propertyName) && !Validation.interpret(additionalProperties, property, ast, dynamicAnchors, quiet)) {
+    if (!isDefinedProperty.test(propertyName) && !Validation.interpret(additionalProperties, property, context)) {
       isValid = false;
     }
   }
@@ -47,7 +47,9 @@ const interpret = ([isDefinedProperty, additionalProperties], instance, ast, dyn
   return isValid;
 };
 
-const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], instance, ast, dynamicAnchors) => {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
@@ -56,7 +58,7 @@ const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], i
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
     if (!isDefinedProperty.test(propertyName)) {
-      if (!Validation.interpret(additionalProperties, property, ast, dynamicAnchors, true)) {
+      if (!Validation.interpret(additionalProperties, property, context)) {
         return false;
       }
 
@@ -67,4 +69,4 @@ const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], i
   return evaluatedPropertyNames;
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };

package/lib/keywords/allOf.js

@@ -21,10 +21,12 @@ const interpret = (allOf, instance, ast, dynamicAnchors, quiet) => {
   return isValid;
 };
 
-const collectEvaluatedProperties = (allOf, instance, ast, dynamicAnchors) => {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = (allOf, instance, context) => {
   const evaluatedPropertyNames = new Set();
   for (const schemaUrl of allOf) {
-    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, context);
     if (!propertyNames) {
       return false;
     }
@@ -35,10 +37,10 @@ const collectEvaluatedProperties = (allOf, instance, ast, dynamicAnchors) => {
   return evaluatedPropertyNames;
 };
 
-const collectEvaluatedItems = (allOf, instance, ast, dynamicAnchors) => {
+const collectEvaluatedItems = (allOf, instance, context) => {
   const evaluatedItemIndexes = new Set();
   for (const schemaUrl of allOf) {
-    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, context);
     if (!itemIndexes) {
       return false;
     }
@@ -49,4 +51,4 @@ const collectEvaluatedItems = (allOf, instance, ast, dynamicAnchors) => {
   return evaluatedItemIndexes;
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/anyOf.js

@@ -16,10 +16,10 @@ const interpret = (anyOf, instance, ast, dynamicAnchors, quiet) => {
   return matches.length > 0;
 };
 
-const collectEvaluatedProperties = (anyOf, instance, ast, dynamicAnchors) => {
+const collectEvaluatedProperties = (anyOf, instance, context) => {
   let evaluatedPropertyNames = false;
   for (const schemaUrl of anyOf) {
-    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, context);
     if (propertyNames) {
       evaluatedPropertyNames ||= new Set();
       propertyNames.forEach(evaluatedPropertyNames.add, evaluatedPropertyNames);
@@ -29,10 +29,10 @@ const collectEvaluatedProperties = (anyOf, instance, ast, dynamicAnchors) => {
   return evaluatedPropertyNames;
 };
 
-const collectEvaluatedItems = (anyOf, instance, ast, dynamicAnchors) => {
+const collectEvaluatedItems = (anyOf, instance, context) => {
   let evaluatedItemIndexes = false;
   for (const schemaUrl of anyOf) {
-    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, context);
     if (itemIndexes) {
       evaluatedItemIndexes ||= new Set();
       itemIndexes.forEach(evaluatedItemIndexes.add, evaluatedItemIndexes);

package/lib/keywords/conditional.js

@@ -12,39 +12,39 @@ const compile = (schema, ast) => pipe(
   asyncCollectArray
 );
 
-const interpret = (conditional, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (conditional, instance, context) => {
   for (let index = 0; index < conditional.length; index += 2) {
-    const isValid = Validation.interpret(conditional[index], instance, ast, dynamicAnchors, quiet);
+    const isValid = Validation.interpret(conditional[index], instance, context);
     if (index + 1 === conditional.length) {
       return isValid;
     } else if (isValid) {
-      return Validation.interpret(conditional[index + 1], instance, ast, dynamicAnchors, quiet);
+      return Validation.interpret(conditional[index + 1], instance, context);
     }
   }
 
   return true;
 };
 
-const collectEvaluatedProperties = (conditional, instance, ast, dynamicAnchors) => {
+const collectEvaluatedProperties = (conditional, instance, context) => {
   for (let index = 0; index < conditional.length; index += 2) {
-    const unevaluatedProperties = Validation.collectEvaluatedProperties(conditional[index], instance, ast, dynamicAnchors);
+    const unevaluatedProperties = Validation.collectEvaluatedProperties(conditional[index], instance, context);
     if (index + 1 === conditional.length) {
       return unevaluatedProperties;
     } else if (unevaluatedProperties !== false) {
-      return Validation.collectEvaluatedProperties(conditional[index + 1], instance, ast, dynamicAnchors);
+      return Validation.collectEvaluatedProperties(conditional[index + 1], instance, context);
     }
   }
 
   return new Set();
 };
 
-const collectEvaluatedItems = (conditional, instance, ast, dynamicAnchors) => {
+const collectEvaluatedItems = (conditional, instance, context) => {
   for (let index = 0; index < conditional.length; index += 2) {
-    const unevaluatedItems = Validation.collectEvaluatedItems(conditional[index], instance, ast, dynamicAnchors);
+    const unevaluatedItems = Validation.collectEvaluatedItems(conditional[index], instance, context);
     if (index + 1 === conditional.length) {
       return unevaluatedItems;
     } else if (unevaluatedItems !== false) {
-      return Validation.collectEvaluatedItems(conditional[index + 1], instance, ast, dynamicAnchors);
+      return Validation.collectEvaluatedItems(conditional[index + 1], instance, context);
     }
   }
 

package/lib/keywords/contains.js

@@ -20,21 +20,21 @@ const compile = async (schema, ast, parentSchema) => {
   return { contains, minContains, maxContains };
 };
 
-const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors, quiet) => {
+const interpret = ({ contains, minContains, maxContains }, instance, context) => {
   const matches = Instance.typeOf(instance) !== "array" || pipe(
     Instance.iter(instance),
-    filter((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet)),
+    filter((item) => Validation.interpret(contains, item, context)),
     reduce((matches) => matches + 1, 0)
   );
   return matches >= minContains && matches <= maxContains;
 };
 
-const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors, true)
+const collectEvaluatedItems = (keywordValue, instance, context) => {
+  return interpret(keywordValue, instance, context)
     && Instance.typeOf(instance) === "array"
     && pipe(
       zip(Instance.iter(instance), range(0)),
-      filter(([item]) => Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)),
+      filter(([item]) => Validation.interpret(keywordValue.contains, item, context)),
       map(([, itemIndex]) => itemIndex),
       collectSet
     );

package/lib/keywords/contentEncoding.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../../annotations/annotated-instance.js";
 
 
 const id = "https://json-schema.org/keyword/contentEncoding";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (contentEncoding) => contentEncoding;
 
-const interpret = (contentEncoding, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, contentEncoding);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/contentMediaType.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../../annotations/annotated-instance.js";
 
 
 const id = "https://json-schema.org/keyword/contentMediaType";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (contentMediaType) => contentMediaType;
 
-const interpret = (contentMediaType, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, contentMediaType);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/contentSchema.js

@@ -1,14 +1,10 @@
 import { canonicalUri } from "../schema.js";
-import * as Instance from "../../annotations/annotated-instance.js";
 
 
 const id = "https://json-schema.org/keyword/contentSchema";
 
 const compile = (contentSchema) => canonicalUri(contentSchema);
+const interpret = () => true;
+const annotation = (contentSchema) => contentSchema;
 
-const interpret = (contentSchema, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, contentSchema);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/default.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../../annotations/annotated-instance.js";
 
 
 const id = "https://json-schema.org/keyword/default";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (value) => value;
 
-const interpret = (value, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, value);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };