@maroonedog/luq 0.1.2-alpha → 2.1.0

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

@@ -0,0 +1,101 @@
+import { isSchemaObject } from "./draft07.types.mjs";
+import { createLocalScope } from "./ref-scope.mjs";
+import { resolveRefInScope } from "./resolve-ref.mjs";
+import { nextBaseUri } from "./uri-reference.mjs";
+/** `true`: matches every instance. */
+const ALWAYS_SCHEMA = Object.freeze({});
+/** `false`: matches nothing. `not` of the empty schema, so no new rule kind. */
+const NEVER_SCHEMA = Object.freeze({
+    not: ALWAYS_SCHEMA,
+});
+/** The two container spellings, in the order a pointer would try them. */
+export const DEFINITION_CONTAINERS = Object.freeze([
+    "definitions",
+    "$defs",
+]);
+export function isDefinitionContainer(keyword) {
+    return DEFINITION_CONTAINERS.includes(keyword);
+}
+/** §4.4: the boolean form as an object, without inventing a rule kind. */
+export function toSchemaObject(schema) {
+    if (schema === true)
+        return ALWAYS_SCHEMA;
+    if (schema === false)
+        return NEVER_SCHEMA;
+    return schema;
+}
+/**
+ * The node a path really carries: `$ref` followed to its target, the boolean
+ * form normalised. A `$ref` sibling is DROPPED, which is Draft-07 §8.3: in
+ * this draft `$ref` replaces the object it appears in.
+ */
+export function resolveSchemaNode(schema, root) {
+    return resolveSchemaNodeInScope(schema, createLocalScope(root)).node;
+}
+/**
+ * The scope-aware form, and the one the converter uses.
+ *
+ * The returned scope is not the one passed in: following a `$ref` can cross
+ * into another document, and a `$ref` written inside THAT document resolves
+ * against ITS base. Returning only the node — which is what the root-taking
+ * form above can do — loses that, and is why a two-document schema resolved
+ * its second hop against the first document.
+ */
+export function resolveSchemaNodeInScope(schema, scope) {
+    const node = toSchemaObject(schema);
+    if (node.$ref === undefined) {
+        // A node's own `$id` moves the base for everything inside it (§8.2).
+        return { node, scope: advanceBase(scope, node) };
+    }
+    // Following a `$ref` lands in whatever base the TARGET lives in, and
+    // resolve-ref already knows it — for a document fetched by URI that is the
+    // retrieval URI, which the draft says wins over the document's own `$id`.
+    const resolved = resolveRefInScope(node.$ref, scope);
+    return { node: toSchemaObject(resolved.schema), scope: resolved.scope };
+}
+/**
+ * The ONE place a base URI advances. It was also being done by the caller,
+ * and doing it in both meant a relative `$id` was applied twice: a `$ref`
+ * of "nested/foo.json" under `$id: "nested/"` went looking for
+ * ".../nested/nested/foo.json".
+ *
+ * A base-setting `$id` starts a new RESOURCE, so the node also becomes the
+ * document that `#/definitions/x` written under it resolves against. Moving
+ * the base without moving the document is why
+ * `{"$id":"a.json","properties":{"foo":{"$id":"b.json","definitions":{...},
+ * "allOf":[{"$ref":"#/definitions/inner"}]}}}` looked for `inner` in the
+ * OUTER document, where it does not exist.
+ */
+export function advanceBase(scope, node) {
+    const id = node.$id;
+    if (typeof id !== "string" || id === "")
+        return scope;
+    const baseUri = nextBaseUri(scope.baseUri, id);
+    if (baseUri === scope.baseUri)
+        return scope;
+    return { ...scope, baseUri, document: node };
+}
+/**
+ * The pointer a node forwards to, or undefined. Used by the flattener to spot
+ * a recursive definition BEFORE it walks into it: `#/definitions/node` inside
+ * its own `properties` is a legitimate schema whose declared paths are
+ * infinite, and Luq declares finite paths.
+ */
+export function readRefPointer(schema) {
+    if (!isSchemaObject(schema))
+        return undefined;
+    return schema.$ref;
+}
+/** Every definition name the document declares, under either spelling. */
+export function collectDefinitionNames(root) {
+    if (!isSchemaObject(root))
+        return Object.freeze([]);
+    const names = new Set();
+    for (const container of [root.definitions, root.$defs]) {
+        if (container === undefined)
+            continue;
+        for (const name of Object.keys(container))
+            names.add(name);
+    }
+    return Object.freeze([...names]);
+}

