@maroonedog/luq 0.1.2-alpha → 2.0.0

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listBundledPluginNames = exports.findUnexplainedBundledPlugins = exports.findUnbundledBoundPlugins = exports.findStaleUnboundDeclarations = exports.UNBOUND_BUNDLED_PLUGIN_NAMES = exports.jsonSchemaBag = exports.jsonSchemaFullFeaturePlugin = exports.fromJsonSchema = void 0;
+// ===========================================================================
+// The public subpath `@maroonedog/luq/plugins/jsonSchemaFullFeature`.
+// Re-exports only.
+//
+// 1.x published exactly one symbol here, `jsonSchemaFullFeaturePlugin`, and the
+// README's only JSON Schema example imports it from this specifier. That symbol
+// and that specifier are unchanged. `fromJsonSchema` and `jsonSchemaBag` are
+// added because the rewritten core has no builder-extension mechanism, so the
+// bundled bag has to be reachable as a value for the conversion function to be
+// callable in one import.
+// ===========================================================================
+var json_schema_full_feature_1 = require("./json-schema-full-feature");
+Object.defineProperty(exports, "fromJsonSchema", { enumerable: true, get: function () { return json_schema_full_feature_1.fromJsonSchema; } });
+Object.defineProperty(exports, "jsonSchemaFullFeaturePlugin", { enumerable: true, get: function () { return json_schema_full_feature_1.jsonSchemaFullFeaturePlugin; } });
+var bundled_plugins_1 = require("./bundled-plugins");
+Object.defineProperty(exports, "jsonSchemaBag", { enumerable: true, get: function () { return bundled_plugins_1.jsonSchemaBag; } });
+var bundle_coverage_1 = require("./bundle-coverage");
+Object.defineProperty(exports, "UNBOUND_BUNDLED_PLUGIN_NAMES", { enumerable: true, get: function () { return bundle_coverage_1.UNBOUND_BUNDLED_PLUGIN_NAMES; } });
+Object.defineProperty(exports, "findStaleUnboundDeclarations", { enumerable: true, get: function () { return bundle_coverage_1.findStaleUnboundDeclarations; } });
+Object.defineProperty(exports, "findUnbundledBoundPlugins", { enumerable: true, get: function () { return bundle_coverage_1.findUnbundledBoundPlugins; } });
+Object.defineProperty(exports, "findUnexplainedBundledPlugins", { enumerable: true, get: function () { return bundle_coverage_1.findUnexplainedBundledPlugins; } });
+Object.defineProperty(exports, "listBundledPluginNames", { enumerable: true, get: function () { return bundle_coverage_1.listBundledPluginNames; } });

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

@@ -0,0 +1,14 @@
+// ===========================================================================
+// The public subpath `@maroonedog/luq/plugins/jsonSchemaFullFeature`.
+// Re-exports only.
+//
+// 1.x published exactly one symbol here, `jsonSchemaFullFeaturePlugin`, and the
+// README's only JSON Schema example imports it from this specifier. That symbol
+// and that specifier are unchanged. `fromJsonSchema` and `jsonSchemaBag` are
+// added because the rewritten core has no builder-extension mechanism, so the
+// bundled bag has to be reachable as a value for the conversion function to be
+// callable in one import.
+// ===========================================================================
+export { fromJsonSchema, jsonSchemaFullFeaturePlugin, } from "./json-schema-full-feature.mjs";
+export { jsonSchemaBag } from "./bundled-plugins.mjs";
+export { UNBOUND_BUNDLED_PLUGIN_NAMES, findStaleUnboundDeclarations, findUnbundledBoundPlugins, findUnexplainedBundledPlugins, listBundledPluginNames, } from "./bundle-coverage.mjs";

package/dist/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.d.ts

