@logixjs/form 0.0.1

package/dist/Form.d.ts

@@ -0,0 +1,64 @@
+import { r as rules } from './impl-BfSlyM58.js';
+export { f as FormAction, j as FormController, F as FormErrors, i as FormExtendDef, k as FormHandleExt, h as FormMakeConfig, d as FormMeta, l as FormModule, g as FormShape, e as FormState, c as FormUiState, n as RuleDescriptor, o as RuleScope, R as RulesDsl, p as RulesManifest, a as RulesNode, b as RulesSpec, m as make } from './impl-BfSlyM58.js';
+import { Schema } from 'effect';
+import { D as DerivedSpec } from './Trait-Bu794ROY.js';
+import * as Logix from '@logixjs/core';
+import { j as RuleEntry } from './Rule-BOAiSVz9.js';
+export { d as CanonicalListItem, c as CanonicalListPath, C as CanonicalPath, b as CanonicalValue, F as FieldPath, a as FieldValue } from './Rule-BOAiSVz9.js';
+
+/**
+ * Form.derived：
+ * - Provides "type narrowing based on the values schema" for derived specs, so you can compose derived fragments
+ *   without losing type information.
+ * - Does no extra runtime normalization; final validation is still governed by Form.make guardrails.
+ */
+declare const derived: <TValues extends object, I>(_valuesSchema: Schema.Schema<TValues, I>) => (spec: DerivedSpec<TValues>) => DerivedSpec<TValues>;
+
+type NonNull<T> = Exclude<T, null | undefined>;
+type ListItem<T> = NonNull<T> extends readonly (infer Item)[] ? Item : never;
+type NodeSpec$1<Input = unknown, Ctx = unknown> = Omit<Logix.StateTrait.StateTraitNode<Input, Ctx>, '_tag' | 'check'> & {
+    readonly check?: Readonly<Record<string, RuleEntry<Input, Ctx>>>;
+};
+type ListSpec$1<Item = unknown> = Omit<Logix.StateTrait.StateTraitList<Item>, '_tag' | 'item' | 'list'> & {
+    readonly item?: NodeSpec$1<Item, any> | Logix.StateTrait.StateTraitNode<Item, any>;
+    readonly list?: NodeSpec$1<ReadonlyArray<Item>, any> | Logix.StateTrait.StateTraitNode<ReadonlyArray<Item>, any>;
+};
+type NodeInput<Input, Ctx = unknown> = NodeSpec$1<Input, Ctx> | Logix.StateTrait.StateTraitNode<Input, Ctx>;
+type ListInput<Item> = ListSpec$1<Item> | Logix.StateTrait.StateTraitList<Item>;
+type TraitValueForPath<TValues extends object, P extends Logix.StateTrait.StateFieldPath<TValues>> = Logix.StateTrait.StateTraitEntry<TValues, P> | NodeInput<Logix.StateTrait.StateAtPath<TValues, P>, any> | (Logix.StateTrait.StateAtPath<TValues, P> extends readonly any[] ? ListInput<ListItem<Logix.StateTrait.StateAtPath<TValues, P>>> : never);
+type TraitsSpec<TValues extends object> = {
+    readonly [P in Logix.StateTrait.StateFieldPath<TValues>]?: TraitValueForPath<TValues, P>;
+} & {
+    readonly $root?: NodeInput<TValues, any>;
+};
+/**
+ * Form.traits：
+ * - Phase 3: a minimal entry point for "type narrowing + fragment organization".
+ * - Allows mixing in raw node/list fragments (auto-fills StateTrait.node/list tags).
+ * - Form defaults `check.deps=[]`; only declare deps when you need "cross-field linked validation triggers".
+ * - Returns a StateTraitSpec fragment that can be spread directly (assembled by Form.make).
+ */
+declare const traits: <TValues extends object, I>(_valuesSchema: Schema.Schema<TValues, I>) => {
+    (spec: TraitsSpec<TValues>): Logix.StateTrait.StateTraitSpec<TValues>;
+    (spec: Logix.StateTrait.StateTraitSpec<TValues>): Logix.StateTrait.StateTraitSpec<TValues>;
+};
+
+type FormFrom<TValues extends object> = Readonly<{
+    readonly derived: ReturnType<typeof derived<TValues, any>>;
+    readonly rules: ReturnType<typeof rules<TValues, any>>;
+    readonly traits: ReturnType<typeof traits<TValues, any>>;
+}>;
+declare const fromValues: <TValues extends object, I>(valuesSchema: Schema.Schema<TValues, I>) => FormFrom<TValues>;
+
+type NodeSpec<Input = unknown, Ctx = unknown> = Omit<Logix.StateTrait.StateTraitNode<Input, Ctx>, '_tag' | 'check'> & {
+    readonly check?: Readonly<Record<string, RuleEntry<Input, Ctx>>>;
+};
+declare const node: <Input = unknown, Ctx = unknown>(spec: NodeSpec<Input, Ctx>) => Logix.StateTrait.StateTraitNode<Input, Ctx>;
+
+type ListSpec<Item = unknown> = Omit<Logix.StateTrait.StateTraitList<Item>, '_tag' | 'item' | 'list'> & {
+    readonly item?: NodeSpec$1<Item, any> | Logix.StateTrait.StateTraitNode<Item, any>;
+    readonly list?: NodeSpec$1<ReadonlyArray<Item>, any> | Logix.StateTrait.StateTraitNode<ReadonlyArray<Item>, any>;
+};
+declare const list: <Item = unknown>(spec: ListSpec<Item>) => Logix.StateTrait.StateTraitList<Item>;
+
+export { type FormFrom, type ListSpec$1 as ListSpec, type NodeSpec$1 as NodeSpec, type TraitsSpec, derived, fromValues, list, node, rules, traits };

