@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/plugins/write-only/write-only.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeOnlyPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/write-only/write-only.ts
+// JSON Schema's writeOnly as an access check: on a READ, a write-only field
+// (a password, a secret) may not carry a value.
+//
+// The peer of src/plugins/read-only/. 1.x kept both in one file and published
+// only readOnly; two directories, two symbols and two subpaths is the fix
+// recorded in docs/legacy-spec/public-api-surface.md. The two do not share a
+// module on purpose: a plugin may import only plugin-kit, types, path and its
+// OWN directory, and that isolation is checked in CI.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const external_context_1 = require("../../plugin-kit/external-context");
+const ACCESS_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "object",
+];
+/** 1.x's default when the context says nothing is "write", so read is opt-in. */
+function isReadOperation(context) {
+    return context["operation"] === "read";
+}
+exports.writeOnlyPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "writeOnly",
+    method: "writeOnly",
+    slots: ACCESS_SLOTS,
+    build: (ctx) => (0, create_rule_1.check)({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, runCtx) => {
+            const external = (0, external_context_1.readExternalContext)(runCtx, types_1.isPlainObject);
+            if (external === undefined || !isReadOperation(external))
+                return types_1.PASS;
+            return value === undefined ? types_1.PASS : (0, types_1.fail)({ actual: value });
+        },
+        describe: (_detail, msgCtx) => `${msgCtx.path} is write-only and cannot be read`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/write-only/write-only.mjs

@@ -0,0 +1,45 @@
+// ===========================================================================
+// L7  src/plugins/write-only/write-only.ts
+// JSON Schema's writeOnly as an access check: on a READ, a write-only field
+// (a password, a secret) may not carry a value.
+//
+// The peer of src/plugins/read-only/. 1.x kept both in one file and published
+// only readOnly; two directories, two symbols and two subpaths is the fix
+// recorded in docs/legacy-spec/public-api-surface.md. The two do not share a
+// module on purpose: a plugin may import only plugin-kit, types, path and its
+// OWN directory, and that isolation is checked in CI.
+// ===========================================================================
+import { PASS, fail, isPlainObject } from "../../types/index.mjs";
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+import { readExternalContext } from "../../plugin-kit/external-context.mjs";
+const ACCESS_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "array",
+    "object",
+];
+/** 1.x's default when the context says nothing is "write", so read is opt-in. */
+function isReadOperation(context) {
+    return context["operation"] === "read";
+}
+export const writeOnlyPlugin = /*#__PURE__*/ definePlugin()({
+    name: "writeOnly",
+    method: "writeOnly",
+    slots: ACCESS_SLOTS,
+    build: (ctx) => check({
+        code: ctx.code,
+        messageFactory: ctx.messageFactory,
+        severity: ctx.severity,
+        run: (value, runCtx) => {
+            const external = readExternalContext(runCtx, isPlainObject);
+            if (external === undefined || !isReadOperation(external))
+                return PASS;
+            return value === undefined ? PASS : fail({ actual: value });
+        },
+        describe: (_detail, msgCtx) => `${msgCtx.path} is write-only and cannot be read`,
+        buildMessageContext: () => ({}),
+    }),
+});

package/dist/plugins/writeOnly.d.ts

@@ -0,0 +1 @@
+export * from "./write-only/index";

package/dist/plugins/writeOnly.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./write-only/index");

package/dist/plugins/writeOnly.mjs

@@ -0,0 +1 @@
+export * from "./write-only/index.mjs";

package/dist/result/index.d.ts

