@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/json-schema/declare-scalar-keywords.mjs

@@ -0,0 +1,105 @@
+// ===========================================================================
+// L8  src/json-schema/declare-scalar-keywords.ts — the keywords that BIND.
+//
+// Every call below goes through applyKeywordBinding, so the chain method a
+// keyword drives is checked by the compiler against the plugin that declares
+// it. That is the whole reason step 24 exists: 1.x wrote
+// `chain.minItems && chain.minItems(n)` and the constraint evaporated.
+//
+// The slot chains are built and driven here, but a slot is NOT a filter: every
+// bound plugin in the bag passes a wrong-typed value on purpose (see
+// string-min.ts: "a wrong-typed value PASSES"), which is exactly Draft-07 §6 —
+// `minLength` says nothing about a number. So the converter applies the string
+// keywords AND the number keywords whenever they appear, without first deciding
+// what the value will be, and `type` (declare-value-keywords.ts) is the only rule
+// that judges the type. That is also what makes `type: ["string","number"]`
+// with a `minLength` correct rather than approximated.
+// ===========================================================================
+import { readChainRules } from "../chain/create-chain-node.mjs";
+import { createFieldSlots } from "../chain/create-field-slots.mjs";
+import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
+import { findFormatHandling } from "./format-map.mjs";
+import { exclusiveMaximumBinding, exclusiveMinimumBinding, maximumBinding, minimumBinding, multipleOfBinding, } from "./keyword-map-number.mjs";
+import { contentEncodingBinding, contentMediaTypeBinding, maxLengthBinding, minLengthBinding, patternBinding, } from "./keyword-map-string.mjs";
+import { UnsupportedKeywordError } from "./unsupported-keyword-error.mjs";
+const NO_RULES = Object.freeze([]);
+/** Total over the plugin's own union, so a new encoding breaks THIS line. */
+const CONTENT_ENCODING_NAMES = {
+    base64: true,
+    base32: true,
+    binary: true,
+    "7bit": true,
+    "8bit": true,
+    "quoted-printable": true,
+};
+function isContentEncodingName(name) {
+    return Object.prototype.hasOwnProperty.call(CONTENT_ENCODING_NAMES, name);
+}
+function readRules(chain) {
+    return readChainRules(chain) ?? NO_RULES;
+}
+function emptyStringChain(bag, context) {
+    return createFieldSlots(bag, context.build)
+        .string;
+}
+export function declareStringRules(schema, context) {
+    let chain = emptyStringChain(context.bag, context);
+    if (schema.minLength !== undefined) {
+        chain = applyKeywordBinding(chain, minLengthBinding, schema.minLength);
+    }
+    if (schema.maxLength !== undefined) {
+        chain = applyKeywordBinding(chain, maxLengthBinding, schema.maxLength);
+    }
+    if (schema.pattern !== undefined) {
+        chain = applyKeywordBinding(chain, patternBinding, schema.pattern);
+    }
+    if (schema.contentMediaType !== undefined) {
+        chain = applyKeywordBinding(chain, contentMediaTypeBinding, schema.contentMediaType);
+    }
+    const encoding = schema.contentEncoding;
+    if (encoding !== undefined) {
+        if (!isContentEncodingName(encoding)) {
+            throw new UnsupportedKeywordError("contentEncoding", `"${encoding}" is not one of the encodings stringContentEncoding ` +
+                "recognises; 1.x accepted every unknown name and validated nothing");
+        }
+        chain = applyKeywordBinding(chain, contentEncodingBinding, encoding);
+    }
+    return readRules(chain);
+}
+/**
+ * Draft-07 §7.2: an unknown format is an ANNOTATION and passes. A format the
+ * table declares out of scope is a different answer and throws — 1.x confused
+ * the two and its validator and its error generator disagreed about which.
+ */
+export function declareFormatRules(schema, context) {
+    const format = schema.format;
+    if (format === undefined)
+        return NO_RULES;
+    const handling = findFormatHandling(format);
+    if (handling === undefined)
+        return NO_RULES;
+    if (handling.handling === "unsupported") {
+        throw new UnsupportedKeywordError(`format: ${format}`, handling.reason);
+    }
+    const chain = emptyStringChain(context.bag, context);
+    return readRules(applyKeywordBinding(chain, handling, "format"));
+}
+export function declareNumberRules(schema, context) {
+    let chain = createFieldSlots(context.bag, context.build).number;
+    if (schema.minimum !== undefined) {
+        chain = applyKeywordBinding(chain, minimumBinding, schema.minimum);
+    }
+    if (schema.maximum !== undefined) {
+        chain = applyKeywordBinding(chain, maximumBinding, schema.maximum);
+    }
+    if (schema.exclusiveMinimum !== undefined) {
+        chain = applyKeywordBinding(chain, exclusiveMinimumBinding, schema.exclusiveMinimum);
+    }
+    if (schema.exclusiveMaximum !== undefined) {
+        chain = applyKeywordBinding(chain, exclusiveMaximumBinding, schema.exclusiveMaximum);
+    }
+    if (schema.multipleOf !== undefined) {
+        chain = applyKeywordBinding(chain, multipleOfBinding, schema.multipleOf);
+    }
+    return readRules(chain);
+}