package/dist/json-schema/collect-sub-schema-rules.d.ts

@@ -0,0 +1,17 @@
+import type { CompositeBranch, Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07Schema } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+export declare function collectSubSchemaRules(schema: Draft07Schema, context: StructuralContext): readonly Rule[];
+/**
+ * Every branch of every composite is built here, so a branch is one shape.
+ *
+ * The call is to the function above and NOT to `context.collectSubSchemaRules`,
+ * and the difference is load-bearing. `context` is already the child context
+ * that createStructuralContext produced by DESCENDING through this schema, so
+ * a `$ref` here is already recorded in `visitedRefs`. Going through the
+ * context would descend the same `$ref` a second time, the recursion guard
+ * would see it as a cycle, and the branch would come back with no rules at all
+ * — `{"items":[{"$ref":"#/definitions/x"}]}` constrained nothing while the
+ * inline form `{"items":[{"type":"integer"}]}` worked.
+ */
+export declare function toSchemaBranch(label: string, schema: Draft07Schema, context: StructuralContext): CompositeBranch;

package/dist/json-schema/collect-sub-schema-rules.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSubSchemaRules = collectSubSchemaRules;
+exports.toSchemaBranch = toSchemaBranch;
+// ===========================================================================
+// L8  src/json-schema/collect-sub-schema-rules.ts — a WHOLE sub-schema as a
+// rule list over one subject.
+//
+// A declared path gets its children as their own `.v()` declarations, because a
+// real path renders a real issue path. A sub-schema INSIDE an applicator cannot:
+// `anyOf` needs one verdict for the whole arm, so the arm's `properties` become
+// CompositeBranch FIELDS (paths relative to the branch subject) and its `items`
+// go through `.each()`. `[*]` cannot be a branch field path — parse-field-path
+// rejects a bracket that trails no key — which is exactly why arrayEach is in
+// the bag (docs/design/verification.md, the retracted "arrayEach does not
+// exist" item).
+//
+// This is the recursion every applicator shares: compose-keyword, compose-
+// conditional, patternProperties, propertyNames, dependentSchemas and
+// additionalProperties all reach it through StructuralContext, so there is one
+// answer to "what does this sub-schema mean" and not one per keyword.
+// ===========================================================================
+const create_rule_1 = require("../plugin-kit/create-rule");
+const types_1 = require("../types");
+const collect_definitions_1 = require("./collect-definitions");
+const declare_presence_1 = require("./declare-presence");
+const flatten_array_schema_1 = require("./flatten-array-schema");
+const schema_to_declarations_1 = require("./schema-to-declarations");
+const NO_BRANCH_FIELDS = Object.freeze([]);
+function toBranchField(child, context) {
+    return {
+        path: child.step,
+        rules: Object.freeze([
+            ...(0, declare_presence_1.declarePresenceRules)({
+                isRequired: child.isRequired,
+                severity: context.build.config.defaultSeverity,
+            }),
+            ...context.collectSubSchemaRules(child.schema),
+        ]),
+    };
+}
+/** One composite whose single branch carries the properties as fields. */
+function composeProperties(children, context) {
+    const fields = children.map((child) => toBranchField(child, context));
+    return [
+        (0, create_rule_1.composite)({
+            code: "properties",
+            severity: context.build.config.defaultSeverity,
+            branches: [(0, create_rule_1.fieldsBranch)("properties", fields)],
+            combine: (runners) => (value, ctx) => runners[0]?.run(value, ctx) ?? types_1.PASS,
+            describe: () => "One or more properties do not match their schema",
+            buildMessageContext: () => ({}),
+        }),
+    ];
+}
+/**
+ * Every sub-schema subject gets the same one-line statement: null is a VALUE
+ * here, so the checks run on it.
+ *
+ * src/runtime/run-field.ts settles presence BEFORE any check, and a subject
+ * with no presence rule carries OPEN_PRESENCE, which ends the field on null.
+ * A branch subject and an array element both arrive without one, so every
+ * check the sub-schema declared was skipped for null: `[null]` passed
+ * `{"items":{"type":"boolean"}}`, and `additionalItems: false` accepted a
+ * trailing null. Deciding it from `type` alone is not enough either —
+ * `false`, `{"not": {}}` and an `enum` without null forbid null while
+ * saying nothing about `type`.
+ */
+function declareOwnNullPolicy(context) {
+    return (0, declare_presence_1.declarePresenceRules)({
+        isRequired: false,
+        severity: context.build.config.defaultSeverity,
+    });
+}
+function collectSubSchemaRules(schema, context) {
+    const node = (0, collect_definitions_1.resolveSchemaNodeInScope)(schema, context.scope).node;
+    const rules = [
+        ...declareOwnNullPolicy(context),
+        ...(0, schema_to_declarations_1.expandSchemaRules)(node, context),
+    ];
+    const children = (0, schema_to_declarations_1.readChildSchemas)(node);
+    const properties = children.filter((child) => child.step !== flatten_array_schema_1.EACH_STEP);
+    if (properties.length > 0) {
+        rules.push(...composeProperties(properties, context));
+    }
+    for (const element of children) {
+        if (element.step !== flatten_array_schema_1.EACH_STEP)
+            continue;
+        const plugin = context.bag.arrayEach;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "items"), context.collectSubSchemaRules(element.schema)));
+    }
+    return Object.freeze(rules);
+}
+/**
+ * Every branch of every composite is built here, so a branch is one shape.
+ *
+ * The call is to the function above and NOT to `context.collectSubSchemaRules`,
+ * and the difference is load-bearing. `context` is already the child context
+ * that createStructuralContext produced by DESCENDING through this schema, so
+ * a `$ref` here is already recorded in `visitedRefs`. Going through the
+ * context would descend the same `$ref` a second time, the recursion guard
+ * would see it as a cycle, and the branch would come back with no rules at all
+ * — `{"items":[{"$ref":"#/definitions/x"}]}` constrained nothing while the
+ * inline form `{"items":[{"type":"integer"}]}` worked.
+ */
+function toSchemaBranch(label, schema, context) {
+    return {
+        label,
+        rules: collectSubSchemaRules(schema, context),
+        fields: NO_BRANCH_FIELDS,
+    };
+}