@@ -0,0 +1,23 @@
+import type { MessageContextExtra, TypeName } from "../../../types";
+import type { Unchanged } from "../../../plugin-kit/marker.types";
+import type { GlobalConfig } from "../../../types/global-config";
+export declare const jsonSchemaFullFeaturePlugin: import("../../../plugin-kit/plugin-definition").PluginDefinition<"jsonSchemaFullFeature", "jsonSchemaFullFeature", readonly TypeName[], {
+    args: readonly [document: unknown];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;
+/**
+ * The documented one-import route:
+ *
+ *     import { fromJsonSchema } from "@maroonedog/luq/plugins/jsonSchemaFullFeature";
+ *     const validator = fromJsonSchema<User>(schema);
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`, and under the default
+ * NO declared path is checked — see build-from-schema.ts, which owns that
+ * escape hatch and its single overload.
+ *
+ * The return type is INFERRED rather than written: naming `Validator<T>` would
+ * mean importing src/builder, which tier `extension` forbids. The inferred type
+ * is that same `Validator<T>` and the type test asserts it.
+ */
+export declare function fromJsonSchema<T extends object = Record<string, unknown>>(schema: unknown, config?: GlobalConfig): import("../../..").Validator<T, T>;

package/dist/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaFullFeaturePlugin = void 0;
+exports.fromJsonSchema = fromJsonSchema;
+// ===========================================================================
+// L8 (tier `extension`)
+// src/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.ts
+// `./plugins/jsonSchemaFullFeature` — the flagship one-import path.
+//
+// ONE IMPLEMENTATION, TWO FRONT DOORS. The rule this plugin builds is built by
+// `jsonSchemaPlugin.build`, reached through the sibling subpath's ENTRY file —
+// the only import a tier-`extension` plugin may make of another plugin. The
+// difference between the two subpaths is the BAG and nothing else: this one
+// ships all forty-five plugins, the other takes the caller's.
+//
+// WHY THE METHOD IS NOT ALSO CALLED `jsonSchema`: attach-slot-methods refuses
+// two plugins claiming one method on one slot, and scripts/check-plugin-
+// uniqueness.ts refuses it across the whole catalogue. 1.x let both bundles
+// claim `.fromJsonSchema` and relied on registration order to pick a winner;
+// here they are two distinct methods, and a builder may hold both.
+//
+// `fromJsonSchema(schema)` below is the documented one-import route (README
+// line 75 in 1.x). It is the step-25 function with this bundle's bag already
+// applied, so there is no second conversion path — only a shorter call.
+// ===========================================================================
+const plugin_definition_1 = require("../../../plugin-kit/plugin-definition");
+const json_schema_1 = require("../json-schema");
+const index_1 = require("../../index");
+const bundled_plugins_1 = require("./bundled-plugins");
+/** The same nine slots the sibling serves: a document constrains any value. */
+const SCHEMA_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+exports.jsonSchemaFullFeaturePlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "jsonSchemaFullFeature",
+    method: "jsonSchemaFullFeature",
+    slots: SCHEMA_SLOTS,
+    build: (ctx, document) => json_schema_1.jsonSchemaPlugin.build(ctx, document, bundled_plugins_1.jsonSchemaBag),
+});
+/**
+ * The documented one-import route:
+ *
+ *     import { fromJsonSchema } from "@maroonedog/luq/plugins/jsonSchemaFullFeature";
+ *     const validator = fromJsonSchema<User>(schema);
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`, and under the default
+ * NO declared path is checked — see build-from-schema.ts, which owns that
+ * escape hatch and its single overload.
+ *
+ * The return type is INFERRED rather than written: naming `Validator<T>` would
+ * mean importing src/builder, which tier `extension` forbids. The inferred type
+ * is that same `Validator<T>` and the type test asserts it.
+ */
+function fromJsonSchema(schema, config) {
+    return (0, index_1.fromJsonSchema)(bundled_plugins_1.jsonSchemaBag, schema, config);
+}

package/dist/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.mjs

