@logixjs/form 0.0.1

package/dist/Form.cjs

@@ -0,0 +1,2455 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form.ts
+var Form_exports = {};
+__export(Form_exports, {
+  derived: () => derived,
+  fromValues: () => fromValues,
+  list: () => list2,
+  make: () => make2,
+  node: () => node,
+  rules: () => rules,
+  traits: () => traits
+});
+module.exports = __toCommonJS(Form_exports);
+
+// src/internal/form/impl.ts
+var Logix4 = __toESM(require("@logixjs/core"), 1);
+var import_effect4 = require("effect");
+
+// src/internal/form/traits.ts
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeValidateOn = (input, fallback) => {
+  if (!Array.isArray(input)) return fallback;
+  const out = [];
+  for (const x of input) {
+    if (x === "onSubmit" || x === "onChange" || x === "onBlur") out.push(x);
+  }
+  return out.length > 0 ? Array.from(new Set(out)) : fallback;
+};
+var normalizeRuleValidateOn = (input) => {
+  if (!Array.isArray(input)) return [];
+  const out = [];
+  for (const x of input) {
+    if (x === "onChange" || x === "onBlur") out.push(x);
+  }
+  return Array.from(new Set(out));
+};
+var readSubmitCount = (state) => {
+  const form = state && typeof state === "object" && !Array.isArray(state) ? state.$form : void 0;
+  const v = form && typeof form === "object" && !Array.isArray(form) ? form.submitCount : void 0;
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+};
+var RULE_SKIP = /* @__PURE__ */ Symbol.for("logix.state-trait.validate.skip");
+var normalizeDerived = (input) => {
+  if (input === void 0) return void 0;
+  if (!isPlainObject(input)) {
+    throw new Error(`[Form.make] "derived" must be a plain object`);
+  }
+  const isAllowedTargetPath = (path) => {
+    if (!path) return false;
+    if (path === "$root") return false;
+    if (path === "errors" || path.startsWith("errors.")) return false;
+    if (path === "$form" || path.startsWith("$form.")) return false;
+    return true;
+  };
+  const isDerivedEntry = (value) => {
+    if (!isPlainObject(value)) return false;
+    if (value._tag === "StateTraitNode" || value._tag === "StateTraitList") return false;
+    const kind = value.kind;
+    return kind === "computed" || kind === "link" || kind === "source";
+  };
+  const out = {};
+  const keys = Object.keys(input).sort((a, b) => a.localeCompare(b));
+  for (const rawKey of keys) {
+    const key = rawKey.trim();
+    if (!key) {
+      throw new Error(`[Form.make] "derived" contains an empty key`);
+    }
+    if (!isAllowedTargetPath(key)) {
+      throw new Error(`[Form.make] "derived" cannot write to "${key}" (only values/ui are allowed)`);
+    }
+    const value = input[rawKey];
+    if (!isDerivedEntry(value)) {
+      throw new Error(`[Form.make] "derived.${key}" must be a Form.Trait entry (computed/link/source)`);
+    }
+    out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var mergeTraitSpecs = (base, extra, baseLabel, extraLabel) => {
+  if (!base && !extra) return void 0;
+  if (!base) return extra;
+  if (!extra) return base;
+  const isStateTraitNode2 = (value) => isPlainObject(value) && value._tag === "StateTraitNode";
+  const isStateTraitList2 = (value) => isPlainObject(value) && value._tag === "StateTraitList";
+  const isStateTraitEntry2 = (value) => isPlainObject(value) && (value.kind === "computed" || value.kind === "source" || value.kind === "link" || value.kind === "check");
+  const mergeEntryOrRecord = (path, a, b) => {
+    if (a === void 0) return b;
+    if (b === void 0) return a;
+    if (isStateTraitEntry2(a) || isStateTraitEntry2(b)) {
+      throw new Error(
+        `[Form.make] Cannot merge "${path}": entry/record conflict between "${baseLabel}" and "${extraLabel}"`
+      );
+    }
+    if (!isPlainObject(a) || !isPlainObject(b)) {
+      throw new Error(
+        `[Form.make] Cannot merge "${path}": incompatible values between "${baseLabel}" and "${extraLabel}"`
+      );
+    }
+    const out2 = { ...a };
+    for (const [k, v] of Object.entries(b)) {
+      if (k in out2) {
+        throw new Error(`[Form.make] Duplicate trait key "${path}.${k}" between "${baseLabel}" and "${extraLabel}"`);
+      }
+      out2[k] = v;
+    }
+    return out2;
+  };
+  const mergeCheckRules = (path, a, b) => {
+    if (a === void 0) return b;
+    if (b === void 0) return a;
+    if (!isPlainObject(a) || !isPlainObject(b)) {
+      throw new Error(
+        `[Form.make] Cannot merge "${path}.check": incompatible values between "${baseLabel}" and "${extraLabel}"`
+      );
+    }
+    const out2 = { ...a };
+    for (const [k, v] of Object.entries(b)) {
+      if (k in out2) {
+        throw new Error(
+          `[Form.make] Duplicate check rule "${path}.check.${k}" between "${baseLabel}" and "${extraLabel}"`
+        );
+      }
+      out2[k] = v;
+    }
+    return out2;
+  };
+  const mergeNodes = (path, a, b) => {
+    const out2 = { ...a };
+    if (a.meta !== void 0 && b.meta !== void 0) {
+      throw new Error(`[Form.make] Duplicate node meta at "${path}" between "${baseLabel}" and "${extraLabel}"`);
+    }
+    if (out2.meta === void 0 && b.meta !== void 0) out2.meta = b.meta;
+    out2.computed = mergeEntryOrRecord(`${path}.computed`, a.computed, b.computed);
+    out2.source = mergeEntryOrRecord(`${path}.source`, a.source, b.source);
+    out2.link = mergeEntryOrRecord(`${path}.link`, a.link, b.link);
+    out2.check = mergeCheckRules(path, a.check, b.check);
+    return out2;
+  };
+  const mergeLists = (path, a, b) => {
+    const trackByA = a.identityHint && typeof a.identityHint === "object" ? a.identityHint.trackBy : void 0;
+    const trackByB = b.identityHint && typeof b.identityHint === "object" ? b.identityHint.trackBy : void 0;
+    if (trackByA !== void 0 && trackByB !== void 0 && trackByA !== trackByB) {
+      throw new Error(
+        `[Form.make] Conflicting list identityHint.trackBy for "${path}" between "${baseLabel}" and "${extraLabel}"`
+      );
+    }
+    const item = a.item && b.item ? mergeNodes(`${path}.item`, a.item, b.item) : a.item !== void 0 ? a.item : b.item;
+    const list3 = a.list && b.list ? mergeNodes(`${path}.list`, a.list, b.list) : a.list !== void 0 ? a.list : b.list;
+    return {
+      ...a,
+      ...b,
+      ...trackByA !== void 0 || trackByB !== void 0 ? { identityHint: { trackBy: String(trackByA ?? trackByB) } } : {},
+      ...item !== void 0 ? { item } : {},
+      ...list3 !== void 0 ? { list: list3 } : {}
+    };
+  };
+  const out = { ...base };
+  for (const [k, v] of Object.entries(extra)) {
+    const existing = out[k];
+    if (existing === void 0) {
+      out[k] = v;
+      continue;
+    }
+    if (isStateTraitList2(existing) && isStateTraitList2(v)) {
+      out[k] = mergeLists(k, existing, v);
+      continue;
+    }
+    if (isStateTraitNode2(existing) && isStateTraitNode2(v)) {
+      out[k] = mergeNodes(k, existing, v);
+      continue;
+    }
+    throw new Error(`[Form.make] Duplicate trait path "${k}" between "${baseLabel}" and "${extraLabel}"`);
+  }
+  return out;
+};
+var wrapTraitsForValidateOn = (spec, options) => {
+  const validateOn = options.validateOn;
+  const reValidateOn = options.reValidateOn;
+  const isNode = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitNode";
+  const isList = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitList";
+  const isCheckEntry = (value) => Boolean(value) && typeof value === "object" && value.kind === "check" && value.meta && typeof value.meta === "object";
+  const explicitTriggers = /* @__PURE__ */ new Set();
+  const wrapRule = (rule) => {
+    if (typeof rule === "function") {
+      const validate2 = rule;
+      return (input, ctx) => {
+        const mode = ctx?.mode;
+        if (mode === "submit" || mode === "manual") return validate2(input, ctx);
+        const trigger = mode === "valueChange" ? "onChange" : mode === "blur" ? "onBlur" : void 0;
+        if (!trigger) return validate2(input, ctx);
+        const submitCount = readSubmitCount(ctx?.state);
+        const effective = submitCount > 0 ? reValidateOn : validateOn;
+        return effective.includes(trigger) ? validate2(input, ctx) : RULE_SKIP;
+      };
+    }
+    if (!rule || typeof rule !== "object") return rule;
+    const anyRule = rule;
+    const validate = anyRule.validate;
+    if (typeof validate !== "function") return rule;
+    const hasExplicit = Array.isArray(anyRule.validateOn);
+    const explicit = hasExplicit ? normalizeRuleValidateOn(anyRule.validateOn) : void 0;
+    if (explicit) {
+      for (const t of explicit) explicitTriggers.add(t);
+    }
+    const wrappedValidate = (input, ctx) => {
+      const mode = ctx?.mode;
+      if (mode === "submit" || mode === "manual") return validate(input, ctx);
+      const trigger = mode === "valueChange" ? "onChange" : mode === "blur" ? "onBlur" : void 0;
+      if (!trigger) return validate(input, ctx);
+      if (hasExplicit) {
+        return explicit && explicit.includes(trigger) ? validate(input, ctx) : RULE_SKIP;
+      }
+      const submitCount = readSubmitCount(ctx?.state);
+      const effective = submitCount > 0 ? reValidateOn : validateOn;
+      return effective.includes(trigger) ? validate(input, ctx) : RULE_SKIP;
+    };
+    return {
+      ...anyRule,
+      ...hasExplicit ? { validateOn: explicit } : {},
+      validate: wrappedValidate
+    };
+  };
+  const visit = (value) => {
+    if (isNode(value)) {
+      const check = value.check;
+      if (!check) return value;
+      const wrapped = {};
+      for (const name of Object.keys(check)) {
+        wrapped[name] = wrapRule(check[name]);
+      }
+      return { ...value, check: wrapped };
+    }
+    if (isList(value)) {
+      return {
+        ...value,
+        item: value.item ? visit(value.item) : void 0,
+        list: value.list ? visit(value.list) : void 0
+      };
+    }
+    if (isCheckEntry(value)) {
+      const meta = value.meta;
+      const rules2 = meta?.rules;
+      if (!isPlainObject(rules2)) return value;
+      const wrapped = {};
+      for (const name of Object.keys(rules2)) {
+        wrapped[name] = wrapRule(rules2[name]);
+      }
+      return {
+        ...value,
+        meta: { ...meta, rules: wrapped }
+      };
+    }
+    if (isPlainObject(value)) {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = visit(v);
+      }
+      return out;
+    }
+    return value;
+  };
+  return {
+    traits: visit(spec),
+    rulesValidateOn: Array.from(explicitTriggers)
+  };
+};
+
+// src/internal/form/path.ts
+var getAtPath = (state, path) => {
+  if (!path) return state;
+  const segments = path.split(".");
+  let current = state;
+  for (const segment of segments) {
+    if (current == null) return void 0;
+    const index = Number(segment);
+    if (Array.isArray(current) && Number.isInteger(index) && String(index) === segment) {
+      current = current[index];
+      continue;
+    }
+    current = current[segment];
+  }
+  return current;
+};
+var cloneContainer = (value) => {
+  if (Array.isArray(value)) return value.slice();
+  if (value && typeof value === "object") return { ...value };
+  return void 0;
+};
+var setAtPath = (state, path, value) => {
+  if (!path) return value;
+  const segments = path.split(".");
+  const rootClone = cloneContainer(state) ?? {};
+  let current = rootClone;
+  let currentSource = state;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const index = Number(segment);
+    const isIndex = Number.isInteger(index) && String(index) === segment;
+    const nextSource = currentSource == null ? void 0 : isIndex && Array.isArray(currentSource) ? currentSource[index] : currentSource[segment];
+    const nextSegment = segments[i + 1];
+    const nextIndex = Number(nextSegment);
+    const nextIsIndex = Number.isInteger(nextIndex) && String(nextIndex) === nextSegment;
+    const nextClone = cloneContainer(nextSource) ?? (nextIsIndex ? [] : {});
+    if (isIndex && Array.isArray(current)) {
+      current[index] = nextClone;
+    } else {
+      current[segment] = nextClone;
+    }
+    current = nextClone;
+    currentSource = nextSource;
+  }
+  const last = segments[segments.length - 1];
+  const lastIndex = Number(last);
+  const lastIsIndex = Number.isInteger(lastIndex) && String(lastIndex) === last;
+  if (lastIsIndex && Array.isArray(current)) {
+    current[lastIndex] = value;
+  } else {
+    current[last] = value;
+  }
+  return rootClone;
+};
+var unsetAtPath = (state, path) => {
+  if (!path) return state;
+  if (getAtPath(state, path) === void 0) return state;
+  const segments = path.split(".");
+  const rootClone = cloneContainer(state);
+  if (rootClone === void 0) return state;
+  let current = rootClone;
+  let currentSource = state;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const index = Number(segment);
+    const isIndex = Number.isInteger(index) && String(index) === segment;
+    const nextSource = currentSource == null ? void 0 : isIndex && Array.isArray(currentSource) ? currentSource[index] : currentSource[segment];
+    const nextClone = cloneContainer(nextSource);
+    if (nextClone === void 0) {
+      return state;
+    }
+    if (isIndex && Array.isArray(current)) {
+      current[index] = nextClone;
+    } else {
+      current[segment] = nextClone;
+    }
+    current = nextClone;
+    currentSource = nextSource;
+  }
+  const last = segments[segments.length - 1];
+  const lastIndex = Number(last);
+  const lastIsIndex = Number.isInteger(lastIndex) && String(lastIndex) === last;
+  if (lastIsIndex && Array.isArray(current)) {
+    current[lastIndex] = void 0;
+    return rootClone;
+  }
+  if (current && typeof current === "object") {
+    delete current[last];
+  }
+  return rootClone;
+};
+var updateArrayAtPath = (state, path, update) => {
+  const current = getAtPath(state, path);
+  const items = Array.isArray(current) ? current : [];
+  const next = update(items);
+  return setAtPath(state, path, next);
+};
+
+// src/Path.ts
+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 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.");
+};
+
+// src/internal/form/errors.ts
+var isErrorValueLeafObject = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const anyValue = value;
+  const msg = anyValue.message;
+  if (typeof msg !== "string" || msg.length === 0) return false;
+  for (const key of Object.keys(anyValue)) {
+    if (key !== "message" && key !== "code" && key !== "details") return false;
+  }
+  const code = anyValue.code;
+  if (code !== void 0 && (typeof code !== "string" || code.length === 0)) return false;
+  return true;
+};
+var countErrorLeaves = (value) => {
+  if (value === null || value === void 0) return 0;
+  if (typeof value === "string") return value.length > 0 ? 1 : 0;
+  if (Array.isArray(value)) return value.reduce((acc, v) => acc + countErrorLeaves(v), 0);
+  if (typeof value === "object") {
+    if (isErrorValueLeafObject(value)) return 1;
+    let acc = 0;
+    for (const [k, v] of Object.entries(value)) {
+      if (k === "$rowId") continue;
+      acc += countErrorLeaves(v);
+    }
+    return acc;
+  }
+  return 1;
+};
+var readErrorCount = (state) => {
+  const form = state && typeof state === "object" && !Array.isArray(state) ? state.$form : void 0;
+  const v = form && typeof form === "object" && !Array.isArray(form) ? form.errorCount : void 0;
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+};
+var writeErrorCount = (state, nextCount) => setAtPath(state, "$form.errorCount", Math.max(0, nextCount));
+
+// src/internal/form/arrays.ts
+var isAuxRootPath = (path) => path === "errors" || path === "ui" || path === "$form" || path.startsWith("errors.") || path.startsWith("ui.") || path.startsWith("$form.");
+var normalizeArrayToLength = (items, length) => {
+  const next = items.slice(0, length);
+  while (next.length < length) next.push(void 0);
+  return next;
+};
+var syncAuxArrays = (state, path, currentLength, update) => {
+  if (!path || isAuxRootPath(path)) return state;
+  const nextUi = updateArrayAtPath(
+    state,
+    `ui.${path}`,
+    (items) => update(normalizeArrayToLength(items, currentLength))
+  );
+  const nextErrors = updateArrayAtPath(
+    nextUi,
+    `errors.${path}.rows`,
+    (items) => update(normalizeArrayToLength(items, currentLength))
+  );
+  const manualRowsPath = `errors.$manual.${path}.rows`;
+  const nextManualErrors = getAtPath(state, manualRowsPath) !== void 0 ? updateArrayAtPath(
+    nextErrors,
+    manualRowsPath,
+    (items) => update(normalizeArrayToLength(items, currentLength))
+  ) : nextErrors;
+  const schemaRowsPath = `errors.$schema.${path}.rows`;
+  const nextSchemaErrors = getAtPath(state, schemaRowsPath) !== void 0 ? updateArrayAtPath(
+    nextManualErrors,
+    schemaRowsPath,
+    (items) => update(normalizeArrayToLength(items, currentLength))
+  ) : nextManualErrors;
+  return nextSchemaErrors;
+};
+
+// src/internal/form/reducer.ts
+var mark = (sink, path) => {
+  if (!sink) return;
+  if (typeof path !== "string" || path.length === 0) return;
+  sink(path);
+};
+var markMany = (sink, paths) => {
+  for (const path of paths) {
+    mark(sink, path);
+  }
+};
+var mergeUiMeta = (prev, patch) => {
+  const base = prev && typeof prev === "object" && !Array.isArray(prev) ? prev : {};
+  return {
+    ...base,
+    ...patch
+  };
+};
+var setUiMeta = (state, path, patch) => {
+  if (!path) return state;
+  const prev = getAtPath(state, `ui.${path}`);
+  return setAtPath(state, `ui.${path}`, mergeUiMeta(prev, patch));
+};
+var initialMeta = () => ({
+  submitCount: 0,
+  isSubmitting: false,
+  isDirty: false,
+  errorCount: 0
+});
+var makeFormReducers = (params) => {
+  const reducers = {
+    setValue: (state, action, sink) => {
+      const path = action.payload.path;
+      const prevErrorCount = readErrorCount(state);
+      if (path === "errors" || path.startsWith("errors.")) {
+        mark(sink, path);
+        const prev = getAtPath(state, path);
+        const nextValue = action.payload.value;
+        const delta = countErrorLeaves(nextValue) - countErrorLeaves(prev);
+        const next2 = setAtPath(state, path, nextValue);
+        if (delta === 0) return next2;
+        mark(sink, "$form.errorCount");
+        return writeErrorCount(next2, prevErrorCount + delta);
+      }
+      mark(sink, path);
+      const next = setAtPath(state, path, action.payload.value);
+      if (isAuxRootPath(path)) return next;
+      markMany(sink, [`ui.${path}`, "$form.isDirty"]);
+      const nextMeta = setAtPath(next, "$form.isDirty", true);
+      let nextUi = setUiMeta(nextMeta, path, { dirty: true });
+      let nextCount = prevErrorCount;
+      const manualPath = toManualErrorsPath(path);
+      const prevManual = getAtPath(nextUi, manualPath);
+      if (prevManual !== void 0) {
+        mark(sink, manualPath);
+        nextCount -= countErrorLeaves(prevManual);
+        nextUi = unsetAtPath(nextUi, manualPath);
+      }
+      const schemaPath = toSchemaErrorsPath(path);
+      const prevSchema = getAtPath(nextUi, schemaPath);
+      if (prevSchema !== void 0) {
+        mark(sink, schemaPath);
+        nextCount -= countErrorLeaves(prevSchema);
+        nextUi = unsetAtPath(nextUi, schemaPath);
+      }
+      if (nextCount === prevErrorCount) return nextUi;
+      mark(sink, "$form.errorCount");
+      return writeErrorCount(nextUi, nextCount);
+    },
+    blur: (state, action, sink) => {
+      const path = action.payload.path;
+      if (isAuxRootPath(path)) return state;
+      mark(sink, `ui.${path}`);
+      return setUiMeta(state, path, { touched: true });
+    },
+    validate: (state) => state,
+    validatePaths: (state) => state,
+    submitAttempt: (state, _action, sink) => {
+      const prev = state.$form;
+      const submitCount = prev && typeof prev === "object" && !Array.isArray(prev) && typeof prev.submitCount === "number" ? prev.submitCount : 0;
+      mark(sink, "$form.submitCount");
+      return setAtPath(state, "$form.submitCount", submitCount + 1);
+    },
+    setSubmitting: (state, action, sink) => {
+      mark(sink, "$form.isSubmitting");
+      return setAtPath(state, "$form.isSubmitting", action.payload);
+    },
+    reset: (_state, action, sink) => {
+      const values = action.payload && typeof action.payload === "object" ? action.payload : params.initialValues;
+      markMany(sink, ["errors", "ui", "$form"]);
+      if (values && typeof values === "object" && !Array.isArray(values)) {
+        for (const key of Object.keys(values)) {
+          if (!key || isAuxRootPath(key)) continue;
+          mark(sink, key);
+        }
+      }
+      return {
+        ...values,
+        errors: {},
+        ui: {},
+        $form: initialMeta()
+      };
+    },
+    setError: (state, action, sink) => {
+      const path = action.payload.path;
+      if (!path || isAuxRootPath(path)) return state;
+      const error = action.payload.error;
+      const manualPath = toManualErrorsPath(path);
+      mark(sink, manualPath);
+      const prevErrorCount = readErrorCount(state);
+      const prevManual = getAtPath(state, manualPath);
+      if (error === null || error === void 0) {
+        const next2 = unsetAtPath(state, manualPath);
+        const delta2 = -countErrorLeaves(prevManual);
+        if (delta2 === 0) return next2;
+        mark(sink, "$form.errorCount");
+        return writeErrorCount(next2, prevErrorCount + delta2);
+      }
+      const next = setAtPath(state, manualPath, error);
+      const delta = countErrorLeaves(error) - countErrorLeaves(prevManual);
+      if (delta === 0) return next;
+      mark(sink, "$form.errorCount");
+      return writeErrorCount(next, prevErrorCount + delta);
+    },
+    clearErrors: (state, action, sink) => {
+      const paths = action.payload;
+      const prevErrorCount = readErrorCount(state);
+      if (paths === void 0) {
+        const prevManual = getAtPath(state, "errors.$manual");
+        mark(sink, "errors.$manual");
+        const next2 = unsetAtPath(state, "errors.$manual");
+        const delta = -countErrorLeaves(prevManual);
+        if (delta === 0) return next2;
+        mark(sink, "$form.errorCount");
+        return writeErrorCount(next2, prevErrorCount + delta);
+      }
+      let next = state;
+      let nextCount = prevErrorCount;
+      for (const path of paths) {
+        if (typeof path !== "string" || !path || isAuxRootPath(path)) continue;
+        const manualPath = toManualErrorsPath(path);
+        const prevManual = getAtPath(next, manualPath);
+        if (prevManual !== void 0) {
+          mark(sink, manualPath);
+          nextCount -= countErrorLeaves(prevManual);
+          next = unsetAtPath(next, manualPath);
+        }
+      }
+      const out = next;
+      if (nextCount === prevErrorCount) return out;
+      mark(sink, "$form.errorCount");
+      return writeErrorCount(out, nextCount);
+    },
+    arrayAppend: (state, action, sink) => {
+      const path = action.payload.path;
+      const value = action.payload.value;
+      const current = getAtPath(state, path);
+      const currentItems = Array.isArray(current) ? current : [];
+      markMany(sink, [path, `ui.${path}`, `errors.${path}.rows`, "$form.isDirty"]);
+      if (getAtPath(state, `errors.$manual.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$manual.${path}.rows`);
+      }
+      if (getAtPath(state, `errors.$schema.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$schema.${path}.rows`);
+      }
+      const nextState = updateArrayAtPath(state, path, (items) => [...items, value]);
+      const nextSync = syncAuxArrays(nextState, path, currentItems.length, (items) => [...items, void 0]);
+      const schemaRootPath = toSchemaErrorsPath(path);
+      const prevErrorCount = readErrorCount(nextSync);
+      const prevSchema = getAtPath(nextSync, schemaRootPath);
+      mark(sink, schemaRootPath);
+      const clearedSchema = unsetAtPath(nextSync, schemaRootPath);
+      const delta = -countErrorLeaves(prevSchema);
+      const nextWithCount = delta === 0 ? clearedSchema : writeErrorCount(clearedSchema, prevErrorCount + delta);
+      if (delta !== 0) mark(sink, "$form.errorCount");
+      return isAuxRootPath(path) ? nextWithCount : setAtPath(nextWithCount, "$form.isDirty", true);
+    },
+    arrayPrepend: (state, action, sink) => {
+      const path = action.payload.path;
+      const value = action.payload.value;
+      const current = getAtPath(state, path);
+      const currentItems = Array.isArray(current) ? current : [];
+      markMany(sink, [path, `ui.${path}`, `errors.${path}.rows`, "$form.isDirty"]);
+      if (getAtPath(state, `errors.$manual.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$manual.${path}.rows`);
+      }
+      if (getAtPath(state, `errors.$schema.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$schema.${path}.rows`);
+      }
+      const nextState = updateArrayAtPath(state, path, (items) => [value, ...items]);
+      const nextSync = syncAuxArrays(nextState, path, currentItems.length, (items) => [void 0, ...items]);
+      const schemaRootPath = toSchemaErrorsPath(path);
+      const prevErrorCount = readErrorCount(nextSync);
+      const prevSchema = getAtPath(nextSync, schemaRootPath);
+      mark(sink, schemaRootPath);
+      const clearedSchema = unsetAtPath(nextSync, schemaRootPath);
+      const delta = -countErrorLeaves(prevSchema);
+      const nextWithCount = delta === 0 ? clearedSchema : writeErrorCount(clearedSchema, prevErrorCount + delta);
+      if (delta !== 0) mark(sink, "$form.errorCount");
+      return isAuxRootPath(path) ? nextWithCount : setAtPath(nextWithCount, "$form.isDirty", true);
+    },
+    arrayRemove: (state, action, sink) => {
+      const path = action.payload.path;
+      const index = action.payload.index;
+      const current = getAtPath(state, path);
+      const currentItems = Array.isArray(current) ? current : [];
+      const prevErrorCount = readErrorCount(state);
+      const prevRuleRow = getAtPath(state, `errors.${path}.rows.${index}`);
+      const prevManualRow = getAtPath(state, `errors.$manual.${path}.rows.${index}`);
+      const schemaRootPath = toSchemaErrorsPath(path);
+      const prevSchemaRoot = getAtPath(state, schemaRootPath);
+      markMany(sink, [path, `ui.${path}`, `errors.${path}.rows`, schemaRootPath, "$form.isDirty"]);
+      if (getAtPath(state, `errors.$manual.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$manual.${path}.rows`);
+      }
+      if (getAtPath(state, `errors.$schema.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$schema.${path}.rows`);
+      }
+      const nextState = updateArrayAtPath(
+        state,
+        path,
+        (items) => items.filter((_, i) => i !== index)
+      );
+      const nextSync = syncAuxArrays(
+        nextState,
+        path,
+        currentItems.length,
+        (items) => items.filter((_, i) => i !== index)
+      );
+      let nextCount = prevErrorCount;
+      nextCount -= countErrorLeaves(prevRuleRow);
+      nextCount -= countErrorLeaves(prevManualRow);
+      nextCount -= countErrorLeaves(prevSchemaRoot);
+      const clearedSchema = unsetAtPath(nextSync, schemaRootPath);
+      const nextWithCount = nextCount === prevErrorCount ? clearedSchema : writeErrorCount(clearedSchema, nextCount);
+      if (nextCount !== prevErrorCount) mark(sink, "$form.errorCount");
+      return isAuxRootPath(path) ? nextWithCount : setAtPath(nextWithCount, "$form.isDirty", true);
+    },
+    arraySwap: (state, action, sink) => {
+      const path = action.payload.path;
+      const a = action.payload.indexA;
+      const b = action.payload.indexB;
+      const current = getAtPath(state, path);
+      const currentItems = Array.isArray(current) ? current : [];
+      const schemaRootPath = toSchemaErrorsPath(path);
+      markMany(sink, [path, `ui.${path}`, `errors.${path}.rows`, schemaRootPath, "$form.isDirty"]);
+      if (getAtPath(state, `errors.$manual.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$manual.${path}.rows`);
+      }
+      if (getAtPath(state, `errors.$schema.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$schema.${path}.rows`);
+      }
+      const swap = (items) => {
+        const next = items.slice();
+        if (a >= 0 && b >= 0 && a < next.length && b < next.length) {
+          const tmp = next[a];
+          next[a] = next[b];
+          next[b] = tmp;
+        }
+        return next;
+      };
+      const nextState = updateArrayAtPath(state, path, swap);
+      const nextSync = syncAuxArrays(nextState, path, currentItems.length, swap);
+      const prevErrorCount = readErrorCount(nextSync);
+      const prevSchema = getAtPath(nextSync, schemaRootPath);
+      const clearedSchema = unsetAtPath(nextSync, schemaRootPath);
+      const delta = -countErrorLeaves(prevSchema);
+      const nextWithCount = delta === 0 ? clearedSchema : writeErrorCount(clearedSchema, prevErrorCount + delta);
+      if (delta !== 0) mark(sink, "$form.errorCount");
+      return isAuxRootPath(path) ? nextWithCount : setAtPath(nextWithCount, "$form.isDirty", true);
+    },
+    arrayMove: (state, action, sink) => {
+      const path = action.payload.path;
+      const from = action.payload.from;
+      const to = action.payload.to;
+      const current = getAtPath(state, path);
+      const currentItems = Array.isArray(current) ? current : [];
+      const schemaRootPath = toSchemaErrorsPath(path);
+      markMany(sink, [path, `ui.${path}`, `errors.${path}.rows`, schemaRootPath, "$form.isDirty"]);
+      if (getAtPath(state, `errors.$manual.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$manual.${path}.rows`);
+      }
+      if (getAtPath(state, `errors.$schema.${path}.rows`) !== void 0) {
+        mark(sink, `errors.$schema.${path}.rows`);
+      }
+      const move = (items) => {
+        const next = items.slice();
+        if (from < 0 || from >= next.length || to < 0 || to >= next.length) {
+          return next;
+        }
+        const [moved] = next.splice(from, 1);
+        next.splice(to, 0, moved);
+        return next;
+      };
+      const nextState = updateArrayAtPath(state, path, move);
+      const nextSync = syncAuxArrays(nextState, path, currentItems.length, move);
+      const prevErrorCount = readErrorCount(nextSync);
+      const prevSchema = getAtPath(nextSync, schemaRootPath);
+      const clearedSchema = unsetAtPath(nextSync, schemaRootPath);
+      const delta = -countErrorLeaves(prevSchema);
+      const nextWithCount = delta === 0 ? clearedSchema : writeErrorCount(clearedSchema, prevErrorCount + delta);
+      if (delta !== 0) mark(sink, "$form.errorCount");
+      return isAuxRootPath(path) ? nextWithCount : setAtPath(nextWithCount, "$form.isDirty", true);
+    }
+  };
+  return reducers;
+};
+
+// src/internal/form/controller.ts
+var Logix = __toESM(require("@logixjs/core"), 1);
+var import_effect = require("effect");
+
+// src/internal/schema/SchemaPathMapping.ts
+var isNumericSegment2 = (seg) => /^[0-9]+$/.test(seg);
+var parseSegmentsFromString = (path) => {
+  if (!path) return [];
+  return path.split(".").filter(Boolean).map((seg) => isNumericSegment2(seg) ? Number(seg) : seg);
+};
+var asSegments = (value) => {
+  if (typeof value === "string") return parseSegmentsFromString(value);
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const x of value) {
+      if (typeof x === "number" && Number.isFinite(x)) {
+        parts.push(Math.floor(x));
+        continue;
+      }
+      if (typeof x === "string" && x.length > 0) {
+        parts.push(isNumericSegment2(x) ? Number(x) : x);
+      }
+    }
+    return parts.length ? parts : void 0;
+  }
+  return void 0;
+};
+var toConcretePath = (segments) => segments.map(String).join(".");
+var toPatternPath = (segments) => {
+  const out = [];
+  const indices = [];
+  for (const seg of segments) {
+    if (typeof seg === "number") {
+      out.push("[]");
+      indices.push(seg);
+    } else {
+      out.push(seg);
+    }
+  }
+  const pattern2 = out.join(".").replace(/\.\[\]/g, "[]");
+  return { pattern: pattern2, indices };
+};
+var applyIndicesToPattern = (pattern2, indices) => {
+  if (!pattern2) return pattern2;
+  const raw = pattern2.split(".").filter(Boolean);
+  const out = [];
+  let cursor = 0;
+  for (const part of raw) {
+    if (part === "[]") {
+      const idx = indices[cursor++];
+      if (idx === void 0) return void 0;
+      out.push(String(idx));
+      continue;
+    }
+    if (part.endsWith("[]") && part.length > 2) {
+      const base = part.slice(0, -2);
+      out.push(base);
+      const idx = indices[cursor++];
+      if (idx === void 0) return void 0;
+      out.push(String(idx));
+      continue;
+    }
+    out.push(part);
+  }
+  return out.join(".");
+};
+var concatPaths = (prefix, rest) => {
+  if (!prefix) return rest;
+  if (!rest) return prefix;
+  return `${prefix}.${rest}`;
+};
+var mapByRename = (segments, rename) => {
+  const concrete = toConcretePath(segments);
+  const direct = rename[concrete];
+  if (direct !== void 0) {
+    return direct;
+  }
+  const { pattern: pattern2, indices } = toPatternPath(segments);
+  const patternDirect = rename[pattern2];
+  if (patternDirect !== void 0) {
+    return applyIndicesToPattern(patternDirect, indices);
+  }
+  const keys = Object.keys(rename).sort((a, b) => b.length - a.length);
+  for (const from of keys) {
+    const to = rename[from];
+    const isPattern = from.includes("[]");
+    const target = isPattern ? pattern2 : concrete;
+    if (target === from || target.startsWith(`${from}.`)) {
+      const rawRest = target.slice(from.length);
+      const rest = rawRest.startsWith(".") ? rawRest.slice(1) : rawRest;
+      const mapped = concatPaths(to, rest);
+      return isPattern ? applyIndicesToPattern(mapped, indices) : mapped;
+    }
+  }
+  const segMap = {};
+  for (const [from, to] of Object.entries(rename)) {
+    if (from.includes(".") || from.includes("[]")) continue;
+    if (to.includes(".") || to.includes("[]")) continue;
+    if (!to) continue;
+    segMap[from] = to;
+  }
+  if (Object.keys(segMap).length === 0) return void 0;
+  const mappedSegments = segments.map((seg) => typeof seg === "string" ? segMap[seg] ?? seg : seg);
+  return toConcretePath(mappedSegments);
+};
+var extractRawPaths = (schemaError) => {
+  const out = [];
+  if (schemaError && typeof schemaError === "object") {
+    const anyErr = schemaError;
+    if (Array.isArray(anyErr.errors)) {
+      for (const e of anyErr.errors) {
+        if (e && typeof e === "object" && "path" in e) {
+          out.push(e.path);
+        }
+      }
+    }
+    if (Array.isArray(anyErr.issues)) {
+      for (const e of anyErr.issues) {
+        if (e && typeof e === "object" && "path" in e) {
+          out.push(e.path);
+        }
+      }
+    }
+    if ("path" in anyErr) {
+      out.push(anyErr.path);
+    }
+  }
+  return out;
+};
+var mapSchemaErrorToFieldPaths = (schemaError, options) => {
+  const fromEscapeHatch = options?.errorMap?.(schemaError);
+  if (fromEscapeHatch && fromEscapeHatch.length) {
+    return Array.from(new Set(fromEscapeHatch.filter((p) => typeof p === "string" && p.length > 0)));
+  }
+  const rename = options?.rename;
+  const results = [];
+  for (const rawPath of extractRawPaths(schemaError)) {
+    const segments = asSegments(rawPath);
+    if (!segments || segments.length === 0) continue;
+    const mapped = rename ? mapByRename(segments, rename) : void 0;
+    const path = mapped ?? toConcretePath(segments);
+    if (path) results.push(path);
+  }
+  return Array.from(new Set(results));
+};
+
+// src/internal/schema/SchemaErrorMapping.ts
+var toSchemaErrorWrites = (schemaError, options) => {
+  const fieldPaths = mapSchemaErrorToFieldPaths(schemaError, options);
+  if (fieldPaths.length === 0) return [];
+  const toLeaf = options?.toLeaf ?? ((e) => e);
+  const leaf = toLeaf(schemaError);
+  return fieldPaths.map((fieldPath) => ({
+    fieldPath,
+    errorPath: toSchemaErrorsPath(fieldPath),
+    error: leaf
+  }));
+};
+var toSchemaErrorTree = (schemaError, options) => {
+  const writes = toSchemaErrorWrites(schemaError, options);
+  if (writes.length === 0) return {};
+  let next = {};
+  for (const w of writes) {
+    const prefix = "errors.$schema.";
+    const relative = w.errorPath.startsWith(prefix) ? w.errorPath.slice(prefix.length) : w.errorPath;
+    if (!relative) continue;
+    next = setAtPath(next, relative, w.error);
+  }
+  return next;
+};
+
+// src/internal/form/controller.ts
+var makeFormController = (params) => {
+  const runtime = params.runtime;
+  const bound = Logix.Bound.make(params.shape, runtime);
+  return {
+    runtime,
+    getState: runtime.getState,
+    dispatch: runtime.dispatch,
+    submit: () => runtime.dispatch({ _tag: "submit", payload: void 0 }),
+    controller: {
+      validate: () => import_effect.Effect.gen(function* () {
+        yield* Logix.TraitLifecycle.scopedValidate(bound, {
+          mode: "manual",
+          target: Logix.TraitLifecycle.Ref.root()
+        });
+        const state = yield* runtime.getState;
+        const { errors: _errors, ui: _ui, $form: _meta, ...values } = state;
+        const decoded = import_effect.Schema.decodeUnknownEither(params.valuesSchema)(values);
+        const schemaTree = decoded._tag === "Right" ? {} : toSchemaErrorTree(decoded.left);
+        yield* runtime.dispatch({
+          _tag: "setValue",
+          payload: { path: "errors.$schema", value: schemaTree }
+        });
+      }),
+      validatePaths: (paths) => import_effect.Effect.gen(function* () {
+        const list3 = typeof paths === "string" ? [paths] : paths;
+        if (!list3 || list3.length === 0) return;
+        const state = yield* runtime.getState;
+        for (const raw of list3) {
+          if (typeof raw !== "string") continue;
+          const path = raw.trim();
+          if (!path || isAuxRootPath(path)) continue;
+          const value = getAtPath(state, path);
+          const target = Array.isArray(value) ? Logix.TraitLifecycle.Ref.list(path) : Logix.TraitLifecycle.Ref.fromValuePath(path);
+          yield* Logix.TraitLifecycle.scopedValidate(bound, {
+            mode: "manual",
+            target
+          });
+        }
+      }),
+      reset: (values) => runtime.dispatch({ _tag: "reset", payload: values }),
+      setError: (path, error) => runtime.dispatch({ _tag: "setError", payload: { path, error } }),
+      clearErrors: (paths) => runtime.dispatch({
+        _tag: "clearErrors",
+        payload: paths === void 0 ? void 0 : typeof paths === "string" ? [paths] : paths
+      }),
+      handleSubmit: (handlers) => import_effect.Effect.gen(function* () {
+        yield* runtime.dispatch({ _tag: "submitAttempt", payload: void 0 });
+        yield* runtime.dispatch({ _tag: "setSubmitting", payload: true });
+        yield* Logix.TraitLifecycle.scopedValidate(bound, {
+          mode: "submit",
+          target: Logix.TraitLifecycle.Ref.root()
+        });
+        const stateAfterRules = yield* runtime.getState;
+        const {
+          errors: _errorsAfterRules,
+          ui: _uiAfterRules,
+          $form: _metaAfterRules,
+          ...valuesAfterRules
+        } = stateAfterRules;
+        const decoded = import_effect.Schema.decodeUnknownEither(params.valuesSchema)(valuesAfterRules);
+        const schemaTree = decoded._tag === "Right" ? {} : toSchemaErrorTree(decoded.left);
+        yield* runtime.dispatch({
+          _tag: "setValue",
+          payload: { path: "errors.$schema", value: schemaTree }
+        });
+        const state = yield* runtime.getState;
+        const errorCount = readErrorCount(state);
+        if (errorCount > 0) {
+          if (handlers.onInvalid) {
+            yield* handlers.onInvalid(state.errors);
+          }
+          return;
+        }
+        const { errors: _errorsFinal, ui: _uiFinal, $form: _metaFinal, ...valuesFinal } = state;
+        yield* handlers.onValid(valuesFinal);
+      }).pipe(import_effect.Effect.ensuring(runtime.dispatch({ _tag: "setSubmitting", payload: false })))
+    },
+    field: (path) => ({
+      get: runtime.getState.pipe(import_effect.Effect.map((s) => getAtPath(s, path))),
+      set: (value) => runtime.dispatch({ _tag: "setValue", payload: { path, value } }),
+      blur: () => runtime.dispatch({ _tag: "blur", payload: { path } })
+    }),
+    fieldArray: (path) => ({
+      get: runtime.getState.pipe(
+        import_effect.Effect.map((s) => {
+          const value = getAtPath(s, path);
+          return Array.isArray(value) ? value : [];
+        })
+      ),
+      append: (value) => runtime.dispatch({ _tag: "arrayAppend", payload: { path, value } }),
+      prepend: (value) => runtime.dispatch({ _tag: "arrayPrepend", payload: { path, value } }),
+      remove: (index) => runtime.dispatch({ _tag: "arrayRemove", payload: { path, index } }),
+      swap: (indexA, indexB) => runtime.dispatch({ _tag: "arraySwap", payload: { path, indexA, indexB } }),
+      move: (from, to) => runtime.dispatch({ _tag: "arrayMove", payload: { path, from, to } })
+    })
+  };
+};
+
+// src/internal/dsl/traits.ts
+var Logix2 = __toESM(require("@logixjs/core"), 1);
+var isPlainObject2 = (value) => Boolean(value) && typeof value === "object" && value !== null && !Array.isArray(value);
+var isStateTraitNode = (value) => Boolean(value) && typeof value === "object" && value._tag === "StateTraitNode";
+var isStateTraitList = (value) => Boolean(value) && typeof value === "object" && value._tag === "StateTraitList";
+var isStateTraitEntry = (value) => Boolean(value) && typeof value === "object" && typeof value.kind === "string";
+var normalizeRule = (rule) => {
+  if (typeof rule === "function") {
+    return { deps: [], validate: rule };
+  }
+  if (!isPlainObject2(rule)) return rule;
+  const validate = rule.validate;
+  if (typeof validate !== "function") return rule;
+  const depsRaw = rule.deps;
+  const deps = Array.isArray(depsRaw) ? depsRaw : [];
+  return { ...rule, deps };
+};
+var normalizeNode = (value) => {
+  const raw = isStateTraitNode(value) ? value : value;
+  const checkRaw = raw?.check;
+  const check = checkRaw && typeof checkRaw === "object" && !Array.isArray(checkRaw) ? Object.fromEntries(Object.entries(checkRaw).map(([k, v]) => [k, normalizeRule(v)])) : checkRaw;
+  return isStateTraitNode(value) ? { ...raw, ...checkRaw !== void 0 ? { check } : {} } : Logix2.StateTrait.node({ ...raw, ...checkRaw !== void 0 ? { check } : {} });
+};
+var normalizeList = (value) => {
+  const raw = isStateTraitList(value) ? value : value;
+  const item = raw?.item ? normalizeNodeOrListOrEntry(raw.item) : void 0;
+  const list3 = raw?.list ? normalizeNodeOrListOrEntry(raw.list) : void 0;
+  const next = {
+    ...raw,
+    ...raw?.item !== void 0 ? { item } : {},
+    ...raw?.list !== void 0 ? { list: list3 } : {}
+  };
+  return isStateTraitList(value) ? next : Logix2.StateTrait.list(next);
+};
+var normalizeNodeOrListOrEntry = (value) => {
+  if (isStateTraitEntry(value)) return value;
+  if (isStateTraitNode(value)) return normalizeNode(value);
+  if (isStateTraitList(value)) return normalizeList(value);
+  if (isPlainObject2(value)) {
+    if ("item" in value || "list" in value || "identityHint" in value) {
+      return normalizeList(value);
+    }
+    if ("check" in value || "computed" in value || "source" in value || "link" in value || "meta" in value) {
+      return normalizeNode(value);
+    }
+  }
+  return value;
+};
+var traits = (_valuesSchema) => {
+  function run(spec) {
+    return Object.fromEntries(Object.entries(spec).map(([k, v]) => [k, normalizeNodeOrListOrEntry(v)]));
+  }
+  return run;
+};
+
+// src/internal/form/install.ts
+var Logix3 = __toESM(require("@logixjs/core"), 1);
+var import_effect2 = require("effect");
+var isAuxRootPath2 = (path) => path === "errors" || path === "ui" || path === "$form" || path.startsWith("errors.") || path.startsWith("ui.") || path.startsWith("$form.");
+var install = (module2, config) => module2.logic(($) => {
+  const validateOn = config?.validateOn ?? ["onSubmit"];
+  const reValidateOn = config?.reValidateOn ?? ["onChange"];
+  const rulesValidateOn = config?.rulesValidateOn ?? [];
+  const debounceMs = config?.debounceMs;
+  const sourceWiring = Logix3.TraitLifecycle.makeSourceWiring($, module2);
+  const validate = (trigger, path) => Logix3.TraitLifecycle.scopedValidate($, {
+    mode: trigger,
+    target: Logix3.TraitLifecycle.Ref.fromValuePath(path)
+  });
+  const validateRoot = () => Logix3.TraitLifecycle.scopedValidate($, {
+    mode: "submit",
+    target: Logix3.TraitLifecycle.Ref.root()
+  });
+  const pending = /* @__PURE__ */ new Map();
+  const cancelPending = (path) => import_effect2.Effect.gen(function* () {
+    const prev = pending.get(path);
+    if (!prev) return;
+    pending.delete(path);
+    yield* import_effect2.Fiber.interruptFork(prev);
+  });
+  const scheduleDebouncedValidate = (path) => import_effect2.Effect.gen(function* () {
+    const ms = debounceMs ?? 0;
+    if (ms <= 0) {
+      yield* validate("valueChange", path);
+      return;
+    }
+    yield* cancelPending(path);
+    const fiber = yield* import_effect2.Effect.forkScoped(
+      import_effect2.Effect.sleep(import_effect2.Duration.millis(ms)).pipe(
+        import_effect2.Effect.zipRight(validate("valueChange", path)),
+        import_effect2.Effect.ensuring(import_effect2.Effect.sync(() => pending.delete(path))),
+        import_effect2.Effect.catchAllCause(() => import_effect2.Effect.void)
+      )
+    );
+    pending.set(path, fiber);
+  });
+  const has = (list3, item) => list3.includes(item);
+  const wantsChange = has(validateOn, "onChange") || has(reValidateOn, "onChange") || rulesValidateOn.includes("onChange");
+  const wantsBlur = has(validateOn, "onBlur") || has(reValidateOn, "onBlur") || rulesValidateOn.includes("onBlur");
+  const shouldValidateNow = (submitCount, trigger) => {
+    const effective = submitCount > 0 ? reValidateOn : validateOn;
+    if (effective.includes(trigger)) return true;
+    return rulesValidateOn.includes(trigger);
+  };
+  const readSubmitCount2 = (state) => {
+    const form = state && typeof state === "object" && !Array.isArray(state) ? state.$form : void 0;
+    const v = form && typeof form === "object" && !Array.isArray(form) ? form.submitCount : void 0;
+    return typeof v === "number" && Number.isFinite(v) ? v : 0;
+  };
+  const setup = sourceWiring.setup;
+  const run = import_effect2.Effect.gen(function* () {
+    if (wantsBlur) {
+      yield* $.onAction("blur").runFork(
+        (action) => import_effect2.Effect.gen(function* () {
+          const path = action.payload.path;
+          if (!path || isAuxRootPath2(path)) return;
+          yield* cancelPending(path);
+          const state = yield* $.state.read;
+          const submitCount = readSubmitCount2(state);
+          if (!shouldValidateNow(submitCount, "onBlur")) return;
+          yield* validate("blur", path);
+        })
+      );
+    }
+    yield* $.onAction("setValue").runFork(
+      (action) => import_effect2.Effect.gen(function* () {
+        const path = action.payload.path;
+        if (!path || isAuxRootPath2(path)) return;
+        yield* sourceWiring.refreshOnKeyChange(path);
+        yield* cancelPending(path);
+        if (!wantsChange) return;
+        const state = yield* $.state.read;
+        const submitCount = readSubmitCount2(state);
+        if (!shouldValidateNow(submitCount, "onChange")) return;
+        yield* scheduleDebouncedValidate(path);
+      })
+    );
+    yield* $.onAction("submit").runFork(
+      () => import_effect2.Effect.gen(function* () {
+        pending.clear();
+        yield* validateRoot();
+      })
+    );
+    yield* $.onAction("arrayAppend").runFork(
+      (action) => import_effect2.Effect.gen(function* () {
+        yield* sourceWiring.refreshOnKeyChange(action.payload.path);
+        if (!wantsChange) return;
+        const state = yield* $.state.read;
+        const submitCount = readSubmitCount2(state);
+        if (!shouldValidateNow(submitCount, "onChange")) return;
+        yield* Logix3.TraitLifecycle.scopedValidate($, {
+          mode: "valueChange",
+          target: Logix3.TraitLifecycle.Ref.list(action.payload.path)
+        });
+      })
+    );
+    yield* $.onAction("arrayPrepend").runFork(
+      (action) => import_effect2.Effect.gen(function* () {
+        yield* sourceWiring.refreshOnKeyChange(action.payload.path);
+        if (!wantsChange) return;
+        const state = yield* $.state.read;
+        const submitCount = readSubmitCount2(state);
+        if (!shouldValidateNow(submitCount, "onChange")) return;
+        yield* Logix3.TraitLifecycle.scopedValidate($, {
+          mode: "valueChange",
+          target: Logix3.TraitLifecycle.Ref.list(action.payload.path)
+        });
+      })
+    );
+    yield* $.onAction("arrayRemove").runFork(
+      (action) => import_effect2.Effect.gen(function* () {
+        yield* sourceWiring.refreshOnKeyChange(action.payload.path);
+        if (!wantsChange) return;
+        const state = yield* $.state.read;
+        const submitCount = readSubmitCount2(state);
+        if (!shouldValidateNow(submitCount, "onChange")) return;
+        yield* Logix3.TraitLifecycle.scopedValidate($, {
+          mode: "valueChange",
+          target: Logix3.TraitLifecycle.Ref.list(action.payload.path)
+        });
+      })
+    );
+    yield* $.onAction("arraySwap").runFork(
+      (action) => import_effect2.Effect.gen(function* () {
+        yield* sourceWiring.refreshOnKeyChange(action.payload.path);
+        if (!wantsChange) return;
+        const state = yield* $.state.read;
+        const submitCount = readSubmitCount2(state);
+        if (!shouldValidateNow(submitCount, "onChange")) return;
+        yield* Logix3.TraitLifecycle.scopedValidate($, {
+          mode: "valueChange",
+          target: Logix3.TraitLifecycle.Ref.list(action.payload.path)
+        });
+      })
+    );
+    yield* $.onAction("arrayMove").runFork(
+      (action) => import_effect2.Effect.gen(function* () {
+        yield* sourceWiring.refreshOnKeyChange(action.payload.path);
+        if (!wantsChange) return;
+        const state = yield* $.state.read;
+        const submitCount = readSubmitCount2(state);
+        if (!shouldValidateNow(submitCount, "onChange")) return;
+        yield* Logix3.TraitLifecycle.scopedValidate($, {
+          mode: "valueChange",
+          target: Logix3.TraitLifecycle.Ref.list(action.payload.path)
+        });
+      })
+    );
+  }).pipe(import_effect2.Effect.asVoid);
+  return { setup, run };
+});
+
+// src/internal/form/artifacts.ts
+var formRulesManifestArtifactKey = "@logixjs/form.rulesManifest@v1";
+var makeFormRulesManifestArtifactExporter = (params) => ({
+  exporterId: "logix-form.rulesManifest@v1",
+  artifactKey: formRulesManifestArtifactKey,
+  export: () => {
+    const manifest = params.getManifest();
+    const warnings = params.getWarnings();
+    return {
+      manifest,
+      warnings: Array.isArray(warnings) ? warnings : []
+    };
+  }
+});
+
+// src/internal/validators/index.ts
+var import_effect3 = require("effect");
+var ERROR_VALUE_MAX_BYTES = 256;
+var textEncoder = new TextEncoder();
+var jsonByteSize = (value) => {
+  const json = JSON.stringify(value);
+  return textEncoder.encode(json).length;
+};
+var truncateToJsonByteBudget = (value, maxBytes) => {
+  if (jsonByteSize(value) <= maxBytes) return value;
+  let lo = 0;
+  let hi = value.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    const slice = value.slice(0, mid);
+    if (jsonByteSize(slice) <= maxBytes) lo = mid;
+    else hi = mid - 1;
+  }
+  return value.slice(0, lo);
+};
+var assertErrorValueBudget = (value, label) => {
+  const bytes = jsonByteSize(value);
+  if (bytes <= ERROR_VALUE_MAX_BYTES) return value;
+  throw new Error(`[Form.validators] ErrorValue for "${label}" must be JSON \u2264${ERROR_VALUE_MAX_BYTES}B (got ${bytes}B)`);
+};
+var errorValue = (label, value) => assertErrorValueBudget(value, label);
+var required = (decl) => {
+  const trim = typeof decl === "object" && decl !== null ? Boolean(decl.trim) : true;
+  const message = typeof decl === "string" ? decl : typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "required";
+  const err = errorValue("required", message);
+  return (value) => {
+    if (value === null || value === void 0) return err;
+    if (typeof value === "string") {
+      const v = trim ? value.trim() : value;
+      return v.length > 0 ? void 0 : err;
+    }
+    if (Array.isArray(value)) return value.length > 0 ? void 0 : err;
+    if (typeof value === "boolean") return value ? void 0 : err;
+    return void 0;
+  };
+};
+var minLength = (decl) => {
+  const min2 = typeof decl === "number" ? decl : decl.min;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "minLength";
+  const err = errorValue("minLength", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "string") return value.length >= min2 ? void 0 : err;
+    if (Array.isArray(value)) return value.length >= min2 ? void 0 : err;
+    return void 0;
+  };
+};
+var maxLength = (decl) => {
+  const max2 = typeof decl === "number" ? decl : decl.max;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "maxLength";
+  const err = errorValue("maxLength", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "string") return value.length <= max2 ? void 0 : err;
+    if (Array.isArray(value)) return value.length <= max2 ? void 0 : err;
+    return void 0;
+  };
+};
+var min = (decl) => {
+  const minValue = typeof decl === "number" ? decl : decl.min;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "min";
+  const err = errorValue("min", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "number" && Number.isFinite(value)) return value >= minValue ? void 0 : err;
+    return void 0;
+  };
+};
+var max = (decl) => {
+  const maxValue = typeof decl === "number" ? decl : decl.max;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "max";
+  const err = errorValue("max", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "number" && Number.isFinite(value)) return value <= maxValue ? void 0 : err;
+    return void 0;
+  };
+};
+var pattern = (decl) => {
+  const re = decl instanceof RegExp ? decl : decl.re;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "pattern";
+  const err = errorValue("pattern", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "string") return void 0;
+    return re.test(value) ? void 0 : err;
+  };
+};
+var schemaErrorMessage = (schemaError) => {
+  let message;
+  try {
+    message = import_effect3.ParseResult.TreeFormatter.formatErrorSync(schemaError);
+  } catch {
+    message = "schema invalid";
+  }
+  const truncated = truncateToJsonByteBudget(message, ERROR_VALUE_MAX_BYTES);
+  return truncated.length > 0 ? truncated : "schema invalid";
+};
+
+// src/Rule.ts
+var uniq = (items) => Array.from(new Set(items));
+var normalizeValidateOn2 = (input) => {
+  if (!Array.isArray(input)) return void 0;
+  const out = [];
+  for (const x of input) {
+    if (x === "onChange" || x === "onBlur") out.push(x);
+  }
+  return uniq(out);
+};
+var normalizeDeps = (input) => {
+  if (!Array.isArray(input)) return void 0;
+  const out = [];
+  for (const x of input) {
+    if (typeof x !== "string") continue;
+    const v = x.trim();
+    if (!v) continue;
+    out.push(v);
+  }
+  return uniq(out);
+};
+var isPlainObject3 = (value) => Boolean(value) && typeof value === "object" && value !== null && !Array.isArray(value);
+var make = (input) => {
+  if (typeof input === "function") {
+    return {
+      default: {
+        deps: [],
+        validate: input
+      }
+    };
+  }
+  if (!isPlainObject3(input)) {
+    return {};
+  }
+  const baseDeps = normalizeDeps(input.deps) ?? [];
+  const baseValidateOn = normalizeValidateOn2(input.validateOn);
+  const byName = /* @__PURE__ */ new Map();
+  const addRule = (name, raw) => {
+    const ruleName = typeof name === "string" ? name.trim() : "";
+    if (!ruleName) return;
+    if (byName.has(ruleName)) {
+      throw new Error(`[Form.Rule.make] Duplicate rule name "${ruleName}"`);
+    }
+    if (typeof raw === "function") {
+      byName.set(ruleName, {
+        deps: baseDeps,
+        validate: raw,
+        ...baseValidateOn !== void 0 ? { validateOn: baseValidateOn } : {}
+      });
+      return;
+    }
+    if (!raw || typeof raw !== "object") return;
+    const entry = raw;
+    const deps = normalizeDeps(entry.deps) ?? baseDeps;
+    const validateOn = normalizeValidateOn2(entry.validateOn) ?? baseValidateOn;
+    const validate = entry.validate;
+    if (typeof validate !== "function") return;
+    byName.set(ruleName, {
+      ...entry,
+      deps,
+      validate,
+      ...validateOn !== void 0 ? { validateOn } : {}
+    });
+  };
+  const requiredDecl = input.required;
+  if (requiredDecl !== void 0 && requiredDecl !== false) {
+    const validate = required(requiredDecl);
+    addRule("required", (value) => validate(value));
+  }
+  const minLengthDecl = input.minLength;
+  if (minLengthDecl !== void 0) {
+    const validate = minLength(minLengthDecl);
+    addRule("minLength", (value) => validate(value));
+  }
+  const maxLengthDecl = input.maxLength;
+  if (maxLengthDecl !== void 0) {
+    const validate = maxLength(maxLengthDecl);
+    addRule("maxLength", (value) => validate(value));
+  }
+  const minDecl = input.min;
+  if (minDecl !== void 0) {
+    const validate = min(minDecl);
+    addRule("min", (value) => validate(value));
+  }
+  const maxDecl = input.max;
+  if (maxDecl !== void 0) {
+    const validate = max(maxDecl);
+    addRule("max", (value) => validate(value));
+  }
+  const patternDecl = input.pattern;
+  if (patternDecl !== void 0) {
+    const validate = pattern(patternDecl);
+    addRule("pattern", (value) => validate(value));
+  }
+  const validateBlock = input.validate;
+  if (typeof validateBlock === "function") {
+    addRule("validate", validateBlock);
+  } else if (isPlainObject3(validateBlock)) {
+    const names2 = Object.keys(validateBlock).sort((a, b) => a.localeCompare(b));
+    for (const name of names2) {
+      addRule(name, validateBlock[name]);
+    }
+  }
+  const out = {};
+  const names = Array.from(byName.keys()).sort((a, b) => a.localeCompare(b));
+  for (const name of names) {
+    out[name] = byName.get(name);
+  }
+  return out;
+};
+var field = (valuePath, rule, options) => ({
+  kind: "field",
+  valuePath,
+  rule,
+  ...options?.errorTarget !== void 0 ? { errorTarget: options.errorTarget } : {}
+});
+var root = (rule) => ({
+  kind: "root",
+  rule
+});
+var list = (listPath, spec) => ({
+  kind: "list",
+  listPath,
+  identity: spec.identity,
+  ...spec.item !== void 0 ? { item: spec.item } : {},
+  ...spec.list !== void 0 ? { list: spec.list } : {}
+});
+
+// src/internal/form/impl.ts
+var FormActions = {
+  setValue: import_effect4.Schema.Struct({ path: import_effect4.Schema.String, value: import_effect4.Schema.Unknown }),
+  blur: import_effect4.Schema.Struct({ path: import_effect4.Schema.String }),
+  submit: import_effect4.Schema.Void,
+  validate: import_effect4.Schema.Void,
+  validatePaths: import_effect4.Schema.Array(import_effect4.Schema.String),
+  submitAttempt: import_effect4.Schema.Void,
+  setSubmitting: import_effect4.Schema.Boolean,
+  reset: import_effect4.Schema.UndefinedOr(import_effect4.Schema.Unknown),
+  setError: import_effect4.Schema.Struct({ path: import_effect4.Schema.String, error: import_effect4.Schema.Unknown }),
+  clearErrors: import_effect4.Schema.UndefinedOr(import_effect4.Schema.Array(import_effect4.Schema.String)),
+  arrayAppend: import_effect4.Schema.Struct({ path: import_effect4.Schema.String, value: import_effect4.Schema.Unknown }),
+  arrayPrepend: import_effect4.Schema.Struct({ path: import_effect4.Schema.String, value: import_effect4.Schema.Unknown }),
+  arrayRemove: import_effect4.Schema.Struct({ path: import_effect4.Schema.String, index: import_effect4.Schema.Number }),
+  arraySwap: import_effect4.Schema.Struct({
+    path: import_effect4.Schema.String,
+    indexA: import_effect4.Schema.Number,
+    indexB: import_effect4.Schema.Number
+  }),
+  arrayMove: import_effect4.Schema.Struct({
+    path: import_effect4.Schema.String,
+    from: import_effect4.Schema.Number,
+    to: import_effect4.Schema.Number
+  })
+};
+var initialMeta2 = () => ({
+  submitCount: 0,
+  isSubmitting: false,
+  isDirty: false,
+  errorCount: 0
+});
+var make2 = (id, config, extend) => {
+  const ErrorsSchema = import_effect4.Schema.Unknown;
+  const UiSchema = import_effect4.Schema.Unknown;
+  const MetaSchema = import_effect4.Schema.Struct({
+    submitCount: import_effect4.Schema.Number,
+    isSubmitting: import_effect4.Schema.Boolean,
+    isDirty: import_effect4.Schema.Boolean,
+    errorCount: import_effect4.Schema.Number
+  });
+  const StateSchema = import_effect4.Schema.extend(
+    config.values,
+    import_effect4.Schema.Struct({
+      errors: ErrorsSchema,
+      ui: UiSchema,
+      $form: MetaSchema
+    })
+  );
+  const Actions = FormActions;
+  const reducers = makeFormReducers({
+    initialValues: config.initialValues
+  });
+  const validateOn = normalizeValidateOn(config.validateOn, ["onSubmit"]);
+  const reValidateOn = normalizeValidateOn(config.reValidateOn, ["onChange"]);
+  const assertCanonicalValuePath2 = (label, path) => {
+    const p = String(path ?? "").trim();
+    if (!p) throw new Error(`[Form.make] ${label} must be a non-empty path`);
+    if (p === "$root") return;
+    if (p.includes("[]") || p.includes("[") || p.includes("]")) {
+      throw new Error(`[Form.make] ${label} "${p}" must not use bracket syntax`);
+    }
+    const segments = p.split(".").map((s) => s.trim()).filter(Boolean);
+    if (segments.length === 0) {
+      throw new Error(`[Form.make] ${label} "${p}" must be a non-empty path`);
+    }
+    for (const seg of segments) {
+      if (/^[0-9]+$/.test(seg)) {
+        throw new Error(`[Form.make] ${label} "${p}" must not contain numeric segments`);
+      }
+    }
+  };
+  const assertValidListIdentity2 = (identity, listPath) => {
+    if (!identity || typeof identity !== "object") {
+      throw new Error(`[Form.make] Missing list identity for "${listPath}"`);
+    }
+    const mode = identity.mode;
+    if (mode === "trackBy") {
+      const trackBy = identity.trackBy;
+      if (typeof trackBy !== "string" || trackBy.trim().length === 0) {
+        throw new Error(`[Form.make] identity.trackBy for "${listPath}" must be a non-empty string`);
+      }
+      if (trackBy.includes("[") || trackBy.includes("]")) {
+        throw new Error(`[Form.make] identity.trackBy for "${listPath}" must not contain brackets (got "${trackBy}")`);
+      }
+      return;
+    }
+    if (mode === "store" || mode === "index") return;
+    throw new Error(`[Form.make] Invalid identity.mode for "${listPath}" (got "${String(mode)}")`);
+  };
+  const compileRulesToTraitSpec = (rulesSpec2) => {
+    if (!rulesSpec2 || rulesSpec2._tag !== "FormRulesSpec") {
+      throw new Error(`[Form.make] "rules" must be a FormRulesSpec (from Form.rules(...)/rules.schema(...))`);
+    }
+    const joinPath2 = (prefix, suffix) => {
+      if (!prefix) return suffix;
+      if (!suffix) return prefix;
+      return `${prefix}.${suffix}`;
+    };
+    const dirnamePath = (path) => {
+      const p = String(path ?? "").trim();
+      if (!p) return "";
+      const idx = p.lastIndexOf(".");
+      return idx >= 0 ? p.slice(0, idx) : "";
+    };
+    const isRelativeDep = (dep) => {
+      if (typeof dep !== "string") return false;
+      const d = dep.trim();
+      if (!d) return false;
+      if (d === "$root") return false;
+      if (d.includes("[") || d.includes("]")) return false;
+      if (d.includes(".")) return false;
+      return true;
+    };
+    const prefixDeps = (deps, prefix) => {
+      if (!Array.isArray(deps)) return void 0;
+      const out = [];
+      for (const raw of deps) {
+        if (typeof raw !== "string") continue;
+        const d = raw.trim();
+        if (!d) continue;
+        out.push(isRelativeDep(d) ? joinPath2(prefix, d) : d);
+      }
+      return out;
+    };
+    const prefixRuleInputDeps = (input, prefix) => {
+      if (!input || typeof input !== "object") return input;
+      if (Array.isArray(input)) return input;
+      const anyInput = input;
+      const deps = prefixDeps(anyInput.deps, prefix);
+      const validate = anyInput.validate;
+      if (typeof validate === "function") {
+        return deps !== void 0 ? { ...anyInput, deps } : input;
+      }
+      if (validate && typeof validate === "object" && !Array.isArray(validate)) {
+        const nextValidate = { ...validate };
+        for (const [name, raw] of Object.entries(validate)) {
+          if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+          const entryDeps = prefixDeps(raw.deps, prefix);
+          if (entryDeps !== void 0) {
+            nextValidate[name] = { ...raw, deps: entryDeps };
+          }
+        }
+        return {
+          ...anyInput,
+          ...deps !== void 0 ? { deps } : {},
+          validate: nextValidate
+        };
+      }
+      return deps !== void 0 ? { ...anyInput, deps } : input;
+    };
+    const decls = Array.isArray(rulesSpec2.decls) ? rulesSpec2.decls : [];
+    const spec = {};
+    const declared = /* @__PURE__ */ new Set();
+    const withDefaultDeps = (ruleSet, defaultDep) => {
+      const out = {};
+      for (const name of Object.keys(ruleSet)) {
+        const r = ruleSet[name];
+        if (!r || typeof r !== "object" || Array.isArray(r)) {
+          out[name] = r;
+          continue;
+        }
+        const deps = Array.isArray(r.deps) ? r.deps : [];
+        out[name] = deps.length > 0 ? r : { ...r, deps: [defaultDep] };
+      }
+      return out;
+    };
+    const reserve = (kind, path) => {
+      const k = `${kind}:${path}`;
+      if (declared.has(k)) {
+        throw new Error(`[Form.make] Duplicate rules declaration for ${kind} "${path}"`);
+      }
+      declared.add(k);
+    };
+    for (const decl of decls) {
+      if (!decl || typeof decl !== "object") continue;
+      if (decl.kind === "field") {
+        const valuePath = String(decl.valuePath ?? "").trim();
+        assertCanonicalValuePath2("field path", valuePath);
+        if (valuePath === "$root") {
+          throw new Error(`[Form.make] field path "$root" is not allowed (use Form.Rule.root(...))`);
+        }
+        reserve("field", valuePath);
+        const errorTarget = decl.errorTarget;
+        if (errorTarget !== void 0 && errorTarget !== "$value" && errorTarget !== "$self") {
+          throw new Error(`[Form.make] Invalid errorTarget for field "${valuePath}"`);
+        }
+        const depsPrefix = errorTarget === "$self" ? valuePath : dirnamePath(valuePath);
+        const ruleInput = prefixRuleInputDeps(decl.rule, depsPrefix);
+        const rules2 = withDefaultDeps(make(ruleInput), valuePath);
+        const writebackPath = errorTarget === "$self" ? `errors.${valuePath}.$self` : void 0;
+        spec[valuePath] = {
+          fieldPath: valuePath,
+          kind: "check",
+          meta: {
+            rules: rules2,
+            writeback: {
+              kind: "errors",
+              ...writebackPath ? { path: writebackPath } : {}
+            }
+          }
+        };
+        continue;
+      }
+      if (decl.kind === "root") {
+        reserve("root", "$root");
+        const ruleInput = prefixRuleInputDeps(decl.rule, "");
+        const rules2 = make(ruleInput);
+        spec.$root = {
+          fieldPath: "$root",
+          kind: "check",
+          meta: {
+            rules: rules2,
+            writeback: { kind: "errors" }
+          }
+        };
+        continue;
+      }
+      if (decl.kind === "list") {
+        const listPath = String(decl.listPath ?? "").trim();
+        assertCanonicalValuePath2("list path", listPath);
+        if (listPath === "$root") {
+          throw new Error(`[Form.make] list path "$root" is not allowed`);
+        }
+        reserve("list", listPath);
+        const identity = decl.identity;
+        assertValidListIdentity2(identity, listPath);
+        const itemInput = decl.item;
+        const listInput = decl.list;
+        const itemRules = itemInput ? make(itemInput) : void 0;
+        const listRules = listInput ? make(listInput) : void 0;
+        spec[listPath] = Logix4.StateTrait.list({
+          identityHint: identity.mode === "trackBy" ? { trackBy: String(identity.trackBy) } : void 0,
+          item: itemRules ? Logix4.StateTrait.node({ check: itemRules }) : void 0,
+          list: listRules ? Logix4.StateTrait.node({ check: listRules }) : void 0
+        });
+        continue;
+      }
+      const kind = String(decl.kind ?? "");
+      throw new Error(`[Form.make] Unknown rules declaration kind "${kind}"`);
+    }
+    return spec;
+  };
+  const toFieldPathSegments = (label, valuePath) => {
+    assertCanonicalValuePath2(label, valuePath);
+    if (valuePath === "$root") return ["$root"];
+    return valuePath.split(".").map((s) => s.trim()).filter(Boolean);
+  };
+  const normalizeAutoValidateOn = (input) => {
+    if (!Array.isArray(input)) return void 0;
+    const out = [];
+    for (const x of input) {
+      if (x === "onChange" || x === "onBlur") out.push(x);
+    }
+    if (out.length === 0) return void 0;
+    return Array.from(new Set(out)).sort((a, b) => a.localeCompare(b));
+  };
+  const normalizeRuleDeps = (deps) => {
+    if (!Array.isArray(deps)) return [];
+    const out = [];
+    for (const x of deps) {
+      if (typeof x !== "string") continue;
+      const v = x.trim();
+      if (!v) continue;
+      out.push(v);
+    }
+    return Array.from(new Set(out)).sort((a, b) => a.localeCompare(b));
+  };
+  const rulesManifestWarningsBase = () => {
+    const warnings = [];
+    if (config.rules && config.traits) {
+      warnings.push(
+        `[Form.make] \u540C\u65F6\u4F20\u5165\u4E86 "rules" \u4E0E "traits"\uFF1A\u63A8\u8350\u5C06\u6821\u9A8C\u8FC1\u79FB\u5230 rules\uFF1Btraits \u4EC5\u4FDD\u7559 computed/source/link \u6216\u5FC5\u8981\u7684\u9AD8\u7EA7\u58F0\u660E\uFF08\u4FBF\u4E8E\u6027\u80FD/\u8BCA\u65AD\u5BF9\u7167\uFF09\u3002`
+      );
+    }
+    return warnings;
+  };
+  const buildRulesManifest = () => {
+    const listsByPath = /* @__PURE__ */ new Map();
+    const rulesById = /* @__PURE__ */ new Map();
+    const addList = (path, identity) => {
+      const segments = toFieldPathSegments("list path", path);
+      const key = segments.join(".");
+      if (listsByPath.has(key)) return;
+      listsByPath.set(key, { path: segments, identity });
+    };
+    const addRule = (rule) => {
+      if (rulesById.has(rule.ruleId)) return;
+      rulesById.set(rule.ruleId, rule);
+    };
+    const ruleMeta = (source) => ({ source });
+    const emitRuleSet = (params) => {
+      const names = Object.keys(params.rules).sort((a, b) => a.localeCompare(b));
+      for (const name of names) {
+        const r = params.rules[name];
+        if (!r || typeof r !== "object") continue;
+        const deps = normalizeRuleDeps(r.deps);
+        const validateOn2 = normalizeAutoValidateOn(r.validateOn);
+        addRule({
+          ruleId: params.ruleId(name),
+          scope: params.scope,
+          deps,
+          ...validateOn2 !== void 0 ? { validateOn: validateOn2 } : {},
+          meta: ruleMeta(params.source)
+        });
+      }
+    };
+    if (config.rules && config.rules._tag === "FormRulesSpec") {
+      const decls = Array.isArray(config.rules.decls) ? config.rules.decls : [];
+      for (const decl of decls) {
+        if (!decl || typeof decl !== "object") continue;
+        if (decl.kind === "field") {
+          const valuePath = String(decl.valuePath ?? "").trim();
+          assertCanonicalValuePath2("field path", valuePath);
+          if (valuePath === "$root") continue;
+          const errorTarget = decl.errorTarget;
+          const scope = {
+            kind: "field",
+            fieldPath: toFieldPathSegments("field path", valuePath),
+            ...errorTarget !== void 0 ? { errorTarget } : {}
+          };
+          const depsPrefix = errorTarget === "$self" ? valuePath : (() => {
+            const idx = valuePath.lastIndexOf(".");
+            return idx >= 0 ? valuePath.slice(0, idx) : "";
+          })();
+          const prefixDeps = (deps, prefix) => {
+            if (!Array.isArray(deps)) return void 0;
+            const out = [];
+            for (const raw of deps) {
+              if (typeof raw !== "string") continue;
+              const d = raw.trim();
+              if (!d) continue;
+              const isRelative = d !== "$root" && !d.includes("[") && !d.includes("]") && !d.includes(".") && !/^[0-9]+$/.test(d);
+              out.push(isRelative && prefix ? `${prefix}.${d}` : d);
+            }
+            return out;
+          };
+          const prefixRuleInputDeps = (input, prefix) => {
+            if (!input || typeof input !== "object") return input;
+            if (Array.isArray(input)) return input;
+            const anyInput = input;
+            const deps = prefixDeps(anyInput.deps, prefix);
+            const validate = anyInput.validate;
+            if (typeof validate === "function") {
+              return deps !== void 0 ? { ...anyInput, deps } : input;
+            }
+            if (validate && typeof validate === "object" && !Array.isArray(validate)) {
+              const nextValidate = { ...validate };
+              for (const [ruleName, raw] of Object.entries(validate)) {
+                if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+                const entryDeps = prefixDeps(raw.deps, prefix);
+                if (entryDeps !== void 0) {
+                  nextValidate[ruleName] = { ...raw, deps: entryDeps };
+                }
+              }
+              return {
+                ...anyInput,
+                ...deps !== void 0 ? { deps } : {},
+                validate: nextValidate
+              };
+            }
+            return deps !== void 0 ? { ...anyInput, deps } : input;
+          };
+          const ruleInput = prefixRuleInputDeps(decl.rule, depsPrefix);
+          const rules3 = make(ruleInput);
+          emitRuleSet({
+            source: "rules",
+            scope,
+            ruleId: (name) => `${valuePath}#${name}`,
+            rules: rules3
+          });
+          continue;
+        }
+        if (decl.kind === "root") {
+          const ruleInput = decl.rule;
+          const rules3 = make(ruleInput);
+          emitRuleSet({
+            source: "rules",
+            scope: { kind: "root", fieldPath: ["$root"] },
+            ruleId: (name) => `$root#${name}`,
+            rules: rules3
+          });
+          continue;
+        }
+        if (decl.kind === "list") {
+          const listPath = String(decl.listPath ?? "").trim();
+          assertCanonicalValuePath2("list path", listPath);
+          if (listPath === "$root") continue;
+          const identity = decl.identity;
+          assertValidListIdentity2(identity, listPath);
+          addList(listPath, identity);
+          const listFieldPath = toFieldPathSegments("list path", listPath);
+          const itemInput = decl.item;
+          const listInput = decl.list;
+          if (itemInput) {
+            const itemRules = make(itemInput);
+            emitRuleSet({
+              source: "rules",
+              scope: { kind: "item", fieldPath: listFieldPath },
+              ruleId: (name) => `${listPath}#item.${name}`,
+              rules: itemRules
+            });
+          }
+          if (listInput) {
+            const listRules = make(listInput);
+            emitRuleSet({
+              source: "rules",
+              scope: { kind: "list", fieldPath: listFieldPath },
+              ruleId: (name) => `${listPath}#list.${name}`,
+              rules: listRules
+            });
+          }
+          continue;
+        }
+      }
+    }
+    const traitsSpec = config.traits ? traits(config.values)(config.traits) : void 0;
+    if (traitsSpec && typeof traitsSpec === "object") {
+      for (const [rawPath, value] of Object.entries(traitsSpec)) {
+        const path = String(rawPath ?? "").trim();
+        if (!path) continue;
+        const addFieldRuleSet = (fieldPath, rules3, errorTarget) => {
+          const scope = {
+            kind: fieldPath === "$root" ? "root" : "field",
+            fieldPath: fieldPath === "$root" ? ["$root"] : toFieldPathSegments("field path", fieldPath),
+            ...errorTarget !== void 0 ? { errorTarget } : {}
+          };
+          const names = Object.keys(rules3).sort((a, b) => a.localeCompare(b));
+          for (const name of names) {
+            const r = rules3[name];
+            if (!r || typeof r !== "object") continue;
+            const deps = normalizeRuleDeps(r.deps);
+            const validateOn2 = normalizeAutoValidateOn(r.validateOn);
+            const ruleId = `${fieldPath}#${name}`;
+            addRule({
+              ruleId,
+              scope,
+              deps,
+              ...validateOn2 !== void 0 ? { validateOn: validateOn2 } : {},
+              meta: ruleMeta("traits")
+            });
+          }
+        };
+        if (value && typeof value === "object" && value._tag === "StateTraitList") {
+          const listPath = path;
+          assertCanonicalValuePath2("list path", listPath);
+          if (listPath !== "$root") {
+            const trackBy = value.identityHint && typeof value.identityHint === "object" ? value.identityHint.trackBy : void 0;
+            addList(
+              listPath,
+              typeof trackBy === "string" && trackBy.length > 0 ? { mode: "trackBy", trackBy: String(trackBy) } : { mode: "store" }
+            );
+          }
+          const listFieldPath = toFieldPathSegments("list path", listPath);
+          const item = value.item;
+          const list3 = value.list;
+          const emitNodeRules = (node2, kind) => {
+            if (!node2 || typeof node2 !== "object") return;
+            if (node2._tag !== "StateTraitNode") return;
+            const check = node2.check;
+            if (!check || typeof check !== "object" || Array.isArray(check)) return;
+            const names = Object.keys(check).sort((a, b) => a.localeCompare(b));
+            for (const name of names) {
+              const r = check[name];
+              if (!r || typeof r !== "object") continue;
+              const deps = normalizeRuleDeps(r.deps);
+              const validateOn2 = normalizeAutoValidateOn(r.validateOn);
+              addRule({
+                ruleId: `${listPath}#${kind}.${name}`,
+                scope: { kind, fieldPath: listFieldPath },
+                deps,
+                ...validateOn2 !== void 0 ? { validateOn: validateOn2 } : {},
+                meta: ruleMeta("traits")
+              });
+            }
+          };
+          emitNodeRules(item, "item");
+          emitNodeRules(list3, "list");
+          continue;
+        }
+        if (value && typeof value === "object" && value._tag === "StateTraitNode") {
+          const check = value.check;
+          if (check && typeof check === "object" && !Array.isArray(check)) {
+            addFieldRuleSet(path, check);
+          }
+          continue;
+        }
+        if (value && typeof value === "object" && value.kind === "check") {
+          const meta = value.meta;
+          const rules3 = meta && typeof meta === "object" ? meta.rules : void 0;
+          if (rules3 && typeof rules3 === "object" && !Array.isArray(rules3)) {
+            const writebackPath = meta && typeof meta === "object" && meta.writeback && typeof meta.writeback === "object" ? meta.writeback.path : void 0;
+            const errorTarget = typeof writebackPath === "string" && writebackPath.endsWith(".$self") ? "$self" : void 0;
+            addFieldRuleSet(path, rules3, errorTarget);
+          }
+        }
+      }
+    }
+    const lists = Array.from(listsByPath.values()).sort((a, b) => a.path.join(".").localeCompare(b.path.join(".")));
+    const rules2 = Array.from(rulesById.values()).sort((a, b) => a.ruleId.localeCompare(b.ruleId));
+    return {
+      moduleId: id,
+      lists,
+      rules: rules2
+    };
+  };
+  const traitsBase = config.traits ? traits(config.values)(config.traits) : void 0;
+  const derivedSpec = normalizeDerived(config.derived);
+  const rulesSpec = config.rules ? compileRulesToTraitSpec(config.rules) : void 0;
+  const mergedSpec1 = mergeTraitSpecs(traitsBase, derivedSpec, "traits", "derived");
+  const mergedSpec = mergeTraitSpecs(mergedSpec1, rulesSpec, "traits/derived", "rules");
+  const traitsWrapped = mergedSpec ? wrapTraitsForValidateOn(mergedSpec, { validateOn, reValidateOn }) : void 0;
+  const traits2 = traitsWrapped?.traits;
+  const rulesValidateOn = traitsWrapped?.rulesValidateOn ?? [];
+  const def = {
+    state: StateSchema,
+    actions: Actions,
+    reducers,
+    traits: traits2,
+    schemas: { values: config.values }
+  };
+  const module2 = extend ? Logix4.Module.make(id, def, extend) : Logix4.Module.make(id, def);
+  const logics = [
+    install(module2.tag, {
+      validateOn,
+      reValidateOn,
+      rulesValidateOn,
+      debounceMs: config.debounceMs
+    })
+  ];
+  const initial = (values) => ({
+    ...values ?? config.initialValues,
+    errors: {},
+    ui: {},
+    $form: initialMeta2()
+  });
+  const controller = {
+    make: (runtime) => {
+      return makeFormController({
+        runtime,
+        shape: module2.shape,
+        valuesSchema: config.values
+      });
+    }
+  };
+  module2.controller = controller;
+  Logix4.Observability.registerTrialRunArtifactExporter(
+    module2.tag,
+    makeFormRulesManifestArtifactExporter({
+      getManifest: buildRulesManifest,
+      getWarnings: rulesManifestWarningsBase
+    })
+  );
+  const EXTEND_HANDLE = /* @__PURE__ */ Symbol.for("logix.module.handle.extend");
+  let manifestMemo;
+  let manifestWarningsMemo;
+  module2.tag[EXTEND_HANDLE] = (runtime, base) => {
+    const form = controller.make(runtime);
+    return {
+      ...base,
+      controller: form.controller,
+      rulesManifest: () => {
+        if (!manifestMemo) {
+          manifestMemo = buildRulesManifest();
+        }
+        return manifestMemo;
+      },
+      rulesManifestWarnings: () => {
+        if (!manifestWarningsMemo) {
+          manifestWarningsMemo = rulesManifestWarningsBase();
+        }
+        return manifestWarningsMemo;
+      }
+    };
+  };
+  return module2.implement({
+    initial: initial(),
+    logics: [...logics]
+  });
+};
+
+// src/internal/dsl/derived.ts
+var derived = (_valuesSchema) => {
+  function run(spec) {
+    return spec;
+  }
+  return run;
+};
+
+// src/internal/dsl/rules.ts
+var import_effect5 = require("effect");
+var normalizePrefix = (prefix) => {
+  const p = String(prefix ?? "").trim();
+  if (!p) return "";
+  if (p.includes("[]") || p.includes("[") || p.includes("]")) {
+    throw new Error(`[Form.rules] Invalid prefix "${p}" (bracket syntax is not allowed)`);
+  }
+  const segments = p.split(".").map((s) => s.trim()).filter(Boolean);
+  if (segments.length === 0) return "";
+  for (const seg of segments) {
+    if (/^[0-9]+$/.test(seg)) {
+      throw new Error(`[Form.rules] Invalid prefix "${p}" (numeric segments are not allowed)`);
+    }
+  }
+  return segments.join(".");
+};
+var joinPath = (prefix, path) => {
+  const p = String(prefix ?? "").trim();
+  const s = String(path ?? "").trim();
+  if (!p) return s;
+  if (!s) return p;
+  return `${p}.${s}`;
+};
+var flattenDecls = (decls) => {
+  const out = [];
+  for (const item of decls) {
+    if (Array.isArray(item)) out.push(...item);
+    else out.push(item);
+  }
+  return out;
+};
+var withPrefix = (prefix, decls) => {
+  if (!prefix) return decls;
+  return decls.map((decl) => {
+    if (!decl || typeof decl !== "object") return decl;
+    if (decl.kind === "field") {
+      const valuePath = joinPath(prefix, String(decl.valuePath ?? ""));
+      return { ...decl, valuePath };
+    }
+    if (decl.kind === "list") {
+      const listPath = joinPath(prefix, String(decl.listPath ?? ""));
+      return { ...decl, listPath };
+    }
+    return decl;
+  });
+};
+var makeFieldNode = (rule) => ({
+  _tag: "FormRulesNodeField",
+  rule
+});
+var fieldFromSchema = (schema) => ({
+  validate: {
+    schema: (value) => {
+      const decoded = import_effect5.Schema.decodeUnknownEither(schema)(value);
+      return decoded._tag === "Right" ? void 0 : schemaErrorMessage(decoded.left);
+    }
+  }
+});
+var makeObjectNode = (params) => {
+  const base = {
+    _tag: "FormRulesNodeObject",
+    shape: params.shape,
+    ...params.refineRule !== void 0 ? { refineRule: params.refineRule } : {},
+    ...params.superRefineRule !== void 0 ? { superRefineRule: params.superRefineRule } : {}
+  };
+  base.refine = (rule) => {
+    if (params.refineRule !== void 0 || params.superRefineRule !== void 0) {
+      throw new Error(`[Form.rules.schema] object.refine(...) can only be specified once`);
+    }
+    return makeObjectNode({ ...params, refineRule: rule });
+  };
+  base.superRefine = (rule) => {
+    if (params.refineRule !== void 0 || params.superRefineRule !== void 0) {
+      throw new Error(`[Form.rules.schema] object.superRefine(...) can only be specified once`);
+    }
+    return makeObjectNode({ ...params, superRefineRule: rule });
+  };
+  return base;
+};
+var makeArrayNode = (params) => {
+  const base = {
+    _tag: "FormRulesNodeArray",
+    item: params.item,
+    identity: params.identity,
+    ...params.refineRule !== void 0 ? { refineRule: params.refineRule } : {},
+    ...params.superRefineRule !== void 0 ? { superRefineRule: params.superRefineRule } : {}
+  };
+  base.refine = (rule) => {
+    if (params.refineRule !== void 0 || params.superRefineRule !== void 0) {
+      throw new Error(`[Form.rules.schema] array.refine(...) can only be specified once`);
+    }
+    return makeArrayNode({ ...params, refineRule: rule });
+  };
+  base.superRefine = (rule) => {
+    if (params.refineRule !== void 0 || params.superRefineRule !== void 0) {
+      throw new Error(`[Form.rules.schema] array.superRefine(...) can only be specified once`);
+    }
+    return makeArrayNode({ ...params, superRefineRule: rule });
+  };
+  return base;
+};
+var assertValidListIdentity = (identity, listPath) => {
+  if (!identity || typeof identity !== "object") {
+    throw new Error(`[Form.rules] Missing list identity for "${listPath}"`);
+  }
+  const mode = identity.mode;
+  if (mode === "trackBy") {
+    const trackBy = identity.trackBy;
+    if (typeof trackBy !== "string" || trackBy.trim().length === 0) {
+      throw new Error(`[Form.rules] identity.trackBy for "${listPath}" must be a non-empty string`);
+    }
+    if (trackBy.includes("[") || trackBy.includes("]")) {
+      throw new Error(`[Form.rules] identity.trackBy for "${listPath}" must not contain brackets (got "${trackBy}")`);
+    }
+    return;
+  }
+  if (mode === "store" || mode === "index") return;
+  throw new Error(`[Form.rules] Invalid identity.mode for "${listPath}" (got "${String(mode)}")`);
+};
+var assertCanonicalValuePath = (label, path) => {
+  const p = String(path ?? "").trim();
+  if (!p) throw new Error(`[Form.rules] ${label} must be a non-empty path`);
+  if (p === "$root") return;
+  if (p.includes("[]") || p.includes("[") || p.includes("]")) {
+    throw new Error(`[Form.rules] ${label} "${p}" must not use bracket syntax`);
+  }
+  const segments = p.split(".").map((s) => s.trim()).filter(Boolean);
+  if (segments.length === 0) throw new Error(`[Form.rules] ${label} "${p}" must be a non-empty path`);
+  for (const seg of segments) {
+    if (/^[0-9]+$/.test(seg)) {
+      throw new Error(`[Form.rules] ${label} "${p}" must not contain numeric segments`);
+    }
+  }
+};
+var assertDeclListGuardrails = (decls) => {
+  const declared = /* @__PURE__ */ new Map();
+  const reserve = (kind, path) => {
+    const existing = declared.get(path);
+    if (existing) {
+      throw new Error(`[Form.rules] Duplicate declaration for "${path}" (${existing} + ${kind})`);
+    }
+    declared.set(path, kind);
+  };
+  for (const decl of decls) {
+    if (!decl || typeof decl !== "object") continue;
+    if (decl.kind === "field") {
+      const valuePath = String(decl.valuePath ?? "").trim();
+      assertCanonicalValuePath("field path", valuePath);
+      reserve("field", valuePath);
+      continue;
+    }
+    if (decl.kind === "root") {
+      reserve("root", "$root");
+      continue;
+    }
+    if (decl.kind === "list") {
+      const listPath = String(decl.listPath ?? "").trim();
+      assertCanonicalValuePath("list path", listPath);
+      const identity = decl.identity;
+      assertValidListIdentity(identity, listPath);
+      reserve("list", listPath);
+      continue;
+    }
+    const kind = String(decl.kind ?? "");
+    throw new Error(`[Form.rules] Unknown declaration kind "${kind}"`);
+  }
+};
+var compileSchema = (node2, prefix) => {
+  const visit = (n, at) => {
+    if (!n || typeof n !== "object") return [];
+    if (n._tag === "FormRulesNodeField") {
+      const rule = n.rule;
+      assertCanonicalValuePath("field path", at);
+      return [field(at, rule)];
+    }
+    if (n._tag === "FormRulesNodeObject") {
+      const shape = n.shape;
+      const out = [];
+      for (const key of Object.keys(shape)) {
+        out.push(...visit(shape[key], joinPath(at, key)));
+      }
+      const refineRule = n.refineRule;
+      const superRefineRule = n.superRefineRule;
+      const selfRule = superRefineRule ?? refineRule;
+      if (selfRule !== void 0) {
+        if (at) {
+          out.push(field(at, selfRule, { errorTarget: "$self" }));
+        } else {
+          out.push(root(selfRule));
+        }
+      }
+      return out;
+    }
+    if (n._tag === "FormRulesNodeArray") {
+      const identity = n.identity;
+      assertCanonicalValuePath("list path", at);
+      assertValidListIdentity(identity, at);
+      const item = n.item;
+      if (!item || typeof item !== "object" || item._tag !== "FormRulesNodeObject") {
+        throw new Error(`[Form.rules.schema] array(item) currently requires item to be an object node`);
+      }
+      const itemObj = item;
+      if (itemObj.refineRule !== void 0 || itemObj.superRefineRule !== void 0) {
+        throw new Error(`[Form.rules.schema] array(item).item.refine(...) is not supported yet`);
+      }
+      const shape = itemObj.shape;
+      const validate = {};
+      for (const key of Object.keys(shape)) {
+        const child = shape[key];
+        if (!child || typeof child !== "object") continue;
+        if (child._tag !== "FormRulesNodeField") {
+          throw new Error(
+            `[Form.rules.schema] array(item) only supports flat field nodes (nested object/array is not supported yet)`
+          );
+        }
+        const ruleInput = child.rule;
+        const leafRules = make(ruleInput);
+        for (const name of Object.keys(leafRules).sort((a, b) => a.localeCompare(b))) {
+          const leaf = leafRules[name];
+          const ruleName = `${key}.${name}`;
+          const deps = Array.isArray(leaf?.deps) ? leaf.deps : [];
+          const depsWithKey = Array.from(/* @__PURE__ */ new Set([key, ...deps])).sort((a, b) => a.localeCompare(b));
+          validate[ruleName] = {
+            ...leaf,
+            deps: depsWithKey,
+            validate: (row, ctx) => {
+              const v = row?.[key];
+              const out = leaf.validate(v, ctx);
+              if (out === /* @__PURE__ */ Symbol.for("logix.state-trait.validate.skip")) return out;
+              return out === void 0 ? void 0 : { [key]: out };
+            }
+          };
+        }
+      }
+      const itemRule = Object.keys(validate).length > 0 ? { validate } : void 0;
+      const listRule = n.refineRule;
+      const listSuper = n.superRefineRule;
+      const listRuleInput = listSuper ?? listRule;
+      return [
+        list(at, {
+          identity,
+          ...itemRule !== void 0 ? { item: itemRule } : {},
+          ...listRuleInput !== void 0 ? { list: listRuleInput } : {}
+        })
+      ];
+    }
+    return [];
+  };
+  const rootPrefix = normalizePrefix(prefix);
+  return visit(node2, rootPrefix);
+};
+var rules = (_valuesSchema) => {
+  const makeDsl = (prefix) => {
+    const build = (...decls) => {
+      const flat = flattenDecls(decls);
+      const p = normalizePrefix(prefix);
+      const normalized = withPrefix(p, flat);
+      assertDeclListGuardrails(normalized);
+      return {
+        _tag: "FormRulesSpec",
+        decls: normalized
+      };
+    };
+    build.schema = (node2) => {
+      const p = normalizePrefix(prefix);
+      const normalized = compileSchema(node2, p);
+      assertDeclListGuardrails(normalized);
+      return {
+        _tag: "FormRulesSpec",
+        decls: normalized
+      };
+    };
+    build.at = (p2) => makeDsl(joinPath(normalizePrefix(prefix), normalizePrefix(p2)));
+    function field2(...args) {
+      if (args.length >= 2 && typeof args[0] === "string") {
+        return field(args[0], args[1], args[2]);
+      }
+      const input = args[0];
+      if (import_effect5.Schema.isSchema(input)) return makeFieldNode(fieldFromSchema(input));
+      return makeFieldNode(input);
+    }
+    build.field = field2;
+    build.object = (shape) => makeObjectNode({ shape });
+    build.array = (item, options) => makeArrayNode({ item, identity: options.identity });
+    build.root = (ruleInput) => root(ruleInput);
+    build.list = (listPath, spec) => list(listPath, spec);
+    return build;
+  };
+  return makeDsl("");
+};
+
+// src/internal/dsl/from.ts
+var fromValues = (valuesSchema) => ({
+  derived: derived(valuesSchema),
+  rules: rules(valuesSchema),
+  traits: traits(valuesSchema)
+});
+
+// src/internal/dsl/node.ts
+var Logix5 = __toESM(require("@logixjs/core"), 1);
+var node = (spec) => Logix5.StateTrait.node(spec);
+
+// src/internal/dsl/list.ts
+var Logix6 = __toESM(require("@logixjs/core"), 1);
+var list2 = (spec) => Logix6.StateTrait.list(spec);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  derived,
+  fromValues,
+  list,
+  make,
+  node,
+  rules,
+  traits
+});
+//# sourceMappingURL=Form.cjs.map