@maroonedog/luq 2.4.3 → 2.5.0

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 { MalformedSchemaError, NotASchemaError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index.mjs";

package/dist/json-schema/flatten-array-schema.d.ts

@@ -6,6 +6,10 @@ export declare const EACH_STEP = "[*]";
 /**
  * The single form only. The tuple form gets no child path: element 0 and
  * element 1 obey DIFFERENT schemas, and one declared `[*]` cannot say that.
+ *
+ * Reading through readCheckedItems is what stops a non-schema value here from
+ * becoming a child declaration whose sub-schema yields no rules at all; see
+ * array-keyword-guards.ts.
  */
 export declare function readItemChildren(schema: Draft07SchemaObject): readonly ChildSchema[];
 export declare function composeTupleItems(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
@@ -13,6 +17,10 @@ export declare function composeTupleItems(schema: Draft07SchemaObject, context:
  * `contains` is EXISTENTIAL: at least one element matches. arrayContains owns
  * that reduction, and its default bounds (min 1, no max) are exactly the
  * draft's, so this is one call and no arithmetic.
+ *
+ * An element branch holding no rules would satisfy the existence check on the
+ * first element and turn the keyword into "the array is non-empty", so the
+ * value is read through array-keyword-guards.ts.
  */
 export declare function composeContains(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
 /**
@@ -20,6 +28,8 @@ export declare function composeContains(schema: Draft07SchemaObject, context: St
  * and `maxItems` to `maxLength`; writing "minItems" as the method name does not
  * compile (keyword-map-array.ts), which is the C2 regression made impossible.
  * `uniqueItems: false` never reaches its binding: §6.4.3 gives it no effect and
- * the binding's value type is `true`.
+ * the binding's value type is `true`. That is why the value is read through
+ * readCheckedUniqueItems: with a bare `=== true`, a non-boolean would take the
+ * same silent route as the lawful `false` and lose the constraint entirely.
  */
 export declare function declareArrayRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/flatten-array-schema.js

@@ -33,6 +33,7 @@ const create_chain_node_1 = require("../chain/create-chain-node");
 const create_field_slots_1 = require("../chain/create-field-slots");
 const create_rule_1 = require("../plugin-kit/create-rule");
 const apply_keyword_binding_1 = require("./apply-keyword-binding");
+const array_keyword_guards_1 = require("./array-keyword-guards");
 const keyword_map_array_1 = require("./keyword-map-array");
 const types_1 = require("../types");
 const collect_definitions_1 = require("./collect-definitions");
@@ -47,9 +48,13 @@ function isTupleItems(items) {
 /**
  * The single form only. The tuple form gets no child path: element 0 and
  * element 1 obey DIFFERENT schemas, and one declared `[*]` cannot say that.
+ *
+ * Reading through readCheckedItems is what stops a non-schema value here from
+ * becoming a child declaration whose sub-schema yields no rules at all; see
+ * array-keyword-guards.ts.
  */
 function readItemChildren(schema) {
-    const items = schema.items;
+    const items = (0, array_keyword_guards_1.readCheckedItems)(schema);
     if (items === undefined || isTupleItems(items))
         return NO_CHILDREN;
     return Object.freeze([{ step: exports.EACH_STEP, schema: items, isRequired: false }]);
@@ -58,7 +63,9 @@ function readItemChildren(schema) {
  * Element i against position i, extra elements against `additionalItems`.
  * A non-array passes, a short array passes, and `additionalItems: false`
  * becomes the schema that matches nothing (collect-definitions), so the
- * "no extra elements" case needs no fourth branch kind.
+ * "no extra elements" case needs no fourth branch kind. A rest branch built
+ * from a non-schema would carry no rules and check none of those elements,
+ * which is why the value is read through array-keyword-guards.ts.
  */
 function applyPositionally(runners, positionCount, hasRest) {
     return (value, ctx) => {
@@ -85,11 +92,11 @@ function describePosition(index) {
         : `Element ${String(index)} does not match the schema declared for it`;
 }
 function composeTupleItems(schema, context) {
-    const items = schema.items;
+    const items = (0, array_keyword_guards_1.readCheckedItems)(schema);
     if (items === undefined || !isTupleItems(items))
         return NO_RULES;
     const branches = items.map((position, index) => context.toBranch(`position:${String(index)}`, position));
-    const rest = schema.additionalItems;
+    const rest = (0, array_keyword_guards_1.readCheckedAdditionalItems)(schema);
     const hasRest = rest !== undefined;
     if (rest !== undefined)
         branches.push(context.toBranch("rest", rest));
@@ -109,9 +116,13 @@ function composeTupleItems(schema, context) {
  * `contains` is EXISTENTIAL: at least one element matches. arrayContains owns
  * that reduction, and its default bounds (min 1, no max) are exactly the
  * draft's, so this is one call and no arithmetic.
+ *
+ * An element branch holding no rules would satisfy the existence check on the
+ * first element and turn the keyword into "the array is non-empty", so the
+ * value is read through array-keyword-guards.ts.
  */
 function composeContains(schema, context) {
-    const contains = schema.contains;
+    const contains = (0, array_keyword_guards_1.readCheckedContains)(schema);
     if (contains === undefined)
         return NO_RULES;
     const element = context.collectSubSchemaRules((0, collect_definitions_1.toSchemaObject)(contains));
@@ -124,7 +135,9 @@ function composeContains(schema, context) {
  * and `maxItems` to `maxLength`; writing "minItems" as the method name does not
  * compile (keyword-map-array.ts), which is the C2 regression made impossible.
  * `uniqueItems: false` never reaches its binding: §6.4.3 gives it no effect and
- * the binding's value type is `true`.
+ * the binding's value type is `true`. That is why the value is read through
+ * readCheckedUniqueItems: with a bare `=== true`, a non-boolean would take the
+ * same silent route as the lawful `false` and lose the constraint entirely.
  */
 function declareArrayRules(schema, context) {
     let chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).array;
@@ -134,7 +147,7 @@ function declareArrayRules(schema, context) {
     if (schema.maxItems !== undefined) {
         chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_array_1.maxItemsBinding, schema.maxItems);
     }
-    if (schema.uniqueItems === true) {
+    if ((0, array_keyword_guards_1.readCheckedUniqueItems)(schema) === true) {
         chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_array_1.uniqueItemsBinding, true);
     }
     return (0, create_chain_node_1.readChainRules)(chain) ?? NO_RULES;

package/dist/json-schema/flatten-array-schema.mjs

@@ -26,6 +26,7 @@ import { readChainRules } from "../chain/create-chain-node.mjs";
 import { createFieldSlots } from "../chain/create-field-slots.mjs";
 import { composite } from "../plugin-kit/create-rule.mjs";
 import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
+import { readCheckedAdditionalItems, readCheckedContains, readCheckedItems, readCheckedUniqueItems, } from "./array-keyword-guards.mjs";
 import { maxItemsBinding, minItemsBinding, uniqueItemsBinding, } from "./keyword-map-array.mjs";
 import { PASS, fail, isArray, isNumber } from "../types/index.mjs";
 import { toSchemaObject } from "./collect-definitions.mjs";
@@ -40,9 +41,13 @@ function isTupleItems(items) {
 /**
  * The single form only. The tuple form gets no child path: element 0 and
  * element 1 obey DIFFERENT schemas, and one declared `[*]` cannot say that.
+ *
+ * Reading through readCheckedItems is what stops a non-schema value here from
+ * becoming a child declaration whose sub-schema yields no rules at all; see
+ * array-keyword-guards.ts.
  */
 export function readItemChildren(schema) {
-    const items = schema.items;
+    const items = readCheckedItems(schema);
     if (items === undefined || isTupleItems(items))
         return NO_CHILDREN;
     return Object.freeze([{ step: EACH_STEP, schema: items, isRequired: false }]);
@@ -51,7 +56,9 @@ export function readItemChildren(schema) {
  * Element i against position i, extra elements against `additionalItems`.
  * A non-array passes, a short array passes, and `additionalItems: false`
  * becomes the schema that matches nothing (collect-definitions), so the
- * "no extra elements" case needs no fourth branch kind.
+ * "no extra elements" case needs no fourth branch kind. A rest branch built
+ * from a non-schema would carry no rules and check none of those elements,
+ * which is why the value is read through array-keyword-guards.ts.
  */
 function applyPositionally(runners, positionCount, hasRest) {
     return (value, ctx) => {
@@ -78,11 +85,11 @@ function describePosition(index) {
         : `Element ${String(index)} does not match the schema declared for it`;
 }
 export function composeTupleItems(schema, context) {
-    const items = schema.items;
+    const items = readCheckedItems(schema);
     if (items === undefined || !isTupleItems(items))
         return NO_RULES;
     const branches = items.map((position, index) => context.toBranch(`position:${String(index)}`, position));
-    const rest = schema.additionalItems;
+    const rest = readCheckedAdditionalItems(schema);
     const hasRest = rest !== undefined;
     if (rest !== undefined)
         branches.push(context.toBranch("rest", rest));
@@ -102,9 +109,13 @@ export function composeTupleItems(schema, context) {
  * `contains` is EXISTENTIAL: at least one element matches. arrayContains owns
  * that reduction, and its default bounds (min 1, no max) are exactly the
  * draft's, so this is one call and no arithmetic.
+ *
+ * An element branch holding no rules would satisfy the existence check on the
+ * first element and turn the keyword into "the array is non-empty", so the
+ * value is read through array-keyword-guards.ts.
  */
 export function composeContains(schema, context) {
-    const contains = schema.contains;
+    const contains = readCheckedContains(schema);
     if (contains === undefined)
         return NO_RULES;
     const element = context.collectSubSchemaRules(toSchemaObject(contains));
@@ -117,7 +128,9 @@ export function composeContains(schema, context) {
  * and `maxItems` to `maxLength`; writing "minItems" as the method name does not
  * compile (keyword-map-array.ts), which is the C2 regression made impossible.
  * `uniqueItems: false` never reaches its binding: §6.4.3 gives it no effect and
- * the binding's value type is `true`.
+ * the binding's value type is `true`. That is why the value is read through
+ * readCheckedUniqueItems: with a bare `=== true`, a non-boolean would take the
+ * same silent route as the lawful `false` and lose the constraint entirely.
  */
 export function declareArrayRules(schema, context) {
     let chain = createFieldSlots(context.bag, context.build).array;
@@ -127,7 +140,7 @@ export function declareArrayRules(schema, context) {
     if (schema.maxItems !== undefined) {
         chain = applyKeywordBinding(chain, maxItemsBinding, schema.maxItems);
     }
-    if (schema.uniqueItems === true) {
+    if (readCheckedUniqueItems(schema) === true) {
         chain = applyKeywordBinding(chain, uniqueItemsBinding, true);
     }
     return readChainRules(chain) ?? NO_RULES;

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

@@ -17,6 +17,7 @@ export { createDocumentScope, createLocalScope } from "./ref-scope";
 export type { SchemaRegistry } from "./schema-registry";
 export { createSchemaRegistry } from "./schema-registry";
 export { UnsupportedKeywordError } from "./unsupported-keyword-error";
+export { MalformedSchemaError } from "./malformed-schema-error";
 export { isDraft07Schema, isSchemaObject } from "./draft07.types";
 export type { Draft07Schema, Draft07SchemaObject, Draft07TypeKeyword, } from "./draft07.types";
 export { assertKeywordSupported, countKeywordHandlings, findKeywordHandling, isDraft07Keyword, listBoundPluginNames, listDraft07Keywords, } from "./keyword-map";

package/dist/json-schema/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFormatNames = exports.findFormatHandling = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Keyword = exports.findKeywordHandling = exports.countKeywordHandlings = exports.assertKeywordSupported = exports.isSchemaObject = exports.isDraft07Schema = exports.UnsupportedKeywordError = exports.createSchemaRegistry = exports.createLocalScope = exports.createDocumentScope = exports.resolveRefInScope = exports.resolveRef = exports.isResolvableRef = exports.RefResolutionError = exports.declarePresenceRules = exports.declareRequiredProperties = exports.createStructuralContext = exports.toSchemaBranch = exports.collectSubSchemaRules = exports.readChildSchemas = exports.isStructuralKeyword = exports.expandSchemaRules = exports.STRUCTURAL_EXPANSIONS = exports.joinDeclaredPath = exports.flattenSchema = exports.toSchemaObject = exports.resolveSchemaNodeInScope = exports.resolveSchemaNode = exports.readRefPointer = exports.isDefinitionContainer = exports.collectDefinitionNames = exports.DEFINITION_CONTAINERS = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.NotASchemaError = void 0;
+exports.listFormatNames = exports.findFormatHandling = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Keyword = exports.findKeywordHandling = exports.countKeywordHandlings = exports.assertKeywordSupported = exports.isSchemaObject = exports.isDraft07Schema = exports.MalformedSchemaError = exports.UnsupportedKeywordError = exports.createSchemaRegistry = exports.createLocalScope = exports.createDocumentScope = exports.resolveRefInScope = exports.resolveRef = exports.isResolvableRef = exports.RefResolutionError = exports.declarePresenceRules = exports.declareRequiredProperties = exports.createStructuralContext = exports.toSchemaBranch = exports.collectSubSchemaRules = exports.readChildSchemas = exports.isStructuralKeyword = exports.expandSchemaRules = exports.STRUCTURAL_EXPANSIONS = exports.joinDeclaredPath = exports.flattenSchema = exports.toSchemaObject = exports.resolveSchemaNodeInScope = exports.resolveSchemaNode = exports.readRefPointer = exports.isDefinitionContainer = exports.collectDefinitionNames = exports.DEFINITION_CONTAINERS = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.NotASchemaError = void 0;
 // ===========================================================================
 // L8  src/json-schema/index.ts — re-exports only. Nothing is defined here.
 //
@@ -50,6 +50,8 @@ var schema_registry_1 = require("./schema-registry");
 Object.defineProperty(exports, "createSchemaRegistry", { enumerable: true, get: function () { return schema_registry_1.createSchemaRegistry; } });
 var unsupported_keyword_error_1 = require("./unsupported-keyword-error");
 Object.defineProperty(exports, "UnsupportedKeywordError", { enumerable: true, get: function () { return unsupported_keyword_error_1.UnsupportedKeywordError; } });
+var malformed_schema_error_1 = require("./malformed-schema-error");
+Object.defineProperty(exports, "MalformedSchemaError", { enumerable: true, get: function () { return malformed_schema_error_1.MalformedSchemaError; } });
 var draft07_types_1 = require("./draft07.types");
 Object.defineProperty(exports, "isDraft07Schema", { enumerable: true, get: function () { return draft07_types_1.isDraft07Schema; } });
 Object.defineProperty(exports, "isSchemaObject", { enumerable: true, get: function () { return draft07_types_1.isSchemaObject; } });

package/dist/json-schema/index.mjs

@@ -17,6 +17,7 @@ export { isResolvableRef, resolveRef, resolveRefInScope } from "./resolve-ref.mj
 export { createDocumentScope, createLocalScope } from "./ref-scope.mjs";
 export { createSchemaRegistry } from "./schema-registry.mjs";
 export { UnsupportedKeywordError } from "./unsupported-keyword-error.mjs";
+export { MalformedSchemaError } from "./malformed-schema-error.mjs";
 export { isDraft07Schema, isSchemaObject } from "./draft07.types.mjs";
 export { assertKeywordSupported, countKeywordHandlings, findKeywordHandling, isDraft07Keyword, listBoundPluginNames, listDraft07Keywords, } from "./keyword-map.mjs";
 export { findFormatHandling, listFormatNames } from "./format-map.mjs";

package/dist/json-schema/keyword-map-string.js

@@ -10,7 +10,9 @@ exports.stringKeywordMap = exports.contentMediaTypeBinding = exports.contentEnco
 // table in this repository — 1.x shipped three of them and they disagreed
 // (docs/legacy-spec/json-schema-mapping.md records the disagreements).
 // ===========================================================================
+const types_1 = require("../types");
 const bind_keyword_1 = require("./bind-keyword");
+const malformed_schema_error_1 = require("./malformed-schema-error");
 const string_min_1 = require("../plugins/string-min");
 const string_max_1 = require("../plugins/string-max");
 const string_pattern_1 = require("../plugins/string-pattern");
@@ -18,13 +20,40 @@ const string_content_encoding_1 = require("../plugins/string-content-encoding");
 const string_content_media_type_1 = require("../plugins/string-content-media-type");
 exports.minLengthBinding = (0, bind_keyword_1.bindKeyword)("string", "min", string_min_1.stringMinPlugin, (v) => [v]);
 exports.maxLengthBinding = (0, bind_keyword_1.bindKeyword)("string", "max", string_max_1.stringMaxPlugin, (v) => [v]);
+/**
+ * Compiles the document's source, refusing anything the meta-schema forbids.
+ *
+ * The parameter is `unknown` although the keyword's value type is `string`,
+ * and that is the whole point: compiling is a TOTAL operation on JSON values —
+ * every one of them has a string form — so a number becomes a literal digit
+ * pattern and an object becomes one that matches almost every string. Both
+ * then reach stringPattern as a perfectly valid RegExp, leaving its
+ * non-RegExp guard nothing to fire on. The refusal has to be here, before the
+ * value is turned into something well formed.
+ *
+ * A string that is not a valid ECMA-262 pattern is the same failure wearing a
+ * different coat: the compile step throws a SyntaxError naming neither the
+ * keyword nor the document, so it is caught and re-raised as the typed refusal
+ * every other malformed value gets.
+ */
+function compilePattern(source) {
+    if (!(0, types_1.isString)(source)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("pattern", "the value must be a string", source);
+    }
+    try {
+        return new RegExp(source);
+    }
+    catch {
+        throw new malformed_schema_error_1.MalformedSchemaError("pattern", "the value must be a valid ECMA-262 regular expression", source);
+    }
+}
 /**
  * Draft-07 spells `pattern` as an ECMA-262 SOURCE string; the plugin accepts a
  * RegExp and only a RegExp, because 1.x's `new RegExp(source)` at the call site
  * dropped flags silently and gave the caller no compile-time check. Compiling
  * the schema's string therefore happens HERE, once, and nowhere else.
  */
-exports.patternBinding = (0, bind_keyword_1.bindKeyword)("string", "pattern", string_pattern_1.stringPatternPlugin, (v) => [new RegExp(v)]);
+exports.patternBinding = (0, bind_keyword_1.bindKeyword)("string", "pattern", string_pattern_1.stringPatternPlugin, (v) => [compilePattern(v)]);
 /**
  * The value type is `ContentEncodingName`, not `string`: an encoding the
  * plugin does not know must be refused by the converter rather than accepted

package/dist/json-schema/keyword-map-string.mjs

@@ -7,7 +7,9 @@
 // table in this repository — 1.x shipped three of them and they disagreed
 // (docs/legacy-spec/json-schema-mapping.md records the disagreements).
 // ===========================================================================
+import { isString } from "../types/index.mjs";
 import { bindKeyword, structural } from "./bind-keyword.mjs";
+import { MalformedSchemaError } from "./malformed-schema-error.mjs";
 import { stringMinPlugin } from "../plugins/string-min/index.mjs";
 import { stringMaxPlugin } from "../plugins/string-max/index.mjs";
 import { stringPatternPlugin } from "../plugins/string-pattern/index.mjs";
@@ -15,13 +17,40 @@ import { stringContentEncodingPlugin, } from "../plugins/string-content-encoding
 import { stringContentMediaTypePlugin } from "../plugins/string-content-media-type/index.mjs";
 export const minLengthBinding = bindKeyword("string", "min", stringMinPlugin, (v) => [v]);
 export const maxLengthBinding = bindKeyword("string", "max", stringMaxPlugin, (v) => [v]);
+/**
+ * Compiles the document's source, refusing anything the meta-schema forbids.
+ *
+ * The parameter is `unknown` although the keyword's value type is `string`,
+ * and that is the whole point: compiling is a TOTAL operation on JSON values —
+ * every one of them has a string form — so a number becomes a literal digit
+ * pattern and an object becomes one that matches almost every string. Both
+ * then reach stringPattern as a perfectly valid RegExp, leaving its
+ * non-RegExp guard nothing to fire on. The refusal has to be here, before the
+ * value is turned into something well formed.
+ *
+ * A string that is not a valid ECMA-262 pattern is the same failure wearing a
+ * different coat: the compile step throws a SyntaxError naming neither the
+ * keyword nor the document, so it is caught and re-raised as the typed refusal
+ * every other malformed value gets.
+ */
+function compilePattern(source) {
+    if (!isString(source)) {
+        throw new MalformedSchemaError("pattern", "the value must be a string", source);
+    }
+    try {
+        return new RegExp(source);
+    }
+    catch {
+        throw new MalformedSchemaError("pattern", "the value must be a valid ECMA-262 regular expression", source);
+    }
+}
 /**
  * Draft-07 spells `pattern` as an ECMA-262 SOURCE string; the plugin accepts a
  * RegExp and only a RegExp, because 1.x's `new RegExp(source)` at the call site
  * dropped flags silently and gave the caller no compile-time check. Compiling
  * the schema's string therefore happens HERE, once, and nowhere else.
  */
-export const patternBinding = bindKeyword("string", "pattern", stringPatternPlugin, (v) => [new RegExp(v)]);
+export const patternBinding = bindKeyword("string", "pattern", stringPatternPlugin, (v) => [compilePattern(v)]);
 /**
  * The value type is `ContentEncodingName`, not `string`: an encoding the
  * plugin does not know must be refused by the converter rather than accepted

package/dist/json-schema/keyword-map.js

@@ -35,6 +35,8 @@ exports.NON_DRAFT07_KEYWORDS = {
     $recursiveRef: "2019-09 recursive references",
     dependentRequired: "2019-09 split of `dependencies`; use `dependencies`",
     dependentSchemas: "2019-09 split of `dependencies`; use `dependencies`",
+    minContains: "2019-09 bound on `contains`; Draft-07's is fixed at one",
+    maxContains: "2019-09 bound on `contains`; Draft-07 states no maximum",
     unevaluatedItems: "2019-09; no annotation-collection model in Luq",
     unevaluatedProperties: "2019-09; no annotation-collection model in Luq",
     contentSchema: "2019-09 companion to contentMediaType",

package/dist/json-schema/keyword-map.mjs

@@ -26,6 +26,8 @@ export const NON_DRAFT07_KEYWORDS = {
     $recursiveRef: "2019-09 recursive references",
     dependentRequired: "2019-09 split of `dependencies`; use `dependencies`",
     dependentSchemas: "2019-09 split of `dependencies`; use `dependencies`",
+    minContains: "2019-09 bound on `contains`; Draft-07's is fixed at one",
+    maxContains: "2019-09 bound on `contains`; Draft-07 states no maximum",
     unevaluatedItems: "2019-09; no annotation-collection model in Luq",
     unevaluatedProperties: "2019-09; no annotation-collection model in Luq",
     contentSchema: "2019-09 companion to contentMediaType",

package/dist/json-schema/malformed-schema-error.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The two shapes §4.4 lets a schema take, worded once. Several keywords take a
+ * schema as their value — `properties` members, `additionalProperties`, every
+ * position of the tuple form of `items` — and each is read by a different
+ * module; sharing the phrase is what stops the same refusal being explained
+ * three different ways to the same caller.
+ *
+ * It is a fragment, so it composes: "the value ", `the schema under "a" `.
+ */
+export declare const SCHEMA_FORMS = "must be an object or a boolean";
+/**
+ * Renders an untrusted schema value for a message, in at most
+ * RECEIVED_MAX_LENGTH characters. The value comes from the same document that
+ * is already known to be malformed, so nothing about it can be assumed: it may
+ * be circular, hold a bigint, or be large enough to drown the message.
+ * Rendering must never be the thing that throws.
+ */
+export declare function renderReceivedValue(value: unknown): string;
+/**
+ * Raised when a keyword's value violates the Draft-07 meta-schema. Thrown at
+ * build time, before a validator that would enforce less than the document
+ * states can exist.
+ */
+export declare class MalformedSchemaError extends Error {
+    /** The keyword whose value is malformed, for instance "type". */
+    readonly keyword: string;
+    /**
+     * What the meta-schema REQUIRES, written as a sentence fragment with no
+     * terminal punctuation — the message supplies it. Every keyword phrases it
+     * the same way, "<the thing> must be <the shape>", so that a caller reading
+     * two refusals from two different keywords reads one library rather than
+     * three; what was found instead is carried separately, in `received`.
+     */
+    readonly reason: string;
+    /** The offending value, rendered short and safe by renderReceivedValue. */
+    readonly received: string;
+    constructor(keyword: string, reason: string, value: unknown);
+}

package/dist/json-schema/malformed-schema-error.js

@@ -0,0 +1,103 @@
+"use strict";
+// ===========================================================================
+// L8  src/json-schema/malformed-schema-error.ts
+//
+// UnsupportedKeywordError refuses a keyword NAME Luq cannot honour. This
+// refuses a keyword VALUE the Draft-07 meta-schema does not allow, which until
+// it is refused does not fail — it quietly enforces less than the document
+// says. `{"type":"strig"}` drops the unknown name, so the type check vanishes
+// and the field starts accepting null; `{"pattern":{"source":"^SKU-"}}` reaches
+// the regex constructor as a stringified object and compiles to one matching
+// almost anything; `{"additionalProperties":"false"}` loses the closed-object
+// guarantee; `{"required":"name"}` builds and then throws a raw TypeError
+// inside validate() on the first request. A validator that silently drops a
+// constraint is worse than one that refuses the schema, so the refusal is a
+// typed error carrying the keyword, what the meta-schema requires, and a
+// rendering of what was found instead.
+//
+// The two refusals stay separate classes, neither extending the other, because
+// they answer different questions: "Luq cannot honour this keyword" versus
+// "this document is not valid Draft-07". The first is a limit of the library
+// and the second is a bug in the document; a caller catching one must not
+// silently catch the other.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalformedSchemaError = exports.SCHEMA_FORMS = void 0;
+exports.renderReceivedValue = renderReceivedValue;
+/**
+ * The two shapes §4.4 lets a schema take, worded once. Several keywords take a
+ * schema as their value — `properties` members, `additionalProperties`, every
+ * position of the tuple form of `items` — and each is read by a different
+ * module; sharing the phrase is what stops the same refusal being explained
+ * three different ways to the same caller.
+ *
+ * It is a fragment, so it composes: "the value ", `the schema under "a" `.
+ */
+exports.SCHEMA_FORMS = "must be an object or a boolean";
+/**
+ * How much of the offending value a message may carry. A schema node is
+ * arbitrarily large, and an error whose message is a megabyte long is unusable
+ * in a log line.
+ */
+const RECEIVED_MAX_LENGTH = 80;
+const TRUNCATION_MARKER = "...";
+/**
+ * Renders an untrusted schema value for a message, in at most
+ * RECEIVED_MAX_LENGTH characters. The value comes from the same document that
+ * is already known to be malformed, so nothing about it can be assumed: it may
+ * be circular, hold a bigint, or be large enough to drown the message.
+ * Rendering must never be the thing that throws.
+ */
+function renderReceivedValue(value) {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "function")
+        return "[function]";
+    if (typeof value === "symbol")
+        return "[symbol]";
+    return truncate(renderJson(value));
+}
+/**
+ * JSON.stringify throws on a circular reference and on a bigint anywhere in
+ * the value, and returns undefined for a value it has no encoding for at all.
+ * Both outcomes become a description of the shape rather than a failure.
+ */
+function renderJson(value) {
+    try {
+        const rendered = JSON.stringify(value);
+        return rendered === undefined ? describeUnrenderable(value) : rendered;
+    }
+    catch {
+        return describeUnrenderable(value);
+    }
+}
+function describeUnrenderable(value) {
+    return Array.isArray(value)
+        ? "[unrenderable array]"
+        : `[unrenderable ${typeof value}]`;
+}
+function truncate(rendered) {
+    if (rendered.length <= RECEIVED_MAX_LENGTH)
+        return rendered;
+    const kept = RECEIVED_MAX_LENGTH - TRUNCATION_MARKER.length;
+    return `${rendered.slice(0, kept)}${TRUNCATION_MARKER}`;
+}
+/**
+ * Raised when a keyword's value violates the Draft-07 meta-schema. Thrown at
+ * build time, before a validator that would enforce less than the document
+ * states can exist.
+ */
+class MalformedSchemaError extends Error {
+    constructor(keyword, reason, value) {
+        const received = renderReceivedValue(value);
+        super(`JSON Schema keyword "${keyword}" has a value the Draft-07 meta-schema ` +
+            `does not allow: ${reason}. Received: ${received}.`);
+        this.name = "MalformedSchemaError";
+        this.keyword = keyword;
+        this.reason = reason;
+        this.received = received;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, MalformedSchemaError.prototype);
+    }
+}
+exports.MalformedSchemaError = MalformedSchemaError;

package/dist/json-schema/malformed-schema-error.mjs

@@ -0,0 +1,98 @@
+// ===========================================================================
+// L8  src/json-schema/malformed-schema-error.ts
+//
+// UnsupportedKeywordError refuses a keyword NAME Luq cannot honour. This
+// refuses a keyword VALUE the Draft-07 meta-schema does not allow, which until
+// it is refused does not fail — it quietly enforces less than the document
+// says. `{"type":"strig"}` drops the unknown name, so the type check vanishes
+// and the field starts accepting null; `{"pattern":{"source":"^SKU-"}}` reaches
+// the regex constructor as a stringified object and compiles to one matching
+// almost anything; `{"additionalProperties":"false"}` loses the closed-object
+// guarantee; `{"required":"name"}` builds and then throws a raw TypeError
+// inside validate() on the first request. A validator that silently drops a
+// constraint is worse than one that refuses the schema, so the refusal is a
+// typed error carrying the keyword, what the meta-schema requires, and a
+// rendering of what was found instead.
+//
+// The two refusals stay separate classes, neither extending the other, because
+// they answer different questions: "Luq cannot honour this keyword" versus
+// "this document is not valid Draft-07". The first is a limit of the library
+// and the second is a bug in the document; a caller catching one must not
+// silently catch the other.
+// ===========================================================================
+/**
+ * The two shapes §4.4 lets a schema take, worded once. Several keywords take a
+ * schema as their value — `properties` members, `additionalProperties`, every
+ * position of the tuple form of `items` — and each is read by a different
+ * module; sharing the phrase is what stops the same refusal being explained
+ * three different ways to the same caller.
+ *
+ * It is a fragment, so it composes: "the value ", `the schema under "a" `.
+ */
+export const SCHEMA_FORMS = "must be an object or a boolean";
+/**
+ * How much of the offending value a message may carry. A schema node is
+ * arbitrarily large, and an error whose message is a megabyte long is unusable
+ * in a log line.
+ */
+const RECEIVED_MAX_LENGTH = 80;
+const TRUNCATION_MARKER = "...";
+/**
+ * Renders an untrusted schema value for a message, in at most
+ * RECEIVED_MAX_LENGTH characters. The value comes from the same document that
+ * is already known to be malformed, so nothing about it can be assumed: it may
+ * be circular, hold a bigint, or be large enough to drown the message.
+ * Rendering must never be the thing that throws.
+ */
+export function renderReceivedValue(value) {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "function")
+        return "[function]";
+    if (typeof value === "symbol")
+        return "[symbol]";
+    return truncate(renderJson(value));
+}
+/**
+ * JSON.stringify throws on a circular reference and on a bigint anywhere in
+ * the value, and returns undefined for a value it has no encoding for at all.
+ * Both outcomes become a description of the shape rather than a failure.
+ */
+function renderJson(value) {
+    try {
+        const rendered = JSON.stringify(value);
+        return rendered === undefined ? describeUnrenderable(value) : rendered;
+    }
+    catch {
+        return describeUnrenderable(value);
+    }
+}
+function describeUnrenderable(value) {
+    return Array.isArray(value)
+        ? "[unrenderable array]"
+        : `[unrenderable ${typeof value}]`;
+}
+function truncate(rendered) {
+    if (rendered.length <= RECEIVED_MAX_LENGTH)
+        return rendered;
+    const kept = RECEIVED_MAX_LENGTH - TRUNCATION_MARKER.length;
+    return `${rendered.slice(0, kept)}${TRUNCATION_MARKER}`;
+}
+/**
+ * Raised when a keyword's value violates the Draft-07 meta-schema. Thrown at
+ * build time, before a validator that would enforce less than the document
+ * states can exist.
+ */
+export class MalformedSchemaError extends Error {
+    constructor(keyword, reason, value) {
+        const received = renderReceivedValue(value);
+        super(`JSON Schema keyword "${keyword}" has a value the Draft-07 meta-schema ` +
+            `does not allow: ${reason}. Received: ${received}.`);
+        this.name = "MalformedSchemaError";
+        this.keyword = keyword;
+        this.reason = reason;
+        this.received = received;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, MalformedSchemaError.prototype);
+    }
+}

package/dist/plugins/manifest.generated.d.ts

@@ -1,8 +1,26 @@
+/** One plugin symbol: the method it adds, and the slots it adds it to. */
+export interface PluginSurface {
+    /** The symbol to pass to `.use()`, e.g. "stringMinPlugin". */
+    readonly symbol: string;
+    /** The chain method it adds, e.g. "min". */
+    readonly method: string;
+    /** The slots that method appears on, e.g. ["string"]. */
+    readonly slots: readonly string[];
+}
 export interface PluginManifestEntry {
     readonly directoryName: string;
     readonly subpathName: string;
     readonly tier: "isolated" | "extension";
+    /**
+     * Where the plugin lives in the REPOSITORY. A source path, so it resolves
+     * only in a checkout; an installed package has no src directory. What a
+     * consumer writes instead is `entryPoint`.
+     */
     readonly entryFile: string;
+    /** The specifier a consumer writes, e.g. "@maroonedog/luq/plugins/stringMin". */
+    readonly entryPoint: string;
     readonly exportedSymbols: readonly string[];
+    /** One per exported symbol, in the same order. */
+    readonly surfaces: readonly PluginSurface[];
 }
 export declare const PLUGIN_MANIFEST: readonly PluginManifestEntry[];