@aventara/core 1.0.0-rc.0 → 1.0.0-rc.1

package/dist/runtime/error-boundary.js

@@ -1,5 +1,5 @@
 import { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } from "../operations/validation-code.js";
-import { FrameworkError } from "./framework-error.js";
+import { AvError } from "./framework-error.js";
 import { INTERNAL_FAILURE_MESSAGE, internalFailure, OPERATION_CODES, operationFailure, } from "./operation-response.js";
 import { PIPE_OUTPUT_FAILURE_MESSAGE } from "./pipe-output.validator.js";
 export const ADAPTER_FAILURE_MESSAGE = "Adapter execution failed.";
@@ -207,7 +207,7 @@ function readProperty(value, key) {
 }
 function isFrameworkErrorInstance(error) {
     try {
-        return error instanceof FrameworkError;
+        return error instanceof AvError;
     }
     catch {
         return false;
@@ -269,24 +269,50 @@ export function sanitizeOperationFailure(error, origin, report, view) {
     }
     return deliberateFailure(outcome);
 }
-export async function resolveOperationFailure(error, filters, context, boundary, report, view) {
-    for (let index = filters.length - 1; index >= 0; index -= 1) {
-        const filter = filters[index];
-        if (filter === undefined) {
-            continue;
-        }
-        const handled = await attemptFilter(filter, error, context, view, boundary);
-        if (handled !== undefined) {
-            if (handled.outcome === MALFORMED_OUTCOME) {
-                report(error, "A3000");
-            }
-            else {
-                reportDeliberate(handled.returned, handled.outcome, report);
-            }
-            return deliberateFailure(handled.outcome);
-        }
+export async function resolveOperationFailure(error, filters, context, boundary, report, view, outer) {
+    const failure = { error, view, boundary, report };
+    const handled = await filterChain(filters, context).attempt(error, view, boundary);
+    if (handled !== undefined) {
+        return answerHandled(failure, handled);
+    }
+    return outer === undefined
+        ? sanitizeUnhandled(failure)
+        : outer.defer(failure);
+}
+function answerHandled(failure, handled) {
+    if (handled.outcome === MALFORMED_OUTCOME) {
+        failure.report(failure.error, "A3000");
+    }
+    else {
+        reportDeliberate(handled.returned, handled.outcome, failure.report);
     }
-    return sanitizeOperationFailure(error, boundary.originOf(error), report, view);
+    return deliberateFailure(handled.outcome);
+}
+function sanitizeUnhandled(failure) {
+    return sanitizeOperationFailure(failure.error, failure.boundary.originOf(failure.error), failure.report, failure.view);
+}
+export async function resolveUnhandledFailure(failure, chain) {
+    const handled = await chain.attempt(failure.error, failure.view, failure.boundary);
+    return handled === undefined
+        ? sanitizeUnhandled(failure)
+        : answerHandled(failure, handled);
+}
+export function filterChain(filters, context) {
+    return {
+        attempt: async (error, view, boundary) => {
+            for (let index = filters.length - 1; index >= 0; index -= 1) {
+                const filter = filters[index];
+                if (filter === undefined) {
+                    continue;
+                }
+                const handled = await attemptFilter(filter, error, context, view, boundary);
+                if (handled !== undefined) {
+                    return handled;
+                }
+            }
+            return undefined;
+        },
+    };
 }
 async function attemptFilter(filter, error, context, view, boundary) {
     try {

package/dist/runtime/execution-options.d.ts

@@ -1,13 +1,21 @@
+import type { AvState } from "./request-state.js";
 /**
  * Options for one in-process call: the optional second argument of every
  * `framework.application.*` / `framework.client.*` call and of
  * `framework.transaction`.
  */
-export type ExecutionOptions = {
+export type AvExecutionOptions = {
     /**
      * The id every pipeline context and every diagnostic of this call or run
-     * carries — a correlation id the caller already holds. Omitted, the Framework
+     * carries, such as a correlation id the caller already holds. Omitted, the Framework
      * mints one; the empty string counts as omitted.
      */
     readonly requestId?: string;
+    /**
+     * The call's or run's `ctx.$state`: the one object every stage of it, and
+     * every ctx call those stages make, reads and writes. It is used as it is, not
+     * copied, so the caller sees what the stages wrote. Omitted (or not an
+     * object), the Framework starts the request with `{}`.
+     */
+    readonly state?: AvState & object;
 };

package/dist/runtime/field-check.evaluator.d.ts

@@ -0,0 +1,29 @@
+import type { AvFieldCheck } from "../contracts/field-check.js";
+import type { AvValidationIssue } from "../operations/validation-code.js";
+/** What a check judges: the runtime form of the value it is given. */
+export type FieldCheckSubject = "string" | "number" | "bigint" | "decimal" | "datetime" | "bytes";
+/**
+ * What a check judges on a field of each scalar type that takes checks; a field
+ * of any other type (an enum's) holds a string.
+ */
+export declare const FIELD_CHECK_SUBJECTS: Readonly<Record<string, FieldCheckSubject>>;
+type Path = readonly (string | number)[];
+/**
+ * Whether `value` passes `check`; `true` for a value the check does not judge
+ * (a value of another form, which validation refused before the checks run).
+ */
+export declare function passesFieldCheck(check: AvFieldCheck, value: unknown, subject: FieldCheckSubject): boolean;
+/** The issue of one failed check at `path`: its V-code, zod's check and its parameters. */
+export declare function fieldCheckIssue(check: AvFieldCheck, subject: FieldCheckSubject, path: Path): AvValidationIssue;
+/**
+ * The issues of the checks `value` breaks, one per broken check, in the checks'
+ * order. On a list (`list`), a `list: true` length check judges the list at
+ * `path` and every other check judges each entry, at its index; `null` is no
+ * value and breaks nothing.
+ */
+export declare function fieldCheckIssues(checks: readonly AvFieldCheck[], value: unknown, subject: FieldCheckSubject, path: Path, list: boolean): readonly AvValidationIssue[];
+/** The issues of the checks one value — a whole value, or a list's entry — breaks. */
+export declare function entryCheckIssues(checks: readonly AvFieldCheck[], value: unknown, subject: FieldCheckSubject, path: Path): readonly AvValidationIssue[];
+/** Whether a check judges a list's own length (`AvZ.minItems`/`AvZ.maxItems`). */
+export declare function isListCheck(check: AvFieldCheck): boolean;
+export {};

package/dist/runtime/field-check.evaluator.js

@@ -0,0 +1,521 @@
+export const FIELD_CHECK_SUBJECTS = {
+    string: "string",
+    int: "number",
+    float: "number",
+    bigint: "bigint",
+    decimal: "decimal",
+    datetime: "datetime",
+    bytes: "bytes",
+};
+const DATE_SOURCE = "(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))";
+const HHMM = "(?:[01]\\d|2[0-3]):[0-5]\\d";
+const IPV6_ALPHABET = /^[0-9a-fA-F:.]+$/;
+const CREDIT_CARD = /^\d(?:[ -]?\d){11,18}$/;
+const IBAN = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
+const FORMAT_PATTERNS = {
+    email: /^(?:[A-Za-z0-9_'+-]+\.)*[A-Za-z0-9_'+-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/,
+    emoji: new RegExp("^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$", "u"),
+    uuid: /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/,
+    guid: /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/,
+    nanoid: /^[a-zA-Z0-9_-]{21}$/,
+    cuid: /^[cC][0-9a-z]{6,}$/,
+    cuid2: /^[0-9a-z]+$/,
+    ulid: /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/,
+    xid: /^[0-9a-vA-V]{20}$/,
+    ksuid: /^[A-Za-z0-9]{27}$/,
+    datetime: new RegExp(`^${DATE_SOURCE}T(?:${HHMM}:[0-5]\\d(?:\\.\\d+)?(?:Z))$`),
+    date: new RegExp(`^${DATE_SOURCE}$`),
+    time: new RegExp(`^${HHMM}(?::[0-5]\\d(?:\\.\\d+)?)?$`),
+    duration: /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/,
+    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+    cidrv4: /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/,
+    e164: /^\+[1-9]\d{6,14}$/,
+};
+const platform = globalThis;
+function canParseUrl(input) {
+    const Url = platform.URL;
+    if (Url === undefined) {
+        return false;
+    }
+    try {
+        if (typeof Url.canParse === "function") {
+            return Url.canParse(input);
+        }
+        new Url(input);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function decodeBase64(value) {
+    if (platform.atob === undefined) {
+        throw new TypeError("No atob is available here.");
+    }
+    return platform.atob(value);
+}
+function isIpv6(value) {
+    return IPV6_ALPHABET.test(value) && canParseUrl(`http://[${value}]`);
+}
+function isCidrv6(value) {
+    const parts = value.split("/");
+    if (parts.length !== 2) {
+        return false;
+    }
+    const [address, prefix] = parts;
+    const bits = Number(prefix);
+    return (prefix !== "" &&
+        `${bits}` === prefix &&
+        bits >= 0 &&
+        bits <= 128 &&
+        isIpv6(address));
+}
+function isBase64(value) {
+    if (value === "") {
+        return true;
+    }
+    if (/\s/.test(value) || value.length % 4 !== 0) {
+        return false;
+    }
+    try {
+        decodeBase64(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBase64Url(value) {
+    if (!/^[A-Za-z0-9_-]*$/.test(value)) {
+        return false;
+    }
+    const base64 = value.replace(/[-_]/g, (char) => (char === "-" ? "+" : "/"));
+    return isBase64(base64.padEnd(Math.ceil(base64.length / 4) * 4, "="));
+}
+function isLuhn(digits) {
+    let length = digits.length;
+    let bit = 1;
+    let sum = 0;
+    while (length) {
+        const value = digits.charCodeAt(--length) - 48;
+        bit ^= 1;
+        sum += bit ? ([0, 2, 4, 6, 8, 1, 3, 5, 7, 9][value] ?? 0) : value;
+    }
+    return sum % 10 === 0;
+}
+function isIbanChecksum(iban) {
+    let remainder = 0;
+    const step = (code) => {
+        remainder =
+            (code >= 65
+                ? remainder * 100 + (code - 55)
+                : remainder * 10 + (code - 48)) % 97;
+    };
+    for (let index = 4; index < iban.length; index += 1) {
+        step(iban.charCodeAt(index));
+    }
+    for (let index = 0; index < 4; index += 1) {
+        step(iban.charCodeAt(index));
+    }
+    return remainder === 1;
+}
+function isJwt(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3 || !parts[0]) {
+            return false;
+        }
+        const header = JSON.parse(decodeBase64(parts[0]));
+        if ("typ" in header && header.typ !== "JWT") {
+            return false;
+        }
+        return Boolean(header.alg);
+    }
+    catch {
+        return false;
+    }
+}
+function isJsonString(value) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function matchesFormat(format, value) {
+    switch (format) {
+        case "url":
+            return canParseUrl(value.trim());
+        case "ipv6":
+            return isIpv6(value);
+        case "cidrv6":
+            return isCidrv6(value);
+        case "base64":
+            return isBase64(value);
+        case "base64url":
+            return isBase64Url(value);
+        case "credit_card":
+            return CREDIT_CARD.test(value) && isLuhn(value.replace(/[- ]/g, ""));
+        case "iban":
+            return IBAN.test(value) && isIbanChecksum(value);
+        case "jwt":
+            return isJwt(value);
+        case "json_string":
+            return isJsonString(value);
+        default: {
+            return FORMAT_PATTERNS[format]?.test(value) === true;
+        }
+    }
+}
+const DECIMAL = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+function decimalParts(text) {
+    const match = DECIMAL.exec(text);
+    if (match === null) {
+        return undefined;
+    }
+    const [, sign, whole = "", fraction = "", power = "0"] = match;
+    const all = `${whole}${fraction}`;
+    const leading = all.length - all.replace(/^0+/, "").length;
+    const digits = all.slice(leading).replace(/0+$/, "");
+    if (digits === "") {
+        return { negative: false, digits: "", exponent: 0 };
+    }
+    return {
+        negative: sign === "-",
+        digits,
+        exponent: whole.length - 1 - leading + Number(power),
+    };
+}
+function compareDecimals(a, b) {
+    const signOf = (parts) => parts.digits === "" ? 0 : parts.negative ? -1 : 1;
+    if (signOf(a) !== signOf(b)) {
+        return Math.sign(signOf(a) - signOf(b));
+    }
+    if (signOf(a) === 0) {
+        return 0;
+    }
+    let magnitude = 0;
+    if (a.exponent !== b.exponent) {
+        magnitude = a.exponent > b.exponent ? 1 : -1;
+    }
+    else {
+        const width = Math.max(a.digits.length, b.digits.length);
+        const left = a.digits.padEnd(width, "0");
+        const right = b.digits.padEnd(width, "0");
+        magnitude = left === right ? 0 : left > right ? 1 : -1;
+    }
+    return a.negative ? -magnitude : magnitude;
+}
+function modPow(base, power, modulus) {
+    let result = BigInt(1) % modulus;
+    let factor = base % modulus;
+    let remaining = power;
+    while (remaining > 0) {
+        if (remaining % 2 === 1) {
+            result = (result * factor) % modulus;
+        }
+        factor = (factor * factor) % modulus;
+        remaining = Math.floor(remaining / 2);
+    }
+    return result;
+}
+function isDecimalMultiple(a, b) {
+    if (b.digits === "") {
+        return false;
+    }
+    if (a.digits === "") {
+        return true;
+    }
+    const scaleA = a.exponent - (a.digits.length - 1);
+    const scaleB = b.exponent - (b.digits.length - 1);
+    if (!Number.isSafeInteger(scaleA) || !Number.isSafeInteger(scaleB)) {
+        return false;
+    }
+    const mantissaA = BigInt(a.digits);
+    const mantissaB = BigInt(b.digits);
+    if (scaleA >= scaleB) {
+        return (((mantissaA % mantissaB) *
+            modPow(BigInt(10), scaleA - scaleB, mantissaB)) %
+            mantissaB ===
+            BigInt(0));
+    }
+    return false;
+}
+function floatRemainder(value, step) {
+    const ratio = value / step;
+    const rounded = Math.round(ratio);
+    const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
+    return Math.abs(ratio - rounded) < tolerance ? 0 : ratio - rounded;
+}
+function codePoints(value) {
+    let count = value.length;
+    for (let index = 0; index < value.length - 1; index += 1) {
+        if ((value.charCodeAt(index) & 0xfc00) === 0xd800 &&
+            (value.charCodeAt(index + 1) & 0xfc00) === 0xdc00) {
+            count -= 1;
+            index += 1;
+        }
+    }
+    return count;
+}
+const patterns = new WeakMap();
+function patternOf(check) {
+    let pattern = patterns.get(check);
+    if (pattern === undefined) {
+        pattern = new RegExp(check.pattern.source, check.pattern.flags);
+        patterns.set(check, pattern);
+    }
+    pattern.lastIndex = 0;
+    return pattern;
+}
+function passesFormat(check, value) {
+    switch (check.format) {
+        case "regex":
+            return patternOf(check).test(value);
+        case "includes":
+            return value.includes(check.includes);
+        case "starts_with":
+            return value.startsWith(check.prefix);
+        case "ends_with":
+            return value.endsWith(check.suffix);
+        case "lowercase":
+            return /^[^A-Z]*$/.test(value);
+        case "uppercase":
+            return /^[^a-z]*$/.test(value);
+        default:
+            return matchesFormat(check.format, value);
+    }
+}
+function compareToBound(value, bound, subject) {
+    switch (subject) {
+        case "number":
+            return typeof value === "number" && typeof bound === "number"
+                ? Math.sign(value - bound)
+                : undefined;
+        case "bigint": {
+            if (typeof value !== "bigint") {
+                return undefined;
+            }
+            const limit = BigInt(bound);
+            return value === limit ? 0 : value > limit ? 1 : -1;
+        }
+        case "decimal": {
+            const left = decimalParts(String(value));
+            const right = decimalParts(String(bound));
+            return left === undefined || right === undefined
+                ? undefined
+                : compareDecimals(left, right);
+        }
+        case "datetime":
+            return value instanceof Date
+                ? Math.sign(value.getTime() - Date.parse(String(bound)))
+                : undefined;
+        default:
+            return undefined;
+    }
+}
+function isMultiple(value, step, subject) {
+    switch (subject) {
+        case "number":
+            return typeof value === "number" && typeof step === "number"
+                ? floatRemainder(value, step) === 0
+                : undefined;
+        case "bigint": {
+            if (typeof value !== "bigint") {
+                return undefined;
+            }
+            const divisor = BigInt(step);
+            return divisor !== BigInt(0) && value % divisor === BigInt(0);
+        }
+        case "decimal": {
+            const left = decimalParts(String(value));
+            const right = decimalParts(String(step));
+            return left === undefined || right === undefined
+                ? undefined
+                : isDecimalMultiple(left, right);
+        }
+        default:
+            return undefined;
+    }
+}
+export function passesFieldCheck(check, value, subject) {
+    switch (check.check) {
+        case "less_than":
+        case "greater_than": {
+            const order = compareToBound(value, check.value, subject);
+            if (order === undefined) {
+                return true;
+            }
+            const signed = check.check === "less_than" ? -order : order;
+            return signed > 0 || (check.inclusive && signed === 0);
+        }
+        case "multiple_of":
+            return isMultiple(value, check.value, subject) ?? true;
+        case "max_length":
+        case "min_length":
+        case "length_equals": {
+            const length = Array.isArray(value)
+                ? value.length
+                : typeof value === "string"
+                    ? codePoints(value)
+                    : undefined;
+            if (length === undefined) {
+                return true;
+            }
+            return check.check === "max_length"
+                ? length <= check.maximum
+                : check.check === "min_length"
+                    ? length >= check.minimum
+                    : length === check.length;
+        }
+        case "string_format":
+            return typeof value === "string" ? passesFormat(check, value) : true;
+        case "max_size":
+        case "min_size":
+        case "size_equals": {
+            if (!(value instanceof Uint8Array)) {
+                return true;
+            }
+            const size = value.byteLength;
+            return check.check === "max_size"
+                ? size <= check.maximum
+                : check.check === "min_size"
+                    ? size >= check.minimum
+                    : size === check.size;
+        }
+    }
+}
+const FORMAT_LABELS = {
+    email: "an email address",
+    url: "a URL",
+    emoji: "emoji",
+    uuid: "a UUID",
+    guid: "a GUID",
+    nanoid: "a Nano ID",
+    cuid: "a CUID",
+    cuid2: "a CUID2",
+    ulid: "a ULID",
+    xid: "an XID",
+    ksuid: "a KSUID",
+    datetime: "an ISO 8601 date-time in UTC",
+    date: "an ISO 8601 date",
+    time: "an ISO 8601 time",
+    duration: "an ISO 8601 duration",
+    ipv4: "an IPv4 address",
+    ipv6: "an IPv6 address",
+    cidrv4: "an IPv4 CIDR block",
+    cidrv6: "an IPv6 CIDR block",
+    base64: "base64",
+    base64url: "base64url",
+    json_string: "a JSON string",
+    e164: "an E.164 phone number",
+    credit_card: "a credit card number",
+    iban: "an IBAN",
+    jwt: "a JWT",
+};
+function plural(count, one, many) {
+    return `${count} ${count === 1 ? one : many}`;
+}
+function formatMessage(check) {
+    switch (check.format) {
+        case "regex":
+            return `Value must match the pattern /${check.pattern.source}/${check.pattern.flags}.`;
+        case "includes":
+            return `Value must include ${JSON.stringify(check.includes)}.`;
+        case "starts_with":
+            return `Value must start with ${JSON.stringify(check.prefix)}.`;
+        case "ends_with":
+            return `Value must end with ${JSON.stringify(check.suffix)}.`;
+        case "lowercase":
+            return "Value must be lowercase.";
+        case "uppercase":
+            return "Value must be uppercase.";
+        default:
+            return `Value must be ${FORMAT_LABELS[check.format]}.`;
+    }
+}
+function boundMessage(check, subject) {
+    const bound = String(check.value);
+    if (subject === "datetime") {
+        return check.check === "less_than"
+            ? `Value must be ${check.inclusive ? "on or before" : "before"} ${bound}.`
+            : `Value must be ${check.inclusive ? "on or after" : "after"} ${bound}.`;
+    }
+    return check.check === "less_than"
+        ? `Value must be ${check.inclusive ? "at most" : "less than"} ${bound}.`
+        : `Value must be ${check.inclusive ? "at least" : "greater than"} ${bound}.`;
+}
+function messageOf(check, subject) {
+    switch (check.check) {
+        case "less_than":
+        case "greater_than":
+            return boundMessage(check, subject);
+        case "multiple_of":
+            return `Value must be a multiple of ${check.value}.`;
+        case "max_length":
+            return check.list === true
+                ? `List must have at most ${plural(check.maximum, "entry", "entries")}.`
+                : `Value must be at most ${plural(check.maximum, "character", "characters")} long.`;
+        case "min_length":
+            return check.list === true
+                ? `List must have at least ${plural(check.minimum, "entry", "entries")}.`
+                : `Value must be at least ${plural(check.minimum, "character", "characters")} long.`;
+        case "length_equals":
+            return `Value must be exactly ${plural(check.length, "character", "characters")} long.`;
+        case "string_format":
+            return formatMessage(check);
+        case "max_size":
+            return `Value must be at most ${plural(check.maximum, "byte", "bytes")}.`;
+        case "min_size":
+            return `Value must be at least ${plural(check.minimum, "byte", "bytes")}.`;
+        case "size_equals":
+            return `Value must be exactly ${plural(check.size, "byte", "bytes")}.`;
+    }
+}
+export function fieldCheckIssue(check, subject, path) {
+    const { check: name, ...params } = check;
+    const code = name === "string_format" ? "V1003" : "V1004";
+    return {
+        code,
+        path,
+        message: messageOf(check, subject),
+        check: name,
+        params,
+    };
+}
+export function fieldCheckIssues(checks, value, subject, path, list) {
+    if (checks.length === 0 || value === null || value === undefined) {
+        return [];
+    }
+    const issues = [];
+    if (list && Array.isArray(value)) {
+        for (const check of checks) {
+            if (isListCheck(check) && !passesFieldCheck(check, value, subject)) {
+                issues.push(fieldCheckIssue(check, subject, path));
+            }
+        }
+        for (const [index, entry] of value.entries()) {
+            issues.push(...entryCheckIssues(checks, entry, subject, [...path, index]));
+        }
+        return issues;
+    }
+    return entryCheckIssues(checks, value, subject, path);
+}
+export function entryCheckIssues(checks, value, subject, path) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    const issues = [];
+    for (const check of checks) {
+        if (!isListCheck(check) && !passesFieldCheck(check, value, subject)) {
+            issues.push(fieldCheckIssue(check, subject, path));
+        }
+    }
+    return issues;
+}
+export function isListCheck(check) {
+    return ((check.check === "max_length" || check.check === "min_length") &&
+        check.list === true);
+}