package/dist/json-schema/declare-value-keywords.d.ts

@@ -0,0 +1,23 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject, Draft07TypeKeyword } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+/** The declared names, always as a list, with unknown names rejected loudly. */
+export declare function readDeclaredTypes(schema: Draft07SchemaObject): readonly Draft07TypeKeyword[];
+/** True when the document permits an explicit null at this position. */
+export declare function permitsNull(schema: Draft07SchemaObject): boolean;
+/**
+ * One check for the whole list: `type: ["string","number"]` is a union, and
+ * running one rule per member would report a failure per member for a value
+ * that fails all of them.
+ */
+export declare function declareTypeRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/** `type: "integer"` is the only `type` member that adds a chain method. */
+export declare function declareIntegerRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function declareConstRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/**
+ * `enum` drives the `.oneOf()` METHOD, which is a different thing from the
+ * `oneOf` KEYWORD. The list is typed against the FIELD (readonly SelfValue[]),
+ * so it carries a marker and can never be a keyword binding; the converter
+ * resolves the list and calls the plugin itself, exactly as the table says.
+ */
+export declare function declareEnumRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/declare-value-keywords.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDeclaredTypes = readDeclaredTypes;
+exports.permitsNull = permitsNull;
+exports.declareTypeRules = declareTypeRules;
+exports.declareIntegerRules = declareIntegerRules;
+exports.declareConstRules = declareConstRules;
+exports.declareEnumRules = declareEnumRules;
+// ===========================================================================
+// L8  src/json-schema/declare-value-keywords.ts — the keywords
+// that judge the VALUE ITSELF: `type`, `enum` and `const`.
+//
+// The keyword table calls `type` structural because it "chooses the slot".
+// Choosing a slot is a TYPE-LEVEL act and asserts nothing at run time, so a
+// converter that only chose a slot would accept `42` for `{"type":"string"}` —
+// which is precisely what 1.x did (docs/legacy-spec/json-schema-mapping.md).
+// The slot choice is still made, in declare-scalar-keywords; the RULE is made
+// here, from create-rule, because no plugin in JsonSchemaBag asserts a
+// primitive type (`object` is the only type plugin in the catalogue and it is
+// not in the bag).
+//
+// `null` never reaches a check — src/runtime/decide-presence.ts settles absence
+// first — so `type: "null"` reads as "every value that got this far is wrong",
+// which is exactly right: the only null-shaped value was already accepted by
+// the nullable presence rule this module's neighbour declares.
+// ===========================================================================
+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 types_1 = require("../types");
+const apply_keyword_binding_1 = require("./apply-keyword-binding");
+const keyword_map_core_1 = require("./keyword-map-core");
+const NO_RULES = Object.freeze([]);
+/** Every Draft-07 `type` name, so an unknown one is a build-time refusal. */
+const JSON_TYPE_TESTS = {
+    string: types_1.isString,
+    number: (value) => typeof value === "number",
+    integer: (value) => typeof value === "number" && Number.isInteger(value),
+    boolean: (value) => typeof value === "boolean",
+    array: types_1.isArray,
+    object: types_1.isPlainObject,
+    null: (value) => value === null,
+};
+function isTypeKeyword(name) {
+    return Object.prototype.hasOwnProperty.call(JSON_TYPE_TESTS, name);
+}
+/** The declared names, always as a list, with unknown names rejected loudly. */
+function readDeclaredTypes(schema) {
+    const declared = schema.type;
+    if (declared === undefined)
+        return Object.freeze([]);
+    const names = (0, types_1.isArray)(declared) ? declared : [declared];
+    return Object.freeze(names.filter((name) => isTypeKeyword(name)));
+}
+/** True when the document permits an explicit null at this position. */
+function permitsNull(schema) {
+    const declared = readDeclaredTypes(schema);
+    return declared.length === 0 || declared.includes("null");
+}
+function describeActual(value) {
+    if (value === null)
+        return "null";
+    if ((0, types_1.isArray)(value))
+        return "array";
+    return typeof value;
+}
+/**
+ * One check for the whole list: `type: ["string","number"]` is a union, and
+ * running one rule per member would report a failure per member for a value
+ * that fails all of them.
+ */
+function declareTypeRules(schema, context) {
+    const declared = readDeclaredTypes(schema);
+    if (declared.length === 0)
+        return NO_RULES;
+    const tests = declared.map((name) => JSON_TYPE_TESTS[name]);
+    const rendered = declared.join(" or ");
+    return Object.freeze([
+        (0, create_rule_1.check)({
+            code: "type",
+            severity: context.build.config.defaultSeverity,
+            run: (value) => tests.some((test) => test(value))
+                ? types_1.PASS
+                : (0, types_1.fail)({ expected: rendered, actual: describeActual(value) }),
+            describe: (detail) => `Value must be of type ${rendered}, but got ${String(detail.actual)}`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}
+/** `type: "integer"` is the only `type` member that adds a chain method. */
+function declareIntegerRules(schema, context) {
+    if (!readDeclaredTypes(schema).includes("integer"))
+        return NO_RULES;
+    const plugin = context.bag.numberInteger;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "type")),
+    ]);
+}
+function declareConstRules(schema, context) {
+    if (!Object.prototype.hasOwnProperty.call(schema, "const"))
+        return NO_RULES;
+    const chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).any;
+    const applied = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_core_1.constBinding, schema.const);
+    return (0, create_chain_node_1.readChainRules)(applied) ?? NO_RULES;
+}
+/**
+ * `enum` drives the `.oneOf()` METHOD, which is a different thing from the
+ * `oneOf` KEYWORD. The list is typed against the FIELD (readonly SelfValue[]),
+ * so it carries a marker and can never be a keyword binding; the converter
+ * resolves the list and calls the plugin itself, exactly as the table says.
+ */
+function declareEnumRules(schema, context) {
+    const allowed = schema.enum;
+    if (allowed === undefined || allowed.length === 0)
+        return NO_RULES;
+    const plugin = context.bag.oneOf;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "enum"), allowed),
+    ]);
+}

