@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/runtime/run-field.mjs

@@ -0,0 +1,84 @@
+import { createIssue } from "./create-issue.mjs";
+import { decidePresence } from "./decide-presence.mjs";
+/** Shared, frozen, never re-assigned: the common answer allocates nothing. */
+export const FIELD_VALUE_UNCHANGED = Object.freeze({
+    hasWriteBack: false,
+});
+export function runField(field, subject, context) {
+    const path = context.indices.renderFieldPath(field.template);
+    const ruleContext = {
+        root: context.root,
+        path,
+        item: context.item,
+        external: context.external,
+    };
+    const read = field.read(subject);
+    const value = applyDefault(field, read, context.root);
+    if (!decidePresence(field, value, ruleContext, context.sink)) {
+        return FIELD_VALUE_UNCHANGED;
+    }
+    if (!openGates(field, value, ruleContext))
+        return FIELD_VALUE_UNCHANGED;
+    const mark = context.sink.count;
+    runChecks(field, value, ruleContext, context, mark);
+    const written = runTransforms(field, value, ruleContext, context, mark);
+    reenterPlan(field, written, ruleContext, context, mark);
+    if (written === read)
+        return FIELD_VALUE_UNCHANGED;
+    return { hasWriteBack: true, value: written };
+}
+/**
+ * The default is substituted BEFORE anything else looks at the value, so
+ * validate() and parse() judge the same value. Only parse writes it back,
+ * which is the caller's decision and not this one's.
+ */
+function applyDefault(field, value, root) {
+    if (field.defaultOf === null)
+        return value;
+    if (value === undefined)
+        return field.defaultOf(root);
+    if (value === null && field.applyDefaultToNull)
+        return field.defaultOf(root);
+    return value;
+}
+/** A closed gate ends the field successfully: no check, no transform. */
+function openGates(field, value, ruleContext) {
+    for (const gate of field.gates) {
+        if (!gate.shouldRun(value, ruleContext))
+            return false;
+    }
+    return true;
+}
+function runChecks(field, value, ruleContext, context, mark) {
+    for (const check of field.checks) {
+        const outcome = check.run(value, ruleContext);
+        if (outcome.ok)
+            continue;
+        context.sink.add(createIssue({
+            path: ruleContext.path,
+            code: check.code,
+            severity: check.severity,
+            value,
+            render: (ctx) => check.describe(outcome.detail, ctx),
+        }));
+        if (context.sink.shouldStopField(mark))
+            return;
+    }
+}
+/** validate() never reaches a transform, and neither does a failed field. */
+function runTransforms(field, value, ruleContext, context, mark) {
+    if (!context.shouldApplyTransforms || context.sink.count !== mark) {
+        return value;
+    }
+    let current = value;
+    for (const transform of field.transforms) {
+        current = transform.apply(current, ruleContext);
+    }
+    return current;
+}
+/** Recursion is the field's last rule, so the field-level abort covers it. */
+function reenterPlan(field, value, ruleContext, context, mark) {
+    if (field.recursion === null || context.sink.shouldStopField(mark))
+        return;
+    context.runRecursion(field.recursion, value, ruleContext);
+}

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

