@maroonedog/luq 2.4.3 → 2.5.0

package/dist/chain/slot-catalog.generated.mjs

@@ -0,0 +1,3 @@
+// GENERATED FILE - do not edit by hand.
+// Generated by scripts/catalog/build-plugin-catalog.ts out of the plugin directory structure.
+export {};

package/dist/core/type-erasure.d.ts

@@ -46,3 +46,23 @@ export declare function eraseBuilderSurface<T extends object>(assembled: object)
  * result is still correct. Exactly one call site is allowed.
  */
 export declare function eraseSchemaValidator<T>(planBacked: object): T;
+/**
+ * Why: useField runs a rule's callback against the BUILDER's slots, and the
+ * two are typed on different bags — the rule's, and the builder's. The
+ * signature proves the relation between them (`keyof BRule extends keyof B`,
+ * i.e. the builder carries at least what the rule was minted from), but that
+ * is a statement about two type parameters and there is no way to write the
+ * value side so the compiler carries it through.
+ *
+ * It used to need no erasure because both sides named one bag `B` and a richer
+ * slot object was simply assignable to a leaner one. That stopped holding when
+ * a slot began carrying a member for every method it does NOT have: where the
+ * rule's bag reports PluginNotImported the builder's may have the real method,
+ * and those two are not assignable in either direction.
+ *
+ * Soundness depends on the subset relation the signature states. The callback
+ * can only call methods its own bag declares, every one of those keys is in
+ * the builder's bag, and a key in the builder's bag is a real method rather
+ * than the not-imported marker.
+ */
+export declare function eraseRuleDefineToBuilderSlots<T>(define: (slots: never) => T): (slots: unknown) => T;

package/dist/core/type-erasure.js

@@ -11,6 +11,7 @@ exports.eraseAssembledRecord = eraseAssembledRecord;
 exports.eraseChainSurface = eraseChainSurface;
 exports.eraseBuilderSurface = eraseBuilderSurface;
 exports.eraseSchemaValidator = eraseSchemaValidator;
+exports.eraseRuleDefineToBuilderSlots = eraseRuleDefineToBuilderSlots;
 /**
  * Why: a record built up key by key has all its keys at run time but stays
  * Record<string, unknown> statically. The generic on the calling side —
@@ -67,3 +68,25 @@ function eraseBuilderSurface(assembled) {
 function eraseSchemaValidator(planBacked) {
     return planBacked;
 }
+/**
+ * Why: useField runs a rule's callback against the BUILDER's slots, and the
+ * two are typed on different bags — the rule's, and the builder's. The
+ * signature proves the relation between them (`keyof BRule extends keyof B`,
+ * i.e. the builder carries at least what the rule was minted from), but that
+ * is a statement about two type parameters and there is no way to write the
+ * value side so the compiler carries it through.
+ *
+ * It used to need no erasure because both sides named one bag `B` and a richer
+ * slot object was simply assignable to a leaner one. That stopped holding when
+ * a slot began carrying a member for every method it does NOT have: where the
+ * rule's bag reports PluginNotImported the builder's may have the real method,
+ * and those two are not assignable in either direction.
+ *
+ * Soundness depends on the subset relation the signature states. The callback
+ * can only call methods its own bag declares, every one of those keys is in
+ * the builder's bag, and a key in the builder's bag is a real method rather
+ * than the not-imported marker.
+ */
+function eraseRuleDefineToBuilderSlots(define) {
+    return define;
+}

package/dist/core/type-erasure.mjs