@@ -0,0 +1,18 @@
+import type { ValidationIssue } from "../types";
+import type { ValidationRejection, ValidationResult, ValidationSuccess } from "../types/validation-result.types";
+export type { ValidationRejection, ValidationResult, ValidationSuccess, } from "../types/validation-result.types";
+/** The one array every issue-free result shares. Frozen, so sharing is safe. */
+export declare const EMPTY_ISSUES: readonly ValidationIssue[];
+export declare function ok<T>(value: T, issues?: readonly ValidationIssue[]): ValidationSuccess<T>;
+export declare function reject(issues: readonly ValidationIssue[]): ValidationRejection;
+export declare function isOk<T>(result: ValidationResult<T>): result is ValidationSuccess<T>;
+/**
+ * An Error that CARRIES the issues rather than flattening them into a string,
+ * so a catch block can still inspect paths and codes.
+ */
+export declare class ValidationFailure extends Error {
+    readonly issues: readonly ValidationIssue[];
+    constructor(issues: readonly ValidationIssue[]);
+}
+/** The success value, or a thrown ValidationFailure carrying the issues. */
+export declare function unwrap<T>(result: ValidationResult<T>): T;

package/dist/result/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationFailure = exports.EMPTY_ISSUES = void 0;
+exports.ok = ok;
+exports.reject = reject;
+exports.isOk = isOk;
+exports.unwrap = unwrap;
+/** The one array every issue-free result shares. Frozen, so sharing is safe. */
+exports.EMPTY_ISSUES = Object.freeze([]);
+function ok(value, issues = exports.EMPTY_ISSUES) {
+    return { valid: true, data: value, issues };
+}
+function reject(issues) {
+    return { valid: false, issues };
+}
+function isOk(result) {
+    return result.valid;
+}
+/** One line per issue, so a thrown failure is readable without unpacking it. */
+function describeIssues(issues) {
+    if (issues.length === 0)
+        return "Validation failed";
+    return issues
+        .map((issue) => `${issue.path}: ${issue.message} (${issue.code})`)
+        .join("\n");
+}
+/**
+ * An Error that CARRIES the issues rather than flattening them into a string,
+ * so a catch block can still inspect paths and codes.
+ */
+class ValidationFailure extends Error {
+    constructor(issues) {
+        super(describeIssues(issues));
+        this.name = "ValidationFailure";
+        this.issues = issues;
+    }
+}
+exports.ValidationFailure = ValidationFailure;
+/** The success value, or a thrown ValidationFailure carrying the issues. */
+function unwrap(result) {
+    if (result.valid)
+        return result.data;
+    throw new ValidationFailure(result.issues);
+}

package/dist/result/index.mjs

@@ -0,0 +1,36 @@
+/** The one array every issue-free result shares. Frozen, so sharing is safe. */
+export const EMPTY_ISSUES = Object.freeze([]);
+export function ok(value, issues = EMPTY_ISSUES) {
+    return { valid: true, data: value, issues };
+}
+export function reject(issues) {
+    return { valid: false, issues };
+}
+export function isOk(result) {
+    return result.valid;
+}
+/** One line per issue, so a thrown failure is readable without unpacking it. */
+function describeIssues(issues) {
+    if (issues.length === 0)
+        return "Validation failed";
+    return issues
+        .map((issue) => `${issue.path}: ${issue.message} (${issue.code})`)
+        .join("\n");
+}
+/**
+ * An Error that CARRIES the issues rather than flattening them into a string,
+ * so a catch block can still inspect paths and codes.
+ */
+export class ValidationFailure extends Error {
+    constructor(issues) {
+        super(describeIssues(issues));
+        this.name = "ValidationFailure";
+        this.issues = issues;
+    }
+}
+/** The success value, or a thrown ValidationFailure carrying the issues. */
+export function unwrap(result) {
+    if (result.valid)
+        return result.data;
+    throw new ValidationFailure(result.issues);
+}

package/dist/result.d.ts

@@ -0,0 +1 @@
+export * from "./result/index";

package/dist/result.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./result/index");

package/dist/result.mjs

@@ -0,0 +1 @@
+export * from "./result/index.mjs";

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

@@ -0,0 +1,12 @@
+import type { ValidateOptions, ValidationResult } from "../types/validation-result.types";
+import type { ValidationPlan } from "../compile/validation-plan.types";
+/**
+ * `siblings` is legacy's `allValues?: Partial<T>`: the rest of the object, so a
+ * cross-field rule declared on this path can still read what it compares
+ * against.
+ */
+export interface PlanFieldValidator {
+    readonly path: string;
+    validate(value: unknown, siblings?: object, options?: ValidateOptions): ValidationResult<unknown>;
+}
+export declare function createFieldValidator(plan: ValidationPlan, path: string): PlanFieldValidator;