package/dist/json-schema/declare-value-keywords.mjs

@@ -0,0 +1,112 @@
+// ===========================================================================
+// L8  src/json-schema/declare-value-keywords.ts — the keywords
+// that judge the VALUE ITSELF: `type`, `enum` and `const`.
+//
+// The keyword table calls `type` structural because it "chooses the slot".
+// Choosing a slot is a TYPE-LEVEL act and asserts nothing at run time, so a
+// converter that only chose a slot would accept `42` for `{"type":"string"}` —
+// which is precisely what 1.x did (docs/legacy-spec/json-schema-mapping.md).
+// The slot choice is still made, in declare-scalar-keywords; the RULE is made
+// here, from create-rule, because no plugin in JsonSchemaBag asserts a
+// primitive type (`object` is the only type plugin in the catalogue and it is
+// not in the bag).
+//
+// `null` never reaches a check — src/runtime/decide-presence.ts settles absence
+// first — so `type: "null"` reads as "every value that got this far is wrong",
+// which is exactly right: the only null-shaped value was already accepted by
+// the nullable presence rule this module's neighbour declares.
+// ===========================================================================
+import { readChainRules } from "../chain/create-chain-node.mjs";
+import { createFieldSlots } from "../chain/create-field-slots.mjs";
+import { check } from "../plugin-kit/create-rule.mjs";
+import { PASS, fail, isArray, isPlainObject, isString } from "../types/index.mjs";
+import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
+import { constBinding } from "./keyword-map-core.mjs";
+const NO_RULES = Object.freeze([]);
+/** Every Draft-07 `type` name, so an unknown one is a build-time refusal. */
+const JSON_TYPE_TESTS = {
+    string: isString,
+    number: (value) => typeof value === "number",
+    integer: (value) => typeof value === "number" && Number.isInteger(value),
+    boolean: (value) => typeof value === "boolean",
+    array: isArray,
+    object: isPlainObject,
+    null: (value) => value === null,
+};
+function isTypeKeyword(name) {
+    return Object.prototype.hasOwnProperty.call(JSON_TYPE_TESTS, name);
+}
+/** The declared names, always as a list, with unknown names rejected loudly. */
+export function readDeclaredTypes(schema) {
+    const declared = schema.type;
+    if (declared === undefined)
+        return Object.freeze([]);
+    const names = isArray(declared) ? declared : [declared];
+    return Object.freeze(names.filter((name) => isTypeKeyword(name)));
+}
+/** True when the document permits an explicit null at this position. */
+export function permitsNull(schema) {
+    const declared = readDeclaredTypes(schema);
+    return declared.length === 0 || declared.includes("null");
+}
+function describeActual(value) {
+    if (value === null)
+        return "null";
+    if (isArray(value))
+        return "array";
+    return typeof value;
+}
+/**
+ * One check for the whole list: `type: ["string","number"]` is a union, and
+ * running one rule per member would report a failure per member for a value
+ * that fails all of them.
+ */
+export function declareTypeRules(schema, context) {
+    const declared = readDeclaredTypes(schema);
+    if (declared.length === 0)
+        return NO_RULES;
+    const tests = declared.map((name) => JSON_TYPE_TESTS[name]);
+    const rendered = declared.join(" or ");
+    return Object.freeze([
+        check({
+            code: "type",
+            severity: context.build.config.defaultSeverity,
+            run: (value) => tests.some((test) => test(value))
+                ? PASS
+                : fail({ expected: rendered, actual: describeActual(value) }),
+            describe: (detail) => `Value must be of type ${rendered}, but got ${String(detail.actual)}`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}
+/** `type: "integer"` is the only `type` member that adds a chain method. */
+export function declareIntegerRules(schema, context) {
+    if (!readDeclaredTypes(schema).includes("integer"))
+        return NO_RULES;
+    const plugin = context.bag.numberInteger;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "type")),
+    ]);
+}
+export function declareConstRules(schema, context) {
+    if (!Object.prototype.hasOwnProperty.call(schema, "const"))
+        return NO_RULES;
+    const chain = createFieldSlots(context.bag, context.build).any;
+    const applied = applyKeywordBinding(chain, constBinding, schema.const);
+    return readChainRules(applied) ?? NO_RULES;
+}
+/**
+ * `enum` drives the `.oneOf()` METHOD, which is a different thing from the
+ * `oneOf` KEYWORD. The list is typed against the FIELD (readonly SelfValue[]),
+ * so it carries a marker and can never be a keyword binding; the converter
+ * resolves the list and calls the plugin itself, exactly as the table says.
+ */
+export function declareEnumRules(schema, context) {
+    const allowed = schema.enum;
+    if (allowed === undefined || allowed.length === 0)
+        return NO_RULES;
+    const plugin = context.bag.oneOf;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "enum"), allowed),
+    ]);
+}

