@maroonedog/luq 2.1.0 → 2.3.0

package/dist/runtime/run-array-node.js

@@ -19,11 +19,8 @@ exports.runArrayNodes = runArrayNodes;
 // `grid[0][2].name` and never the declaration pattern.
 // ===========================================================================
 const types_1 = require("../types");
-const format_issue_path_1 = require("../path/format-issue-path");
 const run_field_1 = require("./run-field");
 const output_writer_1 = require("./output-writer");
-/** A node template never contains a wildcard: the grouping cut it off. */
-const NO_INDICES = Object.freeze([]);
 /**
  * `targets` mirrors `nodes` by position and is EMPTY on every run that produces
  * no output. Zipping by index needs no lookup and no identity check, because
@@ -57,16 +54,27 @@ function runArrayNode(node, subject, context, target) {
     return target.write(subject, rebuilt);
 }
 function runElements(node, array, context, target) {
-    const nodePath = (0, format_issue_path_1.formatIssuePath)(node.template, NO_INDICES);
+    const nodePath = node.renderedPath;
     const elementSink = context.sink.forArrayElements();
     const nested = target === undefined ? output_writer_1.NO_WRITE_TARGETS : target.nested;
+    // One element context per node. `item` is the only member that changes per
+    // element; the rest hold still for the whole node, and rebuilding them per
+    // element only happened because the fixed parts sat beside the moving one.
+    // **It never reaches a plugin** — a plugin sees the RuleContext that running
+    // a field assembles, and that reads `item` afresh, so reusing this is not
+    // observable from outside.
+    const elementContext = {
+        root: context.root,
+        sink: elementSink,
+        indices: context.indices,
+        shouldApplyTransforms: context.shouldApplyTransforms,
+        runRecursion: context.runRecursion,
+        item: undefined,
+        external: context.external,
+    };
     let rebuilt = array;
     for (let index = 0; index < array.length; index += 1) {
-        const elementContext = {
-            ...context,
-            sink: elementSink,
-            item: describeItem(array, index),
-        };
+        elementContext.item = describeItem(array, index);
         context.indices.push(nodePath, index);
         const element = runNested(node, runElementFields(node, array[index], elementContext), elementContext, nested);
         context.indices.pop();
@@ -84,7 +92,11 @@ function runNested(node, element, elementContext, nested) {
 }
 function runElementFields(node, element, elementContext) {
     let current = element;
-    for (const field of node.elementFields) {
+    const fields = node.elementFields;
+    for (let i = 0; i < fields.length; i += 1) {
+        const field = fields[i];
+        if (field === undefined)
+            continue;
         const outcome = (0, run_field_1.runField)(field, current, elementContext);
         current = (0, output_writer_1.writeFieldValue)(field, current, outcome, elementContext.shouldApplyTransforms);
         if (elementContext.sink.shouldStopPlan())

package/dist/runtime/run-array-node.mjs

@@ -16,11 +16,8 @@
 // `grid[0][2].name` and never the declaration pattern.
 // ===========================================================================
 import { isArray } from "../types/index.mjs";
-import { formatIssuePath } from "../path/format-issue-path.mjs";
 import { runField } from "./run-field.mjs";
 import { NO_WRITE_TARGETS, replaceElement, writeFieldValue, } from "./output-writer.mjs";
-/** A node template never contains a wildcard: the grouping cut it off. */
-const NO_INDICES = Object.freeze([]);
 /**
  * `targets` mirrors `nodes` by position and is EMPTY on every run that produces
  * no output. Zipping by index needs no lookup and no identity check, because
@@ -54,16 +51,27 @@ function runArrayNode(node, subject, context, target) {
     return target.write(subject, rebuilt);
 }
 function runElements(node, array, context, target) {
-    const nodePath = formatIssuePath(node.template, NO_INDICES);
+    const nodePath = node.renderedPath;
     const elementSink = context.sink.forArrayElements();
     const nested = target === undefined ? NO_WRITE_TARGETS : target.nested;
+    // One element context per node. `item` is the only member that changes per
+    // element; the rest hold still for the whole node, and rebuilding them per
+    // element only happened because the fixed parts sat beside the moving one.
+    // **It never reaches a plugin** — a plugin sees the RuleContext that running
+    // a field assembles, and that reads `item` afresh, so reusing this is not
+    // observable from outside.
+    const elementContext = {
+        root: context.root,
+        sink: elementSink,
+        indices: context.indices,
+        shouldApplyTransforms: context.shouldApplyTransforms,
+        runRecursion: context.runRecursion,
+        item: undefined,
+        external: context.external,
+    };
     let rebuilt = array;
     for (let index = 0; index < array.length; index += 1) {
-        const elementContext = {
-            ...context,
-            sink: elementSink,
-            item: describeItem(array, index),
-        };
+        elementContext.item = describeItem(array, index);
         context.indices.push(nodePath, index);
         const element = runNested(node, runElementFields(node, array[index], elementContext), elementContext, nested);
         context.indices.pop();
@@ -81,7 +89,11 @@ function runNested(node, element, elementContext, nested) {
 }
 function runElementFields(node, element, elementContext) {
     let current = element;
-    for (const field of node.elementFields) {
+    const fields = node.elementFields;
+    for (let i = 0; i < fields.length; i += 1) {
+        const field = fields[i];
+        if (field === undefined)
+            continue;
         const outcome = runField(field, current, elementContext);
         current = writeFieldValue(field, current, outcome, elementContext.shouldApplyTransforms);
         if (elementContext.sink.shouldStopPlan())

package/dist/runtime/run-field.js

@@ -3,21 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIELD_VALUE_UNCHANGED = void 0;
 exports.runField = runField;
 const create_issue_1 = require("./create-issue");
+const field_rule_context_1 = require("./field-rule-context");
 const decide_presence_1 = require("./decide-presence");
 /** Shared, frozen, never re-assigned: the common answer allocates nothing. */
 exports.FIELD_VALUE_UNCHANGED = Object.freeze({
     hasWriteBack: false,
 });
 function runField(field, subject, context) {
-    const path = context.indices.renderFieldPath(field.template);
-    const ruleContext = {
-        root: context.root,
-        path,
-        item: context.item,
-        external: context.external,
-    };
+    const ruleContext = new field_rule_context_1.FieldRuleContext(context.root, context.indices, field.renderedPath, context.item, context.external);
     const read = field.read(subject);
-    const value = applyDefault(field, read, context.root);
+    const value = applyNormalize(field, applyDefault(field, read, context.root));
     if (!(0, decide_presence_1.decidePresence)(field, value, ruleContext, context.sink)) {
         return exports.FIELD_VALUE_UNCHANGED;
     }
@@ -45,26 +40,56 @@ function applyDefault(field, value, root) {
         return field.defaultOf(root);
     return value;
 }
+/**
+ * Tidies the value before anything judges it: after default, before presence.
+ *
+ * Never called for undefined or null. That closes the accident where a
+ * caller's `(v) => String(v).trim()` turns a missing field into the string
+ * `"undefined"` and walks it past `.required()`. Absence is default's job.
+ */
+function applyNormalize(field, value) {
+    if (field.normalize === null || value === undefined || value === null) {
+        return value;
+    }
+    return field.normalize(value);
+}
 /** A closed gate ends the field successfully: no check, no transform. */
 function openGates(field, value, ruleContext) {
-    for (const gate of field.gates) {
+    const gates = field.gates;
+    for (let i = 0; i < gates.length; i += 1) {
+        const gate = gates[i];
+        if (gate === undefined)
+            continue;
         if (!gate.shouldRun(value, ruleContext))
             return false;
     }
     return true;
 }
+/**
+ * The side taken only on failure. Lifted out of the loop body because most of
+ * that body was issue construction an accepted value never runs, and its size
+ * was what pushed the check loop past the inlining budget. Stopping is not
+ * decided here: add the issue, then ask — that order is what abortEarly means.
+ */
+function reportCheckFailure(check, detail, value, ruleContext, context) {
+    context.sink.add((0, create_issue_1.createIssue)({
+        path: ruleContext.path,
+        code: check.code,
+        severity: check.severity,
+        value,
+        render: (ctx) => check.describe(detail, ctx),
+    }));
+}
 function runChecks(field, value, ruleContext, context, mark) {
-    for (const check of field.checks) {
+    const checks = field.checks;
+    for (let i = 0; i < checks.length; i += 1) {
+        const check = checks[i];
+        if (check === undefined)
+            continue;
         const outcome = check.run(value, ruleContext);
         if (outcome.ok)
             continue;
-        context.sink.add((0, create_issue_1.createIssue)({
-            path: ruleContext.path,
-            code: check.code,
-            severity: check.severity,
-            value,
-            render: (ctx) => check.describe(outcome.detail, ctx),
-        }));
+        reportCheckFailure(check, outcome.detail, value, ruleContext, context);
         if (context.sink.shouldStopField(mark))
             return;
     }
@@ -75,7 +100,11 @@ function runTransforms(field, value, ruleContext, context, mark) {
         return value;
     }
     let current = value;
-    for (const transform of field.transforms) {
+    const transforms = field.transforms;
+    for (let i = 0; i < transforms.length; i += 1) {
+        const transform = transforms[i];
+        if (transform === undefined)
+            continue;
         current = transform.apply(current, ruleContext);
     }
     return current;

package/dist/runtime/run-field.mjs

@@ -1,19 +1,14 @@
 import { createIssue } from "./create-issue.mjs";
+import { FieldRuleContext } from "./field-rule-context.mjs";
 import { decidePresence } from "./decide-presence.mjs";
 /** Shared, frozen, never re-assigned: the common answer allocates nothing. */
 export const FIELD_VALUE_UNCHANGED = Object.freeze({
     hasWriteBack: false,
 });
 export function runField(field, subject, context) {
-    const path = context.indices.renderFieldPath(field.template);
-    const ruleContext = {
-        root: context.root,
-        path,
-        item: context.item,
-        external: context.external,
-    };
+    const ruleContext = new FieldRuleContext(context.root, context.indices, field.renderedPath, context.item, context.external);
     const read = field.read(subject);
-    const value = applyDefault(field, read, context.root);
+    const value = applyNormalize(field, applyDefault(field, read, context.root));
     if (!decidePresence(field, value, ruleContext, context.sink)) {
         return FIELD_VALUE_UNCHANGED;
     }
@@ -41,26 +36,56 @@ function applyDefault(field, value, root) {
         return field.defaultOf(root);
     return value;
 }
+/**
+ * Tidies the value before anything judges it: after default, before presence.
+ *
+ * Never called for undefined or null. That closes the accident where a
+ * caller's `(v) => String(v).trim()` turns a missing field into the string
+ * `"undefined"` and walks it past `.required()`. Absence is default's job.
+ */
+function applyNormalize(field, value) {
+    if (field.normalize === null || value === undefined || value === null) {
+        return value;
+    }
+    return field.normalize(value);
+}
 /** A closed gate ends the field successfully: no check, no transform. */
 function openGates(field, value, ruleContext) {
-    for (const gate of field.gates) {
+    const gates = field.gates;
+    for (let i = 0; i < gates.length; i += 1) {
+        const gate = gates[i];
+        if (gate === undefined)
+            continue;
         if (!gate.shouldRun(value, ruleContext))
             return false;
     }
     return true;
 }
+/**
+ * The side taken only on failure. Lifted out of the loop body because most of
+ * that body was issue construction an accepted value never runs, and its size
+ * was what pushed the check loop past the inlining budget. Stopping is not
+ * decided here: add the issue, then ask — that order is what abortEarly means.
+ */
+function reportCheckFailure(check, detail, value, ruleContext, context) {
+    context.sink.add(createIssue({
+        path: ruleContext.path,
+        code: check.code,
+        severity: check.severity,
+        value,
+        render: (ctx) => check.describe(detail, ctx),
+    }));
+}
 function runChecks(field, value, ruleContext, context, mark) {
-    for (const check of field.checks) {
+    const checks = field.checks;
+    for (let i = 0; i < checks.length; i += 1) {
+        const check = checks[i];
+        if (check === undefined)
+            continue;
         const outcome = check.run(value, ruleContext);
         if (outcome.ok)
             continue;
-        context.sink.add(createIssue({
-            path: ruleContext.path,
-            code: check.code,
-            severity: check.severity,
-            value,
-            render: (ctx) => check.describe(outcome.detail, ctx),
-        }));
+        reportCheckFailure(check, outcome.detail, value, ruleContext, context);
         if (context.sink.shouldStopField(mark))
             return;
     }
@@ -71,7 +96,11 @@ function runTransforms(field, value, ruleContext, context, mark) {
         return value;
     }
     let current = value;
-    for (const transform of field.transforms) {
+    const transforms = field.transforms;
+    for (let i = 0; i < transforms.length; i += 1) {
+        const transform = transforms[i];
+        if (transform === undefined)
+            continue;
         current = transform.apply(current, ruleContext);
     }
     return current;

package/dist/runtime/run-plan.js

@@ -19,7 +19,11 @@ const output_writer_1 = require("./output-writer");
  */
 function runPlan(plan, subject, context, targets = output_writer_1.NO_WRITE_TARGETS) {
     let current = subject;
-    for (const field of plan.fields) {
+    const fields = plan.fields;
+    for (let i = 0; i < fields.length; i += 1) {
+        const field = fields[i];
+        if (field === undefined)
+            continue;
         const outcome = (0, run_field_1.runField)(field, current, context);
         current = (0, output_writer_1.writeFieldValue)(field, current, outcome, context.shouldApplyTransforms);
         if (context.sink.shouldStopPlan())

package/dist/runtime/run-plan.mjs

@@ -15,7 +15,11 @@ import { NO_WRITE_TARGETS, writeFieldValue } from "./output-writer.mjs";
  */
 export function runPlan(plan, subject, context, targets = NO_WRITE_TARGETS) {
     let current = subject;
-    for (const field of plan.fields) {
+    const fields = plan.fields;
+    for (let i = 0; i < fields.length; i += 1) {
+        const field = fields[i];
+        if (field === undefined)
+            continue;
         const outcome = runField(field, current, context);
         current = writeFieldValue(field, current, outcome, context.shouldApplyTransforms);
         if (context.sink.shouldStopPlan())

package/dist/standard-schema/assemble-json-schema.d.ts

@@ -0,0 +1,4 @@
+import type { FieldDeclaredCalls } from "../builder/field-declared-calls.types";
+import type { UnrepresentablePolicy } from "./unrepresentable-rule-error";
+/** Assembles the root schema from the list of declarations. */
+export declare function assembleJsonSchema(fields: readonly FieldDeclaredCalls[], policy: UnrepresentablePolicy): Record<string, unknown>;

package/dist/standard-schema/assemble-json-schema.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleJsonSchema = assembleJsonSchema;
+// ===========================================================================
+// L10 src/standard-schema/assemble-json-schema.ts
+//
+// Builds the nested object and array schema from a list of paths.
+//
+// `"owner.name"` becomes `properties.owner.properties.name`, and
+// `"employees[*].name"` becomes
+// `properties.employees.items.properties.name`. Paths are read with the
+// existing path parser rather than a second grammar written here.
+//
+// `required` belongs to the PARENT. In JSON Schema it says "this object must
+// carry this key", which is a fact about the object, not about the key.
+// ===========================================================================
+const parse_field_path_1 = require("../path/parse-field-path");
+const emit_field_schema_1 = require("./emit-field-schema");
+const declarations_unavailable_error_1 = require("./declarations-unavailable-error");
+const newNode = () => ({
+    properties: new Map(),
+    required: new Set(),
+    element: null,
+    leaf: null,
+});
+/** Descends through `key`, creating it when absent. */
+function descend(node, key) {
+    const existing = node.properties.get(key);
+    if (existing !== undefined)
+        return existing;
+    const created = newNode();
+    node.properties.set(key, created);
+    return created;
+}
+/** Places one path in the tree, setting the schema where the leaf lands. */
+function place(root, segments, schema, isRequired) {
+    let node = root;
+    let owner = null;
+    let ownerKey = "";
+    for (const segment of segments) {
+        if (segment.kind === "each") {
+            node.element ?? (node.element = newNode());
+            node = node.element;
+            owner = null;
+            continue;
+        }
+        owner = node;
+        ownerKey = segment.key;
+        node = descend(node, segment.key);
+    }
+    node.leaf = schema;
+    if (isRequired && owner !== null)
+        owner.required.add(ownerKey);
+}
+/**
+ * Freezes a node into a JSON Schema.
+ *
+ * On a node that has children, the leaf schema is the FOUNDATION. When both
+ * `.object.required()` and `"user.name"` are declared, the properties from
+ * the latter sit on top of the `type: "object"` from the former.
+ */
+function freeze(node) {
+    const schema = { ...node.leaf };
+    if (node.element !== null) {
+        schema["type"] ?? (schema["type"] = "array");
+        schema["items"] = freeze(node.element);
+    }
+    if (node.properties.size > 0) {
+        schema["type"] ?? (schema["type"] = "object");
+        const properties = {};
+        for (const [key, child] of node.properties) {
+            properties[key] = freeze(child);
+        }
+        schema["properties"] = properties;
+    }
+    if (node.required.size > 0)
+        schema["required"] = [...node.required];
+    return schema;
+}
+/** Assembles the root schema from the list of declarations. */
+function assembleJsonSchema(fields, policy) {
+    const root = newNode();
+    for (const field of fields) {
+        // One field with no record is enough to refuse, whatever the policy says.
+        if (field.calls === null)
+            throw new declarations_unavailable_error_1.DeclarationsUnavailableError(field.path);
+        const emitted = (0, emit_field_schema_1.emitFieldSchema)(field.path, field.calls, policy);
+        place(root, (0, parse_field_path_1.parseFieldPath)(field.path), emitted.schema, emitted.isRequired);
+    }
+    const schema = freeze(root);
+    // Even with nothing declared, or everything dropped, the root is an object:
+    // the builder only accepts an object type in the first place.
+    schema["type"] ?? (schema["type"] = "object");
+    return schema;
+}

package/dist/standard-schema/assemble-json-schema.mjs

@@ -0,0 +1,92 @@
+// ===========================================================================
+// L10 src/standard-schema/assemble-json-schema.ts
+//
+// Builds the nested object and array schema from a list of paths.
+//
+// `"owner.name"` becomes `properties.owner.properties.name`, and
+// `"employees[*].name"` becomes
+// `properties.employees.items.properties.name`. Paths are read with the
+// existing path parser rather than a second grammar written here.
+//
+// `required` belongs to the PARENT. In JSON Schema it says "this object must
+// carry this key", which is a fact about the object, not about the key.
+// ===========================================================================
+import { parseFieldPath } from "../path/parse-field-path.mjs";
+import { emitFieldSchema } from "./emit-field-schema.mjs";
+import { DeclarationsUnavailableError } from "./declarations-unavailable-error.mjs";
+const newNode = () => ({
+    properties: new Map(),
+    required: new Set(),
+    element: null,
+    leaf: null,
+});
+/** Descends through `key`, creating it when absent. */
+function descend(node, key) {
+    const existing = node.properties.get(key);
+    if (existing !== undefined)
+        return existing;
+    const created = newNode();
+    node.properties.set(key, created);
+    return created;
+}
+/** Places one path in the tree, setting the schema where the leaf lands. */
+function place(root, segments, schema, isRequired) {
+    let node = root;
+    let owner = null;
+    let ownerKey = "";
+    for (const segment of segments) {
+        if (segment.kind === "each") {
+            node.element ?? (node.element = newNode());
+            node = node.element;
+            owner = null;
+            continue;
+        }
+        owner = node;
+        ownerKey = segment.key;
+        node = descend(node, segment.key);
+    }
+    node.leaf = schema;
+    if (isRequired && owner !== null)
+        owner.required.add(ownerKey);
+}
+/**
+ * Freezes a node into a JSON Schema.
+ *
+ * On a node that has children, the leaf schema is the FOUNDATION. When both
+ * `.object.required()` and `"user.name"` are declared, the properties from
+ * the latter sit on top of the `type: "object"` from the former.
+ */
+function freeze(node) {
+    const schema = { ...node.leaf };
+    if (node.element !== null) {
+        schema["type"] ?? (schema["type"] = "array");
+        schema["items"] = freeze(node.element);
+    }
+    if (node.properties.size > 0) {
+        schema["type"] ?? (schema["type"] = "object");
+        const properties = {};
+        for (const [key, child] of node.properties) {
+            properties[key] = freeze(child);
+        }
+        schema["properties"] = properties;
+    }
+    if (node.required.size > 0)
+        schema["required"] = [...node.required];
+    return schema;
+}
+/** Assembles the root schema from the list of declarations. */
+export function assembleJsonSchema(fields, policy) {
+    const root = newNode();
+    for (const field of fields) {
+        // One field with no record is enough to refuse, whatever the policy says.
+        if (field.calls === null)
+            throw new DeclarationsUnavailableError(field.path);
+        const emitted = emitFieldSchema(field.path, field.calls, policy);
+        place(root, parseFieldPath(field.path), emitted.schema, emitted.isRequired);
+    }
+    const schema = freeze(root);
+    // Even with nothing declared, or everything dropped, the root is an object:
+    // the builder only accepts an object type in the first place.
+    schema["type"] ?? (schema["type"] = "object");
+    return schema;
+}

package/dist/standard-schema/declaration-recorder.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Idempotent. Call it at module scope, never from inside a function: the
+ * recorder has to be in place before any chain runs, and hiding the call
+ * behind a function makes that ordering depend on who calls it first.
+ */
+export declare function installJsonSchemaDeclarationRecorder(): void;

package/dist/standard-schema/declaration-recorder.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installJsonSchemaDeclarationRecorder = installJsonSchemaDeclarationRecorder;
+const declaration_recorder_port_1 = require("../chain/declaration-recorder.port");
+const NONE = Object.freeze([]);
+const callsByNode = new WeakMap();
+const recorder = {
+    record(parent, child, plugin, slot, args) {
+        callsByNode.set(child, [
+            ...(callsByNode.get(parent) ?? NONE),
+            { pluginName: plugin.name, method: plugin.method, slot, args },
+        ]);
+    },
+    inherit(parent, child) {
+        const calls = callsByNode.get(parent);
+        if (calls !== undefined)
+            callsByNode.set(child, calls);
+    },
+    read(node) {
+        return callsByNode.get(node);
+    },
+};
+/**
+ * Idempotent. Call it at module scope, never from inside a function: the
+ * recorder has to be in place before any chain runs, and hiding the call
+ * behind a function makes that ordering depend on who calls it first.
+ */
+function installJsonSchemaDeclarationRecorder() {
+    (0, declaration_recorder_port_1.installDeclarationRecorder)(recorder);
+}

package/dist/standard-schema/declaration-recorder.mjs

@@ -0,0 +1,27 @@
+import { installDeclarationRecorder, } from "../chain/declaration-recorder.port.mjs";
+const NONE = Object.freeze([]);
+const callsByNode = new WeakMap();
+const recorder = {
+    record(parent, child, plugin, slot, args) {
+        callsByNode.set(child, [
+            ...(callsByNode.get(parent) ?? NONE),
+            { pluginName: plugin.name, method: plugin.method, slot, args },
+        ]);
+    },
+    inherit(parent, child) {
+        const calls = callsByNode.get(parent);
+        if (calls !== undefined)
+            callsByNode.set(child, calls);
+    },
+    read(node) {
+        return callsByNode.get(node);
+    },
+};
+/**
+ * Idempotent. Call it at module scope, never from inside a function: the
+ * recorder has to be in place before any chain runs, and hiding the call
+ * behind a function makes that ordering depend on who calls it first.
+ */
+export function installJsonSchemaDeclarationRecorder() {
+    installDeclarationRecorder(recorder);
+}

package/dist/standard-schema/declarations-unavailable-error.d.ts

@@ -0,0 +1,4 @@
+export declare class DeclarationsUnavailableError extends Error {
+    readonly fieldPath?: string | undefined;
+    constructor(fieldPath?: string | undefined);
+}

package/dist/standard-schema/declarations-unavailable-error.js

@@ -0,0 +1,32 @@
+"use strict";
+// ===========================================================================
+// L10 src/standard-schema/declarations-unavailable-error.ts
+//
+// "Nothing was declared" and "what was declared is not known" are different
+// answers, and only one of them can be written out.
+//
+// Collapsing them into an empty list produces a schema that permits everything
+// and looks entirely confident about it. This refusal exists to stop that.
+//
+// It outranks the unrepresentable policy: `omit` is permission to drop a
+// declaration that cannot be written, not permission to write without knowing
+// what was declared.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeclarationsUnavailableError = void 0;
+class DeclarationsUnavailableError extends Error {
+    constructor(fieldPath) {
+        super((fieldPath === undefined
+            ? "This validator carries no declarations"
+            : `"${fieldPath}" carries no declarations`) +
+            ", so no JSON Schema can be emitted from it. Two things cause " +
+            "this. A validator from fromJsonSchema() was assembled from rules " +
+            "directly and never went through the builder chain. Otherwise the " +
+            'build() ran before "@maroonedog/luq/standard-schema" was loaded — ' +
+            "import it from the module that builds the validator, or from one " +
+            "evaluated before it.");
+        this.fieldPath = fieldPath;
+        this.name = "DeclarationsUnavailableError";
+    }
+}
+exports.DeclarationsUnavailableError = DeclarationsUnavailableError;