package/dist/runtime/create-field-validator.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFieldValidator = createFieldValidator;
+// ===========================================================================
+// L5  src/runtime/create-field-validator.ts
+// `pick("user.email")` executed: one declared path, validated on its own, on
+// the same plan and the same engine.
+//
+// The legacy implementation built `{ [key]: value }`, ran the whole validator
+// over it and filtered the errors by a RegExp compiled from the path string on
+// every call. Two things go wrong there and both are fixed here: a wildcard
+// path such as `employees[*].name` had no object shape to put the value into,
+// and the caller's `abortEarly` could stop the run at an unrelated field so the
+// picked field was never reached.
+//
+// So: the subject shape is composed ONCE at build time — a copy-on-write write
+// for a plain path, a nested wrapper for a wildcard one — the run always
+// collects every field, and the issues are then matched against the declared
+// pattern by the ONE matcher, which parses rather than compiles a RegExp.
+// ===========================================================================
+const types_1 = require("../types");
+const create_value_writer_1 = require("../path/create-value-writer");
+const match_path_pattern_1 = require("../path/match-path-pattern");
+const parse_field_path_1 = require("../path/parse-field-path");
+const create_validator_1 = require("./create-validator");
+function createFieldValidator(plan, path) {
+    const template = (0, parse_field_path_1.parseFieldPath)(path);
+    const compose = createSubjectComposer(template);
+    const validator = (0, create_validator_1.createValidator)(plan);
+    return {
+        path,
+        validate(value, siblings, options) {
+            const outcome = validator.validate(compose(siblings, value), {
+                ...options,
+                abortEarly: false,
+            });
+            const issues = Object.freeze(outcome.issues.filter((issue) => (0, match_path_pattern_1.matchPathPattern)(path, issue.path)));
+            if ((0, create_validator_1.hasRejectingIssue)(issues))
+                return { valid: false, issues };
+            return { valid: true, data: value, issues };
+        },
+    };
+}
+/**
+ * A wildcard-free path writes into the siblings copy-on-write, so every other
+ * declared field keeps whatever the caller supplied for it.
+ *
+ * A wildcard path cannot: `employees[*].name` names one member of every
+ * element, and there is no such place in an arbitrary object. The value is
+ * wrapped into the minimal structure the pattern describes — a ONE-element
+ * array at each `[*]` — which makes the issue come back as `employees[0].name`
+ * and match the pattern it was picked by.
+ */
+function createSubjectComposer(template) {
+    if (!template.some((segment) => segment.kind === "each")) {
+        const write = (0, create_value_writer_1.createValueWriter)(template);
+        return (siblings, value) => write(siblings ?? {}, value);
+    }
+    return (siblings, value) => mergeOntoSiblings(siblings, nestValue(template, 0, value));
+}
+function nestValue(template, from, value) {
+    const segment = template[from];
+    if (segment === undefined)
+        return value;
+    if (segment.kind === "each")
+        return [nestValue(template, from + 1, value)];
+    return { [segment.key]: nestValue(template, from + 1, value) };
+}
+/** The wrapper wins on the key it names; every other sibling survives. */
+function mergeOntoSiblings(siblings, fragment) {
+    if (siblings === undefined || !(0, types_1.isPlainObject)(fragment))
+        return fragment;
+    return { ...siblings, ...fragment };
+}

package/dist/runtime/create-field-validator.mjs