package/dist/Form.js

@@ -0,0 +1,25 @@
+import {
+  derived,
+  fromValues,
+  list,
+  make,
+  node,
+  rules,
+  traits
+} from "./chunk-YHDEJ47V.js";
+import "./chunk-YVHXLY63.js";
+import "./chunk-JZ5FZKPJ.js";
+import "./chunk-5DRI5UGD.js";
+import "./chunk-OJVEZKU7.js";
+import "./chunk-EOXJRCM6.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  derived,
+  fromValues,
+  list,
+  make,
+  node,
+  rules,
+  traits
+};
+//# sourceMappingURL=Form.js.map

package/dist/Form.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/FormView-CAg9LVrf.d.cts

@@ -0,0 +1,17 @@
+type FormView = {
+    readonly canSubmit: boolean;
+    readonly isSubmitting: boolean;
+    readonly isValid: boolean;
+    readonly isDirty: boolean;
+    readonly isPristine: boolean;
+    readonly submitCount: number;
+};
+declare const getFormView: (state: unknown, prev?: FormView) => FormView;
+
+type FormView$1_FormView = FormView;
+declare const FormView$1_getFormView: typeof getFormView;
+declare namespace FormView$1 {
+  export { type FormView$1_FormView as FormView, FormView$1_getFormView as getFormView };
+}
+
+export { FormView$1 as F, type FormView as a, getFormView as g };

package/dist/FormView-CAg9LVrf.d.ts

@@ -0,0 +1,17 @@
+type FormView = {
+    readonly canSubmit: boolean;
+    readonly isSubmitting: boolean;
+    readonly isValid: boolean;
+    readonly isDirty: boolean;
+    readonly isPristine: boolean;
+    readonly submitCount: number;
+};
+declare const getFormView: (state: unknown, prev?: FormView) => FormView;
+
+type FormView$1_FormView = FormView;
+declare const FormView$1_getFormView: typeof getFormView;
+declare namespace FormView$1 {
+  export { type FormView$1_FormView as FormView, FormView$1_getFormView as getFormView };
+}
+
+export { FormView$1 as F, type FormView as a, getFormView as g };

