@maroonedog/luq 2.4.0 → 2.4.2

package/dist/builder/compile-declarations.d.ts

@@ -1,10 +1,16 @@
 import type { ValidationPlan } from "../compile/validation-plan.types";
-import type { GlobalConfig } from "../types/global-config";
+import type { GlobalConfig, ResolvedGlobalConfig } from "../types/global-config";
 import type { FieldEntry } from "./field-entry.types";
 import type { FieldDeclaredCalls } from "./field-declared-calls.types";
 /** What build() makes in one pass: the plan to run, and what was declared. */
 export interface CompiledDeclarations {
     readonly plan: ValidationPlan;
     readonly declaredCalls: readonly FieldDeclaredCalls[];
+    /**
+     * Resolved once here, and carried out because the root short-circuit needs
+     * it too. That rejection happens before any rule, so it cannot read the
+     * config the way a plugin does — through RuleBuildContext.
+     */
+    readonly config: ResolvedGlobalConfig;
 }
 export declare function compileDeclarations(entries: readonly FieldEntry[], configOverride: GlobalConfig | undefined): CompiledDeclarations;

package/dist/builder/compile-declarations.js

@@ -46,5 +46,6 @@ function compileDeclarations(entries, configOverride) {
     return {
         plan: (0, compile_schema_1.compileSchema)(declarations, (0, run_branch_1.createBranchExecutor)()),
         declaredCalls,
+        config,
     };
 }

package/dist/builder/compile-declarations.mjs

@@ -43,5 +43,6 @@ export function compileDeclarations(entries, configOverride) {
     return {
         plan: compileSchema(declarations, createBranchExecutor()),
         declaredCalls,
+        config,
     };
 }

package/dist/builder/create-field-builder.js

@@ -27,7 +27,7 @@ const NO_ENTRIES = Object.freeze([]);
  */
 function buildValidator(entries, configOverride) {
     const compiled = (0, compile_declarations_1.compileDeclarations)(entries, configOverride);
-    const validator = (0, create_plan_validator_1.createPlanBackedValidator)(compiled.plan);
+    const validator = (0, create_plan_validator_1.createPlanBackedValidator)(compiled.plan, compiled.config);
     (0, declared_calls_store_1.rememberDeclaredCalls)(validator, compiled.declaredCalls);
     return validator;
 }

package/dist/builder/create-field-builder.mjs

@@ -24,7 +24,7 @@ const NO_ENTRIES = Object.freeze([]);
  */
 function buildValidator(entries, configOverride) {
     const compiled = compileDeclarations(entries, configOverride);
-    const validator = createPlanBackedValidator(compiled.plan);
+    const validator = createPlanBackedValidator(compiled.plan, compiled.config);
     rememberDeclaredCalls(validator, compiled.declaredCalls);
     return validator;
 }

package/dist/builder/create-plan-validator.d.ts

@@ -1,3 +1,4 @@
 import type { ValidationPlan } from "../compile/validation-plan.types";
+import type { ResolvedGlobalConfig } from "../types/global-config";
 import type { PlanBackedValidator } from "./builder-surface.types";
-export declare function createPlanBackedValidator(plan: ValidationPlan): PlanBackedValidator;
+export declare function createPlanBackedValidator(plan: ValidationPlan, config: ResolvedGlobalConfig): PlanBackedValidator;

package/dist/builder/create-plan-validator.js

@@ -4,8 +4,8 @@ exports.createPlanBackedValidator = createPlanBackedValidator;
 const create_field_validator_1 = require("../runtime/create-field-validator");
 const create_validator_1 = require("../runtime/create-validator");
 const create_subset_validator_1 = require("./create-subset-validator");