@@ -0,0 +1,60 @@
+// ===========================================================================
+// L8 (tier `extension`)
+// src/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.ts
+// `./plugins/jsonSchemaFullFeature` — the flagship one-import path.
+//
+// ONE IMPLEMENTATION, TWO FRONT DOORS. The rule this plugin builds is built by
+// `jsonSchemaPlugin.build`, reached through the sibling subpath's ENTRY file —
+// the only import a tier-`extension` plugin may make of another plugin. The
+// difference between the two subpaths is the BAG and nothing else: this one
+// ships all forty-five plugins, the other takes the caller's.
+//
+// WHY THE METHOD IS NOT ALSO CALLED `jsonSchema`: attach-slot-methods refuses
+// two plugins claiming one method on one slot, and scripts/check-plugin-
+// uniqueness.ts refuses it across the whole catalogue. 1.x let both bundles
+// claim `.fromJsonSchema` and relied on registration order to pick a winner;
+// here they are two distinct methods, and a builder may hold both.
+//
+// `fromJsonSchema(schema)` below is the documented one-import route (README
+// line 75 in 1.x). It is the step-25 function with this bundle's bag already
+// applied, so there is no second conversion path — only a shorter call.
+// ===========================================================================
+import { definePlugin } from "../../../plugin-kit/plugin-definition.mjs";
+import { jsonSchemaPlugin } from "../json-schema/index.mjs";
+import { fromJsonSchema as convertWithBag } from "../../index.mjs";
+import { jsonSchemaBag } from "./bundled-plugins.mjs";
+/** The same nine slots the sibling serves: a document constrains any value. */
+const SCHEMA_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+];
+export const jsonSchemaFullFeaturePlugin = /*#__PURE__*/ definePlugin()({
+    name: "jsonSchemaFullFeature",
+    method: "jsonSchemaFullFeature",
+    slots: SCHEMA_SLOTS,
+    build: (ctx, document) => jsonSchemaPlugin.build(ctx, document, jsonSchemaBag),
+});
+/**
+ * The documented one-import route:
+ *
+ *     import { fromJsonSchema } from "@maroonedog/luq/plugins/jsonSchemaFullFeature";
+ *     const validator = fromJsonSchema<User>(schema);
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`, and under the default
+ * NO declared path is checked — see build-from-schema.ts, which owns that
+ * escape hatch and its single overload.
+ *
+ * The return type is INFERRED rather than written: naming `Validator<T>` would
+ * mean importing src/builder, which tier `extension` forbids. The inferred type
+ * is that same `Validator<T>` and the type test asserts it.
+ */
+export function fromJsonSchema(schema, config) {
+    return convertWithBag(jsonSchemaBag, schema, config);
+}

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