package/dist/FormView.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/FormView.ts
+var FormView_exports = {};
+__export(FormView_exports, {
+  getFormView: () => getFormView
+});
+module.exports = __toCommonJS(FormView_exports);
+var readSnapshot = (state) => {
+  const meta = state && typeof state === "object" && !Array.isArray(state) ? state.$form : void 0;
+  const safe = meta && typeof meta === "object" && !Array.isArray(meta) ? meta : void 0;
+  const submitCount = typeof safe?.submitCount === "number" && Number.isFinite(safe.submitCount) ? safe.submitCount : 0;
+  const isSubmitting = safe?.isSubmitting === true;
+  const isDirty = safe?.isDirty === true;
+  const errorCount = typeof safe?.errorCount === "number" && Number.isFinite(safe.errorCount) ? safe.errorCount : 0;
+  return {
+    submitCount,
+    isSubmitting,
+    isDirty,
+    errorCount
+  };
+};
+var getFormView = (state, prev) => {
+  const snap = readSnapshot(state);
+  const isValid = snap.errorCount === 0;
+  const isPristine = !snap.isDirty;
+  const canSubmit = !snap.isSubmitting && isValid;
+  if (prev && prev.submitCount === snap.submitCount && prev.isSubmitting === snap.isSubmitting && prev.isDirty === snap.isDirty && prev.isValid === isValid) {
+    return prev;
+  }
+  return {
+    canSubmit,
+    isSubmitting: snap.isSubmitting,
+    isValid,
+    isDirty: snap.isDirty,
+    isPristine,
+    submitCount: snap.submitCount
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFormView
+});
+//# sourceMappingURL=FormView.cjs.map