package/dist/json-schema/draft07-keyword-value.types.d.ts

@@ -0,0 +1,61 @@
+import type { ContentEncodingName } from "../plugins/string-content-encoding";
+import type { Draft07Schema, Draft07TypeKeyword } from "./draft07.types";
+export type Draft07CoreKeyword = "$schema" | "$id" | "$ref" | "$comment" | "definitions" | "title" | "description" | "default" | "examples" | "readOnly" | "writeOnly" | "type" | "enum" | "const" | "allOf" | "anyOf" | "oneOf" | "not" | "if" | "then" | "else";
+export type Draft07NumberKeyword = "multipleOf" | "maximum" | "exclusiveMaximum" | "minimum" | "exclusiveMinimum";
+export type Draft07StringKeyword = "maxLength" | "minLength" | "pattern" | "format" | "contentEncoding" | "contentMediaType";
+export type Draft07ArrayKeyword = "items" | "additionalItems" | "maxItems" | "minItems" | "uniqueItems" | "contains";
+export type Draft07ObjectKeyword = "maxProperties" | "minProperties" | "required" | "properties" | "patternProperties" | "additionalProperties" | "dependencies" | "propertyNames";
+/** All 46 Draft-07 keywords. Written by hand; checked against the record. */
+export type Draft07Keyword = Draft07CoreKeyword | Draft07NumberKeyword | Draft07StringKeyword | Draft07ArrayKeyword | Draft07ObjectKeyword;
+export interface Draft07KeywordValues {
+    readonly $schema: string;
+    readonly $id: string;
+    readonly $ref: string;
+    readonly $comment: string;
+    readonly definitions: Readonly<Record<string, Draft07Schema>>;
+    readonly title: string;
+    readonly description: string;
+    readonly default: unknown;
+    readonly examples: readonly unknown[];
+    readonly readOnly: boolean;
+    readonly writeOnly: boolean;
+    readonly type: Draft07TypeKeyword | readonly Draft07TypeKeyword[];
+    readonly enum: readonly unknown[];
+    readonly const: unknown;
+    readonly allOf: readonly Draft07Schema[];
+    readonly anyOf: readonly Draft07Schema[];
+    readonly oneOf: readonly Draft07Schema[];
+    readonly not: Draft07Schema;
+    readonly if: Draft07Schema;
+    readonly then: Draft07Schema;
+    readonly else: Draft07Schema;
+    readonly multipleOf: number;
+    readonly maximum: number;
+    readonly exclusiveMaximum: number;
+    readonly minimum: number;
+    readonly exclusiveMinimum: number;
+    readonly maxLength: number;
+    readonly minLength: number;
+    readonly pattern: string;
+    readonly format: string;
+    /** Normalised: an unknown encoding name never reaches the binding. */
+    readonly contentEncoding: ContentEncodingName;
+    readonly contentMediaType: string;
+    readonly items: Draft07Schema | readonly Draft07Schema[];
+    readonly additionalItems: Draft07Schema;
+    readonly maxItems: number;
+    readonly minItems: number;
+    /** Normalised: `uniqueItems: false` is a no-op and is dropped first. */
+    readonly uniqueItems: true;
+    readonly contains: Draft07Schema;
+    readonly maxProperties: number;
+    readonly minProperties: number;
+    /** Normalised: the parent's array, resolved to one flag per child. */
+    readonly required: true;
+    readonly properties: Readonly<Record<string, Draft07Schema>>;
+    readonly patternProperties: Readonly<Record<string, Draft07Schema>>;
+    /** Normalised: only the boolean form binds; the schema form is structural. */
+    readonly additionalProperties: boolean;
+    readonly dependencies: Readonly<Record<string, Draft07Schema | readonly string[]>>;
+    readonly propertyNames: Draft07Schema;
+}

