@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/chain/create-chain-node.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_RULES = void 0;
+exports.createChainNode = createChainNode;
+exports.readChainRules = readChainRules;
+// ===========================================================================
+// L3  src/chain/create-chain-node.ts — the IMMUTABLE chain node.
+//
+// A node owns exactly one thing: the ordered rule list built so far. Calling a
+// slot method builds ONE rule and returns a NEW frozen node; the receiver is
+// never touched, so two chains branched from the same `b` cannot contaminate
+// each other.
+//
+// The declared argument count comes from `plugin.build.length - 1` (build's own
+// parameters minus `ctx`), which is how the trailing `options?: RuleOptions` of
+// ChainMethod is separated from a trailing DECLARED optional argument. A plugin
+// whose build uses a default value or a rest parameter breaks that count; the
+// plugin contract forbids both.
+//
+// The rule list is held in a WeakMap rather than on the node, so the node
+// carries exactly the members its type declares and reading the rules back
+// needs no assertion and no runtime shape check.
+// ===========================================================================
+const types_1 = require("../types");
+const refine_methods_types_1 = require("./refine-methods.types");
+const attach_slot_methods_1 = require("./attach-slot-methods");
+const chainRulesByNode = new WeakMap();
+const EMPTY_RECORD = Object.freeze({});
+exports.EMPTY_RULES = Object.freeze([]);
+function isIssueSeverity(value) {
+    return value === "error" || value === "warning" || value === "info";
+}
+function isMessageFactory(value) {
+    return typeof value === "function";
+}
+function buildRuleContext(wiring, plugin, rawOptions) {
+    const options = (0, types_1.isPlainObject)(rawOptions) ? rawOptions : EMPTY_RECORD;
+    const code = options["code"];
+    const severity = options["severity"];
+    const messageFactory = options["messageFactory"];
+    return {
+        pluginName: plugin.name,
+        code: (0, types_1.isString)(code) ? code : plugin.name,
+        severity: isIssueSeverity(severity)
+            ? severity
+            : wiring.context.config.defaultSeverity,
+        messageFactory: isMessageFactory(messageFactory)
+            ? messageFactory
+            : undefined,
+        config: wiring.context.config,
+        fieldPath: wiring.context.fieldPath,
+        declaredSiblingKeys: wiring.context.declaredSiblingKeys,
+    };
+}
+function createSlotMethod(wiring, slot, rules, plugin) {
+    const arity = Math.max(plugin.build.length - 1, 0);
+    return (...args) => {
+        const rawOptions = args.length > arity ? args[arity] : undefined;
+        const resolved = wiring.resolveArguments(plugin, args.slice(0, arity));
+        const rule = plugin.build(buildRuleContext(wiring, plugin, rawOptions), ...resolved);
+        return createChainNode(wiring, slot, [...rules, rule]);
+    };
+}
+function attachRefineMethods(target, wiring, rules) {
+    for (const [methodName, slot] of Object.entries(refine_methods_types_1.REFINE_METHOD_SLOTS)) {
+        target[methodName] = () => createChainNode(wiring, slot, rules);
+    }
+}
+/** The runtime value behind FieldChain. Erased to its type by its callers. */
+function createChainNode(wiring, slot, rules) {
+    const node = {};
+    attachRefineMethods(node, wiring, rules);
+    (0, attach_slot_methods_1.attachSlotMethods)(node, wiring.bag, slot, (plugin) => createSlotMethod(wiring, slot, rules, plugin));
+    chainRulesByNode.set(node, rules);
+    return Object.freeze(node);
+}
+/** The one way back out of a chain: undefined when the value is not a node. */
+function readChainRules(candidate) {
+    if (typeof candidate !== "object" || candidate === null)
+        return undefined;
+    return chainRulesByNode.get(candidate);
+}

package/dist/chain/create-chain-node.mjs

@@ -0,0 +1,77 @@
+// ===========================================================================
+// L3  src/chain/create-chain-node.ts — the IMMUTABLE chain node.
+//
+// A node owns exactly one thing: the ordered rule list built so far. Calling a
+// slot method builds ONE rule and returns a NEW frozen node; the receiver is
+// never touched, so two chains branched from the same `b` cannot contaminate
+// each other.
+//
+// The declared argument count comes from `plugin.build.length - 1` (build's own
+// parameters minus `ctx`), which is how the trailing `options?: RuleOptions` of
+// ChainMethod is separated from a trailing DECLARED optional argument. A plugin
+// whose build uses a default value or a rest parameter breaks that count; the
+// plugin contract forbids both.
+//
+// The rule list is held in a WeakMap rather than on the node, so the node
+// carries exactly the members its type declares and reading the rules back
+// needs no assertion and no runtime shape check.
+// ===========================================================================
+import { isPlainObject, isString } from "../types/index.mjs";
+import { REFINE_METHOD_SLOTS } from "./refine-methods.types.mjs";
+import { attachSlotMethods } from "./attach-slot-methods.mjs";
+const chainRulesByNode = new WeakMap();
+const EMPTY_RECORD = Object.freeze({});
+export const EMPTY_RULES = Object.freeze([]);
+function isIssueSeverity(value) {
+    return value === "error" || value === "warning" || value === "info";
+}
+function isMessageFactory(value) {
+    return typeof value === "function";
+}
+function buildRuleContext(wiring, plugin, rawOptions) {
+    const options = isPlainObject(rawOptions) ? rawOptions : EMPTY_RECORD;
+    const code = options["code"];
+    const severity = options["severity"];
+    const messageFactory = options["messageFactory"];
+    return {
+        pluginName: plugin.name,
+        code: isString(code) ? code : plugin.name,
+        severity: isIssueSeverity(severity)
+            ? severity
+            : wiring.context.config.defaultSeverity,
+        messageFactory: isMessageFactory(messageFactory)
+            ? messageFactory
+            : undefined,
+        config: wiring.context.config,
+        fieldPath: wiring.context.fieldPath,
+        declaredSiblingKeys: wiring.context.declaredSiblingKeys,
+    };
+}
+function createSlotMethod(wiring, slot, rules, plugin) {
+    const arity = Math.max(plugin.build.length - 1, 0);
+    return (...args) => {
+        const rawOptions = args.length > arity ? args[arity] : undefined;
+        const resolved = wiring.resolveArguments(plugin, args.slice(0, arity));
+        const rule = plugin.build(buildRuleContext(wiring, plugin, rawOptions), ...resolved);
+        return createChainNode(wiring, slot, [...rules, rule]);
+    };
+}
+function attachRefineMethods(target, wiring, rules) {
+    for (const [methodName, slot] of Object.entries(REFINE_METHOD_SLOTS)) {
+        target[methodName] = () => createChainNode(wiring, slot, rules);
+    }
+}
+/** The runtime value behind FieldChain. Erased to its type by its callers. */
+export function createChainNode(wiring, slot, rules) {
+    const node = {};
+    attachRefineMethods(node, wiring, rules);
+    attachSlotMethods(node, wiring.bag, slot, (plugin) => createSlotMethod(wiring, slot, rules, plugin));
+    chainRulesByNode.set(node, rules);
+    return Object.freeze(node);
+}
+/** The one way back out of a chain: undefined when the value is not a node. */
+export function readChainRules(candidate) {
+    if (typeof candidate !== "object" || candidate === null)
+        return undefined;
+    return chainRulesByNode.get(candidate);
+}

package/dist/chain/create-field-slots.d.ts

@@ -0,0 +1,6 @@
+import type { PluginBag } from "./plugin-bag.types";
+import type { FieldSlots } from "./field-slots.types";
+import { type ChainBuildContext } from "./create-chain-node";
+/** The erased twin of FieldSlots: the same nine keys, no type parameters. */
+export declare function buildSlotSurface(bag: PluginBag, context: ChainBuildContext): Readonly<Record<string, unknown>>;
+export declare function createFieldSlots<TRoot, B extends PluginBag, TField>(bag: B, context: ChainBuildContext): FieldSlots<TRoot, B, TField>;

package/dist/chain/create-field-slots.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSlotSurface = buildSlotSurface;
+exports.createFieldSlots = createFieldSlots;
+const type_erasure_1 = require("../core/type-erasure");
+const create_chain_node_1 = require("./create-chain-node");
+const collect_branch_rules_1 = require("./collect-branch-rules");
+const SLOT_NAMES = Object.freeze([
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+]);
+/** The erased twin of FieldSlots: the same nine keys, no type parameters. */
+function buildSlotSurface(bag, context) {
+    const surface = {};
+    const wiring = {
+        bag,
+        context,
+        resolveArguments: (plugin, declared) => (0, collect_branch_rules_1.resolvePluginArguments)(bag, context, buildSlotSurface, plugin, declared),
+    };
+    for (const slot of SLOT_NAMES) {
+        Object.defineProperty(surface, slot, {
+            enumerable: true,
+            get: () => (0, create_chain_node_1.createChainNode)(wiring, slot, create_chain_node_1.EMPTY_RULES),
+        });
+    }
+    return surface;
+}
+function createFieldSlots(bag, context) {
+    return (0, type_erasure_1.eraseChainSurface)(buildSlotSurface(bag, context));
+}

package/dist/chain/create-field-slots.mjs

@@ -0,0 +1,33 @@
+import { eraseChainSurface } from "../core/type-erasure.mjs";
+import { createChainNode, EMPTY_RULES, } from "./create-chain-node.mjs";
+import { resolvePluginArguments } from "./collect-branch-rules.mjs";
+const SLOT_NAMES = Object.freeze([
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "tuple",
+    "object",
+    "union",
+    "any",
+]);
+/** The erased twin of FieldSlots: the same nine keys, no type parameters. */
+export function buildSlotSurface(bag, context) {
+    const surface = {};
+    const wiring = {
+        bag,
+        context,
+        resolveArguments: (plugin, declared) => resolvePluginArguments(bag, context, buildSlotSurface, plugin, declared),
+    };
+    for (const slot of SLOT_NAMES) {
+        Object.defineProperty(surface, slot, {
+            enumerable: true,
+            get: () => createChainNode(wiring, slot, EMPTY_RULES),
+        });
+    }
+    return surface;
+}
+export function createFieldSlots(bag, context) {
+    return eraseChainSurface(buildSlotSurface(bag, context));
+}

package/dist/chain/field-chain.types.d.ts

@@ -0,0 +1,25 @@
+import type { TypeName } from "../types";
+import type { PluginBag, SlotPlugins } from "./plugin-bag.types";
+import type { ChainState } from "./chain-state.types";
+import type { ChainMethod } from "./chain-method.types";
+import type { RefineMethods } from "./refine-methods.types";
+/** The phantom is REQUIRED, not optional. */
+export interface ChainMarks<TValue, TState extends ChainState> {
+    readonly value: TValue;
+    readonly state: TState;
+}
+export type FieldChain<B extends PluginBag, S extends TypeName, TRoot, TValue, TState extends ChainState> = {
+    readonly [M in keyof SlotPlugins<B, S>]: ChainMethod<SlotPlugins<B, S>[M], B, S, TRoot, TValue, TState>;
+} & RefineMethods<B, TRoot, TValue, TState> & {
+    readonly __chain: ChainMarks<TValue, TState>;
+};
+/** `ChainMarks<unknown, ChainState>`, never `ChainMarks<never, ...>`. */
+export interface AnyChain {
+    readonly __chain: ChainMarks<unknown, ChainState>;
+}
+export type ChainOutput<C> = C extends {
+    readonly __chain: ChainMarks<infer V, ChainState>;
+} ? V : never;
+export type ChainStateOf<C> = C extends {
+    readonly __chain: ChainMarks<unknown, infer St>;
+} ? St : never;

package/dist/chain/field-chain.types.js

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

package/dist/chain/field-chain.types.mjs

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

package/dist/chain/field-slots.types.d.ts

@@ -0,0 +1,18 @@
+import type { TypeName } from "../types";
+import type { PluginBag } from "./plugin-bag.types";
+import type { OpenState } from "./chain-state.types";
+import type { FieldChain } from "./field-chain.types";
+import type { SlotAccepts, SlotTypeMismatch, SlotValue } from "./slot-value.types";
+type Slot<B extends PluginBag, S extends TypeName, TRoot, TField, TBase> = SlotAccepts<TField, TBase> extends true ? FieldChain<B, S, TRoot, SlotValue<TField, TBase>, OpenState> : SlotTypeMismatch<S, TField>;
+export interface FieldSlots<TRoot, B extends PluginBag, TField> {
+    readonly string: Slot<B, "string", TRoot, TField, string>;
+    readonly number: Slot<B, "number", TRoot, TField, number>;
+    readonly boolean: Slot<B, "boolean", TRoot, TField, boolean>;
+    readonly date: Slot<B, "date", TRoot, TField, Date>;
+    readonly array: Slot<B, "array", TRoot, TField, readonly unknown[]>;
+    readonly tuple: Slot<B, "tuple", TRoot, TField, readonly unknown[]>;
+    readonly object: Slot<B, "object", TRoot, TField, object>;
+    readonly union: Slot<B, "union", TRoot, TField, unknown>;
+    readonly any: Slot<B, "any", TRoot, TField, unknown>;
+}
+export {};

package/dist/chain/field-slots.types.js

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

package/dist/chain/field-slots.types.mjs

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

package/dist/chain/index.d.ts

@@ -0,0 +1,13 @@
+export { attachSlotMethods, CHAIN_BUILT_IN_OWNER, PluginMethodCollisionError, } from "./attach-slot-methods";
+export { createChainNode, readChainRules, EMPTY_RULES, type ChainBuildContext, type ChainNodeWiring, } from "./create-chain-node";
+export { collectBranchRules, resolvePluginArguments, SubChainResultError, type SlotSurfaceFactory, type SubChainArgumentDeclaration, type SubChainDefine, } from "./collect-branch-rules";
+export { buildSlotSurface, createFieldSlots } from "./create-field-slots";
+export { collectFieldRules, FieldChainResultError, } from "./collect-field-rules";
+export type { PluginBag, BagEntry, SlotPlugins } from "./plugin-bag.types";
+export type { AllowNull, ChainState, CoverWith, ExcludeMissing, ExcludeNull, ExcludeUndefined, OpenState, UncoveredMembers, UnionGuardCoverageError, } from "./chain-state.types";
+export type { ChainMethod } from "./chain-method.types";
+export type { AnyChain, ChainMarks, ChainOutput, ChainStateOf, FieldChain, } from "./field-chain.types";
+export type { FieldSlots } from "./field-slots.types";
+export type { ResolveArg, ResolveArgs, ResolveOut } from "./resolve-args.types";
+export type { SlotAccepts, SlotTypeMismatch, SlotValue, } from "./slot-value.types";
+export { REFINE_METHOD_SLOTS, type RefineMethodName, type RefineMethods, } from "./refine-methods.types";

package/dist/chain/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFINE_METHOD_SLOTS = exports.FieldChainResultError = exports.collectFieldRules = exports.createFieldSlots = exports.buildSlotSurface = exports.SubChainResultError = exports.resolvePluginArguments = exports.collectBranchRules = exports.EMPTY_RULES = exports.readChainRules = exports.createChainNode = exports.PluginMethodCollisionError = exports.CHAIN_BUILT_IN_OWNER = exports.attachSlotMethods = void 0;
+// ===========================================================================
+// L3  src/chain/index.ts — re-exports only.
+// ===========================================================================
+var attach_slot_methods_1 = require("./attach-slot-methods");
+Object.defineProperty(exports, "attachSlotMethods", { enumerable: true, get: function () { return attach_slot_methods_1.attachSlotMethods; } });
+Object.defineProperty(exports, "CHAIN_BUILT_IN_OWNER", { enumerable: true, get: function () { return attach_slot_methods_1.CHAIN_BUILT_IN_OWNER; } });
+Object.defineProperty(exports, "PluginMethodCollisionError", { enumerable: true, get: function () { return attach_slot_methods_1.PluginMethodCollisionError; } });
+var create_chain_node_1 = require("./create-chain-node");
+Object.defineProperty(exports, "createChainNode", { enumerable: true, get: function () { return create_chain_node_1.createChainNode; } });
+Object.defineProperty(exports, "readChainRules", { enumerable: true, get: function () { return create_chain_node_1.readChainRules; } });
+Object.defineProperty(exports, "EMPTY_RULES", { enumerable: true, get: function () { return create_chain_node_1.EMPTY_RULES; } });
+var collect_branch_rules_1 = require("./collect-branch-rules");
+Object.defineProperty(exports, "collectBranchRules", { enumerable: true, get: function () { return collect_branch_rules_1.collectBranchRules; } });
+Object.defineProperty(exports, "resolvePluginArguments", { enumerable: true, get: function () { return collect_branch_rules_1.resolvePluginArguments; } });
+Object.defineProperty(exports, "SubChainResultError", { enumerable: true, get: function () { return collect_branch_rules_1.SubChainResultError; } });
+var create_field_slots_1 = require("./create-field-slots");
+Object.defineProperty(exports, "buildSlotSurface", { enumerable: true, get: function () { return create_field_slots_1.buildSlotSurface; } });
+Object.defineProperty(exports, "createFieldSlots", { enumerable: true, get: function () { return create_field_slots_1.createFieldSlots; } });
+var collect_field_rules_1 = require("./collect-field-rules");
+Object.defineProperty(exports, "collectFieldRules", { enumerable: true, get: function () { return collect_field_rules_1.collectFieldRules; } });
+Object.defineProperty(exports, "FieldChainResultError", { enumerable: true, get: function () { return collect_field_rules_1.FieldChainResultError; } });
+var refine_methods_types_1 = require("./refine-methods.types");
+Object.defineProperty(exports, "REFINE_METHOD_SLOTS", { enumerable: true, get: function () { return refine_methods_types_1.REFINE_METHOD_SLOTS; } });

package/dist/chain/index.mjs

@@ -0,0 +1,9 @@
+// ===========================================================================
+// L3  src/chain/index.ts — re-exports only.
+// ===========================================================================
+export { attachSlotMethods, CHAIN_BUILT_IN_OWNER, PluginMethodCollisionError, } from "./attach-slot-methods.mjs";
+export { createChainNode, readChainRules, EMPTY_RULES, } from "./create-chain-node.mjs";
+export { collectBranchRules, resolvePluginArguments, SubChainResultError, } from "./collect-branch-rules.mjs";
+export { buildSlotSurface, createFieldSlots } from "./create-field-slots.mjs";
+export { collectFieldRules, FieldChainResultError, } from "./collect-field-rules.mjs";
+export { REFINE_METHOD_SLOTS, } from "./refine-methods.types.mjs";

package/dist/chain/marker-coverage.types.d.ts

@@ -0,0 +1,56 @@
+import type { ArgumentMarkerKind, ArgumentMarkerRegistry, AssertNever, IsMarkerFree, MarkerRegistryProof, OutputMarkerKind, OutputMarkerRegistry } from "../plugin-kit/marker.types";
+import type { RuleForOut, RuntimeArg } from "../plugin-kit/runtime-args.types";
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { PluginBag } from "./plugin-bag.types";
+import type { ChainState, OpenState } from "./chain-state.types";
+import type { ResolveArg, ResolveOut } from "./resolve-args.types";
+interface CoverageRoot {
+    readonly probeField: string;
+    readonly probeList: readonly string[];
+}
+type CoverageValue = string;
+type CoverageBag = PluginBag;
+type LeftUnresolved<Resolved, Marker> = [Resolved] extends [Marker] ? true : false;
+type CallSiteGap = {
+    [K in ArgumentMarkerKind]: LeftUnresolved<ResolveArg<ArgumentMarkerRegistry[K], CoverageBag, CoverageRoot, CoverageValue, OpenState>, ArgumentMarkerRegistry[K]> extends true ? K : never;
+}[ArgumentMarkerKind];
+type RuntimeGap = {
+    [K in ArgumentMarkerKind]: LeftUnresolved<RuntimeArg<ArgumentMarkerRegistry[K]>, ArgumentMarkerRegistry[K]> extends true ? K : never;
+}[ArgumentMarkerKind];
+type OutputGap = {
+    [K in OutputMarkerKind]: ResolveOut<OutputMarkerRegistry[K], CoverageValue, OpenState> extends readonly [infer V, ChainState] ? LeftUnresolved<V, OutputMarkerRegistry[K]> extends true ? K : never : K;
+}[OutputMarkerKind];
+type UnwrapList<L> = L extends readonly (infer V)[] ? V : L;
+type UnwrapRecord<R> = R extends Readonly<Record<string, infer V>> ? V : R;
+type CallSiteListGap = {
+    [K in ArgumentMarkerKind]: LeftUnresolved<UnwrapList<ResolveArg<readonly ArgumentMarkerRegistry[K][], CoverageBag, CoverageRoot, CoverageValue, OpenState>>, ArgumentMarkerRegistry[K]> extends true ? K : never;
+}[ArgumentMarkerKind];
+type CallSiteRecordGap = {
+    [K in ArgumentMarkerKind]: LeftUnresolved<UnwrapRecord<ResolveArg<Readonly<Record<string, ArgumentMarkerRegistry[K]>>, CoverageBag, CoverageRoot, CoverageValue, OpenState>>, ArgumentMarkerRegistry[K]> extends true ? K : never;
+}[ArgumentMarkerKind];
+type RuntimeListGap = {
+    [K in ArgumentMarkerKind]: LeftUnresolved<UnwrapList<RuntimeArg<readonly ArgumentMarkerRegistry[K][]>>, ArgumentMarkerRegistry[K]> extends true ? K : never;
+}[ArgumentMarkerKind];
+type RuntimeRecordGap = {
+    [K in ArgumentMarkerKind]: LeftUnresolved<UnwrapRecord<RuntimeArg<Readonly<Record<string, ArgumentMarkerRegistry[K]>>>>, ArgumentMarkerRegistry[K]> extends true ? K : never;
+}[ArgumentMarkerKind];
+/** A marker hidden inside a container must not read as marker-free either. */
+type BindableLeakGap = {
+    [K in ArgumentMarkerKind]: (IsMarkerFree<readonly [readonly ArgumentMarkerRegistry[K][]]> extends true ? K : never) | (IsMarkerFree<readonly [Readonly<Record<string, ArgumentMarkerRegistry[K]>>]> extends true ? K : never);
+}[ArgumentMarkerKind];
+type RuleShapeGap = {
+    [K in OutputMarkerKind]: [RuleForOut<OutputMarkerRegistry[K]>] extends [Rule] ? never : K;
+}[OutputMarkerKind];
+export type MarkerResolutionProof = [
+    MarkerRegistryProof,
+    AssertNever<CallSiteGap>,
+    AssertNever<RuntimeGap>,
+    AssertNever<CallSiteListGap>,
+    AssertNever<CallSiteRecordGap>,
+    AssertNever<RuntimeListGap>,
+    AssertNever<RuntimeRecordGap>,
+    AssertNever<BindableLeakGap>,
+    AssertNever<OutputGap>,
+    AssertNever<RuleShapeGap>
+];
+export {};

package/dist/chain/marker-coverage.types.js

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

package/dist/chain/marker-coverage.types.mjs

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

package/dist/chain/plugin-bag.types.d.ts

@@ -0,0 +1,9 @@
+import type { AnyPlugin, PluginDefinition, PluginSignature } from "../plugin-kit/plugin-definition";
+import type { TypeName } from "../types";
+export type PluginBag = Readonly<Record<string, AnyPlugin>>;
+export type BagEntry<P> = P extends PluginDefinition<infer TName, string, readonly TypeName[], PluginSignature> ? {
+    readonly [K in TName]: P;
+} : never;
+export type SlotPlugins<B extends PluginBag, S extends TypeName> = {
+    [K in keyof B as S extends B[K]["slots"][number] ? B[K]["method"] : never]: B[K];
+};

package/dist/chain/plugin-bag.types.js

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

package/dist/chain/plugin-bag.types.mjs

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

package/dist/chain/refine-methods.types.d.ts

@@ -0,0 +1,33 @@
+import type { TypeName } from "../types";
+import type { PluginBag } from "./plugin-bag.types";
+import type { ChainState } from "./chain-state.types";
+import type { FieldChain } from "./field-chain.types";
+import type { SlotAccepts, SlotTypeMismatch } from "./slot-value.types";
+type Refine<B extends PluginBag, S extends TypeName, TRoot, TValue, TState extends ChainState, TBase> = SlotAccepts<TValue, TBase> extends true ? () => FieldChain<B, S, TRoot, TValue, TState> : SlotTypeMismatch<S, TValue>;
+/**
+ * Present on EVERY chain, exactly as in 1.x. Declared as an interface so the
+ * mutual reference with FieldChain stays deferred instead of expanding.
+ */
+export interface RefineMethods<B extends PluginBag, TRoot, TValue, TState extends ChainState> {
+    readonly refineString: Refine<B, "string", TRoot, TValue, TState, string>;
+    readonly refineNumber: Refine<B, "number", TRoot, TValue, TState, number>;
+    readonly refineBoolean: Refine<B, "boolean", TRoot, TValue, TState, boolean>;
+    readonly refineDate: Refine<B, "date", TRoot, TValue, TState, Date>;
+    readonly refineArray: Refine<B, "array", TRoot, TValue, TState, readonly unknown[]>;
+    readonly refineTuple: Refine<B, "tuple", TRoot, TValue, TState, readonly unknown[]>;
+    readonly refineObject: Refine<B, "object", TRoot, TValue, TState, object>;
+    readonly refineUnion: Refine<B, "union", TRoot, TValue, TState, unknown>;
+}
+/** The eight names, as a value-level closed set the runtime shares. */
+export declare const REFINE_METHOD_SLOTS: {
+    readonly refineString: "string";
+    readonly refineNumber: "number";
+    readonly refineBoolean: "boolean";
+    readonly refineDate: "date";
+    readonly refineArray: "array";
+    readonly refineTuple: "tuple";
+    readonly refineObject: "object";
+    readonly refineUnion: "union";
+};
+export type RefineMethodName = keyof typeof REFINE_METHOD_SLOTS;
+export {};

package/dist/chain/refine-methods.types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFINE_METHOD_SLOTS = void 0;
+/** The eight names, as a value-level closed set the runtime shares. */
+exports.REFINE_METHOD_SLOTS = {
+    refineString: "string",
+    refineNumber: "number",
+    refineBoolean: "boolean",
+    refineDate: "date",
+    refineArray: "array",
+    refineTuple: "tuple",
+    refineObject: "object",
+    refineUnion: "union",
+};

package/dist/chain/refine-methods.types.mjs

@@ -0,0 +1,11 @@
+/** The eight names, as a value-level closed set the runtime shares. */
+export const REFINE_METHOD_SLOTS = {
+    refineString: "string",
+    refineNumber: "number",
+    refineBoolean: "boolean",
+    refineDate: "date",
+    refineArray: "array",
+    refineTuple: "tuple",
+    refineObject: "object",
+    refineUnion: "union",
+};

package/dist/chain/resolve-args.types.d.ts

@@ -0,0 +1,28 @@
+import type { ArrayItemContext, Present } from "../types";
+import type { ElementChain, FieldRef, FieldRefs, GuardOut, MarkerRecord, NarrowedChain, PresenceShift, PropertyKeyChain, PropertyValueChain, RootPredicate, RootReader, SelfGuard, SelfReader, SelfValue, TransformOut, Unchanged } from "../plugin-kit/marker.types";
+import type { ElementOf } from "../path/element-of.types";
+import type { PropertyValueOf } from "../path/property-value-of.types";
+import type { FieldPath } from "../path/field-path.types";
+import type { PluginBag } from "./plugin-bag.types";
+import type { AnyChain } from "./field-chain.types";
+import type { FieldSlots } from "./field-slots.types";
+import type { AllowNull, ChainState, ExcludeMissing, ExcludeNull, ExcludeUndefined } from "./chain-state.types";
+/** Optional tuple elements are stripped of `undefined` before matching. */
+export type ResolveArg<A, B extends PluginBag, TRoot, TValue, TState extends ChainState> = [undefined] extends [A] ? ResolveOneArg<Exclude<A, undefined>, B, TRoot, TValue, TState> | undefined : ResolveOneArg<A, B, TRoot, TValue, TState>;
+type ResolveOneArg<A, B extends PluginBag, TRoot, TValue, TState extends ChainState> = [A] extends [FieldRef] ? FieldPath<TRoot> & string : [A] extends [FieldRefs] ? readonly (FieldPath<TRoot> & string)[] : [A] extends [RootPredicate] ? (root: TRoot, item?: ArrayItemContext) => boolean : [A] extends [RootReader<infer R>] ? (root: TRoot) => R : [A] extends [SelfReader<infer R>] ? (value: Present<TValue, TState>) => R : [A] extends [SelfGuard] ? (value: Present<TValue, TState>) => boolean : [A] extends [NarrowedChain] ? (b: FieldSlots<TRoot, B, Present<TValue, TState>>) => AnyChain : [A] extends [SelfValue] ? Present<TValue, TState> : [A] extends [ElementChain] ? (b: FieldSlots<TRoot, B, ElementOf<TValue>>) => AnyChain : [
+    A
+] extends [PropertyValueChain] ? (b: FieldSlots<TRoot, B, PropertyValueOf<Present<TValue, TState>>>) => AnyChain : [A] extends [PropertyKeyChain] ? (b: FieldSlots<TRoot, B, string>) => AnyChain : [A] extends [readonly unknown[]] ? {
+    [I in keyof A]: ResolveArg<A[I], B, TRoot, TValue, TState>;
+} : [
+    A
+] extends [MarkerRecord] ? {
+    readonly [K in keyof A]: ResolveArg<A[K], B, TRoot, TValue, TState>;
+} : A;
+export type ResolveArgs<A extends readonly unknown[], B extends PluginBag, TRoot, TValue, TState extends ChainState> = {
+    [I in keyof A]: ResolveArg<A[I], B, TRoot, TValue, TState>;
+};
+/** Presence shifts go through the NAMED operators over ChainState. */
+export type ResolveOut<O, TValue, TState extends ChainState> = [O] extends [
+    Unchanged
+] ? [TValue, TState] : [O] extends [TransformOut] ? [unknown, TState] : [O] extends [GuardOut] ? [TValue, TState] : [O] extends [PresenceShift<"excludeMissing">] ? [TValue, ExcludeMissing<TState>] : [O] extends [PresenceShift<"excludeUndefined">] ? [TValue, ExcludeUndefined<TState>] : [O] extends [PresenceShift<"excludeNull">] ? [TValue, ExcludeNull<TState>] : [O] extends [PresenceShift<"allowNull">] ? [TValue | null, AllowNull<TState>] : [O, TState];
+export {};

package/dist/chain/resolve-args.types.js

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

package/dist/chain/resolve-args.types.mjs

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

package/dist/chain/slot-value.types.d.ts

@@ -0,0 +1,14 @@
+import type { TypeName } from "../types";
+type IsUnknown<T> = unknown extends T ? true : false;
+/** True when TField can legally be addressed through a slot based on TBase. */
+export type SlotAccepts<TField, TBase> = IsUnknown<TField> extends true ? true : [Extract<NonNullable<TField>, TBase>] extends [never] ? false : true;
+/** The TValue a slot hands its chain. */
+export type SlotValue<TField, TBase> = IsUnknown<TField> extends true ? TBase | undefined : Extract<TField, TBase | null | undefined>;
+/** What a slot resolves to when the field type cannot flow through it. */
+export interface SlotTypeMismatch<S extends TypeName, TField> {
+    readonly luqError: "slotTypeMismatch";
+    readonly message: "This field's declared type cannot be validated through this slot.";
+    readonly slot: S;
+    readonly fieldType: TField;
+}
+export {};

package/dist/chain/slot-value.types.js

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

package/dist/chain/slot-value.types.mjs

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

package/dist/compile/branch-executor.port.d.ts

@@ -0,0 +1,6 @@
+import type { CheckOutcome, RuleContext } from "../types";
+import type { ValidationPlan } from "./validation-plan.types";
+/** L4 declares the PORT, L5 implements it, L6 wires them. */
+export interface BranchExecutor {
+    runBranch(plan: ValidationPlan, value: unknown, ctx: RuleContext): CheckOutcome;
+}

package/dist/compile/branch-executor.port.js

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

package/dist/compile/branch-executor.port.mjs

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

package/dist/compile/compile-array-node.d.ts

@@ -0,0 +1,19 @@
+import type { ArrayNode, CompiledField, PlanRef } from "./validation-plan.types";
+import { type CompositeEraser } from "./compile-field";
+import { type ArrayFieldGroup, type RelativeDeclaration } from "./group-array-fields";
+/** Everything a field needs that is not the declaration itself. */
+export interface NodeCompileContext {
+    /** The plan a `recursively` rule on any of these fields re-enters. */
+    readonly planRef: PlanRef;
+    readonly eraseComposite: CompositeEraser;
+}
+/** The one adapter from a grouped declaration to compileField's request. */
+export declare function compileRelativeDeclaration(declaration: RelativeDeclaration, context: NodeCompileContext): CompiledField;
+/**
+ * Nesting is a re-grouping of the members, not a second traversal strategy:
+ * `items[*].sub[*].x` arrives here as the group `items` whose one member is
+ * still `sub[*].x`, and that member groups again into the nested node `sub`.
+ * `matrix[*][*]` reaches the same shape through an EMPTY nested template —
+ * the element of the outer array is itself the inner array.
+ */
+export declare function compileArrayNode(group: ArrayFieldGroup, context: NodeCompileContext): ArrayNode;