package/dist/FormView.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/FormView.ts"],"sourcesContent":["export type FormView = {\n  readonly canSubmit: boolean\n  readonly isSubmitting: boolean\n  readonly isValid: boolean\n  readonly isDirty: boolean\n  readonly isPristine: boolean\n  readonly submitCount: number\n}\n\ntype Snapshot = {\n  readonly submitCount: number\n  readonly isSubmitting: boolean\n  readonly isDirty: boolean\n  readonly errorCount: number\n}\n\nconst readSnapshot = (state: unknown): Snapshot => {\n  const meta = state && typeof state === 'object' && !Array.isArray(state) ? (state as any).$form : undefined\n  const safe = meta && typeof meta === 'object' && !Array.isArray(meta) ? (meta as any) : undefined\n\n  const submitCount = typeof safe?.submitCount === 'number' && Number.isFinite(safe.submitCount) ? safe.submitCount : 0\n  const isSubmitting = safe?.isSubmitting === true\n  const isDirty = safe?.isDirty === true\n  const errorCount = typeof safe?.errorCount === 'number' && Number.isFinite(safe.errorCount) ? safe.errorCount : 0\n\n  return {\n    submitCount,\n    isSubmitting,\n    isDirty,\n    errorCount,\n  }\n}\n\nexport const getFormView = (state: unknown, prev?: FormView): FormView => {\n  const snap = readSnapshot(state)\n  const isValid = snap.errorCount === 0\n  const isPristine = !snap.isDirty\n  const canSubmit = !snap.isSubmitting && isValid\n\n  if (\n    prev &&\n    prev.submitCount === snap.submitCount &&\n    prev.isSubmitting === snap.isSubmitting &&\n    prev.isDirty === snap.isDirty &&\n    prev.isValid === isValid\n  ) {\n    return prev\n  }\n\n  return {\n    canSubmit,\n    isSubmitting: snap.isSubmitting,\n    isValid,\n    isDirty: snap.isDirty,\n    isPristine,\n    submitCount: snap.submitCount,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,IAAM,eAAe,CAAC,UAA6B;AACjD,QAAM,OAAO,SAAS,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK,IAAK,MAAc,QAAQ;AAClG,QAAM,OAAO,QAAQ,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,IAAK,OAAe;AAExF,QAAM,cAAc,OAAO,MAAM,gBAAgB,YAAY,OAAO,SAAS,KAAK,WAAW,IAAI,KAAK,cAAc;AACpH,QAAM,eAAe,MAAM,iBAAiB;AAC5C,QAAM,UAAU,MAAM,YAAY;AAClC,QAAM,aAAa,OAAO,MAAM,eAAe,YAAY,OAAO,SAAS,KAAK,UAAU,IAAI,KAAK,aAAa;AAEhH,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAM,cAAc,CAAC,OAAgB,SAA8B;AACxE,QAAM,OAAO,aAAa,KAAK;AAC/B,QAAM,UAAU,KAAK,eAAe;AACpC,QAAM,aAAa,CAAC,KAAK;AACzB,QAAM,YAAY,CAAC,KAAK,gBAAgB;AAExC,MACE,QACA,KAAK,gBAAgB,KAAK,eAC1B,KAAK,iBAAiB,KAAK,gBAC3B,KAAK,YAAY,KAAK,WACtB,KAAK,YAAY,SACjB;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL;AAAA,IACA,cAAc,KAAK;AAAA,IACnB;AAAA,IACA,SAAS,KAAK;AAAA,IACd;AAAA,IACA,aAAa,KAAK;AAAA,EACpB;AACF;","names":[]}

package/dist/FormView.d.cts

@@ -0,0 +1 @@
+export { a as FormView, g as getFormView } from './FormView-CAg9LVrf.cjs';

package/dist/FormView.d.ts

@@ -0,0 +1 @@
+export { a as FormView, g as getFormView } from './FormView-CAg9LVrf.js';

package/dist/FormView.js

@@ -0,0 +1,8 @@
+import {
+  getFormView
+} from "./chunk-LNJJPZAG.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  getFormView
+};
+//# sourceMappingURL=FormView.js.map

package/dist/FormView.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Path-DOjMkAS6.d.cts

@@ -0,0 +1,42 @@
+type ValuePath = string;
+type PatternPath = string;
+type ListPath = string;
+type ErrorsPath = string;
+type UiPath = string;
+type FieldPath = ReadonlyArray<string>;
+declare const toPatternPath: (valuePath: ValuePath) => PatternPath;
+declare const toListPath: (valuePath: ValuePath) => ListPath | undefined;
+declare const toErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+declare const toManualErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+declare const toSchemaErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+declare const toUiPath: (valuePath: ValuePath) => UiPath;
+declare const toFieldPath: (path: ValuePath | PatternPath) => FieldPath;
+declare const Path: {
+    readonly toPatternPath: (valuePath: ValuePath) => PatternPath;
+    readonly toListPath: (valuePath: ValuePath) => ListPath | undefined;
+    readonly toErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+    readonly toManualErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+    readonly toSchemaErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+    readonly toUiPath: (valuePath: ValuePath) => UiPath;
+    readonly toFieldPath: (path: ValuePath | PatternPath) => FieldPath;
+};
+
+type Path$1_ErrorsPath = ErrorsPath;
+type Path$1_FieldPath = FieldPath;
+type Path$1_ListPath = ListPath;
+declare const Path$1_Path: typeof Path;
+type Path$1_PatternPath = PatternPath;
+type Path$1_UiPath = UiPath;
+type Path$1_ValuePath = ValuePath;
+declare const Path$1_toErrorsPath: typeof toErrorsPath;
+declare const Path$1_toFieldPath: typeof toFieldPath;
+declare const Path$1_toListPath: typeof toListPath;
+declare const Path$1_toManualErrorsPath: typeof toManualErrorsPath;
+declare const Path$1_toPatternPath: typeof toPatternPath;
+declare const Path$1_toSchemaErrorsPath: typeof toSchemaErrorsPath;
+declare const Path$1_toUiPath: typeof toUiPath;
+declare namespace Path$1 {
+  export { type Path$1_ErrorsPath as ErrorsPath, type Path$1_FieldPath as FieldPath, type Path$1_ListPath as ListPath, Path$1_Path as Path, type Path$1_PatternPath as PatternPath, type Path$1_UiPath as UiPath, type Path$1_ValuePath as ValuePath, Path$1_toErrorsPath as toErrorsPath, Path$1_toFieldPath as toFieldPath, Path$1_toListPath as toListPath, Path$1_toManualErrorsPath as toManualErrorsPath, Path$1_toPatternPath as toPatternPath, Path$1_toSchemaErrorsPath as toSchemaErrorsPath, Path$1_toUiPath as toUiPath };
+}
+
+export { type ErrorsPath as E, type FieldPath as F, type ListPath as L, Path$1 as P, type UiPath as U, type ValuePath as V, type PatternPath as a, toListPath as b, toErrorsPath as c, toManualErrorsPath as d, toSchemaErrorsPath as e, toUiPath as f, toFieldPath as g, Path as h, toPatternPath as t };

package/dist/Path-DOjMkAS6.d.ts

@@ -0,0 +1,42 @@
+type ValuePath = string;
+type PatternPath = string;
+type ListPath = string;
+type ErrorsPath = string;
+type UiPath = string;
+type FieldPath = ReadonlyArray<string>;
+declare const toPatternPath: (valuePath: ValuePath) => PatternPath;
+declare const toListPath: (valuePath: ValuePath) => ListPath | undefined;
+declare const toErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+declare const toManualErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+declare const toSchemaErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+declare const toUiPath: (valuePath: ValuePath) => UiPath;
+declare const toFieldPath: (path: ValuePath | PatternPath) => FieldPath;
+declare const Path: {
+    readonly toPatternPath: (valuePath: ValuePath) => PatternPath;
+    readonly toListPath: (valuePath: ValuePath) => ListPath | undefined;
+    readonly toErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+    readonly toManualErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+    readonly toSchemaErrorsPath: (valuePath: ValuePath) => ErrorsPath;
+    readonly toUiPath: (valuePath: ValuePath) => UiPath;
+    readonly toFieldPath: (path: ValuePath | PatternPath) => FieldPath;
+};
+
+type Path$1_ErrorsPath = ErrorsPath;
+type Path$1_FieldPath = FieldPath;
+type Path$1_ListPath = ListPath;
+declare const Path$1_Path: typeof Path;
+type Path$1_PatternPath = PatternPath;
+type Path$1_UiPath = UiPath;
+type Path$1_ValuePath = ValuePath;
+declare const Path$1_toErrorsPath: typeof toErrorsPath;
+declare const Path$1_toFieldPath: typeof toFieldPath;
+declare const Path$1_toListPath: typeof toListPath;
+declare const Path$1_toManualErrorsPath: typeof toManualErrorsPath;
+declare const Path$1_toPatternPath: typeof toPatternPath;
+declare const Path$1_toSchemaErrorsPath: typeof toSchemaErrorsPath;
+declare const Path$1_toUiPath: typeof toUiPath;
+declare namespace Path$1 {
+  export { type Path$1_ErrorsPath as ErrorsPath, type Path$1_FieldPath as FieldPath, type Path$1_ListPath as ListPath, Path$1_Path as Path, type Path$1_PatternPath as PatternPath, type Path$1_UiPath as UiPath, type Path$1_ValuePath as ValuePath, Path$1_toErrorsPath as toErrorsPath, Path$1_toFieldPath as toFieldPath, Path$1_toListPath as toListPath, Path$1_toManualErrorsPath as toManualErrorsPath, Path$1_toPatternPath as toPatternPath, Path$1_toSchemaErrorsPath as toSchemaErrorsPath, Path$1_toUiPath as toUiPath };
+}
+
+export { type ErrorsPath as E, type FieldPath as F, type ListPath as L, Path$1 as P, type UiPath as U, type ValuePath as V, type PatternPath as a, toListPath as b, toErrorsPath as c, toManualErrorsPath as d, toSchemaErrorsPath as e, toUiPath as f, toFieldPath as g, Path as h, toPatternPath as t };

package/dist/Path.cjs

@@ -0,0 +1,132 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Path.ts
+var Path_exports = {};
+__export(Path_exports, {
+  Path: () => Path,
+  toErrorsPath: () => toErrorsPath,
+  toFieldPath: () => toFieldPath,
+  toListPath: () => toListPath,
+  toManualErrorsPath: () => toManualErrorsPath,
+  toPatternPath: () => toPatternPath,
+  toSchemaErrorsPath: () => toSchemaErrorsPath,
+  toUiPath: () => toUiPath
+});
+module.exports = __toCommonJS(Path_exports);
+var isNumericSegment = (seg) => /^[0-9]+$/.test(seg);
+var splitPath = (path) => {
+  if (!path) return [];
+  const parts = path.split(".").filter((p) => p.length > 0);
+  const segs = [];
+  for (const part of parts) {
+    if (!part) continue;
+    if (part.endsWith("[]")) {
+      const base = part.slice(0, -2);
+      if (base) segs.push(base);
+      segs.push("[]");
+      continue;
+    }
+    const bracket = /^(.+)\[(\d+)\]$/.exec(part);
+    if (bracket) {
+      const base = bracket[1];
+      if (base) segs.push(base);
+      segs.push(bracket[2]);
+      continue;
+    }
+    segs.push(part);
+  }
+  return segs;
+};
+var toPatternPath = (valuePath) => {
+  if (!valuePath) return valuePath;
+  const segs = splitPath(valuePath);
+  const out = [];
+  for (const seg of segs) {
+    if (seg === "[]" || isNumericSegment(seg)) {
+      if (out.length === 0) continue;
+      const last = out[out.length - 1];
+      if (!last.endsWith("[]")) out[out.length - 1] = `${last}[]`;
+      continue;
+    }
+    out.push(seg);
+  }
+  return out.join(".");
+};
+var toListPath = (valuePath) => {
+  const segs = splitPath(valuePath);
+  const firstIndex = segs.findIndex((seg) => seg === "[]" || isNumericSegment(seg));
+  if (firstIndex <= 0) return void 0;
+  return segs.slice(0, firstIndex).join(".");
+};
+var toErrorsPath = (valuePath) => {
+  if (!valuePath) return "errors";
+  const segs = splitPath(valuePath);
+  const out = [];
+  for (const seg of segs) {
+    if (isNumericSegment(seg)) {
+      out.push("rows", seg);
+      continue;
+    }
+    if (seg === "[]") {
+      continue;
+    }
+    out.push(seg);
+  }
+  return `errors.${out.join(".")}`;
+};
+var toManualErrorsPath = (valuePath) => {
+  const base = toErrorsPath(valuePath);
+  return base === "errors" ? "errors.$manual" : base.replace(/^errors\./, "errors.$manual.");
+};
+var toSchemaErrorsPath = (valuePath) => {
+  const base = toErrorsPath(valuePath);
+  return base === "errors" ? "errors.$schema" : base.replace(/^errors\./, "errors.$schema.");
+};
+var toUiPath = (valuePath) => valuePath ? `ui.${valuePath}` : "ui";
+var toFieldPath = (path) => {
+  const segs = splitPath(path);
+  const out = [];
+  for (const seg of segs) {
+    if (seg === "[]" || isNumericSegment(seg)) continue;
+    out.push(seg);
+  }
+  return out.length > 0 ? out : ["$root"];
+};
+var Path = {
+  toPatternPath,
+  toListPath,
+  toErrorsPath,
+  toManualErrorsPath,
+  toSchemaErrorsPath,
+  toUiPath,
+  toFieldPath
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Path,
+  toErrorsPath,
+  toFieldPath,
+  toListPath,
+  toManualErrorsPath,
+  toPatternPath,
+  toSchemaErrorsPath,
+  toUiPath
+});
+//# sourceMappingURL=Path.cjs.map