@@ -61,3 +61,25 @@ export function eraseBuilderSurface(assembled) {
 export function eraseSchemaValidator(planBacked) {
     return planBacked;
 }
+/**
+ * Why: useField runs a rule's callback against the BUILDER's slots, and the
+ * two are typed on different bags — the rule's, and the builder's. The
+ * signature proves the relation between them (`keyof BRule extends keyof B`,
+ * i.e. the builder carries at least what the rule was minted from), but that
+ * is a statement about two type parameters and there is no way to write the
+ * value side so the compiler carries it through.
+ *
+ * It used to need no erasure because both sides named one bag `B` and a richer
+ * slot object was simply assignable to a leaner one. That stopped holding when
+ * a slot began carrying a member for every method it does NOT have: where the
+ * rule's bag reports PluginNotImported the builder's may have the real method,
+ * and those two are not assignable in either direction.
+ *
+ * Soundness depends on the subset relation the signature states. The callback
+ * can only call methods its own bag declares, every one of those keys is in
+ * the builder's bag, and a key in the builder's bag is a real method rather
+ * than the not-imported marker.
+ */
+export function eraseRuleDefineToBuilderSlots(define) {
+    return define;
+}

package/dist/field-rule/use-field.d.ts

@@ -1,6 +1,7 @@
 import type { FieldBuilder } from "../builder/field-builder.types";
 import type { PluginBag } from "../chain/plugin-bag.types";
+import type { FieldRuleNeedsPlugins } from "../chain/plugin-not-imported.types";
 import type { FieldPath } from "../path/field-path.types";
 import type { ValueAtPath } from "../path/value-at-path.types";
 import type { FieldRule } from "./field-rule.types";
-export declare function useField<T extends object, B extends PluginBag, TDeclared extends string, K extends FieldPath<T> & string>(builder: FieldBuilder<T, B, TDeclared>, path: K, rule: FieldRule<ValueAtPath<T, K>, B>): FieldBuilder<T, B, TDeclared | K>;
+export declare function useField<T extends object, B extends PluginBag, BRule extends PluginBag, TDeclared extends string, K extends FieldPath<T> & string>(builder: FieldBuilder<T, B, TDeclared> & (keyof BRule extends keyof B ? unknown : FieldRuleNeedsPlugins<Exclude<keyof BRule, keyof B>>), path: K, rule: FieldRule<ValueAtPath<T, K>, BRule>): FieldBuilder<T, B, TDeclared | K>;

package/dist/field-rule/use-field.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useField = useField;
-function useField(builder, path, rule) {
-    return builder.v(path, rule.define, rule.fieldOptions);
+const type_erasure_1 = require("../core/type-erasure");
+function useField(
+// The gate rides on the BUILDER rather than on the rule, so a builder that
+// is missing plugins fails at the argument that is actually short of them.
+// When it carries what the rule needs the intersection is `& unknown` and
+// changes nothing; when it does not, the builder is asked to be a type no
+// builder is, and the error names the plugins it lacks.
+builder, path, rule) {
+    return builder.v(path, (0, type_erasure_1.eraseRuleDefineToBuilderSlots)(rule.define), rule.fieldOptions);
 }

package/dist/field-rule/use-field.mjs

@@ -1,3 +1,10 @@
-export function useField(builder, path, rule) {
-    return builder.v(path, rule.define, rule.fieldOptions);
+import { eraseRuleDefineToBuilderSlots } from "../core/type-erasure.mjs";
+export function useField(
+// The gate rides on the BUILDER rather than on the rule, so a builder that
+// is missing plugins fails at the argument that is actually short of them.
+// When it carries what the rule needs the intersection is `& unknown` and
+// changes nothing; when it does not, the builder is asked to be a type no
+// builder is, and the error names the plugins it lacks.
+builder, path, rule) {
+    return builder.v(path, eraseRuleDefineToBuilderSlots(rule.define), rule.fieldOptions);
 }

package/dist/json-schema/array-keyword-guards.d.ts

@@ -0,0 +1,31 @@
+import type { Draft07Schema, Draft07SchemaObject } from "./draft07.types";
+/** The two shapes §9.3.1 permits `items` to take. */
+export type ItemsValue = Draft07Schema | readonly Draft07Schema[];
+/**
+ * Reads `items` after checking it against the meta-schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal when it is
+ * neither of the two forms §9.3.1 defines.
+ */
+export declare function readCheckedItems(schema: Draft07SchemaObject): ItemsValue | undefined;
+/**
+ * Reads `additionalItems` after checking it is a single schema: the keyword's
+ * own value, or undefined when the keyword is absent, and a refusal for
+ * anything §4.4 does not call a schema.
+ *
+ * It is read only where §6.4.2 gives the keyword effect, which is beside the
+ * tuple form of `items`; beside the single form the draft ignores it, no rest
+ * branch is built and this reader is never reached.
+ */
+export declare function readCheckedAdditionalItems(schema: Draft07SchemaObject): Draft07Schema | undefined;
+/**
+ * Reads `contains` after checking it is a single schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal for anything
+ * §4.4 does not call a schema. Unlike `items`, `contains` has no array form —
+ * a tuple there is a malformed value, not a second reading.
+ */
+export declare function readCheckedContains(schema: Draft07SchemaObject): Draft07Schema | undefined;
+/**
+ * Reads `uniqueItems` after checking it is a boolean: the keyword's own value,
+ * or undefined when the keyword is absent, and a refusal for anything else.
+ */
+export declare function readCheckedUniqueItems(schema: Draft07SchemaObject): boolean | undefined;

package/dist/json-schema/array-keyword-guards.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCheckedItems = readCheckedItems;
+exports.readCheckedAdditionalItems = readCheckedAdditionalItems;
+exports.readCheckedContains = readCheckedContains;
+exports.readCheckedUniqueItems = readCheckedUniqueItems;
+// ===========================================================================
+// L8  src/json-schema/array-keyword-guards.ts — the meta-schema checks for
+// `items`, `additionalItems`, `contains` and `uniqueItems`, read by
+// flatten-array-schema.ts.
+//
+// Every one of these keywords decides whether a rule EXISTS, and each had a
+// route where a value the meta-schema forbids produced no rule at all rather
+// than an error. `items: 5` is not a schema, but the sub-schema walker takes it
+// anyway and iterates its keys; a number has none, so the walker yields zero
+// rules and every element passes — the document asked for a constraint and the
+// built validator carries an always-true one in its place. `additionalItems: 5`
+// takes that same route for the rest branch, so every element past the tuple
+// goes unchecked. `contains: 5` is the same bug wearing a disguise: an
+// always-true element branch matches the FIRST element, so the existence
+// requirement collapses into "the array is non-empty" — the empty array is
+// still refused, and that lawful-looking verdict is what makes the loss of the
+// real constraint easy to miss. `uniqueItems` is honoured only on a strict
+// `=== true`, so `uniqueItems: "yes"`, the shape a form encoding or a loose
+// YAML loader produces, drops to nothing the same way.
+//
+// A validator that quietly enforces LESS than its document says cannot be
+// detected downstream: it answers "valid" for exactly the inputs the schema
+// meant to refuse, and nothing in the result says a constraint went missing.
+// Build time is therefore the only place a caller can still act, so these
+// read the value and refuse it there.
+//
+// What must survive the refusal, because Draft-07 defines it: `items` has TWO
+// legal forms — one schema for every element, or an ARRAY of schemas where
+// position i constrains element i (§9.3.1) — `additionalItems` and `contains`
+// take the boolean form of a schema as readily as the object form (§4.4), and
+// `uniqueItems: false` is a lawful no-op (§6.4.3), so only a NON-boolean is
+// refused.
+// ===========================================================================
+const types_1 = require("../types");
+const draft07_types_1 = require("./draft07.types");
+const malformed_schema_error_1 = require("./malformed-schema-error");
+const ITEMS_REASON = "the value must be a schema or an array of schemas";
+const UNIQUE_ITEMS_REASON = "the value must be a boolean";
+/**
+ * Reads `items` after checking it against the meta-schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal when it is
+ * neither of the two forms §9.3.1 defines.
+ */
+function readCheckedItems(schema) {
+    const items = schema.items;
+    if (items === undefined)
+        return undefined;
+    if ((0, types_1.isArray)(items))
+        return checkTuplePositions(items);
+    if (!(0, draft07_types_1.isDraft07Schema)(items)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("items", ITEMS_REASON, items);
+    }
+    return items;
+}
+/**
+ * Every position of the tuple form is a schema in its own right, so a bad one
+ * names its index: with the whole array rendered instead, a caller holding a
+ * long tuple is told only that something in it is wrong.
+ */
+function checkTuplePositions(positions) {
+    for (let index = 0; index < positions.length; index += 1) {
+        const position = positions[index];
+        if ((0, draft07_types_1.isDraft07Schema)(position))
+            continue;
+        throw new malformed_schema_error_1.MalformedSchemaError("items", `position ${String(index)} of the array form ${malformed_schema_error_1.SCHEMA_FORMS}`, position);
+    }
+    return positions;
+}
+/**
+ * Reads `additionalItems` after checking it is a single schema: the keyword's
+ * own value, or undefined when the keyword is absent, and a refusal for
+ * anything §4.4 does not call a schema.
+ *
+ * It is read only where §6.4.2 gives the keyword effect, which is beside the
+ * tuple form of `items`; beside the single form the draft ignores it, no rest
+ * branch is built and this reader is never reached.
+ */
+function readCheckedAdditionalItems(schema) {
+    const additionalItems = schema.additionalItems;
+    if (additionalItems === undefined)
+        return undefined;
+    if (!(0, draft07_types_1.isDraft07Schema)(additionalItems)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("additionalItems", `the value ${malformed_schema_error_1.SCHEMA_FORMS}`, additionalItems);
+    }
+    return additionalItems;
+}
+/**
+ * Reads `contains` after checking it is a single schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal for anything
+ * §4.4 does not call a schema. Unlike `items`, `contains` has no array form —
+ * a tuple there is a malformed value, not a second reading.
+ */
+function readCheckedContains(schema) {
+    const contains = schema.contains;
+    if (contains === undefined)
+        return undefined;
+    if (!(0, draft07_types_1.isDraft07Schema)(contains)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("contains", `the value ${malformed_schema_error_1.SCHEMA_FORMS}`, contains);
+    }
+    return contains;
+}
+/**
+ * Reads `uniqueItems` after checking it is a boolean: the keyword's own value,
+ * or undefined when the keyword is absent, and a refusal for anything else.
+ */
+function readCheckedUniqueItems(schema) {
+    const uniqueItems = schema.uniqueItems;
+    if (uniqueItems === undefined)
+        return undefined;
+    if (typeof uniqueItems !== "boolean") {
+        throw new malformed_schema_error_1.MalformedSchemaError("uniqueItems", UNIQUE_ITEMS_REASON, uniqueItems);
+    }
+    return uniqueItems;
+}

package/dist/json-schema/array-keyword-guards.mjs

@@ -0,0 +1,114 @@
+// ===========================================================================
+// L8  src/json-schema/array-keyword-guards.ts — the meta-schema checks for
+// `items`, `additionalItems`, `contains` and `uniqueItems`, read by
+// flatten-array-schema.ts.
+//
+// Every one of these keywords decides whether a rule EXISTS, and each had a
+// route where a value the meta-schema forbids produced no rule at all rather
+// than an error. `items: 5` is not a schema, but the sub-schema walker takes it
+// anyway and iterates its keys; a number has none, so the walker yields zero
+// rules and every element passes — the document asked for a constraint and the
+// built validator carries an always-true one in its place. `additionalItems: 5`
+// takes that same route for the rest branch, so every element past the tuple
+// goes unchecked. `contains: 5` is the same bug wearing a disguise: an
+// always-true element branch matches the FIRST element, so the existence
+// requirement collapses into "the array is non-empty" — the empty array is
+// still refused, and that lawful-looking verdict is what makes the loss of the
+// real constraint easy to miss. `uniqueItems` is honoured only on a strict
+// `=== true`, so `uniqueItems: "yes"`, the shape a form encoding or a loose
+// YAML loader produces, drops to nothing the same way.
+//
+// A validator that quietly enforces LESS than its document says cannot be
+// detected downstream: it answers "valid" for exactly the inputs the schema
+// meant to refuse, and nothing in the result says a constraint went missing.
+// Build time is therefore the only place a caller can still act, so these
+// read the value and refuse it there.
+//
+// What must survive the refusal, because Draft-07 defines it: `items` has TWO
+// legal forms — one schema for every element, or an ARRAY of schemas where
+// position i constrains element i (§9.3.1) — `additionalItems` and `contains`
+// take the boolean form of a schema as readily as the object form (§4.4), and
+// `uniqueItems: false` is a lawful no-op (§6.4.3), so only a NON-boolean is
+// refused.
+// ===========================================================================
+import { isArray } from "../types/index.mjs";
+import { isDraft07Schema } from "./draft07.types.mjs";
+import { MalformedSchemaError, SCHEMA_FORMS } from "./malformed-schema-error.mjs";
+const ITEMS_REASON = "the value must be a schema or an array of schemas";
+const UNIQUE_ITEMS_REASON = "the value must be a boolean";
+/**
+ * Reads `items` after checking it against the meta-schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal when it is
+ * neither of the two forms §9.3.1 defines.
+ */
+export function readCheckedItems(schema) {
+    const items = schema.items;
+    if (items === undefined)
+        return undefined;
+    if (isArray(items))
+        return checkTuplePositions(items);
+    if (!isDraft07Schema(items)) {
+        throw new MalformedSchemaError("items", ITEMS_REASON, items);
+    }
+    return items;
+}
+/**
+ * Every position of the tuple form is a schema in its own right, so a bad one
+ * names its index: with the whole array rendered instead, a caller holding a
+ * long tuple is told only that something in it is wrong.
+ */
+function checkTuplePositions(positions) {
+    for (let index = 0; index < positions.length; index += 1) {
+        const position = positions[index];
+        if (isDraft07Schema(position))
+            continue;
+        throw new MalformedSchemaError("items", `position ${String(index)} of the array form ${SCHEMA_FORMS}`, position);
+    }
+    return positions;
+}
+/**
+ * Reads `additionalItems` after checking it is a single schema: the keyword's
+ * own value, or undefined when the keyword is absent, and a refusal for
+ * anything §4.4 does not call a schema.
+ *
+ * It is read only where §6.4.2 gives the keyword effect, which is beside the
+ * tuple form of `items`; beside the single form the draft ignores it, no rest
+ * branch is built and this reader is never reached.
+ */
+export function readCheckedAdditionalItems(schema) {
+    const additionalItems = schema.additionalItems;
+    if (additionalItems === undefined)
+        return undefined;
+    if (!isDraft07Schema(additionalItems)) {
+        throw new MalformedSchemaError("additionalItems", `the value ${SCHEMA_FORMS}`, additionalItems);
+    }
+    return additionalItems;
+}
+/**
+ * Reads `contains` after checking it is a single schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal for anything
+ * §4.4 does not call a schema. Unlike `items`, `contains` has no array form —
+ * a tuple there is a malformed value, not a second reading.
+ */
+export function readCheckedContains(schema) {
+    const contains = schema.contains;
+    if (contains === undefined)
+        return undefined;
+    if (!isDraft07Schema(contains)) {
+        throw new MalformedSchemaError("contains", `the value ${SCHEMA_FORMS}`, contains);
+    }
+    return contains;
+}
+/**
+ * Reads `uniqueItems` after checking it is a boolean: the keyword's own value,
+ * or undefined when the keyword is absent, and a refusal for anything else.
+ */
+export function readCheckedUniqueItems(schema) {
+    const uniqueItems = schema.uniqueItems;
+    if (uniqueItems === undefined)
+        return undefined;
+    if (typeof uniqueItems !== "boolean") {
+        throw new MalformedSchemaError("uniqueItems", UNIQUE_ITEMS_REASON, uniqueItems);
+    }
+    return uniqueItems;
+}

package/dist/json-schema/assert-object-keyword-values.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `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 declare function assertRequiredIsNameList(value: unknown): void;
+/**
+ * `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 declare function assertPropertiesIsSchemaMap(value: unknown): void;
+/**
+ * `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 declare function assertAdditionalPropertiesIsSchema(value: unknown): void;
+/**
+ * `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 declare function assertPatternPropertiesIsSchemaMap(value: unknown): void;
+/**
+ * `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 declare function assertPropertyNamesIsSchema(value: unknown): void;
+/**
+ * `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 declare function assertDependenciesIsSchemaOrNameListMap(value: unknown): void;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRequiredIsNameList = assertRequiredIsNameList;
+exports.assertPropertiesIsSchemaMap = assertPropertiesIsSchemaMap;
+exports.assertAdditionalPropertiesIsSchema = assertAdditionalPropertiesIsSchema;
+exports.assertPatternPropertiesIsSchemaMap = assertPatternPropertiesIsSchemaMap;
+exports.assertPropertyNamesIsSchema = assertPropertyNamesIsSchema;
+exports.assertDependenciesIsSchemaOrNameListMap = assertDependenciesIsSchemaOrNameListMap;
+// ===========================================================================
+// 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.
+// ===========================================================================
+const types_1 = require("../types");
+const draft07_types_1 = require("./draft07.types");
+const malformed_schema_error_1 = require("./malformed-schema-error");
+/**
+ * `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.
+ */
+function assertRequiredIsNameList(value) {
+    if (value === undefined || (0, types_1.isStringArray)(value))
+        return;
+    throw new malformed_schema_error_1.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 (!(0, types_1.isPlainObject)(value)) {
+        throw new malformed_schema_error_1.MalformedSchemaError(keyword, mapReason, value);
+    }
+    for (const [key, member] of Object.entries(value)) {
+        if ((0, draft07_types_1.isDraft07Schema)(member))
+            continue;
+        throw new malformed_schema_error_1.MalformedSchemaError(keyword, `the schema under "${key}" ${malformed_schema_error_1.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.
+ */
+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.
+ */
+function assertAdditionalPropertiesIsSchema(value) {
+    if (value === undefined || (0, draft07_types_1.isDraft07Schema)(value))
+        return;
+    throw new malformed_schema_error_1.MalformedSchemaError("additionalProperties", `the value ${malformed_schema_error_1.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.
+ */
+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.
+ */
+function assertPropertyNamesIsSchema(value) {
+    if (value === undefined || (0, draft07_types_1.isDraft07Schema)(value))
+        return;
+    throw new malformed_schema_error_1.MalformedSchemaError("propertyNames", `the value ${malformed_schema_error_1.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.
+ */
+function assertDependenciesIsSchemaOrNameListMap(value) {
+    if (value === undefined)
+        return;
+    if (!(0, types_1.isPlainObject)(value)) {
+        throw new malformed_schema_error_1.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 ((0, types_1.isStringArray)(dependency) || (0, draft07_types_1.isDraft07Schema)(dependency))
+            continue;
+        throw new malformed_schema_error_1.MalformedSchemaError("dependencies", `the dependency under "${key}" ${malformed_schema_error_1.SCHEMA_FORMS}, or an array of ` +
+            "property names", dependency);
+    }
+}