@@ -0,0 +1,71 @@
+// ===========================================================================
+// L5  src/runtime/create-field-validator.ts
+// `pick("user.email")` executed: one declared path, validated on its own, on
+// the same plan and the same engine.
+//
+// The legacy implementation built `{ [key]: value }`, ran the whole validator
+// over it and filtered the errors by a RegExp compiled from the path string on
+// every call. Two things go wrong there and both are fixed here: a wildcard
+// path such as `employees[*].name` had no object shape to put the value into,
+// and the caller's `abortEarly` could stop the run at an unrelated field so the
+// picked field was never reached.
+//
+// So: the subject shape is composed ONCE at build time — a copy-on-write write
+// for a plain path, a nested wrapper for a wildcard one — the run always
+// collects every field, and the issues are then matched against the declared
+// pattern by the ONE matcher, which parses rather than compiles a RegExp.
+// ===========================================================================
+import { isPlainObject } from "../types/index.mjs";
+import { createValueWriter } from "../path/create-value-writer.mjs";
+import { matchPathPattern } from "../path/match-path-pattern.mjs";
+import { parseFieldPath } from "../path/parse-field-path.mjs";
+import { createValidator, hasRejectingIssue } from "./create-validator.mjs";
+export function createFieldValidator(plan, path) {
+    const template = parseFieldPath(path);
+    const compose = createSubjectComposer(template);
+    const validator = createValidator(plan);
+    return {
+        path,
+        validate(value, siblings, options) {
+            const outcome = validator.validate(compose(siblings, value), {
+                ...options,
+                abortEarly: false,
+            });
+            const issues = Object.freeze(outcome.issues.filter((issue) => matchPathPattern(path, issue.path)));
+            if (hasRejectingIssue(issues))
+                return { valid: false, issues };
+            return { valid: true, data: value, issues };
+        },
+    };
+}
+/**
+ * A wildcard-free path writes into the siblings copy-on-write, so every other
+ * declared field keeps whatever the caller supplied for it.
+ *
+ * A wildcard path cannot: `employees[*].name` names one member of every
+ * element, and there is no such place in an arbitrary object. The value is
+ * wrapped into the minimal structure the pattern describes — a ONE-element
+ * array at each `[*]` — which makes the issue come back as `employees[0].name`
+ * and match the pattern it was picked by.
+ */
+function createSubjectComposer(template) {
+    if (!template.some((segment) => segment.kind === "each")) {
+        const write = createValueWriter(template);
+        return (siblings, value) => write(siblings ?? {}, value);
+    }
+    return (siblings, value) => mergeOntoSiblings(siblings, nestValue(template, 0, value));
+}
+function nestValue(template, from, value) {
+    const segment = template[from];
+    if (segment === undefined)
+        return value;
+    if (segment.kind === "each")
+        return [nestValue(template, from + 1, value)];
+    return { [segment.key]: nestValue(template, from + 1, value) };
+}
+/** The wrapper wins on the key it names; every other sibling survives. */
+function mergeOntoSiblings(siblings, fragment) {
+    if (siblings === undefined || !isPlainObject(fragment))
+        return fragment;
+    return { ...siblings, ...fragment };
+}

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

@@ -0,0 +1,24 @@
+import type { IssueSeverity, MessageContext, ValidationIssue } from "../types";
+export interface IssueRequest {
+    /** Already rendered against the index stack: `items[0].name`, never `[*]`. */
+    readonly path: string;
+    readonly code: string;
+    readonly severity: IssueSeverity;
+    /** The value that failed; the plugin reads it on MessageContext.value. */
+    readonly value: unknown;
+    /**
+     * Binds the failing rule to its detail. A check closes over the
+     * `IssueDetail` its `run` returned — expected / actual / branch / index /
+     * causes — and a presence policy closes over nothing; either way this layer
+     * sees one call shape and needs no rule kind to dispatch on.
+     */
+    render(context: MessageContext): string;
+}
+/**
+ * A plugin whose message factory throws must not take the validation down
+ * with it: the failure being reported is the user's data, not the plugin's
+ * formatting. The legacy contract is the same, and the wording is carried
+ * over verbatim.
+ */
+export declare function renderFallbackMessage(path: string): string;
+export declare function createIssue(request: IssueRequest): ValidationIssue;