-function createPlanBackedValidator(plan) {
-    const validator = (0, create_validator_1.createValidator)(plan);
+function createPlanBackedValidator(plan, config) {
+    const validator = (0, create_validator_1.createValidator)(plan, config);
     return Object.freeze({
         validate: validator.validate,
         parse: validator.parse,

package/dist/builder/create-plan-validator.mjs

@@ -1,8 +1,8 @@
 import { createFieldValidator } from "../runtime/create-field-validator.mjs";
 import { createValidator } from "../runtime/create-validator.mjs";
 import { createSubsetValidator } from "./create-subset-validator.mjs";
-export function createPlanBackedValidator(plan) {
-    const validator = createValidator(plan);
+export function createPlanBackedValidator(plan, config) {
+    const validator = createValidator(plan, config);
     return Object.freeze({
         validate: validator.validate,
         parse: validator.parse,

package/dist/runtime/create-validator.d.ts

@@ -1,14 +1,22 @@
 import type { ValidationIssue } from "../types";
 import type { ValidateOptions, ValidationResult } from "../types/validation-result.types";
 import type { ValidationPlan } from "../compile/validation-plan.types";
+import { type ResolvedGlobalConfig } from "../types/global-config";
 /** The untyped pair. L6 puts the declared type back on top of it. */
 export interface PlanValidator {
     validate(value: unknown, options?: ValidateOptions): ValidationResult<unknown>;
     parse(value: unknown, options?: ValidateOptions): ValidationResult<unknown>;
 }
-/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
-export declare const ROOT_MISSING_CODE = "REQUIRED";
-export declare const ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * The code an absent SUBJECT reports.
+ *
+ * The same spelling a missing FIELD reports, deliberately. It was "REQUIRED"
+ * — 1.x's SCREAMING_SNAKE, carried over with the wording — which meant a
+ * caller switching on issue.code handled `required` for a missing field and
+ * missed the root, where the only difference is how much of the value was
+ * absent.
+ */
+export declare const ROOT_MISSING_CODE = "required";
 /**
  * Severity decides validity, and nothing else does. An `info` or `warning`
  * issue is still an issue — the sink counted it and abortEarly saw it — but it
@@ -16,4 +24,4 @@ export declare const ROOT_MISSING_MESSAGE = "Value is required";
  * an `issues` list at all.
  */
 export declare function hasRejectingIssue(issues: readonly ValidationIssue[]): boolean;
-export declare function createValidator(plan: ValidationPlan): PlanValidator;
+export declare function createValidator(plan: ValidationPlan, config?: ResolvedGlobalConfig): PlanValidator;

package/dist/runtime/create-validator.js

@@ -1,30 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ROOT_MISSING_MESSAGE = exports.ROOT_MISSING_CODE = void 0;
+exports.ROOT_MISSING_CODE = void 0;
 exports.hasRejectingIssue = hasRejectingIssue;
 exports.createValidator = createValidator;
+const global_config_1 = require("../types/global-config");
 const index_stack_1 = require("./index-stack");
 const issue_sink_1 = require("./issue-sink");
 const output_writer_1 = require("./output-writer");
 const run_recursion_1 = require("./run-recursion");
 const run_plan_1 = require("./run-plan");
-/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
-exports.ROOT_MISSING_CODE = "REQUIRED";
-exports.ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * The code an absent SUBJECT reports.
+ *
+ * The same spelling a missing FIELD reports, deliberately. It was "REQUIRED"
+ * — 1.x's SCREAMING_SNAKE, carried over with the wording — which meant a
+ * caller switching on issue.code handled `required` for a missing field and
+ * missed the root, where the only difference is how much of the value was
+ * absent.
+ */
+exports.ROOT_MISSING_CODE = "required";
 /**
  * A null or undefined subject fails before the plan runs. Without it every
  * reader would answer `undefined`, OPEN_PRESENCE would permit every absence,
  * and `validate(null)` would report success for a schema that declares nothing
  * required.
  */
-function rejectMissingRoot() {
+function rejectMissingRoot(config) {
     return {
         valid: false,
         issues: Object.freeze([
             Object.freeze({
                 path: "",
                 code: exports.ROOT_MISSING_CODE,
-                message: exports.ROOT_MISSING_MESSAGE,
+                message: config.rootMissingMessage,
+                // Not config.defaultSeverity. A warning here would let validate(null)
+                // report success for a schema that declares nothing required, which is
+                // the outcome this rejection exists to prevent.
                 severity: "error",
             }),
         ]),
@@ -66,9 +77,9 @@ function nodeCanRecurse(node) {
     return (node.elementFields.some((field) => field.recursion !== null) ||
         node.nested.some(nodeCanRecurse));
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
+function runRoot(plan, config, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
-        return rejectMissingRoot();
+        return rejectMissingRoot(config);
     const sink = new issue_sink_1.IssueSink((0, issue_sink_1.resolveAbortPolicy)(options));
     const output = (0, run_plan_1.runPlan)(plan, value, {
         root: value,
@@ -89,12 +100,12 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurs
         return { valid: false, issues };
     return { valid: true, data: output, issues };
 }
-function createValidator(plan) {
+function createValidator(plan, config = global_config_1.DEFAULT_GLOBAL_CONFIG) {
     const parseTargets = (0, output_writer_1.createPlanWriteTargets)(plan);
     const shouldWriteOutput = parseTargets !== null;
     const canRecurse = planCanRecurse(plan);
     return {
-        validate: (value, options) => runRoot(plan, value, options, output_writer_1.NO_WRITE_TARGETS, false, canRecurse),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
+        validate: (value, options) => runRoot(plan, config, value, options, output_writer_1.NO_WRITE_TARGETS, false, canRecurse),
+        parse: (value, options) => runRoot(plan, config, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
     };
 }

package/dist/runtime/create-validator.mjs

@@ -1,25 +1,36 @@
+import { DEFAULT_GLOBAL_CONFIG, } from "../types/global-config.mjs";
 import { IndexStack } from "./index-stack.mjs";
 import { IssueSink, resolveAbortPolicy } from "./issue-sink.mjs";
 import { NO_WRITE_TARGETS, createPlanWriteTargets } from "./output-writer.mjs";
 import { createRecursionRunner } from "./run-recursion.mjs";
 import { runPlan } from "./run-plan.mjs";
-/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
-export const ROOT_MISSING_CODE = "REQUIRED";
-export const ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * The code an absent SUBJECT reports.
+ *
+ * The same spelling a missing FIELD reports, deliberately. It was "REQUIRED"
+ * — 1.x's SCREAMING_SNAKE, carried over with the wording — which meant a
+ * caller switching on issue.code handled `required` for a missing field and
+ * missed the root, where the only difference is how much of the value was
+ * absent.
+ */
+export const ROOT_MISSING_CODE = "required";
 /**
  * A null or undefined subject fails before the plan runs. Without it every
  * reader would answer `undefined`, OPEN_PRESENCE would permit every absence,
  * and `validate(null)` would report success for a schema that declares nothing
  * required.
  */
-function rejectMissingRoot() {
+function rejectMissingRoot(config) {
     return {
         valid: false,
         issues: Object.freeze([
             Object.freeze({
                 path: "",
                 code: ROOT_MISSING_CODE,
-                message: ROOT_MISSING_MESSAGE,
+                message: config.rootMissingMessage,
+                // Not config.defaultSeverity. A warning here would let validate(null)
+                // report success for a schema that declares nothing required, which is
+                // the outcome this rejection exists to prevent.
                 severity: "error",
             }),
         ]),
@@ -61,9 +72,9 @@ function nodeCanRecurse(node) {
     return (node.elementFields.some((field) => field.recursion !== null) ||
         node.nested.some(nodeCanRecurse));
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
+function runRoot(plan, config, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
-        return rejectMissingRoot();
+        return rejectMissingRoot(config);
     const sink = new IssueSink(resolveAbortPolicy(options));
     const output = runPlan(plan, value, {
         root: value,
@@ -84,12 +95,12 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurs
         return { valid: false, issues };
     return { valid: true, data: output, issues };
 }
-export function createValidator(plan) {
+export function createValidator(plan, config = DEFAULT_GLOBAL_CONFIG) {
     const parseTargets = createPlanWriteTargets(plan);
     const shouldWriteOutput = parseTargets !== null;
     const canRecurse = planCanRecurse(plan);
     return {
-        validate: (value, options) => runRoot(plan, value, options, NO_WRITE_TARGETS, false, canRecurse),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
+        validate: (value, options) => runRoot(plan, config, value, options, NO_WRITE_TARGETS, false, canRecurse),
+        parse: (value, options) => runRoot(plan, config, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
     };
 }

package/dist/runtime/index.d.ts

@@ -13,7 +13,7 @@ export { prefixIssuePaths, runPlan } from "./run-plan";
 export { RECURSION_ABORT_POLICY, createRecursionRunner } from "./run-recursion";
 export type { RecursionHost } from "./run-recursion";
 export { BRANCH_ABORT_POLICY, createBranchExecutor } from "./run-branch";
-export { ROOT_MISSING_CODE, ROOT_MISSING_MESSAGE, createValidator, hasRejectingIssue, } from "./create-validator";
+export { ROOT_MISSING_CODE, createValidator, hasRejectingIssue, } from "./create-validator";
 export type { PlanValidator } from "./create-validator";
 export { createFieldValidator } from "./create-field-validator";
 export type { PlanFieldValidator } from "./create-field-validator";

package/dist/runtime/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFieldValidator = exports.hasRejectingIssue = exports.createValidator = exports.ROOT_MISSING_MESSAGE = exports.ROOT_MISSING_CODE = exports.createBranchExecutor = exports.BRANCH_ABORT_POLICY = exports.createRecursionRunner = exports.RECURSION_ABORT_POLICY = exports.runPlan = exports.prefixIssuePaths = exports.runArrayNodes = exports.writeFieldValue = exports.replaceElement = exports.createPlanWriteTargets = exports.createArrayWriteTargets = exports.NO_WRITE_TARGETS = exports.runField = exports.FIELD_VALUE_UNCHANGED = exports.decidePresence = exports.renderFallbackMessage = exports.createIssue = exports.joinIssuePath = exports.IndexStack = exports.resolveAbortPolicy = exports.IssueSink = exports.DEFAULT_ABORT_EARLY_ON_EACH_FIELD = exports.DEFAULT_ABORT_EARLY = exports.ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD = void 0;
+exports.createFieldValidator = exports.hasRejectingIssue = exports.createValidator = exports.ROOT_MISSING_CODE = exports.createBranchExecutor = exports.BRANCH_ABORT_POLICY = exports.createRecursionRunner = exports.RECURSION_ABORT_POLICY = exports.runPlan = exports.prefixIssuePaths = exports.runArrayNodes = exports.writeFieldValue = exports.replaceElement = exports.createPlanWriteTargets = exports.createArrayWriteTargets = exports.NO_WRITE_TARGETS = exports.runField = exports.FIELD_VALUE_UNCHANGED = exports.decidePresence = exports.renderFallbackMessage = exports.createIssue = exports.joinIssuePath = exports.IndexStack = exports.resolveAbortPolicy = exports.IssueSink = exports.DEFAULT_ABORT_EARLY_ON_EACH_FIELD = exports.DEFAULT_ABORT_EARLY = exports.ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD = void 0;
 // ===========================================================================
 // L5  src/runtime/index.ts — re-exports only. The engine: one plan in, issues
 // and (for parse) a copy-on-write output out. Nothing is defined in this file.
@@ -41,7 +41,6 @@ Object.defineProperty(exports, "BRANCH_ABORT_POLICY", { enumerable: true, get: f
 Object.defineProperty(exports, "createBranchExecutor", { enumerable: true, get: function () { return run_branch_1.createBranchExecutor; } });
 var create_validator_1 = require("./create-validator");
 Object.defineProperty(exports, "ROOT_MISSING_CODE", { enumerable: true, get: function () { return create_validator_1.ROOT_MISSING_CODE; } });
-Object.defineProperty(exports, "ROOT_MISSING_MESSAGE", { enumerable: true, get: function () { return create_validator_1.ROOT_MISSING_MESSAGE; } });
 Object.defineProperty(exports, "createValidator", { enumerable: true, get: function () { return create_validator_1.createValidator; } });
 Object.defineProperty(exports, "hasRejectingIssue", { enumerable: true, get: function () { return create_validator_1.hasRejectingIssue; } });
 var create_field_validator_1 = require("./create-field-validator");

package/dist/runtime/index.mjs

@@ -12,5 +12,5 @@ export { runArrayNodes } from "./run-array-node.mjs";
 export { prefixIssuePaths, runPlan } from "./run-plan.mjs";
 export { RECURSION_ABORT_POLICY, createRecursionRunner } from "./run-recursion.mjs";
 export { BRANCH_ABORT_POLICY, createBranchExecutor } from "./run-branch.mjs";
-export { ROOT_MISSING_CODE, ROOT_MISSING_MESSAGE, createValidator, hasRejectingIssue, } from "./create-validator.mjs";
+export { ROOT_MISSING_CODE, createValidator, hasRejectingIssue, } from "./create-validator.mjs";
 export { createFieldValidator } from "./create-field-validator.mjs";

package/dist/standard-schema/emit-field-schema.js

@@ -55,6 +55,16 @@ function emitFieldSchema(fieldPath, calls, policy) {
             continue;
         }
         const keywords = toKeywords(call.args);
+        // undefined is the table saying it cannot express THESE arguments, which
+        // is the same answer as having no entry at all: refuse, rather than emit a
+        // schema missing a constraint the validator enforces. null is different —
+        // it means type or presence already carries the declaration.
+        if (keywords === undefined) {
+            if (policy === "throw") {
+                throw new unrepresentable_rule_error_1.UnrepresentableRuleError(fieldPath, call.pluginName, "no JSON Schema keyword expresses the arguments it was given");
+            }
+            continue;
+        }
         if (keywords === null)
             continue;
         Object.assign(schema, keywords);

package/dist/standard-schema/emit-field-schema.mjs

@@ -52,6 +52,16 @@ export function emitFieldSchema(fieldPath, calls, policy) {
             continue;
         }
         const keywords = toKeywords(call.args);
+        // undefined is the table saying it cannot express THESE arguments, which
+        // is the same answer as having no entry at all: refuse, rather than emit a
+        // schema missing a constraint the validator enforces. null is different —
+        // it means type or presence already carries the declaration.
+        if (keywords === undefined) {
+            if (policy === "throw") {
+                throw new UnrepresentableRuleError(fieldPath, call.pluginName, "no JSON Schema keyword expresses the arguments it was given");
+            }
+            continue;
+        }
         if (keywords === null)
             continue;
         Object.assign(schema, keywords);

package/dist/standard-schema/plugin-keyword-map.d.ts

@@ -1,3 +1,16 @@
-/** A keyword fragment made from the arguments; null means type or presence handles it. */
-export type ToKeywords = (args: readonly unknown[]) => Record<string, unknown> | null;
+/**
+ * A keyword fragment made from the arguments. Three answers, and the
+ * difference between the last two is the point:
+ *
+ *   an object   the keywords this declaration means
+ *   null        it adds no keyword, and that is correct — type or presence
+ *               already carries it
+ *   undefined   it cannot be expressed with these arguments, so the caller
+ *               must refuse rather than emit a schema that quietly says
+ *               something else
+ *
+ * Collapsing the last two into `null` is how a constraint disappears without
+ * a trace, which is the failure UnrepresentableRuleError exists to prevent.
+ */
+export type ToKeywords = (args: readonly unknown[]) => Record<string, unknown> | null | undefined;
 export declare const PLUGIN_KEYWORDS: Readonly<Record<string, ToKeywords>>;

package/dist/standard-schema/plugin-keyword-map.js

@@ -37,9 +37,14 @@ exports.PLUGIN_KEYWORDS = Object.freeze({
         maxLength: numberAt(args, 0),
     }),
     // Draft-07's `pattern` is an ECMA-262 SOURCE string. Flags cannot be
-    // spelled there, and dropping them changes the meaning, so a flagged
-    // RegExp counts as unwritable rather than being silently narrowed.
-    stringPattern: (args) => args[0] instanceof RegExp ? { pattern: args[0].source } : null,
+    // spelled there, and dropping them changes the meaning — `/^a.c$/i`
+    // accepts "ABC" and `{"pattern":"^a.c$"}` does not — so a flagged RegExp
+    // is unwritable rather than something to narrow quietly. Anything that is
+    // not a RegExp at all is unwritable for the same reason: refusing is the
+    // only answer that does not lose the constraint in silence.
+    stringPattern: (args) => args[0] instanceof RegExp && args[0].flags === ""
+        ? { pattern: args[0].source }
+        : undefined,
     stringContentEncoding: (args) => ({ contentEncoding: args[0] }),
     stringContentMediaType: (args) => ({ contentMediaType: args[0] }),
     // --- formats (names taken verbatim from the format map) ---------------
@@ -81,7 +86,9 @@ exports.PLUGIN_KEYWORDS = Object.freeze({
     arrayUnique: () => ({ uniqueItems: true }),
     // --- values -----------------------------------------------------------
     literal: (args) => ({ const: args[0] }),
-    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : null),
+    // `enum` needs the list itself. Given something else there is no list to
+    // write, and answering "no keyword" would drop the constraint.
+    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : undefined),
     // --- handled by type or presence, adding no keyword -------------------
     // numberInteger becomes `type: "integer"`, so it feeds the type decision.
     numberInteger: () => null,

package/dist/standard-schema/plugin-keyword-map.mjs

@@ -34,9 +34,14 @@ export const PLUGIN_KEYWORDS = Object.freeze({
         maxLength: numberAt(args, 0),
     }),
     // Draft-07's `pattern` is an ECMA-262 SOURCE string. Flags cannot be
-    // spelled there, and dropping them changes the meaning, so a flagged
-    // RegExp counts as unwritable rather than being silently narrowed.
-    stringPattern: (args) => args[0] instanceof RegExp ? { pattern: args[0].source } : null,
+    // spelled there, and dropping them changes the meaning — `/^a.c$/i`
+    // accepts "ABC" and `{"pattern":"^a.c$"}` does not — so a flagged RegExp
+    // is unwritable rather than something to narrow quietly. Anything that is
+    // not a RegExp at all is unwritable for the same reason: refusing is the
+    // only answer that does not lose the constraint in silence.
+    stringPattern: (args) => args[0] instanceof RegExp && args[0].flags === ""
+        ? { pattern: args[0].source }
+        : undefined,
     stringContentEncoding: (args) => ({ contentEncoding: args[0] }),
     stringContentMediaType: (args) => ({ contentMediaType: args[0] }),
     // --- formats (names taken verbatim from the format map) ---------------
@@ -78,7 +83,9 @@ export const PLUGIN_KEYWORDS = Object.freeze({
     arrayUnique: () => ({ uniqueItems: true }),
     // --- values -----------------------------------------------------------
     literal: (args) => ({ const: args[0] }),
-    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : null),
+    // `enum` needs the list itself. Given something else there is no list to
+    // write, and answering "no keyword" would drop the constraint.
+    oneOf: (args) => (Array.isArray(args[0]) ? { enum: args[0] } : undefined),
     // --- handled by type or presence, adding no keyword -------------------
     // numberInteger becomes `type: "integer"`, so it feeds the type decision.
     numberInteger: () => null,

package/dist/types/global-config.d.ts

@@ -15,6 +15,17 @@ export interface GlobalConfig {
     readonly customTransforms?: Readonly<Record<string, ValueTransform>>;
     /** Severity a rule emits when neither the rule nor the call names one. */
     readonly defaultSeverity?: IssueSeverity;
+    /**
+     * What `validate(null)` and `validate(undefined)` say.
+     *
+     * A subject that is absent fails before the plan runs, so there is no rule
+     * to carry a messageFactory and no call site to name one. This is where it
+     * is said instead. The severity is NOT settable with it: a warning here
+     * would let `validate(null)` report success for a schema that declares
+     * nothing required, which is the outcome the short-circuit exists to
+     * prevent.
+     */
+    readonly rootMissingMessage?: string;
 }
 /** Every member present: this is what a plugin reads. */
 export interface ResolvedGlobalConfig {
@@ -26,6 +37,7 @@ export interface ResolvedGlobalConfig {
     readonly caseSensitive: boolean;
     readonly customTransforms: Readonly<Record<string, ValueTransform>>;
     readonly defaultSeverity: IssueSeverity;
+    readonly rootMissingMessage: string;
 }
 export declare const DEFAULT_GLOBAL_CONFIG: ResolvedGlobalConfig;
 export declare function resolveGlobalConfig(overrides: GlobalConfig | undefined, base?: ResolvedGlobalConfig): ResolvedGlobalConfig;

package/dist/types/global-config.js

@@ -14,6 +14,7 @@ exports.DEFAULT_GLOBAL_CONFIG = Object.freeze({
     caseSensitive: true,
     customTransforms: Object.freeze({}),
     defaultSeverity: "error",
+    rootMissingMessage: "Value is required",
 });
 function resolveGlobalConfig(overrides, base = exports.DEFAULT_GLOBAL_CONFIG) {
     if (overrides === undefined)
@@ -32,5 +33,6 @@ function resolveGlobalConfig(overrides, base = exports.DEFAULT_GLOBAL_CONFIG) {
         caseSensitive: overrides.caseSensitive ?? base.caseSensitive,
         customTransforms: overrides.customTransforms ?? base.customTransforms,
         defaultSeverity: overrides.defaultSeverity ?? base.defaultSeverity,
+        rootMissingMessage: overrides.rootMissingMessage ?? base.rootMissingMessage,
     });
 }

package/dist/types/global-config.mjs

@@ -10,6 +10,7 @@ export const DEFAULT_GLOBAL_CONFIG = Object.freeze({
     caseSensitive: true,
     customTransforms: Object.freeze({}),
     defaultSeverity: "error",
+    rootMissingMessage: "Value is required",
 });
 export function resolveGlobalConfig(overrides, base = DEFAULT_GLOBAL_CONFIG) {
     if (overrides === undefined)
@@ -28,5 +29,6 @@ export function resolveGlobalConfig(overrides, base = DEFAULT_GLOBAL_CONFIG) {
         caseSensitive: overrides.caseSensitive ?? base.caseSensitive,
         customTransforms: overrides.customTransforms ?? base.customTransforms,
         defaultSeverity: overrides.defaultSeverity ?? base.defaultSeverity,
+        rootMissingMessage: overrides.rootMissingMessage ?? base.rootMissingMessage,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maroonedog/luq",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "Universal Model & API Definition Platform - TypeScript validation library evolving into cross-language code generation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",