package/dist/json-schema/draft07-keyword-value.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/json-schema/draft07-keyword-value.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/json-schema/draft07.types.d.ts

@@ -0,0 +1,57 @@
+/** The seven values Draft-07 allows in `type`. `integer` is NOT a Luq slot. */
+export type Draft07TypeKeyword = "string" | "number" | "integer" | "boolean" | "array" | "object" | "null";
+export type Draft07Schema = boolean | Draft07SchemaObject;
+export interface Draft07SchemaObject {
+    readonly $id?: string;
+    readonly $schema?: string;
+    readonly $ref?: string;
+    readonly $comment?: string;
+    readonly definitions?: Readonly<Record<string, Draft07Schema>>;
+    /** 2019-09 spelling. Not a Draft-07 keyword; only the RESOLVER accepts it. */
+    readonly $defs?: Readonly<Record<string, Draft07Schema>>;
+    readonly title?: string;
+    readonly description?: string;
+    readonly default?: unknown;
+    readonly readOnly?: boolean;
+    readonly writeOnly?: boolean;
+    readonly examples?: readonly unknown[];
+    readonly type?: Draft07TypeKeyword | readonly Draft07TypeKeyword[];
+    readonly enum?: readonly unknown[];
+    readonly const?: unknown;
+    readonly format?: string;
+    readonly multipleOf?: number;
+    readonly maximum?: number;
+    readonly exclusiveMaximum?: number;
+    readonly minimum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly maxLength?: number;
+    readonly minLength?: number;
+    readonly pattern?: string;
+    readonly contentMediaType?: string;
+    readonly contentEncoding?: string;
+    readonly items?: Draft07Schema | readonly Draft07Schema[];
+    readonly additionalItems?: Draft07Schema;
+    readonly maxItems?: number;
+    readonly minItems?: number;
+    readonly uniqueItems?: boolean;
+    readonly contains?: Draft07Schema;
+    readonly maxProperties?: number;
+    readonly minProperties?: number;
+    readonly required?: readonly string[];
+    readonly properties?: Readonly<Record<string, Draft07Schema>>;
+    readonly patternProperties?: Readonly<Record<string, Draft07Schema>>;
+    readonly additionalProperties?: Draft07Schema;
+    readonly dependencies?: Readonly<Record<string, Draft07Schema | readonly string[]>>;
+    readonly propertyNames?: Draft07Schema;
+    readonly allOf?: readonly Draft07Schema[];
+    readonly anyOf?: readonly Draft07Schema[];
+    readonly oneOf?: readonly Draft07Schema[];
+    readonly not?: Draft07Schema;
+    readonly if?: Draft07Schema;
+    readonly then?: Draft07Schema;
+    readonly else?: Draft07Schema;
+}
+/** Narrows away the boolean form of §4.4 without an assertion. */
+export declare function isSchemaObject(schema: Draft07Schema): schema is Draft07SchemaObject;
+/** The one entry gate for untyped JSON. `null` is NOT a schema. */
+export declare function isDraft07Schema(value: unknown): value is Draft07Schema;