package/dist/runtime/create-issue.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFallbackMessage = renderFallbackMessage;
+exports.createIssue = createIssue;
+/**
+ * A plugin whose message factory throws must not take the validation down
+ * with it: the failure being reported is the user's data, not the plugin's
+ * formatting. The legacy contract is the same, and the wording is carried
+ * over verbatim.
+ */
+function renderFallbackMessage(path) {
+    return `Validation failed for ${path}`;
+}
+function createIssue(request) {
+    const context = {
+        path: request.path,
+        value: request.value,
+        code: request.code,
+    };
+    return Object.freeze({
+        path: request.path,
+        code: request.code,
+        message: renderMessageOrFallback(request, context),
+        severity: request.severity,
+    });
+}
+function renderMessageOrFallback(request, context) {
+    try {
+        return request.render(context);
+    }
+    catch {
+        return renderFallbackMessage(request.path);
+    }
+}

package/dist/runtime/create-issue.mjs

@@ -0,0 +1,30 @@
+/**
+ * A plugin whose message factory throws must not take the validation down
+ * with it: the failure being reported is the user's data, not the plugin's
+ * formatting. The legacy contract is the same, and the wording is carried
+ * over verbatim.
+ */
+export function renderFallbackMessage(path) {
+    return `Validation failed for ${path}`;
+}
+export function createIssue(request) {
+    const context = {
+        path: request.path,
+        value: request.value,
+        code: request.code,
+    };
+    return Object.freeze({
+        path: request.path,
+        code: request.code,
+        message: renderMessageOrFallback(request, context),
+        severity: request.severity,
+    });
+}
+function renderMessageOrFallback(request, context) {
+    try {
+        return request.render(context);
+    }
+    catch {
+        return renderFallbackMessage(request.path);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { ValidationIssue } from "../types";
+import type { ValidateOptions, ValidationResult } from "../types/validation-result.types";
+import type { ValidationPlan } from "../compile/validation-plan.types";
+/** The untyped pair. L6 puts the declared type back on top of it. */
+export interface PlanValidator {
+    validate(value: unknown, options?: ValidateOptions): ValidationResult<unknown>;
+    parse(value: unknown, options?: ValidateOptions): ValidationResult<unknown>;
+}
+/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
+export declare const ROOT_MISSING_CODE = "REQUIRED";
+export declare const ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * Severity decides validity, and nothing else does. An `info` or `warning`
+ * issue is still an issue — the sink counted it and abortEarly saw it — but it
+ * does not reject the value, which is the only reason ValidationSuccess carries
+ * an `issues` list at all.
+ */
+export declare function hasRejectingIssue(issues: readonly ValidationIssue[]): boolean;
+export declare function createValidator(plan: ValidationPlan): PlanValidator;

package/dist/runtime/create-validator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_MISSING_MESSAGE = exports.ROOT_MISSING_CODE = void 0;
+exports.hasRejectingIssue = hasRejectingIssue;
+exports.createValidator = createValidator;
+const index_stack_1 = require("./index-stack");
+const issue_sink_1 = require("./issue-sink");
+const output_writer_1 = require("./output-writer");
+const run_recursion_1 = require("./run-recursion");
+const run_plan_1 = require("./run-plan");
+/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
+exports.ROOT_MISSING_CODE = "REQUIRED";
+exports.ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * A null or undefined subject fails before the plan runs. Without it every
+ * reader would answer `undefined`, OPEN_PRESENCE would permit every absence,
+ * and `validate(null)` would report success for a schema that declares nothing
+ * required.
+ */
+function rejectMissingRoot() {
+    return {
+        valid: false,
+        issues: Object.freeze([
+            Object.freeze({
+                path: "",
+                code: exports.ROOT_MISSING_CODE,
+                message: exports.ROOT_MISSING_MESSAGE,
+                severity: "error",
+            }),
+        ]),
+    };
+}
+/**
+ * Severity decides validity, and nothing else does. An `info` or `warning`
+ * issue is still an issue — the sink counted it and abortEarly saw it — but it
+ * does not reject the value, which is the only reason ValidationSuccess carries
+ * an `issues` list at all.
+ */
+function hasRejectingIssue(issues) {
+    return issues.some((issue) => issue.severity === "error");
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+    if (value === null || value === undefined)
+        return rejectMissingRoot();
+    const sink = new issue_sink_1.IssueSink((0, issue_sink_1.resolveAbortPolicy)(options));
+    const output = (0, run_plan_1.runPlan)(plan, value, {
+        root: value,
+        sink,
+        indices: new index_stack_1.IndexStack(),
+        shouldApplyTransforms,
+        runRecursion: (0, run_recursion_1.createRecursionRunner)({
+            root: value,
+            sink,
+            external: options?.external,
+        }),
+        external: options?.external,
+    }, targets);
+    const issues = Object.freeze(sink.issues);
+    if (hasRejectingIssue(issues))
+        return { valid: false, issues };
+    return { valid: true, data: output, issues };
+}
+function createValidator(plan) {
+    const parseTargets = (0, output_writer_1.createPlanWriteTargets)(plan);
+    const shouldWriteOutput = parseTargets !== null;
+    return {
+        validate: (value, options) => runRoot(plan, value, options, output_writer_1.NO_WRITE_TARGETS, false),
+        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput),
+    };
+}

package/dist/runtime/create-validator.mjs

@@ -0,0 +1,65 @@
+import { IndexStack } from "./index-stack.mjs";
+import { IssueSink, resolveAbortPolicy } from "./issue-sink.mjs";
+import { NO_WRITE_TARGETS, createPlanWriteTargets } from "./output-writer.mjs";
+import { createRecursionRunner } from "./run-recursion.mjs";
+import { runPlan } from "./run-plan.mjs";
+/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
+export const ROOT_MISSING_CODE = "REQUIRED";
+export const ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * A null or undefined subject fails before the plan runs. Without it every
+ * reader would answer `undefined`, OPEN_PRESENCE would permit every absence,
+ * and `validate(null)` would report success for a schema that declares nothing
+ * required.
+ */
+function rejectMissingRoot() {
+    return {
+        valid: false,
+        issues: Object.freeze([
+            Object.freeze({
+                path: "",
+                code: ROOT_MISSING_CODE,
+                message: ROOT_MISSING_MESSAGE,
+                severity: "error",
+            }),
+        ]),
+    };
+}
+/**
+ * Severity decides validity, and nothing else does. An `info` or `warning`
+ * issue is still an issue — the sink counted it and abortEarly saw it — but it
+ * does not reject the value, which is the only reason ValidationSuccess carries
+ * an `issues` list at all.
+ */
+export function hasRejectingIssue(issues) {
+    return issues.some((issue) => issue.severity === "error");
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+    if (value === null || value === undefined)
+        return rejectMissingRoot();
+    const sink = new IssueSink(resolveAbortPolicy(options));
+    const output = runPlan(plan, value, {
+        root: value,
+        sink,
+        indices: new IndexStack(),
+        shouldApplyTransforms,
+        runRecursion: createRecursionRunner({
+            root: value,
+            sink,
+            external: options?.external,
+        }),
+        external: options?.external,
+    }, targets);
+    const issues = Object.freeze(sink.issues);
+    if (hasRejectingIssue(issues))
+        return { valid: false, issues };
+    return { valid: true, data: output, issues };
+}
+export function createValidator(plan) {
+    const parseTargets = createPlanWriteTargets(plan);
+    const shouldWriteOutput = parseTargets !== null;
+    return {
+        validate: (value, options) => runRoot(plan, value, options, NO_WRITE_TARGETS, false),
+        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput),
+    };
+}

package/dist/runtime/decide-presence.d.ts

@@ -0,0 +1,5 @@
+import type { RuleContext } from "../types";
+import type { CompiledField } from "../compile/validation-plan.types";
+import type { IssueSink } from "./issue-sink";
+/** True when the field should go on to its gates, checks and transforms. */
+export declare function decidePresence(field: CompiledField, value: unknown, ruleContext: RuleContext, sink: IssueSink): boolean;