@maroonedog/luq 2.4.3 → 2.5.0

package/dist/json-schema/assert-object-keyword-values.mjs

@@ -0,0 +1,141 @@
+// ===========================================================================
+// L8  src/json-schema/assert-object-keyword-values.ts — the meta-schema check
+// on the VALUES of the object-family keywords: `required`, `properties`,
+// `additionalProperties`, `patternProperties`, `propertyNames` and
+// `dependencies`.
+//
+// They live together because they fail together: every one is read in a place
+// that trusts the declared type, and untyped JSON reaches all six. `required:
+// "name"` is iterated as a string and declares one phantom child per
+// CHARACTER; `properties: {a: null}` is read for a pointer; the remaining four
+// take the sub-schema route with a value that is not a schema at all, and the
+// walker finds no keys on a primitive, so it yields a branch holding no rules.
+//
+// That last outcome is the SILENT one, and it is the one that matters most: a
+// document saying "no extra properties", or "every key beginning with a_ holds
+// a string", compiles to a validator that accepts everything. It is what a
+// config service serialising booleans as strings produces, and what a
+// hand-edited document with a quoted sub-schema produces. The loud failures
+// are loud in the wrong place — a raw TypeError read off null somewhere deep
+// in the walker, naming neither the keyword nor the document.
+//
+// Refusal is therefore always at BUILD time, and every well-formed shape is
+// untouched: a name list, a map of schemas (including the §4.4 boolean form),
+// a single schema, and — under `dependencies` — either a schema or an array of
+// property names, which §6.5.7 makes equally lawful under the same key.
+// ===========================================================================
+import { isPlainObject, isStringArray } from "../types/index.mjs";
+import { isDraft07Schema } from "./draft07.types.mjs";
+import { MalformedSchemaError, SCHEMA_FORMS } from "./malformed-schema-error.mjs";
+/**
+ * `required` is an array of property names (§6.5.3), and whatever the document
+ * put there is refused when it is anything else.
+ *
+ * UNIQUENESS IS NOT ENFORCED, although the meta-schema's `stringArray` asks
+ * for it. A repeated name asks for nothing the single name does not — the
+ * property is required either way, so the verdict is identical — and this
+ * check exists to stop a validator enforcing LESS than its document, not to
+ * lint a document that is enforced exactly as written. Refusing a duplicate
+ * would reject working schemas for no gain in correctness.
+ */
+export function assertRequiredIsNameList(value) {
+    if (value === undefined || isStringArray(value))
+        return;
+    throw new MalformedSchemaError("required", "the value must be an array of property names", value);
+}
+/**
+ * `properties` and `patternProperties` differ only in what their KEYS mean, so
+ * they are checked the same way: the map itself, then every member of it, and
+ * the offending key named in the reason so the message points at one entry
+ * rather than at a map that may hold a dozen. `dependencies` is not routed
+ * through here — §6.5.7 gives its members a second lawful form, which is a
+ * different member check and a different sentence.
+ *
+ * `mapReason` is the keyword's own, because "an object mapping property names
+ * to schemas" and "an object mapping regular expressions to schemas" are the
+ * only part of the requirement the two keywords do not share.
+ */
+function assertSchemaMap(keyword, mapReason, value) {
+    if (value === undefined)
+        return;
+    if (!isPlainObject(value)) {
+        throw new MalformedSchemaError(keyword, mapReason, value);
+    }
+    for (const [key, member] of Object.entries(value)) {
+        if (isDraft07Schema(member))
+            continue;
+        throw new MalformedSchemaError(keyword, `the schema under "${key}" ${SCHEMA_FORMS}`, member);
+    }
+}
+/**
+ * `properties` maps property names to schemas (§6.5.4), and a schema is an
+ * object or a boolean; the map itself and every member of it are refused when
+ * they are not. The key is named in the reason so the message points at the
+ * offending node rather than at the whole document.
+ */
+export function assertPropertiesIsSchemaMap(value) {
+    assertSchemaMap("properties", "the value must be an object mapping property names to schemas", value);
+}
+/**
+ * `additionalProperties` is a schema, and §4.4 makes a boolean one (§6.5.6).
+ * Both of those forms pass through unchanged; only a value the meta-schema
+ * already forbids — a string, a number, an array, null — is refused.
+ */
+export function assertAdditionalPropertiesIsSchema(value) {
+    if (value === undefined || isDraft07Schema(value))
+        return;
+    throw new MalformedSchemaError("additionalProperties", `the value ${SCHEMA_FORMS}`, value);
+}
+/**
+ * `patternProperties` maps regular expressions to schemas (§6.5.5). The map
+ * itself and every member of it are refused when they are not schemas, and the
+ * pattern is named in the reason so the message points at the one offending
+ * entry rather than at a map that may hold a dozen.
+ *
+ * THE KEYS ARE DELIBERATELY NOT COMPILED HERE, although Draft-07 says each
+ * SHOULD be a valid ECMA-262 pattern. A key that will not compile is not the
+ * failure this module exists to stop: the plugin compiles every key while
+ * building its rule, so such a key already kills the build, loudly, before any
+ * validator exists — it is a SyntaxError rather than a typed refusal, but
+ * nothing is silently under-enforced. Compiling one here as well would put a
+ * SECOND `new RegExp` in the converter, which holds exactly one — the `pattern`
+ * keyword's, over the document's own source string — so that regex
+ * construction and its flag handling stay in a single place.
+ */
+export function assertPatternPropertiesIsSchemaMap(value) {
+    assertSchemaMap("patternProperties", "the value must be an object mapping regular expressions to schemas", value);
+}
+/**
+ * `propertyNames` is ONE schema, applied to every property name (§6.5.8), and
+ * §4.4 makes a boolean one. An ARRAY is the shape of a schema list and is not
+ * itself a schema, so it is refused along with every primitive. An object
+ * stands whatever keywords it carries, because §4.3 has a schema ignore the
+ * keywords it does not recognise rather than be invalid for holding them.
+ */
+export function assertPropertyNamesIsSchema(value) {
+    if (value === undefined || isDraft07Schema(value))
+        return;
+    throw new MalformedSchemaError("propertyNames", `the value ${SCHEMA_FORMS}`, value);
+}
+/**
+ * `dependencies` maps a property name to what its presence demands (§6.5.7),
+ * and the draft gives that two equally lawful forms under the same key: an
+ * ARRAY of property names, which makes those names required alongside it, or a
+ * SCHEMA the whole instance must then satisfy. Both are kept; only a value
+ * that is neither is refused, and the key is named so the message points at
+ * the one offending entry rather than at the whole map.
+ */
+export function assertDependenciesIsSchemaOrNameListMap(value) {
+    if (value === undefined)
+        return;
+    if (!isPlainObject(value)) {
+        throw new MalformedSchemaError("dependencies", "the value must be an object mapping property names to schemas or to " +
+            "arrays of property names", value);
+    }
+    for (const [key, dependency] of Object.entries(value)) {
+        if (isStringArray(dependency) || isDraft07Schema(dependency))
+            continue;
+        throw new MalformedSchemaError("dependencies", `the dependency under "${key}" ${SCHEMA_FORMS}, or an array of ` +
+            "property names", dependency);
+    }
+}

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 { MalformedSchemaError, NotASchemaError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index";
 export type { 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.NotASchemaError = exports.MalformedSchemaError = exports.jsonSchemaPlugin = exports.collectDocumentRules = exports.SCHEMA_BRANCH_LABEL = void 0;
 // ===========================================================================
 // The public subpath `@maroonedog/luq/plugins/jsonSchema`. Re-exports only.
 //
@@ -15,6 +15,7 @@ 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, "MalformedSchemaError", { enumerable: true, get: function () { return index_1.MalformedSchemaError; } });
 Object.defineProperty(exports, "NotASchemaError", { enumerable: true, get: function () { return index_1.NotASchemaError; } });
 Object.defineProperty(exports, "UnsupportedKeywordError", { enumerable: true, get: function () { return index_1.UnsupportedKeywordError; } });
 Object.defineProperty(exports, "RefResolutionError", { enumerable: true, get: function () { return index_1.RefResolutionError; } });