@maroonedog/luq 2.2.0 → 2.3.1

package/dist/runtime/create-validator.js

@@ -40,23 +40,23 @@ function hasRejectingIssue(issues) {
     return issues.some((issue) => issue.severity === "error");
 }
 /**
- * 再帰しないプランのための、共有の何もしないランナー。
+ * The shared do-nothing runner for a plan that cannot recurse.
  *
- * createRecursionRunner は WeakSet と四つのクロージャを作る。プランに
- * 再帰規則が一つも無くても validate() のたびに作っていて、それが固定コストの
- * 88% を占めていた — 計測で 9.7%。プランが再帰を含むかは build() 時に
- * 分かることで、実行時に問い直すことではない。
+ * Building a real runner allocates a WeakSet and several closures. Doing that
+ * on every validate() of a plan with no recursive rule in it was most of the
+ * fixed per-call cost. Whether a plan can recurse is known at build time and
+ * is not a question to re-ask at validation time.
  *
- * 呼ばれることはない。呼ばれるのは field.recursion が null でない場合だけで、
- * そのときは planCanRecurse が true を返しているので本物が渡っている。
+ * Never actually called: a field only reaches its runner when it declares
+ * recursion, and a plan containing one gets the real runner instead.
  */
 const NO_RECURSION = () => { };
 /**
- * ルートのランナーが要るか。
+ * Whether the root needs a real runner.
  *
- * 見るのはルートの直下と配列ノードの要素だけでよい。合成 (oneOf など) の
- * 枝は run-branch が自前のランナーを作って入れ子のプランを回すので、
- * ここで渡すものを使わない。
+ * Only the fields directly under the root and the elements of array nodes
+ * matter. A composite branch makes its own runner for the nested plan, so it
+ * never uses the one passed from here.
  */
 function planCanRecurse(plan) {
     return (plan.fields.some((field) => field.recursion !== null) ||

package/dist/runtime/create-validator.mjs

@@ -35,23 +35,23 @@ export function hasRejectingIssue(issues) {
     return issues.some((issue) => issue.severity === "error");
 }
 /**
- * 再帰しないプランのための、共有の何もしないランナー。
+ * The shared do-nothing runner for a plan that cannot recurse.
  *
- * createRecursionRunner は WeakSet と四つのクロージャを作る。プランに
- * 再帰規則が一つも無くても validate() のたびに作っていて、それが固定コストの
- * 88% を占めていた — 計測で 9.7%。プランが再帰を含むかは build() 時に
- * 分かることで、実行時に問い直すことではない。
+ * Building a real runner allocates a WeakSet and several closures. Doing that
+ * on every validate() of a plan with no recursive rule in it was most of the
+ * fixed per-call cost. Whether a plan can recurse is known at build time and
+ * is not a question to re-ask at validation time.
  *
- * 呼ばれることはない。呼ばれるのは field.recursion が null でない場合だけで、
- * そのときは planCanRecurse が true を返しているので本物が渡っている。
+ * Never actually called: a field only reaches its runner when it declares
+ * recursion, and a plan containing one gets the real runner instead.
  */
 const NO_RECURSION = () => { };
 /**
- * ルートのランナーが要るか。
+ * Whether the root needs a real runner.
  *
- * 見るのはルートの直下と配列ノードの要素だけでよい。合成 (oneOf など) の
- * 枝は run-branch が自前のランナーを作って入れ子のプランを回すので、
- * ここで渡すものを使わない。
+ * Only the fields directly under the root and the elements of array nodes
+ * matter. A composite branch makes its own runner for the nested plan, so it
+ * never uses the one passed from here.
  */
 function planCanRecurse(plan) {
     return (plan.fields.some((field) => field.recursion !== null) ||

package/dist/runtime/output-writer.js

@@ -24,8 +24,12 @@ function createArrayWriteTargets(nodes) {
  * hands back the very object it was given.
  */
 function createPlanWriteTargets(plan) {
-    if (!plan.hasTransforms && !plan.hasDefaults)
+    // A field declaring only a normalizer is still written back by parse().
+    // Leave it out of this condition and no writer is made, so the value read
+    // comes back unchanged and in silence.
+    if (!plan.hasTransforms && !plan.hasDefaults && !plan.hasNormalizers) {
         return null;
+    }
     return createArrayWriteTargets(plan.arrays);
 }
 /**

package/dist/runtime/output-writer.mjs

@@ -17,8 +17,12 @@ export function createArrayWriteTargets(nodes) {
  * hands back the very object it was given.
  */
 export function createPlanWriteTargets(plan) {
-    if (!plan.hasTransforms && !plan.hasDefaults)
+    // A field declaring only a normalizer is still written back by parse().
+    // Leave it out of this condition and no writer is made, so the value read
+    // comes back unchanged and in silence.
+    if (!plan.hasTransforms && !plan.hasDefaults && !plan.hasNormalizers) {
         return null;
+    }
     return createArrayWriteTargets(plan.arrays);
 }
 /**

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

@@ -57,12 +57,12 @@ function runElements(node, array, context, target) {
     const nodePath = node.renderedPath;
     const elementSink = context.sink.forArrayElements();
     const nested = target === undefined ? output_writer_1.NO_WRITE_TARGETS : target.nested;
-    // 要素コンテキストはノードごとに一つ。7つの成員のうち要素ごとに変わるのは
-    // `item` だけで、残る6つは validate() 一回のあいだ、あるいはこのノードの
-    // あいだ動かない。毎要素で組み直していたのは、動かないものを動くものと
-    // 同じ場所に置いていたからにすぎない。**プラグインには渡らない** —
-    // プラグインが見るのは runField が組む RuleContext で、そちらは `item` を
-    // 都度読み直すので、この使い回しは外から観測できない。
+    // 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,

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

@@ -54,12 +54,12 @@ function runElements(node, array, context, target) {
     const nodePath = node.renderedPath;
     const elementSink = context.sink.forArrayElements();
     const nested = target === undefined ? NO_WRITE_TARGETS : target.nested;
-    // 要素コンテキストはノードごとに一つ。7つの成員のうち要素ごとに変わるのは
-    // `item` だけで、残る6つは validate() 一回のあいだ、あるいはこのノードの
-    // あいだ動かない。毎要素で組み直していたのは、動かないものを動くものと
-    // 同じ場所に置いていたからにすぎない。**プラグインには渡らない** —
-    // プラグインが見るのは runField が組む RuleContext で、そちらは `item` を
-    // 都度読み直すので、この使い回しは外から観測できない。
+    // 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,

package/dist/runtime/run-field.js

@@ -12,7 +12,7 @@ exports.FIELD_VALUE_UNCHANGED = Object.freeze({
 function runField(field, subject, context) {
     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;
     }
@@ -40,15 +40,21 @@ 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-of ではない。ここが回るのはコンパイル済みの
-    // 凍結配列で、凍結配列は V8 では PACKED_FROZEN_ELEMENTS になり、配列
-    // イテレータの高速化パスから外れる — イテレータと IteratorResult が
-    // 消去されず、要素×フィールドの回数だけ確保される。配列シェイプでは
-    // それだけで全ゴミの 45〜54% を占めていた (独立に5通りの改変で -45%
-    // 〜 -54%)。凍結は落とさない: コンパイル層の不変条件であり、凍結を
-    // 外しても添字ループより速くはならない。
     const gates = field.gates;
     for (let i = 0; i < gates.length; i += 1) {
         const gate = gates[i];
@@ -60,17 +66,10 @@ function openGates(field, value, ruleContext) {
     return true;
 }
 /**
- * 失敗したときだけ通る側。ループ本体から出してある。
- *
- * runChecks はバイトコードで 302 バイトあり、TurboFan の呼び出し先
- * インライン予算 (既定で累計 920 バイト) の最大の落選候補として
- * --trace-turbo-inlining に名指しされていた。その 302 バイトの大半が、
- * 受理された値では一度も走らない issue の組み立てである。ここへ出すと
- * 残るループ本体が縮み、受理パスで 6.4% 速くなった。
- *
- * 中断の判定はここに含めない。issue を足したあとに shouldStopField を
- * 見るという順序が abortEarlyOnEachField の意味そのものなので、呼び出し側に
- * 並べて置いておく。
+ * 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)({

package/dist/runtime/run-field.mjs

@@ -8,7 +8,7 @@ export const FIELD_VALUE_UNCHANGED = Object.freeze({
 export function runField(field, subject, context) {
     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;
     }
@@ -36,15 +36,21 @@ 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-of ではない。ここが回るのはコンパイル済みの
-    // 凍結配列で、凍結配列は V8 では PACKED_FROZEN_ELEMENTS になり、配列
-    // イテレータの高速化パスから外れる — イテレータと IteratorResult が
-    // 消去されず、要素×フィールドの回数だけ確保される。配列シェイプでは
-    // それだけで全ゴミの 45〜54% を占めていた (独立に5通りの改変で -45%
-    // 〜 -54%)。凍結は落とさない: コンパイル層の不変条件であり、凍結を
-    // 外しても添字ループより速くはならない。
     const gates = field.gates;
     for (let i = 0; i < gates.length; i += 1) {
         const gate = gates[i];
@@ -56,17 +62,10 @@ function openGates(field, value, ruleContext) {
     return true;
 }
 /**
- * 失敗したときだけ通る側。ループ本体から出してある。
- *
- * runChecks はバイトコードで 302 バイトあり、TurboFan の呼び出し先
- * インライン予算 (既定で累計 920 バイト) の最大の落選候補として
- * --trace-turbo-inlining に名指しされていた。その 302 バイトの大半が、
- * 受理された値では一度も走らない issue の組み立てである。ここへ出すと
- * 残るループ本体が縮み、受理パスで 6.4% 速くなった。
- *
- * 中断の判定はここに含めない。issue を足したあとに shouldStopField を
- * 見るという順序が abortEarlyOnEachField の意味そのものなので、呼び出し側に
- * 並べて置いておく。
+ * 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({

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;

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

@@ -0,0 +1,28 @@
+// ===========================================================================
+// 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.
+// ===========================================================================
+export 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";
+    }
+}

package/dist/standard-schema/emit-field-schema.d.ts

@@ -0,0 +1,9 @@
+import type { DeclaredCall } from "../chain/declared-call.types";
+import { type UnrepresentablePolicy } from "./unrepresentable-rule-error";
+/** One emitted field. `required` is separate: the parent assembles it. */
+export interface EmittedField {
+    readonly schema: Record<string, unknown>;
+    readonly isRequired: boolean;
+}
+/** Makes one field's schema from that field's declared calls. */
+export declare function emitFieldSchema(fieldPath: string, calls: readonly DeclaredCall[], policy: UnrepresentablePolicy): EmittedField;