@maroonedog/luq 2.4.4 → 2.6.0

package/dist/json-schema/build-from-schema.js

@@ -6,6 +6,7 @@ exports.buildFromSchema = buildFromSchema;
 exports.fromJsonSchema = fromJsonSchema;
 const create_field_builder_1 = require("../builder/create-field-builder");
 const type_erasure_1 = require("../core/type-erasure");
+const assert_supported_dialect_1 = require("./assert-supported-dialect");
 const create_structural_context_1 = require("./create-structural-context");
 const declare_presence_1 = require("./declare-presence");
 const ref_scope_1 = require("./ref-scope");
@@ -35,9 +36,12 @@ function collectDeclaredRules(declaration, bag, root, chain) {
     ]);
 }
 /** One pending `.v()` per declared path, with its callback still unrun. */
-function buildFieldEntries(bag, schema) {
+function buildFieldEntries(bag, schema, options = {}) {
     if (!(0, draft07_types_1.isDraft07Schema)(schema))
         throw new NotASchemaError(schema);
+    // Before any keyword is read: what the document's keywords MEAN depends on
+    // the dialect it declares, and Luq reads every one of them as Draft-07.
+    (0, assert_supported_dialect_1.assertSupportedDialect)(schema, options);
     return (0, flatten_schema_1.flattenSchema)(schema, schema_to_declarations_1.readChildSchemas).map((declaration) => ({
         path: declaration.path,
         defaultOf: null,
@@ -53,10 +57,28 @@ function buildFieldEntries(bag, schema) {
     }));
 }
 /** The erased front door: the declarations, with nothing compiled yet. */
-function buildFromSchema(bag, schema, config) {
-    return (0, create_field_builder_1.createFieldBuilderSurface)(bag, config, buildFieldEntries(bag, schema));
+function buildFromSchema(bag, schema, config, options) {
+    return (0, create_field_builder_1.createFieldBuilderSurface)(bag, config, buildFieldEntries(bag, schema, options));
 }
 /**
+ * Converts a JSON Schema document into a validator.
+ *
+ * THE INPUT LIMIT IS DRAFT-07, and it is a limit on what may be handed in, not
+ * only a statement of how much of Draft-07 is covered. A document declaring
+ * 2019-09 or 2020-12 in its root `$schema` is REFUSED with an
+ * `UnsupportedDialectError` rather than read as Draft-07, because the two
+ * dialects disagree about what an unchanged keyword means: from 2019-09 on
+ * `$ref` is an ordinary applicator whose siblings are applied, while Draft-07
+ * §8.3 replaces the node, so `{"$ref": "#/$defs/name", "minLength": 5}` read as
+ * Draft-07 loses the `minLength` and accepts a value the document forbids. A
+ * document with NO `$schema` is read as Draft-07 and always has been. Pass
+ * `{ assumeDraft07: true }` as the fourth argument to read a newer-dialect
+ * document under Draft-07 rules deliberately, with that reading's consequences.
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`; under the default NO
+ * declared path is checked. See the header of this file, which owns that
+ * escape hatch.
+ *
  * The declared type is put back on by `eraseSchemaValidator`, the fourth
  * function in src/core/type-erasure.ts — the one file the code standard allows
  * to assert. Step 25 expressed this as an OVERLOAD PAIR instead, because
@@ -64,7 +86,7 @@ function buildFromSchema(bag, schema, config) {
  * TypeScript on lenient compatibility rules and so was never audited anywhere.
  * The call below is, in the file where every escape hatch is reviewed together.
  */
-function fromJsonSchema(bag, schema, config) {
-    const planBacked = buildFromSchema(bag, schema, config).build();
+function fromJsonSchema(bag, schema, config, options) {
+    const planBacked = buildFromSchema(bag, schema, config, options).build();
     return (0, type_erasure_1.eraseSchemaValidator)(planBacked);
 }

package/dist/json-schema/build-from-schema.mjs

@@ -1,5 +1,6 @@
 import { createFieldBuilderSurface } from "../builder/create-field-builder.mjs";
 import { eraseSchemaValidator } from "../core/type-erasure.mjs";
+import { assertSupportedDialect } from "./assert-supported-dialect.mjs";
 import { createStructuralContext } from "./create-structural-context.mjs";
 import { declarePresenceRules } from "./declare-presence.mjs";
 import { createLocalScope } from "./ref-scope.mjs";
@@ -28,9 +29,12 @@ function collectDeclaredRules(declaration, bag, root, chain) {
     ]);
 }
 /** One pending `.v()` per declared path, with its callback still unrun. */
-export function buildFieldEntries(bag, schema) {
+export function buildFieldEntries(bag, schema, options = {}) {
     if (!isDraft07Schema(schema))
         throw new NotASchemaError(schema);
+    // Before any keyword is read: what the document's keywords MEAN depends on
+    // the dialect it declares, and Luq reads every one of them as Draft-07.
+    assertSupportedDialect(schema, options);
     return flattenSchema(schema, readChildSchemas).map((declaration) => ({
         path: declaration.path,
         defaultOf: null,
@@ -46,10 +50,28 @@ export function buildFieldEntries(bag, schema) {
     }));
 }
 /** The erased front door: the declarations, with nothing compiled yet. */
-export function buildFromSchema(bag, schema, config) {
-    return createFieldBuilderSurface(bag, config, buildFieldEntries(bag, schema));
+export function buildFromSchema(bag, schema, config, options) {
+    return createFieldBuilderSurface(bag, config, buildFieldEntries(bag, schema, options));
 }
 /**
+ * Converts a JSON Schema document into a validator.
+ *
+ * THE INPUT LIMIT IS DRAFT-07, and it is a limit on what may be handed in, not
+ * only a statement of how much of Draft-07 is covered. A document declaring
+ * 2019-09 or 2020-12 in its root `$schema` is REFUSED with an
+ * `UnsupportedDialectError` rather than read as Draft-07, because the two
+ * dialects disagree about what an unchanged keyword means: from 2019-09 on
+ * `$ref` is an ordinary applicator whose siblings are applied, while Draft-07
+ * §8.3 replaces the node, so `{"$ref": "#/$defs/name", "minLength": 5}` read as
+ * Draft-07 loses the `minLength` and accepts a value the document forbids. A
+ * document with NO `$schema` is read as Draft-07 and always has been. Pass
+ * `{ assumeDraft07: true }` as the fourth argument to read a newer-dialect
+ * document under Draft-07 rules deliberately, with that reading's consequences.
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`; under the default NO
+ * declared path is checked. See the header of this file, which owns that
+ * escape hatch.
+ *
  * The declared type is put back on by `eraseSchemaValidator`, the fourth
  * function in src/core/type-erasure.ts — the one file the code standard allows
  * to assert. Step 25 expressed this as an OVERLOAD PAIR instead, because
@@ -57,7 +79,7 @@ export function buildFromSchema(bag, schema, config) {
  * TypeScript on lenient compatibility rules and so was never audited anywhere.
  * The call below is, in the file where every escape hatch is reviewed together.
  */
-export function fromJsonSchema(bag, schema, config) {
-    const planBacked = buildFromSchema(bag, schema, config).build();
+export function fromJsonSchema(bag, schema, config, options) {
+    const planBacked = buildFromSchema(bag, schema, config, options).build();
     return eraseSchemaValidator(planBacked);
 }

package/dist/json-schema/collect-definitions.d.ts

@@ -45,6 +45,13 @@ export declare function advanceBase(scope: RefScope, node: Draft07SchemaObject):
  * a recursive definition BEFORE it walks into it: `#/definitions/node` inside
  * its own `properties` is a legitimate schema whose declared paths are
  * infinite, and Luq declares finite paths.
+ *
+ * The node is asked what it IS, not what it is not. Untyped JSON reaches here —
+ * a `properties` entry is whatever the document wrote — and "not a boolean"
+ * counts `null` as something to read `$ref` off, which throws before the
+ * malformed entry can be named. The pair is the same one resolve-ref uses:
+ * isDraft07Schema keeps out everything that is not a schema at all, and
+ * isSchemaObject drops the §4.4 boolean form, which carries no pointer.
  */
 export declare function readRefPointer(schema: Draft07Schema): string | undefined;
 /** Every definition name the document declares, under either spelling. */

package/dist/json-schema/collect-definitions.js

@@ -90,8 +90,17 @@ function advanceBase(scope, node) {
  * a recursive definition BEFORE it walks into it: `#/definitions/node` inside
  * its own `properties` is a legitimate schema whose declared paths are
  * infinite, and Luq declares finite paths.
+ *
+ * The node is asked what it IS, not what it is not. Untyped JSON reaches here —
+ * a `properties` entry is whatever the document wrote — and "not a boolean"
+ * counts `null` as something to read `$ref` off, which throws before the
+ * malformed entry can be named. The pair is the same one resolve-ref uses:
+ * isDraft07Schema keeps out everything that is not a schema at all, and
+ * isSchemaObject drops the §4.4 boolean form, which carries no pointer.
  */
 function readRefPointer(schema) {
+    if (!(0, draft07_types_1.isDraft07Schema)(schema))
+        return undefined;
     if (!(0, draft07_types_1.isSchemaObject)(schema))
         return undefined;
     return schema.$ref;

package/dist/json-schema/collect-definitions.mjs

@@ -1,4 +1,4 @@
-import { isSchemaObject } from "./draft07.types.mjs";
+import { isDraft07Schema, isSchemaObject } from "./draft07.types.mjs";
 import { createLocalScope } from "./ref-scope.mjs";
 import { resolveRefInScope } from "./resolve-ref.mjs";
 import { nextBaseUri } from "./uri-reference.mjs";
@@ -80,8 +80,17 @@ export function advanceBase(scope, node) {
  * a recursive definition BEFORE it walks into it: `#/definitions/node` inside
  * its own `properties` is a legitimate schema whose declared paths are
  * infinite, and Luq declares finite paths.
+ *
+ * The node is asked what it IS, not what it is not. Untyped JSON reaches here —
+ * a `properties` entry is whatever the document wrote — and "not a boolean"
+ * counts `null` as something to read `$ref` off, which throws before the
+ * malformed entry can be named. The pair is the same one resolve-ref uses:
+ * isDraft07Schema keeps out everything that is not a schema at all, and
+ * isSchemaObject drops the §4.4 boolean form, which carries no pointer.
  */
 export function readRefPointer(schema) {
+    if (!isDraft07Schema(schema))
+        return undefined;
     if (!isSchemaObject(schema))
         return undefined;
     return schema.$ref;

package/dist/json-schema/declare-additional-properties.d.ts

@@ -15,5 +15,15 @@ export declare function patternPropertyKeys(schema: Draft07SchemaObject): readon
  * holds the keyword table and the compile-time check that the method exists.
  */
 export declare function applyAdditionalPropertiesBoolean(chain: ConverterChain<"object">, schema: Draft07SchemaObject, allowed: boolean): ConverterChain<"object">;
-/** The SCHEMA form: whatever matches neither a declaration nor a pattern follows it. */
+/**
+ * The SCHEMA form: whatever matches neither a declaration nor a pattern
+ * follows it.
+ *
+ * This is the ONE place a non-boolean `additionalProperties` is consumed — the
+ * boolean form is taken by declareObjectRules before this runs — so it is
+ * where the value is checked. A string or a number reaching the sub-schema
+ * route is not a schema, expands to no rules, and turns
+ * `{"additionalProperties":"false"}` into an object that accepts every extra
+ * property; the check refuses it instead. Both well-formed forms are untouched.
+ */
 export declare function declareAdditionalPropertiesSchema(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/declare-additional-properties.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.patternPropertyKeys = patternPropertyKeys;
 exports.applyAdditionalPropertiesBoolean = applyAdditionalPropertiesBoolean;
 exports.declareAdditionalPropertiesSchema = declareAdditionalPropertiesSchema;
+const assert_object_keyword_values_1 = require("./assert-object-keyword-values");
 const apply_keyword_binding_1 = require("./apply-keyword-binding");
 const keyword_map_object_1 = require("./keyword-map-object");
 const NO_RULES = Object.freeze([]);
@@ -29,9 +30,20 @@ function applyAdditionalPropertiesBoolean(chain, schema, allowed) {
         ? (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.additionalPropertiesBinding, allowed)
         : chain.additionalProperties(allowed, undefined, patterns);
 }
-/** The SCHEMA form: whatever matches neither a declaration nor a pattern follows it. */
+/**
+ * The SCHEMA form: whatever matches neither a declaration nor a pattern
+ * follows it.
+ *
+ * This is the ONE place a non-boolean `additionalProperties` is consumed — the
+ * boolean form is taken by declareObjectRules before this runs — so it is
+ * where the value is checked. A string or a number reaching the sub-schema
+ * route is not a schema, expands to no rules, and turns
+ * `{"additionalProperties":"false"}` into an object that accepts every extra
+ * property; the check refuses it instead. Both well-formed forms are untouched.
+ */
 function declareAdditionalPropertiesSchema(schema, context) {
     const additional = schema.additionalProperties;
+    (0, assert_object_keyword_values_1.assertAdditionalPropertiesIsSchema)(additional);
     if (additional === undefined || typeof additional === "boolean") {
         return NO_RULES;
     }

package/dist/json-schema/declare-additional-properties.mjs

@@ -1,3 +1,4 @@
+import { assertAdditionalPropertiesIsSchema } from "./assert-object-keyword-values.mjs";
 import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
 import { additionalPropertiesBinding } from "./keyword-map-object.mjs";
 const NO_RULES = Object.freeze([]);
@@ -24,9 +25,20 @@ export function applyAdditionalPropertiesBoolean(chain, schema, allowed) {
         ? applyKeywordBinding(chain, additionalPropertiesBinding, allowed)
         : chain.additionalProperties(allowed, undefined, patterns);
 }
-/** The SCHEMA form: whatever matches neither a declaration nor a pattern follows it. */
+/**
+ * The SCHEMA form: whatever matches neither a declaration nor a pattern
+ * follows it.
+ *
+ * This is the ONE place a non-boolean `additionalProperties` is consumed — the
+ * boolean form is taken by declareObjectRules before this runs — so it is
+ * where the value is checked. A string or a number reaching the sub-schema
+ * route is not a schema, expands to no rules, and turns
+ * `{"additionalProperties":"false"}` into an object that accepts every extra
+ * property; the check refuses it instead. Both well-formed forms are untouched.
+ */
 export function declareAdditionalPropertiesSchema(schema, context) {
     const additional = schema.additionalProperties;
+    assertAdditionalPropertiesIsSchema(additional);
     if (additional === undefined || typeof additional === "boolean") {
         return NO_RULES;
     }

package/dist/json-schema/declare-object-keywords.d.ts

@@ -14,6 +14,10 @@ export declare function declareDependencies(schema: Draft07SchemaObject, context
  * (declareRequiredProperties). A name in `required` with no `properties` entry
  * still gets a path on the empty schema, because §6.5.3 makes the two keywords
  * independent and the root distribution needs the path to exist.
+ *
+ * Both keywords are first READ here, for the root and for every nested node
+ * alike, so this is where both are checked. Unchecked, a string `required` is
+ * iterated character by character and every character becomes a declared path.
  */
 export declare function readPropertyChildren(schema: Draft07SchemaObject): readonly {
     step: string;

package/dist/json-schema/declare-object-keywords.js

@@ -22,14 +22,12 @@ exports.readPropertyChildren = readPropertyChildren;
 const create_chain_node_1 = require("../chain/create-chain-node");
 const create_field_slots_1 = require("../chain/create-field-slots");
 const types_1 = require("../types");
+const assert_object_keyword_values_1 = require("./assert-object-keyword-values");
 const declare_additional_properties_1 = require("./declare-additional-properties");
 const apply_keyword_binding_1 = require("./apply-keyword-binding");
 const collect_definitions_1 = require("./collect-definitions");
 const keyword_map_object_1 = require("./keyword-map-object");
 const NO_RULES = Object.freeze([]);
-function readRules(chain) {
-    return (0, create_chain_node_1.readChainRules)(chain) ?? NO_RULES;
-}
 function declareObjectRules(schema, context) {
     let chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).object;
     if (schema.minProperties !== undefined) {
@@ -46,11 +44,12 @@ function declareObjectRules(schema, context) {
         // stays: it holds the keyword table and the check that the method exists.
         chain = (0, declare_additional_properties_1.applyAdditionalPropertiesBoolean)(chain, schema, additional);
     }
-    return readRules(chain);
+    return (0, create_chain_node_1.readChainRules)(chain) ?? NO_RULES;
 }
 /** EVERY matching pattern applies; 1.x broke after the first match. */
 function declarePatternProperties(schema, context) {
     const patterns = schema.patternProperties;
+    (0, assert_object_keyword_values_1.assertPatternPropertiesIsSchemaMap)(patterns);
     if (patterns === undefined)
         return NO_RULES;
     const byPattern = {};
@@ -65,6 +64,7 @@ function declarePatternProperties(schema, context) {
 /** A sub-chain over the property NAMES, which are always strings. */
 function declarePropertyNames(schema, context) {
     const names = schema.propertyNames;
+    (0, assert_object_keyword_values_1.assertPropertyNamesIsSchema)(names);
     if (names === undefined)
         return NO_RULES;
     const plugin = context.bag.objectPropertyNames;
@@ -86,6 +86,7 @@ function splitDependencies(dependencies) {
 }
 function declareDependencies(schema, context) {
     const dependencies = schema.dependencies;
+    (0, assert_object_keyword_values_1.assertDependenciesIsSchemaOrNameListMap)(dependencies);
     if (dependencies === undefined)
         return NO_RULES;
     const split = splitDependencies(dependencies);
@@ -115,8 +116,14 @@ function declareDependencies(schema, context) {
  * (declareRequiredProperties). A name in `required` with no `properties` entry
  * still gets a path on the empty schema, because §6.5.3 makes the two keywords
  * independent and the root distribution needs the path to exist.
+ *
+ * Both keywords are first READ here, for the root and for every nested node
+ * alike, so this is where both are checked. Unchecked, a string `required` is
+ * iterated character by character and every character becomes a declared path.
  */
 function readPropertyChildren(schema) {
+    (0, assert_object_keyword_values_1.assertPropertiesIsSchemaMap)(schema.properties);
+    (0, assert_object_keyword_values_1.assertRequiredIsNameList)(schema.required);
     const properties = schema.properties ?? {};
     const required = schema.required ?? [];
     const children = Object.entries(properties).map(([key, member]) => ({

package/dist/json-schema/declare-object-keywords.mjs

@@ -15,14 +15,12 @@
 import { readChainRules } from "../chain/create-chain-node.mjs";
 import { createFieldSlots } from "../chain/create-field-slots.mjs";
 import { isStringArray } from "../types/index.mjs";
+import { assertDependenciesIsSchemaOrNameListMap, assertPatternPropertiesIsSchemaMap, assertPropertiesIsSchemaMap, assertPropertyNamesIsSchema, assertRequiredIsNameList, } from "./assert-object-keyword-values.mjs";
 import { applyAdditionalPropertiesBoolean } from "./declare-additional-properties.mjs";
 import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
 import { toSchemaObject } from "./collect-definitions.mjs";
 import { maxPropertiesBinding, minPropertiesBinding, } from "./keyword-map-object.mjs";
 const NO_RULES = Object.freeze([]);
-function readRules(chain) {
-    return readChainRules(chain) ?? NO_RULES;
-}
 export function declareObjectRules(schema, context) {
     let chain = createFieldSlots(context.bag, context.build).object;
     if (schema.minProperties !== undefined) {
@@ -39,11 +37,12 @@ export function declareObjectRules(schema, context) {
         // stays: it holds the keyword table and the check that the method exists.
         chain = applyAdditionalPropertiesBoolean(chain, schema, additional);
     }
-    return readRules(chain);
+    return readChainRules(chain) ?? NO_RULES;
 }
 /** EVERY matching pattern applies; 1.x broke after the first match. */
 export function declarePatternProperties(schema, context) {
     const patterns = schema.patternProperties;
+    assertPatternPropertiesIsSchemaMap(patterns);
     if (patterns === undefined)
         return NO_RULES;
     const byPattern = {};
@@ -58,6 +57,7 @@ export function declarePatternProperties(schema, context) {
 /** A sub-chain over the property NAMES, which are always strings. */
 export function declarePropertyNames(schema, context) {
     const names = schema.propertyNames;
+    assertPropertyNamesIsSchema(names);
     if (names === undefined)
         return NO_RULES;
     const plugin = context.bag.objectPropertyNames;
@@ -79,6 +79,7 @@ function splitDependencies(dependencies) {
 }
 export function declareDependencies(schema, context) {
     const dependencies = schema.dependencies;
+    assertDependenciesIsSchemaOrNameListMap(dependencies);
     if (dependencies === undefined)
         return NO_RULES;
     const split = splitDependencies(dependencies);
@@ -108,8 +109,14 @@ export function declareDependencies(schema, context) {
  * (declareRequiredProperties). A name in `required` with no `properties` entry
  * still gets a path on the empty schema, because §6.5.3 makes the two keywords
  * independent and the root distribution needs the path to exist.
+ *
+ * Both keywords are first READ here, for the root and for every nested node
+ * alike, so this is where both are checked. Unchecked, a string `required` is
+ * iterated character by character and every character becomes a declared path.
  */
 export function readPropertyChildren(schema) {
+    assertPropertiesIsSchemaMap(schema.properties);
+    assertRequiredIsNameList(schema.required);
     const properties = schema.properties ?? {};
     const required = schema.required ?? [];
     const children = Object.entries(properties).map(([key, member]) => ({

package/dist/json-schema/declare-required-properties.js

@@ -19,6 +19,7 @@ exports.declareRequiredProperties = declareRequiredProperties;
 // ===========================================================================
 const create_rule_1 = require("../plugin-kit/create-rule");
 const types_1 = require("../types");
+const assert_object_keyword_values_1 = require("./assert-object-keyword-values");
 const NO_RULES = Object.freeze([]);
 /**
  * `required` as a rule on the OBJECT, not as a presence rule on each child.
@@ -36,6 +37,11 @@ const NO_RULES = Object.freeze([]);
  */
 function declareRequiredProperties(schema, context) {
     const required = schema.required;
+    // Checked again here, and not only where the children are read: this rule
+    // closes over `required` and calls `.filter` on it at VALIDATION time, so an
+    // unchecked non-array escapes the build and surfaces as a raw TypeError on
+    // the first request.
+    (0, assert_object_keyword_values_1.assertRequiredIsNameList)(required);
     if (required === undefined || required.length === 0)
         return NO_RULES;
     const missingOf = (value) => required.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));

package/dist/json-schema/declare-required-properties.mjs

@@ -16,6 +16,7 @@
 // ===========================================================================
 import { check } from "../plugin-kit/create-rule.mjs";
 import { PASS, fail, isArray, isPlainObject } from "../types/index.mjs";
+import { assertRequiredIsNameList } from "./assert-object-keyword-values.mjs";
 const NO_RULES = Object.freeze([]);
 /**
  * `required` as a rule on the OBJECT, not as a presence rule on each child.
@@ -33,6 +34,11 @@ const NO_RULES = Object.freeze([]);
  */
 export function declareRequiredProperties(schema, context) {
     const required = schema.required;
+    // Checked again here, and not only where the children are read: this rule
+    // closes over `required` and calls `.filter` on it at VALIDATION time, so an
+    // unchecked non-array escapes the build and surfaces as a raw TypeError on
+    // the first request.
+    assertRequiredIsNameList(required);
     if (required === undefined || required.length === 0)
         return NO_RULES;
     const missingOf = (value) => required.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));

package/dist/json-schema/declare-value-keywords.d.ts

@@ -1,7 +1,16 @@
 import type { Rule } from "../plugin-kit/compiled-rule";
 import type { Draft07SchemaObject, Draft07TypeKeyword } from "./draft07.types";
 import type { StructuralContext } from "./structural-expansion.types";
-/** The declared names, always as a list, with unknown names rejected loudly. */
+/**
+ * The declared names, always as a list. Every departure from the meta-schema
+ * is a refusal rather than a name dropped from the list: a dropped name leaves
+ * NO type rule at all (the list is what declareTypeRules counts) and also
+ * turns permitsNull true, so `{"type":"strig"}` would both stop checking the
+ * type and start accepting null.
+ *
+ * `schema.type` is typed by draft07.types.ts, but the document it came from is
+ * plain JSON that nothing has checked, so the value is re-read as `unknown`.
+ */
 export declare function readDeclaredTypes(schema: Draft07SchemaObject): readonly Draft07TypeKeyword[];
 /** True when the document permits an explicit null at this position. */
 export declare function permitsNull(schema: Draft07SchemaObject): boolean;

package/dist/json-schema/declare-value-keywords.js

@@ -19,6 +19,11 @@ exports.declareEnumRules = declareEnumRules;
 // primitive type (`object` is the only type plugin in the catalogue and it is
 // not in the bag).
 //
+// `type` is also the ONE keyword here whose value is refused rather than
+// normalised, because it is the only rule in the converter that judges the
+// value's type: a name this module cannot read would take the whole check with
+// it. See readDeclaredTypes.
+//
 // `null` never reaches a check — src/runtime/decide-presence.ts settles absence
 // first — so `type: "null"` reads as "every value that got this far is wrong",
 // which is exactly right: the only null-shaped value was already accepted by
@@ -30,8 +35,9 @@ const create_rule_1 = require("../plugin-kit/create-rule");
 const types_1 = require("../types");
 const apply_keyword_binding_1 = require("./apply-keyword-binding");
 const keyword_map_core_1 = require("./keyword-map-core");
+const malformed_schema_error_1 = require("./malformed-schema-error");
 const NO_RULES = Object.freeze([]);
-/** Every Draft-07 `type` name, so an unknown one is a build-time refusal. */
+/** The seven names, and the test each one stands for. Nothing else is a type. */
 const JSON_TYPE_TESTS = {
     string: types_1.isString,
     number: (value) => typeof value === "number",
@@ -44,13 +50,46 @@ const JSON_TYPE_TESTS = {
 function isTypeKeyword(name) {
     return Object.prototype.hasOwnProperty.call(JSON_TYPE_TESTS, name);
 }
-/** The declared names, always as a list, with unknown names rejected loudly. */
+/**
+ * One member of `type`, checked against the seven names.
+ *
+ * The string check is not decoration and must stay FIRST: the lookup below is
+ * a property lookup, so a non-string key is coerced to its string form, and
+ * `null` coerces to the name "null" — an unguarded lookup therefore reads
+ * `{"type": null}` as `{"type": "null"}` and changes what the document says.
+ */
+function readTypeName(name) {
+    if (!(0, types_1.isString)(name)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("type", "every member of the array form must be a string", name);
+    }
+    if (!isTypeKeyword(name)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("type", `the name "${name}" must be one of the seven type names`, name);
+    }
+    return name;
+}
+/**
+ * The declared names, always as a list. Every departure from the meta-schema
+ * is a refusal rather than a name dropped from the list: a dropped name leaves
+ * NO type rule at all (the list is what declareTypeRules counts) and also
+ * turns permitsNull true, so `{"type":"strig"}` would both stop checking the
+ * type and start accepting null.
+ *
+ * `schema.type` is typed by draft07.types.ts, but the document it came from is
+ * plain JSON that nothing has checked, so the value is re-read as `unknown`.
+ */
 function readDeclaredTypes(schema) {
     const declared = schema.type;
     if (declared === undefined)
         return Object.freeze([]);
-    const names = (0, types_1.isArray)(declared) ? declared : [declared];
-    return Object.freeze(names.filter((name) => isTypeKeyword(name)));
+    if ((0, types_1.isString)(declared))
+        return Object.freeze([readTypeName(declared)]);
+    if (!(0, types_1.isArray)(declared)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("type", "the value must be a type name or an array of type names", declared);
+    }
+    if (declared.length === 0) {
+        throw new malformed_schema_error_1.MalformedSchemaError("type", "the array form must hold at least one name (minItems 1)", declared);
+    }
+    return Object.freeze(declared.map((name) => readTypeName(name)));
 }
 /** True when the document permits an explicit null at this position. */
 function permitsNull(schema) {

package/dist/json-schema/declare-value-keywords.mjs

@@ -11,6 +11,11 @@
 // primitive type (`object` is the only type plugin in the catalogue and it is
 // not in the bag).
 //
+// `type` is also the ONE keyword here whose value is refused rather than
+// normalised, because it is the only rule in the converter that judges the
+// value's type: a name this module cannot read would take the whole check with
+// it. See readDeclaredTypes.
+//
 // `null` never reaches a check — src/runtime/decide-presence.ts settles absence
 // first — so `type: "null"` reads as "every value that got this far is wrong",
 // which is exactly right: the only null-shaped value was already accepted by
@@ -22,8 +27,9 @@ import { check } from "../plugin-kit/create-rule.mjs";
 import { PASS, fail, isArray, isPlainObject, isString } from "../types/index.mjs";
 import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
 import { constBinding } from "./keyword-map-core.mjs";
+import { MalformedSchemaError } from "./malformed-schema-error.mjs";
 const NO_RULES = Object.freeze([]);
-/** Every Draft-07 `type` name, so an unknown one is a build-time refusal. */
+/** The seven names, and the test each one stands for. Nothing else is a type. */
 const JSON_TYPE_TESTS = {
     string: isString,
     number: (value) => typeof value === "number",
@@ -36,13 +42,46 @@ const JSON_TYPE_TESTS = {
 function isTypeKeyword(name) {
     return Object.prototype.hasOwnProperty.call(JSON_TYPE_TESTS, name);
 }
-/** The declared names, always as a list, with unknown names rejected loudly. */
+/**
+ * One member of `type`, checked against the seven names.
+ *
+ * The string check is not decoration and must stay FIRST: the lookup below is
+ * a property lookup, so a non-string key is coerced to its string form, and
+ * `null` coerces to the name "null" — an unguarded lookup therefore reads
+ * `{"type": null}` as `{"type": "null"}` and changes what the document says.
+ */
+function readTypeName(name) {
+    if (!isString(name)) {
+        throw new MalformedSchemaError("type", "every member of the array form must be a string", name);
+    }
+    if (!isTypeKeyword(name)) {
+        throw new MalformedSchemaError("type", `the name "${name}" must be one of the seven type names`, name);
+    }
+    return name;
+}
+/**
+ * The declared names, always as a list. Every departure from the meta-schema
+ * is a refusal rather than a name dropped from the list: a dropped name leaves
+ * NO type rule at all (the list is what declareTypeRules counts) and also
+ * turns permitsNull true, so `{"type":"strig"}` would both stop checking the
+ * type and start accepting null.
+ *
+ * `schema.type` is typed by draft07.types.ts, but the document it came from is
+ * plain JSON that nothing has checked, so the value is re-read as `unknown`.
+ */
 export function readDeclaredTypes(schema) {
     const declared = schema.type;
     if (declared === undefined)
         return Object.freeze([]);
-    const names = isArray(declared) ? declared : [declared];
-    return Object.freeze(names.filter((name) => isTypeKeyword(name)));
+    if (isString(declared))
+        return Object.freeze([readTypeName(declared)]);
+    if (!isArray(declared)) {
+        throw new MalformedSchemaError("type", "the value must be a type name or an array of type names", declared);
+    }
+    if (declared.length === 0) {
+        throw new MalformedSchemaError("type", "the array form must hold at least one name (minItems 1)", declared);
+    }
+    return Object.freeze(declared.map((name) => readTypeName(name)));
 }
 /** True when the document permits an explicit null at this position. */
 export function permitsNull(schema) {

package/dist/json-schema/extensions/json-schema/index.d.ts

@@ -1,4 +1,4 @@
 export { SCHEMA_BRANCH_LABEL, collectDocumentRules, jsonSchemaPlugin, } from "./json-schema";
 export type { JsonSchemaOptions } from "./json-schema";
-export { NotASchemaError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index";
-export type { Draft07Schema, Draft07SchemaObject, JsonSchemaBag, } from "../../index";
+export { DRAFT07_DIALECT_URI, MalformedSchemaError, NotASchemaError, UnsupportedDialectError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index";
+export type { DialectOptions, Draft07Schema, Draft07SchemaObject, JsonSchemaBag, } from "../../index";

package/dist/json-schema/extensions/json-schema/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFormatNames = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Schema = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.RefResolutionError = exports.UnsupportedKeywordError = exports.NotASchemaError = exports.jsonSchemaPlugin = exports.collectDocumentRules = exports.SCHEMA_BRANCH_LABEL = void 0;
+exports.listFormatNames = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Schema = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.RefResolutionError = exports.UnsupportedKeywordError = exports.UnsupportedDialectError = exports.NotASchemaError = exports.MalformedSchemaError = exports.DRAFT07_DIALECT_URI = exports.jsonSchemaPlugin = exports.collectDocumentRules = exports.SCHEMA_BRANCH_LABEL = void 0;
 // ===========================================================================
 // The public subpath `@maroonedog/luq/plugins/jsonSchema`. Re-exports only.
 //
@@ -15,7 +15,10 @@ Object.defineProperty(exports, "SCHEMA_BRANCH_LABEL", { enumerable: true, get: f
 Object.defineProperty(exports, "collectDocumentRules", { enumerable: true, get: function () { return json_schema_1.collectDocumentRules; } });
 Object.defineProperty(exports, "jsonSchemaPlugin", { enumerable: true, get: function () { return json_schema_1.jsonSchemaPlugin; } });
 var index_1 = require("../../index");
+Object.defineProperty(exports, "DRAFT07_DIALECT_URI", { enumerable: true, get: function () { return index_1.DRAFT07_DIALECT_URI; } });
+Object.defineProperty(exports, "MalformedSchemaError", { enumerable: true, get: function () { return index_1.MalformedSchemaError; } });
 Object.defineProperty(exports, "NotASchemaError", { enumerable: true, get: function () { return index_1.NotASchemaError; } });
+Object.defineProperty(exports, "UnsupportedDialectError", { enumerable: true, get: function () { return index_1.UnsupportedDialectError; } });
 Object.defineProperty(exports, "UnsupportedKeywordError", { enumerable: true, get: function () { return index_1.UnsupportedKeywordError; } });
 Object.defineProperty(exports, "RefResolutionError", { enumerable: true, get: function () { return index_1.RefResolutionError; } });
 Object.defineProperty(exports, "buildFieldEntries", { enumerable: true, get: function () { return index_1.buildFieldEntries; } });

package/dist/json-schema/extensions/json-schema/index.mjs

@@ -8,4 +8,4 @@
 // a consumer of this subpath pays only for the plugins they import themselves.
 // ===========================================================================
 export { SCHEMA_BRANCH_LABEL, collectDocumentRules, jsonSchemaPlugin, } from "./json-schema.mjs";
-export { NotASchemaError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index.mjs";
+export { DRAFT07_DIALECT_URI, MalformedSchemaError, NotASchemaError, UnsupportedDialectError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index.mjs";