@@ -0,0 +1,25 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { ChildSchema, StructuralContext } from "./structural-expansion.types";
+/** The declaration step for "every element of this array". */
+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.
+ */
+export declare function readItemChildren(schema: Draft07SchemaObject): readonly ChildSchema[];
+export declare function composeTupleItems(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/**
+ * `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.
+ */
+export declare function composeContains(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/**
+ * The three array keywords that BIND. `minItems` maps to the method `minLength`
+ * 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`.
+ */
+export declare function declareArrayRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EACH_STEP = void 0;
+exports.readItemChildren = readItemChildren;
+exports.composeTupleItems = composeTupleItems;
+exports.composeContains = composeContains;
+exports.declareArrayRules = declareArrayRules;
+// ===========================================================================
+// L8  src/json-schema/flatten-array-schema.ts — `items`, `additionalItems`,
+// `contains`.
+//
+// TWO SHAPES, ONE KEYWORD. `items` is either a schema (every element) or an
+// ARRAY of schemas (position i constrains element i). 1.x read only the first
+// shape and guessed the method name `tupleBuilder` for the second, which is not
+// a chain method, so the tuple form silently constrained nothing.
+//
+//   single form  ->  a CHILD DECLARATION at `path[*]`. That is better than
+//                    `.each()` here: the element gets a real declared path, so
+//                    its own `properties` become `path[*].name` and an issue
+//                    renders as `tags[2].name` rather than as a nested cause.
+//   tuple form   ->  ONE composite, built from create-rule.
+//
+// WHY NOT tupleBuilder (measured, not assumed): tupleBuilderPlugin rejects a
+// NON-ARRAY and enforces a LENGTH — exactly `value.length !== positions.length`
+// without a rest chain, and `value.length < positions.length` with one. Draft-07
+// §6.4 / §9.3.1 does neither: a non-array is not an array constraint's business
+// at all, a SHORT array is valid, and a LONG array is `additionalItems`' to
+// judge. Binding the tuple form to `.builder()` would therefore reject
+// documents the schema permits. The composite below is the same rule KIND,
+// with the draft's semantics.
+// ===========================================================================
+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 keyword_map_array_1 = require("./keyword-map-array");
+const types_1 = require("../types");
+const collect_definitions_1 = require("./collect-definitions");
+/** The declaration step for "every element of this array". */
+exports.EACH_STEP = "[*]";
+const NO_CHILDREN = Object.freeze([]);
+const NO_RULES = Object.freeze([]);
+/** True for the tuple form of `items`, which is an ARRAY of schemas. */
+function isTupleItems(items) {
+    return (0, types_1.isArray)(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.
+ */
+function readItemChildren(schema) {
+    const items = schema.items;
+    if (items === undefined || isTupleItems(items))
+        return NO_CHILDREN;
+    return Object.freeze([{ step: exports.EACH_STEP, schema: items, isRequired: false }]);
+}
+/**
+ * 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.
+ */
+function applyPositionally(runners, positionCount, hasRest) {
+    return (value, ctx) => {
+        if (!(0, types_1.isArray)(value))
+            return types_1.PASS;
+        for (let index = 0; index < value.length; index += 1) {
+            const runner = index < positionCount
+                ? runners[index]
+                : hasRest
+                    ? runners[positionCount]
+                    : undefined;
+            if (runner === undefined)
+                continue;
+            const outcome = runner.run(value[index], ctx);
+            if (!outcome.ok)
+                return (0, types_1.fail)({ ...outcome.detail, index });
+        }
+        return types_1.PASS;
+    };
+}
+function describePosition(index) {
+    return index < 0
+        ? "An element does not match the schema declared for its position"
+        : `Element ${String(index)} does not match the schema declared for it`;
+}
+function composeTupleItems(schema, context) {
+    const items = schema.items;
+    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 hasRest = rest !== undefined;
+    if (rest !== undefined)
+        branches.push(context.toBranch("rest", rest));
+    const positionCount = items.length;
+    return Object.freeze([
+        (0, create_rule_1.composite)({
+            code: "items",
+            severity: context.build.config.defaultSeverity,
+            branches,
+            combine: (runners) => applyPositionally(runners, positionCount, hasRest),
+            describe: (detail) => describePosition((0, types_1.isNumber)(detail.index) ? detail.index : -1),
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}
+/**
+ * `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.
+ */
+function composeContains(schema, context) {
+    const contains = schema.contains;
+    if (contains === undefined)
+        return NO_RULES;
+    const element = context.collectSubSchemaRules((0, collect_definitions_1.toSchemaObject)(contains));
+    return Object.freeze([
+        context.bag.arrayContains.build(context.ruleContextFor(context.bag.arrayContains.name, "contains"), element),
+    ]);
+}
+/**
+ * The three array keywords that BIND. `minItems` maps to the method `minLength`
+ * 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`.
+ */
+function declareArrayRules(schema, context) {
+    let chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).array;
+    if (schema.minItems !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_array_1.minItemsBinding, schema.minItems);
+    }
+    if (schema.maxItems !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_array_1.maxItemsBinding, schema.maxItems);
+    }
+    if (schema.uniqueItems === 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

@@ -0,0 +1,134 @@
+// ===========================================================================
+// L8  src/json-schema/flatten-array-schema.ts — `items`, `additionalItems`,
+// `contains`.
+//
+// TWO SHAPES, ONE KEYWORD. `items` is either a schema (every element) or an
+// ARRAY of schemas (position i constrains element i). 1.x read only the first
+// shape and guessed the method name `tupleBuilder` for the second, which is not
+// a chain method, so the tuple form silently constrained nothing.
+//
+//   single form  ->  a CHILD DECLARATION at `path[*]`. That is better than
+//                    `.each()` here: the element gets a real declared path, so
+//                    its own `properties` become `path[*].name` and an issue
+//                    renders as `tags[2].name` rather than as a nested cause.
+//   tuple form   ->  ONE composite, built from create-rule.
+//
+// WHY NOT tupleBuilder (measured, not assumed): tupleBuilderPlugin rejects a
+// NON-ARRAY and enforces a LENGTH — exactly `value.length !== positions.length`
+// without a rest chain, and `value.length < positions.length` with one. Draft-07
+// §6.4 / §9.3.1 does neither: a non-array is not an array constraint's business
+// at all, a SHORT array is valid, and a LONG array is `additionalItems`' to
+// judge. Binding the tuple form to `.builder()` would therefore reject
+// documents the schema permits. The composite below is the same rule KIND,
+// with the draft's semantics.
+// ===========================================================================
+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 { maxItemsBinding, minItemsBinding, uniqueItemsBinding, } from "./keyword-map-array.mjs";
+import { PASS, fail, isArray, isNumber } from "../types/index.mjs";
+import { toSchemaObject } from "./collect-definitions.mjs";
+/** The declaration step for "every element of this array". */
+export const EACH_STEP = "[*]";
+const NO_CHILDREN = Object.freeze([]);
+const NO_RULES = Object.freeze([]);
+/** True for the tuple form of `items`, which is an ARRAY of schemas. */
+function isTupleItems(items) {
+    return isArray(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.
+ */
+export function readItemChildren(schema) {
+    const items = schema.items;
+    if (items === undefined || isTupleItems(items))
+        return NO_CHILDREN;
+    return Object.freeze([{ step: EACH_STEP, schema: items, isRequired: false }]);
+}
+/**
+ * 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.
+ */
+function applyPositionally(runners, positionCount, hasRest) {
+    return (value, ctx) => {
+        if (!isArray(value))
+            return PASS;
+        for (let index = 0; index < value.length; index += 1) {
+            const runner = index < positionCount
+                ? runners[index]
+                : hasRest
+                    ? runners[positionCount]
+                    : undefined;
+            if (runner === undefined)
+                continue;
+            const outcome = runner.run(value[index], ctx);
+            if (!outcome.ok)
+                return fail({ ...outcome.detail, index });
+        }
+        return PASS;
+    };
+}
+function describePosition(index) {
+    return index < 0
+        ? "An element does not match the schema declared for its position"
+        : `Element ${String(index)} does not match the schema declared for it`;
+}
+export function composeTupleItems(schema, context) {
+    const items = schema.items;
+    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 hasRest = rest !== undefined;
+    if (rest !== undefined)
+        branches.push(context.toBranch("rest", rest));
+    const positionCount = items.length;
+    return Object.freeze([
+        composite({
+            code: "items",
+            severity: context.build.config.defaultSeverity,
+            branches,
+            combine: (runners) => applyPositionally(runners, positionCount, hasRest),
+            describe: (detail) => describePosition(isNumber(detail.index) ? detail.index : -1),
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}
+/**
+ * `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.
+ */
+export function composeContains(schema, context) {
+    const contains = schema.contains;
+    if (contains === undefined)
+        return NO_RULES;
+    const element = context.collectSubSchemaRules(toSchemaObject(contains));
+    return Object.freeze([
+        context.bag.arrayContains.build(context.ruleContextFor(context.bag.arrayContains.name, "contains"), element),
+    ]);
+}
+/**
+ * The three array keywords that BIND. `minItems` maps to the method `minLength`
+ * 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`.
+ */
+export function declareArrayRules(schema, context) {
+    let chain = createFieldSlots(context.bag, context.build).array;
+    if (schema.minItems !== undefined) {
+        chain = applyKeywordBinding(chain, minItemsBinding, schema.minItems);
+    }
+    if (schema.maxItems !== undefined) {
+        chain = applyKeywordBinding(chain, maxItemsBinding, schema.maxItems);
+    }
+    if (schema.uniqueItems === true) {
+        chain = applyKeywordBinding(chain, uniqueItemsBinding, true);
+    }
+    return readChainRules(chain) ?? NO_RULES;
+}

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

@@ -0,0 +1,20 @@
+import type { Draft07Schema, Draft07SchemaObject } from "./draft07.types";
+import type { ChildSchema } from "./structural-expansion.types";
+export interface SchemaFieldDeclaration {
+    readonly path: string;
+    readonly schema: Draft07SchemaObject;
+    readonly isRequired: boolean;
+}
+export type ReadChildSchemas = (schema: Draft07SchemaObject) => readonly ChildSchema[];
+/** `[*]` trails its key; every other step is a `.`-joined property name. */
+export declare function joinDeclaredPath(parent: string, step: string): string;
+/** The root plus every arm of its `allOf`, transitively, all resolved. */
+export declare function collectRootNodes(root: Draft07Schema): readonly Draft07SchemaObject[];
+/**
+ * The root declarations come FIRST, one per `allOf` arm that carries a rule of
+ * its own, so two arms cannot silently overwrite each other's `minProperties`.
+ * `isRequired` is false: the root is always present (create-validator refuses a
+ * missing root before the plan runs), and a presence rule there would only add
+ * a second answer to a question already settled.
+ */
+export declare function flattenSchema(root: Draft07Schema, readChildren: ReadChildSchemas): readonly SchemaFieldDeclaration[];