@@ -0,0 +1,28 @@
+import type { ValidationIssue } from "../types";
+import type { ValidationPlan } from "../compile/validation-plan.types";
+import type { FieldRunContext } from "./run-field";
+import type { ArrayWriteTarget } from "./output-writer";
+/**
+ * `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 declare function runPlan(plan: ValidationPlan, subject: unknown, context: FieldRunContext, targets?: readonly ArrayWriteTarget[]): unknown;
+/**
+ * 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 declare function prefixIssuePaths(prefix: string, issues: readonly ValidationIssue[]): readonly ValidationIssue[];

package/dist/runtime/run-plan.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlan = runPlan;
+exports.prefixIssuePaths = prefixIssuePaths;
+const index_stack_1 = require("./index-stack");
+const run_array_node_1 = require("./run-array-node");
+const run_field_1 = require("./run-field");
+const output_writer_1 = require("./output-writer");
+/**
+ * `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.
+ */
+function runPlan(plan, subject, context, targets = output_writer_1.NO_WRITE_TARGETS) {
+    let current = subject;
+    for (const field of plan.fields) {
+        const outcome = (0, run_field_1.runField)(field, current, context);
+        current = (0, output_writer_1.writeFieldValue)(field, current, outcome, context.shouldApplyTransforms);
+        if (context.sink.shouldStopPlan())
+            return current;
+    }
+    return (0, run_array_node_1.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.
+ */
+function prefixIssuePaths(prefix, issues) {
+    if (prefix === "")
+        return issues;
+    return issues.map((issue) => Object.freeze({
+        path: (0, index_stack_1.joinIssuePath)(prefix, issue.path),
+        code: issue.code,
+        message: issue.message,
+        severity: issue.severity,
+    }));
+}

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/standard-schema/index.d.ts

@@ -0,0 +1,6 @@
+export type { InferStandardInput, InferStandardOutput, StandardSchemaFailure, StandardSchemaIssue, StandardSchemaPathSegment, StandardSchemaProps, StandardSchemaResult, StandardSchemaSuccess, StandardSchemaTypes, StandardSchemaV1, } from "./standard-schema.types";
+export type { StandardSchemaOptions } from "./standard-schema.types";
+export type { IssuePathSegments } from "./split-issue-path";
+export { splitIssuePath } from "./split-issue-path";
+export type { StandardLuqSchema } from "./to-standard-schema";
+export { toStandardSchema } from "./to-standard-schema";

package/dist/standard-schema/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStandardSchema = exports.splitIssuePath = void 0;
+var split_issue_path_1 = require("./split-issue-path");
+Object.defineProperty(exports, "splitIssuePath", { enumerable: true, get: function () { return split_issue_path_1.splitIssuePath; } });
+var to_standard_schema_1 = require("./to-standard-schema");
+Object.defineProperty(exports, "toStandardSchema", { enumerable: true, get: function () { return to_standard_schema_1.toStandardSchema; } });

package/dist/standard-schema/index.mjs

@@ -0,0 +1,2 @@
+export { splitIssuePath } from "./split-issue-path.mjs";
+export { toStandardSchema } from "./to-standard-schema.mjs";

package/dist/standard-schema/split-issue-path.d.ts

@@ -0,0 +1,9 @@
+/** 開いた結果。オブジェクトのキーは string、配列の添字は number。 */
+export type IssuePathSegments = readonly (string | number)[];
+/**
+ * ルート ("") は空配列。空配列は仕様上「ルート自身への issue」を意味する。
+ *
+ * 解釈できない形が来たら、握り潰さずに path 全体を1つの文字列セグメントとして
+ * 返す。issue を落とすより、開けなかったことが分かる形で渡すほうがまし。
+ */
+export declare function splitIssuePath(path: string): IssuePathSegments;

package/dist/standard-schema/split-issue-path.js

@@ -0,0 +1,66 @@
+"use strict";
+// ===========================================================================
+// L10 src/standard-schema/split-issue-path.ts
+//
+// Luq の issue path ("items[1].productId") を Standard Schema の path
+// (["items", 1, "productId"]) に開く。
+//
+// 方向に注意: これは formatIssuePath の逆で、宣言パス (parseFieldPath が
+// 読む "items[*].productId") のパーサではない。issue path には [*] が
+// 決して現れず、代わりに実インデックスが入る。二つの文法を一つの関数で
+// 扱おうとすると、[*] を 0 と読むような取り違えが静かに入るので分けてある。
+//
+// 配列インデックスは number として出す。仕様の PropertyKey は
+// string | number | symbol を許し、消費側 (フォームライブラリ) は
+// 添字を number として受け取る前提で書かれているため。
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitIssuePath = splitIssuePath;
+const INDEX_PATTERN = /^\[(\d+)\]/;
+/**
+ * ルート ("") は空配列。空配列は仕様上「ルート自身への issue」を意味する。
+ *
+ * 解釈できない形が来たら、握り潰さずに path 全体を1つの文字列セグメントとして
+ * 返す。issue を落とすより、開けなかったことが分かる形で渡すほうがまし。
+ */
+function splitIssuePath(path) {
+    if (path === "")
+        return [];
+    const segments = [];
+    let rest = path;
+    let expectKey = true;
+    while (rest !== "") {
+        if (expectKey) {
+            const key = rest.slice(0, findKeyEnd(rest));
+            if (key === "")
+                return [path];
+            segments.push(key);
+            rest = rest.slice(key.length);
+            expectKey = false;
+            continue;
+        }
+        const index = INDEX_PATTERN.exec(rest);
+        if (index !== null) {
+            segments.push(Number(index[1]));
+            rest = rest.slice(index[0].length);
+            continue;
+        }
+        if (rest.startsWith(".")) {
+            rest = rest.slice(1);
+            expectKey = true;
+            continue;
+        }
+        return [path];
+    }
+    return expectKey ? [path] : segments;
+}
+/** キーは "." か "[" の手前まで。どちらも無ければ末尾まで。 */
+function findKeyEnd(rest) {
+    const dot = rest.indexOf(".");
+    const bracket = rest.indexOf("[");
+    if (dot === -1)
+        return bracket === -1 ? rest.length : bracket;
+    if (bracket === -1)
+        return dot;
+    return Math.min(dot, bracket);
+}

package/dist/standard-schema/split-issue-path.mjs

@@ -0,0 +1,63 @@
+// ===========================================================================
+// L10 src/standard-schema/split-issue-path.ts
+//
+// Luq の issue path ("items[1].productId") を Standard Schema の path
+// (["items", 1, "productId"]) に開く。
+//
+// 方向に注意: これは formatIssuePath の逆で、宣言パス (parseFieldPath が
+// 読む "items[*].productId") のパーサではない。issue path には [*] が
+// 決して現れず、代わりに実インデックスが入る。二つの文法を一つの関数で
+// 扱おうとすると、[*] を 0 と読むような取り違えが静かに入るので分けてある。
+//
+// 配列インデックスは number として出す。仕様の PropertyKey は
+// string | number | symbol を許し、消費側 (フォームライブラリ) は
+// 添字を number として受け取る前提で書かれているため。
+// ===========================================================================
+const INDEX_PATTERN = /^\[(\d+)\]/;
+/**
+ * ルート ("") は空配列。空配列は仕様上「ルート自身への issue」を意味する。
+ *
+ * 解釈できない形が来たら、握り潰さずに path 全体を1つの文字列セグメントとして
+ * 返す。issue を落とすより、開けなかったことが分かる形で渡すほうがまし。
+ */
+export function splitIssuePath(path) {
+    if (path === "")
+        return [];
+    const segments = [];
+    let rest = path;
+    let expectKey = true;
+    while (rest !== "") {
+        if (expectKey) {
+            const key = rest.slice(0, findKeyEnd(rest));
+            if (key === "")
+                return [path];
+            segments.push(key);
+            rest = rest.slice(key.length);
+            expectKey = false;
+            continue;
+        }
+        const index = INDEX_PATTERN.exec(rest);
+        if (index !== null) {
+            segments.push(Number(index[1]));
+            rest = rest.slice(index[0].length);
+            continue;
+        }
+        if (rest.startsWith(".")) {
+            rest = rest.slice(1);
+            expectKey = true;
+            continue;
+        }
+        return [path];
+    }
+    return expectKey ? [path] : segments;
+}
+/** キーは "." か "[" の手前まで。どちらも無ければ末尾まで。 */
+function findKeyEnd(rest) {
+    const dot = rest.indexOf(".");
+    const bracket = rest.indexOf("[");
+    if (dot === -1)
+        return bracket === -1 ? rest.length : bracket;
+    if (bracket === -1)
+        return dot;
+    return Math.min(dot, bracket);
+}

package/dist/standard-schema/standard-schema.types.d.ts

@@ -0,0 +1,46 @@
+/** 仕様の StandardSchemaV1。Input と Output を型として運ぶ。 */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaProps<Input, Output>;
+}
+export interface StandardSchemaProps<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown, options?: StandardSchemaOptions | undefined) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+    /**
+     * 実行時には存在しない。型を運ぶためだけのメンバーで、仕様がそう定めている。
+     * InferInput / InferOutput はここから読む。
+     */
+    readonly types?: StandardSchemaTypes<Input, Output> | undefined;
+}
+export interface StandardSchemaTypes<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+}
+export type StandardSchemaResult<Output> = StandardSchemaSuccess<Output> | StandardSchemaFailure;
+export interface StandardSchemaSuccess<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+}
+export interface StandardSchemaFailure {
+    readonly issues: readonly StandardSchemaIssue[];
+}
+/**
+ * path は仕様上 optional。Luq は必ず入れる (root への issue は空配列)。
+ * 省略と「ルートを指す」を呼び出し側が区別できるようにするため。
+ */
+export interface StandardSchemaIssue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | StandardSchemaPathSegment)[] | undefined;
+}
+export interface StandardSchemaPathSegment {
+    readonly key: PropertyKey;
+}
+export type InferStandardInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+export type InferStandardOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+/**
+ * validate の第2引数。仕様が定めているので受ける。
+ * libraryOptions はベンダーごとの追加パラメータで、Luq はまだ何も定義していない。
+ */
+export interface StandardSchemaOptions {
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+}