package/dist/Path.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Path.ts"],"sourcesContent":["export type ValuePath = string\nexport type PatternPath = string\nexport type ListPath = string\nexport type ErrorsPath = string\nexport type UiPath = string\nexport type FieldPath = ReadonlyArray<string>\n\nconst isNumericSegment = (seg: string): boolean => /^[0-9]+$/.test(seg)\n\nconst splitPath = (path: string): ReadonlyArray<string> => {\n  if (!path) return []\n  const parts = path.split('.').filter((p) => p.length > 0)\n  const segs: Array<string> = []\n\n  for (const part of parts) {\n    if (!part) continue\n    if (part.endsWith('[]')) {\n      const base = part.slice(0, -2)\n      if (base) segs.push(base)\n      segs.push('[]')\n      continue\n    }\n    const bracket = /^(.+)\\[(\\d+)\\]$/.exec(part)\n    if (bracket) {\n      const base = bracket[1]!\n      if (base) segs.push(base)\n      segs.push(bracket[2]!)\n      continue\n    }\n    segs.push(part)\n  }\n\n  return segs\n}\n\nexport const toPatternPath = (valuePath: ValuePath): PatternPath => {\n  if (!valuePath) return valuePath\n  const segs = splitPath(valuePath)\n  const out: Array<string> = []\n\n  for (const seg of segs) {\n    if (seg === '[]' || isNumericSegment(seg)) {\n      if (out.length === 0) continue\n      const last = out[out.length - 1]!\n      if (!last.endsWith('[]')) out[out.length - 1] = `${last}[]`\n      continue\n    }\n    out.push(seg)\n  }\n\n  return out.join('.')\n}\n\nexport const toListPath = (valuePath: ValuePath): ListPath | undefined => {\n  const segs = splitPath(valuePath)\n  const firstIndex = segs.findIndex((seg) => seg === '[]' || isNumericSegment(seg))\n  if (firstIndex <= 0) return undefined\n  return segs.slice(0, firstIndex).join('.')\n}\n\nexport const toErrorsPath = (valuePath: ValuePath): ErrorsPath => {\n  if (!valuePath) return 'errors'\n  const segs = splitPath(valuePath)\n  const out: Array<string> = []\n\n  for (const seg of segs) {\n    if (isNumericSegment(seg)) {\n      out.push('rows', seg)\n      continue\n    }\n    if (seg === '[]') {\n      continue\n    }\n    out.push(seg)\n  }\n\n  return `errors.${out.join('.')}`\n}\n\nexport const toManualErrorsPath = (valuePath: ValuePath): ErrorsPath => {\n  const base = toErrorsPath(valuePath)\n  return base === 'errors' ? 'errors.$manual' : base.replace(/^errors\\./, 'errors.$manual.')\n}\n\nexport const toSchemaErrorsPath = (valuePath: ValuePath): ErrorsPath => {\n  const base = toErrorsPath(valuePath)\n  return base === 'errors' ? 'errors.$schema' : base.replace(/^errors\\./, 'errors.$schema.')\n}\n\nexport const toUiPath = (valuePath: ValuePath): UiPath => (valuePath ? `ui.${valuePath}` : 'ui')\n\nexport const toFieldPath = (path: ValuePath | PatternPath): FieldPath => {\n  const segs = splitPath(path)\n  const out: Array<string> = []\n  for (const seg of segs) {\n    if (seg === '[]' || isNumericSegment(seg)) continue\n    out.push(seg)\n  }\n  return out.length > 0 ? out : ['$root']\n}\n\nexport const Path = {\n  toPatternPath,\n  toListPath,\n  toErrorsPath,\n  toManualErrorsPath,\n  toSchemaErrorsPath,\n  toUiPath,\n  toFieldPath,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,IAAM,mBAAmB,CAAC,QAAyB,WAAW,KAAK,GAAG;AAEtE,IAAM,YAAY,CAAC,SAAwC;AACzD,MAAI,CAAC,KAAM,QAAO,CAAC;AACnB,QAAM,QAAQ,KAAK,MAAM,GAAG,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC;AACxD,QAAM,OAAsB,CAAC;AAE7B,aAAW,QAAQ,OAAO;AACxB,QAAI,CAAC,KAAM;AACX,QAAI,KAAK,SAAS,IAAI,GAAG;AACvB,YAAM,OAAO,KAAK,MAAM,GAAG,EAAE;AAC7B,UAAI,KAAM,MAAK,KAAK,IAAI;AACxB,WAAK,KAAK,IAAI;AACd;AAAA,IACF;AACA,UAAM,UAAU,kBAAkB,KAAK,IAAI;AAC3C,QAAI,SAAS;AACX,YAAM,OAAO,QAAQ,CAAC;AACtB,UAAI,KAAM,MAAK,KAAK,IAAI;AACxB,WAAK,KAAK,QAAQ,CAAC,CAAE;AACrB;AAAA,IACF;AACA,SAAK,KAAK,IAAI;AAAA,EAChB;AAEA,SAAO;AACT;AAEO,IAAM,gBAAgB,CAAC,cAAsC;AAClE,MAAI,CAAC,UAAW,QAAO;AACvB,QAAM,OAAO,UAAU,SAAS;AAChC,QAAM,MAAqB,CAAC;AAE5B,aAAW,OAAO,MAAM;AACtB,QAAI,QAAQ,QAAQ,iBAAiB,GAAG,GAAG;AACzC,UAAI,IAAI,WAAW,EAAG;AACtB,YAAM,OAAO,IAAI,IAAI,SAAS,CAAC;AAC/B,UAAI,CAAC,KAAK,SAAS,IAAI,EAAG,KAAI,IAAI,SAAS,CAAC,IAAI,GAAG,IAAI;AACvD;AAAA,IACF;AACA,QAAI,KAAK,GAAG;AAAA,EACd;AAEA,SAAO,IAAI,KAAK,GAAG;AACrB;AAEO,IAAM,aAAa,CAAC,cAA+C;AACxE,QAAM,OAAO,UAAU,SAAS;AAChC,QAAM,aAAa,KAAK,UAAU,CAAC,QAAQ,QAAQ,QAAQ,iBAAiB,GAAG,CAAC;AAChF,MAAI,cAAc,EAAG,QAAO;AAC5B,SAAO,KAAK,MAAM,GAAG,UAAU,EAAE,KAAK,GAAG;AAC3C;AAEO,IAAM,eAAe,CAAC,cAAqC;AAChE,MAAI,CAAC,UAAW,QAAO;AACvB,QAAM,OAAO,UAAU,SAAS;AAChC,QAAM,MAAqB,CAAC;AAE5B,aAAW,OAAO,MAAM;AACtB,QAAI,iBAAiB,GAAG,GAAG;AACzB,UAAI,KAAK,QAAQ,GAAG;AACpB;AAAA,IACF;AACA,QAAI,QAAQ,MAAM;AAChB;AAAA,IACF;AACA,QAAI,KAAK,GAAG;AAAA,EACd;AAEA,SAAO,UAAU,IAAI,KAAK,GAAG,CAAC;AAChC;AAEO,IAAM,qBAAqB,CAAC,cAAqC;AACtE,QAAM,OAAO,aAAa,SAAS;AACnC,SAAO,SAAS,WAAW,mBAAmB,KAAK,QAAQ,aAAa,iBAAiB;AAC3F;AAEO,IAAM,qBAAqB,CAAC,cAAqC;AACtE,QAAM,OAAO,aAAa,SAAS;AACnC,SAAO,SAAS,WAAW,mBAAmB,KAAK,QAAQ,aAAa,iBAAiB;AAC3F;AAEO,IAAM,WAAW,CAAC,cAAkC,YAAY,MAAM,SAAS,KAAK;AAEpF,IAAM,cAAc,CAAC,SAA6C;AACvE,QAAM,OAAO,UAAU,IAAI;AAC3B,QAAM,MAAqB,CAAC;AAC5B,aAAW,OAAO,MAAM;AACtB,QAAI,QAAQ,QAAQ,iBAAiB,GAAG,EAAG;AAC3C,QAAI,KAAK,GAAG;AAAA,EACd;AACA,SAAO,IAAI,SAAS,IAAI,MAAM,CAAC,OAAO;AACxC;AAEO,IAAM,OAAO;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;","names":[]}

package/dist/Path.d.cts

@@ -0,0 +1 @@
+export { E as ErrorsPath, F as FieldPath, L as ListPath, h as Path, a as PatternPath, U as UiPath, V as ValuePath, c as toErrorsPath, g as toFieldPath, b as toListPath, d as toManualErrorsPath, t as toPatternPath, e as toSchemaErrorsPath, f as toUiPath } from './Path-DOjMkAS6.cjs';

package/dist/Path.d.ts

@@ -0,0 +1 @@
+export { E as ErrorsPath, F as FieldPath, L as ListPath, h as Path, a as PatternPath, U as UiPath, V as ValuePath, c as toErrorsPath, g as toFieldPath, b as toListPath, d as toManualErrorsPath, t as toPatternPath, e as toSchemaErrorsPath, f as toUiPath } from './Path-DOjMkAS6.js';

package/dist/Path.js

@@ -0,0 +1,22 @@
+import {
+  Path,
+  toErrorsPath,
+  toFieldPath,
+  toListPath,
+  toManualErrorsPath,
+  toPatternPath,
+  toSchemaErrorsPath,
+  toUiPath
+} from "./chunk-OJVEZKU7.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  Path,
+  toErrorsPath,
+  toFieldPath,
+  toListPath,
+  toManualErrorsPath,
+  toPatternPath,
+  toSchemaErrorsPath,
+  toUiPath
+};
+//# sourceMappingURL=Path.js.map

package/dist/Path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}