package/dist/json-schema/collect-sub-schema-rules.mjs

@@ -0,0 +1,108 @@
+// ===========================================================================
+// L8  src/json-schema/collect-sub-schema-rules.ts — a WHOLE sub-schema as a
+// rule list over one subject.
+//
+// A declared path gets its children as their own `.v()` declarations, because a
+// real path renders a real issue path. A sub-schema INSIDE an applicator cannot:
+// `anyOf` needs one verdict for the whole arm, so the arm's `properties` become
+// CompositeBranch FIELDS (paths relative to the branch subject) and its `items`
+// go through `.each()`. `[*]` cannot be a branch field path — parse-field-path
+// rejects a bracket that trails no key — which is exactly why arrayEach is in
+// the bag (docs/design/verification.md, the retracted "arrayEach does not
+// exist" item).
+//
+// This is the recursion every applicator shares: compose-keyword, compose-
+// conditional, patternProperties, propertyNames, dependentSchemas and
+// additionalProperties all reach it through StructuralContext, so there is one
+// answer to "what does this sub-schema mean" and not one per keyword.
+// ===========================================================================
+import { composite, fieldsBranch } from "../plugin-kit/create-rule.mjs";
+import { PASS } from "../types/index.mjs";
+import { resolveSchemaNodeInScope } from "./collect-definitions.mjs";
+import { declarePresenceRules } from "./declare-presence.mjs";
+import { EACH_STEP } from "./flatten-array-schema.mjs";
+import { expandSchemaRules, readChildSchemas } from "./schema-to-declarations.mjs";
+const NO_BRANCH_FIELDS = Object.freeze([]);
+function toBranchField(child, context) {
+    return {
+        path: child.step,
+        rules: Object.freeze([
+            ...declarePresenceRules({
+                isRequired: child.isRequired,
+                severity: context.build.config.defaultSeverity,
+            }),
+            ...context.collectSubSchemaRules(child.schema),
+        ]),
+    };
+}
+/** One composite whose single branch carries the properties as fields. */
+function composeProperties(children, context) {
+    const fields = children.map((child) => toBranchField(child, context));
+    return [
+        composite({
+            code: "properties",
+            severity: context.build.config.defaultSeverity,
+            branches: [fieldsBranch("properties", fields)],
+            combine: (runners) => (value, ctx) => runners[0]?.run(value, ctx) ?? PASS,
+            describe: () => "One or more properties do not match their schema",
+            buildMessageContext: () => ({}),
+        }),
+    ];
+}
+/**
+ * Every sub-schema subject gets the same one-line statement: null is a VALUE
+ * here, so the checks run on it.
+ *
+ * src/runtime/run-field.ts settles presence BEFORE any check, and a subject
+ * with no presence rule carries OPEN_PRESENCE, which ends the field on null.
+ * A branch subject and an array element both arrive without one, so every
+ * check the sub-schema declared was skipped for null: `[null]` passed
+ * `{"items":{"type":"boolean"}}`, and `additionalItems: false` accepted a
+ * trailing null. Deciding it from `type` alone is not enough either —
+ * `false`, `{"not": {}}` and an `enum` without null forbid null while
+ * saying nothing about `type`.
+ */
+function declareOwnNullPolicy(context) {
+    return declarePresenceRules({
+        isRequired: false,
+        severity: context.build.config.defaultSeverity,
+    });
+}
+export function collectSubSchemaRules(schema, context) {
+    const node = resolveSchemaNodeInScope(schema, context.scope).node;
+    const rules = [
+        ...declareOwnNullPolicy(context),
+        ...expandSchemaRules(node, context),
+    ];
+    const children = readChildSchemas(node);
+    const properties = children.filter((child) => child.step !== EACH_STEP);
+    if (properties.length > 0) {
+        rules.push(...composeProperties(properties, context));
+    }
+    for (const element of children) {
+        if (element.step !== EACH_STEP)
+            continue;
+        const plugin = context.bag.arrayEach;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "items"), context.collectSubSchemaRules(element.schema)));
+    }
+    return Object.freeze(rules);
+}
+/**
+ * Every branch of every composite is built here, so a branch is one shape.
+ *
+ * The call is to the function above and NOT to `context.collectSubSchemaRules`,
+ * and the difference is load-bearing. `context` is already the child context
+ * that createStructuralContext produced by DESCENDING through this schema, so
+ * a `$ref` here is already recorded in `visitedRefs`. Going through the
+ * context would descend the same `$ref` a second time, the recursion guard
+ * would see it as a cycle, and the branch would come back with no rules at all
+ * — `{"items":[{"$ref":"#/definitions/x"}]}` constrained nothing while the
+ * inline form `{"items":[{"type":"integer"}]}` worked.
+ */
+export function toSchemaBranch(label, schema, context) {
+    return {
+        label,
+        rules: collectSubSchemaRules(schema, context),
+        fields: NO_BRANCH_FIELDS,
+    };
+}