package/dist/json-schema/draft07.types.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSchemaObject = isSchemaObject;
+exports.isDraft07Schema = isDraft07Schema;
+// ===========================================================================
+// L8  src/json-schema/draft07.types.ts — the DOCUMENT shape.
+//
+// This is what a Draft-07 JSON document is allowed to say, keyword for
+// keyword, straight from the draft-07 meta-schema's `properties` (46 keys).
+// It is deliberately NOT the same thing as `Draft07KeywordValues`: this type
+// is as wide as the specification, while the value types next door are as
+// narrow as the handling can accept, so the converter is FORCED by the
+// compiler to normalise (`uniqueItems: boolean` -> `true`, a `required` array
+// -> a per-field flag) instead of quietly passing the wide form through.
+//
+// A schema may also be a bare boolean — Draft-07 §4.4 — and 1.x's converter
+// could not represent that at all (it tested `typeof x === "object"` and
+// dropped the rest), so it is in the union here from the start.
+// ===========================================================================
+const types_1 = require("../types");
+/** Narrows away the boolean form of §4.4 without an assertion. */
+function isSchemaObject(schema) {
+    return typeof schema !== "boolean";
+}
+/** The one entry gate for untyped JSON. `null` is NOT a schema. */
+function isDraft07Schema(value) {
+    return typeof value === "boolean" || (0, types_1.isPlainObject)(value);
+}

package/dist/json-schema/draft07.types.mjs

@@ -0,0 +1,24 @@
+// ===========================================================================
+// L8  src/json-schema/draft07.types.ts — the DOCUMENT shape.
+//
+// This is what a Draft-07 JSON document is allowed to say, keyword for
+// keyword, straight from the draft-07 meta-schema's `properties` (46 keys).
+// It is deliberately NOT the same thing as `Draft07KeywordValues`: this type
+// is as wide as the specification, while the value types next door are as
+// narrow as the handling can accept, so the converter is FORCED by the
+// compiler to normalise (`uniqueItems: boolean` -> `true`, a `required` array
+// -> a per-field flag) instead of quietly passing the wide form through.
+//
+// A schema may also be a bare boolean — Draft-07 §4.4 — and 1.x's converter
+// could not represent that at all (it tested `typeof x === "object"` and
+// dropped the rest), so it is in the union here from the start.
+// ===========================================================================
+import { isPlainObject } from "../types/index.mjs";
+/** Narrows away the boolean form of §4.4 without an assertion. */
+export function isSchemaObject(schema) {
+    return typeof schema !== "boolean";
+}
+/** The one entry gate for untyped JSON. `null` is NOT a schema. */
+export function isDraft07Schema(value) {
+    return typeof value === "boolean" || isPlainObject(value);
+}

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

