@hyperjump/json-schema 1.6.7 → 1.7.0

package/annotations/annotated-instance.js

@@ -1,4 +1,4 @@
-import { toAbsoluteUri } from "../lib/common.js";
+import { toAbsoluteIri } from "@hyperjump/uri";
 import { nil as nilInstance, get } from "../lib/instance.js";
 import { getKeywordId } from "../lib/keywords.js";
 
@@ -8,13 +8,13 @@ const defaultDialectId = "https://json-schema.org/validation";
 export const nil = { ...nilInstance, annotations: {} };
 export const cons = (instance, id = undefined) => ({
   ...nil,
-  id: id ? toAbsoluteUri(id) : "",
+  id: id ? toAbsoluteIri(id) : "",
   instance,
   value: instance
 });
 
 export const annotation = (instance, keyword, dialectId = defaultDialectId) => {
-  const keywordId = getKeywordId(dialectId, keyword);
+  const keywordId = getKeywordId(keyword, dialectId);
   return instance.annotations[instance.pointer]?.[keywordId] || [];
 };
 

package/annotations/index.d.ts

@@ -1,4 +1,4 @@
-import type { OutputFormat } from "../lib/core.js";
+import type { OutputFormat, OutputUnit } from "../lib/index.js";
 import type { AnnotatedJsonDocument } from "./annotated-instance.js";
 
 
@@ -9,3 +9,9 @@ export const annotate: (
 );
 
 export type Annotator = (value: unknown, outputFormat?: OutputFormat) => AnnotatedJsonDocument;
+
+export class ValidationError extends Error {
+  public output: OutputUnit;
+
+  public constructor(output: OutputUnit);
+}

package/annotations/index.js

@@ -1,13 +1,13 @@
 import { subscribe, unsubscribe } from "../lib/pubsub.js";
-import { compile, interpret as validate, BASIC } from "../lib/core.js";
-import { getKeyword } from "../lib/keywords.js";
 import * as Instance from "./annotated-instance.js";
 import { ValidationError } from "./validation-error.js";
