@allhailai/formfoundry-core 1.2.0

package/dist/index.cjs

@@ -0,0 +1,2972 @@
+'use strict';
+
+var React4 = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React4__default = /*#__PURE__*/_interopDefault(React4);
+
+// src/node/events.ts
+function createEventEmitter() {
+  const listeners2 = /* @__PURE__ */ new Map();
+  const emitter = {
+    on(event, listener) {
+      if (!listeners2.has(event)) {
+        listeners2.set(event, /* @__PURE__ */ new Set());
+      }
+      listeners2.get(event).add(listener);
+      return () => {
+        listeners2.get(event)?.delete(listener);
+      };
+    },
+    once(event, listener) {
+      const wrapper = (payload) => {
+        listener(payload);
+        listeners2.get(event)?.delete(wrapper);
+      };
+      return emitter.on(event, wrapper);
+    },
+    emit(event, payload) {
+      const eventListeners = listeners2.get(event);
+      if (!eventListeners) return;
+      for (const listener of eventListeners) {
+        try {
+          listener(payload);
+        } catch (e) {
+          if (process.env.NODE_ENV !== "production") {
+            console.error("[FormFoundry] Event listener error:", e);
+          }
+        }
+      }
+    },
+    off(event) {
+      if (event) {
+        listeners2.delete(event);
+      } else {
+        listeners2.clear();
+      }
+    }
+  };
+  return emitter;
+}
+
+// src/node/globalRegistry.ts
+var globalNodeMap = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+function subscribeToRegistry(fn) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+function getNode(id) {
+  return globalNodeMap.get(id);
+}
+function registerNode(node) {
+  if (process.env.NODE_ENV !== "production" && globalNodeMap.has(node.id)) {
+    const existing = globalNodeMap.get(node.id);
+    if (existing !== node) {
+      console.warn(
+        `[FormFoundry] Node with id "${node.id}" is already registered globally. The previous node will be overwritten.`
+      );
+    }
+  }
+  globalNodeMap.set(node.id, node);
+  listeners.forEach((fn) => fn("registered", node.id, node));
+}
+function unregisterNode(id) {
+  const node = globalNodeMap.get(id);
+  globalNodeMap.delete(id);
+  if (node) {
+    listeners.forEach((fn) => fn("unregistered", id, node));
+  }
+}
+function clearGlobalRegistry() {
+  const entries = [...globalNodeMap.entries()];
+  globalNodeMap.clear();
+  for (const [id, node] of entries) {
+    listeners.forEach((fn) => fn("unregistered", id, node));
+  }
+}
+function clearRegistryListeners() {
+  listeners.clear();
+}
+function getRegisteredNodeIds() {
+  return Array.from(globalNodeMap.keys());
+}
+
+// src/node/hooks.ts
+function createHookDispatcher() {
+  const middlewares = [];
+  return {
+    use(middleware) {
+      middlewares.push(middleware);
+      return () => {
+        const index = middlewares.indexOf(middleware);
+        if (index !== -1) {
+          middlewares.splice(index, 1);
+        }
+      };
+    },
+    dispatch(payload) {
+      if (middlewares.length === 0) return payload;
+      let index = 0;
+      const next = (current) => {
+        if (index >= middlewares.length) return current;
+        const middleware = middlewares[index++];
+        return middleware(current, next);
+      };
+      return next(payload);
+    },
+    // BUG-34 fix: async dispatch that awaits each middleware result
+    async dispatchAsync(payload) {
+      if (middlewares.length === 0) return payload;
+      let current = payload;
+      for (const middleware of middlewares) {
+        const result = middleware(current, (p) => p);
+        current = result instanceof Promise ? await result : result;
+      }
+      return current;
+    }
+  };
+}
+function createHooks() {
+  return {
+    init: createHookDispatcher(),
+    input: createHookDispatcher(),
+    commit: createHookDispatcher(),
+    prop: createHookDispatcher(),
+    message: createHookDispatcher(),
+    submit: createHookDispatcher()
+  };
+}
+
+// src/node/ledger.ts
+function createLedger(store) {
+  const counters = [];
+  let unsubscribe = null;
+  function recalculate() {
+    for (const counter of counters) {
+      counter.count = 0;
+      for (const msg of store.messages.values()) {
+        if (counter.filter(msg)) {
+          counter.count++;
+        }
+      }
+    }
+  }
+  unsubscribe = store.on(() => {
+    recalculate();
+  });
+  const ledger = {
+    count(name, filter) {
+      const counter = { name, filter, count: 0 };
+      for (const msg of store.messages.values()) {
+        if (filter(msg)) {
+          counter.count++;
+        }
+      }
+      counters.push(counter);
+      return counter;
+    },
+    counters() {
+      return counters;
+    },
+    recalculate,
+    destroy() {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+      counters.length = 0;
+    }
+  };
+  return ledger;
+}
+
+// src/node/messages.ts
+function createMessage(partial) {
+  return {
+    type: "validation",
+    blocking: true,
+    visible: true,
+    meta: {},
+    ...partial
+  };
+}
+function createMessageStore() {
+  const messages = /* @__PURE__ */ new Map();
+  const listeners2 = /* @__PURE__ */ new Set();
+  let batchDepth = 0;
+  let batchDirty = false;
+  const notify = () => {
+    if (batchDepth > 0) {
+      batchDirty = true;
+      return;
+    }
+    for (const listener of listeners2) {
+      listener(store);
+    }
+  };
+  const store = {
+    get messages() {
+      return messages;
+    },
+    set(message) {
+      messages.set(message.key, message);
+      notify();
+    },
+    remove(key) {
+      if (messages.delete(key)) {
+        notify();
+      }
+    },
+    get(key) {
+      return messages.get(key);
+    },
+    has(key) {
+      return messages.has(key);
+    },
+    clear(type) {
+      if (type) {
+        for (const [key, msg] of messages) {
+          if (msg.type === type) {
+            messages.delete(key);
+          }
+        }
+      } else {
+        messages.clear();
+      }
+      notify();
+    },
+    filter(type) {
+      const result = [];
+      for (const msg of messages.values()) {
+        if (msg.type === type) {
+          result.push(msg);
+        }
+      }
+      return result;
+    },
+    visible() {
+      const result = [];
+      for (const msg of messages.values()) {
+        if (msg.visible) {
+          result.push(msg);
+        }
+      }
+      return result;
+    },
+    hasBlocking() {
+      for (const msg of messages.values()) {
+        if (msg.blocking) return true;
+      }
+      return false;
+    },
+    blocking() {
+      const result = [];
+      for (const msg of messages.values()) {
+        if (msg.blocking) {
+          result.push(msg);
+        }
+      }
+      return result;
+    },
+    on(listener) {
+      listeners2.add(listener);
+      return () => {
+        listeners2.delete(listener);
+      };
+    },
+    batch(fn) {
+      batchDepth++;
+      try {
+        fn();
+      } finally {
+        batchDepth--;
+        if (batchDepth === 0 && batchDirty) {
+          batchDirty = false;
+          notify();
+        }
+      }
+    }
+  };
+  return store;
+}
+
+// src/node/index.ts
+var nodeCounter = 0;
+function generateNodeId(type) {
+  return `${type}_${++nodeCounter}`;
+}
+function recomputeValue(node) {
+  if (node.type === "group") {
+    const obj = {};
+    for (const child of node.children) {
+      obj[child.name] = child.value;
+    }
+    node.value = obj;
+    node._value = obj;
+  } else if (node.type === "list") {
+    node.value = node.children.map((child) => child.value);
+    node._value = node.value;
+  }
+  if (node.parent) {
+    recomputeValue(node.parent);
+  }
+}
+async function hydrateChildren(node, initialValue, emitEvents = false) {
+  if (node.type === "group" && initialValue !== null && typeof initialValue === "object" && !Array.isArray(initialValue)) {
+    const values = initialValue;
+    for (const child of node.children) {
+      if (child.name in values) {
+        if (emitEvents) {
+          await child.input(values[child.name]);
+        } else {
+          child.value = values[child.name];
+          child._value = values[child.name];
+          if (child.config.defaultValue === void 0) {
+            child.config.defaultValue = values[child.name];
+          }
+          if (child.type !== "input") {
+            hydrateChildren(child, child.value);
+          }
+        }
+      }
+    }
+  } else if (node.type === "list" && Array.isArray(initialValue)) {
+    for (let i = 0; i < node.children.length && i < initialValue.length; i++) {
+      const child = node.children[i];
+      if (emitEvents) {
+        await child.input(initialValue[i]);
+      } else {
+        child.value = initialValue[i];
+        child._value = initialValue[i];
+        if (child.config.defaultValue === void 0) {
+          child.config.defaultValue = initialValue[i];
+        }
+        if (child.type !== "input") {
+          hydrateChildren(child, child.value);
+        }
+      }
+    }
+  }
+}
+function resolveConfig(node, key) {
+  if (key in node.config) {
+    return node.config[key];
+  }
+  if (node.parent) {
+    return resolveConfig(node.parent, key);
+  }
+  return void 0;
+}
+function createNode(options = {}) {
+  const {
+    type = "input",
+    name,
+    value,
+    id,
+    config = {},
+    children: initialChildren = [],
+    parent = null,
+    plugins = [],
+    props = {}
+  } = options;
+  const nodeId = id ?? generateNodeId(type);
+  const nodeName = name ?? nodeId;
+  const store = createMessageStore();
+  const hooks = createHooks();
+  const events = createEventEmitter();
+  const ledger = createLedger(store);
+  const pluginCleanups = [];
+  const pluginCleanupsByChild = /* @__PURE__ */ new Map();
+  let pendingCount = 0;
+  let settleResolvers = [];
+  function trackPending() {
+    pendingCount++;
+  }
+  function resolvePending() {
+    pendingCount--;
+    if (pendingCount <= 0) {
+      pendingCount = 0;
+      const resolvers = settleResolvers;
+      settleResolvers = [];
+      queueMicrotask(() => {
+        if (pendingCount <= 0) {
+          for (const resolve of resolvers) {
+            resolve();
+          }
+        } else {
+          settleResolvers = [...resolvers, ...settleResolvers];
+        }
+      });
+    }
+  }
+  const node = {
+    id: nodeId,
+    name: nodeName,
+    type,
+    // Tree
+    parent,
+    children: [],
+    // Value
+    value: value ?? (type === "group" ? {} : type === "list" ? [] : void 0),
+    _value: value ?? (type === "group" ? {} : type === "list" ? [] : void 0),
+    // State
+    touched: false,
+    dirty: false,
+    disabled: false,
+    // Derived (computed from message store)
+    get valid() {
+      return !store.hasBlocking();
+    },
+    get errors() {
+      return store.filter("validation").filter((m) => m.visible).map((m) => m.value);
+    },
+    // Subsystems
+    store,
+    hooks,
+    events,
+    ledger,
+    config,
+    props,
+    // Methods
+    async input(newValue) {
+      trackPending();
+      try {
+        const transformedValue = await hooks.input.dispatchAsync(newValue);
+        node._value = transformedValue;
+        const committedValue = await hooks.commit.dispatchAsync(transformedValue);
+        node.value = committedValue;
+        if (node.type !== "input" && committedValue != null) {
+          await hydrateChildren(node, committedValue, true);
+        }
+        if (node.parent) {
+          recomputeValue(node.parent);
+        }
+        events.emit("input", committedValue);
+        events.emit("commit", committedValue);
+      } finally {
+        resolvePending();
+      }
+    },
+    addChild(child, index) {
+      child.parent = node;
+      if (index !== void 0 && index >= 0 && index <= node.children.length) {
+        node.children.splice(index, 0, child);
+      } else {
+        node.children.push(child);
+      }
+      const parentPlugins = config.plugins ?? plugins;
+      const childCleanups = [];
+      for (const plugin of parentPlugins) {
+        const cleanup = plugin(child);
+        if (cleanup) childCleanups.push(cleanup);
+      }
+      if (childCleanups.length > 0) {
+        pluginCleanupsByChild.set(child.id, childCleanups);
+      }
+      const preAddValue = node.type === "group" ? node.value : null;
+      recomputeValue(node);
+      if (preAddValue && typeof preAddValue === "object" && child.name in preAddValue) {
+        const existingVal = preAddValue[child.name];
+        if (existingVal !== void 0) {
+          const shouldHydrate = child.type !== "input" || child.value === void 0;
+          if (shouldHydrate) {
+            child.value = existingVal;
+            child._value = existingVal;
+            if (child.type !== "input") {
+              hydrateChildren(child, existingVal);
+            }
+            recomputeValue(node);
+          }
+        }
+      }
+    },
+    removeChild(child) {
+      const index = node.children.indexOf(child);
+      if (index !== -1) {
+        node.children.splice(index, 1);
+        child.parent = null;
+        const childCleanups = pluginCleanupsByChild.get(child.id);
+        if (childCleanups) {
+          for (const cleanup of childCleanups) {
+            cleanup();
+          }
+          pluginCleanupsByChild.delete(child.id);
+        }
+        recomputeValue(node);
+      }
+    },
+    destroy() {
+      events.emit("destroying", void 0);
+      for (const cleanup of pluginCleanups) {
+        cleanup();
+      }
+      if (node.parent) {
+        node.parent.removeChild(node);
+      }
+      const childrenToDestroy = [...node.children];
+      node.children = [];
+      for (const child of childrenToDestroy) {
+        child.destroy();
+        child.parent = null;
+      }
+      for (const cleanups of pluginCleanupsByChild.values()) {
+        for (const cleanup of cleanups) {
+          cleanup();
+        }
+      }
+      pluginCleanupsByChild.clear();
+      ledger.destroy();
+      events.off();
+      unregisterNode(node.id);
+    },
+    walk(fn) {
+      fn(node);
+      for (const child of node.children) {
+        child.walk(fn);
+      }
+    },
+    at(path) {
+      const segments = path.split(".");
+      let current = node;
+      for (const segment of segments) {
+        if (!current || current.type === "input") return void 0;
+        current = current.children.find((c) => c.name === segment);
+      }
+      return current;
+    },
+    reset(resetValue) {
+      node.touched = false;
+      node.dirty = false;
+      node.store.clear("validation");
+      node.store.clear("error");
+      if (node.type === "group" && node.children.length > 0) {
+        const obj = typeof resetValue === "object" && resetValue !== null && !Array.isArray(resetValue) ? resetValue : void 0;
+        for (const child of node.children) {
+          child.reset(obj?.[child.name]);
+        }
+        recomputeValue(node);
+      } else if (node.type === "list" && node.children.length > 0) {
+        const arr = Array.isArray(resetValue) ? resetValue : void 0;
+        for (let i = 0; i < node.children.length; i++) {
+          node.children[i].reset(arr?.[i]);
+        }
+        recomputeValue(node);
+      } else {
+        const defaultVal = resetValue ?? node.config.defaultValue ?? (node.type === "group" ? {} : node.type === "list" ? [] : void 0);
+        node.value = defaultVal;
+        node._value = defaultVal;
+      }
+      if (node.parent) {
+        recomputeValue(node.parent);
+      }
+      events.emit("reset", node.value);
+    },
+    /**
+     * Wait for all currently in-flight `input()` calls to complete.
+     *
+     * **Design note (G1):** If no `input()` calls are pending, `settle()`
+     * resolves immediately. This is intentional — it means "wait for
+     * current async work", not "wait for the next input". If you need to
+     * wait for a future input, subscribe to the `'commit'` event instead.
+     *
+     * Uses a microtask-deferred resolver (G2 fix) so that re-entrant
+     * `input()` calls triggered during resolver callbacks are captured
+     * before settlement completes.
+     */
+    async settle() {
+      if (pendingCount <= 0) return;
+      return new Promise((resolve) => {
+        settleResolvers.push(resolve);
+      });
+    },
+    async submit() {
+    }
+  };
+  for (const child of initialChildren) {
+    node.addChild(child);
+  }
+  if (value !== void 0 && type !== "input") {
+    hydrateChildren(node, value);
+  } else if (type !== "input") {
+    recomputeValue(node);
+  }
+  const allPlugins = [...config.plugins ?? [], ...plugins];
+  for (const plugin of allPlugins) {
+    const cleanup = plugin(node);
+    if (cleanup) pluginCleanups.push(cleanup);
+  }
+  hooks.init.dispatch(node);
+  registerNode(node);
+  events.emit("created", node);
+  return node;
+}
+
+// src/i18n/index.ts
+function interpolate(template, ctx) {
+  return template.replace(/\{label\}/g, ctx.label).replace(/\{name\}/g, ctx.name).replace(/\{args\.(\d+)\}/g, (_, i) => String(ctx.args[Number(i)] ?? "")).replace(/\{(\d+)\}/g, (_, i) => String(ctx.args[Number(i)] ?? ""));
+}
+function resolveLocaleMessage(locale, ruleName, ctx) {
+  const msg = locale.messages[ruleName];
+  if (!msg) return `${ctx.label} is invalid.`;
+  if (typeof msg === "function") {
+    return msg(ctx);
+  }
+  return interpolate(msg, ctx);
+}
+var localeRegistry = /* @__PURE__ */ new Map();
+var activeLocaleCode = "en";
+function registerLocale(locale) {
+  localeRegistry.set(locale.code, locale);
+}
+function setActiveLocale(code) {
+  if (!localeRegistry.has(code)) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[FormFoundry i18n] Locale "${code}" is not registered. Available: ${Array.from(localeRegistry.keys()).join(", ") || "(none)"}`
+      );
+    }
+  }
+  activeLocaleCode = code;
+}
+function getActiveLocale() {
+  return localeRegistry.get(activeLocaleCode);
+}
+function getLocale(code) {
+  return localeRegistry.get(code);
+}
+function getRegisteredLocales() {
+  return Array.from(localeRegistry.keys());
+}
+
+// src/validation/messages.ts
+var defaultMessages = {
+  required: "This field is required.",
+  email: "Please enter a valid email address.",
+  url: "Please enter a valid URL.",
+  min: (args) => `Must be at least ${args[0] ?? "?"}.`,
+  max: (args) => `Must be at most ${args[0] ?? "?"}.`,
+  minLength: (args) => `Must be at least ${args[0] ?? "?"} characters.`,
+  maxLength: (args) => `Must be at most ${args[0] ?? "?"} characters.`,
+  matches: "This field does not match the required pattern.",
+  confirm: "This field does not match.",
+  alpha: "This field must contain only alphabetical characters.",
+  alphanumeric: "This field must contain only alphanumeric characters.",
+  date: "Please enter a valid date.",
+  between: (args) => `Must be between ${args[0] ?? "?"} and ${args[1] ?? "?"}.`,
+  number: "This field must be a number.",
+  accepted: "This field must be accepted.",
+  alpha_spaces: "This field must contain only letters and spaces.",
+  contains_alpha: "This field must contain at least one letter.",
+  contains_alphanumeric: "This field must contain at least one letter or number.",
+  contains_alpha_spaces: "This field must contain at least one letter or space.",
+  contains_lowercase: "This field must contain at least one lowercase letter.",
+  contains_uppercase: "This field must contain at least one uppercase letter.",
+  contains_numeric: "This field must contain at least one number.",
+  contains_symbol: "This field must contain at least one symbol.",
+  date_after: (args) => `Must be after ${args[0] ?? "today"}.`,
+  date_before: (args) => `Must be before ${args[0] ?? "today"}.`,
+  date_between: (args) => `Must be between ${args[0] ?? "?"} and ${args[1] ?? "?"}.`,
+  date_format: (args) => `Must match the format ${args[0] ?? "YYYY-MM-DD"}.`,
+  ends_with: (args) => `Must end with ${args.join(", ") || "?"}.`,
+  is: (args) => `Must be one of: ${args.join(", ") || "?"}.`,
+  length: (args) => args[1] ? `Must be between ${args[0]} and ${args[1]} characters.` : `Must be exactly ${args[0] ?? "?"} characters.`,
+  lowercase: "This field must be all lowercase.",
+  not: (args) => `Must not be: ${args.join(", ") || "?"}.`,
+  require_one: "At least one of these fields is required.",
+  starts_with: (args) => `Must start with ${args.join(", ") || "?"}.`,
+  symbol: "This field must contain only symbols.",
+  uppercase: "This field must be all uppercase."
+};
+function resolveMessage(ruleName, args, customMessages, label, name) {
+  const custom = customMessages?.[ruleName];
+  if (custom) {
+    return typeof custom === "function" ? custom(args) : custom;
+  }
+  const activeLocale = getActiveLocale();
+  if (activeLocale) {
+    const ctx = {
+      label: label ?? name ?? "This field",
+      name: name ?? "",
+      args,
+      values: {}
+    };
+    const localeMsg = activeLocale.messages[ruleName];
+    if (localeMsg) {
+      return resolveLocaleMessage(activeLocale, ruleName, ctx);
+    }
+  }
+  const source = defaultMessages[ruleName];
+  if (typeof source === "function") return source(args);
+  if (typeof source === "string") return source;
+  return "This field is invalid.";
+}
+
+// src/validation/parseRules.ts
+function parseRules(spec) {
+  if (typeof spec === "string") {
+    return parseStringRules(spec);
+  }
+  if (Array.isArray(spec)) {
+    return parseArrayRules(spec);
+  }
+  return [];
+}
+function parseStringRules(spec) {
+  if (!spec.trim()) return [];
+  const rules = spec.split("|");
+  return rules.map(parseStringRule).filter(Boolean);
+}
+function parseStringRule(rule) {
+  let remaining = rule.trim();
+  if (!remaining) return null;
+  const hints = {};
+  while (remaining.length > 0) {
+    const debounceMatch = remaining.match(/^\((\d+)\)/);
+    if (debounceMatch) {
+      hints.debounce = parseInt(debounceMatch[1], 10);
+      remaining = remaining.slice(debounceMatch[0].length);
+      continue;
+    }
+    if (remaining.startsWith("+")) {
+      hints.empty = true;
+      remaining = remaining.slice(1);
+      continue;
+    }
+    if (remaining.startsWith("*")) {
+      hints.force = true;
+      remaining = remaining.slice(1);
+      continue;
+    }
+    if (remaining.startsWith("?")) {
+      hints.optional = true;
+      remaining = remaining.slice(1);
+      continue;
+    }
+    break;
+  }
+  const colonIndex = remaining.indexOf(":");
+  if (colonIndex === -1) {
+    return { name: remaining, args: [], hints };
+  }
+  const name = remaining.slice(0, colonIndex);
+  const argsString = remaining.slice(colonIndex + 1);
+  const args = argsString.split(",").map((a) => a.trim());
+  return { name, args, hints };
+}
+function parseArrayRules(spec) {
+  const rules = [];
+  for (const item of spec) {
+    if (typeof item === "string") {
+      rules.push(...parseStringRules(item));
+    } else if (typeof item === "function") {
+      rules.push({
+        name: item.name || `custom_${rules.length}`,
+        args: [],
+        hints: {},
+        handler: item
+      });
+    } else if (Array.isArray(item)) {
+      const [name, ...args] = item;
+      if (typeof name === "string") {
+        rules.push({ name, args, hints: {} });
+      }
+    }
+  }
+  return rules;
+}
+
+// src/validation/rules.ts
+function isEmpty(value) {
+  if (value === null || value === void 0 || value === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return isNaN(parsed) ? null : parsed;
+  }
+  return null;
+}
+function toString(value) {
+  if (typeof value === "string") return value;
+  if (value === null || value === void 0) return "";
+  return String(value);
+}
+function getMessage(ruleName, args) {
+  const msgFactory = defaultMessages[ruleName];
+  if (typeof msgFactory === "function") {
+    return msgFactory(args.map(String));
+  }
+  if (typeof msgFactory === "string") {
+    return msgFactory;
+  }
+  return `This field is invalid.`;
+}
+var required = (value, args) => {
+  if (isEmpty(value)) return getMessage("required", args);
+  if (typeof value === "boolean" && !value) return getMessage("required", args);
+  return null;
+};
+var email = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return re.test(str) ? null : getMessage("email", args);
+};
+var url = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  try {
+    new URL(str);
+    return null;
+  } catch {
+    return getMessage("url", args);
+  }
+};
+var min = (value, args) => {
+  const num = toNumber(value);
+  const threshold = toNumber(args[0]);
+  if (num === null || threshold === null) return null;
+  return num >= threshold ? null : getMessage("min", args);
+};
+var max = (value, args) => {
+  const num = toNumber(value);
+  const threshold = toNumber(args[0]);
+  if (num === null || threshold === null) return null;
+  return num <= threshold ? null : getMessage("max", args);
+};
+var minLength = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const threshold = toNumber(args[0]);
+  if (threshold === null) return null;
+  return str.length >= threshold ? null : getMessage("minLength", args);
+};
+var maxLength = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const threshold = toNumber(args[0]);
+  if (threshold === null) return null;
+  return str.length <= threshold ? null : getMessage("maxLength", args);
+};
+var matches = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const pattern = args[0];
+  if (pattern instanceof RegExp) {
+    return pattern.test(str) ? null : getMessage("matches", args);
+  }
+  if (typeof pattern === "string") {
+    const re = new RegExp(pattern);
+    return re.test(str) ? null : getMessage("matches", args);
+  }
+  return null;
+};
+var confirm = (value, args, context) => {
+  const siblingName = typeof args[0] === "string" ? args[0] : `${context.name}_confirm`;
+  const siblingValue = context.values[siblingName];
+  return value === siblingValue ? null : getMessage("confirm", args);
+};
+var alpha = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /^[a-zA-Z]+$/.test(str) ? null : getMessage("alpha", args);
+};
+var alphanumeric = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /^[a-zA-Z0-9]+$/.test(str) ? null : getMessage("alphanumeric", args);
+};
+var date = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const d = new Date(str);
+  return isNaN(d.getTime()) ? getMessage("date", args) : null;
+};
+var between = (value, args) => {
+  const num = toNumber(value);
+  const lo = toNumber(args[0]);
+  const hi = toNumber(args[1]);
+  if (num === null || lo === null || hi === null) return null;
+  return num >= lo && num <= hi ? null : getMessage("between", args);
+};
+var number = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return isNaN(Number(str)) ? getMessage("number", args) : null;
+};
+var accepted = (value, args) => {
+  const v = typeof value === "string" ? value.toLowerCase() : value;
+  if (v === true || v === "yes" || v === "on" || v === "1" || v === 1) return null;
+  return getMessage("accepted", args);
+};
+var alpha_spaces = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /^[a-zA-Z\s]+$/.test(str) ? null : getMessage("alpha_spaces", args);
+};
+var contains_alpha = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /[a-zA-Z]/.test(str) ? null : getMessage("contains_alpha", args);
+};
+var contains_alphanumeric = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /[a-zA-Z0-9]/.test(str) ? null : getMessage("contains_alphanumeric", args);
+};
+var contains_alpha_spaces = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /[a-zA-Z\s]/.test(str) ? null : getMessage("contains_alpha_spaces", args);
+};
+var contains_lowercase = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /[a-z]/.test(str) ? null : getMessage("contains_lowercase", args);
+};
+var contains_uppercase = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /[A-Z]/.test(str) ? null : getMessage("contains_uppercase", args);
+};
+var contains_numeric = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /\d/.test(str) ? null : getMessage("contains_numeric", args);
+};
+var contains_symbol = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /[^a-zA-Z0-9\s]/.test(str) ? null : getMessage("contains_symbol", args);
+};
+var date_after = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const d = new Date(str);
+  if (isNaN(d.getTime())) return getMessage("date_after", args);
+  const after = args[0] ? new Date(String(args[0])) : /* @__PURE__ */ new Date();
+  if (isNaN(after.getTime())) return null;
+  return d > after ? null : getMessage("date_after", args);
+};
+var date_before = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const d = new Date(str);
+  if (isNaN(d.getTime())) return getMessage("date_before", args);
+  const before = args[0] ? new Date(String(args[0])) : /* @__PURE__ */ new Date();
+  if (isNaN(before.getTime())) return null;
+  return d < before ? null : getMessage("date_before", args);
+};
+var date_between = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const d = new Date(str);
+  if (isNaN(d.getTime())) return getMessage("date_between", args);
+  const lo = args[0] ? new Date(String(args[0])) : null;
+  const hi = args[1] ? new Date(String(args[1])) : null;
+  if (!lo || !hi || isNaN(lo.getTime()) || isNaN(hi.getTime())) return null;
+  return d >= lo && d <= hi ? null : getMessage("date_between", args);
+};
+var date_format = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const format = typeof args[0] === "string" ? args[0] : "YYYY-MM-DD";
+  const regex = format.replace(/YYYY/g, "\\d{4}").replace(/MM/g, "\\d{2}").replace(/DD/g, "\\d{2}").replace(/HH/g, "\\d{2}").replace(/mm/g, "\\d{2}").replace(/ss/g, "\\d{2}");
+  return new RegExp(`^${regex}$`).test(str) ? null : getMessage("date_format", args);
+};
+var ends_with = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const suffixes = args.map(String);
+  return suffixes.some((s) => str.endsWith(s)) ? null : getMessage("ends_with", args);
+};
+var is = (value, args) => {
+  const str = toString(value);
+  return args.some((arg) => String(arg) === str) ? null : getMessage("is", args);
+};
+var length = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const len = str.length;
+  const lo = toNumber(args[0]);
+  const hi = args[1] !== void 0 ? toNumber(args[1]) : lo;
+  if (lo === null) return null;
+  if (hi === null) return len === lo ? null : getMessage("length", args);
+  return len >= lo && len <= hi ? null : getMessage("length", args);
+};
+var lowercase = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return str === str.toLowerCase() ? null : getMessage("lowercase", args);
+};
+var not = (value, args) => {
+  const str = toString(value);
+  return args.some((arg) => String(arg) === str) ? getMessage("not", args) : null;
+};
+var require_one = (value, args, context) => {
+  const fieldNames = args.map(String);
+  const hasSome = fieldNames.some((name) => {
+    const v = context.values[name];
+    return v !== null && v !== void 0 && v !== "";
+  });
+  return hasSome ? null : getMessage("require_one", args);
+};
+var starts_with = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  const prefixes = args.map(String);
+  return prefixes.some((p) => str.startsWith(p)) ? null : getMessage("starts_with", args);
+};
+var symbol = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return /^[^a-zA-Z0-9\s]+$/.test(str) ? null : getMessage("symbol", args);
+};
+var uppercase = (value, args) => {
+  const str = toString(value);
+  if (!str) return null;
+  return str === str.toUpperCase() ? null : getMessage("uppercase", args);
+};
+var builtInRules = {
+  required,
+  email,
+  url,
+  min,
+  max,
+  minLength,
+  maxLength,
+  matches,
+  confirm,
+  alpha,
+  alphanumeric,
+  date,
+  between,
+  number,
+  accepted,
+  alpha_spaces,
+  contains_alpha,
+  contains_alphanumeric,
+  contains_alpha_spaces,
+  contains_lowercase,
+  contains_uppercase,
+  contains_numeric,
+  contains_symbol,
+  date_after,
+  date_before,
+  date_between,
+  date_format,
+  ends_with,
+  is,
+  length,
+  lowercase,
+  not,
+  require_one,
+  starts_with,
+  symbol,
+  uppercase
+};
+
+// src/validation/registry.ts
+var customRules = /* @__PURE__ */ new Map();
+function registerRule(name, rule) {
+  customRules.set(name, rule);
+}
+function getRule(name) {
+  return customRules.get(name) ?? builtInRules[name];
+}
+function hasRule(name) {
+  return customRules.has(name) || name in builtInRules;
+}
+function unregisterRule(name) {
+  customRules.delete(name);
+}
+
+// src/validation/zodAdapter.ts
+function validateWithZod(schema, value) {
+  const result = schema.safeParse(value);
+  if (result.success) return [];
+  return result.error.issues.map((issue) => {
+    const path = issue.path.join(".");
+    return createMessage({
+      key: `zod_${path || "root"}_${issue.code}`,
+      type: "validation",
+      value: issue.message,
+      blocking: true,
+      visible: true,
+      meta: {
+        zodCode: issue.code,
+        path: issue.path
+      }
+    });
+  });
+}
+function validateFormWithZod(schema, values) {
+  const result = schema.safeParse(values);
+  if (result.success) return {};
+  const errors = {};
+  for (const issue of result.error.issues) {
+    const fieldName = issue.path[0];
+    if (typeof fieldName === "string") {
+      if (!errors[fieldName]) {
+        errors[fieldName] = [];
+      }
+      errors[fieldName].push(issue.message);
+    }
+  }
+  return errors;
+}
+
+// src/validation/index.ts
+async function runValidation(spec, value, context, customMessages) {
+  const rules = parseRules(spec);
+  const messages = [];
+  const valueIsEmpty = isEmpty2(value);
+  for (const rule of rules) {
+    if (valueIsEmpty && !rule.hints.empty && rule.name !== "required") {
+      continue;
+    }
+    const error = await executeRule(rule, value, context, customMessages);
+    if (error) {
+      messages.push(error);
+      if (!rule.hints.force) {
+        break;
+      }
+    }
+  }
+  return messages;
+}
+async function executeRule(rule, value, context, customMessages) {
+  const handler = rule.handler ?? getRule(rule.name);
+  if (!handler) {
+    console.warn(`[FormFoundry] Unknown validation rule: "${rule.name}"`);
+    return null;
+  }
+  const errorString = await handler(value, rule.args, context);
+  if (errorString === null) return null;
+  const source = customMessages?.[rule.name];
+  let messageValue = errorString;
+  if (source) {
+    messageValue = typeof source === "function" ? source(rule.args.map(String)) : source;
+  }
+  return createMessage({
+    key: `rule_${rule.name}`,
+    type: "validation",
+    value: messageValue,
+    blocking: !rule.hints.optional,
+    visible: true,
+    meta: {
+      ruleName: rule.name,
+      ruleArgs: rule.args
+    }
+  });
+}
+function isEmpty2(value) {
+  if (value === null || value === void 0 || value === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+var defaultMeta = {
+  isSubmitting: false,
+  isValid: true,
+  errors: {},
+  register: () => {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("[FormFoundry] register called outside of a <Form> component");
+    }
+  },
+  unregister: () => {
+  },
+  getNode: () => void 0,
+  triggerValidation: async () => true,
+  showErrors: false,
+  config: {},
+  formNode: null,
+  reset: () => {
+  },
+  submitCount: 0,
+  setExternalErrors: () => {
+  },
+  clearExternalErrors: () => {
+  },
+  isDisabled: false
+};
+var FormMetaContext = React4.createContext(defaultMeta);
+function useFormMeta() {
+  return React4.useContext(FormMetaContext);
+}
+var defaultValues = {
+  values: {},
+  getValue: () => void 0,
+  setValue: () => {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("[FormFoundry] setValue called outside of a <Form> component");
+    }
+  }
+};
+var FormValuesContext = React4.createContext(defaultValues);
+function useFormValues() {
+  return React4.useContext(FormValuesContext);
+}
+
+// src/context/useFormContext.ts
+function useFormContext() {
+  return {
+    values: useFormValues(),
+    meta: useFormMeta()
+  };
+}
+function useFormFoundryField(options) {
+  const {
+    name,
+    validation,
+    validationBehavior: fieldBehavior,
+    defaultValue,
+    plugins,
+    disabled = false,
+    label,
+    inputType,
+    selectOptions,
+    dependsOn
+  } = options;
+  const reactId = React4.useId();
+  const fieldId = `formfoundry-${name}-${reactId}`;
+  const { values, getValue, setValue } = useFormValues();
+  const meta = useFormMeta();
+  const validationBehavior = fieldBehavior ?? meta.config.validationBehavior ?? "blur";
+  const nodeRef = React4.useRef(null);
+  if (!nodeRef.current) {
+    nodeRef.current = createNode({
+      type: "input",
+      name,
+      id: fieldId,
+      value: getValue(name) ?? defaultValue,
+      config: {
+        validation,
+        validationBehavior,
+        defaultValue,
+        plugins,
+        // Store label and inputType for print renderer access
+        label,
+        inputType: inputType ?? "text",
+        options: selectOptions
+      }
+    });
+  }
+  const node = nodeRef.current;
+  if (label !== void 0) {
+    node.config.label = label;
+  }
+  if (inputType !== void 0) {
+    node.config.inputType = inputType;
+  }
+  if (selectOptions !== void 0) {
+    node.config.options = selectOptions;
+  }
+  if (node.name !== name) {
+    const oldName = node.name;
+    node.name = name;
+    meta.unregister(oldName);
+    meta.register(name, node);
+  }
+  const [touched, setTouched] = React4.useState(false);
+  const [dirty, setDirty] = React4.useState(false);
+  const [errorStrings, setErrorStrings] = React4.useState([]);
+  const hasBlurredRef = React4.useRef(false);
+  const debounceTimerRef = React4.useRef(null);
+  const valuesRef = React4.useRef(values);
+  valuesRef.current = values;
+  const getValueRef = React4.useRef(getValue);
+  getValueRef.current = getValue;
+  const validationGenRef = React4.useRef(0);
+  const defaultValueRef = React4.useRef(defaultValue);
+  defaultValueRef.current = defaultValue;
+  const defaultValueJsonRef = React4.useRef(JSON.stringify(defaultValue));
+  defaultValueJsonRef.current = JSON.stringify(defaultValue);
+  const validate = React4.useCallback(async () => {
+    const gen = ++validationGenRef.current;
+    if (!validation) {
+      setErrorStrings([]);
+      node.store.clear("validation");
+      return;
+    }
+    if (isZodSchema(validation)) {
+      const msgs2 = validateWithZod(validation, getValueRef.current(name));
+      if (gen !== validationGenRef.current) return;
+      node.store.batch(() => {
+        node.store.clear("validation");
+        for (const msg of msgs2) {
+          node.store.set(msg);
+        }
+      });
+      setErrorStrings(msgs2.filter((m) => m.visible).map((m) => m.value));
+      return;
+    }
+    const msgs = await runValidation(
+      validation,
+      getValueRef.current(name),
+      {
+        values: valuesRef.current,
+        name,
+        label
+      },
+      meta.config.messages
+    );
+    if (gen !== validationGenRef.current) return;
+    node.store.batch(() => {
+      node.store.clear("validation");
+      for (const msg of msgs) {
+        node.store.set(msg);
+      }
+    });
+    setErrorStrings(msgs.filter((m) => m.visible).map((m) => m.value));
+  }, [validation, name, label, meta.config.messages, node]);
+  React4.useEffect(() => {
+    meta.register(name, node);
+    return () => {
+      meta.unregister(name);
+    };
+  }, [name, node, meta]);
+  React4.useEffect(() => {
+    meta.updateValidateCallback?.(name, validate);
+  }, [name, validate, meta]);
+  const onChange = React4.useCallback(
+    (newValue) => {
+      setValue(name, newValue);
+      void node.input(newValue).then(() => {
+        const committedValue = node.value;
+        if (committedValue !== newValue) {
+          setValue(name, committedValue);
+        }
+        const def = defaultValueRef.current ?? void 0;
+        let isDirty;
+        if (def !== null && typeof def === "object") {
+          isDirty = JSON.stringify(committedValue) !== defaultValueJsonRef.current;
+        } else {
+          isDirty = committedValue !== def;
+        }
+        setDirty(isDirty);
+        node.dirty = isDirty;
+      });
+      if (validationBehavior === "live" || validationBehavior === "blur" && hasBlurredRef.current || validationBehavior === "dirty" && newValue !== (defaultValueRef.current ?? void 0) || validationBehavior === "submit" && meta.submitCount > 0) {
+        if (debounceTimerRef.current) {
+          clearTimeout(debounceTimerRef.current);
+        }
+        const debounceMs = meta.config.validationDebounce ?? 150;
+        debounceTimerRef.current = setTimeout(() => {
+          void validate();
+        }, debounceMs);
+      }
+    },
+    [name, setValue, validationBehavior, validate, meta.config.validationDebounce, meta.submitCount, node]
+  );
+  const onBlur = React4.useCallback(() => {
+    setTouched(true);
+    node.touched = true;
+    hasBlurredRef.current = true;
+    if (validationBehavior === "blur") {
+      void validate();
+    }
+  }, [validationBehavior, validate, node]);
+  const depsKey = dependsOn?.join(",") ?? "";
+  const depsValues = dependsOn?.map((dep) => JSON.stringify(getValue(dep))).join("|") ?? "";
+  React4.useEffect(() => {
+    if (!dependsOn || dependsOn.length === 0) return;
+    if (touched || hasBlurredRef.current) {
+      void validate();
+    }
+  }, [depsKey, depsValues, validate]);
+  React4.useEffect(() => {
+    return () => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+    };
+  }, []);
+  const value = getValue(name) ?? defaultValue;
+  const valid = errorStrings.length === 0;
+  const error = errorStrings[0] ?? null;
+  const showErrors = touched || meta.showErrors;
+  const fieldDisabled = disabled || meta.isDisabled;
+  const fieldProps = React4.useMemo(
+    () => ({
+      value: value ?? "",
+      onChange,
+      onBlur,
+      "aria-invalid": showErrors && !valid ? true : void 0,
+      "aria-describedby": showErrors && error ? `${fieldId}-error` : void 0,
+      id: fieldId,
+      name,
+      disabled: fieldDisabled || void 0
+    }),
+    [value, onChange, onBlur, showErrors, valid, error, fieldId, name, fieldDisabled]
+  );
+  return {
+    value,
+    error: showErrors ? error : null,
+    errors: showErrors ? errorStrings : [],
+    touched,
+    dirty,
+    valid,
+    onChange,
+    onBlur,
+    fieldProps,
+    id: fieldId,
+    node
+  };
+}
+function isZodSchema(validation) {
+  return typeof validation === "object" && validation !== null && "_def" in validation && "safeParse" in validation;
+}
+function subscribeToNode(node, onChange) {
+  const unsubs = [
+    node.events.on("commit", onChange),
+    node.events.on("reset", onChange),
+    node.events.on("message-added", onChange),
+    node.events.on("message-removed", onChange)
+  ];
+  return () => unsubs.forEach((u) => u());
+}
+function useFormNode(id) {
+  const [, forceRender] = React4.useState(0);
+  const nodeUnsubRef = React4.useRef(null);
+  const triggerRender = React4.useCallback(() => {
+    forceRender((n) => n + 1);
+  }, []);
+  const subscribeToNodeEvents = React4.useCallback(
+    (node) => {
+      nodeUnsubRef.current?.();
+      nodeUnsubRef.current = subscribeToNode(node, triggerRender);
+    },
+    [triggerRender]
+  );
+  React4.useEffect(() => {
+    if (!id) return;
+    const node = getNode(id);
+    if (node) {
+      subscribeToNodeEvents(node);
+    }
+    const unsubRegistry = subscribeToRegistry((event, registeredId, registeredNode) => {
+      if (registeredId !== id) return;
+      if (event === "registered") {
+        subscribeToNodeEvents(registeredNode);
+        triggerRender();
+      } else if (event === "unregistered") {
+        nodeUnsubRef.current?.();
+        nodeUnsubRef.current = null;
+        triggerRender();
+      }
+    });
+    return () => {
+      unsubRegistry();
+      nodeUnsubRef.current?.();
+      nodeUnsubRef.current = null;
+    };
+  }, [id, triggerRender, subscribeToNodeEvents]);
+  return id ? getNode(id) : void 0;
+}
+function useFormNodes(ids) {
+  const [, forceRender] = React4.useState(0);
+  const nodeUnsubsRef = React4.useRef(/* @__PURE__ */ new Map());
+  const triggerRender = React4.useCallback(() => {
+    forceRender((n) => n + 1);
+  }, []);
+  const idsKey = ids.join(",");
+  React4.useEffect(() => {
+    for (const unsub of nodeUnsubsRef.current.values()) {
+      unsub();
+    }
+    nodeUnsubsRef.current.clear();
+    const idSet = new Set(ids);
+    for (const id of ids) {
+      const node = getNode(id);
+      if (node) {
+        nodeUnsubsRef.current.set(id, subscribeToNode(node, triggerRender));
+      }
+    }
+    const unsubRegistry = subscribeToRegistry((event, registeredId, registeredNode) => {
+      if (!idSet.has(registeredId)) return;
+      if (event === "registered") {
+        nodeUnsubsRef.current.get(registeredId)?.();
+        nodeUnsubsRef.current.set(
+          registeredId,
+          subscribeToNode(registeredNode, triggerRender)
+        );
+        triggerRender();
+      } else if (event === "unregistered") {
+        nodeUnsubsRef.current.get(registeredId)?.();
+        nodeUnsubsRef.current.delete(registeredId);
+        triggerRender();
+      }
+    });
+    return () => {
+      unsubRegistry();
+      for (const unsub of nodeUnsubsRef.current.values()) {
+        unsub();
+      }
+      nodeUnsubsRef.current.clear();
+    };
+  }, [idsKey, triggerRender]);
+  const result = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    result.set(id, getNode(id));
+  }
+  return result;
+}
+function useFormPrint(defaultOptions) {
+  const { values } = useFormValues();
+  const meta = useFormMeta();
+  const printContainerRef = React4.useRef(null);
+  const getFieldDescriptors = React4.useCallback(
+    (_mode) => {
+      const descriptors = [];
+      const formNode = meta.formNode;
+      if (!formNode) return descriptors;
+      for (const child of formNode.children) {
+        const name = child.name;
+        const config = child.config ?? {};
+        const label = config.label;
+        const type = child.type === "input" ? config.inputType ?? "text" : child.type;
+        if (child.type !== "input") continue;
+        const descriptor = {
+          name,
+          label: label ?? name,
+          type,
+          value: values[name],
+          options: config.options
+        };
+        descriptors.push(descriptor);
+      }
+      return descriptors;
+    },
+    [meta.formNode, values]
+  );
+  const printForm = React4.useCallback(
+    (overrides) => {
+      const options = { ...defaultOptions, ...overrides };
+      const mode = options.mode ?? "filled";
+      const fields = getFieldDescriptors(mode);
+      injectPrintCSS();
+      const container = document.createElement("div");
+      container.setAttribute("data-formfoundry-print-root", "");
+      container.style.display = "none";
+      const resolvedMode = mode === "current" ? "filled" : mode;
+      container.innerHTML = buildPrintHTML(fields, resolvedMode, options);
+      document.body.appendChild(container);
+      printContainerRef.current = container;
+      container.style.display = "block";
+      requestAnimationFrame(() => {
+        window.print();
+        setTimeout(() => {
+          if (printContainerRef.current) {
+            document.body.removeChild(printContainerRef.current);
+            printContainerRef.current = null;
+          }
+        }, 100);
+      });
+    },
+    [defaultOptions, getFieldDescriptors]
+  );
+  return { printForm, getFieldDescriptors };
+}
+function buildPrintHTML(fields, mode, options) {
+  const header = options.title || options.subtitle ? `<div class="ff-print__header">
+            ${options.title ? `<h1 class="ff-print__title">${escapeHtml(options.title)}</h1>` : ""}
+            ${options.subtitle ? `<p class="ff-print__subtitle">${escapeHtml(options.subtitle)}</p>` : ""}
+           </div>` : "";
+  const fieldRows = fields.map((field) => {
+    const label = escapeHtml(field.label || field.name);
+    const isTextarea = field.type === "textarea";
+    const fieldClass = `ff-print__field${isTextarea ? " ff-print__field--textarea" : ""}`;
+    const valueHtml = mode === "blank" ? buildBlankValue(field) : buildFilledValue(field);
+    return `<li class="${fieldClass}">
+            <span class="ff-print__label">${label}:</span>
+            <span class="ff-print__value">${valueHtml}</span>
+        </li>`;
+  }).join("\n");
+  const footer = options.footer ? `<div class="ff-print__footer">${escapeHtml(options.footer)}</div>` : "";
+  return `<div class="ff-print${options.className ? ` ${options.className}` : ""}">
+        ${header}
+        <ul class="ff-print__fields">${fieldRows}</ul>
+        ${footer}
+    </div>`;
+}
+function buildBlankValue(field) {
+  switch (field.type) {
+    case "checkbox":
+    case "switch":
+      return '<span class="ff-print__blank-box"></span>';
+    case "radio":
+      return `<span class="ff-print__blank-options">
+                ${(field.options ?? []).map(
+        (opt) => `<span class="ff-print__blank-option"><span class="ff-print__blank-radio"></span>${escapeHtml(opt.label)}</span>`
+      ).join("")}
+            </span>`;
+    case "select":
+    case "checkboxgroup":
+      return `<span class="ff-print__blank-options">
+                ${(field.options ?? []).map(
+        (opt) => `<span class="ff-print__blank-option"><span class="ff-print__blank-box"></span>${escapeHtml(opt.label)}</span>`
+      ).join("")}
+            </span>`;
+    case "textarea":
+      return '<div class="ff-print__blank-textarea"></div>';
+    default:
+      return '<span class="ff-print__blank-line"></span>';
+  }
+}
+function buildFilledValue(field) {
+  const { value, type } = field;
+  switch (type) {
+    case "checkbox":
+    case "switch":
+      return `<span class="ff-print__filled-check">${value ? "\u2611" : "\u2610"}</span>`;
+    case "radio":
+    case "select": {
+      const selected = field.options?.find(
+        (opt) => String(opt.value) === String(value)
+      );
+      return `<span class="ff-print__filled-value">${escapeHtml(selected?.label ?? String(value ?? "\u2014"))}</span>`;
+    }
+    case "checkboxgroup": {
+      const selectedValues = Array.isArray(value) ? value : [];
+      const labels = (field.options ?? []).filter((opt) => selectedValues.includes(opt.value)).map((opt) => opt.label);
+      return `<span class="ff-print__filled-value">${escapeHtml(labels.length > 0 ? labels.join(", ") : "\u2014")}</span>`;
+    }
+    case "textarea":
+      return `<div class="ff-print__filled-textarea">${escapeHtml(String(value ?? ""))}</div>`;
+    case "file":
+      return `<span class="ff-print__filled-value">${value ? escapeHtml(String(value)) : "No file selected"}</span>`;
+    case "hidden":
+      return "";
+    default:
+      return `<span class="ff-print__filled-value">${value != null && value !== "" ? escapeHtml(String(value)) : "\u2014"}</span>`;
+  }
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var PRINT_STYLE_ID = "formfoundry-print-css";
+function injectPrintCSS() {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(PRINT_STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = PRINT_STYLE_ID;
+  style.textContent = PRINT_CSS;
+  document.head.appendChild(style);
+}
+var PRINT_CSS = `
+@media print {
+    body > *:not([data-formfoundry-print-root]) {
+        display: none !important;
+    }
+    [data-formfoundry-print-root] {
+        display: block !important;
+        position: static !important;
+        width: 100% !important;
+        background: white !important;
+        color: black !important;
+    }
+}
+.ff-print {
+    font-family: 'Georgia', 'Times New Roman', serif;
+    font-size: 12pt;
+    line-height: 1.5;
+    color: #000;
+    background: #fff;
+    padding: 0.5in;
+    max-width: 8.5in;
+    margin: 0 auto;
+}
+.ff-print__header {
+    text-align: center;
+    margin-bottom: 1.5rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 2px solid #000;
+}
+.ff-print__title {
+    font-size: 18pt;
+    font-weight: 700;
+    margin: 0 0 0.25rem 0;
+}
+.ff-print__subtitle {
+    font-size: 10pt;
+    color: #555;
+    margin: 0;
+    font-style: italic;
+}
+.ff-print__fields {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+.ff-print__field {
+    display: flex;
+    align-items: baseline;
+    padding: 0.4rem 0;
+    border-bottom: 1px solid #e5e5e5;
+    break-inside: avoid;
+    page-break-inside: avoid;
+}
+.ff-print__field--textarea {
+    flex-direction: column;
+    align-items: stretch;
+}
+.ff-print__label {
+    font-weight: 600;
+    font-size: 10pt;
+    min-width: 160px;
+    flex-shrink: 0;
+    color: #333;
+}
+.ff-print__value {
+    flex: 1;
+    font-size: 11pt;
+}
+.ff-print__blank-line {
+    flex: 1;
+    border-bottom: 1px solid #999;
+    min-height: 1.2em;
+    margin-left: 0.5rem;
+}
+.ff-print__blank-box {
+    display: inline-block;
+    width: 14px;
+    height: 14px;
+    border: 1.5px solid #666;
+    vertical-align: middle;
+    margin-right: 0.25rem;
+    border-radius: 2px;
+}
+.ff-print__blank-radio {
+    display: inline-block;
+    width: 14px;
+    height: 14px;
+    border: 1.5px solid #666;
+    vertical-align: middle;
+    margin-right: 0.25rem;
+    border-radius: 50%;
+}
+.ff-print__blank-textarea {
+    border: 1px solid #999;
+    min-height: 4em;
+    margin-top: 0.35rem;
+    border-radius: 2px;
+}
+.ff-print__blank-options {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    margin-left: 0.5rem;
+}
+.ff-print__blank-option {
+    display: flex;
+    align-items: center;
+    gap: 0.35rem;
+    font-size: 10pt;
+}
+.ff-print__filled-value {
+    font-size: 11pt;
+    margin-left: 0.5rem;
+}
+.ff-print__filled-check {
+    font-size: 13pt;
+    margin-left: 0.5rem;
+}
+.ff-print__filled-textarea {
+    white-space: pre-wrap;
+    font-size: 10pt;
+    margin-top: 0.35rem;
+    padding: 0.35rem;
+    background: #fafafa;
+    border: 1px solid #e0e0e0;
+    border-radius: 2px;
+    min-height: 2em;
+}
+.ff-print__footer {
+    margin-top: 2rem;
+    padding-top: 0.75rem;
+    border-top: 1px solid #ccc;
+    font-size: 9pt;
+    color: #888;
+    text-align: center;
+}
+.ff-print--preview {
+    border: 1px solid #ddd;
+    border-radius: 8px;
+    box-shadow: 0 2px 12px rgba(0, 0, 0, 0.08);
+    margin: 1rem 0;
+}
+`;
+var InputRegistryContext = React4.createContext(null);
+function useInputRegistry() {
+  const registry = React4.useContext(InputRegistryContext);
+  if (!registry) {
+    throw new Error(
+      "[FormFoundry] useInputRegistry must be used within a <FormFoundryProvider>. Wrap your application or form tree with <FormFoundryProvider>."
+    );
+  }
+  return registry;
+}
+function createRegistry(entries) {
+  const map = /* @__PURE__ */ new Map();
+  if (entries) {
+    for (const [type, component] of Object.entries(entries)) {
+      map.set(type, component);
+    }
+  }
+  return {
+    register(type, component) {
+      map.set(type, component);
+    },
+    get(type) {
+      return map.get(type);
+    },
+    has(type) {
+      return map.has(type);
+    },
+    keys() {
+      return [...map.keys()];
+    }
+  };
+}
+function createDefaultRegistry() {
+  return createRegistry();
+}
+var FormFoundryProviderContext = React4.createContext({});
+function useFormFoundryProvider() {
+  return React4.useContext(FormFoundryProviderContext);
+}
+function FormFoundryProvider({
+  config,
+  locale,
+  registry,
+  plugins,
+  children
+}) {
+  const inputRegistry = React4.useMemo(
+    () => registry ?? createDefaultRegistry(),
+    [registry]
+  );
+  const providerValue = React4.useMemo(
+    () => ({
+      config: config ? { ...config, locale } : locale ? { locale } : void 0,
+      plugins
+    }),
+    [config, locale, plugins]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(FormFoundryProviderContext.Provider, { value: providerValue, children: /* @__PURE__ */ jsxRuntime.jsx(InputRegistryContext.Provider, { value: inputRegistry, children }) });
+}
+function formReducer(state, action) {
+  switch (action.type) {
+    case "SET_VALUE":
+      return {
+        ...state,
+        values: { ...state.values, [action.name]: action.value }
+      };
+    case "SET_VALUES":
+      return { ...state, values: action.values };
+    case "SET_SUBMITTING":
+      return { ...state, isSubmitting: action.isSubmitting };
+    case "SHOW_ERRORS":
+      return { ...state, showErrors: true };
+    case "RESET":
+      return {
+        values: action.values,
+        isSubmitting: false,
+        showErrors: false,
+        submitCount: 0,
+        externalErrors: {}
+      };
+    case "INCREMENT_SUBMIT_COUNT":
+      return { ...state, submitCount: state.submitCount + 1 };
+    case "SET_EXTERNAL_ERRORS":
+      return { ...state, externalErrors: action.errors };
+    case "CLEAR_EXTERNAL_ERRORS":
+      return { ...state, externalErrors: {} };
+    default:
+      return state;
+  }
+}
+function Form({
+  id: formId,
+  ref,
+  onSubmit,
+  onSubmitRaw,
+  defaultValues: defaultValues2 = {},
+  schema,
+  resolver,
+  plugins,
+  validationBehavior,
+  showErrors: showErrorsProp,
+  disableOnSubmit = true,
+  as: Component = "form",
+  children,
+  className
+}) {
+  const providerConfig = useFormFoundryProvider();
+  const [state, dispatch] = React4.useReducer(formReducer, {
+    values: defaultValues2,
+    isSubmitting: false,
+    showErrors: false,
+    submitCount: 0,
+    externalErrors: {}
+  });
+  const [validationVersion, setValidationVersion] = React4.useState(0);
+  const nodesRef = React4.useRef(/* @__PURE__ */ new Map());
+  const validateCallbacksRef = React4.useRef(/* @__PURE__ */ new Map());
+  const formNodeRef = React4.useRef(null);
+  if (!formNodeRef.current) {
+    formNodeRef.current = createNode({
+      type: "group",
+      name: "__form__",
+      id: formId,
+      value: defaultValues2,
+      config: {
+        validationBehavior: validationBehavior ?? providerConfig.config?.validationBehavior,
+        plugins: [...providerConfig.plugins ?? [], ...plugins ?? []]
+      }
+    });
+  }
+  const defaultValuesRef = React4.useRef(defaultValues2);
+  defaultValuesRef.current = defaultValues2;
+  const valuesContext = React4.useMemo(
+    () => ({
+      values: state.values,
+      getValue: (name) => state.values[name],
+      setValue: (name, value) => {
+        dispatch({ type: "SET_VALUE", name, value });
+      }
+    }),
+    [state.values]
+  );
+  const valuesRef = React4.useRef(state.values);
+  valuesRef.current = state.values;
+  const externalErrorsRef = React4.useRef(state.externalErrors);
+  externalErrorsRef.current = state.externalErrors;
+  const register = React4.useCallback((name, node) => {
+    nodesRef.current.set(name, node);
+    if (formNodeRef.current && !formNodeRef.current.children.includes(node)) {
+      formNodeRef.current.addChild(node);
+    }
+  }, []);
+  const updateValidateCallback = React4.useCallback((name, validate) => {
+    const wrappedValidate = async () => {
+      await validate();
+      setValidationVersion((v) => v + 1);
+    };
+    validateCallbacksRef.current.set(name, wrappedValidate);
+  }, []);
+  const unregister = React4.useCallback((name) => {
+    const node = nodesRef.current.get(name);
+    if (node) {
+      formNodeRef.current?.removeChild(node);
+    }
+    nodesRef.current.delete(name);
+    validateCallbacksRef.current.delete(name);
+  }, []);
+  const getNode2 = React4.useCallback(
+    (name) => nodesRef.current.get(name),
+    []
+  );
+  const triggerValidation = React4.useCallback(
+    async (name) => {
+      if (name) {
+        const validateFn = validateCallbacksRef.current.get(name);
+        if (validateFn) {
+          await validateFn();
+        }
+        const node = nodesRef.current.get(name);
+        return node ? node.valid : true;
+      }
+      const validationPromises = [];
+      for (const validateFn of validateCallbacksRef.current.values()) {
+        validationPromises.push(validateFn());
+      }
+      await Promise.all(validationPromises);
+      let allValid = true;
+      for (const node of nodesRef.current.values()) {
+        if (!node.valid) {
+          allValid = false;
+        }
+      }
+      if (schema) {
+        const formErrors = validateFormWithZod(schema, valuesRef.current);
+        if (Object.keys(formErrors).length > 0) {
+          allValid = false;
+        }
+      }
+      if (resolver) {
+        const result = await resolver(valuesRef.current);
+        if (Object.keys(result.errors).length > 0) {
+          allValid = false;
+        }
+      }
+      return allValid;
+    },
+    [schema, resolver]
+  );
+  const reset = React4.useCallback((values) => {
+    const resetValues = values ?? defaultValuesRef.current;
+    for (const [fieldName, node] of nodesRef.current) {
+      node.reset(resetValues[fieldName]);
+    }
+    dispatch({ type: "RESET", values: resetValues });
+  }, []);
+  const setExternalErrors = React4.useCallback((errors) => {
+    const normalized = {};
+    for (const [key, val] of Object.entries(errors)) {
+      normalized[key] = Array.isArray(val) ? val : [val];
+    }
+    dispatch({ type: "SET_EXTERNAL_ERRORS", errors: normalized });
+  }, []);
+  const clearExternalErrors = React4.useCallback(() => {
+    dispatch({ type: "CLEAR_EXTERNAL_ERRORS" });
+  }, []);
+  const aggregatedErrors = React4.useMemo(() => {
+    const errors = {};
+    for (const [name, node] of nodesRef.current) {
+      if (node.errors.length > 0) {
+        errors[name] = [...node.errors];
+      }
+    }
+    for (const [name, extErrors] of Object.entries(state.externalErrors)) {
+      if (!errors[name]) {
+        errors[name] = [];
+      }
+      errors[name].push(...extErrors);
+    }
+    return errors;
+  }, [state.values, state.externalErrors, validationVersion]);
+  const isValid = React4.useMemo(() => {
+    for (const node of nodesRef.current.values()) {
+      if (!node.valid) return false;
+    }
+    return Object.keys(state.externalErrors).length === 0;
+  }, [state.values, state.externalErrors, validationVersion]);
+  const isDisabled = disableOnSubmit && state.isSubmitting;
+  const metaContext = React4.useMemo(
+    () => ({
+      isSubmitting: state.isSubmitting,
+      isValid,
+      errors: aggregatedErrors,
+      register,
+      unregister,
+      updateValidateCallback,
+      getNode: getNode2,
+      triggerValidation,
+      showErrors: state.showErrors || (showErrorsProp ?? false),
+      config: {
+        ...providerConfig.config,
+        validationBehavior: validationBehavior ?? providerConfig.config?.validationBehavior
+      },
+      formNode: formNodeRef.current,
+      reset,
+      submitCount: state.submitCount,
+      setExternalErrors,
+      clearExternalErrors,
+      isDisabled
+    }),
+    [
+      state.isSubmitting,
+      state.showErrors,
+      state.submitCount,
+      state.externalErrors,
+      isValid,
+      isDisabled,
+      aggregatedErrors,
+      register,
+      unregister,
+      updateValidateCallback,
+      getNode2,
+      triggerValidation,
+      showErrorsProp,
+      providerConfig.config,
+      validationBehavior,
+      reset,
+      setExternalErrors,
+      clearExternalErrors
+    ]
+  );
+  const performSubmit = React4.useCallback(
+    async () => {
+      dispatch({ type: "INCREMENT_SUBMIT_COUNT" });
+      onSubmitRaw?.(valuesRef.current);
+      dispatch({ type: "SHOW_ERRORS" });
+      const valid = await triggerValidation();
+      if (!valid) return;
+      dispatch({ type: "SET_SUBMITTING", isSubmitting: true });
+      try {
+        const formNode = formNodeRef.current;
+        const currentValues = valuesRef.current;
+        const values = formNode ? formNode.hooks.submit.dispatch({ ...currentValues }) : currentValues;
+        await onSubmit(values);
+      } finally {
+        dispatch({ type: "SET_SUBMITTING", isSubmitting: false });
+      }
+    },
+    [triggerValidation, onSubmit, onSubmitRaw]
+  );
+  const handleSubmit = React4.useCallback(
+    async (e) => {
+      e.preventDefault();
+      await performSubmit();
+    },
+    [performSubmit]
+  );
+  React4.useEffect(() => {
+    const formNode = formNodeRef.current;
+    if (formNode) {
+      formNode.submit = performSubmit;
+    }
+  }, [performSubmit]);
+  const { printForm } = useFormPrint();
+  React4.useImperativeHandle(ref, () => ({
+    submit: performSubmit,
+    reset,
+    getValues: () => ({ ...valuesRef.current }),
+    isValid: () => {
+      for (const node of nodesRef.current.values()) {
+        if (!node.valid) return false;
+      }
+      return Object.keys(externalErrorsRef.current).length === 0;
+    },
+    printForm
+  }), [performSubmit, reset, printForm]);
+  return /* @__PURE__ */ jsxRuntime.jsx(FormValuesContext.Provider, { value: valuesContext, children: /* @__PURE__ */ jsxRuntime.jsx(FormMetaContext.Provider, { value: metaContext, children: /* @__PURE__ */ jsxRuntime.jsx(
+    Component,
+    {
+      onSubmit: Component === "form" ? handleSubmit : void 0,
+      className,
+      noValidate: Component === "form" ? true : void 0,
+      children
+    }
+  ) }) });
+}
+
+// src/schema/expressions.ts
+var EXPRESSION_PREFIX = "$: ";
+function isExpression(value) {
+  return typeof value === "string" && value.startsWith(EXPRESSION_PREFIX);
+}
+function isVariableRef(value) {
+  return typeof value === "string" && value.startsWith("$") && !value.startsWith("$: ") && !value.startsWith("$el") && !value.startsWith("$cmp") && !value.startsWith("$formfoundry");
+}
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && i + 1 < expr.length && /[0-9]/.test(expr[i + 1])) {
+      let num = "";
+      while (i < expr.length && /[0-9.]/.test(expr[i])) {
+        num += expr[i];
+        i++;
+      }
+      tokens.push({ type: "number", value: parseFloat(num) });
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      let str = "";
+      while (i < expr.length && expr[i] !== quote) {
+        if (expr[i] === "\\" && i + 1 < expr.length) {
+          i++;
+          str += expr[i];
+        } else {
+          str += expr[i];
+        }
+        i++;
+      }
+      i++;
+      tokens.push({ type: "string", value: str });
+      continue;
+    }
+    if (ch === "$") {
+      i++;
+      let varName = "";
+      while (i < expr.length && /[a-zA-Z0-9_]/.test(expr[i])) {
+        varName += expr[i];
+        i++;
+      }
+      while (i < expr.length && expr[i] === "." && i + 1 < expr.length && /[a-zA-Z_]/.test(expr[i + 1])) {
+        varName += ".";
+        i++;
+        while (i < expr.length && /[a-zA-Z0-9_]/.test(expr[i])) {
+          varName += expr[i];
+          i++;
+        }
+      }
+      tokens.push({ type: "variable", value: varName });
+      continue;
+    }
+    if (expr.slice(i, i + 4) === "true" && (i + 4 >= expr.length || !/[a-zA-Z0-9_]/.test(expr[i + 4]))) {
+      tokens.push({ type: "boolean", value: true });
+      i += 4;
+      continue;
+    }
+    if (expr.slice(i, i + 5) === "false" && (i + 5 >= expr.length || !/[a-zA-Z0-9_]/.test(expr[i + 5]))) {
+      tokens.push({ type: "boolean", value: false });
+      i += 5;
+      continue;
+    }
+    if (expr.slice(i, i + 3) === "===" || expr.slice(i, i + 3) === "!==") {
+      tokens.push({ type: "operator", value: expr.slice(i, i + 3) });
+      i += 3;
+      continue;
+    }
+    if (expr.slice(i, i + 2) === "&&" || expr.slice(i, i + 2) === "||" || expr.slice(i, i + 2) === ">=" || expr.slice(i, i + 2) === "<=") {
+      tokens.push({ type: "operator", value: expr.slice(i, i + 2) });
+      i += 2;
+      continue;
+    }
+    if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%" || ch === ">" || ch === "<") {
+      tokens.push({ type: "operator", value: ch });
+      i++;
+      continue;
+    }
+    if (ch === ".") {
+      tokens.push({ type: "dot", value: "." });
+      i++;
+      continue;
+    }
+    if (ch === "?") {
+      tokens.push({ type: "ternary_q", value: "?" });
+      i++;
+      continue;
+    }
+    if (ch === ":") {
+      tokens.push({ type: "ternary_c", value: ":" });
+      i++;
+      continue;
+    }
+    if (ch === "(" || ch === ")") {
+      tokens.push({ type: "paren", value: ch });
+      i++;
+      continue;
+    }
+    if (ch === "!" && (i + 1 >= expr.length || expr[i + 1] !== "=")) {
+      tokens.push({ type: "not", value: "!" });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return tokens;
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  pos = 0;
+  parse() {
+    const ast = this.parseTernary();
+    return ast;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  consume() {
+    return this.tokens[this.pos++];
+  }
+  parseTernary() {
+    let node = this.parseOr();
+    if (this.peek()?.type === "ternary_q") {
+      this.consume();
+      const consequent = this.parseTernary();
+      if (this.peek()?.type === "ternary_c") {
+        this.consume();
+      }
+      const alternate = this.parseTernary();
+      node = { kind: "ternary", condition: node, consequent, alternate };
+    }
+    return node;
+  }
+  parseOr() {
+    let node = this.parseAnd();
+    while (this.peek()?.type === "operator" && this.peek()?.value === "||") {
+      const op = this.consume().value;
+      const right = this.parseAnd();
+      node = { kind: "binary", op, left: node, right };
+    }
+    return node;
+  }
+  parseAnd() {
+    let node = this.parseEquality();
+    while (this.peek()?.type === "operator" && this.peek()?.value === "&&") {
+      const op = this.consume().value;
+      const right = this.parseEquality();
+      node = { kind: "binary", op, left: node, right };
+    }
+    return node;
+  }
+  parseEquality() {
+    let node = this.parseComparison();
+    while (this.peek()?.type === "operator" && (this.peek()?.value === "===" || this.peek()?.value === "!==")) {
+      const op = this.consume().value;
+      const right = this.parseComparison();
+      node = { kind: "binary", op, left: node, right };
+    }
+    return node;
+  }
+  parseComparison() {
+    let node = this.parseAdditive();
+    while (this.peek()?.type === "operator" && (this.peek()?.value === ">" || this.peek()?.value === "<" || this.peek()?.value === ">=" || this.peek()?.value === "<=")) {
+      const op = this.consume().value;
+      const right = this.parseAdditive();
+      node = { kind: "binary", op, left: node, right };
+    }
+    return node;
+  }
+  parseAdditive() {
+    let node = this.parseMultiplicative();
+    while (this.peek()?.type === "operator" && (this.peek()?.value === "+" || this.peek()?.value === "-")) {
+      const op = this.consume().value;
+      const right = this.parseMultiplicative();
+      node = { kind: "binary", op, left: node, right };
+    }
+    return node;
+  }
+  parseMultiplicative() {
+    let node = this.parseUnary();
+    while (this.peek()?.type === "operator" && (this.peek()?.value === "*" || this.peek()?.value === "/" || this.peek()?.value === "%")) {
+      const op = this.consume().value;
+      const right = this.parseUnary();
+      node = { kind: "binary", op, left: node, right };
+    }
+    return node;
+  }
+  parseUnary() {
+    if (this.peek()?.type === "not") {
+      this.consume();
+      const operand = this.parseUnary();
+      return { kind: "unary", op: "!", operand };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const token = this.peek();
+    if (!token) {
+      return { kind: "literal", value: void 0 };
+    }
+    if (token.type === "paren" && token.value === "(") {
+      this.consume();
+      const node = this.parseTernary();
+      if (this.peek()?.type === "paren" && this.peek()?.value === ")") {
+        this.consume();
+      }
+      return node;
+    }
+    if (token.type === "number" || token.type === "string" || token.type === "boolean") {
+      this.consume();
+      return { kind: "literal", value: token.value };
+    }
+    if (token.type === "variable") {
+      this.consume();
+      const path = token.value.split(".");
+      return { kind: "variable", path };
+    }
+    this.consume();
+    return { kind: "literal", value: void 0 };
+  }
+};
+function resolvePath(data, path) {
+  let current = data;
+  for (const segment of path) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function evaluate(ast, data) {
+  switch (ast.kind) {
+    case "literal":
+      return ast.value;
+    case "variable":
+      return resolvePath(data, ast.path);
+    case "unary": {
+      const val = evaluate(ast.operand, data);
+      if (ast.op === "!") return !val;
+      return val;
+    }
+    case "binary": {
+      const left = evaluate(ast.left, data);
+      const right = evaluate(ast.right, data);
+      switch (ast.op) {
+        case "+": {
+          if (typeof left === "string" || typeof right === "string") {
+            return String(left ?? "") + String(right ?? "");
+          }
+          return left + right;
+        }
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return right !== 0 ? left / right : 0;
+        case "%":
+          return right !== 0 ? left % right : 0;
+        case "===":
+          return left === right;
+        case "!==":
+          return left !== right;
+        case ">":
+          return left > right;
+        case "<":
+          return left < right;
+        case ">=":
+          return left >= right;
+        case "<=":
+          return left <= right;
+        case "&&":
+          return left && right;
+        case "||":
+          return left || right;
+        default:
+          return void 0;
+      }
+    }
+    case "ternary": {
+      const condition = evaluate(ast.condition, data);
+      return condition ? evaluate(ast.consequent, data) : evaluate(ast.alternate, data);
+    }
+  }
+}
+function evaluateExpression(expression, data) {
+  const raw = expression.startsWith(EXPRESSION_PREFIX) ? expression.slice(EXPRESSION_PREFIX.length) : expression;
+  const tokens = tokenize(raw);
+  const parser = new Parser(tokens);
+  const ast = parser.parse();
+  return evaluate(ast, data);
+}
+function resolveVariableRef(ref, data) {
+  const path = ref.slice(1).split(".");
+  return resolvePath(data, path);
+}
+function resolveSchemaValue(value, data) {
+  if (isExpression(value)) {
+    return evaluateExpression(value, data);
+  }
+  if (isVariableRef(value)) {
+    return resolveVariableRef(value, data);
+  }
+  return value;
+}
+var SchemaDataContext = React4.createContext({
+  values: {},
+  data: {},
+  merged: {}
+});
+function useSchemaData() {
+  return React4.useContext(SchemaDataContext);
+}
+function SchemaRenderer({ schema, library, data = {} }) {
+  const registry = useInputRegistry();
+  const { values } = useFormValues();
+  const schemaDataContext = React4.useMemo(
+    () => ({
+      values,
+      data,
+      merged: { ...values, ...data }
+    }),
+    [values, data]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(SchemaDataContext.Provider, { value: schemaDataContext, children: schema.map((node, index) => /* @__PURE__ */ jsxRuntime.jsx(
+    SchemaNodeRenderer,
+    {
+      node,
+      registry,
+      library
+    },
+    getNodeKey(node, index)
+  )) });
+}
+function SchemaNodeRenderer({
+  node,
+  registry,
+  library
+}) {
+  const { merged } = useSchemaData();
+  if ("for" in node && Array.isArray(node.for)) {
+    return renderLoop(node, registry, library, merged);
+  }
+  if ("then" in node && "if" in node && !("$formfoundry" in node) && !("$el" in node) && !("$cmp" in node)) {
+    return renderConditional(
+      node,
+      registry,
+      library,
+      merged
+    );
+  }
+  if ("if" in node && typeof node.if === "function" && !node.if(merged)) {
+    return null;
+  }
+  if ("$formfoundry" in node) {
+    return renderFormFoundryInput(node, registry, merged);
+  }
+  if ("$el" in node) {
+    return renderHtmlElement(
+      node,
+      registry,
+      library,
+      merged
+    );
+  }
+  if ("$cmp" in node) {
+    return renderComponent(
+      node,
+      registry,
+      library,
+      merged
+    );
+  }
+  return null;
+}
+function renderFormFoundryInput(node, registry, merged = {}) {
+  const { $formfoundry, if: _if, ...rawProps } = node;
+  const Component = registry.get($formfoundry);
+  if (!Component) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[FormFoundry] No input registered for type "${$formfoundry}". Available types: ${registry.keys().join(", ") || "(none)"}`
+      );
+    }
+    return null;
+  }
+  const props = resolveObjectExpressions(rawProps, merged);
+  return /* @__PURE__ */ jsxRuntime.jsx(Component, { ...props });
+}
+function renderHtmlElement(node, registry, library, merged = {}) {
+  const { $el, attrs: rawAttrs, children, if: _if } = node;
+  const attrs = rawAttrs ? resolveObjectExpressions(rawAttrs, merged) : void 0;
+  const childContent = resolveChildren(children, registry, library, merged);
+  return React4__default.default.createElement($el, attrs, childContent);
+}
+function renderComponent(node, registry, library, merged = {}) {
+  const { $cmp, props: rawProps, children, if: _if } = node;
+  const Component = library?.[$cmp];
+  if (!Component) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[FormFoundry] No component found for "$cmp: ${$cmp}" in library.`
+      );
+    }
+    return null;
+  }
+  const resolvedProps = rawProps ? resolveObjectExpressions(rawProps, merged) : {};
+  const childContent = resolveChildren(children, registry, library, merged);
+  return /* @__PURE__ */ jsxRuntime.jsx(Component, { ...resolvedProps, children: childContent });
+}
+function renderConditional(node, registry, library, merged) {
+  const branch = node.if(merged) ? node.then : node.else;
+  if (!branch) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: branch.map((child, index) => /* @__PURE__ */ jsxRuntime.jsx(
+    SchemaNodeRenderer,
+    {
+      node: child,
+      registry,
+      library
+    },
+    getNodeKey(child, index)
+  )) });
+}
+function renderLoop(node, registry, library, merged) {
+  const [itemName, indexName, source] = node.for;
+  const items = typeof source === "string" ? merged[source] ?? [] : source ?? [];
+  if (!Array.isArray(items)) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: items.map((item, idx) => {
+    const loopData = {
+      ...merged,
+      [itemName]: item,
+      [indexName]: idx
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      SchemaDataContext.Provider,
+      {
+        value: { values: {}, data: loopData, merged: loopData },
+        children: node.children.map((child, childIdx) => /* @__PURE__ */ jsxRuntime.jsx(
+          SchemaNodeRenderer,
+          {
+            node: child,
+            registry,
+            library
+          },
+          getNodeKey(child, childIdx)
+        ))
+      },
+      `loop_${idx}`
+    );
+  }) });
+}
+function resolveObjectExpressions(obj, data) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(obj)) {
+    resolved[key] = resolveSchemaValue(value, data);
+  }
+  return resolved;
+}
+function resolveChildren(children, registry, library, merged) {
+  if (children === void 0) return null;
+  if (typeof children === "string") {
+    if (isExpression(children) || isVariableRef(children)) {
+      return String(resolveSchemaValue(children, merged) ?? "");
+    }
+    return children;
+  }
+  return children.map((child, index) => /* @__PURE__ */ jsxRuntime.jsx(
+    SchemaNodeRenderer,
+    {
+      node: child,
+      registry,
+      library
+    },
+    getNodeKey(child, index)
+  ));
+}
+function getNodeKey(node, index) {
+  if ("name" in node && typeof node.name === "string") {
+    return node.name;
+  }
+  if ("$el" in node) {
+    return `el_${index}`;
+  }
+  if ("$cmp" in node) {
+    return `cmp_${node.$cmp}_${index}`;
+  }
+  return `node_${index}`;
+}
+
+// src/plugins/index.ts
+function applyPlugins(node, plugins) {
+  const cleanups = [];
+  for (const plugin of plugins) {
+    const cleanup = plugin(node);
+    if (cleanup) {
+      cleanups.push(cleanup);
+    }
+  }
+  return cleanups;
+}
+function createDebugPlugin(prefix = "[FormFoundry]") {
+  return (node) => {
+    const unsubscribe = node.hooks.commit.use((value, next) => {
+      console.log(`${prefix} ${node.name} committed:`, value);
+      return next(value);
+    });
+    return unsubscribe;
+  };
+}
+function createAutoTrimPlugin() {
+  return (node) => {
+    const unsubscribe = node.hooks.commit.use((value, next) => {
+      if (typeof value === "string") {
+        return next(value.trim());
+      }
+      return next(value);
+    });
+    return unsubscribe;
+  };
+}
+
+// src/resolvers/zodResolver.ts
+function zodResolver(schema) {
+  return async (values) => {
+    const result = schema.safeParse(values);
+    if (result.success) {
+      return { errors: {} };
+    }
+    const errors = {};
+    for (const issue of result.error.issues) {
+      const fieldName = issue.path[0];
+      if (typeof fieldName === "string") {
+        if (!errors[fieldName]) {
+          errors[fieldName] = [];
+        }
+        errors[fieldName].push(issue.message);
+      }
+    }
+    return { errors };
+  };
+}
+
+// src/i18n/en.ts
+var en = {
+  code: "en",
+  name: "English",
+  messages: {
+    // ─── Core rules ────────────────────────────────────────────────────
+    required: "{label} is required.",
+    email: "{label} must be a valid email address.",
+    url: "{label} must be a valid URL.",
+    min: "{label} must be at least {0}.",
+    max: "{label} must be at most {0}.",
+    minLength: "{label} must be at least {0} characters.",
+    maxLength: "{label} must be at most {0} characters.",
+    matches: "{label} does not match the required pattern.",
+    confirm: "{label} does not match.",
+    alpha: "{label} must contain only alphabetical characters.",
+    alphanumeric: "{label} must contain only alphanumeric characters.",
+    date: "{label} must be a valid date.",
+    between: "{label} must be between {0} and {1}.",
+    number: "{label} must be a number.",
+    // ─── Extended rules ────────────────────────────────────────────────
+    accepted: "{label} must be accepted.",
+    alpha_spaces: "{label} must contain only letters and spaces.",
+    contains_alpha: "{label} must contain at least one letter.",
+    contains_alphanumeric: "{label} must contain at least one letter or number.",
+    contains_alpha_spaces: "{label} must contain at least one letter or space.",
+    contains_lowercase: "{label} must contain at least one lowercase letter.",
+    contains_uppercase: "{label} must contain at least one uppercase letter.",
+    contains_numeric: "{label} must contain at least one number.",
+    contains_symbol: "{label} must contain at least one symbol.",
+    date_after: "{label} must be after {0}.",
+    date_before: "{label} must be before {0}.",
+    date_between: "{label} must be between {0} and {1}.",
+    date_format: "{label} must match the format {0}.",
+    ends_with: ({ label, args }) => `${label} must end with ${args.join(", ") || "?"}.`,
+    is: ({ label, args }) => `${label} must be one of: ${args.join(", ") || "?"}.`,
+    length: ({ label, args }) => args[1] ? `${label} must be between ${args[0]} and ${args[1]} characters.` : `${label} must be exactly ${args[0] ?? "?"} characters.`,
+    lowercase: "{label} must be all lowercase.",
+    not: ({ label, args }) => `${label} must not be: ${args.join(", ") || "?"}.`,
+    require_one: "At least one of these fields is required.",
+    starts_with: ({ label, args }) => `${label} must start with ${args.join(", ") || "?"}.`,
+    symbol: "{label} must contain only symbols.",
+    uppercase: "{label} must be all uppercase."
+  }
+};
+function FormPrintButton({
+  options,
+  children = "Print",
+  className,
+  disabled
+}) {
+  const { printForm } = useFormPrint(options);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      onClick: () => printForm(),
+      className,
+      disabled,
+      "data-formfoundry": "print-button",
+      children
+    }
+  );
+}
+function FormPrintView({
+  fields,
+  mode,
+  title,
+  subtitle,
+  footer,
+  className,
+  preview = false
+}) {
+  const resolvedMode = mode === "current" ? "filled" : mode;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `ff-print${preview ? " ff-print--preview" : ""}${className ? ` ${className}` : ""}`, children: [
+    (title || subtitle) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-print__header", children: [
+      title && /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "ff-print__title", children: title }),
+      subtitle && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-print__subtitle", children: subtitle })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "ff-print__fields", children: fields.map((field) => /* @__PURE__ */ jsxRuntime.jsx(
+      PrintField,
+      {
+        field,
+        mode: resolvedMode
+      },
+      field.name
+    )) }),
+    footer && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-print__footer", children: footer })
+  ] });
+}
+function PrintField({ field, mode }) {
+  const isTextarea = field.type === "textarea";
+  const label = field.label || field.name;
+  return /* @__PURE__ */ jsxRuntime.jsxs("li", { className: `ff-print__field${isTextarea ? " ff-print__field--textarea" : ""}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ff-print__label", children: [
+      label,
+      ":"
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__value", children: mode === "blank" ? renderBlank(field) : renderFilled(field) })
+  ] });
+}
+function renderBlank(field) {
+  switch (field.type) {
+    case "checkbox":
+    case "switch":
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-box" });
+    case "radio":
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-options", children: (field.options ?? []).map((opt) => /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ff-print__blank-option", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-radio" }),
+        opt.label
+      ] }, opt.value)) });
+    case "select":
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-options", children: (field.options ?? []).map((opt) => /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ff-print__blank-option", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-box" }),
+        opt.label
+      ] }, opt.value)) });
+    case "textarea":
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-print__blank-textarea" });
+    case "checkboxgroup":
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-options", children: (field.options ?? []).map((opt) => /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ff-print__blank-option", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-box" }),
+        opt.label
+      ] }, opt.value)) });
+    // text, email, password, url, tel, number, date, color, slider, file, hidden
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__blank-line" });
+  }
+}
+function renderFilled(field) {
+  const { value, type } = field;
+  switch (type) {
+    case "checkbox":
+    case "switch":
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__filled-check", children: value ? "\u2611" : "\u2610" });
+    case "radio":
+    case "select": {
+      const selected = field.options?.find(
+        (opt) => String(opt.value) === String(value)
+      );
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__filled-value", children: selected?.label ?? String(value ?? "\u2014") });
+    }
+    case "checkboxgroup": {
+      const selectedValues = Array.isArray(value) ? value : [];
+      const selectedLabels = (field.options ?? []).filter((opt) => selectedValues.includes(opt.value)).map((opt) => opt.label);
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__filled-value", children: selectedLabels.length > 0 ? selectedLabels.join(", ") : "\u2014" });
+    }
+    case "textarea":
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-print__filled-textarea", children: String(value ?? "") });
+    case "file":
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__filled-value", children: value ? String(value) : "No file selected" });
+    case "color":
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__filled-value", children: value ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            style: {
+              display: "inline-block",
+              width: 14,
+              height: 14,
+              backgroundColor: String(value),
+              border: "1px solid #999",
+              verticalAlign: "middle",
+              marginRight: 6,
+              borderRadius: 2
+            }
+          }
+        ),
+        String(value)
+      ] }) : "\u2014" });
+    case "hidden":
+      return null;
+    // text, email, password, url, tel, number, date, slider
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-print__filled-value", children: value != null && value !== "" ? String(value) : "\u2014" });
+  }
+}
+function PrintOverlay({
+  fields,
+  mode,
+  title,
+  subtitle,
+  footer,
+  className,
+  open = true
+}) {
+  if (!open || fields.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-formfoundry-print-root": "",
+      style: { display: "none" },
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        FormPrintView,
+        {
+          fields,
+          mode,
+          title,
+          subtitle,
+          footer,
+          className
+        }
+      )
+    }
+  );
+}
+
+exports.EXPRESSION_PREFIX = EXPRESSION_PREFIX;
+exports.Form = Form;
+exports.FormFoundryProvider = FormFoundryProvider;
+exports.FormMetaContext = FormMetaContext;
+exports.FormPrintButton = FormPrintButton;
+exports.FormPrintView = FormPrintView;
+exports.FormValuesContext = FormValuesContext;
+exports.InputRegistryContext = InputRegistryContext;
+exports.PrintOverlay = PrintOverlay;
+exports.SchemaRenderer = SchemaRenderer;
+exports.applyPlugins = applyPlugins;
+exports.builtInRules = builtInRules;
+exports.clearGlobalRegistry = clearGlobalRegistry;
+exports.clearRegistryListeners = clearRegistryListeners;
+exports.createAutoTrimPlugin = createAutoTrimPlugin;
+exports.createDebugPlugin = createDebugPlugin;
+exports.createDefaultRegistry = createDefaultRegistry;
+exports.createEventEmitter = createEventEmitter;
+exports.createHooks = createHooks;
+exports.createLedger = createLedger;
+exports.createMessage = createMessage;
+exports.createMessageStore = createMessageStore;
+exports.createNode = createNode;
+exports.createRegistry = createRegistry;
+exports.defaultMessages = defaultMessages;
+exports.enLocale = en;
+exports.evaluateExpression = evaluateExpression;
+exports.getActiveLocale = getActiveLocale;
+exports.getLocale = getLocale;
+exports.getNode = getNode;
+exports.getRegisteredLocales = getRegisteredLocales;
+exports.getRegisteredNodeIds = getRegisteredNodeIds;
+exports.getRule = getRule;
+exports.hasRule = hasRule;
+exports.interpolate = interpolate;
+exports.isExpression = isExpression;
+exports.isVariableRef = isVariableRef;
+exports.parseRules = parseRules;
+exports.registerLocale = registerLocale;
+exports.registerNode = registerNode;
+exports.registerRule = registerRule;
+exports.resolveConfig = resolveConfig;
+exports.resolveLocaleMessage = resolveLocaleMessage;
+exports.resolveMessage = resolveMessage;
+exports.resolveSchemaValue = resolveSchemaValue;
+exports.resolveVariableRef = resolveVariableRef;
+exports.runValidation = runValidation;
+exports.setActiveLocale = setActiveLocale;
+exports.subscribeToRegistry = subscribeToRegistry;
+exports.unregisterNode = unregisterNode;
+exports.unregisterRule = unregisterRule;
+exports.useFormContext = useFormContext;
+exports.useFormFoundryField = useFormFoundryField;
+exports.useFormMeta = useFormMeta;
+exports.useFormNode = useFormNode;
+exports.useFormNodes = useFormNodes;
+exports.useFormPrint = useFormPrint;
+exports.useFormValues = useFormValues;
+exports.useInputRegistry = useInputRegistry;
+exports.validateFormWithZod = validateFormWithZod;
+exports.validateWithZod = validateWithZod;
+exports.zodResolver = zodResolver;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map