@form-eng/core 1.0.0

package/dist/index.js

@@ -0,0 +1,4361 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CheckAsyncFieldValidationRules: () => CheckAsyncFieldValidationRules,
+  CheckDefaultValues: () => CheckDefaultValues,
+  CheckFieldValidationRules: () => CheckFieldValidationRules,
+  CheckValidDropdownOptions: () => CheckValidDropdownOptions,
+  ComponentTypes: () => ComponentTypes,
+  ConfirmInputsModal: () => ConfirmInputsModal_default,
+  ExecuteComputedValue: () => ExecuteComputedValue,
+  FIELD_PARENT_PREFIX: () => FIELD_PARENT_PREFIX,
+  FieldArray: () => FieldArray,
+  FieldWrapper: () => FieldWrapper,
+  FormConstants: () => FormConstants,
+  FormDevTools: () => FormDevTools,
+  FormEngine: () => FormEngine,
+  FormErrorBoundary: () => FormErrorBoundary,
+  FormFields: () => FormFields,
+  FormStrings: () => FormStrings,
+  GetChildEntity: () => GetChildEntity,
+  GetComputedValuesOnCreate: () => GetComputedValuesOnCreate,
+  GetComputedValuesOnDirtyFields: () => GetComputedValuesOnDirtyFields,
+  GetConfirmInputModalProps: () => GetConfirmInputModalProps,
+  GetFieldsToRender: () => GetFieldsToRender,
+  InitOnCreateFormState: () => InitOnCreateFormState,
+  InitOnEditFormState: () => InitOnEditFormState,
+  InjectedFieldProvider: () => InjectedFieldProvider,
+  IsExpandVisible: () => IsExpandVisible,
+  RenderField: () => RenderField_default,
+  RulesEngineActionType: () => RulesEngineActionType,
+  RulesEngineProvider: () => RulesEngineProvider,
+  ShowField: () => ShowField,
+  SortDropdownOptions: () => SortOptions2,
+  SortOptions: () => SortOptions,
+  UseInjectedFieldContext: () => UseInjectedFieldContext,
+  UseRulesEngineContext: () => UseRulesEngineContext,
+  WizardForm: () => WizardForm,
+  buildDefaultFieldStates: () => buildDefaultFieldStates,
+  buildDependencyGraph: () => buildDependencyGraph,
+  clearRuleTraceLog: () => clearRuleTraceLog,
+  clearTimeline: () => clearTimeline,
+  convertBooleanToYesOrNoText: () => convertBooleanToYesOrNoText,
+  createLazyFieldRegistry: () => createLazyFieldRegistry,
+  createMaxLengthRule: () => createMaxLengthRule,
+  createMinLengthRule: () => createMinLengthRule,
+  createNumericRangeRule: () => createNumericRangeRule,
+  createOption: () => createOption,
+  createPatternRule: () => createPatternRule,
+  createRequiredIfRule: () => createRequiredIfRule,
+  deepCopy: () => deepCopy,
+  defineFormConfig: () => defineFormConfig,
+  deserializeFormState: () => deserializeFormState,
+  detectDependencyCycles: () => detectDependencyCycles,
+  detectSelfDependencies: () => detectSelfDependencies,
+  disableRuleTracing: () => disableRuleTracing,
+  enableRuleTracing: () => enableRuleTracing,
+  evaluateAffectedFields: () => evaluateAffectedFields,
+  evaluateAllRules: () => evaluateAllRules,
+  evaluateCondition: () => evaluateCondition,
+  evaluateExpression: () => evaluateExpression,
+  executeValueFunction: () => executeValueFunction,
+  extractConditionDependencies: () => extractConditionDependencies,
+  extractExpressionDependencies: () => extractExpressionDependencies,
+  extractFunctionDependencies: () => extractFunctionDependencies,
+  flushRenderCycle: () => flushRenderCycle,
+  fromRjsfSchema: () => fromRjsfSchema,
+  getCurrentLocale: () => getCurrentLocale,
+  getLastRenderedFields: () => getLastRenderedFields,
+  getLocaleString: () => getLocaleString,
+  getRenderCounts: () => getRenderCounts,
+  getRuleTraceLog: () => getRuleTraceLog,
+  getStepFieldOrder: () => getStepFieldOrder,
+  getStepFields: () => getStepFields,
+  getStepIndex: () => getStepIndex,
+  getTimeline: () => getTimeline,
+  getTotalFormRenders: () => getTotalFormRenders,
+  getValidator: () => getValidator,
+  getValidatorRegistry: () => getValidatorRegistry,
+  getValueFunction: () => getValueFunction,
+  getVisibleSteps: () => getVisibleSteps,
+  isEmpty: () => isEmpty,
+  isFieldCondition: () => isFieldCondition,
+  isLogicalCondition: () => isLogicalCondition,
+  isNull: () => isNull,
+  isRuleTracingEnabled: () => isRuleTracingEnabled,
+  isStepValid: () => isStepValid,
+  isStringEmpty: () => isStringEmpty,
+  logEvent: () => logEvent,
+  registerLocale: () => registerLocale,
+  registerValidators: () => registerValidators,
+  registerValueFunctions: () => registerValueFunctions,
+  resetLocale: () => resetLocale,
+  resetRenderTracker: () => resetRenderTracker,
+  resetValidatorRegistry: () => resetValidatorRegistry,
+  resetValueFunctionRegistry: () => resetValueFunctionRegistry,
+  runSyncValidations: () => runSyncValidations,
+  runValidations: () => runValidations,
+  serializeFormState: () => serializeFormState,
+  sortDropdownOptions: () => sortDropdownOptions,
+  toRjsfSchema: () => toRjsfSchema,
+  topologicalSort: () => topologicalSort,
+  traceRuleEvent: () => traceRuleEvent,
+  trackRender: () => trackRender,
+  useBeforeUnload: () => useBeforeUnload,
+  useDraftPersistence: () => useDraftPersistence,
+  useFormAnalytics: () => useFormAnalytics,
+  validateDependencyGraph: () => validateDependencyGraph,
+  validateFieldConfigs: () => validateFieldConfigs,
+  validateStepFields: () => validateStepFields,
+  zodSchemaToFieldConfig: () => zodSchemaToFieldConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/ICondition.ts
+function isLogicalCondition(condition) {
+  const op = condition.operator;
+  return op === "and" || op === "or" || op === "not";
+}
+function isFieldCondition(condition) {
+  return "field" in condition;
+}
+
+// src/types/IRulesEngineAction.ts
+var RulesEngineActionType = /* @__PURE__ */ ((RulesEngineActionType2) => {
+  RulesEngineActionType2["SET"] = "RULES_ENGINE_SET";
+  RulesEngineActionType2["UPDATE"] = "RULES_ENGINE_UPDATE";
+  RulesEngineActionType2["CLEAR"] = "RULES_ENGINE_CLEAR";
+  return RulesEngineActionType2;
+})(RulesEngineActionType || {});
+
+// src/types/TypedFieldConfig.ts
+function defineFormConfig(fields) {
+  return fields;
+}
+
+// src/utils/index.ts
+function isEmpty(value) {
+  if (value == null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function isNull(value) {
+  return value == null;
+}
+function isStringEmpty(value) {
+  return value == null || value.trim() === "";
+}
+function deepCopy(obj) {
+  return structuredClone(obj);
+}
+function convertBooleanToYesOrNoText(value) {
+  if (value === true) return "Yes";
+  if (value === false) return "No";
+  return "";
+}
+function sortDropdownOptions(a, b) {
+  const aText = a.label ? a.label.toLowerCase() : "";
+  const bText = b.label ? b.label.toLowerCase() : "";
+  return aText < bText ? -1 : aText > bText ? 1 : 0;
+}
+function createOption(value) {
+  return { value, label: value };
+}
+
+// src/constants.ts
+var FIELD_PARENT_PREFIX = "Parent.";
+var ComponentTypes = {
+  Textbox: "Textbox",
+  Dropdown: "Dropdown",
+  Toggle: "Toggle",
+  Number: "Number",
+  MultiSelect: "Multiselect",
+  DateControl: "DateControl",
+  Slider: "Slider",
+  Fragment: "DynamicFragment",
+  SimpleDropdown: "SimpleDropdown",
+  MultiSelectSearch: "MultiSelectSearch",
+  PopOutEditor: "PopOutEditor",
+  RichText: "RichText",
+  Textarea: "Textarea",
+  DocumentLinks: "DocumentLinks",
+  StatusDropdown: "StatusDropdown",
+  ReadOnly: "ReadOnly",
+  ReadOnlyArray: "ReadOnlyArray",
+  ReadOnlyDateTime: "ReadOnlyDateTime",
+  ReadOnlyCumulativeNumber: "ReadOnlyCumulativeNumber",
+  ReadOnlyRichText: "ReadOnlyRichText",
+  ReadOnlyWithButton: "ReadOnlyWithButton",
+  ChoiceSet: "ChoiceSet",
+  FieldArray: "FieldArray"
+};
+var FormConstants = {
+  defaultExpandCutoffCount: 12,
+  loadingShimmerCount: 12,
+  loadingFieldShimmerHeight: 32,
+  na: "n/a",
+  panelActionKeys: {
+    cancel: "Cancel",
+    close: "Close",
+    create: "Create",
+    update: "Update"
+  },
+  urlRegex: /(http(s?)):\/\//i,
+  errorColor: "#a4262c"
+};
+
+// src/helpers/LocaleRegistry.ts
+var defaultStrings = {
+  // Form status
+  autoSavePending: "AutoSave Pending, please check for errors...",
+  savePending: "Save Pending, please check for errors...",
+  saving: "Saving...",
+  saveError: "Error saving form",
+  // Actions
+  save: "Save",
+  cancel: "Cancel",
+  create: "Create",
+  update: "Update",
+  confirm: "Confirm",
+  add: "Add",
+  edit: "Edit",
+  deleteLabel: "Delete",
+  remove: "Remove",
+  close: "Close",
+  clear: "Clear",
+  // Field labels
+  required: "Required",
+  remaining: "remaining",
+  na: "N/A",
+  unknown: "Unknown",
+  loading: "Loading",
+  noResultsFound: "No results found",
+  clickToClear: "Click here to Clear",
+  // Document links
+  linkTitleLabel: "Link Title",
+  linkUrlLabel: "Link URL",
+  urlRequired: "Invalid Url (http/https required)",
+  // Expand/collapse
+  seeLess: "See less",
+  expand: "Expand",
+  // Rich text editor
+  openExpandedTextEditor: "Open Expanded Editor",
+  closeExpandedTextEditor: "Close Expanded Editor",
+  // Unsaved changes
+  unsavedChanges: "Unsaved Changes",
+  returnToEditing: "Return to Editing",
+  dontSave: "Don't save",
+  overview: "Overview",
+  by: "by",
+  // Accessibility
+  filterFields: "Filter form fields",
+  saved: "Saved successfully",
+  saveFailed: "Save failed",
+  validating: "Validating...",
+  stepOf: (current, total) => `Step ${current} of ${total}`,
+  formWizard: "Form wizard",
+  itemOfTotal: (index, total, label) => `${label} item ${index} of ${total}`,
+  // Dynamic functions
+  saveChangesTo: (title) => `Do you want to save your changes to ${title}?`,
+  // Validation error messages
+  invalidUrl: "Invalid URL",
+  invalidEmail: "Invalid email address",
+  invalidPhoneNumber: "Invalid phone number",
+  invalidYear: "Invalid year",
+  contentExceedsMaxSize: (maxKb2) => `Content exceeds maximum size of ${maxKb2}KB`,
+  noSpecialCharacters: "Special characters are not allowed",
+  invalidCurrencyFormat: "Invalid currency format",
+  duplicateValue: (value) => `Duplicate value: ${value}`,
+  mustBeAtLeastChars: (min) => `Must be at least ${min} characters`,
+  mustBeAtMostChars: (max) => `Must be at most ${max} characters`,
+  mustBeANumber: "Must be a number",
+  mustBeBetween: (min, max) => `Must be between ${min} and ${max}`,
+  thisFieldIsRequired: "This field is required",
+  // Reliability / save status
+  saveRetrying: "Retrying save...",
+  saveTimeout: "Save timed out",
+  // Draft persistence
+  draftRecovered: "Draft recovered",
+  discardDraft: "Discard draft",
+  unsavedChangesWarning: "You have unsaved changes. Are you sure you want to leave?"
+};
+var currentLocale = { ...defaultStrings };
+function registerLocale(partial) {
+  currentLocale = { ...currentLocale, ...partial };
+}
+function getLocaleString(key) {
+  return currentLocale[key];
+}
+function resetLocale() {
+  currentLocale = { ...defaultStrings };
+}
+function getCurrentLocale() {
+  return { ...currentLocale };
+}
+
+// src/strings.ts
+var FormStrings = {
+  get autoSavePending() {
+    return getLocaleString("autoSavePending");
+  },
+  get savePending() {
+    return getLocaleString("savePending");
+  },
+  get remaining() {
+    return getLocaleString("remaining");
+  },
+  get saving() {
+    return getLocaleString("saving");
+  },
+  get seeLess() {
+    return getLocaleString("seeLess");
+  },
+  get expand() {
+    return getLocaleString("expand");
+  },
+  get required() {
+    return getLocaleString("required");
+  },
+  get save() {
+    return getLocaleString("save");
+  },
+  get cancel() {
+    return getLocaleString("cancel");
+  },
+  get create() {
+    return getLocaleString("create");
+  },
+  get update() {
+    return getLocaleString("update");
+  },
+  get na() {
+    return getLocaleString("na");
+  },
+  get saveError() {
+    return getLocaleString("saveError");
+  },
+  get confirm() {
+    return getLocaleString("confirm");
+  },
+  get linkTitleLabel() {
+    return getLocaleString("linkTitleLabel");
+  },
+  get linkUrlLabel() {
+    return getLocaleString("linkUrlLabel");
+  },
+  get add() {
+    return getLocaleString("add");
+  },
+  get edit() {
+    return getLocaleString("edit");
+  },
+  get deleteLabel() {
+    return getLocaleString("deleteLabel");
+  },
+  get remove() {
+    return getLocaleString("remove");
+  },
+  get unknown() {
+    return getLocaleString("unknown");
+  },
+  get close() {
+    return getLocaleString("close");
+  },
+  get loading() {
+    return getLocaleString("loading");
+  },
+  get noResultsFound() {
+    return getLocaleString("noResultsFound");
+  },
+  get clickToClear() {
+    return getLocaleString("clickToClear");
+  },
+  get clear() {
+    return getLocaleString("clear");
+  },
+  get urlRequired() {
+    return getLocaleString("urlRequired");
+  },
+  get openExpandedTextEditor() {
+    return getLocaleString("openExpandedTextEditor");
+  },
+  get closeExpandedTextEditor() {
+    return getLocaleString("closeExpandedTextEditor");
+  },
+  get unsavedChanges() {
+    return getLocaleString("unsavedChanges");
+  },
+  get returnToEditing() {
+    return getLocaleString("returnToEditing");
+  },
+  get dontSave() {
+    return getLocaleString("dontSave");
+  },
+  get overview() {
+    return getLocaleString("overview");
+  },
+  get by() {
+    return getLocaleString("by");
+  },
+  get filterFields() {
+    return getLocaleString("filterFields");
+  },
+  get saved() {
+    return getLocaleString("saved");
+  },
+  get saveFailed() {
+    return getLocaleString("saveFailed");
+  },
+  get validating() {
+    return getLocaleString("validating");
+  },
+  get stepOf() {
+    return getLocaleString("stepOf");
+  },
+  get formWizard() {
+    return getLocaleString("formWizard");
+  },
+  get itemOfTotal() {
+    return getLocaleString("itemOfTotal");
+  },
+  get saveChangesTo() {
+    return getLocaleString("saveChangesTo");
+  },
+  get draftRecovered() {
+    return getLocaleString("draftRecovered");
+  },
+  get discardDraft() {
+    return getLocaleString("discardDraft");
+  },
+  get unsavedChangesWarning() {
+    return getLocaleString("unsavedChangesWarning");
+  },
+  get saveRetrying() {
+    return getLocaleString("saveRetrying");
+  },
+  get saveTimeout() {
+    return getLocaleString("saveTimeout");
+  }
+};
+
+// src/providers/BusinessRulesProvider.tsx
+var import_react = __toESM(require("react"));
+
+// src/helpers/ConditionEvaluator.ts
+function evaluateCondition(condition, values) {
+  if (isLogicalCondition(condition)) {
+    return evaluateLogicalCondition(condition, values);
+  }
+  return evaluateFieldCondition(condition, values);
+}
+function evaluateLogicalCondition(condition, values) {
+  switch (condition.operator) {
+    case "and":
+      return condition.conditions.every((c) => evaluateCondition(c, values));
+    case "or":
+      return condition.conditions.some((c) => evaluateCondition(c, values));
+    case "not":
+      return condition.conditions.length > 0 ? !evaluateCondition(condition.conditions[0], values) : false;
+    default:
+      return false;
+  }
+}
+function evaluateFieldCondition(condition, values) {
+  const fieldValue = getNestedValue(values, condition.field);
+  switch (condition.operator) {
+    case "equals":
+      return looseEquals(fieldValue, condition.value);
+    case "notEquals":
+      return !looseEquals(fieldValue, condition.value);
+    case "greaterThan":
+      return toNumber(fieldValue) > toNumber(condition.value);
+    case "lessThan":
+      return toNumber(fieldValue) < toNumber(condition.value);
+    case "greaterThanOrEqual":
+      return toNumber(fieldValue) >= toNumber(condition.value);
+    case "lessThanOrEqual":
+      return toNumber(fieldValue) <= toNumber(condition.value);
+    case "contains":
+      return toString(fieldValue).includes(toString(condition.value));
+    case "notContains":
+      return !toString(fieldValue).includes(toString(condition.value));
+    case "startsWith":
+      return toString(fieldValue).startsWith(toString(condition.value));
+    case "endsWith":
+      return toString(fieldValue).endsWith(toString(condition.value));
+    case "in":
+      return Array.isArray(condition.value) ? condition.value.some((v) => looseEquals(fieldValue, v)) : false;
+    case "notIn":
+      return Array.isArray(condition.value) ? !condition.value.some((v) => looseEquals(fieldValue, v)) : false;
+    case "isEmpty":
+      return isValueEmpty(fieldValue);
+    case "isNotEmpty":
+      return !isValueEmpty(fieldValue);
+    case "matches":
+      try {
+        return new RegExp(toString(condition.value)).test(toString(fieldValue));
+      } catch {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+function extractConditionDependencies(condition) {
+  const deps = /* @__PURE__ */ new Set();
+  collectDependencies(condition, deps);
+  return [...deps];
+}
+function collectDependencies(condition, deps) {
+  if (isLogicalCondition(condition)) {
+    condition.conditions.forEach((c) => collectDependencies(c, deps));
+  } else {
+    const fieldRef = condition.field;
+    deps.add(fieldRef.includes(".") ? fieldRef.split(".")[0] : fieldRef);
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function looseEquals(a, b) {
+  if (a === b) return true;
+  if (a == null && b == null) return true;
+  if (a == null || b == null) return false;
+  return String(a) === String(b);
+}
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const n = Number(value);
+    return isNaN(n) ? 0 : n;
+  }
+  if (value instanceof Date) return value.getTime();
+  return 0;
+}
+function toString(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  return String(value);
+}
+function isValueEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+
+// src/helpers/ValueFunctionRegistry.ts
+var defaultValueFunctions = {
+  setDate: () => /* @__PURE__ */ new Date(),
+  setDateIfNull: ({ fieldValue }) => fieldValue ? fieldValue : /* @__PURE__ */ new Date(),
+  setLoggedInUser: ({ currentUserId }) => currentUserId ? { id: currentUserId } : void 0,
+  inheritFromParent: ({ fieldName, values }) => {
+    const parent = values?.Parent;
+    return parent ? parent[fieldName] : void 0;
+  }
+};
+var valueFunctionRegistry = { ...defaultValueFunctions };
+function registerValueFunctions(custom) {
+  valueFunctionRegistry = { ...valueFunctionRegistry, ...custom };
+}
+function getValueFunction(name) {
+  return valueFunctionRegistry[name];
+}
+function executeValueFunction(fieldName, functionName, values, fieldValue, parentEntity, currentUserId) {
+  const fn = valueFunctionRegistry[functionName];
+  if (fn) {
+    return fn({ fieldName, fieldValue, values, parentEntity, currentUserId });
+  }
+  return void 0;
+}
+function resetValueFunctionRegistry() {
+  valueFunctionRegistry = { ...defaultValueFunctions };
+}
+
+// src/helpers/ExpressionEngine.ts
+function evaluateExpression(expression, values, fieldName, parentEntity, currentUserId) {
+  let resolved = expression.replace(
+    /\$fn\.([a-zA-Z_][a-zA-Z0-9_]*)\(\)/g,
+    (_, fnName) => {
+      const fn = getValueFunction(fnName);
+      if (fn) {
+        const result = fn({
+          fieldName: fieldName ?? "",
+          fieldValue: fieldName ? values[fieldName] : void 0,
+          values,
+          parentEntity,
+          currentUserId
+        });
+        if (result === null || result === void 0) return "undefined";
+        if (typeof result === "string") return JSON.stringify(result);
+        if (result instanceof Date) return `new Date(${result.getTime()})`;
+        return String(result);
+      }
+      return "undefined";
+    }
+  );
+  resolved = resolved.replace(
+    /\$parent\.([a-zA-Z_][a-zA-Z0-9_.]*)/g,
+    (_, fieldPath) => {
+      const value = getNestedValue2(parentEntity ?? {}, fieldPath);
+      if (value === null || value === void 0) return "undefined";
+      if (typeof value === "string") return JSON.stringify(value);
+      return String(value);
+    }
+  );
+  resolved = resolved.replace(
+    /\$root\.([a-zA-Z_][a-zA-Z0-9_.]*)/g,
+    (_, fieldPath) => {
+      const value = getNestedValue2(values, fieldPath);
+      if (value === null || value === void 0) return "undefined";
+      if (typeof value === "string") return JSON.stringify(value);
+      return String(value);
+    }
+  );
+  resolved = resolved.replace(
+    /\$values\.([a-zA-Z_][a-zA-Z0-9_.]*)/g,
+    (_, fieldPath) => {
+      const value = getNestedValue2(values, fieldPath);
+      if (value === null || value === void 0) return "undefined";
+      if (typeof value === "string") return JSON.stringify(value);
+      return String(value);
+    }
+  );
+  try {
+    const safeEval = new Function(
+      "Math",
+      "Date",
+      `"use strict"; return (${resolved});`
+    );
+    return safeEval(Math, Date);
+  } catch {
+    return void 0;
+  }
+}
+function getNestedValue2(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function extractExpressionDependencies(expression) {
+  const deps = /* @__PURE__ */ new Set();
+  const valuesRegex = /\$(?:values|root)\.([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let match;
+  while ((match = valuesRegex.exec(expression)) !== null) {
+    deps.add(match[1]);
+  }
+  return [...deps];
+}
+function extractFunctionDependencies(expression) {
+  const fns = /* @__PURE__ */ new Set();
+  const fnRegex = /\$fn\.([a-zA-Z_][a-zA-Z0-9_]*)\(\)/g;
+  let match;
+  while ((match = fnRegex.exec(expression)) !== null) {
+    fns.add(match[1]);
+  }
+  return [...fns];
+}
+
+// src/helpers/EventTimeline.ts
+var timeline = [];
+var MAX_EVENTS = 500;
+function logEvent(type, fieldName, details) {
+  timeline.push({ timestamp: Date.now(), type, fieldName, details });
+  if (timeline.length > MAX_EVENTS) {
+    timeline.splice(0, timeline.length - MAX_EVENTS);
+  }
+}
+function getTimeline() {
+  return [...timeline];
+}
+function clearTimeline() {
+  timeline.length = 0;
+}
+
+// src/helpers/RuleEngine.ts
+function buildDependencyGraph(fields) {
+  const graph = {};
+  const fieldNames = Object.keys(fields);
+  for (const name of fieldNames) {
+    graph[name] = /* @__PURE__ */ new Set();
+  }
+  for (const [fieldName, config] of Object.entries(fields)) {
+    if (config.rules) {
+      for (const rule of config.rules) {
+        const condDeps = extractConditionDependencies(rule.when);
+        for (const dep of condDeps) {
+          if (dep in graph) {
+            graph[dep].add(fieldName);
+          }
+        }
+        collectEffectTargets(rule.then, fieldName, graph);
+        if (rule.else) {
+          collectEffectTargets(rule.else, fieldName, graph);
+        }
+      }
+    }
+    if (config.computedValue) {
+      const exprDeps = extractExpressionDependencies(config.computedValue);
+      for (const dep of exprDeps) {
+        if (dep in graph) {
+          graph[dep].add(fieldName);
+        }
+      }
+    }
+  }
+  return graph;
+}
+function collectEffectTargets(effect, ownerField, graph) {
+  if (effect.fields) {
+    for (const targetField of Object.keys(effect.fields)) {
+      if (targetField in graph) {
+        graph[ownerField]?.add(targetField);
+      }
+    }
+  }
+}
+function topologicalSort(graph) {
+  const inDegree = {};
+  const adjacency = {};
+  const fields = Object.keys(graph);
+  for (const f of fields) {
+    inDegree[f] = 0;
+    adjacency[f] = [...graph[f]];
+  }
+  for (const f of fields) {
+    for (const dep of adjacency[f]) {
+      if (dep in inDegree) {
+        inDegree[dep]++;
+      }
+    }
+  }
+  const queue = [];
+  for (const f of fields) {
+    if (inDegree[f] === 0) queue.push(f);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const neighbor of adjacency[current]) {
+      if (neighbor in inDegree) {
+        inDegree[neighbor]--;
+        if (inDegree[neighbor] === 0) queue.push(neighbor);
+      }
+    }
+  }
+  const hasCycle = sorted.length < fields.length;
+  const cycleFields = hasCycle ? fields.filter((f) => !sorted.includes(f)) : [];
+  return { sorted, hasCycle, cycleFields };
+}
+function buildDefaultFieldStates(fields, areAllFieldsReadonly) {
+  const states = {};
+  const graph = buildDependencyGraph(fields);
+  for (const [fieldName, config] of Object.entries(fields)) {
+    states[fieldName] = {
+      type: config.type,
+      required: config.required,
+      hidden: config.hidden || config.type === "DynamicFragment",
+      readOnly: areAllFieldsReadonly ? true : config.readOnly,
+      validate: config.validate,
+      computedValue: config.computedValue,
+      confirmInput: config.confirmInput,
+      options: config.options,
+      label: config.label,
+      defaultValue: config.defaultValue,
+      computeOnCreateOnly: config.computeOnCreateOnly,
+      dependentFields: [...graph[fieldName] ?? []],
+      dependsOnFields: [],
+      activeRuleIds: []
+    };
+  }
+  for (const [fieldName, state] of Object.entries(states)) {
+    for (const dep of state.dependentFields ?? []) {
+      if (states[dep]) {
+        states[dep].dependsOnFields = states[dep].dependsOnFields ?? [];
+        states[dep].dependsOnFields.push(fieldName);
+      }
+    }
+  }
+  return states;
+}
+function evaluateAllRules(fields, values, areAllFieldsReadonly) {
+  const fieldStates = buildDefaultFieldStates(fields, areAllFieldsReadonly);
+  const fieldOrder = Object.keys(fields);
+  const graph = buildDependencyGraph(fields);
+  const { sorted } = topologicalSort(graph);
+  const evalOrder = sorted.length > 0 ? sorted : fieldOrder;
+  let currentOrder = [...fieldOrder];
+  for (const fieldName of evalOrder) {
+    const config = fields[fieldName];
+    if (!config?.rules) continue;
+    const ruleResults = evaluateFieldRules(config.rules, values);
+    if (fieldStates[fieldName]) {
+      fieldStates[fieldName].activeRuleIds = ruleResults.activeRuleIds;
+    }
+    logEvent("rule_evaluated", fieldName, `${config.rules.length} rule(s) evaluated`);
+    applyEffectToState(fieldStates, fieldName, ruleResults.selfEffect);
+    for (const [targetField, effect] of Object.entries(ruleResults.crossEffects)) {
+      if (fieldStates[targetField]) {
+        applyEffectToState(fieldStates, targetField, effect);
+      }
+    }
+    if (ruleResults.fieldOrder) {
+      currentOrder = ruleResults.fieldOrder;
+    }
+  }
+  return { fieldStates, fieldOrder: currentOrder };
+}
+function evaluateAffectedFields(changedField, fields, values, currentState) {
+  const affected = getTransitivelyAffectedFields(changedField, currentState.fieldStates);
+  logEvent("field_change", changedField, `${affected.size} affected field(s)`);
+  if (affected.size === 0) {
+    return currentState;
+  }
+  const updatedStates = { ...currentState.fieldStates };
+  let updatedOrder = [...currentState.fieldOrder];
+  for (const fieldName of affected) {
+    const config = fields[fieldName];
+    if (!config) continue;
+    updatedStates[fieldName] = {
+      ...updatedStates[fieldName],
+      type: config.type,
+      required: config.required,
+      hidden: config.hidden || config.type === "DynamicFragment",
+      readOnly: config.readOnly,
+      validate: config.validate,
+      computedValue: config.computedValue,
+      confirmInput: config.confirmInput,
+      options: config.options,
+      label: config.label,
+      defaultValue: config.defaultValue,
+      computeOnCreateOnly: config.computeOnCreateOnly,
+      activeRuleIds: []
+    };
+  }
+  for (const [ownerField, config] of Object.entries(fields)) {
+    if (!config.rules) continue;
+    const ruleResults = evaluateFieldRules(config.rules, values);
+    if (affected.has(ownerField) || ownerField === changedField) {
+      applyEffectToState(updatedStates, ownerField, ruleResults.selfEffect);
+    }
+    for (const [targetField, effect] of Object.entries(ruleResults.crossEffects)) {
+      if (affected.has(targetField) && updatedStates[targetField]) {
+        applyEffectToState(updatedStates, targetField, effect);
+      }
+    }
+    if (ruleResults.fieldOrder) {
+      updatedOrder = ruleResults.fieldOrder;
+    }
+  }
+  return { fieldStates: updatedStates, fieldOrder: updatedOrder };
+}
+function getTransitivelyAffectedFields(changedField, fieldStates) {
+  const affected = /* @__PURE__ */ new Set();
+  const queue = [changedField];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const deps = fieldStates[current]?.dependentFields ?? [];
+    for (const dep of deps) {
+      if (!affected.has(dep)) {
+        affected.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return affected;
+}
+function evaluateFieldRules(rules, values) {
+  const sorted = [...rules].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  const selfEffect = {};
+  const crossEffects = {};
+  let fieldOrder;
+  const activeRuleIds = [];
+  for (let i = 0; i < sorted.length; i++) {
+    const rule = sorted[i];
+    const conditionMet = evaluateCondition(rule.when, values);
+    if (conditionMet) {
+      activeRuleIds.push(rule.id ?? `rule_${i}`);
+    }
+    const effect = conditionMet ? rule.then : rule.else;
+    if (!effect) continue;
+    mergeEffect(selfEffect, effect);
+    if (effect.fields) {
+      for (const [targetField, targetEffect] of Object.entries(effect.fields)) {
+        if (!crossEffects[targetField]) {
+          crossEffects[targetField] = {};
+        }
+        mergeEffect(crossEffects[targetField], targetEffect);
+      }
+    }
+    if (effect.fieldOrder && !fieldOrder) {
+      fieldOrder = effect.fieldOrder;
+    }
+  }
+  return { selfEffect, crossEffects, fieldOrder, activeRuleIds };
+}
+function mergeEffect(target, source) {
+  if (source.required !== void 0 && target.required === void 0) {
+    target.required = source.required;
+  }
+  if (source.hidden !== void 0 && target.hidden === void 0) {
+    target.hidden = source.hidden;
+  }
+  if (source.readOnly !== void 0 && target.readOnly === void 0) {
+    target.readOnly = source.readOnly;
+  }
+  if (source.label !== void 0 && target.label === void 0) {
+    target.label = source.label;
+  }
+  const sourceType = source.type ?? source.component;
+  const targetType = target.type ?? target.component;
+  if (sourceType !== void 0 && targetType === void 0) {
+    target.type = sourceType;
+  }
+  if (source.options !== void 0 && target.options === void 0) {
+    target.options = source.options;
+  }
+  if (source.validate !== void 0 && target.validate === void 0) {
+    target.validate = source.validate;
+  }
+  if (source.computedValue !== void 0 && target.computedValue === void 0) {
+    target.computedValue = source.computedValue;
+  }
+}
+function applyEffectToState(states, fieldName, effect) {
+  const state = states[fieldName];
+  if (!state) return;
+  if (effect.required !== void 0) state.required = effect.required;
+  if (effect.hidden !== void 0) state.hidden = effect.hidden;
+  if (effect.readOnly !== void 0) state.readOnly = effect.readOnly;
+  if (effect.label !== void 0) state.label = effect.label;
+  const effectType = effect.type ?? effect.component;
+  if (effectType !== void 0) state.type = effectType;
+  if (effect.options !== void 0) state.options = effect.options;
+  if (effect.validate !== void 0) state.validate = effect.validate;
+  if (effect.computedValue !== void 0) state.computedValue = effect.computedValue;
+}
+
+// src/reducers/BusinessRulesReducer.ts
+var defaultRulesEngineState = {
+  configs: {}
+};
+var rulesEngineReducer = (state = defaultRulesEngineState, action) => {
+  switch (action.type) {
+    case "RULES_ENGINE_SET" /* SET */: {
+      const configName = action.payload.configName;
+      return {
+        configs: {
+          ...state.configs,
+          [configName]: { ...action.payload.formState }
+        }
+      };
+    }
+    case "RULES_ENGINE_UPDATE" /* UPDATE */: {
+      const configName = action.payload.configName;
+      const existing = state.configs[configName];
+      if (!existing) return state;
+      const updatedFieldStates = { ...existing.fieldStates };
+      Object.keys(action.payload.formState.fieldStates).forEach((fieldName) => {
+        updatedFieldStates[fieldName] = {
+          ...updatedFieldStates[fieldName],
+          ...action.payload.formState.fieldStates[fieldName]
+        };
+      });
+      return {
+        configs: {
+          ...state.configs,
+          [configName]: {
+            fieldStates: updatedFieldStates,
+            fieldOrder: action.payload.formState.fieldOrder
+          }
+        }
+      };
+    }
+    case "RULES_ENGINE_CLEAR" /* CLEAR */: {
+      if (action.payload.configName) {
+        const { [action.payload.configName]: _, ...remaining } = state.configs;
+        return { configs: remaining };
+      }
+      return defaultRulesEngineState;
+    }
+    default:
+      return state;
+  }
+};
+var BusinessRulesReducer_default = rulesEngineReducer;
+
+// src/providers/BusinessRulesProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var RulesEngineContext = import_react.default.createContext(
+  void 0
+);
+function UseRulesEngineContext() {
+  const context = import_react.default.useContext(RulesEngineContext);
+  if (context === void 0) {
+    throw new Error(
+      "UseRulesEngineContext() was called outside of <RulesEngineProvider>. Required hierarchy: <RulesEngineProvider> > <InjectedFieldProvider> > <FormEngine>"
+    );
+  }
+  return context;
+}
+var RulesEngineProvider = (props) => {
+  const [rulesState, dispatch] = import_react.default.useReducer(BusinessRulesReducer_default, defaultRulesEngineState);
+  const rulesStateRef = import_react.default.useRef(rulesState);
+  import_react.default.useEffect(() => {
+    rulesStateRef.current = rulesState;
+  }, [rulesState]);
+  const initFormState = import_react.default.useCallback((configName, defaultValues, fields, areAllFieldsReadonly) => {
+    const formState = evaluateAllRules(fields, defaultValues, areAllFieldsReadonly);
+    dispatch({
+      type: "RULES_ENGINE_SET" /* SET */,
+      payload: { configName, formState }
+    });
+    return formState;
+  }, []);
+  const clearFormState = import_react.default.useCallback((configName) => {
+    dispatch({
+      type: "RULES_ENGINE_CLEAR" /* CLEAR */,
+      payload: { configName }
+    });
+  }, []);
+  const processFieldChange = import_react.default.useCallback((entityData, configName, fieldName, fields) => {
+    const currentState = rulesStateRef.current.configs[configName];
+    if (!currentState) return;
+    const hasAnyDeps = (currentState.fieldStates[fieldName]?.dependentFields?.length ?? 0) > 0 || (currentState.fieldStates[fieldName]?.dependsOnFields?.length ?? 0) > 0;
+    if (!hasAnyDeps) return;
+    const updatedState = evaluateAffectedFields(fieldName, fields, entityData, currentState);
+    dispatch({
+      type: "RULES_ENGINE_UPDATE" /* UPDATE */,
+      payload: { configName, formState: updatedState }
+    });
+  }, []);
+  const providerValue = import_react.default.useMemo(() => ({
+    rulesState,
+    initFormState,
+    processFieldChange,
+    clearFormState
+  }), [rulesState, initFormState, processFieldChange, clearFormState]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RulesEngineContext.Provider, { value: providerValue, children: props.children });
+};
+
+// src/providers/InjectedHookFieldProvider.tsx
+var import_react2 = __toESM(require("react"));
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var InjectedFieldContext = import_react2.default.createContext(
+  void 0
+);
+function UseInjectedFieldContext() {
+  const context = import_react2.default.useContext(InjectedFieldContext);
+  if (context === void 0) {
+    throw new Error(
+      "UseInjectedFieldContext() was called outside of <InjectedFieldProvider>. Required hierarchy: <RulesEngineProvider> > <InjectedFieldProvider> > <FormEngine>"
+    );
+  }
+  return context;
+}
+var InjectedFieldProvider = (props) => {
+  const [injectedFields, setInjectedFields] = import_react2.default.useState(
+    props.injectedFields ?? void 0
+  );
+  const providerValue = import_react2.default.useMemo(() => ({
+    injectedFields,
+    setInjectedFields
+  }), [injectedFields]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(InjectedFieldContext.Provider, { value: providerValue, children: props.children });
+};
+
+// src/helpers/ValidationRegistry.ts
+var required = (value) => {
+  if (value === null || value === void 0 || typeof value === "string" && value.trim() === "") {
+    return "This field is required";
+  }
+  return void 0;
+};
+var email = (value) => {
+  if (!value || typeof value !== "string") return void 0;
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value) ? void 0 : "Invalid email address";
+};
+var phone = (value) => {
+  if (!value || typeof value !== "string") return void 0;
+  const phoneRegex = /^[+]?[(]?[0-9]{1,4}[)]?[-\s./0-9]*$/;
+  return phoneRegex.test(value) ? void 0 : "Invalid phone number";
+};
+var url = (value) => {
+  if (!value || typeof value !== "string") return void 0;
+  return /(http(s?)):\/\//i.test(value) ? void 0 : "Invalid URL";
+};
+var year = (value) => {
+  if (!value || typeof value !== "string") return void 0;
+  const y = parseInt(value, 10);
+  if (isNaN(y) || y < 1900 || y > 2100) return "Invalid year";
+  return void 0;
+};
+var noSpecialCharacters = (value) => {
+  if (!value || typeof value !== "string") return void 0;
+  return /[^a-zA-Z0-9\s\-_.]/.test(value) ? "Special characters are not allowed" : void 0;
+};
+var currency = (value) => {
+  if (!value && value !== 0) return void 0;
+  const str = typeof value === "string" ? value : String(value);
+  return /^-?\d{1,}(\.\d{1,2})?$/.test(str) ? void 0 : "Invalid currency format";
+};
+var uniqueInArray = (value) => {
+  if (!value || !Array.isArray(value)) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    const str = String(item);
+    if (seen.has(str)) return `Duplicate value: ${str}`;
+    seen.add(str);
+  }
+  return void 0;
+};
+var minLength = (value, params) => {
+  if (value === null || value === void 0 || typeof value !== "string") return void 0;
+  const min = Number(params?.min ?? 0);
+  return value.length < min ? `Must be at least ${min} characters` : void 0;
+};
+var maxLength = (value, params) => {
+  if (!value || typeof value !== "string") return void 0;
+  const max = Number(params?.max ?? Infinity);
+  return value.length > max ? `Must be at most ${max} characters` : void 0;
+};
+var numericRange = (value, params) => {
+  if (value == null || value === "") return void 0;
+  const num = typeof value === "number" ? value : Number(value);
+  if (isNaN(num)) return "Must be a number";
+  const min = Number(params?.min ?? -Infinity);
+  const max = Number(params?.max ?? Infinity);
+  if (num < min || num > max) return `Must be between ${min} and ${max}`;
+  return void 0;
+};
+var pattern = (value, params) => {
+  if (!value || typeof value !== "string") return void 0;
+  const regex = params?.pattern;
+  const message = params?.message ?? "Invalid format";
+  if (!regex) return void 0;
+  try {
+    return new RegExp(regex).test(value) ? void 0 : message;
+  } catch {
+    return void 0;
+  }
+};
+var maxKb = (value, params) => {
+  if (!value || typeof value !== "string") return void 0;
+  const maxKbValue = Number(params?.maxKb ?? 150);
+  const sizeKb = Math.ceil(new Blob([value]).size / 1e3);
+  return sizeKb > maxKbValue ? `Content exceeds maximum size of ${maxKbValue}KB` : void 0;
+};
+var exclusiveNumericRange = (value, params) => {
+  if (value == null || value === "") return void 0;
+  const num = typeof value === "number" ? value : Number(value);
+  if (isNaN(num)) return "Must be a number";
+  const exclMin = params?.exclusiveMin != null ? Number(params.exclusiveMin) : void 0;
+  const exclMax = params?.exclusiveMax != null ? Number(params.exclusiveMax) : void 0;
+  const min = params?.min != null ? Number(params.min) : void 0;
+  const max = params?.max != null ? Number(params.max) : void 0;
+  if (exclMin !== void 0 && num <= exclMin) return `Must be greater than ${exclMin}`;
+  if (exclMax !== void 0 && num >= exclMax) return `Must be less than ${exclMax}`;
+  if (min !== void 0 && num < min) return `Must be at least ${min}`;
+  if (max !== void 0 && num > max) return `Must be at most ${max}`;
+  return void 0;
+};
+var multipleOf = (value, params) => {
+  if (value == null || value === "") return void 0;
+  const num = typeof value === "number" ? value : Number(value);
+  if (isNaN(num)) return "Must be a number";
+  const factor = Number(params?.factor ?? 1);
+  if (factor === 0) return void 0;
+  const remainder = Math.abs(num % factor);
+  const tolerance = 1e-10;
+  if (remainder > tolerance && Math.abs(remainder - Math.abs(factor)) > tolerance) {
+    return `Must be a multiple of ${factor}`;
+  }
+  return void 0;
+};
+var requiredIf = (value, params, context) => {
+  if (!params?.field || !params?.values) return void 0;
+  const depValue = context.values[params.field];
+  const allowedValues = params.values;
+  if (allowedValues.includes(String(depValue)) && (value == null || value === "")) {
+    return "This field is required";
+  }
+  return void 0;
+};
+var defaultValidators = {
+  required,
+  email,
+  phone,
+  url,
+  year,
+  noSpecialCharacters,
+  currency,
+  uniqueInArray,
+  minLength,
+  maxLength,
+  numericRange,
+  pattern,
+  maxKb,
+  exclusiveNumericRange,
+  multipleOf,
+  requiredIf,
+  // Legacy name aliases
+  EmailValidation: email,
+  PhoneNumberValidation: phone,
+  YearValidation: year,
+  isValidUrl: url,
+  NoSpecialCharactersValidation: noSpecialCharacters,
+  CurrencyValidation: currency,
+  UniqueInArrayValidation: uniqueInArray,
+  Max150KbValidation: (v, _p, c) => maxKb(v, { maxKb: 150 }, c),
+  Max32KbValidation: (v, _p, c) => maxKb(v, { maxKb: 32 }, c)
+};
+var validatorRegistry = { ...defaultValidators };
+function registerValidators(custom) {
+  validatorRegistry = { ...validatorRegistry, ...custom };
+}
+function getValidator(name) {
+  return validatorRegistry[name];
+}
+function getValidatorRegistry() {
+  return { ...validatorRegistry };
+}
+function resetValidatorRegistry() {
+  validatorRegistry = { ...defaultValidators };
+}
+async function runValidations(value, rules, context) {
+  for (const rule of rules) {
+    if (context.signal?.aborted) return void 0;
+    if (rule.when) {
+      if (!evaluateCondition(rule.when, context.values)) continue;
+    }
+    const validator = getValidator(rule.name);
+    if (!validator) continue;
+    const result = validator(value, rule.params, context);
+    const message = result instanceof Promise ? await result : result;
+    if (message) {
+      return rule.message ?? message;
+    }
+  }
+  return void 0;
+}
+function runSyncValidations(value, rules, context) {
+  for (const rule of rules) {
+    if (rule.async) continue;
+    if (rule.when) {
+      if (!evaluateCondition(rule.when, context.values)) continue;
+    }
+    const validator = getValidator(rule.name);
+    if (!validator) continue;
+    const result = validator(value, rule.params, context);
+    if (typeof result === "string") {
+      return rule.message ?? result;
+    }
+  }
+  return void 0;
+}
+function createMinLengthRule(min, message) {
+  return { name: "minLength", params: { min }, message };
+}
+function createMaxLengthRule(max, message) {
+  return { name: "maxLength", params: { max }, message };
+}
+function createNumericRangeRule(min, max, message) {
+  return { name: "numericRange", params: { min, max }, message };
+}
+function createPatternRule(pattern2, message) {
+  return { name: "pattern", params: { pattern: pattern2, message } };
+}
+function createRequiredIfRule(field, values, message) {
+  return { name: "requiredIf", params: { field, values }, message };
+}
+
+// src/helpers/InlineFormHelper.ts
+var GetChildEntity = (entityId, entity, entityPath, idField = "id") => {
+  if (!entity || !entityPath) return void 0;
+  const childValues = entity[entityPath]?.filter((child) => child[idField] === entityId);
+  return childValues?.length === 1 ? { ...childValues[0], Parent: { ...entity } } : void 0;
+};
+var IsExpandVisible = (fieldStates, expandCutoffCount = 12) => {
+  let count = 0;
+  Object.keys(fieldStates).forEach((field) => {
+    if (!fieldStates[field].hidden) count += 1;
+  });
+  return count > expandCutoffCount;
+};
+var GetConfirmInputModalProps = (dirtyFieldNames, fieldStates) => {
+  const confirmInputModalProps = {};
+  dirtyFieldNames?.forEach((fieldName) => {
+    fieldStates[fieldName]?.dependentFields?.forEach((dependentFieldName) => {
+      if (fieldStates[dependentFieldName]?.confirmInput) {
+        if (confirmInputModalProps.confirmInputsTriggeredBy === void 0) {
+          confirmInputModalProps.confirmInputsTriggeredBy = fieldName;
+          confirmInputModalProps.dependentFieldNames = [dependentFieldName];
+        } else {
+          confirmInputModalProps.dependentFieldNames.push(dependentFieldName);
+        }
+      }
+    });
+  });
+  confirmInputModalProps.otherDirtyFields = dirtyFieldNames?.filter(
+    (fieldName) => !confirmInputModalProps.dependentFieldNames?.includes(fieldName) && fieldName !== confirmInputModalProps.confirmInputsTriggeredBy
+  );
+  return confirmInputModalProps;
+};
+var GetComputedValuesOnDirtyFields = (dirtyFieldNames, fieldStates) => {
+  const computedValues = [];
+  dirtyFieldNames?.forEach((fieldName) => {
+    fieldStates[fieldName]?.dependentFields?.forEach((dependentFieldName) => {
+      const state = fieldStates[dependentFieldName];
+      if (state?.computedValue && !state.computeOnCreateOnly && !dirtyFieldNames.includes(dependentFieldName)) {
+        computedValues.push({
+          fieldName: dependentFieldName,
+          expression: state.computedValue
+        });
+      }
+    });
+  });
+  return computedValues;
+};
+var GetComputedValuesOnCreate = (fieldStates) => {
+  const computedValues = [];
+  Object.keys(fieldStates).forEach((fieldName) => {
+    const state = fieldStates[fieldName];
+    if (state.computedValue && state.computeOnCreateOnly) {
+      computedValues.push({
+        fieldName,
+        expression: state.computedValue
+      });
+    }
+  });
+  return computedValues;
+};
+var ExecuteComputedValue = (expression, values, fieldName, parentEntity, currentUserId) => {
+  return evaluateExpression(expression, values, fieldName, parentEntity, currentUserId);
+};
+var CheckFieldValidationRules = (value, fieldName, entityData, state) => {
+  if (!state.validate || state.validate.length === 0) return void 0;
+  const context = { fieldName, values: entityData };
+  const result = runSyncValidations(value, state.validate, context);
+  logEvent("validation_run", fieldName, result ? `failed: ${result}` : "passed");
+  return result;
+};
+var CheckAsyncFieldValidationRules = async (value, fieldName, entityData, state, signal) => {
+  if (!state.validate || state.validate.length === 0) return void 0;
+  const context = { fieldName, values: entityData, signal };
+  return runValidations(value, state.validate, context);
+};
+var CheckValidDropdownOptions = (fieldStates, formValues, setValue) => {
+  if (isEmpty(fieldStates) || isEmpty(formValues)) return;
+  Object.keys(fieldStates).forEach((fieldName) => {
+    const { type, options } = fieldStates[fieldName];
+    if ((type === "Dropdown" || type === "StatusDropdown") && !isNull(formValues[fieldName]) && options && options.findIndex((o) => String(o.value) === String(formValues[fieldName])) === -1) {
+      setValue(`${fieldName}`, null, { shouldDirty: false });
+    } else if (type === "Multiselect" && !isNull(formValues[fieldName]) && options) {
+      const filteredValues = formValues[fieldName]?.filter(
+        (val) => options.some((o) => String(o.value) === val)
+      );
+      if (filteredValues?.length !== formValues[fieldName]?.length) {
+        setValue(`${fieldName}`, filteredValues, { shouldDirty: false });
+      }
+    }
+  });
+};
+var CheckDefaultValues = (fieldStates, formValues, setValue) => {
+  if (isEmpty(fieldStates) || isEmpty(formValues)) return;
+  Object.keys(fieldStates).forEach((fieldName) => {
+    const { defaultValue, hidden } = fieldStates[fieldName];
+    if (!isNull(defaultValue) && isNull(formValues[fieldName]) && !hidden) {
+      setValue(`${fieldName}`, defaultValue, { shouldDirty: true });
+    }
+  });
+};
+var InitOnCreateFormState = (configName, fields, defaultValues, parentEntity, userId, setValue, initFormState) => {
+  const initEntityData = { ...defaultValues, Parent: { ...parentEntity } };
+  for (const [fieldName, config] of Object.entries(fields)) {
+    if (config.computedValue && config.computeOnCreateOnly) {
+      const result = ExecuteComputedValue(
+        config.computedValue,
+        initEntityData,
+        fieldName,
+        parentEntity,
+        userId
+      );
+      if (result !== void 0) {
+        setValue(`${fieldName}`, result);
+        initEntityData[fieldName] = result;
+      }
+    }
+    if (config.defaultValue !== void 0 && isNull(initEntityData[fieldName])) {
+      setValue(`${fieldName}`, config.defaultValue);
+      initEntityData[fieldName] = config.defaultValue;
+    }
+  }
+  return {
+    formState: initFormState(configName, initEntityData, fields, false),
+    initEntityData
+  };
+};
+var InitOnEditFormState = (configName, fields, defaultValues, areAllFieldsReadonly, initFormState) => {
+  return {
+    formState: initFormState(configName, defaultValues, fields, areAllFieldsReadonly),
+    initEntityData: defaultValues
+  };
+};
+var ShowField = (filterText, value, label) => {
+  if (!filterText) return true;
+  const valueStr = JSON.stringify(value)?.toLowerCase();
+  const labelStr = label?.toLowerCase();
+  return (valueStr?.includes(filterText.toLowerCase()) ?? false) || (labelStr?.includes(filterText.toLowerCase()) ?? false);
+};
+var GetFieldsToRender = (fieldRenderLimit, fieldOrder, fieldStates) => {
+  if (fieldRenderLimit) {
+    const fieldsToRender = [];
+    let count = 0;
+    fieldOrder.forEach((fieldName) => {
+      if (fieldStates?.[fieldName]?.hidden) return;
+      if (count === fieldRenderLimit) {
+        fieldsToRender.push({ fieldName, softHidden: true });
+      } else {
+        fieldsToRender.push({ fieldName, softHidden: false });
+        count += 1;
+      }
+    });
+    return fieldsToRender;
+  }
+  return fieldOrder?.map((fieldName) => ({ fieldName, softHidden: false }));
+};
+var SortOptions = (options) => {
+  return [...options].sort((a, b) => {
+    const aLabel = a.label?.toLowerCase() ?? "";
+    const bLabel = b.label?.toLowerCase() ?? "";
+    return aLabel < bLabel ? -1 : aLabel > bLabel ? 1 : 0;
+  });
+};
+
+// src/helpers/FieldHelper.ts
+function SortOptions2(options) {
+  return [...options].sort((a, b) => {
+    const aLabel = a.label?.toLowerCase() ?? "";
+    const bLabel = b.label?.toLowerCase() ?? "";
+    return aLabel < bLabel ? -1 : aLabel > bLabel ? 1 : 0;
+  });
+}
+
+// src/helpers/DependencyGraphValidator.ts
+function detectDependencyCycles(fields) {
+  const errors = [];
+  const graph = buildDependencyGraph(fields);
+  const { hasCycle, cycleFields } = topologicalSort(graph);
+  if (hasCycle) {
+    errors.push({
+      type: "dependency",
+      fields: cycleFields,
+      message: `Circular dependency detected among fields: ${cycleFields.join(", ")}`
+    });
+  }
+  return errors;
+}
+function detectSelfDependencies(fields) {
+  const errors = [];
+  for (const [fieldName, config] of Object.entries(fields)) {
+    if (!config.rules) continue;
+    for (const rule of config.rules) {
+      const condDeps = extractConditionDependencies(rule.when);
+      const selfInCondition = condDeps.includes(fieldName);
+      if (selfInCondition && rule.then.fields?.[fieldName]) {
+        errors.push({
+          type: "self",
+          fields: [fieldName],
+          message: `Field "${fieldName}" has a rule that both depends on and modifies itself`
+        });
+      }
+    }
+  }
+  return errors;
+}
+function validateDependencyGraph(fields) {
+  const errors = [];
+  errors.push(...detectDependencyCycles(fields));
+  errors.push(...detectSelfDependencies(fields));
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.__DEV__ !== false) {
+      for (const error of errors) {
+        console.warn(`[dynamic-forms] ${error.message}`);
+      }
+    }
+  } catch {
+  }
+  return errors;
+}
+
+// src/helpers/ConfigValidator.ts
+function validateFieldConfigs(fields, registeredComponents) {
+  const errors = [];
+  const fieldNames = new Set(Object.keys(fields));
+  for (const [fieldName, config] of Object.entries(fields)) {
+    if (config.rules) {
+      for (const rule of config.rules) {
+        const condDeps = extractConditionDependencies(rule.when);
+        for (const dep of condDeps) {
+          if (!fieldNames.has(dep)) {
+            errors.push({
+              type: "missing_rule_target",
+              fieldName,
+              message: `Field "${fieldName}" has a rule condition referencing non-existent field "${dep}"`,
+              details: dep
+            });
+          }
+        }
+        if (rule.then.fields) {
+          for (const target of Object.keys(rule.then.fields)) {
+            if (!fieldNames.has(target)) {
+              errors.push({
+                type: "missing_rule_target",
+                fieldName,
+                message: `Field "${fieldName}" has a rule effect targeting non-existent field "${target}"`,
+                details: target
+              });
+            }
+          }
+        }
+        if (rule.else?.fields) {
+          for (const target of Object.keys(rule.else.fields)) {
+            if (!fieldNames.has(target)) {
+              errors.push({
+                type: "missing_rule_target",
+                fieldName,
+                message: `Field "${fieldName}" has a rule else-effect targeting non-existent field "${target}"`,
+                details: target
+              });
+            }
+          }
+        }
+      }
+    }
+    if (registeredComponents && config.type && !registeredComponents.has(config.type)) {
+      errors.push({
+        type: "unregistered_component",
+        fieldName,
+        message: `Field "${fieldName}" uses unregistered component type "${config.type}". Available: ${[...registeredComponents].join(", ")}`,
+        details: config.type
+      });
+    }
+    if (config.validate) {
+      for (const rule of config.validate) {
+        if (!getValidator(rule.name)) {
+          errors.push({
+            type: "unregistered_validator",
+            fieldName,
+            message: `Field "${fieldName}" references unregistered validator "${rule.name}"`,
+            details: rule.name
+          });
+        }
+      }
+    }
+    if ((config.type === "Dropdown" || config.type === "StatusDropdown" || config.type === "Multiselect") && (!config.options || config.options.length === 0) && !hasRuleProvidingOptions(fieldName, fields)) {
+      errors.push({
+        type: "missing_options",
+        fieldName,
+        message: `Field "${fieldName}" is a ${config.type} but has no options configured and no rules providing options`
+      });
+    }
+  }
+  const cycleErrors = detectDependencyCycles(fields);
+  for (const cycleError of cycleErrors) {
+    errors.push({
+      type: "circular_dependency",
+      fieldName: cycleError.fields[0] ?? "",
+      message: cycleError.message
+    });
+  }
+  const selfErrors = detectSelfDependencies(fields);
+  for (const selfError of selfErrors) {
+    errors.push({
+      type: "self_dependency",
+      fieldName: selfError.fields[0] ?? "",
+      message: selfError.message
+    });
+  }
+  return errors;
+}
+function hasRuleProvidingOptions(targetFieldName, fields) {
+  for (const config of Object.values(fields)) {
+    if (config.rules) {
+      for (const rule of config.rules) {
+        if (rule.then.fields?.[targetFieldName]?.options) return true;
+        if (rule.else?.fields?.[targetFieldName]?.options) return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/components/WizardForm.tsx
+var import_react3 = __toESM(require("react"));
+
+// src/helpers/WizardHelper.ts
+function getVisibleSteps(steps, entityData) {
+  return steps.filter((step) => {
+    if (!step.visibleWhen) return true;
+    return evaluateCondition(step.visibleWhen, entityData);
+  });
+}
+function getStepFields(step, fieldStates) {
+  if (!fieldStates) return step.fields;
+  return step.fields.filter((fieldName) => {
+    const state = fieldStates[fieldName];
+    return !state?.hidden;
+  });
+}
+function getStepFieldOrder(steps, entityData) {
+  const visibleSteps = getVisibleSteps(steps, entityData);
+  return visibleSteps.flatMap((step) => step.fields);
+}
+function validateStepFields(step, errors) {
+  return step.fields.filter((fieldName) => fieldName in errors);
+}
+function isStepValid(step, errors) {
+  return validateStepFields(step, errors).length === 0;
+}
+function getStepIndex(steps, stepId) {
+  return steps.findIndex((s) => s.id === stepId);
+}
+
+// src/components/WizardForm.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var WizardForm = (props) => {
+  const {
+    wizardConfig,
+    entityData,
+    fieldStates,
+    errors,
+    renderStepContent,
+    renderStepNavigation,
+    renderStepHeader,
+    onStepChange,
+    onAnalyticsStepChange
+  } = props;
+  const [currentStepIndex, setCurrentStepIndex] = import_react3.default.useState(0);
+  const visibleSteps = import_react3.default.useMemo(
+    () => getVisibleSteps(wizardConfig.steps, entityData),
+    [wizardConfig.steps, entityData]
+  );
+  const currentStep = visibleSteps[currentStepIndex];
+  const currentFields = currentStep ? getStepFields(currentStep, fieldStates) : [];
+  const canGoNext = currentStepIndex < visibleSteps.length - 1;
+  const canGoPrev = currentStepIndex > 0;
+  const goToStep = import_react3.default.useCallback((index) => {
+    if (index >= 0 && index < visibleSteps.length) {
+      if (wizardConfig.validateOnStepChange && errors && currentStep) {
+        if (!isStepValid(currentStep, errors)) return;
+      }
+      const prevIndex = currentStepIndex;
+      setCurrentStepIndex(index);
+      onStepChange?.(prevIndex, index);
+      onAnalyticsStepChange?.(prevIndex, index);
+    }
+  }, [visibleSteps.length, currentStepIndex, wizardConfig.validateOnStepChange, errors, currentStep, onStepChange, onAnalyticsStepChange]);
+  const goNext = import_react3.default.useCallback(() => {
+    if (canGoNext) goToStep(currentStepIndex + 1);
+  }, [canGoNext, currentStepIndex, goToStep]);
+  const goPrev = import_react3.default.useCallback(() => {
+    if (canGoPrev) goToStep(currentStepIndex - 1);
+  }, [canGoPrev, currentStepIndex, goToStep]);
+  const stepAnnouncement = currentStep ? `${FormStrings.stepOf(currentStepIndex + 1, visibleSteps.length)}${currentStep.title ? `: ${currentStep.title}` : ""}` : "";
+  if (!currentStep) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "wizard-form", role: "group", "aria-label": FormStrings.formWizard, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { role: "status", "aria-live": "polite", className: "sr-only", style: { position: "absolute", width: "1px", height: "1px", padding: 0, margin: "-1px", overflow: "hidden", clip: "rect(0, 0, 0, 0)", whiteSpace: "nowrap", border: 0 }, "data-testid": "wizard-step-live-region", children: stepAnnouncement }),
+    renderStepHeader?.({ step: currentStep, stepIndex: currentStepIndex, totalSteps: visibleSteps.length }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "wizard-step-content", "aria-current": "step", children: renderStepContent(currentFields) }),
+    renderStepNavigation?.({ steps: visibleSteps, currentStepIndex, goToStep, canGoNext, canGoPrev, goNext, goPrev })
+  ] });
+};
+
+// src/components/FieldArray.tsx
+var import_react4 = __toESM(require("react"));
+var import_react_hook_form = require("react-hook-form");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var FieldArray = (props) => {
+  const { fieldName, config, renderItem, renderAddButton } = props;
+  const { control } = (0, import_react_hook_form.useFormContext)();
+  const { fields, append, remove } = (0, import_react_hook_form.useFieldArray)({ control, name: fieldName });
+  const canAdd = config.maxItems ? fields.length < config.maxItems : true;
+  const canRemove = config.minItems ? fields.length > config.minItems : true;
+  const handleAppend = import_react4.default.useCallback(() => {
+    if (canAdd) append({});
+  }, [canAdd, append]);
+  const handleRemove = import_react4.default.useCallback((index) => {
+    if (canRemove) remove(index);
+  }, [canRemove, remove]);
+  const itemFieldNames = import_react4.default.useMemo(
+    () => config.items ? Object.keys(config.items) : [],
+    [config.items]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "field-array", role: "group", "aria-label": config.label || fieldName, children: [
+    fields.map((field, index) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "field-array-item", role: "group", "aria-label": FormStrings.itemOfTotal(index + 1, fields.length, config.label || fieldName), children: renderItem(
+      itemFieldNames.map((name) => `${fieldName}.${index}.${name}`),
+      index,
+      () => handleRemove(index)
+    ) }, field.id)),
+    renderAddButton?.(handleAppend, canAdd)
+  ] });
+};
+
+// src/components/InlineForm.tsx
+var import_react11 = __toESM(require("react"));
+var import_react_hook_form4 = require("react-hook-form");
+
+// src/hooks/useFormAnalytics.ts
+var import_react5 = require("react");
+function useFormAnalytics(callbacks) {
+  const formStartTime = (0, import_react5.useRef)(Date.now()).current;
+  const focusTimes = (0, import_react5.useRef)({});
+  const callbacksRef = (0, import_react5.useRef)(callbacks);
+  callbacksRef.current = callbacks;
+  return (0, import_react5.useMemo)(() => ({
+    formStartTime,
+    trackFieldFocus(fieldName) {
+      focusTimes.current[fieldName] = Date.now();
+      callbacksRef.current?.onFieldFocus?.(fieldName);
+    },
+    trackFieldBlur(fieldName) {
+      const start = focusTimes.current[fieldName];
+      const timeSpentMs = start ? Date.now() - start : 0;
+      delete focusTimes.current[fieldName];
+      callbacksRef.current?.onFieldBlur?.(fieldName, timeSpentMs);
+    },
+    trackFieldChange(fieldName, oldValue, newValue) {
+      callbacksRef.current?.onFieldChange?.(fieldName, oldValue, newValue);
+    },
+    trackValidationError(fieldName, errors) {
+      callbacksRef.current?.onValidationError?.(fieldName, errors);
+    },
+    trackFormSubmit(values) {
+      const durationMs = Date.now() - formStartTime;
+      callbacksRef.current?.onFormSubmit?.(values, durationMs);
+    },
+    trackFormAbandonment(filledFields, emptyRequiredFields) {
+      callbacksRef.current?.onFormAbandonment?.(filledFields, emptyRequiredFields);
+    },
+    trackWizardStepChange(fromStep, toStep) {
+      callbacksRef.current?.onWizardStepChange?.(fromStep, toStep);
+    },
+    trackRuleTriggered(event) {
+      callbacksRef.current?.onRuleTriggered?.(event);
+    }
+  }), [formStartTime]);
+}
+
+// src/components/ConfirmInputsModal.tsx
+var import_react8 = __toESM(require("react"));
+var import_react_hook_form3 = require("react-hook-form");
+
+// src/components/RenderField.tsx
+var import_react7 = __toESM(require("react"));
+var import_react_hook_form2 = require("react-hook-form");
+
+// src/components/FieldWrapper.tsx
+var import_react6 = __toESM(require("react"));
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var FieldWrapper = import_react6.default.memo((props) => {
+  const {
+    id,
+    required: required2,
+    error,
+    errorCount,
+    savePending,
+    saving,
+    labelClassName,
+    fieldClassName,
+    showControlonSide,
+    label,
+    ariaLabel,
+    ariaDescription,
+    containerClassName,
+    additionalInfo,
+    additionalInfoComponent,
+    isManualSave,
+    renderLabel,
+    renderError,
+    renderStatus
+  } = props;
+  const labelId = `${id}_label`;
+  const errorMessageId = `${id}_error`;
+  const children = Array.isArray(props.children) ? props.children : [props.children];
+  const defaultLabel = /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: labelClassName || "", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("label", { id: labelId, htmlFor: id, className: "field-label", children: [
+      label,
+      required2 && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "required-indicator", "aria-hidden": "true", style: { color: "var(--form-required-color, #d13438)" }, children: " *" }),
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "sr-only", style: { position: "absolute", width: "1px", height: "1px", padding: 0, margin: "-1px", overflow: "hidden", clip: "rect(0, 0, 0, 0)", whiteSpace: "nowrap", border: 0 }, children: " (required)" })
+      ] })
+    ] }),
+    additionalInfoComponent,
+    !additionalInfoComponent && additionalInfo && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "additional-info", title: additionalInfo, children: "\u24D8" })
+  ] });
+  const defaultErrorAndStatus = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "message", children: error ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "error-icon", "aria-hidden": "true", style: { color: "var(--form-error-color, #d13438)" }, children: "\u2716" }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "error-message", id: errorMessageId, role: "alert", style: { color: "var(--form-error-color, #d13438)" }, children: error.message || "Error" })
+  ] }) : savePending ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "warning-icon", "aria-hidden": "true", style: { color: "var(--form-warning-color, #ffb900)" }, children: "\u26A0" }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("span", { className: "warning-message", id: errorMessageId, role: "status", style: { color: "var(--form-warning-color, #ffb900)" }, children: [
+      !isManualSave ? FormStrings.autoSavePending : FormStrings.savePending,
+      " (",
+      `${errorCount} ${FormStrings.remaining}`,
+      ")"
+    ] })
+  ] }) : saving ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "save-spinner", "aria-hidden": "true", style: { color: "var(--form-saving-color, #0078d4)" }, children: "\u231B" }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "save-message", id: errorMessageId, role: "status", style: { color: "var(--form-saving-color, #0078d4)" }, children: FormStrings.saving })
+  ] }) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, {}) });
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+    "div",
+    {
+      className: `form-field ${showControlonSide ? "flexBox" : ""} ${containerClassName || ""} ${saving ? "saving" : ""}`,
+      "aria-busy": saving ? "true" : void 0,
+      children: [
+        renderLabel ? renderLabel({ id: id || "", labelId, label, required: required2 }) : defaultLabel,
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: `flexBox-Direction-column field-container ${fieldClassName || ""}`, children: children.map((child, index) => {
+          if (child && child.props) {
+            const childProps = {
+              id,
+              "aria-labelledby": ariaLabel ? void 0 : labelId,
+              "aria-label": ariaLabel || void 0,
+              "aria-required": required2,
+              "aria-invalid": !!error,
+              "aria-describedby": errorMessageId,
+              key: index,
+              className: child.props.className
+            };
+            if (ariaDescription && !error) {
+              childProps["aria-description"] = ariaDescription;
+            }
+            if (index === 0) {
+              return import_react6.default.cloneElement(child, childProps);
+            }
+            const siblingProps = {
+              key: index,
+              "aria-labelledby": childProps["aria-labelledby"],
+              "aria-label": childProps["aria-label"],
+              "aria-required": childProps["aria-required"],
+              "aria-invalid": childProps["aria-invalid"],
+              "aria-describedby": childProps["aria-describedby"],
+              className: child.props.className
+            };
+            if (childProps["aria-description"]) {
+              siblingProps["aria-description"] = childProps["aria-description"];
+            }
+            return import_react6.default.cloneElement(child, siblingProps);
+          }
+          return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react6.default.Fragment, {}, index);
+        }) }),
+        renderError ? renderError({ id: id || "", error, errorCount }) : renderStatus ? renderStatus({ id: id || "", saving, savePending, errorCount, isManualSave }) : defaultErrorAndStatus
+      ]
+    }
+  );
+});
+
+// src/helpers/RenderTracker.ts
+var renderCounts = /* @__PURE__ */ new Map();
+var lastRenderedFields = /* @__PURE__ */ new Set();
+var pendingRenderedFields = /* @__PURE__ */ new Set();
+var totalFormRenders = 0;
+function trackRender(fieldName) {
+  renderCounts.set(fieldName, (renderCounts.get(fieldName) ?? 0) + 1);
+  pendingRenderedFields.add(fieldName);
+}
+function flushRenderCycle() {
+  lastRenderedFields = pendingRenderedFields;
+  pendingRenderedFields = /* @__PURE__ */ new Set();
+  totalFormRenders++;
+}
+function getRenderCounts() {
+  return new Map(renderCounts);
+}
+function getLastRenderedFields() {
+  return new Set(lastRenderedFields);
+}
+function getTotalFormRenders() {
+  return totalFormRenders;
+}
+function resetRenderTracker() {
+  renderCounts.clear();
+  lastRenderedFields.clear();
+  pendingRenderedFields.clear();
+  totalFormRenders = 0;
+}
+
+// src/components/RenderField.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var RenderField = (props) => {
+  const {
+    type,
+    fieldName,
+    entityId,
+    entityType,
+    programName,
+    hidden,
+    required: required2,
+    readOnly,
+    disabled,
+    options,
+    validate,
+    parentEntityId,
+    parentEntityType,
+    isManualSave,
+    setFieldValue,
+    isCreate,
+    filterText,
+    softHidden,
+    label,
+    skipLayoutReadOnly,
+    hideOnCreate,
+    config,
+    description,
+    placeholder,
+    helpText,
+    renderLabel,
+    renderError,
+    renderStatus,
+    analytics
+  } = props;
+  const { injectedFields } = UseInjectedFieldContext();
+  const { control, getValues } = (0, import_react_hook_form2.useFormContext)();
+  const previousValueRef = import_react7.default.useRef(void 0);
+  import_react7.default.useEffect(() => {
+    trackRender(fieldName);
+  });
+  const isDisabled = disabled ?? false;
+  const fieldNameConst = `${fieldName}`;
+  const FieldComponent = import_react7.default.useMemo(() => {
+    const isReadOnly = readOnly || isDisabled && (isNull(skipLayoutReadOnly) || !isNull(skipLayoutReadOnly) && !skipLayoutReadOnly);
+    if (isCreate && hideOnCreate || hidden) return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, {});
+    if (!isEmpty(injectedFields) && injectedFields[type]) {
+      const Comp = injectedFields[type];
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        import_react_hook_form2.Controller,
+        {
+          name: fieldNameConst,
+          control,
+          rules: {
+            required: required2 && type !== ComponentTypes.Toggle && !isReadOnly ? { value: true, message: FormStrings.required } : void 0,
+            validate: async (value) => {
+              if (!validate || validate.length === 0 || isReadOnly || !value) return void 0;
+              const fieldState = { validate };
+              const syncError = CheckFieldValidationRules(value, fieldName, getValues(), fieldState);
+              if (syncError) return syncError;
+              return CheckAsyncFieldValidationRules(value, fieldName, getValues(), fieldState);
+            }
+          },
+          render: ({
+            field: { value },
+            fieldState: { error, isDirty },
+            formState: { isSubmitting, isSubmitSuccessful, errors }
+          }) => {
+            const errorCount = errors ? Object.keys(errors).length : 0;
+            const saving = isDirty && (isSubmitting || isSubmitSuccessful);
+            const savePending = isDirty && errorCount > 0 && !isSubmitting && !isSubmitSuccessful;
+            if (error && analytics) {
+              analytics.trackValidationError(fieldName, [error.message || "Error"]);
+            }
+            if (previousValueRef.current !== void 0 && previousValueRef.current !== value && analytics) {
+              analytics.trackFieldChange(fieldName, previousValueRef.current, value);
+            }
+            previousValueRef.current = value;
+            return type === "DynamicFragment" ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children: import_react7.default.cloneElement(Comp, { value }) }) : ShowField(filterText, value, label) && !softHidden ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+              FieldWrapper,
+              {
+                id: fieldName,
+                required: required2,
+                label,
+                error,
+                errorCount,
+                saving,
+                savePending,
+                labelClassName: "form-label",
+                isManualSave,
+                renderLabel,
+                renderError,
+                renderStatus,
+                children: import_react7.default.cloneElement(Comp, {
+                  fieldName,
+                  entityId,
+                  entityType,
+                  parentEntityId,
+                  parentEntityType,
+                  programName,
+                  value,
+                  readOnly: isReadOnly,
+                  required: required2,
+                  error,
+                  errorCount,
+                  saving,
+                  savePending,
+                  config,
+                  options,
+                  label,
+                  type,
+                  description,
+                  placeholder,
+                  helpText,
+                  setFieldValue,
+                  onFocus: analytics ? () => analytics.trackFieldFocus(fieldName) : void 0,
+                  onBlur: analytics ? () => analytics.trackFieldBlur(fieldName) : void 0
+                })
+              }
+            ) : /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, {});
+          }
+        }
+      );
+    }
+    const available = !isEmpty(injectedFields) ? Object.keys(injectedFields).join(", ") : "none";
+    return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { style: { color: "red", fontSize: "0.85em", padding: "4px" }, children: [
+      'Missing component "',
+      type,
+      '" for field "',
+      fieldName,
+      '". Available: [',
+      available,
+      "]"
+    ] });
+  }, [
+    type,
+    hidden,
+    required2,
+    readOnly,
+    disabled,
+    options,
+    softHidden,
+    renderLabel,
+    renderError,
+    renderStatus,
+    fieldName,
+    fieldNameConst,
+    label,
+    validate,
+    config,
+    description,
+    placeholder,
+    helpText,
+    isCreate,
+    hideOnCreate,
+    isManualSave,
+    skipLayoutReadOnly,
+    entityId,
+    entityType,
+    programName,
+    parentEntityId,
+    parentEntityType,
+    injectedFields,
+    analytics,
+    control,
+    getValues,
+    setFieldValue
+  ]);
+  return FieldComponent;
+};
+var RenderField_default = import_react7.default.memo(RenderField);
+
+// src/components/ConfirmInputsModal.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+function getFocusableElements(container) {
+  const selector = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]):not([type="hidden"]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+  return Array.from(container.querySelectorAll(selector));
+}
+var ConfirmInputsModal = (props) => {
+  const {
+    isOpen,
+    configName,
+    entityId,
+    entityType,
+    programName,
+    fields,
+    confirmInputFields,
+    saveConfirmInputFields,
+    cancelConfirmInputFields,
+    renderDialog
+  } = props;
+  const { setValue, trigger } = (0, import_react_hook_form3.useFormContext)();
+  const { rulesState } = UseRulesEngineContext();
+  const dialogRef = import_react8.default.useRef(null);
+  const previouslyFocusedRef = import_react8.default.useRef(null);
+  const saveButtonRef = import_react8.default.useRef(null);
+  import_react8.default.useEffect(() => {
+    if (isOpen && dialogRef.current && !dialogRef.current.open) {
+      previouslyFocusedRef.current = document.activeElement;
+      dialogRef.current.showModal();
+      saveButtonRef.current?.focus();
+    } else if (!isOpen && dialogRef.current?.open) {
+      dialogRef.current.close();
+      if (previouslyFocusedRef.current instanceof HTMLElement) previouslyFocusedRef.current.focus();
+      previouslyFocusedRef.current = null;
+    }
+  }, [isOpen]);
+  import_react8.default.useEffect(() => {
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+    const handleCancel = (e) => {
+      e.preventDefault();
+      cancelConfirmInputFields();
+    };
+    dialog.addEventListener("cancel", handleCancel);
+    return () => {
+      dialog.removeEventListener("cancel", handleCancel);
+    };
+  }, [cancelConfirmInputFields]);
+  const handleKeyDown = import_react8.default.useCallback((e) => {
+    if (e.key !== "Tab" || !dialogRef.current) return;
+    const focusableElements = getFocusableElements(dialogRef.current);
+    if (focusableElements.length === 0) return;
+    const first = focusableElements[0];
+    const last = focusableElements[focusableElements.length - 1];
+    if (e.shiftKey) {
+      if (document.activeElement === first) {
+        e.preventDefault();
+        last.focus();
+      }
+    } else {
+      if (document.activeElement === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    }
+  }, []);
+  const setValueFunctionFieldValue = (fieldName, fieldValue) => {
+    trigger();
+    setValue(`${fieldName}`, fieldValue, { shouldDirty: true });
+  };
+  const content = /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: "dynamic-form-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: "dynamic-form-container", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("form", { className: "dynamic-form modal", children: confirmInputFields?.map((confirmInputField) => {
+    const fieldState = rulesState.configs[configName]?.fieldStates[confirmInputField];
+    const fieldConfig = fields[confirmInputField];
+    if (!fieldState || !fieldConfig) return null;
+    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+      RenderField_default,
+      {
+        fieldName: confirmInputField,
+        entityId,
+        entityType,
+        programName,
+        type: fieldState.type ?? "",
+        required: true,
+        options: fieldState.options,
+        validate: fieldState.validate,
+        isManualSave: true,
+        setFieldValue: setValueFunctionFieldValue,
+        label: fieldConfig.label,
+        skipLayoutReadOnly: true,
+        hideOnCreate: fieldConfig.hideOnCreate,
+        config: fieldConfig.config
+      },
+      `${confirmInputField}-${entityId}-modal`
+    );
+  }) }) }) });
+  if (renderDialog) {
+    return renderDialog({ isOpen: !!isOpen, onSave: saveConfirmInputFields, onCancel: cancelConfirmInputFields, children: content });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("dialog", { ref: dialogRef, className: "dynamic-form-modal", role: "dialog", "aria-modal": "true", "aria-label": FormStrings.confirm, onKeyDown: handleKeyDown, children: [
+    content,
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "dynamic-form-modal-actions", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", ref: saveButtonRef, onClick: saveConfirmInputFields, children: FormStrings.save }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", onClick: cancelConfirmInputFields, children: FormStrings.cancel })
+    ] })
+  ] });
+};
+var ConfirmInputsModal_default = ConfirmInputsModal;
+
+// src/components/InlineFormFields.tsx
+var import_react10 = __toESM(require("react"));
+
+// src/components/FormErrorBoundary.tsx
+var import_react9 = __toESM(require("react"));
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var FormErrorBoundary = class extends import_react9.default.Component {
+  constructor(props) {
+    super(props);
+    this.resetError = () => {
+      this.setState({ hasError: false, error: null });
+    };
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.props.onError?.(error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError && this.state.error) {
+      if (this.props.fallback) return this.props.fallback(this.state.error, this.resetError);
+      return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "form-error-boundary", role: "alert", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { className: "error-boundary-message", children: [
+          "Something went wrong: ",
+          this.state.error.message
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { className: "error-boundary-retry", onClick: this.resetError, type: "button", children: "Retry" })
+      ] });
+    }
+    return this.props.children;
+  }
+};
+
+// src/components/InlineFormFields.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var FormFields = (props) => {
+  const {
+    entityId,
+    entityType,
+    programName,
+    parentEntityId,
+    parentEntityType,
+    isExpanded,
+    expandEnabled,
+    fieldOrder,
+    inPanel,
+    collapsedMaxHeight,
+    formState,
+    fields,
+    setFieldValue,
+    isManualSave,
+    isCreate,
+    filterText,
+    fieldRenderLimit,
+    renderLabel,
+    renderError,
+    renderStatus,
+    analytics
+  } = props;
+  const collapsedClass = !isExpanded && (expandEnabled || expandEnabled === void 0) ? "collapsed" : "";
+  const fieldsToRender = GetFieldsToRender(fieldRenderLimit ?? 0, fieldOrder ?? [], formState?.fieldStates);
+  const loadingKey = `${programName}-${entityType}-${entityId}-form-loaded`;
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { className: `dynamic-form-container ${collapsedClass}`, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(
+    "form",
+    {
+      className: `dynamic-form ${collapsedClass} ${inPanel ? "in-panel" : ""}`,
+      style: collapsedClass && collapsedMaxHeight ? { maxHeight: `${collapsedMaxHeight}px` } : void 0,
+      "data-testid": `${programName}-${entityType}-${entityId}-form`,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("input", { type: "hidden", id: loadingKey, name: loadingKey, "data-testid": loadingKey }),
+        fieldsToRender?.map((fieldToRender) => {
+          const { fieldName, softHidden } = fieldToRender;
+          const fieldState = formState?.fieldStates[fieldName];
+          if (!fieldState) return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react10.default.Fragment, {}, fieldName);
+          const fieldConfig = fields[fieldName];
+          return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(FormErrorBoundary, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+            RenderField_default,
+            {
+              fieldName,
+              entityId,
+              entityType,
+              programName,
+              type: fieldState.type ?? "",
+              hidden: fieldState.hidden,
+              required: fieldState.required,
+              readOnly: fieldState.readOnly,
+              options: fieldState.options,
+              validate: fieldState.validate,
+              parentEntityId,
+              parentEntityType,
+              setFieldValue,
+              isManualSave,
+              isCreate,
+              filterText,
+              softHidden,
+              label: fieldState?.label ?? fieldConfig?.label,
+              skipLayoutReadOnly: fieldConfig?.skipLayoutReadOnly,
+              hideOnCreate: fieldConfig?.hideOnCreate,
+              config: fieldConfig?.config,
+              description: fieldConfig?.description,
+              placeholder: fieldConfig?.placeholder,
+              helpText: fieldConfig?.helpText,
+              renderLabel,
+              renderError,
+              renderStatus,
+              analytics
+            }
+          ) }, `${fieldName}-${entityId}-form`);
+        })
+      ]
+    }
+  ) });
+};
+
+// src/components/InlineForm.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var FormEngine = (props) => {
+  const {
+    configName,
+    entityId,
+    entityType,
+    programName,
+    parentEntityId,
+    parentEntityType,
+    entityPath,
+    expandCutoffCount,
+    formConfig,
+    defaultValues,
+    areAllFieldsReadonly,
+    collapsedMaxHeight,
+    isCreate,
+    parentEntity,
+    isChildEntity,
+    enableFilter,
+    currentUserId,
+    onSaveError,
+    isManualSave = false,
+    saveTimeoutMs = 3e4,
+    maxSaveRetries = 3,
+    renderExpandButton,
+    renderFilterInput,
+    renderDialog,
+    renderSaveButton,
+    formErrors,
+    renderLabel,
+    renderError,
+    renderStatus
+  } = props;
+  const fields = formConfig?.fields ?? props.fieldConfigs ?? {};
+  const formSettings = formConfig?.settings;
+  const effectiveManualSave = formSettings?.manualSave ?? isManualSave;
+  const effectiveSaveTimeout = formSettings?.saveTimeoutMs ?? saveTimeoutMs;
+  const effectiveMaxRetries = formSettings?.maxSaveRetries ?? maxSaveRetries;
+  const effectiveExpandCutoff = formSettings?.expandCutoffCount ?? expandCutoffCount;
+  const analytics = useFormAnalytics(formSettings?.analytics);
+  const saveData = props.saveData ? props.saveData : () => Promise.resolve({});
+  const { initFormState, processFieldChange, rulesState } = UseRulesEngineContext();
+  const saveTimeoutDelay = import_react11.default.useRef(void 0);
+  const saveTimeout = import_react11.default.useRef(void 0);
+  const confirmInputModalProps = import_react11.default.useRef(void 0);
+  const saveAbortControllerRef = import_react11.default.useRef(void 0);
+  const [isExpanded, setIsExpanded] = import_react11.default.useState(false);
+  const [expandEnabled, setExpandEnabled] = import_react11.default.useState();
+  const [inputFieldsConfirmed, setInputFieldsConfirmed] = import_react11.default.useState(true);
+  const [filterText, setFilterText] = import_react11.default.useState();
+  const [statusMessage, setStatusMessage] = import_react11.default.useState("");
+  const formMethods = (0, import_react_hook_form4.useForm)({ mode: "onChange", defaultValues });
+  const { reset, resetField, handleSubmit, trigger, setValue, getValues, setError, clearErrors, formState } = formMethods;
+  const rulesStateRef = import_react11.default.useRef(rulesState);
+  const formStateRef = import_react11.default.useRef({ ...formState });
+  const filterTimeoutRef = import_react11.default.useRef(void 0);
+  const validateAndSaveRef = import_react11.default.useRef(void 0);
+  const { isDirty, isValid, dirtyFields, errors, isSubmitting, isSubmitSuccessful } = formState;
+  import_react11.default.useEffect(() => {
+    rulesStateRef.current = rulesState;
+  }, [rulesState]);
+  import_react11.default.useEffect(() => {
+    formStateRef.current = formState;
+  }, [formState]);
+  import_react11.default.useEffect(() => {
+    initForm(defaultValues);
+  }, [areAllFieldsReadonly]);
+  const initForm = (entityData) => {
+    const { formState: loadedState, initEntityData } = isCreate ? InitOnCreateFormState(configName, fields, entityData, parentEntity ?? {}, currentUserId ?? "", setValue, initFormState) : InitOnEditFormState(configName, fields, entityData, areAllFieldsReadonly ?? false, initFormState);
+    setExpandEnabled(IsExpandVisible(loadedState.fieldStates, effectiveExpandCutoff));
+    CheckValidDropdownOptions(loadedState.fieldStates, initEntityData, setValue);
+  };
+  import_react11.default.useEffect(() => {
+    if (rulesState.configs[configName]) {
+      const cfg = rulesState.configs[configName];
+      CheckValidDropdownOptions(cfg.fieldStates, getValues(), setValue);
+      CheckDefaultValues(cfg.fieldStates, getValues(), setValue);
+      handleComputedValues();
+    }
+  }, [rulesState]);
+  const attemptSave = import_react11.default.useCallback(() => {
+    if (saveTimeout.current) {
+      clearTimeout(saveTimeout.current);
+      saveTimeout.current = void 0;
+    }
+    saveTimeout.current = setTimeout(() => {
+      validateAndSaveRef.current?.();
+      clearTimeout(saveTimeout.current);
+      saveTimeout.current = void 0;
+    }, saveTimeoutDelay?.current || 100);
+  }, []);
+  const setFieldValue = (fieldName, fieldValue, skipSave, timeout) => {
+    saveTimeoutDelay.current = timeout;
+    setValue(`${fieldName}`, fieldValue, { shouldDirty: !skipSave });
+    trigger(fieldName);
+    processFieldChange(getValues(), configName, fieldName, fields);
+    if (!skipSave && !effectiveManualSave) {
+      attemptSave();
+    }
+  };
+  const manualSave = import_react11.default.useCallback(() => {
+    validateAndSaveRef.current?.();
+  }, []);
+  const saveConfirmInputFields = () => {
+    trigger().then((valid) => {
+      if (valid) {
+        setInputFieldsConfirmed(true);
+        attemptSave();
+      }
+    });
+  };
+  const handleComputedValues = () => {
+    const { dirtyFields: dirtyFields2 } = formStateRef.current;
+    const currentRulesState = rulesStateRef.current;
+    const cfg = currentRulesState.configs[configName];
+    if (!cfg) return;
+    const computedValues = GetComputedValuesOnDirtyFields(Object.keys(dirtyFields2), cfg.fieldStates);
+    if (computedValues.length > 0) {
+      computedValues.forEach((cv) => {
+        const result = ExecuteComputedValue(cv.expression, getValues(), cv.fieldName);
+        setValue(`${cv.fieldName}`, result, { shouldDirty: true });
+      });
+    }
+  };
+  const focusFirstError = () => {
+    if (typeof document === "undefined") return;
+    const currentErrors = formStateRef.current.errors;
+    const errorFieldNames = Object.keys(currentErrors);
+    if (errorFieldNames.length > 0) {
+      const element = document.getElementById(errorFieldNames[0]) || document.querySelector(`[name="${errorFieldNames[0]}"]`);
+      if (element && typeof element.focus === "function") element.focus();
+    }
+  };
+  const validateAndSave = () => {
+    const { dirtyFields: dirtyFields2 } = formStateRef.current;
+    const currentRulesState = rulesStateRef.current;
+    const cfg = currentRulesState.configs[configName];
+    if (cfg?.fieldStates) {
+      Object.keys(cfg.fieldStates).forEach((fieldName) => {
+        if (cfg.fieldStates[fieldName]?.hidden) clearErrors(fieldName);
+      });
+    }
+    setStatusMessage(FormStrings.validating);
+    trigger().then((valid) => {
+      if (!valid) {
+        setIsExpanded(true);
+        setStatusMessage("");
+        (typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : setTimeout)(() => focusFirstError());
+      } else {
+        const newConfirmInputModalProps = confirmInputModalProps.current === void 0 ? GetConfirmInputModalProps(Object.keys(dirtyFields2), cfg?.fieldStates ?? {}) : void 0;
+        if (newConfirmInputModalProps && !isEmpty(newConfirmInputModalProps.confirmInputsTriggeredBy) && (newConfirmInputModalProps.dependentFieldNames?.length ?? 0) > 0) {
+          confirmInputModalProps.current = newConfirmInputModalProps;
+          setInputFieldsConfirmed(false);
+          setStatusMessage("");
+        } else if (dirtyFields2 && Object.keys(dirtyFields2).length > 0) {
+          setStatusMessage(FormStrings.saving);
+          handleSubmit(handleSave)();
+          confirmInputModalProps.current = void 0;
+        } else {
+          setStatusMessage("");
+        }
+      }
+    });
+  };
+  validateAndSaveRef.current = validateAndSave;
+  const handleSave = (data) => {
+    if (saveAbortControllerRef.current) saveAbortControllerRef.current.abort();
+    const abortController = new AbortController();
+    saveAbortControllerRef.current = abortController;
+    const dirtyFieldNames = Object.keys(formStateRef.current.dirtyFields);
+    const saveWithTimeoutAndRetry = async (attempt) => {
+      if (abortController.signal.aborted) return;
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(FormStrings.saveTimeout)), effectiveSaveTimeout);
+      });
+      try {
+        const updatedEntity = await Promise.race([saveData(data, dirtyFieldNames), timeoutPromise]);
+        if (abortController.signal.aborted) return;
+        setStatusMessage(FormStrings.saved);
+        analytics.trackFormSubmit(data);
+        if (!isCreate) handleDirtyFields(updatedEntity, data);
+      } catch (error) {
+        if (abortController.signal.aborted) return;
+        if (attempt < effectiveMaxRetries) {
+          const delay = Math.pow(2, attempt) * 1e3;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          if (abortController.signal.aborted) return;
+          return saveWithTimeoutAndRetry(attempt + 1);
+        }
+        setStatusMessage(FormStrings.saveFailed);
+        dirtyFieldNames.forEach((field) => {
+          setError(field, { type: "custom", message: FormStrings.saveError });
+        });
+        onSaveError?.(`${FormStrings.saveError}${error ? `: ${error}` : ""}`);
+      }
+    };
+    saveWithTimeoutAndRetry(0);
+  };
+  const handleDirtyFields = (entity, data) => {
+    const { dirtyFields: dirtyFields2 } = formStateRef.current;
+    const stillDirtyFields = {};
+    Object.keys(dirtyFields2).forEach((field) => {
+      stillDirtyFields[field] = getValues(field);
+    });
+    const resetValue = isChildEntity ? GetChildEntity(entityId, entity, entityPath) ?? entity : entity;
+    reset(resetValue);
+    Object.keys(stillDirtyFields).forEach((field) => {
+      if (JSON.stringify(stillDirtyFields[field]) !== JSON.stringify(data[field])) {
+        setFieldValue(field, stillDirtyFields[field], false, saveTimeoutDelay?.current);
+      }
+    });
+  };
+  const onFilterChange = import_react11.default.useCallback((value) => {
+    if (filterTimeoutRef.current) clearTimeout(filterTimeoutRef.current);
+    filterTimeoutRef.current = setTimeout(() => setFilterText(value), 500);
+  }, []);
+  const cancelConfirmInputFields = () => {
+    const current = confirmInputModalProps.current;
+    if (current && current.otherDirtyFields && current.otherDirtyFields.length > 0) {
+      if (current.confirmInputsTriggeredBy) resetField(current.confirmInputsTriggeredBy);
+      if (current.dependentFieldNames) current.dependentFieldNames.forEach((n) => resetField(n));
+      saveData(getValues(), current.otherDirtyFields).then((updatedEntity) => initForm(updatedEntity));
+    } else {
+      reset();
+      initForm(getValues());
+    }
+    setInputFieldsConfirmed(true);
+    confirmInputModalProps.current = void 0;
+  };
+  const cutoff = expandEnabled && !isExpanded ? effectiveExpandCutoff ?? FormConstants.defaultExpandCutoffCount : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_react_hook_form4.FormProvider, { ...formMethods, formState: { ...formMethods.formState, isDirty, isValid, dirtyFields, errors, isSubmitting, isSubmitSuccessful }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { role: "status", "aria-live": "polite", className: "sr-only", style: { position: "absolute", width: "1px", height: "1px", padding: 0, margin: "-1px", overflow: "hidden", clip: "rect(0, 0, 0, 0)", whiteSpace: "nowrap", border: 0 }, "data-testid": "form-status-live-region", children: statusMessage }),
+    enableFilter && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "dynamic-form-filter", children: renderFilterInput ? renderFilterInput({ onChange: onFilterChange }) : /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("input", { type: "text", placeholder: FormStrings.filterFields, "aria-label": FormStrings.filterFields, onChange: (e) => onFilterChange(e.target.value), className: "dynamic-form-filter-input" }) }),
+    formErrors && formErrors.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "form-errors", role: "alert", style: { color: "var(--form-error-color, #d13438)", padding: "8px", marginBottom: "8px" }, children: formErrors.map((err, i) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "form-error-item", children: err }, i)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: "dynamic-form-wrapper", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+        FormFields,
+        {
+          entityId,
+          entityType,
+          programName,
+          parentEntityId,
+          parentEntityType,
+          isExpanded,
+          expandEnabled,
+          fieldOrder: rulesState?.configs[configName]?.fieldOrder,
+          collapsedMaxHeight,
+          formState: rulesState?.configs[configName],
+          fields,
+          setFieldValue,
+          isManualSave: effectiveManualSave,
+          isCreate,
+          filterText,
+          fieldRenderLimit: cutoff,
+          renderLabel,
+          renderError,
+          renderStatus,
+          analytics
+        }
+      ),
+      expandEnabled && (renderExpandButton ? renderExpandButton({ isExpanded, onToggle: () => setIsExpanded(!isExpanded) }) : /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("button", { className: "expand-button", onClick: () => setIsExpanded(!isExpanded), "aria-expanded": isExpanded, "data-testid": `${programName}-${entityType}-${entityId}-expand-form`, children: isExpanded ? FormStrings.seeLess : FormStrings.expand })),
+      effectiveManualSave && (renderSaveButton ? renderSaveButton({ onSave: manualSave, isDirty, isValid, isSubmitting }) : /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: "dynamic-form-save-actions", style: { marginTop: "16px", display: "flex", gap: "8px" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("button", { type: "button", className: "save-button", onClick: manualSave, disabled: !isDirty || isSubmitting, children: isCreate ? FormStrings.create : FormStrings.save }),
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("button", { type: "button", className: "cancel-button", onClick: () => {
+          reset();
+          initForm(defaultValues);
+        }, disabled: !isDirty || isSubmitting, children: FormStrings.cancel })
+      ] }))
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+      ConfirmInputsModal_default,
+      {
+        isOpen: confirmInputModalProps !== void 0 && !inputFieldsConfirmed,
+        configName,
+        entityId,
+        entityType,
+        programName,
+        fields,
+        confirmInputFields: confirmInputModalProps?.current?.dependentFieldNames ?? [],
+        cancelConfirmInputFields,
+        saveConfirmInputFields,
+        renderDialog
+      }
+    )
+  ] });
+};
+
+// src/components/FormDevTools.tsx
+var import_react12 = __toESM(require("react"));
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var FormDevTools = (props) => {
+  const { configName, formState, formValues, formErrors, dirtyFields, enabled = true } = props;
+  const [isOpen, setIsOpen] = import_react12.default.useState(false);
+  const [activeTab, setActiveTab] = import_react12.default.useState("rules");
+  const [timelineFilter, setTimelineFilter] = import_react12.default.useState("");
+  const [depGraphSort, setDepGraphSort] = import_react12.default.useState("name");
+  const [, forceUpdate] = import_react12.default.useReducer((x) => x + 1, 0);
+  if (!enabled) return null;
+  const fieldStates = formState?.fieldStates ?? {};
+  const fieldNames = Object.keys(fieldStates);
+  const dependencyGraph = import_react12.default.useMemo(() => {
+    const lines = [];
+    for (const [name, state] of Object.entries(fieldStates)) {
+      if (state.dependentFields?.length) {
+        lines.push(`${name} -> ${state.dependentFields.join(", ")}`);
+      }
+      if (state.dependsOnFields?.length) {
+        lines.push(`${name} (depends on) ${state.dependsOnFields.join(", ")}`);
+      }
+    }
+    return lines;
+  }, [fieldStates]);
+  const containerStyle = {
+    position: "fixed",
+    bottom: 0,
+    right: 0,
+    width: isOpen ? "520px" : "auto",
+    maxHeight: isOpen ? "50vh" : "auto",
+    background: "#1e1e1e",
+    color: "#d4d4d4",
+    fontFamily: "monospace",
+    fontSize: "12px",
+    zIndex: 9999,
+    borderTopLeftRadius: "8px",
+    overflow: "hidden",
+    boxShadow: "0 -2px 10px rgba(0,0,0,0.3)"
+  };
+  const tabStyle = (active) => ({
+    padding: "4px 8px",
+    cursor: "pointer",
+    background: active ? "#333" : "transparent",
+    color: active ? "#fff" : "#888",
+    border: "none",
+    borderBottom: active ? "2px solid #007acc" : "2px solid transparent",
+    fontFamily: "monospace",
+    fontSize: "11px"
+  });
+  const thStyle = {
+    textAlign: "left",
+    padding: "3px 6px",
+    borderBottom: "1px solid #555",
+    fontWeight: "bold",
+    color: "#fff",
+    fontSize: "11px"
+  };
+  const tdStyle = {
+    padding: "3px 6px",
+    borderBottom: "1px solid #333",
+    fontSize: "11px"
+  };
+  const btnStyle = {
+    padding: "2px 8px",
+    margin: "0 4px",
+    cursor: "pointer",
+    background: "#333",
+    color: "#d4d4d4",
+    border: "1px solid #555",
+    fontFamily: "monospace",
+    fontSize: "10px",
+    borderRadius: "3px"
+  };
+  const renderPerformanceTab = () => {
+    const counts = getRenderCounts();
+    const lastRendered = getLastRenderedFields();
+    const totalRenders = getTotalFormRenders();
+    const entries = Array.from(counts.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    const avgCount = entries.length > 0 ? entries.reduce((sum, [, c]) => sum + c, 0) / entries.length : 0;
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { style: { marginBottom: "6px", display: "flex", alignItems: "center", gap: "8px" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("span", { children: [
+          "Total form renders: ",
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("strong", { style: { color: "#4ec9b0" }, children: totalRenders })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { style: btnStyle, onClick: () => {
+          resetRenderTracker();
+          forceUpdate();
+        }, children: "Reset" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { style: btnStyle, onClick: () => forceUpdate(), children: "Refresh" })
+      ] }),
+      entries.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { children: "No render data yet." }) : /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("table", { style: { width: "100%", borderCollapse: "collapse" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("tr", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Field" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Renders" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Last Cycle" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Hot" })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("tbody", { children: entries.map(([fieldName, count]) => {
+          const isHot = count > avgCount * 1.5;
+          const wasLastRendered = lastRendered.has(fieldName);
+          return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("tr", { style: isHot ? { background: "#3e2a00" } : void 0, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: fieldName }),
+            /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: { ...tdStyle, color: isHot ? "#ff9900" : "#d4d4d4" }, children: count }),
+            /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: wasLastRendered ? "\u2713" : "" }),
+            /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: isHot ? "\u26A0" : "" })
+          ] }, fieldName);
+        }) })
+      ] })
+    ] });
+  };
+  const renderDepGraphTab = () => {
+    const rows = [];
+    let hasCycles = false;
+    for (const [name, state] of Object.entries(fieldStates)) {
+      const dependsOn = state.dependsOnFields ?? [];
+      const dependedBy = state.dependentFields ?? [];
+      const effects = [];
+      if (state.hidden) effects.push("hidden");
+      if (state.required) effects.push("required");
+      if (state.readOnly) effects.push("readOnly");
+      if (state.options && state.options.length > 0 && dependsOn.length > 0) effects.push("options");
+      if (state.computedValue) effects.push("computed");
+      rows.push({ name, dependsOn, dependedBy, effects });
+    }
+    for (const row of rows) {
+      for (const dep of row.dependsOn) {
+        const depRow = rows.find((r) => r.name === dep);
+        if (depRow?.dependsOn.includes(row.name)) {
+          hasCycles = true;
+          break;
+        }
+      }
+      if (hasCycles) break;
+    }
+    const depRows = rows.filter((r) => r.dependsOn.length > 0 || r.dependedBy.length > 0);
+    if (depGraphSort === "name") {
+      depRows.sort((a, b) => a.name.localeCompare(b.name));
+    } else {
+      depRows.sort((a, b) => b.dependsOn.length + b.dependedBy.length - (a.dependsOn.length + a.dependedBy.length));
+    }
+    const effectColor = (effects) => {
+      if (effects.includes("hidden")) return { background: "#3e3a20" };
+      if (effects.includes("required")) return { background: "#1e2a3e" };
+      if (effects.includes("readOnly")) return { background: "#2a2a2a" };
+      if (effects.includes("options")) return { background: "#1e3a2a" };
+      return {};
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { style: { marginBottom: "6px", display: "flex", alignItems: "center", gap: "8px" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { children: "Sort by:" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { style: { ...btnStyle, borderColor: depGraphSort === "name" ? "#007acc" : "#555" }, onClick: () => setDepGraphSort("name"), children: "Name" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { style: { ...btnStyle, borderColor: depGraphSort === "depCount" ? "#007acc" : "#555" }, onClick: () => setDepGraphSort("depCount"), children: "Dep Count" }),
+        hasCycles && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { style: { color: "#f44747", fontWeight: "bold" }, children: "Cycles detected!" })
+      ] }),
+      depRows.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { children: "No dependencies defined." }) : /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("table", { style: { width: "100%", borderCollapse: "collapse" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("tr", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Field" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Depends On" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Depended By" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Effects" })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("tbody", { children: depRows.map((row) => /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("tr", { style: effectColor(row.effects), children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: row.name }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: row.dependsOn.join(", ") || "\u2014" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: row.dependedBy.join(", ") || "\u2014" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: row.effects.join(", ") || "\u2014" })
+        ] }, row.name)) })
+      ] })
+    ] });
+  };
+  const renderTimelineTab = () => {
+    const timeline2 = getTimeline();
+    const filterLower = timelineFilter.toLowerCase();
+    const filtered = filterLower ? timeline2.filter((e) => e.fieldName.toLowerCase().includes(filterLower) || e.type.toLowerCase().includes(filterLower)) : timeline2;
+    const reversed = [...filtered].reverse();
+    const typeColor = (type) => {
+      switch (type) {
+        case "field_change":
+          return "#4ec9b0";
+        case "rule_evaluated":
+          return "#ce9178";
+        case "validation_run":
+          return "#dcdcaa";
+        case "form_submit":
+          return "#569cd6";
+        default:
+          return "#d4d4d4";
+      }
+    };
+    const formatTime = (ts) => {
+      const d = new Date(ts);
+      return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}.${String(d.getMilliseconds()).padStart(3, "0")}`;
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { style: { marginBottom: "6px", display: "flex", alignItems: "center", gap: "8px" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          "input",
+          {
+            type: "text",
+            placeholder: "Filter by field or type...",
+            value: timelineFilter,
+            onChange: (e) => setTimelineFilter(e.target.value),
+            style: {
+              padding: "2px 6px",
+              background: "#2d2d2d",
+              color: "#d4d4d4",
+              border: "1px solid #555",
+              fontFamily: "monospace",
+              fontSize: "11px",
+              borderRadius: "3px",
+              flex: 1
+            }
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { style: btnStyle, onClick: () => {
+          clearTimeline();
+          forceUpdate();
+        }, children: "Clear" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { style: btnStyle, onClick: () => forceUpdate(), children: "Refresh" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { style: { fontSize: "10px", color: "#888", marginBottom: "4px" }, children: [
+        filtered.length,
+        " event",
+        filtered.length !== 1 ? "s" : ""
+      ] }),
+      reversed.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { children: "No events recorded yet." }) : /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("table", { style: { width: "100%", borderCollapse: "collapse" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("tr", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Time" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Type" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Field" }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("th", { style: thStyle, children: "Details" })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("tbody", { children: reversed.slice(0, 200).map((event, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("tr", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: { ...tdStyle, whiteSpace: "nowrap", color: "#888" }, children: formatTime(event.timestamp) }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: { ...tdStyle, color: typeColor(event.type), whiteSpace: "nowrap" }, children: event.type }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: tdStyle, children: event.fieldName }),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("td", { style: { ...tdStyle, maxWidth: "200px", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: event.details })
+        ] }, i)) })
+      ] })
+    ] });
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { style: containerStyle, "data-testid": "form-devtools", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("button", { type: "button", "aria-expanded": isOpen, "aria-controls": "devtools-content", style: { width: "100%", padding: "4px 8px", cursor: "pointer", background: "#333", display: "flex", justifyContent: "space-between", alignItems: "center", border: "none", color: "inherit", font: "inherit" }, onClick: () => setIsOpen(!isOpen), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("span", { style: { color: "#007acc", fontWeight: "bold" }, children: [
+        "DevTools: ",
+        configName
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { "aria-hidden": "true", children: isOpen ? "\u25BC" : "\u25B2" })
+    ] }),
+    isOpen && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { role: "tablist", "aria-label": "DevTools panels", style: { display: "flex", borderBottom: "1px solid #333", flexWrap: "wrap" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("button", { role: "tab", "aria-selected": activeTab === "rules", "aria-controls": "devtools-panel-rules", style: tabStyle(activeTab === "rules"), onClick: () => setActiveTab("rules"), children: [
+          "Rules (",
+          fieldNames.length,
+          ")"
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { role: "tab", "aria-selected": activeTab === "values", "aria-controls": "devtools-panel-values", style: tabStyle(activeTab === "values"), onClick: () => setActiveTab("values"), children: "Values" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { role: "tab", "aria-selected": activeTab === "errors", "aria-controls": "devtools-panel-errors", style: tabStyle(activeTab === "errors"), onClick: () => setActiveTab("errors"), children: "Errors" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { role: "tab", "aria-selected": activeTab === "graph", "aria-controls": "devtools-panel-graph", style: tabStyle(activeTab === "graph"), onClick: () => setActiveTab("graph"), children: "Graph" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { role: "tab", "aria-selected": activeTab === "performance", "aria-controls": "devtools-panel-performance", style: tabStyle(activeTab === "performance"), onClick: () => {
+          setActiveTab("performance");
+          forceUpdate();
+        }, children: "Perf" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { role: "tab", "aria-selected": activeTab === "depgraph", "aria-controls": "devtools-panel-depgraph", style: tabStyle(activeTab === "depgraph"), onClick: () => setActiveTab("depgraph"), children: "Deps" }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { role: "tab", "aria-selected": activeTab === "timeline", "aria-controls": "devtools-panel-timeline", style: tabStyle(activeTab === "timeline"), onClick: () => {
+          setActiveTab("timeline");
+          forceUpdate();
+        }, children: "Timeline" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { role: "tabpanel", id: `devtools-panel-${activeTab}`, "aria-label": activeTab, style: { overflow: "auto", maxHeight: "calc(50vh - 60px)", padding: "8px" }, children: [
+        activeTab === "rules" && fieldNames.map((name) => {
+          const state = fieldStates[name];
+          return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { style: { marginBottom: "8px", borderBottom: "1px solid #333", paddingBottom: "4px" }, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { style: { color: "#4ec9b0" }, children: name }),
+            /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+              "type: ",
+              state.type ?? "\u2014",
+              " | required: ",
+              String(state.required ?? false),
+              " | hidden: ",
+              String(state.hidden ?? false),
+              " | readOnly: ",
+              String(state.readOnly ?? false)
+            ] }),
+            state.validate?.length ? /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+              "validate: ",
+              state.validate.map((v) => v.name).join(", ")
+            ] }) : null,
+            state.computedValue ? /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+              "computedValue: ",
+              state.computedValue
+            ] }) : null,
+            state.activeRuleIds?.length ? /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+              "activeRules: ",
+              state.activeRuleIds.join(", ")
+            ] }) : null
+          ] }, name);
+        }),
+        activeTab === "values" && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("pre", { style: { margin: 0, whiteSpace: "pre-wrap" }, children: JSON.stringify(formValues, null, 2) }),
+        activeTab === "errors" && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("pre", { style: { margin: 0, whiteSpace: "pre-wrap", color: formErrors && Object.keys(formErrors).length > 0 ? "#f44747" : "#4ec9b0" }, children: formErrors && Object.keys(formErrors).length > 0 ? JSON.stringify(formErrors, null, 2) : "No errors" }),
+        activeTab === "graph" && (dependencyGraph.length > 0 ? dependencyGraph.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { style: { color: "#ce9178" }, children: line }, i)) : /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { children: "No dependencies defined" })),
+        activeTab === "performance" && renderPerformanceTab(),
+        activeTab === "depgraph" && renderDepGraphTab(),
+        activeTab === "timeline" && renderTimelineTab()
+      ] })
+    ] })
+  ] });
+};
+
+// src/utils/rjsf/refResolver.ts
+function resolveRefs(schema) {
+  const defs = {
+    ...schema.definitions ?? {},
+    ...schema.$defs ?? {}
+  };
+  const resolved = resolveNode(schema, defs, /* @__PURE__ */ new Set());
+  const { definitions: _d, $defs: _dd, ...clean } = resolved;
+  return clean;
+}
+function resolveNode(node, defs, visited) {
+  if (node.$ref) {
+    const refPath = node.$ref;
+    if (visited.has(refPath)) {
+      return { type: "string" };
+    }
+    const resolved = lookupRef(refPath, defs);
+    if (!resolved) {
+      return { type: "string" };
+    }
+    visited.add(refPath);
+    const { $ref: _ref, ...siblings } = node;
+    const inlined = resolveNode({ ...resolved, ...siblings }, defs, visited);
+    visited.delete(refPath);
+    return inlined;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "definitions" || key === "$defs") {
+      continue;
+    }
+    if (key === "properties" && value && typeof value === "object") {
+      const props = {};
+      for (const [propName, propValue] of Object.entries(
+        value
+      )) {
+        props[propName] = resolveNode(propValue, defs, visited);
+      }
+      result.properties = props;
+    } else if (key === "items") {
+      if (Array.isArray(value)) {
+        result.items = value.map(
+          (item) => resolveNode(item, defs, visited)
+        );
+      } else if (value && typeof value === "object") {
+        result.items = resolveNode(value, defs, visited);
+      }
+    } else if ((key === "allOf" || key === "oneOf" || key === "anyOf") && Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => resolveNode(item, defs, visited)
+      );
+    } else if (key === "if" || key === "then" || key === "else") {
+      if (value && typeof value === "object") {
+        result[key] = resolveNode(
+          value,
+          defs,
+          visited
+        );
+      }
+    } else if (key === "dependencies" && value && typeof value === "object") {
+      const deps = {};
+      for (const [depName, depValue] of Object.entries(
+        value
+      )) {
+        if (Array.isArray(depValue)) {
+          deps[depName] = depValue;
+        } else if (typeof depValue === "object" && depValue !== null) {
+          deps[depName] = resolveNode(
+            depValue,
+            defs,
+            visited
+          );
+        }
+      }
+      result.dependencies = deps;
+    } else if (key === "additionalProperties" && value && typeof value === "object") {
+      result.additionalProperties = resolveNode(
+        value,
+        defs,
+        visited
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function lookupRef(ref, defs) {
+  const match = ref.match(/^#\/(?:definitions|\$defs)\/(.+)$/);
+  if (!match) return void 0;
+  const path = match[1];
+  const parts = path.split("/");
+  let current = defs[parts[0]];
+  for (let i = 1; i < parts.length && current; i++) {
+    current = current[parts[i]];
+  }
+  return current;
+}
+
+// src/utils/rjsf/fieldMapper.ts
+var WIDGET_MAP = {
+  text: "Textbox",
+  textarea: "Textarea",
+  password: "Textbox",
+  color: "Textbox",
+  hidden: "DynamicFragment",
+  select: "Dropdown",
+  radio: "Dropdown",
+  checkboxes: "Multiselect",
+  updown: "Number",
+  range: "Slider",
+  date: "DateControl",
+  datetime: "DateControl",
+  "date-time": "DateControl",
+  file: "DocumentLinks",
+  checkbox: "Toggle"
+};
+var WIDGET_CONFIG = {
+  password: { type: "password" },
+  color: { type: "color" },
+  radio: { display: "radio" },
+  checkboxes: { display: "checkboxes" }
+};
+function schemaNodeToFieldConfig(fieldName, node, isRequired) {
+  const type = mapTypeToComponent(node);
+  const validate = extractValidationRules(node);
+  const options = extractOptions(node);
+  const config = {
+    type,
+    label: node.title ?? fieldName,
+    required: isRequired
+  };
+  if (validate.length > 0) config.validate = validate;
+  if (options) config.options = options;
+  if (node.default !== void 0) config.defaultValue = node.default;
+  if (node.description) config.description = node.description;
+  if (node.const !== void 0) {
+    config.readOnly = true;
+    config.defaultValue = node.const;
+  }
+  return config;
+}
+function extractValidationRules(node) {
+  const rules = [];
+  if (node.minLength !== void 0) {
+    rules.push({ name: "minLength", params: { min: node.minLength } });
+  }
+  if (node.maxLength !== void 0) {
+    rules.push({ name: "maxLength", params: { max: node.maxLength } });
+  }
+  if (node.pattern) {
+    rules.push({
+      name: "pattern",
+      params: { pattern: node.pattern, message: "Must match pattern" }
+    });
+  }
+  const hasMin = node.minimum !== void 0;
+  const hasMax = node.maximum !== void 0;
+  const hasExclMin = node.exclusiveMinimum !== void 0;
+  const hasExclMax = node.exclusiveMaximum !== void 0;
+  if (hasExclMin || hasExclMax) {
+    rules.push({
+      name: "exclusiveNumericRange",
+      params: {
+        exclusiveMin: node.exclusiveMinimum,
+        exclusiveMax: node.exclusiveMaximum,
+        min: node.minimum,
+        max: node.maximum
+      }
+    });
+  } else if (hasMin || hasMax) {
+    rules.push({
+      name: "numericRange",
+      params: {
+        min: node.minimum ?? -Infinity,
+        max: node.maximum ?? Infinity
+      }
+    });
+  }
+  if (node.multipleOf !== void 0) {
+    rules.push({
+      name: "multipleOf",
+      params: { factor: node.multipleOf }
+    });
+  }
+  if (node.format === "email") rules.push({ name: "email" });
+  if (node.format === "uri" || node.format === "url") rules.push({ name: "url" });
+  if (node.format === "phone") rules.push({ name: "phone" });
+  if (node.uniqueItems) {
+    rules.push({ name: "uniqueInArray" });
+  }
+  return rules;
+}
+function applyUiSchema(config, uiSchema) {
+  const result = { ...config };
+  const widget = uiSchema["ui:widget"];
+  if (typeof widget === "string" && WIDGET_MAP[widget]) {
+    result.type = WIDGET_MAP[widget];
+    const extraConfig = WIDGET_CONFIG[widget];
+    if (extraConfig) {
+      result.config = { ...result.config ?? {}, ...extraConfig };
+    }
+  }
+  if (uiSchema["ui:title"]) result.label = uiSchema["ui:title"];
+  if (uiSchema["ui:description"])
+    result.description = uiSchema["ui:description"];
+  if (uiSchema["ui:help"]) result.helpText = uiSchema["ui:help"];
+  if (uiSchema["ui:placeholder"])
+    result.placeholder = uiSchema["ui:placeholder"];
+  if (uiSchema["ui:hidden"] === true) result.hidden = true;
+  if (uiSchema["ui:readonly"] === true) result.readOnly = true;
+  if (uiSchema["ui:disabled"] === true) result.disabled = true;
+  if (uiSchema["ui:autofocus"] === true) {
+    result.config = { ...result.config ?? {}, autofocus: true };
+  }
+  if (uiSchema["ui:classNames"]) {
+    result.config = {
+      ...result.config ?? {},
+      className: uiSchema["ui:classNames"]
+    };
+  }
+  if (uiSchema["ui:options"] && typeof uiSchema["ui:options"] === "object") {
+    result.config = { ...result.config ?? {}, ...uiSchema["ui:options"] };
+  }
+  if (uiSchema["ui:label"] === false) {
+    result.config = { ...result.config ?? {}, hideLabel: true };
+  }
+  const enumDisabled = uiSchema["ui:enumDisabled"];
+  if (Array.isArray(enumDisabled) && result.options) {
+    result.options = result.options.map((opt) => ({
+      ...opt,
+      disabled: enumDisabled.includes(opt.value) ? true : opt.disabled
+    }));
+  }
+  const enumNames = uiSchema["ui:enumNames"];
+  if (Array.isArray(enumNames) && result.options) {
+    result.options = result.options.map((opt, i) => ({
+      ...opt,
+      label: enumNames[i] != null ? String(enumNames[i]) : opt.label
+    }));
+  }
+  return result;
+}
+function mapTypeToComponent(node) {
+  if (node.enum) return "Dropdown";
+  if (node.const !== void 0) return "Textbox";
+  const type = resolveType(node);
+  switch (type) {
+    case "string":
+      if (node.format === "date" || node.format === "date-time") return "DateControl";
+      if (node.format === "data-url") return "DocumentLinks";
+      if (node.maxLength && node.maxLength > 200) return "Textarea";
+      return "Textbox";
+    case "number":
+    case "integer":
+      if (node.minimum !== void 0 && node.maximum !== void 0) return "Slider";
+      return "Number";
+    case "boolean":
+      return "Toggle";
+    case "array":
+      return mapArrayType(node);
+    case "object":
+      return "Textbox";
+    // Objects handled at converter level
+    default:
+      return "Textbox";
+  }
+}
+function resolveType(node) {
+  if (!node.type) return "string";
+  if (typeof node.type === "string") return node.type;
+  const nonNull = node.type.filter((t) => t !== "null");
+  return nonNull[0] ?? "string";
+}
+function mapArrayType(node) {
+  const items = node.items;
+  if (!items || Array.isArray(items)) return "Multiselect";
+  if (items.enum) return "Multiselect";
+  if (items.type === "object" && items.properties) return "FieldArray";
+  return "Multiselect";
+}
+function extractOptions(node) {
+  if (!node.enum) return void 0;
+  const names = node.enumNames;
+  return node.enum.map((val, i) => ({
+    value: String(val),
+    label: names && names[i] != null ? String(names[i]) : String(val)
+  }));
+}
+
+// src/utils/rjsf/ruleConverter.ts
+function convertDependencies(dependencies, fields, rootSchema, idPrefix) {
+  for (const [sourceField, dep] of Object.entries(dependencies)) {
+    if (Array.isArray(dep)) {
+      for (const dependentField of dep) {
+        if (!fields[dependentField]) continue;
+        const rule = {
+          id: `${idPrefix}_dep_${sourceField}_${dependentField}`,
+          when: { field: sourceField, operator: "isNotEmpty" },
+          then: { required: true },
+          else: { required: false }
+        };
+        fields[dependentField].rules = [
+          ...fields[dependentField].rules ?? [],
+          rule
+        ];
+      }
+    } else {
+      convertSchemaDependency(sourceField, dep, fields, rootSchema, idPrefix);
+    }
+  }
+}
+function convertIfThenElse(schema, fields, rootSchema, idPrefix) {
+  const condition = schemaToCondition(schema.if);
+  if (!condition) return;
+  const thenSchema = schema.then;
+  const elseSchema = schema.else;
+  const affectedFields = /* @__PURE__ */ new Set();
+  if (thenSchema?.properties) {
+    Object.keys(thenSchema.properties).forEach((f) => affectedFields.add(f));
+  }
+  if (thenSchema?.required) {
+    thenSchema.required.forEach((f) => affectedFields.add(f));
+  }
+  if (elseSchema?.properties) {
+    Object.keys(elseSchema.properties).forEach((f) => affectedFields.add(f));
+  }
+  if (elseSchema?.required) {
+    elseSchema.required.forEach((f) => affectedFields.add(f));
+  }
+  for (const fieldName of affectedFields) {
+    if (!fields[fieldName] && thenSchema?.properties?.[fieldName]) {
+      fields[fieldName] = schemaNodeToFieldConfig(
+        fieldName,
+        thenSchema.properties[fieldName],
+        false
+      );
+      fields[fieldName].hidden = true;
+    }
+    if (!fields[fieldName] && elseSchema?.properties?.[fieldName]) {
+      fields[fieldName] = schemaNodeToFieldConfig(
+        fieldName,
+        elseSchema.properties[fieldName],
+        false
+      );
+      fields[fieldName].hidden = true;
+    }
+    if (!fields[fieldName]) continue;
+    const thenEffect = {};
+    const elseEffect = {};
+    if (thenSchema?.properties?.[fieldName]) {
+      thenEffect.hidden = false;
+    }
+    if (elseSchema?.properties?.[fieldName]) {
+      elseEffect.hidden = false;
+    }
+    if (thenSchema?.properties?.[fieldName] && !elseSchema?.properties?.[fieldName]) {
+      elseEffect.hidden = true;
+    }
+    if (!thenSchema?.properties?.[fieldName] && elseSchema?.properties?.[fieldName]) {
+      thenEffect.hidden = true;
+    }
+    if (thenSchema?.required?.includes(fieldName)) {
+      thenEffect.required = true;
+    }
+    if (elseSchema?.required?.includes(fieldName)) {
+      elseEffect.required = true;
+    }
+    const rule = {
+      id: `${idPrefix}_ite_${fieldName}`,
+      when: condition,
+      then: thenEffect
+    };
+    if (Object.keys(elseEffect).length > 0) {
+      rule.else = elseEffect;
+    }
+    fields[fieldName].rules = [...fields[fieldName].rules ?? [], rule];
+  }
+}
+function convertComposition(schema, fields, rootSchema, idPrefix) {
+  const variants = schema.oneOf ?? schema.anyOf;
+  if (!variants || variants.length === 0) return;
+  const compositionType = schema.oneOf ? "oneOf" : "anyOf";
+  const discriminator = findDiscriminator(variants);
+  if (discriminator) {
+    convertWithDiscriminator(
+      discriminator,
+      variants,
+      fields,
+      rootSchema,
+      idPrefix,
+      compositionType
+    );
+  } else {
+    convertWithSyntheticDiscriminator(
+      variants,
+      fields,
+      rootSchema,
+      idPrefix,
+      compositionType
+    );
+  }
+}
+function schemaToCondition(schema) {
+  if (!schema) return null;
+  if (schema.not) {
+    const inner = schemaToCondition(schema.not);
+    if (!inner) return null;
+    return { operator: "not", conditions: [inner] };
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    const conditions = schema.allOf.map((s) => schemaToCondition(s)).filter((c) => c !== null);
+    if (conditions.length === 0) return null;
+    if (conditions.length === 1) return conditions[0];
+    return { operator: "and", conditions };
+  }
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    const conditions = schema.anyOf.map((s) => schemaToCondition(s)).filter((c) => c !== null);
+    if (conditions.length === 0) return null;
+    if (conditions.length === 1) return conditions[0];
+    return { operator: "or", conditions };
+  }
+  if (schema.required && !schema.properties) {
+    const conditions = schema.required.map((field) => ({
+      field,
+      operator: "isNotEmpty"
+    }));
+    if (conditions.length === 1) return conditions[0];
+    return { operator: "and", conditions };
+  }
+  if (schema.properties) {
+    const conditions = [];
+    for (const [field, propSchema] of Object.entries(schema.properties)) {
+      const condition = propertySchemaToCondition(field, propSchema);
+      if (condition) conditions.push(condition);
+    }
+    if (schema.required) {
+      for (const field of schema.required) {
+        if (!schema.properties[field]) {
+          conditions.push({ field, operator: "isNotEmpty" });
+        }
+      }
+    }
+    if (conditions.length === 0) return null;
+    if (conditions.length === 1) return conditions[0];
+    return { operator: "and", conditions };
+  }
+  return null;
+}
+function propertySchemaToCondition(field, schema) {
+  if (schema.const !== void 0) {
+    return { field, operator: "equals", value: schema.const };
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    return { field, operator: "in", value: schema.enum };
+  }
+  if (schema.minimum !== void 0) {
+    return { field, operator: "greaterThanOrEqual", value: schema.minimum };
+  }
+  if (schema.maximum !== void 0) {
+    return { field, operator: "lessThanOrEqual", value: schema.maximum };
+  }
+  if (schema.minLength !== void 0 && schema.minLength > 0) {
+    return { field, operator: "isNotEmpty" };
+  }
+  if (schema.pattern) {
+    return { field, operator: "matches", value: schema.pattern };
+  }
+  return null;
+}
+function convertSchemaDependency(sourceField, depSchema, fields, rootSchema, idPrefix) {
+  const depRequired = new Set(depSchema.required ?? []);
+  if (depSchema.properties) {
+    for (const [depFieldName, depFieldSchema] of Object.entries(
+      depSchema.properties
+    )) {
+      if (!fields[depFieldName]) {
+        fields[depFieldName] = schemaNodeToFieldConfig(
+          depFieldName,
+          depFieldSchema,
+          depRequired.has(depFieldName)
+        );
+        fields[depFieldName].hidden = true;
+      }
+      const rule = {
+        id: `${idPrefix}_schemadep_${sourceField}_${depFieldName}`,
+        when: { field: sourceField, operator: "isNotEmpty" },
+        then: {
+          hidden: false,
+          ...depRequired.has(depFieldName) ? { required: true } : {}
+        },
+        else: {
+          hidden: true
+        }
+      };
+      fields[depFieldName].rules = [
+        ...fields[depFieldName].rules ?? [],
+        rule
+      ];
+    }
+  }
+  if (depSchema.oneOf) {
+    convertComposition(
+      depSchema,
+      fields,
+      rootSchema,
+      `${idPrefix}_schemadep_${sourceField}`
+    );
+  }
+}
+function findDiscriminator(variants) {
+  if (variants.length < 2) return null;
+  const firstVariant = variants[0];
+  if (!firstVariant.properties) return null;
+  for (const propName of Object.keys(firstVariant.properties)) {
+    const prop = firstVariant.properties[propName];
+    if (!hasConstOrSingleEnum(prop)) continue;
+    const allHave = variants.every(
+      (v) => v.properties?.[propName] && hasConstOrSingleEnum(v.properties[propName])
+    );
+    if (allHave) {
+      const values = variants.map(
+        (v) => getConstValue(v.properties[propName])
+      );
+      const unique = new Set(values.map(String));
+      if (unique.size === variants.length) return propName;
+    }
+  }
+  return null;
+}
+function hasConstOrSingleEnum(node) {
+  if (node.const !== void 0) return true;
+  if (node.enum && node.enum.length === 1) return true;
+  return false;
+}
+function getConstValue(node) {
+  if (node.const !== void 0) return node.const;
+  if (node.enum && node.enum.length === 1) return node.enum[0];
+  return void 0;
+}
+function convertWithDiscriminator(discriminatorField, variants, fields, rootSchema, idPrefix, compositionType) {
+  const allValues = variants.map(
+    (v) => getConstValue(v.properties[discriminatorField])
+  );
+  if (!fields[discriminatorField]) {
+    fields[discriminatorField] = {
+      type: "Dropdown",
+      label: discriminatorField,
+      options: allValues.map((v) => ({
+        value: String(v),
+        label: String(v)
+      }))
+    };
+  }
+  for (const variant of variants) {
+    if (!variant.properties) continue;
+    const variantValue = getConstValue(variant.properties[discriminatorField]);
+    const variantRequired = new Set(variant.required ?? []);
+    for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+      if (fieldName === discriminatorField) continue;
+      if (!fields[fieldName]) {
+        fields[fieldName] = schemaNodeToFieldConfig(
+          fieldName,
+          fieldSchema,
+          variantRequired.has(fieldName)
+        );
+        fields[fieldName].hidden = true;
+      }
+      const rule = {
+        id: `${idPrefix}_${compositionType}_${discriminatorField}_${fieldName}`,
+        when: {
+          field: discriminatorField,
+          operator: "equals",
+          value: variantValue
+        },
+        then: {
+          hidden: false,
+          ...variantRequired.has(fieldName) ? { required: true } : {}
+        },
+        else: { hidden: true }
+      };
+      fields[fieldName].rules = [
+        ...fields[fieldName].rules ?? [],
+        rule
+      ];
+    }
+  }
+}
+function convertWithSyntheticDiscriminator(variants, fields, rootSchema, idPrefix, compositionType) {
+  const options = variants.map((_, i) => ({
+    value: String(i),
+    label: `Option ${i + 1}`
+  }));
+  fields["_variant"] = {
+    type: "Dropdown",
+    label: "Variant",
+    options
+  };
+  for (let i = 0; i < variants.length; i++) {
+    const variant = variants[i];
+    if (!variant.properties) continue;
+    const variantRequired = new Set(variant.required ?? []);
+    for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+      if (!fields[fieldName]) {
+        fields[fieldName] = schemaNodeToFieldConfig(
+          fieldName,
+          fieldSchema,
+          variantRequired.has(fieldName)
+        );
+        fields[fieldName].hidden = true;
+      }
+      const rule = {
+        id: `${idPrefix}_${compositionType}_variant${i}_${fieldName}`,
+        when: {
+          field: "_variant",
+          operator: "equals",
+          value: String(i)
+        },
+        then: {
+          hidden: false,
+          ...variantRequired.has(fieldName) ? { required: true } : {}
+        },
+        else: { hidden: true }
+      };
+      fields[fieldName].rules = [
+        ...fields[fieldName].rules ?? [],
+        rule
+      ];
+    }
+  }
+}
+
+// src/utils/rjsf/converter.ts
+function fromRjsfSchema(schema, uiSchema, formData, options) {
+  const strategy = options?.nestedObjectStrategy ?? "flatten";
+  const idPrefix = options?.ruleIdPrefix ?? "rjsf";
+  const resolved = resolveRefs(schema);
+  const merged = mergeAllOf(resolved);
+  const fields = {};
+  const requiredSet = new Set(merged.required ?? []);
+  if (merged.properties) {
+    mapProperties(
+      merged.properties,
+      requiredSet,
+      fields,
+      "",
+      strategy,
+      uiSchema,
+      formData
+    );
+  }
+  if (merged.dependencies) {
+    convertDependencies(merged.dependencies, fields, merged, idPrefix);
+  }
+  if (merged.if) {
+    convertIfThenElse(merged, fields, merged, idPrefix);
+  }
+  if (merged.oneOf || merged.anyOf) {
+    convertComposition(merged, fields, merged, idPrefix);
+  }
+  const fieldOrder = resolveFieldOrder(fields, uiSchema);
+  return {
+    version: 2,
+    fields,
+    fieldOrder
+  };
+}
+function mapProperties(properties, requiredSet, fields, prefix, strategy, uiSchema, formData) {
+  for (const [propName, propSchema] of Object.entries(properties)) {
+    const fullName = prefix ? `${prefix}.${propName}` : propName;
+    const isRequired = requiredSet.has(propName);
+    if (isObjectType(propSchema) && propSchema.properties) {
+      if (strategy === "flatten") {
+        const nestedRequired = new Set(propSchema.required ?? []);
+        const nestedUiSchema = uiSchema?.[propName];
+        const nestedFormData = formData?.[propName];
+        mapProperties(
+          propSchema.properties,
+          nestedRequired,
+          fields,
+          fullName,
+          strategy,
+          nestedUiSchema,
+          nestedFormData
+        );
+        continue;
+      } else {
+        const items = {};
+        const nestedRequired = new Set(propSchema.required ?? []);
+        for (const [itemProp, itemSchema] of Object.entries(
+          propSchema.properties
+        )) {
+          items[itemProp] = schemaNodeToFieldConfig(
+            itemProp,
+            itemSchema,
+            nestedRequired.has(itemProp)
+          );
+        }
+        fields[fullName] = {
+          type: "FieldArray",
+          label: propSchema.title ?? propName,
+          items
+        };
+        continue;
+      }
+    }
+    if (isArrayWithObjectItems(propSchema)) {
+      const itemSchema = propSchema.items;
+      const items = {};
+      const itemRequired = new Set(itemSchema.required ?? []);
+      if (itemSchema.properties) {
+        for (const [itemProp, itemPropSchema] of Object.entries(
+          itemSchema.properties
+        )) {
+          items[itemProp] = schemaNodeToFieldConfig(
+            itemProp,
+            itemPropSchema,
+            itemRequired.has(itemProp)
+          );
+        }
+      }
+      const config2 = schemaNodeToFieldConfig(fullName, propSchema, isRequired);
+      config2.type = "FieldArray";
+      config2.items = items;
+      if (propSchema.minItems !== void 0) config2.minItems = propSchema.minItems;
+      if (propSchema.maxItems !== void 0) config2.maxItems = propSchema.maxItems;
+      fields[fullName] = config2;
+      const fieldUiSchema2 = getFieldUiSchema(uiSchema, propName, prefix);
+      if (fieldUiSchema2) {
+        fields[fullName] = applyUiSchema(fields[fullName], fieldUiSchema2);
+      }
+      const dataValue2 = getFormDataValue(formData, propName);
+      if (dataValue2 !== void 0 && fields[fullName].defaultValue === void 0) {
+        fields[fullName].defaultValue = dataValue2;
+      }
+      continue;
+    }
+    const config = schemaNodeToFieldConfig(fullName, propSchema, isRequired);
+    fields[fullName] = config;
+    const fieldUiSchema = getFieldUiSchema(uiSchema, propName, prefix);
+    if (fieldUiSchema) {
+      fields[fullName] = applyUiSchema(fields[fullName], fieldUiSchema);
+    }
+    const dataValue = getFormDataValue(formData, propName);
+    if (dataValue !== void 0 && fields[fullName].defaultValue === void 0) {
+      fields[fullName].defaultValue = dataValue;
+    }
+  }
+}
+function mergeAllOf(schema) {
+  if (!schema.allOf || schema.allOf.length === 0) return schema;
+  const { allOf, ...base } = schema;
+  let result = { ...base };
+  for (const subSchema of allOf) {
+    result = mergeSchemas(result, subSchema);
+  }
+  return result;
+}
+function mergeSchemas(a, b) {
+  const result = { ...a };
+  if (b.properties) {
+    result.properties = { ...result.properties ?? {}, ...b.properties };
+  }
+  if (b.required) {
+    const existing = new Set(result.required ?? []);
+    for (const r of b.required) existing.add(r);
+    result.required = [...existing];
+  }
+  if (b.if) result.if = b.if;
+  if (b.then) result.then = b.then;
+  if (b.else) result.else = b.else;
+  if (b.dependencies) {
+    result.dependencies = {
+      ...result.dependencies ?? {},
+      ...b.dependencies
+    };
+  }
+  return result;
+}
+function isObjectType(node) {
+  if (node.type === "object") return true;
+  if (Array.isArray(node.type) && node.type.includes("object")) return true;
+  return false;
+}
+function isArrayWithObjectItems(node) {
+  const type = Array.isArray(node.type) ? node.type[0] : node.type;
+  if (type !== "array") return false;
+  const items = node.items;
+  if (!items || Array.isArray(items)) return false;
+  return items.type === "object" && !!items.properties;
+}
+function getFieldUiSchema(uiSchema, fieldName, prefix) {
+  if (!uiSchema) return void 0;
+  if (prefix) {
+    const parts = prefix.split(".");
+    let current = uiSchema;
+    for (const part of parts) {
+      current = current?.[part];
+    }
+    return current?.[fieldName];
+  }
+  return uiSchema[fieldName];
+}
+function getFormDataValue(formData, fieldName) {
+  if (!formData) return void 0;
+  return formData[fieldName];
+}
+function resolveFieldOrder(fields, uiSchema) {
+  const uiOrder = uiSchema?.["ui:order"];
+  if (!Array.isArray(uiOrder)) return Object.keys(fields);
+  const allFields = new Set(Object.keys(fields));
+  const order = [];
+  const wildcardIdx = uiOrder.indexOf("*");
+  for (const item of uiOrder) {
+    if (item === "*") continue;
+    if (allFields.has(item)) {
+      order.push(item);
+      allFields.delete(item);
+    }
+  }
+  if (wildcardIdx !== -1) {
+    const remaining = [...allFields];
+    order.splice(wildcardIdx, 0, ...remaining);
+  } else {
+    order.push(...allFields);
+  }
+  return order;
+}
+
+// src/utils/rjsf/reverseConverter.ts
+function toRjsfSchema(config) {
+  const properties = {};
+  const required2 = [];
+  const uiSchema = {};
+  for (const [fieldName, fieldConfig] of Object.entries(config.fields)) {
+    if (fieldName.includes(".")) {
+      setNestedProperty(properties, required2, uiSchema, fieldName, fieldConfig);
+      continue;
+    }
+    properties[fieldName] = fieldConfigToSchemaNode(fieldConfig);
+    if (fieldConfig.required) required2.push(fieldName);
+    const fieldUi = fieldConfigToUiSchema(fieldConfig);
+    if (Object.keys(fieldUi).length > 0) {
+      uiSchema[fieldName] = fieldUi;
+    }
+  }
+  if (config.fieldOrder && config.fieldOrder.length > 0) {
+    uiSchema["ui:order"] = config.fieldOrder;
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required2.length > 0) schema.required = required2;
+  return { schema, uiSchema };
+}
+var REVERSE_TYPE_MAP = {
+  Textbox: "string",
+  Textarea: "string",
+  Number: "number",
+  Slider: "number",
+  Toggle: "boolean",
+  DateControl: "string",
+  Dropdown: "string",
+  Multiselect: "array",
+  DocumentLinks: "string",
+  DynamicFragment: "string"
+};
+var REVERSE_WIDGET_MAP = {
+  Textarea: "textarea",
+  Slider: "range",
+  Toggle: "checkbox",
+  DocumentLinks: "file"
+};
+function fieldConfigToSchemaNode(config) {
+  const node = {};
+  const jsonType = REVERSE_TYPE_MAP[config.type] ?? "string";
+  node.type = jsonType;
+  if (config.label) node.title = config.label;
+  if (config.description) node.description = config.description;
+  if (config.defaultValue !== void 0) node.default = config.defaultValue;
+  if (config.options && config.options.length > 0) {
+    node.enum = config.options.map((o) => o.value);
+    const labels = config.options.map((o) => o.label);
+    const valuesAsStrings = config.options.map((o) => String(o.value));
+    if (labels.some((l, i) => l !== valuesAsStrings[i])) {
+      node.enumNames = labels;
+    }
+  }
+  if (config.validate) {
+    for (const rule of config.validate) {
+      applyValidationToSchema(node, rule.name, rule.params);
+    }
+  }
+  if (config.type === "FieldArray" && config.items) {
+    node.type = "array";
+    const itemProperties = {};
+    const itemRequired = [];
+    for (const [itemName, itemConfig] of Object.entries(config.items)) {
+      itemProperties[itemName] = fieldConfigToSchemaNode(itemConfig);
+      if (itemConfig.required) itemRequired.push(itemName);
+    }
+    node.items = {
+      type: "object",
+      properties: itemProperties,
+      ...itemRequired.length > 0 ? { required: itemRequired } : {}
+    };
+    if (config.minItems !== void 0) node.minItems = config.minItems;
+    if (config.maxItems !== void 0) node.maxItems = config.maxItems;
+  }
+  if (config.type === "Multiselect" && config.options) {
+    node.type = "array";
+    node.items = {
+      type: "string",
+      enum: config.options.map((o) => o.value)
+    };
+    delete node.enum;
+    delete node.enumNames;
+  }
+  if (config.type === "DateControl") {
+    node.format = "date";
+  }
+  if (config.type === "DocumentLinks") {
+    node.format = "data-url";
+  }
+  if (config.config?.type === "password" || config.config?.type === "color") {
+  }
+  return node;
+}
+function fieldConfigToUiSchema(config) {
+  const ui = {};
+  const widget = REVERSE_WIDGET_MAP[config.type];
+  if (widget) ui["ui:widget"] = widget;
+  if (config.config?.type === "password") ui["ui:widget"] = "password";
+  if (config.config?.type === "color") ui["ui:widget"] = "color";
+  if (config.config?.display === "radio") ui["ui:widget"] = "radio";
+  if (config.config?.display === "checkboxes") ui["ui:widget"] = "checkboxes";
+  if (config.placeholder) ui["ui:placeholder"] = config.placeholder;
+  if (config.helpText) ui["ui:help"] = config.helpText;
+  if (config.hidden) ui["ui:hidden"] = true;
+  if (config.readOnly) ui["ui:readonly"] = true;
+  if (config.disabled) ui["ui:disabled"] = true;
+  if (config.config?.autofocus) ui["ui:autofocus"] = true;
+  if (config.config?.className) ui["ui:classNames"] = config.config.className;
+  if (config.config?.hideLabel) ui["ui:label"] = false;
+  if (config.options) {
+    const disabled = config.options.filter((o) => o.disabled).map((o) => o.value);
+    if (disabled.length > 0) ui["ui:enumDisabled"] = disabled;
+  }
+  return ui;
+}
+function applyValidationToSchema(node, name, params) {
+  switch (name) {
+    case "minLength":
+      node.minLength = Number(params?.min ?? 0);
+      break;
+    case "maxLength":
+      node.maxLength = Number(params?.max ?? 0);
+      break;
+    case "pattern":
+      node.pattern = String(params?.pattern ?? "");
+      break;
+    case "numericRange":
+      if (params?.min !== void 0 && params.min !== -Infinity)
+        node.minimum = Number(params.min);
+      if (params?.max !== void 0 && params.max !== Infinity)
+        node.maximum = Number(params.max);
+      break;
+    case "exclusiveNumericRange":
+      if (params?.exclusiveMin !== void 0)
+        node.exclusiveMinimum = Number(params.exclusiveMin);
+      if (params?.exclusiveMax !== void 0)
+        node.exclusiveMaximum = Number(params.exclusiveMax);
+      break;
+    case "multipleOf":
+      node.multipleOf = Number(params?.factor ?? 1);
+      break;
+    case "email":
+      node.format = "email";
+      break;
+    case "url":
+      node.format = "uri";
+      break;
+    case "uniqueInArray":
+      node.uniqueItems = true;
+      break;
+  }
+}
+function setNestedProperty(properties, required2, uiSchema, dotPath, config) {
+  const parts = dotPath.split(".");
+  let currentProps = properties;
+  let currentUi = uiSchema;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!currentProps[part]) {
+      currentProps[part] = {
+        type: "object",
+        properties: {}
+      };
+    }
+    if (!currentProps[part].properties) {
+      currentProps[part].properties = {};
+    }
+    currentProps = currentProps[part].properties;
+    if (!currentUi[part]) {
+      currentUi[part] = {};
+    }
+    currentUi = currentUi[part];
+  }
+  const leafName = parts[parts.length - 1];
+  currentProps[leafName] = fieldConfigToSchemaNode(config);
+  if (config.required) {
+    const parentPath = parts.slice(0, -1);
+    let parentNode;
+    let props = properties;
+    for (const p of parentPath) {
+      parentNode = props[p];
+      props = parentNode?.properties ?? {};
+    }
+    if (parentNode) {
+      parentNode.required = [...parentNode.required ?? [], leafName];
+    }
+  }
+  const fieldUi = fieldConfigToUiSchema(config);
+  if (Object.keys(fieldUi).length > 0) {
+    currentUi[leafName] = fieldUi;
+  }
+}
+
+// src/utils/zodSchemaImport.ts
+function zodSchemaToFieldConfig(zodSchema) {
+  const configs = {};
+  const shape = getZodShape(zodSchema);
+  if (!shape) return configs;
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    configs[fieldName] = zodFieldToConfig(fieldName, fieldSchema);
+  }
+  return configs;
+}
+function getZodShape(schema) {
+  const s = schema;
+  if (s?._def && typeof s._def === "object") {
+    const def = s._def;
+    if (typeof def.shape === "function") return def.shape();
+    if (typeof def.shape === "object" && def.shape !== null) return def.shape;
+  }
+  return null;
+}
+function zodFieldToConfig(fieldName, field) {
+  const { typeName, isOptional } = unwrapZodType(field);
+  const checks = getZodChecks(field);
+  const config = {
+    type: "Textbox",
+    label: formatLabel(fieldName),
+    required: !isOptional
+  };
+  switch (typeName) {
+    case "ZodString":
+      config.type = "Textbox";
+      if (checks.some((c) => c.kind === "email")) {
+        config.validate = [...config.validate ?? [], { name: "email" }];
+      }
+      if (checks.some((c) => c.kind === "url")) {
+        config.validate = [...config.validate ?? [], { name: "url" }];
+      }
+      break;
+    case "ZodNumber":
+      config.type = "Number";
+      break;
+    case "ZodBoolean":
+      config.type = "Toggle";
+      break;
+    case "ZodEnum":
+    case "ZodNativeEnum": {
+      config.type = "Dropdown";
+      const values = getZodEnumValues(field);
+      if (values) {
+        config.options = values.map((v) => ({ value: String(v), label: String(v) }));
+      }
+      break;
+    }
+    case "ZodDate":
+      config.type = "DateControl";
+      break;
+    case "ZodArray":
+      config.type = "Multiselect";
+      break;
+    default:
+      config.type = "Textbox";
+  }
+  return config;
+}
+function unwrapZodType(field) {
+  let current = field;
+  let isOptional = false;
+  while (current?._def) {
+    const tn = current._def.typeName;
+    if (tn === "ZodOptional" || tn === "ZodNullable") {
+      isOptional = true;
+      current = current._def.innerType;
+    } else if (tn === "ZodDefault") {
+      current = current._def.innerType;
+    } else {
+      break;
+    }
+  }
+  return { typeName: current?._def?.typeName ?? "ZodString", isOptional };
+}
+function getZodChecks(field) {
+  let current = field;
+  while (current?._def) {
+    if (current._def.checks) return current._def.checks;
+    if (current._def.innerType) {
+      current = current._def.innerType;
+    } else {
+      break;
+    }
+  }
+  return [];
+}
+function getZodEnumValues(field) {
+  let current = field;
+  while (current?._def) {
+    if (current._def.values) return current._def.values;
+    if (current._def.innerType) {
+      current = current._def.innerType;
+    } else {
+      break;
+    }
+  }
+  return null;
+}
+function formatLabel(fieldName) {
+  return fieldName.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+}
+
+// src/utils/lazyFieldRegistry.ts
+var import_react13 = __toESM(require("react"));
+function createLazyFieldRegistry(imports) {
+  const registry = {};
+  for (const [key, importFn] of Object.entries(imports)) {
+    const LazyComponent = import_react13.default.lazy(importFn);
+    registry[key] = import_react13.default.createElement(
+      import_react13.default.Suspense,
+      { fallback: import_react13.default.createElement("span", { className: "field-loading" }, "Loading...") },
+      import_react13.default.createElement(LazyComponent)
+    );
+  }
+  return registry;
+}
+
+// src/hooks/useDraftPersistence.ts
+var import_react14 = require("react");
+
+// src/utils/formStateSerialization.ts
+function markDates(value, visited = /* @__PURE__ */ new WeakSet()) {
+  if (value instanceof Date) {
+    return { __type: "Date", value: value.toISOString() };
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) return value;
+    visited.add(value);
+    return value.map((item) => markDates(item, visited));
+  }
+  if (value !== null && typeof value === "object") {
+    if (visited.has(value)) return value;
+    visited.add(value);
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = markDates(value[key], visited);
+    }
+    return result;
+  }
+  return value;
+}
+function serializeFormState(data) {
+  return JSON.stringify(markDates(data));
+}
+function deserializeFormState(json) {
+  return JSON.parse(json, (_key, value) => {
+    if (value && typeof value === "object" && value.__type === "Date") {
+      return new Date(value.value);
+    }
+    return value;
+  });
+}
+
+// src/hooks/useDraftPersistence.ts
+function getStorageKey(formId, prefix) {
+  return `${prefix}${formId}`;
+}
+function getStorage() {
+  try {
+    return typeof localStorage !== "undefined" ? localStorage : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function useDraftPersistence(options) {
+  const {
+    formId,
+    data,
+    saveIntervalMs = 3e4,
+    enabled = true,
+    storageKeyPrefix = "draft_"
+  } = options;
+  const [hasDraft, setHasDraft] = (0, import_react14.useState)(false);
+  const dataRef = (0, import_react14.useRef)(data);
+  const intervalRef = (0, import_react14.useRef)(void 0);
+  (0, import_react14.useEffect)(() => {
+    dataRef.current = data;
+  }, [data]);
+  const storageKey = getStorageKey(formId, storageKeyPrefix);
+  const saveDraft = (0, import_react14.useCallback)(() => {
+    try {
+      const storage = getStorage();
+      if (!storage) return;
+      const draftState = {
+        data: dataRef.current,
+        timestamp: Date.now()
+      };
+      storage.setItem(storageKey, serializeFormState(draftState));
+      setHasDraft(true);
+    } catch {
+    }
+  }, [storageKey]);
+  const recoverDraft = (0, import_react14.useCallback)(() => {
+    try {
+      const storage = getStorage();
+      if (!storage) return null;
+      const stored = storage.getItem(storageKey);
+      if (!stored) return null;
+      const parsed = deserializeFormState(stored);
+      return parsed;
+    } catch {
+      return null;
+    }
+  }, [storageKey]);
+  const clearDraft = (0, import_react14.useCallback)(() => {
+    try {
+      const storage = getStorage();
+      if (!storage) return;
+      storage.removeItem(storageKey);
+      setHasDraft(false);
+    } catch {
+    }
+  }, [storageKey]);
+  (0, import_react14.useEffect)(() => {
+    if (!enabled) return;
+    try {
+      const storage = getStorage();
+      if (!storage) {
+        setHasDraft(false);
+        return;
+      }
+      const stored = storage.getItem(storageKey);
+      setHasDraft(stored !== null);
+    } catch {
+      setHasDraft(false);
+    }
+  }, [enabled, storageKey]);
+  (0, import_react14.useEffect)(() => {
+    if (!enabled) return;
+    intervalRef.current = setInterval(() => {
+      saveDraft();
+    }, saveIntervalMs);
+    return () => {
+      if (intervalRef.current !== void 0) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = void 0;
+      }
+    };
+  }, [enabled, saveIntervalMs, saveDraft]);
+  return {
+    recoverDraft,
+    clearDraft,
+    hasDraft,
+    saveDraft
+  };
+}
+
+// src/hooks/useBeforeUnload.ts
+var import_react15 = require("react");
+function useBeforeUnload(shouldWarn, message, onAbandonment) {
+  const onAbandonmentRef = (0, import_react15.useRef)(onAbandonment);
+  onAbandonmentRef.current = onAbandonment;
+  (0, import_react15.useEffect)(() => {
+    if (!shouldWarn || typeof window === "undefined") return;
+    const handler = (e) => {
+      e.preventDefault();
+      onAbandonmentRef.current?.();
+      return e.returnValue = message ?? "You have unsaved changes.";
+    };
+    window.addEventListener("beforeunload", handler);
+    return () => window.removeEventListener("beforeunload", handler);
+  }, [shouldWarn, message]);
+}
+
+// src/helpers/RuleTracer.ts
+var traceEnabled = false;
+var traceLog = [];
+var traceCallback = null;
+function enableRuleTracing(callback) {
+  traceEnabled = true;
+  traceLog = [];
+  traceCallback = callback ?? null;
+}
+function disableRuleTracing() {
+  traceEnabled = false;
+  traceCallback = null;
+}
+function traceRuleEvent(event) {
+  if (!traceEnabled) return;
+  const fullEvent = { ...event, timestamp: Date.now() };
+  traceLog.push(fullEvent);
+  traceCallback?.(fullEvent);
+}
+function getRuleTraceLog() {
+  return [...traceLog];
+}
+function clearRuleTraceLog() {
+  traceLog = [];
+}
+function isRuleTracingEnabled() {
+  return traceEnabled;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckAsyncFieldValidationRules,
+  CheckDefaultValues,
+  CheckFieldValidationRules,
+  CheckValidDropdownOptions,
+  ComponentTypes,
+  ConfirmInputsModal,
+  ExecuteComputedValue,
+  FIELD_PARENT_PREFIX,
+  FieldArray,
+  FieldWrapper,
+  FormConstants,
+  FormDevTools,
+  FormEngine,
+  FormErrorBoundary,
+  FormFields,
+  FormStrings,
+  GetChildEntity,
+  GetComputedValuesOnCreate,
+  GetComputedValuesOnDirtyFields,
+  GetConfirmInputModalProps,
+  GetFieldsToRender,
+  InitOnCreateFormState,
+  InitOnEditFormState,
+  InjectedFieldProvider,
+  IsExpandVisible,
+  RenderField,
+  RulesEngineActionType,
+  RulesEngineProvider,
+  ShowField,
+  SortDropdownOptions,
+  SortOptions,
+  UseInjectedFieldContext,
+  UseRulesEngineContext,
+  WizardForm,
+  buildDefaultFieldStates,
+  buildDependencyGraph,
+  clearRuleTraceLog,
+  clearTimeline,
+  convertBooleanToYesOrNoText,
+  createLazyFieldRegistry,
+  createMaxLengthRule,
+  createMinLengthRule,
+  createNumericRangeRule,
+  createOption,
+  createPatternRule,
+  createRequiredIfRule,
+  deepCopy,
+  defineFormConfig,
+  deserializeFormState,
+  detectDependencyCycles,
+  detectSelfDependencies,
+  disableRuleTracing,
+  enableRuleTracing,
+  evaluateAffectedFields,
+  evaluateAllRules,
+  evaluateCondition,
+  evaluateExpression,
+  executeValueFunction,
+  extractConditionDependencies,
+  extractExpressionDependencies,
+  extractFunctionDependencies,
+  flushRenderCycle,
+  fromRjsfSchema,
+  getCurrentLocale,
+  getLastRenderedFields,
+  getLocaleString,
+  getRenderCounts,
+  getRuleTraceLog,
+  getStepFieldOrder,
+  getStepFields,
+  getStepIndex,
+  getTimeline,
+  getTotalFormRenders,
+  getValidator,
+  getValidatorRegistry,
+  getValueFunction,
+  getVisibleSteps,
+  isEmpty,
+  isFieldCondition,
+  isLogicalCondition,
+  isNull,
+  isRuleTracingEnabled,
+  isStepValid,
+  isStringEmpty,
+  logEvent,
+  registerLocale,
+  registerValidators,
+  registerValueFunctions,
+  resetLocale,
+  resetRenderTracker,
+  resetValidatorRegistry,
+  resetValueFunctionRegistry,
+  runSyncValidations,
+  runValidations,
+  serializeFormState,
+  sortDropdownOptions,
+  toRjsfSchema,
+  topologicalSort,
+  traceRuleEvent,
+  trackRender,
+  useBeforeUnload,
+  useDraftPersistence,
+  useFormAnalytics,
+  validateDependencyGraph,
+  validateFieldConfigs,
+  validateStepFields,
+  zodSchemaToFieldConfig
+});
+//# sourceMappingURL=index.js.map