package/dist/json-schema/compose-conditional.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+export declare function composeConditional(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/compose-conditional.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeConditional = composeConditional;
+const NO_RULES = Object.freeze([]);
+/** An absent arm stays absent: the plugin treats `undefined` as "passes". */
+function readArm(arm, context) {
+    return arm === undefined ? undefined : context.collectSubSchemaRules(arm);
+}
+function composeConditional(schema, context) {
+    const condition = schema.if;
+    if (condition === undefined)
+        return NO_RULES;
+    const plugin = context.bag.conditionalSchema;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "if"), context.collectSubSchemaRules(condition), readArm(schema.then, context), readArm(schema.else, context)),
+    ]);
+}

package/dist/json-schema/compose-conditional.mjs

@@ -0,0 +1,14 @@
+const NO_RULES = Object.freeze([]);
+/** An absent arm stays absent: the plugin treats `undefined` as "passes". */
+function readArm(arm, context) {
+    return arm === undefined ? undefined : context.collectSubSchemaRules(arm);
+}
+export function composeConditional(schema, context) {
+    const condition = schema.if;
+    if (condition === undefined)
+        return NO_RULES;
+    const plugin = context.bag.conditionalSchema;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "if"), context.collectSubSchemaRules(condition), readArm(schema.then, context), readArm(schema.else, context)),
+    ]);
+}

