@hyperjump/json-schema 1.11.0 → 1.12.0

package/lib/keywords/deprecated.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/deprecated";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (deprecated) => deprecated;
 
-const interpret = (deprecated, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, deprecated);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/description.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/description";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (description) => description;
 
-const interpret = (description, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, description);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/dynamicRef.js

@@ -12,15 +12,17 @@ const compile = async (schema, ast) => {
   return reference;
 };
 
-const evaluate = (strategy, fragment, instance, ast, dynamicAnchors, quiet) => {
-  if (!(fragment in dynamicAnchors)) {
+const evaluate = (strategy, fragment, instance, context) => {
+  if (!(fragment in context.dynamicAnchors)) {
     throw Error(`No dynamic anchor found for "${fragment}"`);
   }
-  return strategy(dynamicAnchors[fragment], instance, ast, dynamicAnchors, quiet);
+  return strategy(context.dynamicAnchors[fragment], instance, context);
 };
 
+const simpleApplicator = true;
+
 const interpret = (...args) => evaluate(Validation.interpret, ...args);
 const collectEvaluatedProperties = (...args) => evaluate(Validation.collectEvaluatedProperties, ...args);
 const collectEvaluatedItems = (...args) => evaluate(Validation.collectEvaluatedItems, ...args);
 
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/else.js

@@ -1,4 +1,5 @@
 import * as Browser from "@hyperjump/browser";
+import { FLAG } from "../index.js";
 import { getKeywordName, Validation } from "../experimental.js";
 
 
@@ -14,26 +15,28 @@ const compile = async (schema, ast, parentSchema) => {
   }
 };
 
-const interpret = ([ifSchema, elseSchema], instance, ast, dynamicAnchors, quiet) => {
+const interpret = ([ifSchema, elseSchema], instance, context) => {
   return ifSchema === undefined
-    || Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)
-    || Validation.interpret(elseSchema, instance, ast, dynamicAnchors, quiet);
+    || Validation.interpret(ifSchema, instance, { ...context, errors: [], annotations: [], oututFormat: FLAG })
+    || Validation.interpret(elseSchema, instance, context);
 };
 
-const collectEvaluatedProperties = ([ifSchema, elseSchema], instance, ast, dynamicAnchors) => {
-  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = ([ifSchema, elseSchema], instance, context) => {
+  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, context)) {
     return new Set();
   }
 
-  return Validation.collectEvaluatedProperties(elseSchema, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedProperties(elseSchema, instance, context);
 };
 
-const collectEvaluatedItems = ([ifSchema, elseSchema], instance, ast, dynamicAnchors) => {
-  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
+const collectEvaluatedItems = ([ifSchema, elseSchema], instance, context) => {
+  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, context)) {
     return new Set();
   }
 
-  return Validation.collectEvaluatedItems(elseSchema, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedItems(elseSchema, instance, context);
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/examples.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/examples";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (examples) => examples;
 
-const interpret = (examples, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, examples);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/format.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/format";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (format) => format;
 
-const interpret = (format, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, format);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/if.js

@@ -5,17 +5,17 @@ const id = "https://json-schema.org/keyword/if";
 
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
-const interpret = (ifSchema, instance, ast, dynamicAnchors) => {
-  Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true);
+const interpret = (ifSchema, instance, context) => {
+  Validation.interpret(ifSchema, instance, context);
   return true;
 };
 
-const collectEvaluatedProperties = (ifSchema, instance, ast, dynamicAnchors) => {
-  return Validation.collectEvaluatedProperties(ifSchema, instance, ast, dynamicAnchors) || [];
+const collectEvaluatedProperties = (ifSchema, instance, context) => {
+  return Validation.collectEvaluatedProperties(ifSchema, instance, context) || new Set();
 };
 
-const collectEvaluatedItems = (ifSchema, instance, ast, dynamicAnchors) => {
-  return Validation.collectEvaluatedItems(ifSchema, instance, ast, dynamicAnchors) || new Set();
+const collectEvaluatedItems = (ifSchema, instance, context) => {
+  return Validation.collectEvaluatedItems(ifSchema, instance, context) || new Set();
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/itemPattern.js

@@ -39,7 +39,7 @@ const compile = async (schema, ast) => {
     .reduce(union);
 };
 
-const evaluate = (strategy) => (nfa, instance, ast, dynamicAnchors, quiet) => {
+const evaluate = (strategy, nfa, instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
@@ -51,7 +51,7 @@ const evaluate = (strategy) => (nfa, instance, ast, dynamicAnchors, quiet) => {
     const nextStates = [];
 
     for (const state of currentStates) {
-      const nextState = transition(strategy, state.transition, item, ast, dynamicAnchors, quiet);
+      const nextState = transition(strategy, state.transition, item, context);
       if (nextState) {
         addNextState(nextState, nextStates, []);
       }
@@ -76,16 +76,16 @@ const addNextState = (state, nextStates, visited) => {
   }
 };
 
-const transition = (strategy, transitions, instance, ast, dynamicAnchors, quiet) => {
+const transition = (strategy, transitions, instance, context) => {
   for (const schema in transitions) {
-    if (strategy(schema, instance, ast, dynamicAnchors, quiet)) {
+    if (strategy(schema, instance, context)) {
       return transitions[schema];
     }
   }
 };
 
-const interpret = evaluate(Validation.interpret);
-const collectEvalatedProperties = evaluate(Validation.collectEvaluatedProperties);
-const collectEvalatedItems = evaluate(Validation.collectEvaluatedItems);
+const interpret = (...args) => evaluate(Validation.interpret, ...args);
+const collectEvalatedProperties = (...args) => evaluate(Validation.collectEvaluatedProperties, ...args);
+const collectEvalatedItems = (...args) => evaluate(Validation.collectEvaluatedItems, ...args);
 
 export default { id, compile, interpret, collectEvalatedProperties, collectEvalatedItems };

package/lib/keywords/items.js

@@ -14,14 +14,14 @@ const compile = async (schema, ast, parentSchema) => {
   return [numberOfPrefixItems, await Validation.compile(schema, ast)];
 };
 
-const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors, quiet) => {
+const interpret = ([numberOfPrefixItems, items], instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 
   let isValid = true;
   for (const item of drop(numberOfPrefixItems, Instance.iter(instance))) {
-    if (!Validation.interpret(items, item, ast, dynamicAnchors, quiet)) {
+    if (!Validation.interpret(items, item, context)) {
       isValid = false;
     }
   }
@@ -29,8 +29,10 @@ const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors,
   return isValid;
 };
 
-const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  if (!interpret(keywordValue, instance, ast, dynamicAnchors, true)) {
+const simpleApplicator = true;
+
+const collectEvaluatedItems = (keywordValue, instance, context) => {
+  if (!interpret(keywordValue, instance, context)) {
     return false;
   }
 
@@ -42,4 +44,4 @@ const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
   return evaluatedIndexes;
 };
 
-export default { id, compile, interpret, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };

package/lib/keywords/oneOf.js

@@ -11,10 +11,10 @@ const compile = (schema, ast) => pipe(
   asyncCollectArray
 );
 
-const interpret = (oneOf, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (oneOf, instance, context) => {
   let validCount = 0;
   for (const schemaUrl of oneOf) {
-    if (Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet)) {
+    if (Validation.interpret(schemaUrl, instance, context)) {
       validCount++;
     }
   }
@@ -22,10 +22,10 @@ const interpret = (oneOf, instance, ast, dynamicAnchors, quiet) => {
   return validCount === 1;
 };
 
-const collectEvaluatedProperties = (oneOf, instance, ast, dynamicAnchors) => {
+const collectEvaluatedProperties = (oneOf, instance, context) => {
   let evaluatedProperties = false;
   for (const schemaUrl of oneOf) {
-    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, context);
     if (propertyNames) {
       if (evaluatedProperties) {
         return false;
@@ -38,10 +38,10 @@ const collectEvaluatedProperties = (oneOf, instance, ast, dynamicAnchors) => {
   return evaluatedProperties;
 };
 
-const collectEvaluatedItems = (oneOf, instance, ast, dynamicAnchors) => {
+const collectEvaluatedItems = (oneOf, instance, context) => {
   let evaluatedItemIndexes = false;
   for (const schemaUrl of oneOf) {
-    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, context);
     if (itemIndexes) {
       if (evaluatedItemIndexes) {
         return false;

package/lib/keywords/patternProperties.js

@@ -15,7 +15,7 @@ const compile = (schema, ast) => pipe(
   asyncCollectArray
 );
 
-const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (patternProperties, instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
@@ -24,7 +24,7 @@ const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
   for (const [pattern, schemaUri] of patternProperties) {
     for (const [propertyNameNode, propertyValue] of Instance.entries(instance)) {
       const propertyName = Instance.value(propertyNameNode);
-      if (pattern.test(propertyName) && !Validation.interpret(schemaUri, propertyValue, ast, dynamicAnchors, quiet)) {
+      if (pattern.test(propertyName) && !Validation.interpret(schemaUri, propertyValue, context)) {
         isValid = false;
       }
     }
@@ -33,7 +33,9 @@ const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
   return isValid;
 };
 
-const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnchors) => {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = (patternProperties, instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return false;
   }
@@ -43,7 +45,7 @@ const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnc
     for (const [propertyNameNode, property] of Instance.entries(instance)) {
       const propertyName = Instance.value(propertyNameNode);
       if (pattern.test(propertyName)) {
-        if (!Validation.interpret(propertySchema, property, ast, dynamicAnchors, true)) {
+        if (!Validation.interpret(propertySchema, property, context)) {
           return false;
         }
 
@@ -55,4 +57,4 @@ const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnc
   return evaluatedPropertyNames;
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };

package/lib/keywords/prefixItems.js

@@ -12,7 +12,7 @@ const compile = (schema, ast) => pipe(
   asyncCollectArray
 );
 
-const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (prefixItems, instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
@@ -25,7 +25,7 @@ const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
       break;
     }
 
-    if (!Validation.interpret(schemaUri, item, ast, dynamicAnchors, quiet)) {
+    if (!Validation.interpret(schemaUri, item, context)) {
       isValid = false;
     }
 
@@ -35,8 +35,10 @@ const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
   return isValid;
 };
 
-const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
-  return interpret(items, instance, ast, dynamicAnchors, true) && new Set(items.map((_item, ndx) => ndx));
+const simpleApplicator = true;
+
+const collectEvaluatedItems = (items, instance, context) => {
+  return interpret(items, instance, context) && new Set(items.map((_item, ndx) => ndx));
 };
 
-export default { id, compile, interpret, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };

package/lib/keywords/properties.js

@@ -12,7 +12,7 @@ const compile = (schema, ast) => pipe(
   asyncCollectObject
 );
 
-const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (properties, instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
@@ -20,7 +20,7 @@ const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
   let isValid = true;
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
-    if (propertyName in properties && !Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, quiet)) {
+    if (propertyName in properties && !Validation.interpret(properties[propertyName], property, context)) {
       isValid = false;
     }
   }
@@ -28,7 +28,9 @@ const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
   return isValid;
 };
 
-const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) => {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = (properties, instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return false;
   }
@@ -37,7 +39,7 @@ const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) =
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
     if (propertyName in properties) {
-      if (!Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, true)) {
+      if (!Validation.interpret(properties[propertyName], property, context)) {
         return false;
       }
 
@@ -48,4 +50,4 @@ const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) =
   return evaluatedPropertyNames;
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };

package/lib/keywords/propertyDependencies.js

@@ -20,7 +20,7 @@ const compile = (schema, ast) => {
   );
 };
 
-const interpret = (propertyDependencies, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (propertyDependencies, instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
@@ -32,7 +32,7 @@ const interpret = (propertyDependencies, instance, ast, dynamicAnchors, quiet) =
     if (
       Instance.has(propertyName, instance)
       && propertyValue in valueMappings
-      && !Validation.interpret(valueMappings[propertyValue], instance, ast, dynamicAnchors, quiet)
+      && !Validation.interpret(valueMappings[propertyValue], instance, context)
     ) {
       isValid = false;
     }
@@ -41,14 +41,16 @@ const interpret = (propertyDependencies, instance, ast, dynamicAnchors, quiet) =
   return isValid;
 };
 
-const collectEvaluatedProperties = (propertyDependencies, instance, ast, dynamicAnchors) => {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = (propertyDependencies, instance, context) => {
   const evaluatedPropertyNames = new Set();
   for (const propertyName in propertyDependencies) {
     const propertyValue = Instance.value(instance)[propertyName];
 
     const valueMappings = propertyDependencies[propertyName];
     if (Instance.has(propertyName, instance) && propertyValue in valueMappings) {
-      const propertyNames = Validation.collectEvaluatedProperties(valueMappings[propertyValue], instance, ast, dynamicAnchors);
+      const propertyNames = Validation.collectEvaluatedProperties(valueMappings[propertyValue], instance, context);
       if (!propertyNames) {
         return false;
       }
@@ -60,4 +62,4 @@ const collectEvaluatedProperties = (propertyDependencies, instance, ast, dynamic
   return evaluatedPropertyNames;
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };

package/lib/keywords/propertyNames.js

@@ -6,14 +6,14 @@ const id = "https://json-schema.org/keyword/propertyNames";
 
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
-const interpret = (propertyNames, instance, ast, dynamicAnchors) => {
+const interpret = (propertyNames, instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 
   let isValid = true;
   for (const key of Instance.keys(instance)) {
-    if (!Validation.interpret(propertyNames, key, ast, dynamicAnchors, true)) {
+    if (!Validation.interpret(propertyNames, key, { ...context, annotations: [] })) {
       isValid = false;
     }
   }
@@ -21,4 +21,6 @@ const interpret = (propertyNames, instance, ast, dynamicAnchors) => {
   return isValid;
 };
 
-export default { id, compile, interpret };
+const simpleApplicator = true;
+
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/readOnly.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/readOnly";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (readOnly) => readOnly;
 
-const interpret = (readOnly, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, readOnly);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/ref.js

@@ -8,4 +8,6 @@ const interpret = (...args) => Validation.interpret(...args);
 const collectEvaluatedProperties = (...args) => Validation.collectEvaluatedProperties(...args);
 const collectEvaluatedItems = (...args) => Validation.collectEvaluatedItems(...args);
 
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+const simpleApplicator = true;
+
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/then.js

@@ -1,6 +1,6 @@
 import * as Browser from "@hyperjump/browser";
-import { getKeywordName } from "../keywords.js";
-import { Validation } from "../experimental.js";
+import { FLAG } from "../index.js";
+import { getKeywordName, Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/then";
@@ -15,26 +15,28 @@ const compile = async (schema, ast, parentSchema) => {
   }
 };
 
-const interpret = ([ifSchema, thenSchema], instance, ast, dynamicAnchors, quiet) => {
+const interpret = ([ifSchema, thenSchema], instance, context) => {
   return ifSchema === undefined
-    || !Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)
-    || Validation.interpret(thenSchema, instance, ast, dynamicAnchors, quiet);
+    || !Validation.interpret(ifSchema, instance, { ...context, errors: [], annotations: [], outputFormat: FLAG })
+    || Validation.interpret(thenSchema, instance, context);
 };
 
-const collectEvaluatedProperties = ([ifSchema, thenSchema], instance, ast, dynamicAnchors) => {
-  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = ([ifSchema, thenSchema], instance, context) => {
+  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, context)) {
     return new Set();
   }
 
-  return Validation.collectEvaluatedProperties(thenSchema, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedProperties(thenSchema, instance, context);
 };
 
-const collectEvaluatedItems = ([ifSchema, thenSchema], instance, ast, dynamicAnchors) => {
-  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
+const collectEvaluatedItems = ([ifSchema, thenSchema], instance, context) => {
+  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, context)) {
     return new Set();
   }
 
-  return Validation.collectEvaluatedItems(thenSchema, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedItems(thenSchema, instance, context);
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/title.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/title";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (title) => title;
 
-const interpret = (title, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, title);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/unevaluatedItems.js

@@ -1,7 +1,7 @@
 import { zip, range } from "@hyperjump/pact";
+import { FLAG } from "../index.js";
+import { canonicalUri, Validation } from "../experimental.js";
 import * as Instance from "../instance.js";
-import { canonicalUri } from "../schema.js";
-import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/unevaluatedItems";
@@ -10,19 +10,20 @@ const compile = async (schema, ast, parentSchema) => {
   return [canonicalUri(parentSchema), await Validation.compile(schema, ast)];
 };
 
-const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors, quiet) => {
+const interpret = ([schemaUrl, unevaluatedItems], instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 
-  const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors, true);
+  const keywordContext = { ...context, errors: [], annotations: [], outputFormat: FLAG };
+  const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, keywordContext, true);
   if (itemIndexes === false) {
     return true;
   }
 
   let isValid = true;
   for (const [item, index] of zip(Instance.iter(instance), range(0))) {
-    if (!itemIndexes.has(index) && !Validation.interpret(unevaluatedItems, item, ast, dynamicAnchors, quiet)) {
+    if (!itemIndexes.has(index) && !Validation.interpret(unevaluatedItems, item, context)) {
       isValid = false;
     }
   }
@@ -30,8 +31,10 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors,
   return isValid;
 };
 
-const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  const itemIndexes = Validation.collectEvaluatedItems(keywordValue[0], instance, ast, dynamicAnchors, true);
+const simpleApplicator = true;
+
+const collectEvaluatedItems = (keywordValue, instance, context) => {
+  const itemIndexes = Validation.collectEvaluatedItems(keywordValue[0], instance, context, true);
   if (!itemIndexes) {
     return false;
   }
@@ -45,4 +48,4 @@ const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
   return evaluatedIndexes;
 };
 
-export default { id, compile, interpret, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };