@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/runtime/run-plan.mjs

@@ -0,0 +1,46 @@
+import { joinIssuePath } from "./index-stack.mjs";
+import { runArrayNodes } from "./run-array-node.mjs";
+import { runField } from "./run-field.mjs";
+import { NO_WRITE_TARGETS, writeFieldValue } from "./output-writer.mjs";
+/**
+ * `targets` mirrors `plan.arrays` by position and defaults to empty, which is
+ * the honest description of every run that produces no output: a validate(),
+ * a branch, a recursive re-entry.
+ *
+ * Each field reads from `current`, the subject as earlier fields in this plan
+ * left it, so a rule on `a.b` sees a transform that rewrote `a`. `context.root`
+ * is NOT advanced: cross-field rules are written against the input the caller
+ * passed, and moving the root under them would make their answer depend on
+ * declaration order.
+ */
+export function runPlan(plan, subject, context, targets = NO_WRITE_TARGETS) {
+    let current = subject;
+    for (const field of plan.fields) {
+        const outcome = runField(field, current, context);
+        current = writeFieldValue(field, current, outcome, context.shouldApplyTransforms);
+        if (context.sink.shouldStopPlan())
+            return current;
+    }
+    return runArrayNodes(plan.arrays, current, context, targets);
+}
+/**
+ * Re-bases the issues of a NESTED plan onto the path of the rule that entered
+ * it. A branch's fields and a recursive re-entry's fields are both declared
+ * relative to their own subject, so their issues come back as `name`; the
+ * enclosing rule knows the subject sits at `user`, and the consumer must read
+ * `user.name`.
+ *
+ * It lives here because both callers already depend on this module and neither
+ * may depend on the other — run-branch creates a recursion runner, so
+ * run-recursion could not own it without a cycle.
+ */
+export function prefixIssuePaths(prefix, issues) {
+    if (prefix === "")
+        return issues;
+    return issues.map((issue) => Object.freeze({
+        path: joinIssuePath(prefix, issue.path),
+        code: issue.code,
+        message: issue.message,
+        severity: issue.severity,
+    }));
+}

package/dist/runtime/run-recursion.d.ts

@@ -0,0 +1,17 @@
+import { IssueSink } from "./issue-sink";
+import type { AbortPolicy } from "./issue-sink";
+import type { RecursionRunner } from "./run-field";
+/**
+ * Legacy contract, kept: fields do not abort each other inside a recursive
+ * re-entry. A descent that stopped at its first issue would report one leaf of
+ * a tree and hide the rest, and the caller's abortEarly still decides whether
+ * the OUTER plan continues once these issues are merged back.
+ */
+export declare const RECURSION_ABORT_POLICY: AbortPolicy;
+/** Everything a re-entry needs that is not the policy or the value. */
+export interface RecursionHost {
+    readonly root: unknown;
+    readonly sink: IssueSink;
+    readonly external?: Readonly<Record<string, unknown>>;
+}
+export declare function createRecursionRunner(host: RecursionHost): RecursionRunner;

package/dist/runtime/run-recursion.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECURSION_ABORT_POLICY = void 0;
+exports.createRecursionRunner = createRecursionRunner;
+// ===========================================================================
+// L5  src/runtime/run-recursion.ts
+// `objectRecursively` executed: the SAME plan, re-entered against a nested
+// value, with a depth counter and a cycle guard.
+//
+// Two terminations, and they are not the same event:
+//   * a CYCLE ends the descent silently. The object is already being validated
+//     further up this very path, so re-validating it can only repeat issues
+//     that are already in the sink — and never terminate.
+//   * MAX DEPTH is reported, under the recursive rule's own code and severity.
+//     Legacy truncated at maxDepth as a SUCCESS, which meant a structure deeper
+//     than the limit silently skipped every rule below it.
+//
+// The nested plan runs into its OWN sink and its OWN index stack, and its
+// issues are re-based onto the entering field's path afterwards. That is what
+// makes `node.child.name` come out right: the plan's fields are declared
+// relative to the plan's subject and know nothing about where they were
+// re-entered from.
+//
+// A re-entry never writes. RecursionRunner returns void by contract, so there
+// is nowhere for a transformed subtree to go; recursion is validation, and
+// `shouldApplyTransforms` is false for everything below it.
+// ===========================================================================
+const types_1 = require("../types");
+const create_issue_1 = require("./create-issue");
+const index_stack_1 = require("./index-stack");
+const issue_sink_1 = require("./issue-sink");
+const run_plan_1 = require("./run-plan");
+/**
+ * Legacy contract, kept: fields do not abort each other inside a recursive
+ * re-entry. A descent that stopped at its first issue would report one leaf of
+ * a tree and hide the rest, and the caller's abortEarly still decides whether
+ * the OUTER plan continues once these issues are merged back.
+ */
+exports.RECURSION_ABORT_POLICY = Object.freeze({
+    abortEarly: false,
+    abortEarlyOnEachField: false,
+});
+function createRecursionRunner(host) {
+    return bindRecursionRunner(host, {
+        depth: 0,
+        visited: new WeakSet(),
+    });
+}
+/**
+ * Re-binding at each descent is what makes a recursion two levels down come
+ * back as `child.child.name`. A single runner bound to the top sink would add
+ * the inner issues straight to it, prefixed only by the inner path, and the
+ * intermediate hop would vanish.
+ */
+function bindRecursionRunner(host, progress) {
+    const runRecursion = (policy, value, ruleContext) => {
+        if (policy.target === "element") {
+            enterElements(policy, value, ruleContext.path);
+            return;
+        }
+        enterPlan(policy, value, ruleContext.path);
+    };
+    function enterElements(policy, value, path) {
+        if (!(0, types_1.isArray)(value))
+            return;
+        for (let index = 0; index < value.length; index += 1) {
+            enterPlan(policy, value[index], `${path}[${index}]`);
+        }
+    }
+    function enterPlan(policy, value, path) {
+        if (progress.depth >= policy.maxDepth) {
+            host.sink.add(describeDepthLimit(policy, value, path, progress.depth));
+            return;
+        }
+        const tracked = isTrackableObject(value) ? value : null;
+        if (tracked !== null && progress.visited.has(tracked))
+            return;
+        if (tracked !== null)
+            progress.visited.add(tracked);
+        progress.depth += 1;
+        collectInto(policy, value, path);
+        progress.depth -= 1;
+        if (tracked !== null)
+            progress.visited.delete(tracked);
+    }
+    function collectInto(policy, value, path) {
+        const nested = new issue_sink_1.IssueSink(exports.RECURSION_ABORT_POLICY);
+        (0, run_plan_1.runPlan)(policy.plan.resolve(), value, {
+            root: host.root,
+            sink: nested,
+            indices: new index_stack_1.IndexStack(),
+            shouldApplyTransforms: false,
+            runRecursion: bindRecursionRunner({ ...host, sink: nested }, progress),
+            external: host.external,
+        });
+        for (const issue of (0, run_plan_1.prefixIssuePaths)(path, nested.issues)) {
+            host.sink.add(issue);
+        }
+    }
+    return runRecursion;
+}
+/**
+ * The depth issue carries the limit as `expected` and the depth actually
+ * reached as `actual`, so a plugin's message can name both without the runtime
+ * formatting anything itself.
+ */
+function describeDepthLimit(policy, value, path, depth) {
+    return (0, create_issue_1.createIssue)({
+        path,
+        code: policy.code,
+        severity: policy.severity,
+        value,
+        render: (messageContext) => policy.describe({ expected: policy.maxDepth, actual: depth }, messageContext),
+    });
+}
+/** A WeakSet holds objects only; a primitive cannot be part of a cycle. */
+function isTrackableObject(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/runtime/run-recursion.mjs

@@ -0,0 +1,115 @@
+// ===========================================================================
+// L5  src/runtime/run-recursion.ts
+// `objectRecursively` executed: the SAME plan, re-entered against a nested
+// value, with a depth counter and a cycle guard.
+//
+// Two terminations, and they are not the same event:
+//   * a CYCLE ends the descent silently. The object is already being validated
+//     further up this very path, so re-validating it can only repeat issues
+//     that are already in the sink — and never terminate.
+//   * MAX DEPTH is reported, under the recursive rule's own code and severity.
+//     Legacy truncated at maxDepth as a SUCCESS, which meant a structure deeper
+//     than the limit silently skipped every rule below it.
+//
+// The nested plan runs into its OWN sink and its OWN index stack, and its
+// issues are re-based onto the entering field's path afterwards. That is what
+// makes `node.child.name` come out right: the plan's fields are declared
+// relative to the plan's subject and know nothing about where they were
+// re-entered from.
+//
+// A re-entry never writes. RecursionRunner returns void by contract, so there
+// is nowhere for a transformed subtree to go; recursion is validation, and
+// `shouldApplyTransforms` is false for everything below it.
+// ===========================================================================
+import { isArray } from "../types/index.mjs";
+import { createIssue } from "./create-issue.mjs";
+import { IndexStack } from "./index-stack.mjs";
+import { IssueSink } from "./issue-sink.mjs";
+import { prefixIssuePaths, runPlan } from "./run-plan.mjs";
+/**
+ * Legacy contract, kept: fields do not abort each other inside a recursive
+ * re-entry. A descent that stopped at its first issue would report one leaf of
+ * a tree and hide the rest, and the caller's abortEarly still decides whether
+ * the OUTER plan continues once these issues are merged back.
+ */
+export const RECURSION_ABORT_POLICY = Object.freeze({
+    abortEarly: false,
+    abortEarlyOnEachField: false,
+});
+export function createRecursionRunner(host) {
+    return bindRecursionRunner(host, {
+        depth: 0,
+        visited: new WeakSet(),
+    });
+}
+/**
+ * Re-binding at each descent is what makes a recursion two levels down come
+ * back as `child.child.name`. A single runner bound to the top sink would add
+ * the inner issues straight to it, prefixed only by the inner path, and the
+ * intermediate hop would vanish.
+ */
+function bindRecursionRunner(host, progress) {
+    const runRecursion = (policy, value, ruleContext) => {
+        if (policy.target === "element") {
+            enterElements(policy, value, ruleContext.path);
+            return;
+        }
+        enterPlan(policy, value, ruleContext.path);
+    };
+    function enterElements(policy, value, path) {
+        if (!isArray(value))
+            return;
+        for (let index = 0; index < value.length; index += 1) {
+            enterPlan(policy, value[index], `${path}[${index}]`);
+        }
+    }
+    function enterPlan(policy, value, path) {
+        if (progress.depth >= policy.maxDepth) {
+            host.sink.add(describeDepthLimit(policy, value, path, progress.depth));
+            return;
+        }
+        const tracked = isTrackableObject(value) ? value : null;
+        if (tracked !== null && progress.visited.has(tracked))
+            return;
+        if (tracked !== null)
+            progress.visited.add(tracked);
+        progress.depth += 1;
+        collectInto(policy, value, path);
+        progress.depth -= 1;
+        if (tracked !== null)
+            progress.visited.delete(tracked);
+    }
+    function collectInto(policy, value, path) {
+        const nested = new IssueSink(RECURSION_ABORT_POLICY);
+        runPlan(policy.plan.resolve(), value, {
+            root: host.root,
+            sink: nested,
+            indices: new IndexStack(),
+            shouldApplyTransforms: false,
+            runRecursion: bindRecursionRunner({ ...host, sink: nested }, progress),
+            external: host.external,
+        });
+        for (const issue of prefixIssuePaths(path, nested.issues)) {
+            host.sink.add(issue);
+        }
+    }
+    return runRecursion;
+}
+/**
+ * The depth issue carries the limit as `expected` and the depth actually
+ * reached as `actual`, so a plugin's message can name both without the runtime
+ * formatting anything itself.
+ */
+function describeDepthLimit(policy, value, path, depth) {
+    return createIssue({
+        path,
+        code: policy.code,
+        severity: policy.severity,
+        value,
+        render: (messageContext) => policy.describe({ expected: policy.maxDepth, actual: depth }, messageContext),
+    });
+}
+/** A WeakSet holds objects only; a primitive cannot be part of a cycle. */
+function isTrackableObject(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/subpath-aliases/read-only-write-only.d.ts

@@ -0,0 +1,2 @@
+export { readOnlyPlugin } from "../plugins/read-only/index";
+export { writeOnlyPlugin } from "../plugins/write-only/index";

package/dist/subpath-aliases/read-only-write-only.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeOnlyPlugin = exports.readOnlyPlugin = void 0;
+// ===========================================================================
+// src/subpath-aliases/read-only-write-only.ts
+// The 1.x subpath `@maroonedog/luq/plugins/readOnlyWriteOnly` kept alive.
+//
+// It has no plugin directory of its own — readOnly and writeOnly are two
+// directories now — so it lives here, where the catalog does not look for
+// plugins, and SUBPATH_ALIASES publishes it only because this file exists.
+// Deprecated: import ./plugins/readOnly and ./plugins/writeOnly instead.
+// ===========================================================================
+var index_1 = require("../plugins/read-only/index");
+Object.defineProperty(exports, "readOnlyPlugin", { enumerable: true, get: function () { return index_1.readOnlyPlugin; } });
+var index_2 = require("../plugins/write-only/index");
+Object.defineProperty(exports, "writeOnlyPlugin", { enumerable: true, get: function () { return index_2.writeOnlyPlugin; } });

package/dist/subpath-aliases/read-only-write-only.mjs

@@ -0,0 +1,11 @@
+// ===========================================================================
+// src/subpath-aliases/read-only-write-only.ts
+// The 1.x subpath `@maroonedog/luq/plugins/readOnlyWriteOnly` kept alive.
+//
+// It has no plugin directory of its own — readOnly and writeOnly are two
+// directories now — so it lives here, where the catalog does not look for
+// plugins, and SUBPATH_ALIASES publishes it only because this file exists.
+// Deprecated: import ./plugins/readOnly and ./plugins/writeOnly instead.
+// ===========================================================================
+export { readOnlyPlugin } from "../plugins/read-only/index.mjs";
+export { writeOnlyPlugin } from "../plugins/write-only/index.mjs";

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

@@ -0,0 +1,31 @@
+import type { IssueSeverity } from "./index";
+export type ValueTransform = (value: unknown) => unknown;
+export interface NumberFormat {
+    readonly decimalSeparator: string;
+    readonly thousandSeparator: string;
+}
+/** Every member optional: this is what a caller supplies. */
+export interface GlobalConfig {
+    readonly messageKeyPrefix?: string;
+    readonly toBooleanTruthyValues?: readonly string[];
+    readonly numberFormat?: Partial<NumberFormat>;
+    readonly dateFormat?: string;
+    readonly trimStrings?: boolean;
+    readonly caseSensitive?: boolean;
+    readonly customTransforms?: Readonly<Record<string, ValueTransform>>;
+    /** Severity a rule emits when neither the rule nor the call names one. */
+    readonly defaultSeverity?: IssueSeverity;
+}
+/** Every member present: this is what a plugin reads. */
+export interface ResolvedGlobalConfig {
+    readonly messageKeyPrefix: string;
+    readonly toBooleanTruthyValues: readonly string[];
+    readonly numberFormat: NumberFormat;
+    readonly dateFormat: string;
+    readonly trimStrings: boolean;
+    readonly caseSensitive: boolean;
+    readonly customTransforms: Readonly<Record<string, ValueTransform>>;
+    readonly defaultSeverity: IssueSeverity;
+}
+export declare const DEFAULT_GLOBAL_CONFIG: ResolvedGlobalConfig;
+export declare function resolveGlobalConfig(overrides: GlobalConfig | undefined, base?: ResolvedGlobalConfig): ResolvedGlobalConfig;

package/dist/types/global-config.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GLOBAL_CONFIG = void 0;
+exports.resolveGlobalConfig = resolveGlobalConfig;
+exports.DEFAULT_GLOBAL_CONFIG = Object.freeze({
+    messageKeyPrefix: "",
+    toBooleanTruthyValues: Object.freeze(["true", "1", "yes", "on"]),
+    numberFormat: Object.freeze({
+        decimalSeparator: ".",
+        thousandSeparator: ",",
+    }),
+    dateFormat: "YYYY-MM-DD",
+    trimStrings: false,
+    caseSensitive: true,
+    customTransforms: Object.freeze({}),
+    defaultSeverity: "error",
+});
+function resolveGlobalConfig(overrides, base = exports.DEFAULT_GLOBAL_CONFIG) {
+    if (overrides === undefined)
+        return base;
+    return Object.freeze({
+        messageKeyPrefix: overrides.messageKeyPrefix ?? base.messageKeyPrefix,
+        toBooleanTruthyValues: overrides.toBooleanTruthyValues ?? base.toBooleanTruthyValues,
+        numberFormat: Object.freeze({
+            decimalSeparator: overrides.numberFormat?.decimalSeparator ??
+                base.numberFormat.decimalSeparator,
+            thousandSeparator: overrides.numberFormat?.thousandSeparator ??
+                base.numberFormat.thousandSeparator,
+        }),
+        dateFormat: overrides.dateFormat ?? base.dateFormat,
+        trimStrings: overrides.trimStrings ?? base.trimStrings,
+        caseSensitive: overrides.caseSensitive ?? base.caseSensitive,
+        customTransforms: overrides.customTransforms ?? base.customTransforms,
+        defaultSeverity: overrides.defaultSeverity ?? base.defaultSeverity,
+    });
+}

package/dist/types/global-config.mjs

@@ -0,0 +1,32 @@
+export const DEFAULT_GLOBAL_CONFIG = Object.freeze({
+    messageKeyPrefix: "",
+    toBooleanTruthyValues: Object.freeze(["true", "1", "yes", "on"]),
+    numberFormat: Object.freeze({
+        decimalSeparator: ".",
+        thousandSeparator: ",",
+    }),
+    dateFormat: "YYYY-MM-DD",
+    trimStrings: false,
+    caseSensitive: true,
+    customTransforms: Object.freeze({}),
+    defaultSeverity: "error",
+});
+export function resolveGlobalConfig(overrides, base = DEFAULT_GLOBAL_CONFIG) {
+    if (overrides === undefined)
+        return base;
+    return Object.freeze({
+        messageKeyPrefix: overrides.messageKeyPrefix ?? base.messageKeyPrefix,
+        toBooleanTruthyValues: overrides.toBooleanTruthyValues ?? base.toBooleanTruthyValues,
+        numberFormat: Object.freeze({
+            decimalSeparator: overrides.numberFormat?.decimalSeparator ??
+                base.numberFormat.decimalSeparator,
+            thousandSeparator: overrides.numberFormat?.thousandSeparator ??
+                base.numberFormat.thousandSeparator,
+        }),
+        dateFormat: overrides.dateFormat ?? base.dateFormat,
+        trimStrings: overrides.trimStrings ?? base.trimStrings,
+        caseSensitive: overrides.caseSensitive ?? base.caseSensitive,
+        customTransforms: overrides.customTransforms ?? base.customTransforms,
+        defaultSeverity: overrides.defaultSeverity ?? base.defaultSeverity,
+    });
+}

package/dist/types/index.d.ts

@@ -1,74 +1,68 @@
+export type TypeName = "string" | "number" | "boolean" | "date" | "array" | "tuple" | "object" | "union" | "any";
+/** The extra members a plugin contributes to its own message context. */
+export type MessageContextExtra = object;
+export interface MessageContext {
+    readonly path: string;
+    readonly value: unknown;
+    readonly code: string;
+}
+export type MessageFactory<C extends MessageContextExtra = MessageContextExtra> = (context: MessageContext & C) => string;
 /**
- * Minimal type definitions - only exports actually used in the codebase
- * Optimized for bundle size by removing unused complex type definitions
- */
-import { NestedKeyOf, TypeOfPath, ElementType } from "./util";
-import { Result, LuqValidationException } from "./result";
-export { Result, LuqValidationException };
-/**
- * Validation result interface - used in builder/types.ts
- */
-export type ValidationResult<T> = {
-    valid: boolean;
-    value: T | null;
-    errors: ValidationError[];
-    originalValue?: T;
-};
-/**
- * Validation error interface - used in plugin-registry.ts
- */
-export type ValidationError = {
-    path: string;
-    message: string;
-    code: string;
-    paths(): string[];
-};
-/**
- * Message factory type - used in reporter.ts and plugin/types.ts
- * Import from plugin/types for consistent definition
- */
-import type { MessageFactory } from "../core/plugin/types";
-export type { MessageFactory };
-/**
- * Validation options - used in registry and plugin-types
- */
-export type ValidationOptions = {
-    /** Abort validation on first error (default: true) */
-    abortEarly?: boolean;
-    /** Abort validation on each field's first error (default: true) */
-    abortEarlyOnEachField?: boolean;
-    /** Custom message factory for error messages */
-    messageFactory?: MessageFactory;
-    /** Translation function for i18n support */
-    translate?: (key: string, params?: Record<string, any>) => string;
-    /** Context data passed to validators */
-    context?: Record<string, any>;
-};
-/**
- * Parse options - used in registry and plugin-types
+ * User decision 8 keeps severity. The legacy three-level SEVERITY
+ * (INFO / WARN / ERROR) is carried over verbatim in meaning, spelled
+ * lower-case to match every other string vocabulary in L0.
  */
-export type ParseOptions = {
-    /** Abort parsing on first error (default: true) */
-    abortEarly?: boolean;
-    /** Abort parsing on each field's first error (default: true) */
-    abortEarlyOnEachField?: boolean;
-    /** Custom message factory for error messages */
-    messageFactory?: MessageFactory;
-    /** Translation function for i18n support */
-    translate?: (key: string, params?: Record<string, any>) => string;
-    /** Context data passed to validators */
-    context?: Record<string, any>;
-    /** Custom transform functions for post-processing */
-    transforms?: Record<string, (value: any) => any>;
+export type IssueSeverity = "error" | "warning" | "info";
+export interface RuleOptions<C extends MessageContextExtra = MessageContextExtra> {
+    readonly code?: string;
+    readonly messageFactory?: MessageFactory<C>;
+    /** Per-call override. Legacy ValidationOptions.severity, same meaning. */
+    readonly severity?: IssueSeverity;
+}
+export interface ValidationIssue {
+    readonly path: string;
+    readonly code: string;
+    readonly message: string;
+    /** Never optional: the chain resolves it once at build time, so a reader
+     *  never has to re-implement the "absent means error" fallback. */
+    readonly severity: IssueSeverity;
+}
+/** branch / index / causes let a composite failure explain itself. */
+export interface IssueDetail {
+    readonly expected?: unknown;
+    readonly actual?: unknown;
+    readonly branch?: string;
+    readonly index?: number;
+    readonly causes?: readonly ValidationIssue[];
+}
+export type CheckOutcome = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly detail: IssueDetail;
 };
-export { NestedKeyOf, TypeOfPath, ElementType };
-/**
- * Union to intersection utility type - used in plugin/types.ts
- */
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/**
- * Validator interface - simplified version for compatibility
- */
-export interface Validator<T> {
-    validate(value: unknown): ValidationResult<T>;
+export declare const PASS: CheckOutcome;
+export declare function fail(detail: IssueDetail): CheckOutcome;
+export interface ArrayItemContext {
+    readonly index: number;
+    readonly item: unknown;
+    readonly array: readonly unknown[];
+}
+export interface RuleContext {
+    readonly root: unknown;
+    readonly path: string;
+    readonly item?: ArrayItemContext;
+    /** The ONE channel a pre-resolved async context arrives on. */
+    readonly external?: Readonly<Record<string, unknown>>;
+}
+/** L0 keeps only the two presence flags. L3 extends it with guard coverage. */
+export interface PresenceState {
+    readonly undefinedAllowed: boolean;
+    readonly nullAllowed: boolean;
 }
+export type Present<T, S extends PresenceState> = Exclude<T, (S["undefinedAllowed"] extends false ? undefined : never) | (S["nullAllowed"] extends false ? null : never)>;
+export declare function isString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function isArray(value: unknown): value is readonly unknown[];
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isStringArray(value: unknown): value is readonly string[];

package/dist/types/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PASS = void 0;
+exports.fail = fail;
+exports.isString = isString;
+exports.isNumber = isNumber;
+exports.isArray = isArray;
+exports.isPlainObject = isPlainObject;
+exports.isStringArray = isStringArray;
+exports.PASS = { ok: true };
+function fail(detail) {
+    return { ok: false, detail };
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function isNumber(value) {
+    return typeof value === "number";
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return isArray(value) && value.every(isString);
+}

package/dist/types/index.mjs

@@ -0,0 +1,19 @@
+export const PASS = { ok: true };
+export function fail(detail) {
+    return { ok: false, detail };
+}
+export function isString(value) {
+    return typeof value === "string";
+}
+export function isNumber(value) {
+    return typeof value === "number";
+}
+export function isArray(value) {
+    return Array.isArray(value);
+}
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isStringArray(value) {
+    return isArray(value) && value.every(isString);
+}

package/dist/types/validation-result.types.d.ts

@@ -0,0 +1,22 @@
+import type { ValidationIssue } from "./index";
+export interface ValidationSuccess<T> {
+    readonly valid: true;
+    readonly data: T;
+    readonly issues: readonly ValidationIssue[];
+}
+export interface ValidationRejection {
+    readonly valid: false;
+    readonly issues: readonly ValidationIssue[];
+}
+/** Narrows on `valid` with no cast: `data` exists only on the success branch. */
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationRejection;
+/**
+ * The second argument of validate() / parse(). `external` is the ONE channel a
+ * pre-resolved async context arrives on; see l9-async-validator.ts. It lands in
+ * RuleContext.external unchanged, so L5 needs no async-specific branch.
+ */
+export interface ValidateOptions {
+    readonly abortEarly?: boolean;
+    readonly abortEarlyOnEachField?: boolean;
+    readonly external?: Readonly<Record<string, unknown>>;
+}

package/dist/types/validation-result.types.js

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

package/dist/types/validation-result.types.mjs

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