package/dist/json-schema/compose-keyword.d.ts

@@ -0,0 +1,7 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+export declare function composeAllOf(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function composeAnyOf(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function composeOneOf(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function composeNot(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeAllOf = composeAllOf;
+exports.composeAnyOf = composeAnyOf;
+exports.composeOneOf = composeOneOf;
+exports.composeNot = composeNot;
+// ===========================================================================
+// L8  src/json-schema/compose-keyword.ts — allOf / anyOf / oneOf / not.
+//
+// FOUR KEYWORDS, ONE RULE KIND. Each is a CompositeRule built from
+// src/plugin-kit/create-rule.ts and nothing else: the four differ only in the
+// `combine` they hand the engine, which is called ONCE at build time and
+// returns the finished reduction. There is no schema evaluator here — a branch
+// is a nested ValidationPlan run by the one engine — which is what retires
+// 1.x's private `validateValueAgainstSchema`, a second, disagreeing Draft-07
+// implementation that `chain.custom()` reached for allOf/anyOf/oneOf.
+//
+// A branch carries its sub-schema's own rules AND its `properties` as relative
+// FIELDS (CompositeBranch.fields), so `anyOf: [{ properties: { a: ... } }]`
+// really constrains `a` instead of being dropped the way 1.x dropped it.
+// ===========================================================================
+const create_rule_1 = require("../plugin-kit/create-rule");
+const types_1 = require("../types");
+const NO_RULES = Object.freeze([]);
+const NO_CAUSES = Object.freeze([]);
+/** Every issue the failing branches reported, in branch order. */
+function collectCauses(outcomes) {
+    const causes = [];
+    for (const outcome of outcomes) {
+        if (outcome.ok)
+            continue;
+        for (const cause of outcome.detail.causes ?? NO_CAUSES)
+            causes.push(cause);
+    }
+    return Object.freeze(causes);
+}
+/** `allOf`: every sub-schema holds. The first refusal names the arm. */
+function combineAllOf(runners) {
+    return (value, ctx) => {
+        for (const runner of runners) {
+            const outcome = runner.run(value, ctx);
+            if (!outcome.ok) {
+                return (0, types_1.fail)({ ...outcome.detail, branch: runner.label });
+            }
+        }
+        return types_1.PASS;
+    };
+}
+/** `anyOf`: at least one holds. Every arm's issues explain the refusal. */
+function combineAnyOf(runners) {
+    return (value, ctx) => {
+        for (const runner of runners) {
+            if (runner.run(value, ctx).ok)
+                return types_1.PASS;
+        }
+        const outcomes = runners.map((runner) => runner.run(value, ctx));
+        return (0, types_1.fail)({
+            expected: runners.length,
+            actual: 0,
+            causes: collectCauses(outcomes),
+        });
+    };
+}
+/** `oneOf`: exactly one holds. Both "none" and "several" are refusals. */
+function combineOneOf(runners) {
+    return (value, ctx) => {
+        const outcomes = runners.map((runner) => runner.run(value, ctx));
+        const accepted = outcomes.filter((outcome) => outcome.ok).length;
+        if (accepted === 1)
+            return types_1.PASS;
+        return (0, types_1.fail)({
+            expected: 1,
+            actual: accepted,
+            causes: accepted === 0 ? collectCauses(outcomes) : NO_CAUSES,
+        });
+    };
+}
+/** `not`: the single arm must NOT hold. */
+function combineNot(runners) {
+    const negated = runners[0];
+    return (value, ctx) => {
+        if (negated === undefined)
+            return types_1.PASS;
+        return negated.run(value, ctx).ok ? (0, types_1.fail)({ actual: value }) : types_1.PASS;
+    };
+}
+function composeBranches(code, branches, combine, describe, context) {
+    if (branches.length === 0)
+        return NO_RULES;
+    return Object.freeze([
+        (0, create_rule_1.composite)({
+            code,
+            severity: context.build.config.defaultSeverity,
+            branches,
+            combine,
+            describe: () => describe,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}
+function toBranches(keyword, schemas, context) {
+    return schemas.map((member, index) => context.toBranch(`${keyword}:${String(index)}`, member));
+}
+function composeAllOf(schema, context) {
+    const members = schema.allOf;
+    if (members === undefined)
+        return NO_RULES;
+    return composeBranches("allOf", toBranches("allOf", members, context), combineAllOf, "Value must match every schema in allOf", context);
+}
+function composeAnyOf(schema, context) {
+    const members = schema.anyOf;
+    if (members === undefined)
+        return NO_RULES;
+    return composeBranches("anyOf", toBranches("anyOf", members, context), combineAnyOf, "Value must match at least one schema in anyOf", context);
+}
+function composeOneOf(schema, context) {
+    const members = schema.oneOf;
+    if (members === undefined)
+        return NO_RULES;
+    return composeBranches("oneOf", toBranches("oneOf", members, context), combineOneOf, "Value must match exactly one schema in oneOf", context);
+}
+function composeNot(schema, context) {
+    const negated = schema.not;
+    if (negated === undefined)
+        return NO_RULES;
+    return composeBranches("not", [context.toBranch("not", negated)], combineNot, "Value must not match the schema in not", context);
+}

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

@@ -0,0 +1,121 @@
+// ===========================================================================
+// L8  src/json-schema/compose-keyword.ts — allOf / anyOf / oneOf / not.
+//
+// FOUR KEYWORDS, ONE RULE KIND. Each is a CompositeRule built from
+// src/plugin-kit/create-rule.ts and nothing else: the four differ only in the
+// `combine` they hand the engine, which is called ONCE at build time and
+// returns the finished reduction. There is no schema evaluator here — a branch
+// is a nested ValidationPlan run by the one engine — which is what retires
+// 1.x's private `validateValueAgainstSchema`, a second, disagreeing Draft-07
+// implementation that `chain.custom()` reached for allOf/anyOf/oneOf.
+//
+// A branch carries its sub-schema's own rules AND its `properties` as relative
+// FIELDS (CompositeBranch.fields), so `anyOf: [{ properties: { a: ... } }]`
+// really constrains `a` instead of being dropped the way 1.x dropped it.
+// ===========================================================================
+import { composite } from "../plugin-kit/create-rule.mjs";
+import { PASS, fail } from "../types/index.mjs";
+const NO_RULES = Object.freeze([]);
+const NO_CAUSES = Object.freeze([]);
+/** Every issue the failing branches reported, in branch order. */
+function collectCauses(outcomes) {
+    const causes = [];
+    for (const outcome of outcomes) {
+        if (outcome.ok)
+            continue;
+        for (const cause of outcome.detail.causes ?? NO_CAUSES)
+            causes.push(cause);
+    }
+    return Object.freeze(causes);
+}
+/** `allOf`: every sub-schema holds. The first refusal names the arm. */
+function combineAllOf(runners) {
+    return (value, ctx) => {
+        for (const runner of runners) {
+            const outcome = runner.run(value, ctx);
+            if (!outcome.ok) {
+                return fail({ ...outcome.detail, branch: runner.label });
+            }
+        }
+        return PASS;
+    };
+}
+/** `anyOf`: at least one holds. Every arm's issues explain the refusal. */
+function combineAnyOf(runners) {
+    return (value, ctx) => {
+        for (const runner of runners) {
+            if (runner.run(value, ctx).ok)
+                return PASS;
+        }
+        const outcomes = runners.map((runner) => runner.run(value, ctx));
+        return fail({
+            expected: runners.length,
+            actual: 0,
+            causes: collectCauses(outcomes),
+        });
+    };
+}
+/** `oneOf`: exactly one holds. Both "none" and "several" are refusals. */
+function combineOneOf(runners) {
+    return (value, ctx) => {
+        const outcomes = runners.map((runner) => runner.run(value, ctx));
+        const accepted = outcomes.filter((outcome) => outcome.ok).length;
+        if (accepted === 1)
+            return PASS;
+        return fail({
+            expected: 1,
+            actual: accepted,
+            causes: accepted === 0 ? collectCauses(outcomes) : NO_CAUSES,
+        });
+    };
+}
+/** `not`: the single arm must NOT hold. */
+function combineNot(runners) {
+    const negated = runners[0];
+    return (value, ctx) => {
+        if (negated === undefined)
+            return PASS;
+        return negated.run(value, ctx).ok ? fail({ actual: value }) : PASS;
+    };
+}
+function composeBranches(code, branches, combine, describe, context) {
+    if (branches.length === 0)
+        return NO_RULES;
+    return Object.freeze([
+        composite({
+            code,
+            severity: context.build.config.defaultSeverity,
+            branches,
+            combine,
+            describe: () => describe,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}
+function toBranches(keyword, schemas, context) {
+    return schemas.map((member, index) => context.toBranch(`${keyword}:${String(index)}`, member));
+}
+export function composeAllOf(schema, context) {
+    const members = schema.allOf;
+    if (members === undefined)
+        return NO_RULES;
+    return composeBranches("allOf", toBranches("allOf", members, context), combineAllOf, "Value must match every schema in allOf", context);
+}
+export function composeAnyOf(schema, context) {
+    const members = schema.anyOf;
+    if (members === undefined)
+        return NO_RULES;
+    return composeBranches("anyOf", toBranches("anyOf", members, context), combineAnyOf, "Value must match at least one schema in anyOf", context);
+}
+export function composeOneOf(schema, context) {
+    const members = schema.oneOf;
+    if (members === undefined)
+        return NO_RULES;
+    return composeBranches("oneOf", toBranches("oneOf", members, context), combineOneOf, "Value must match exactly one schema in oneOf", context);
+}
+export function composeNot(schema, context) {
+    const negated = schema.not;
+    if (negated === undefined)
+        return NO_RULES;
+    return composeBranches("not", [context.toBranch("not", negated)], combineNot, "Value must not match the schema in not", context);
+}

package/dist/json-schema/create-structural-context.d.ts

@@ -0,0 +1,20 @@
+import type { ChainBuildContext } from "../chain/create-chain-node";
+import type { RefScope } from "./ref-scope";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { JsonSchemaBag } from "./json-schema-bag.types";
+import type { StructuralContext } from "./structural-expansion.types";
+/** Shared by every context of ONE conversion, so the budget is the whole. */
+interface ExpansionBudget {
+    remaining: number;
+}
+export interface ConversionSeed {
+    readonly bag: JsonSchemaBag;
+    readonly scope: RefScope;
+    readonly chain: ChainBuildContext;
+    /** Created by the entry point; every nested context shares this one. */
+    readonly budget?: ExpansionBudget;
+}
+/** The budget a conversion starts with. One per document, not one per node. */
+export declare function createExpansionBudget(): ExpansionBudget;
+export declare function createStructuralContext(seed: ConversionSeed, node: Draft07SchemaObject, visitedRefs: readonly string[], scope?: RefScope): StructuralContext;
+export {};