@@ -0,0 +1,3 @@
+export { SCHEMA_BRANCH_LABEL, collectDocumentRules, jsonSchemaPlugin, } from "./json-schema";
+export { NotASchemaError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index";
+export type { Draft07Schema, Draft07SchemaObject, JsonSchemaBag, } from "../../index";

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFormatNames = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Schema = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.RefResolutionError = exports.UnsupportedKeywordError = exports.NotASchemaError = exports.jsonSchemaPlugin = exports.collectDocumentRules = exports.SCHEMA_BRANCH_LABEL = void 0;
+// ===========================================================================
+// The public subpath `@maroonedog/luq/plugins/jsonSchema`. Re-exports only.
+//
+// 1.x published this subpath as "the jsonSchema barrel": the plugin plus the
+// module's named helpers. The same shape is kept — the plugin, the conversion
+// front door, and the errors a caller has to be able to catch by identity —
+// with ONE deliberate omission: no plugin entry file is imported from here, so
+// a consumer of this subpath pays only for the plugins they import themselves.
+// ===========================================================================
+var json_schema_1 = require("./json-schema");
+Object.defineProperty(exports, "SCHEMA_BRANCH_LABEL", { enumerable: true, get: function () { return json_schema_1.SCHEMA_BRANCH_LABEL; } });
+Object.defineProperty(exports, "collectDocumentRules", { enumerable: true, get: function () { return json_schema_1.collectDocumentRules; } });
+Object.defineProperty(exports, "jsonSchemaPlugin", { enumerable: true, get: function () { return json_schema_1.jsonSchemaPlugin; } });
+var index_1 = require("../../index");
+Object.defineProperty(exports, "NotASchemaError", { enumerable: true, get: function () { return index_1.NotASchemaError; } });
+Object.defineProperty(exports, "UnsupportedKeywordError", { enumerable: true, get: function () { return index_1.UnsupportedKeywordError; } });
+Object.defineProperty(exports, "RefResolutionError", { enumerable: true, get: function () { return index_1.RefResolutionError; } });
+Object.defineProperty(exports, "buildFieldEntries", { enumerable: true, get: function () { return index_1.buildFieldEntries; } });
+Object.defineProperty(exports, "buildFromSchema", { enumerable: true, get: function () { return index_1.buildFromSchema; } });
+Object.defineProperty(exports, "fromJsonSchema", { enumerable: true, get: function () { return index_1.fromJsonSchema; } });
+Object.defineProperty(exports, "isDraft07Schema", { enumerable: true, get: function () { return index_1.isDraft07Schema; } });
+Object.defineProperty(exports, "listBoundPluginNames", { enumerable: true, get: function () { return index_1.listBoundPluginNames; } });
+Object.defineProperty(exports, "listDraft07Keywords", { enumerable: true, get: function () { return index_1.listDraft07Keywords; } });
+Object.defineProperty(exports, "listFormatNames", { enumerable: true, get: function () { return index_1.listFormatNames; } });

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

@@ -0,0 +1,11 @@
+// ===========================================================================
+// The public subpath `@maroonedog/luq/plugins/jsonSchema`. Re-exports only.
+//
+// 1.x published this subpath as "the jsonSchema barrel": the plugin plus the
+// module's named helpers. The same shape is kept — the plugin, the conversion
+// front door, and the errors a caller has to be able to catch by identity —
+// with ONE deliberate omission: no plugin entry file is imported from here, so
+// 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";

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

@@ -0,0 +1,18 @@
+import type { Rule } from "../../../plugin-kit/compiled-rule";
+import { type MessageContextExtra, type TypeName } from "../../../types";
+import type { RuleBuildContext } from "../../../plugin-kit/rule-build-context";
+import type { Unchanged } from "../../../plugin-kit/marker.types";
+import { type JsonSchemaBag } from "../../index";
+/** The label the whole document carries inside the composite it becomes. */
+export declare const SCHEMA_BRANCH_LABEL = "schema";
+/**
+ * The document as a rule list over ONE subject. Exported because it is the
+ * only part of this plugin the full-feature bundle needs, and because a test
+ * can then count the rules a document produces without building a validator.
+ */
+export declare function collectDocumentRules(ctx: RuleBuildContext<MessageContextExtra>, document: unknown, bag: JsonSchemaBag): readonly Rule[];
+export declare const jsonSchemaPlugin: import("../../../plugin-kit/plugin-definition").PluginDefinition<"jsonSchema", "jsonSchema", readonly TypeName[], {
+    args: readonly [document: unknown, bag: JsonSchemaBag];
+    out: Unchanged;
+    context: MessageContextExtra;
+}>;