+import { getSchema, getKeyword, compile, interpret as validate, BASIC } from "../lib/experimental.js";
 
 
 export const annotate = async (schemaUri, json = undefined, outputFormat = undefined) => {
   loadKeywordSupport();
-  const compiled = await compile(schemaUri);
+  const schema = await getSchema(schemaUri);
+  const compiled = await compile(schema);
   const interpretAst = (json, outputFormat) => interpret(compiled, Instance.cons(json), outputFormat);
 
   return json === undefined ? interpretAst : interpretAst(json, outputFormat);

package/bundle/index.d.ts

@@ -1,18 +1,14 @@
-import type { SchemaObject } from "../lib/schema.js";
+import type { SchemaObject } from "../lib/index.js";
 
 
 export const bundle: <A = SchemaObject>(uri: string, options?: BundleOptions) => Promise<A>;
-export const FULL: "full";
-export const FLAT: "flat";
 export const URI: "uri";
 export const UUID: "uuid";
 
 export type BundleOptions = {
   alwaysIncludeDialect?: boolean;
-  bundleMode?: BundleMode;
   definitionNamingStrategy?: DefinitionNamingStrategy;
   externalSchemas?: string[];
 };
 
-export type BundleMode = "full" | "flat";
 export type DefinitionNamingStrategy = "uri" | "uuid";

package/bundle/index.js

@@ -1,18 +1,20 @@
+import curry from "just-curry-it";
 import { v4 as uuid } from "uuid";
+import * as Browser from "@hyperjump/browser";
 import * as JsonPointer from "@hyperjump/json-pointer";
-import { toAbsoluteUri } from "../lib/common.js";
-import { compile } from "../lib/core.js";
-import { getKeywordName, getKeyword } from "../lib/keywords.js";
-import Validation from "../lib/keywords/validation.js";
-import * as Schema from "../lib/schema.js";
+import { asyncCollectSet, asyncFilter, asyncFlatten, asyncMap, pipe } from "@hyperjump/pact";
+import { resolveUri } from "@hyperjump/uri";
+import {
+  Validation,
+  canonicalUri, getSchema, toSchema,
+  getKeywordName, getKeyword, getKeywordByName
+} from "../lib/experimental.js";
 
 
-export const FULL = "full", FLAT = "flat";
 export const URI = "uri", UUID = "uuid";
 
 const defaultOptions = {
   alwaysIncludeDialect: false,
-  bundleMode: FLAT,
   definitionNamingStrategy: URI,
   externalSchemas: []
 };
@@ -21,30 +23,35 @@ export const bundle = async (url, options = {}) => {
   loadKeywordSupport();
   const fullOptions = { ...defaultOptions, ...options };
 
-  const schemaDoc = await Schema.get(url);
-  const externalIds = await collectExternalIds(url, fullOptions);
+  const mainSchema = await getSchema(url);
+  const contextUri = mainSchema.document.baseUri;
+  const contextDialectId = mainSchema.document.dialectId;
+  const bundled = toSchema(mainSchema);
 
-  const bundled = Schema.toSchema(schemaDoc, {
-    includeEmbedded: fullOptions.bundleMode === FULL
-  });
+  const externalIds = await Validation.collectExternalIds(new Set(), mainSchema, mainSchema);
 
-  const bundlingLocation = "/" + getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/definitions");
+  // Bundle
+  const bundlingLocation = "/" + getKeywordName(contextDialectId, "https://json-schema.org/keyword/definitions");
   if (JsonPointer.get(bundlingLocation, bundled) === undefined && externalIds.size > 0) {
     JsonPointer.assign(bundlingLocation, bundled, {});
   }
 
-  for (const uri of externalIds.values()) {
-    const externalSchema = await Schema.get(uri);
-    const embeddedSchema = Schema.toSchema(externalSchema, {
-      parentId: schemaDoc.id,
-      parentDialect: fullOptions.alwaysIncludeDialect ? "" : schemaDoc.dialectId,
-      includeEmbedded: fullOptions.bundleMode === FULL
+  for (const uri of externalIds) {
+    const externalSchema = await getSchema(uri);
+    const embeddedSchema = toSchema(externalSchema, {
+      selfIdentify: true,
+      contextUri: contextUri,
+      includeDialect: fullOptions.alwaysIncludeDialect ? "always" : "auto",
+      contextDialectId: contextDialectId
     });
     let id;
     if (fullOptions.definitionNamingStrategy === URI) {
-      const idToken = getKeywordName(externalSchema.dialectId, "https://json-schema.org/keyword/id")
-        || getKeywordName(externalSchema.dialectId, "https://json-schema.org/keyword/draft-04/id");
+      const idToken = getKeywordName(externalSchema.document.dialectId, "https://json-schema.org/keyword/id")
+        || getKeywordName(externalSchema.document.dialectId, "https://json-schema.org/keyword/draft-04/id");
       id = embeddedSchema[idToken];
+      if (id in JsonPointer.get(bundlingLocation, bundled)) {
+        id = resolveUri(id, contextUri);
+      }
     } else if (fullOptions.definitionNamingStrategy === UUID) {
       id = uuid();
     } else {
@@ -57,74 +64,76 @@ export const bundle = async (url, options = {}) => {
   return bundled;
 };
 
-const collectExternalIds = async (uri, options) => {
-  const { ast, schemaUri } = await compile(uri);
-  const subSchemaUris = new Set();
-  Validation.collectExternalIds(schemaUri, subSchemaUris, ast, {});
-  const externalIds = new Set([...subSchemaUris]
-    .map(toAbsoluteUri)
-    .filter((uri) => !options.externalSchemas.includes(uri)));
-  externalIds.delete(toAbsoluteUri(schemaUri));
-
-  return externalIds;
-};
-
-Validation.collectExternalIds = (schemaUri, externalIds, ast, dynamicAnchors) => {
-  if (externalIds.has(schemaUri) || typeof ast[schemaUri] === "boolean") {
-    return;
+Validation.collectExternalIds = curry(async (visited, parentSchema, schema) => {
+  const uri = canonicalUri(schema);
+  if (visited.has(uri) || Browser.typeOf(schema) === "boolean") {
+    return new Set();
   }
-  externalIds.add(schemaUri);
-
-  const id = toAbsoluteUri(schemaUri);
-  for (const [keywordId, , keywordValue] of ast[schemaUri]) {
-    const keyword = getKeyword(keywordId);
 
-    if (keyword.collectExternalIds) {
-      keyword.collectExternalIds(keywordValue, externalIds, ast, {
-        ...ast.metaData[id].dynamicAnchors, ...dynamicAnchors
-      });
-    }
+  visited.add(uri);
+
+  const externalIds = await pipe(
+    Browser.entries(schema),
+    asyncMap(async ([keyword, keywordSchema]) => {
+      const keywordHandler = getKeywordByName(keyword, schema.document.dialectId);
+
+      return "collectExternalIds" in keywordHandler
+        ? await keywordHandler.collectExternalIds(visited, schema, keywordSchema)
+        : new Set();
+    }),
+    asyncFlatten,
+    asyncCollectSet
+  );
+
+  if (parentSchema.document.baseUri !== schema.document.baseUri
+    && (!(schema.document.baseUri in parentSchema.document.embedded) || schema.document.baseUri in parentSchema._cache)
+  ) {
+    externalIds.add(schema.document.baseUri);
   }
-};
+
+  return externalIds;
+});
+
+const collectExternalIdsFromArrayOfSchemas = (visited, parentSchema, schema) => pipe(
+  Browser.iter(schema),
+  asyncMap(Validation.collectExternalIds(visited, parentSchema)),
+  asyncFlatten,
+  asyncCollectSet
+);
+
+const collectExternalIdsFromObjectOfSchemas = async (visited, parentSchema, schema) => pipe(
+  Browser.values(schema),
+  asyncMap(Validation.collectExternalIds(visited, parentSchema)),
+  asyncFlatten,
+  asyncCollectSet
+);
 
 const loadKeywordSupport = () => {
   // Stable
 
   const additionalProperties = getKeyword("https://json-schema.org/keyword/additionalProperties");
   if (additionalProperties) {
-    additionalProperties.collectExternalIds = ([, additionalProperties], externalIds, ast, dynamicAnchors) => {
-      if (typeof additionalProperties === "string") {
-        Validation.collectExternalIds(additionalProperties, externalIds, ast, dynamicAnchors);
-      }
-    };
+    additionalProperties.collectExternalIds = Validation.collectExternalIds;
   }
 
   const allOf = getKeyword("https://json-schema.org/keyword/allOf");
   if (allOf) {
-    allOf.collectExternalIds = (allOf, externalIds, ast, dynamicAnchors) => {
-      allOf.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-    };
+    allOf.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
   }
 
   const anyOf = getKeyword("https://json-schema.org/keyword/anyOf");
   if (anyOf) {
-    anyOf.collectExternalIds = (anyOf, externalIds, ast, dynamicAnchors) => {
-      anyOf.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-    };
+    anyOf.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
   }
 
   const contains = getKeyword("https://json-schema.org/keyword/contains");
   if (contains) {
-    contains.collectExternalIds = ({ contains }, externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(contains, externalIds, ast, dynamicAnchors);
-    };
+    contains.collectExternalIds = Validation.collectExternalIds;
   }
 
   const dependentSchemas = getKeyword("https://json-schema.org/keyword/dependentSchemas");
   if (dependentSchemas) {
-    dependentSchemas.collectExternalIds = (dependentSchemas, externalIds, ast, dynamicAnchors) => {
-      Object.values(dependentSchemas).forEach(([, schemaUri]) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-    };
+    dependentSchemas.collectExternalIds = collectExternalIdsFromObjectOfSchemas;
   }
 
   const if_ = getKeyword("https://json-schema.org/keyword/if");
@@ -134,23 +143,17 @@ const loadKeywordSupport = () => {
 
   const then = getKeyword("https://json-schema.org/keyword/then");
   if (then) {
-    then.collectExternalIds = ([, then], externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(then, externalIds, ast, dynamicAnchors);
-    };
+    then.collectExternalIds = Validation.collectExternalIds;
   }
 
   const else_ = getKeyword("https://json-schema.org/keyword/else");
   if (else_) {
-    else_.collectExternalIds = ([, elseSchema], externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(elseSchema, externalIds, ast, dynamicAnchors);
-    };
+    else_.collectExternalIds = Validation.collectExternalIds;
   }
 
   const items = getKeyword("https://json-schema.org/keyword/items");
   if (items) {
-    items.collectExternalIds = ([, items], externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(items, externalIds, ast, dynamicAnchors);
-    };
+    items.collectExternalIds = Validation.collectExternalIds;
   }
 
   const not = getKeyword("https://json-schema.org/keyword/not");
@@ -160,30 +163,22 @@ const loadKeywordSupport = () => {
 
   const oneOf = getKeyword("https://json-schema.org/keyword/oneOf");
   if (oneOf) {
-    oneOf.collectExternalIds = (oneOf, externalIds, ast, dynamicAnchors) => {
-      oneOf.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-    };
+    oneOf.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
   }
 
   const patternProperties = getKeyword("https://json-schema.org/keyword/patternProperties");
   if (patternProperties) {
-    patternProperties.collectExternalIds = (patternProperties, externalIds, ast, dynamicAnchors) => {
-      patternProperties.forEach(([, schemaUri]) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-    };
+    patternProperties.collectExternalIds = collectExternalIdsFromObjectOfSchemas;
   }
 
   const prefixItems = getKeyword("https://json-schema.org/keyword/prefixItems");
   if (prefixItems) {
-    prefixItems.collectExternalIds = (tupleItems, externalIds, ast, dynamicAnchors) => {
-      tupleItems.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-    };
+    prefixItems.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
   }
 
   const properties = getKeyword("https://json-schema.org/keyword/properties");
   if (properties) {
-    properties.collectExternalIds = (properties, externalIds, ast, dynamicAnchors) => {
-      Object.values(properties).forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-    };
+    properties.collectExternalIds = collectExternalIdsFromObjectOfSchemas;
   }
 
   const propertyNames = getKeyword("https://json-schema.org/keyword/propertyNames");
@@ -198,119 +193,80 @@ const loadKeywordSupport = () => {
 
   const unevaluatedItems = getKeyword("https://json-schema.org/keyword/unevaluatedItems");
   if (unevaluatedItems) {
-    unevaluatedItems.collectExternalIds = ([, unevaluatedItems], externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(unevaluatedItems, externalIds, ast, dynamicAnchors);
-    };
+    unevaluatedItems.collectExternalIds = Validation.collectExternalIds;
   }
 
   const unevaluatedProperties = getKeyword("https://json-schema.org/keyword/unevaluatedProperties");
   if (unevaluatedProperties) {
-    unevaluatedProperties.collectExternalIds = ([, unevaluatedProperties], externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(unevaluatedProperties, externalIds, ast, dynamicAnchors);
-    };
+    unevaluatedProperties.collectExternalIds = Validation.collectExternalIds;
   }
 
   // Draft-04
 
   const additionalItems4 = getKeyword("https://json-schema.org/keyword/draft-04/additionalItems");
   if (additionalItems4) {
-    additionalItems4.collectExternalIds = ([, additionalItems], externalIds, ast, dynamicAnchors) => {
-      if (typeof additionalItems === "string") {
-        Validation.collectExternalIds(additionalItems, externalIds, ast, dynamicAnchors);
-      }
-    };
+    additionalItems4.collectExternalIds = Validation.collectExternalIds;
   }
 
   const dependencies = getKeyword("https://json-schema.org/keyword/draft-04/dependencies");
   if (dependencies) {
-    dependencies.collectExternalIds = (dependencies, externalIds, ast, dynamicAnchors) => {
-      Object.values(dependencies).forEach(([, dependency]) => {
-        if (typeof dependency === "string") {
-          Validation.collectExternalIds(dependency, externalIds, ast, dynamicAnchors);
-        }
-      });
-    };
+    dependencies.collectExternalIds = (visited, parentSchema, schema) => pipe(
+      Browser.values(schema),
+      asyncFilter((subSchema) => Browser.typeOf(subSchema) === "object"),
+      asyncMap(Validation.collectExternalIds(visited, parentSchema)),
+      asyncFlatten,
+      asyncCollectSet
+    );
   }
 
   const items4 = getKeyword("https://json-schema.org/keyword/draft-04/items");
   if (items4) {
-    items4.collectExternalIds = (items, externalIds, ast, dynamicAnchors) => {
-      if (typeof items === "string") {
-        Validation.collectExternalIds(items, externalIds, ast, dynamicAnchors);
-      } else {
-        items.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
-      }
-    };
-  }
-
-  const ref4 = getKeyword("https://json-schema.org/keyword/draft-04/ref");
-  if (ref4) {
-    ref4.collectExternalIds = Validation.collectExternalIds;
+    items4.collectExternalIds = (visited, parentSchema, schema) => Browser.typeOf(schema) === "array"
+      ? collectExternalIdsFromArrayOfSchemas(visited, parentSchema, schema)
+      : Validation.collectExternalIds(visited, parentSchema, schema);
   }
 
   // Draft-06
 
   const contains6 = getKeyword("https://json-schema.org/keyword/draft-06/contains");
   if (contains6) {
-    contains6.collectExternalIds = (contains, externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(contains, externalIds, ast, dynamicAnchors);
-    };
+    contains6.collectExternalIds = Validation.collectExternalIds;
   }
 
   // Draft-2019-09
 
   const contains19 = getKeyword("https://json-schema.org/keyword/draft-2019-09/contains");
   if (contains19) {
-    contains19.collectExternalIds = ({ contains }, externalIds, ast, dynamicAnchors) => {
-      Validation.collectExternalIds(contains, externalIds, ast, dynamicAnchors);
-    };
+    contains19.collectExternalIds = Validation.collectExternalIds;
   }
 
-  // Experimental
+  // Extensions
 
   const propertyDependencies = getKeyword("https://json-schema.org/keyword/propertyDependencies");
   if (propertyDependencies) {
-    propertyDependencies.collectExternalIds = (propertyDependencies, externalIds, ast, dynamicAnchors) => {
-      for (const key in propertyDependencies) {
-        for (const value in propertyDependencies[key]) {
-          Validation.collectExternalIds(propertyDependencies[key][value], externalIds, ast, dynamicAnchors);
-        }
-      }
-    };
+    propertyDependencies.collectExternalIds = (visited, parentSchema, schema) => pipe(
+      Browser.values(schema),
+      asyncMap((mapping) => Browser.values(mapping)),
+      asyncFlatten,
+      asyncMap(Validation.collectExternalIds(visited, parentSchema)),
+      asyncFlatten,
+      asyncCollectSet
+    );
   }
 
   const conditional = getKeyword("https://json-schema.org/keyword/conditional");
   if (conditional) {
-    conditional.collectExternalIds = (conditional, externalIds, ast, dynamicAnchors) => {
-      for (const schema of conditional) {
-        Validation.collectExternalIds(schema, externalIds, ast, dynamicAnchors);
-      }
-    };
+    conditional.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
   }
 
   const itemPattern = getKeyword("https://json-schema.org/keyword/itemPattern");
   if (itemPattern) {
-    itemPattern.collectExternalIds = (nfa, externalIds, ast, dynamicAnchors) => {
-      for (const itemSchema of collectNfaSchemas(nfa.start)) {
-        Validation.collectExternalIds(itemSchema, externalIds, ast, dynamicAnchors);
-      }
-    };
+    itemPattern.collectExternalIds = (visited, parentSchema, schema) => pipe(
+      Browser.iter(schema),
+      asyncFilter((item) => Browser.typeOf(item) === "object"),
+      asyncMap(Validation.collectExternalIds(visited, parentSchema)),
+      asyncFlatten,
+      asyncCollectSet
+    );
   }
-
-  const collectNfaSchemas = function* (node, visited = new Set()) {
-    if (visited.has(node)) {
-      return;
-    }
-
-    visited.add(node);
-
-    for (const schema in node.transition) {
-      yield schema;
-      yield* collectNfaSchemas(node.transition[schema], visited);
-    }
-
-    for (const epsilon of node.epsilonTransitions) {
-      yield* collectNfaSchemas(epsilon, visited);
-    }
-  };
 };

package/draft-04/additionalItems.js

@@ -1,22 +1,21 @@
 import { pipe, drop, every } from "@hyperjump/pact";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
-import * as Schema from "../lib/schema.js";
-import Validation from "../lib/keywords/validation.js";
-import { getKeywordName } from "../lib/keywords.js";
+import { getKeywordName, Validation } from "../lib/experimental.js";
 
 
 const id = "https://json-schema.org/keyword/draft-04/additionalItems";
 
 const compile = async (schema, ast, parentSchema) => {
-  const itemsKeywordName = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/draft-04/items");
-  const items = await Schema.step(itemsKeywordName, parentSchema);
-  const numberOfItems = Schema.typeOf(items, "array") ? Schema.length(items) : Number.MAX_SAFE_INTEGER;
+  const itemsKeywordName = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/draft-04/items");
+  const items = await Browser.step(itemsKeywordName, parentSchema);
+  const numberOfItems = Browser.typeOf(items) === "array" ? Browser.length(items) : Number.MAX_SAFE_INTEGER;
 
   return [numberOfItems, await Validation.compile(schema, ast)];
 };
 
 const interpret = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
+  if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 

package/draft-04/dependencies.js

@@ -1,16 +1,16 @@
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
-import * as Schema from "../lib/schema.js";
-import Validation from "../lib/keywords/validation.js";
+import { Validation } from "../lib/experimental.js";
 
 
 const id = "https://json-schema.org/keyword/draft-04/dependencies";
 
 const compile = (schema, ast) => pipe(
-  Schema.entries(schema),
+  Browser.entries(schema),
   asyncMap(async ([key, dependency]) => [
     key,
-    Schema.typeOf(dependency, "array") ? Schema.value(dependency) : await Validation.compile(dependency, ast)
+    Browser.typeOf(dependency) === "array" ? Browser.value(dependency) : await Validation.compile(dependency, ast)
   ]),
   asyncCollectArray
 );
@@ -18,7 +18,7 @@ const compile = (schema, ast) => pipe(
 const interpret = (dependencies, instance, ast, dynamicAnchors, quiet) => {
   const value = Instance.value(instance);
 
-  return !Instance.typeOf(instance, "object") || dependencies.every(([propertyName, dependency]) => {
+  return Instance.typeOf(instance) !== "object" || dependencies.every(([propertyName, dependency]) => {
     if (!(propertyName in value)) {
       return true;
     }

package/draft-04/index.js

@@ -1,5 +1,5 @@
 import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
-import { addSchema } from "../lib/core.js";
+import { registerSchema } from "../lib/index.js";
 import metaSchema from "./schema.js";
 import additionalItems from "./additionalItems.js";
 import dependencies from "./dependencies.js";
@@ -64,6 +64,6 @@ loadDialect(jsonSchemaVersion, {
   [jsonSchemaVersion]: true
 }, true);
 
-addSchema(metaSchema);
+registerSchema(metaSchema);
 
 export * from "../lib/index.js";

package/draft-04/items.js

@@ -1,15 +1,15 @@
 import { pipe, asyncMap, asyncCollectArray, every, zip, take, range, collectSet } from "@hyperjump/pact";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
-import * as Schema from "../lib/schema.js";
-import Validation from "../lib/keywords/validation.js";
+import { Validation } from "../lib/experimental.js";
 
 
 const id = "https://json-schema.org/keyword/draft-04/items";
 
 const compile = (schema, ast) => {
-  if (Schema.typeOf(schema, "array")) {
+  if (Browser.typeOf(schema) === "array") {
     return pipe(
-      Schema.iter(schema),
+      Browser.iter(schema),
       asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
       asyncCollectArray
     );
@@ -19,7 +19,7 @@ const compile = (schema, ast) => {
 };
 
 const interpret = (items, instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
+  if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 

package/draft-04/maximum.js

@@ -1,20 +1,20 @@
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
-import * as Schema from "../lib/schema.js";
-import { getKeywordName } from "../lib/keywords.js";
+import { getKeywordName } from "../lib/experimental.js";
 
 
 const id = "https://json-schema.org/keyword/draft-04/maximum";
 
-const compile = async (schema, ast, parentSchema) => {
-  const exclusiveMaximumKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/draft-04/exclusiveMaximum");
-  const exclusiveMaximum = await Schema.step(exclusiveMaximumKeyword, parentSchema);
-  const isExclusive = Schema.value(exclusiveMaximum);
+const compile = async (schema, _ast, parentSchema) => {
+  const exclusiveMaximumKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/draft-04/exclusiveMaximum");
+  const exclusiveMaximum = await Browser.step(exclusiveMaximumKeyword, parentSchema);
+  const isExclusive = Browser.value(exclusiveMaximum);
 
-  return [Schema.value(schema), isExclusive];
+  return [Browser.value(schema), isExclusive];
 };
 
 const interpret = ([maximum, isExclusive], instance) => {
-  if (!Instance.typeOf(instance, "number")) {
+  if (Instance.typeOf(instance) !== "number") {
     return true;
   }
 

package/draft-04/minimum.js

@@ -1,20 +1,20 @@
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
-import * as Schema from "../lib/schema.js";
-import { getKeywordName } from "../lib/keywords.js";
+import { getKeywordName } from "../lib/experimental.js";
 
 
 const id = "https://json-schema.org/keyword/draft-04/minimum";
 
-const compile = async (schema, ast, parentSchema) => {
-  const exclusiveMinimumKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/draft-04/exclusiveMinimum");
-  const exclusiveMinimum = await Schema.step(exclusiveMinimumKeyword, parentSchema);
-  const isExclusive = Schema.value(exclusiveMinimum);
+const compile = async (schema, _ast, parentSchema) => {
+  const exclusiveMinimumKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/draft-04/exclusiveMinimum");
+  const exclusiveMinimum = await Browser.step(exclusiveMinimumKeyword, parentSchema);
+  const isExclusive = Browser.value(exclusiveMinimum);
 
-  return [Schema.value(schema), isExclusive];
+  return [Browser.value(schema), isExclusive];
 };
 
 const interpret = ([minimum, isExclusive], instance) => {
-  if (!Instance.typeOf(instance, "number")) {
+  if (Instance.typeOf(instance) !== "number") {
     return true;
   }