@letar/forms 1.1.0 → 1.2.0

package/index.js

@@ -1,21 +1,25 @@
-import { FieldFileUpload, FieldColorPicker, FieldOTPInput, FieldPinInput, FieldCity, FieldAddress, FieldPhone } from './chunk-GOELIS6T.js';
-import { FormSyncStatus, FormOfflineIndicator, useOfflineForm } from './chunk-4V6WBJ76.js';
-export { FormOfflineIndicator, FormSyncStatus, useOfflineForm, useOfflineStatus, useSyncQueue } from './chunk-4V6WBJ76.js';
-import { FieldRichText, FieldEditable, FieldMaskedInput, FieldPasswordStrength, FieldPassword, FieldTextarea, FieldString } from './chunk-M2PNAAIR.js';
-export { FieldString } from './chunk-M2PNAAIR.js';
-import { FieldRating, FieldSlider, FieldPercentage, FieldCurrency, FieldNumberInput, FieldNumber } from './chunk-XKKJKYWZ.js';
-export { FieldNumber } from './chunk-XKKJKYWZ.js';
-import { FieldSchedule, FieldDuration, FieldTime, FieldDateTimePicker, FieldDateRange, FieldDate } from './chunk-KUNT5MSU.js';
-import { FieldTags, FieldSegmentedGroup, FieldRadioCard, FieldRadioGroup, FieldListbox, FieldAutocomplete, FieldCombobox, FieldCascadingSelect, FieldNativeSelect, FieldSelect, FieldCheckboxCard } from './chunk-PJETA6YN.js';
-export { FieldCombobox, FieldListbox, FieldSegmentedGroup, FieldSelect } from './chunk-PJETA6YN.js';
-import { FieldSwitch, FieldCheckbox } from './chunk-6QOPSQ3Z.js';
-import { useDeclarativeForm, useFormGroup, getZodConstraints, FormGroup, DeclarativeFormContext, unwrapSchema } from './chunk-HWVOFWAT.js';
-export { DeclarativeFormContext, FieldLabel, FieldTooltip, FormGroup, useAsyncSearch, useDebounce, useDeclarativeField, useDeclarativeForm, useDeclarativeFormOptional, useFormGroup } from './chunk-HWVOFWAT.js';
-export { FormI18nProvider, getLocalizedValue, useFormI18n, useLocalizedOptions } from './chunk-7FEQFDJ7.js';
+import { CreditCardField, FieldSignature, FieldFileUpload, FieldColorPicker, FieldOTPInput, FieldPinInput, FieldCity, FieldAddress, FieldPhone } from './chunk-2PSXYC3I.js';
+export { CardBrandIcon, CreditCardField, creditCardSchema, detectBrand, formatCardNumber, formatExpiry, isExpiryValid, luhn, parseFileSize, processFileWithSecurity, sanitizeFileName, validateMimeType } from './chunk-2PSXYC3I.js';
+export { applyServerErrors, mapServerErrors } from './chunk-5D6S6EGF.js';
+export { AnalyticsPanel, createGtagAdapter, createPostHogAdapter, createUmamiAdapter, createYandexMetrikaAdapter, useFormAnalytics } from './chunk-K3J4L26K.js';
+import { validateSnils, validateBik, validateOgrn, validateKpp, validateInn10, validateInn12 } from './chunk-CGXKRCSM.js';
+import { FormSyncStatus, FormOfflineIndicator, useOfflineForm } from './chunk-MVGXZNHP.js';
+export { FormOfflineIndicator, FormSyncStatus, useOfflineForm, useOfflineStatus, useSyncQueue } from './chunk-MVGXZNHP.js';
+import { FieldRichText, FieldEditable, FieldMaskedInput, FieldPasswordStrength, FieldPassword, FieldTextarea, FieldString } from './chunk-DQUVUMCX.js';
+export { FieldString } from './chunk-DQUVUMCX.js';
+import { FieldRating, FieldSlider, FieldPercentage, FieldCurrency, FieldNumberInput, FieldNumber } from './chunk-MZDTJSF7.js';
+export { FieldNumber } from './chunk-MZDTJSF7.js';
+import { FieldSchedule, FieldDuration, FieldTime, FieldDateTimePicker, FieldDateRange, FieldDate } from './chunk-Q5EOF36Y.js';
+import { FieldTags, FieldSegmentedGroup, FieldRadioCard, FieldRadioGroup, FieldListbox, FieldAutocomplete, FieldCombobox, FieldCascadingSelect, FieldNativeSelect, FieldSelect, FieldCheckboxCard } from './chunk-MAYUFA5K.js';
+export { FieldCombobox, FieldListbox, FieldSegmentedGroup, FieldSelect } from './chunk-MAYUFA5K.js';
+import { FieldSwitch, FieldCheckbox } from './chunk-6E7VJAJT.js';
+import { createField, FieldLabel, FieldError, useDeclarativeForm, useFormGroup, getZodConstraints, FormGroup, useDeclarativeFormOptional, useResolvedFieldProps, FieldWrapper, hasFieldErrors, formatFieldErrors, DeclarativeFormContext, unwrapSchema, useDebounce } from './chunk-XFWLD5EO.js';
+export { DeclarativeFormContext, FieldLabel, FieldTooltip, FormGroup, useAsyncSearch, useDebounce, useDeclarativeField, useDeclarativeForm, useDeclarativeFormOptional, useFormGroup } from './chunk-XFWLD5EO.js';
+export { FormI18nProvider, getLocalizedValue, useFormI18n, useLocalizedOptions } from './chunk-R2RTCKXY.js';
 import { createFormHookContexts, createFormHook } from '@tanstack/react-form';
-import { createContext, forwardRef, useContext, Fragment, useState, useRef, useMemo, useCallback, useEffect, Children, isValidElement, useSyncExternalStore, lazy, Suspense } from 'react';
+import { createContext, forwardRef, lazy, useContext, useCallback, Fragment, useState, useRef, useMemo, useEffect, Suspense, useSyncExternalStore, Children, isValidElement, useId } from 'react';
 import { jsxs, jsx, Fragment as Fragment$1 } from 'react/jsx-runtime';
-import { Field, IconButton, Button, Steps, ButtonGroup, Box, VStack, HStack, Heading, Alert, List, Text, Dialog, Portal, CloseButton, Skeleton } from '@chakra-ui/react';
+import { Field, InputGroup, Input, Icon, IconButton, Button, Steps, ButtonGroup, Box, VStack, HStack, Separator, Flex, Text, Alert, Heading, List, Checkbox, Table, SimpleGrid, Image, RadioGroup, Circle, Dialog, Portal, CloseButton, NativeSelect, Progress, Spinner, Skeleton } from '@chakra-ui/react';
 import { useRouter } from 'next/navigation';
 import { useSensors, useSensor, PointerSensor, KeyboardSensor, DndContext, closestCenter } from '@dnd-kit/core';
 import { sortableKeyboardCoordinates, SortableContext, verticalListSortingStrategy, useSortable } from '@dnd-kit/sortable';
@@ -23,7 +27,10 @@ import { CSS } from '@dnd-kit/utilities';
 import JsonView from '@uiw/react-json-view';
 import { githubDarkTheme } from '@uiw/react-json-view/githubDark';
 import { githubLightTheme } from '@uiw/react-json-view/githubLight';
-import { LuCheck } from 'react-icons/lu';
+import { withMask } from 'use-mask-input';
+import { LuCheck, LuBookOpen, LuShield, LuLandmark, LuFileText } from 'react-icons/lu';
+import { useReactTable, getPaginationRowModel, getFilteredRowModel, getSortedRowModel, getCoreRowModel, flexRender } from '@tanstack/react-table';
+import { useVirtualizer } from '@tanstack/react-virtual';
 import { AnimatePresence, motion } from 'framer-motion';
 import { z } from 'zod/v4';
 
@@ -180,6 +187,80 @@ function useFormGroupList() {
 function useFormGroupListItem() {
   return useContext(FormGroupListItemContext);
 }
+var CaptchaContext = createContext(void 0);
+function useCaptchaConfig() {
+  return useContext(CaptchaContext);
+}
+
+// src/lib/captcha/types.ts
+var CAPTCHA_TOKEN_FIELD = "__captchaToken";
+var providers = {
+  turnstile: lazy(() => import('./turnstile-7FXTBSLW.js').then((m) => ({ default: m.TurnstileProvider }))),
+  recaptcha: lazy(() => import('./recaptcha-PKAUAY2S.js').then((m) => ({ default: m.RecaptchaProvider }))),
+  hcaptcha: lazy(() => import('./hcaptcha-U4XIT3HS.js').then((m) => ({ default: m.HcaptchaProvider })))
+};
+function CaptchaField(props) {
+  const config = useCaptchaConfig();
+  const formCtx = useDeclarativeFormOptional();
+  const provider = props.provider ?? config?.provider;
+  const siteKey = props.siteKey ?? config?.siteKey;
+  const theme = props.theme ?? config?.theme ?? "auto";
+  const size = props.size ?? config?.size ?? "normal";
+  const language = props.language ?? config?.language;
+  const [, setToken] = useState(null);
+  const handleSuccess = useCallback(
+    (captchaToken) => {
+      setToken(captchaToken);
+      if (formCtx?.form) {
+        formCtx.form.setFieldValue(CAPTCHA_TOKEN_FIELD, captchaToken);
+      }
+      props.onSuccess?.(captchaToken);
+    },
+    [formCtx, props.onSuccess]
+  );
+  const handleError = useCallback(
+    (error) => {
+      setToken(null);
+      if (formCtx?.form) {
+        formCtx.form.setFieldValue(CAPTCHA_TOKEN_FIELD, "");
+      }
+      props.onError?.(error);
+    },
+    [formCtx, props.onError]
+  );
+  const handleExpire = useCallback(() => {
+    setToken(null);
+    if (formCtx?.form) {
+      formCtx.form.setFieldValue(CAPTCHA_TOKEN_FIELD, "");
+    }
+    props.onExpire?.();
+  }, [formCtx, props.onExpire]);
+  if (!provider || !siteKey) {
+    if (process.env.NODE_ENV === "development") {
+      console.warn(
+        "[Form.Captcha] provider \u0438 siteKey \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u044B. \u041F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u0447\u0435\u0440\u0435\u0437 \u043F\u0440\u043E\u043F\u0441\u044B \u0438\u043B\u0438 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u0442\u0435 captcha \u0432 createForm()."
+      );
+    }
+    return null;
+  }
+  const ProviderComponent = providers[provider];
+  if (!ProviderComponent) {
+    console.error(`[Form.Captcha] \u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440: ${provider}`);
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx("div", { style: { height: 65, width: 300 } }), children: /* @__PURE__ */ jsx(
+    ProviderComponent,
+    {
+      siteKey,
+      theme,
+      size,
+      language,
+      onSuccess: handleSuccess,
+      onError: handleError,
+      onExpire: handleExpire
+    }
+  ) });
+}
 function DirtyGuard({
   message = "You have unsaved changes. Are you sure you want to leave?",
   dialogTitle = "Unsaved changes",
@@ -1364,6 +1445,635 @@ function ButtonSubmit({
     }
   ) });
 }
+function FieldImageChoice({
+  name,
+  label,
+  helperText,
+  required,
+  disabled,
+  readOnly,
+  options,
+  columns = 3,
+  multiple = false
+}) {
+  const { form } = useDeclarativeForm();
+  useFormGroup();
+  const {
+    fullPath,
+    label: resolvedLabel,
+    helperText: resolvedHelperText,
+    required: resolvedRequired,
+    disabled: resolvedDisabled,
+    readOnly: resolvedReadOnly
+  } = useResolvedFieldProps(name, { label, helperText, required, disabled, readOnly });
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => {
+    const errors = field.state.meta.errors;
+    const hasError = hasFieldErrors(errors);
+    const value = field.state.value;
+    const isSelected = (optValue) => {
+      if (multiple) {
+        return Array.isArray(value) && value.includes(optValue);
+      }
+      return value === optValue;
+    };
+    const handleSelect = (optValue) => {
+      if (resolvedDisabled || resolvedReadOnly) return;
+      if (multiple) {
+        const current = Array.isArray(value) ? value : [];
+        const next = current.includes(optValue) ? current.filter((v) => v !== optValue) : [...current, optValue];
+        field.handleChange(next);
+      } else {
+        field.handleChange(optValue);
+      }
+    };
+    return /* @__PURE__ */ jsxs(Field.Root, { invalid: hasError, children: [
+      resolvedLabel && /* @__PURE__ */ jsx(FieldLabel, { label: resolvedLabel, required: resolvedRequired }),
+      /* @__PURE__ */ jsx(SimpleGrid, { columns: { base: 1, sm: 2, md: columns }, gap: 3, children: options.map((opt) => {
+        const selected = isSelected(opt.value);
+        return /* @__PURE__ */ jsxs(
+          Box,
+          {
+            borderWidth: "2px",
+            borderColor: selected ? "blue.500" : "border",
+            borderRadius: "lg",
+            overflow: "hidden",
+            cursor: resolvedDisabled ? "default" : "pointer",
+            onClick: () => handleSelect(opt.value),
+            transition: "all 0.2s",
+            _hover: resolvedDisabled ? void 0 : { borderColor: "blue.400", shadow: "md" },
+            opacity: resolvedDisabled ? 0.5 : 1,
+            position: "relative",
+            children: [
+              /* @__PURE__ */ jsx(
+                Image,
+                {
+                  src: opt.image,
+                  alt: opt.label,
+                  w: "100%",
+                  h: "120px",
+                  objectFit: "cover"
+                }
+              ),
+              selected && /* @__PURE__ */ jsx(
+                Box,
+                {
+                  position: "absolute",
+                  top: "8px",
+                  right: "8px",
+                  bg: "blue.500",
+                  color: "white",
+                  borderRadius: "full",
+                  w: "24px",
+                  h: "24px",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  fontSize: "sm",
+                  fontWeight: "bold",
+                  children: "\u2713"
+                }
+              ),
+              /* @__PURE__ */ jsxs(Box, { p: 2, children: [
+                /* @__PURE__ */ jsx(Text, { fontSize: "sm", fontWeight: "medium", children: opt.label }),
+                opt.description && /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "fg.muted", children: opt.description })
+              ] })
+            ]
+          },
+          opt.value
+        );
+      }) }),
+      /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage: formatFieldErrors(errors), helperText: resolvedHelperText })
+    ] });
+  } });
+}
+function FieldLikert({
+  name,
+  label,
+  helperText,
+  required,
+  disabled,
+  readOnly,
+  anchors,
+  showNumbers = false
+}) {
+  const { form } = useDeclarativeForm();
+  useFormGroup();
+  const {
+    fullPath,
+    label: resolvedLabel,
+    helperText: resolvedHelperText,
+    required: resolvedRequired,
+    disabled: resolvedDisabled,
+    readOnly: resolvedReadOnly
+  } = useResolvedFieldProps(name, { label, helperText, required, disabled, readOnly });
+  anchors.length;
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => {
+    const errors = field.state.meta.errors;
+    const hasError = hasFieldErrors(errors);
+    const value = field.state.value;
+    const handleSelect = (point) => {
+      if (resolvedDisabled || resolvedReadOnly) return;
+      field.handleChange(point);
+    };
+    return /* @__PURE__ */ jsxs(Field.Root, { invalid: hasError, children: [
+      resolvedLabel && /* @__PURE__ */ jsx(FieldLabel, { label: resolvedLabel, required: resolvedRequired }),
+      /* @__PURE__ */ jsxs(Box, { display: { base: "none", md: "block" }, children: [
+        /* @__PURE__ */ jsx(Flex, { justify: "space-between", align: "center", py: 2, children: anchors.map((anchor, i) => {
+          const point = i + 1;
+          const isSelected = value === point;
+          return /* @__PURE__ */ jsxs(
+            Flex,
+            {
+              direction: "column",
+              align: "center",
+              gap: 1,
+              flex: 1,
+              cursor: resolvedDisabled ? "default" : "pointer",
+              onClick: () => handleSelect(point),
+              opacity: resolvedDisabled ? 0.5 : 1,
+              children: [
+                showNumbers && /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "fg.muted", children: point }),
+                /* @__PURE__ */ jsx(
+                  Box,
+                  {
+                    w: "32px",
+                    h: "32px",
+                    borderRadius: "full",
+                    borderWidth: "2px",
+                    borderColor: isSelected ? "blue.500" : "border",
+                    bg: isSelected ? "blue.500" : "transparent",
+                    transition: "all 0.15s",
+                    _hover: resolvedDisabled ? void 0 : { borderColor: "blue.400", transform: "scale(1.1)" }
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Text,
+                  {
+                    fontSize: "xs",
+                    textAlign: "center",
+                    color: isSelected ? "blue.600" : "fg.muted",
+                    fontWeight: isSelected ? "medium" : "normal",
+                    maxW: "80px",
+                    children: anchor
+                  }
+                )
+              ]
+            },
+            point
+          );
+        }) }),
+        /* @__PURE__ */ jsx(Box, { h: "2px", bg: "border", mt: "-28px", mb: "24px", mx: "16px", borderRadius: "full" })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { display: { base: "block", md: "none" }, children: anchors.map((anchor, i) => {
+        const point = i + 1;
+        const isSelected = value === point;
+        return /* @__PURE__ */ jsxs(
+          HStack,
+          {
+            p: 2,
+            borderRadius: "md",
+            cursor: resolvedDisabled ? "default" : "pointer",
+            onClick: () => handleSelect(point),
+            bg: isSelected ? "blue.50" : "transparent",
+            _dark: isSelected ? { bg: "blue.900/20" } : void 0,
+            _hover: resolvedDisabled ? void 0 : { bg: "bg.subtle" },
+            gap: 3,
+            children: [
+              /* @__PURE__ */ jsx(
+                Box,
+                {
+                  w: "24px",
+                  h: "24px",
+                  borderRadius: "full",
+                  borderWidth: "2px",
+                  borderColor: isSelected ? "blue.500" : "border",
+                  bg: isSelected ? "blue.500" : "transparent",
+                  flexShrink: 0
+                }
+              ),
+              /* @__PURE__ */ jsxs(Text, { fontSize: "sm", color: isSelected ? "blue.600" : "fg", children: [
+                showNumbers && `${point}. `,
+                anchor
+              ] })
+            ]
+          },
+          point
+        );
+      }) }),
+      /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage: formatFieldErrors(errors), helperText: resolvedHelperText })
+    ] });
+  } });
+}
+function FieldMatrixChoice({
+  name,
+  label,
+  helperText,
+  required,
+  disabled,
+  readOnly,
+  rows,
+  columns,
+  variant = "radio"
+}) {
+  const { form } = useDeclarativeForm();
+  const {
+    fullPath,
+    label: resolvedLabel,
+    helperText: resolvedHelperText,
+    required: resolvedRequired,
+    disabled: resolvedDisabled,
+    readOnly: resolvedReadOnly
+  } = useResolvedFieldProps(name, { label, helperText, required, disabled, readOnly });
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => {
+    const errors = field.state.meta.errors;
+    const hasError = hasFieldErrors(errors);
+    const value = field.state.value ?? {};
+    const setRowValue = (rowValue, colValue) => {
+      if (resolvedDisabled || resolvedReadOnly) return;
+      if (variant === "checkbox") {
+        const current = value[rowValue] ?? [];
+        const next = current.includes(colValue) ? current.filter((v) => v !== colValue) : [...current, colValue];
+        field.handleChange({ ...value, [rowValue]: next });
+      } else {
+        field.handleChange({ ...value, [rowValue]: colValue });
+      }
+    };
+    const isSelected = (rowValue, colValue) => {
+      const rowVal = value[rowValue];
+      if (variant === "checkbox") {
+        return Array.isArray(rowVal) && rowVal.includes(colValue);
+      }
+      return rowVal === colValue;
+    };
+    const mobileView = /* @__PURE__ */ jsx(VStack, { gap: 4, align: "stretch", display: { base: "flex", md: "none" }, children: rows.map((row) => /* @__PURE__ */ jsxs(Box, { p: 3, borderWidth: "1px", borderRadius: "md", children: [
+      /* @__PURE__ */ jsx(Text, { fontWeight: "medium", mb: 2, children: row.label }),
+      variant === "checkbox" ? /* @__PURE__ */ jsx(VStack, { align: "start", gap: 1, children: columns.map((col) => /* @__PURE__ */ jsxs(
+        Checkbox.Root,
+        {
+          checked: isSelected(row.value, col.value),
+          onCheckedChange: () => setRowValue(row.value, col.value),
+          disabled: !!resolvedDisabled,
+          size: "sm",
+          children: [
+            /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+            /* @__PURE__ */ jsx(Checkbox.Control, {}),
+            /* @__PURE__ */ jsx(Checkbox.Label, { children: col.label })
+          ]
+        },
+        col.value
+      )) }) : /* @__PURE__ */ jsx(
+        RadioGroup.Root,
+        {
+          value: String(value[row.value] ?? ""),
+          onValueChange: (details) => {
+            if (details.value) setRowValue(row.value, details.value);
+          },
+          disabled: !!resolvedDisabled,
+          size: "sm",
+          children: /* @__PURE__ */ jsx(VStack, { align: "start", gap: 1, children: columns.map((col) => /* @__PURE__ */ jsxs(RadioGroup.Item, { value: col.value, children: [
+            /* @__PURE__ */ jsx(RadioGroup.ItemHiddenInput, {}),
+            /* @__PURE__ */ jsx(RadioGroup.ItemIndicator, {}),
+            /* @__PURE__ */ jsx(RadioGroup.ItemText, { children: col.label })
+          ] }, col.value)) })
+        }
+      )
+    ] }, row.value)) });
+    const handleMatrixKeyDown = (e) => {
+      const target = e.target;
+      const cell = target.closest("[data-matrix-row][data-matrix-col]");
+      if (!cell) return;
+      const currentRow = cell.dataset.matrixRow;
+      const currentCol = cell.dataset.matrixCol;
+      const rowIdx = rows.findIndex((r) => r.value === currentRow);
+      const colIdx = columns.findIndex((c) => c.value === currentCol);
+      let nextRowIdx = rowIdx;
+      let nextColIdx = colIdx;
+      switch (e.key) {
+        case "ArrowRight":
+          nextColIdx = Math.min(colIdx + 1, columns.length - 1);
+          break;
+        case "ArrowLeft":
+          nextColIdx = Math.max(colIdx - 1, 0);
+          break;
+        case "ArrowDown":
+          nextRowIdx = Math.min(rowIdx + 1, rows.length - 1);
+          break;
+        case "ArrowUp":
+          nextRowIdx = Math.max(rowIdx - 1, 0);
+          break;
+        case " ":
+        case "Enter":
+          e.preventDefault();
+          setRowValue(rows[rowIdx].value, columns[colIdx].value);
+          return;
+        default:
+          return;
+      }
+      e.preventDefault();
+      const nextCell = document.querySelector(
+        `[data-matrix-row="${rows[nextRowIdx].value}"][data-matrix-col="${columns[nextColIdx].value}"]`
+      );
+      nextCell?.focus();
+    };
+    const desktopView = /* @__PURE__ */ jsx(Box, { display: { base: "none", md: "block" }, overflowX: "auto", children: /* @__PURE__ */ jsxs(Table.Root, { size: "sm", variant: "outline", onKeyDown: handleMatrixKeyDown, children: [
+      /* @__PURE__ */ jsx(Table.Header, { children: /* @__PURE__ */ jsxs(Table.Row, { children: [
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { w: "40%" }),
+        columns.map((col) => /* @__PURE__ */ jsx(Table.ColumnHeader, { textAlign: "center", children: col.label }, col.value))
+      ] }) }),
+      /* @__PURE__ */ jsx(Table.Body, { children: rows.map((row) => {
+        const rowValue = value[row.value];
+        const isRowEmpty = variant === "checkbox" ? !Array.isArray(rowValue) || rowValue.length === 0 : !rowValue;
+        const showRowError = resolvedRequired && hasError && isRowEmpty;
+        return /* @__PURE__ */ jsxs(
+          Table.Row,
+          {
+            _hover: { bg: "bg.subtle" },
+            bg: showRowError ? "red.50" : void 0,
+            _dark: showRowError ? { bg: "red.900/10" } : void 0,
+            children: [
+              /* @__PURE__ */ jsx(Table.Cell, { fontWeight: "medium", color: showRowError ? "red.500" : void 0, children: row.label }),
+              columns.map((col) => /* @__PURE__ */ jsx(
+                Table.Cell,
+                {
+                  textAlign: "center",
+                  "data-matrix-row": row.value,
+                  "data-matrix-col": col.value,
+                  tabIndex: 0,
+                  role: "gridcell",
+                  children: variant === "checkbox" ? /* @__PURE__ */ jsxs(
+                    Checkbox.Root,
+                    {
+                      checked: isSelected(row.value, col.value),
+                      onCheckedChange: () => setRowValue(row.value, col.value),
+                      disabled: !!resolvedDisabled,
+                      size: "sm",
+                      children: [
+                        /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+                        /* @__PURE__ */ jsx(Checkbox.Control, {})
+                      ]
+                    }
+                  ) : variant === "rating" ? /* @__PURE__ */ jsx(
+                    Box,
+                    {
+                      cursor: resolvedDisabled ? "default" : "pointer",
+                      onClick: () => setRowValue(row.value, col.value),
+                      fontSize: "lg",
+                      color: isSelected(row.value, col.value) ? "yellow.400" : "gray.300",
+                      _hover: resolvedDisabled ? void 0 : { color: "yellow.400" },
+                      children: "\u2605"
+                    }
+                  ) : /* @__PURE__ */ jsx(
+                    Circle,
+                    {
+                      size: "18px",
+                      borderWidth: "2px",
+                      borderColor: isSelected(row.value, col.value) ? "blue.500" : "border",
+                      bg: isSelected(row.value, col.value) ? "blue.500" : "transparent",
+                      cursor: resolvedDisabled ? "default" : "pointer",
+                      onClick: () => setRowValue(row.value, col.value),
+                      transition: "all 0.15s",
+                      _hover: resolvedDisabled ? void 0 : { borderColor: "blue.400" },
+                      "aria-checked": isSelected(row.value, col.value),
+                      role: "radio",
+                      children: isSelected(row.value, col.value) && /* @__PURE__ */ jsx(Circle, { size: "8px", bg: "white" })
+                    }
+                  )
+                },
+                col.value
+              ))
+            ]
+          },
+          row.value
+        );
+      }) })
+    ] }) });
+    return /* @__PURE__ */ jsxs(Field.Root, { invalid: hasError, children: [
+      resolvedLabel && /* @__PURE__ */ jsx(FieldLabel, { label: resolvedLabel, required: resolvedRequired }),
+      desktopView,
+      mobileView,
+      /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage: formatFieldErrors(errors), helperText: resolvedHelperText })
+    ] });
+  } });
+}
+var VARIANT_CONTENT = {
+  buttons: { yes: null, no: null },
+  thumbs: { yes: "\u{1F44D}", no: "\u{1F44E}" },
+  emoji: { yes: "\u{1F60A}", no: "\u{1F61E}" }
+};
+function FieldYesNo({
+  name,
+  label,
+  helperText,
+  required,
+  disabled,
+  readOnly,
+  yesLabel = "\u0414\u0430",
+  noLabel = "\u041D\u0435\u0442",
+  variant = "buttons"
+}) {
+  const { form } = useDeclarativeForm();
+  useFormGroup();
+  const {
+    fullPath,
+    label: resolvedLabel,
+    helperText: resolvedHelperText,
+    required: resolvedRequired,
+    disabled: resolvedDisabled,
+    readOnly: resolvedReadOnly
+  } = useResolvedFieldProps(name, { label, helperText, required, disabled, readOnly });
+  const icons = VARIANT_CONTENT[variant];
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => {
+    const errors = field.state.meta.errors;
+    const hasError = hasFieldErrors(errors);
+    const value = field.state.value;
+    const handleSelect = (val) => {
+      if (resolvedDisabled || resolvedReadOnly) return;
+      field.handleChange(val);
+    };
+    return /* @__PURE__ */ jsxs(Field.Root, { invalid: hasError, children: [
+      resolvedLabel && /* @__PURE__ */ jsx(FieldLabel, { label: resolvedLabel, required: resolvedRequired }),
+      /* @__PURE__ */ jsxs(HStack, { gap: 3, children: [
+        /* @__PURE__ */ jsxs(
+          Box,
+          {
+            flex: 1,
+            p: 4,
+            borderWidth: "2px",
+            borderColor: value === true ? "green.500" : "border",
+            borderRadius: "lg",
+            cursor: resolvedDisabled ? "default" : "pointer",
+            onClick: () => handleSelect(true),
+            bg: value === true ? "green.50" : "transparent",
+            _dark: value === true ? { bg: "green.900/20" } : void 0,
+            _hover: resolvedDisabled ? void 0 : { borderColor: "green.400", shadow: "sm" },
+            transition: "all 0.2s",
+            textAlign: "center",
+            opacity: resolvedDisabled ? 0.5 : 1,
+            role: "radio",
+            "aria-checked": value === true,
+            children: [
+              icons.yes && /* @__PURE__ */ jsx(Text, { fontSize: "2xl", mb: 1, children: icons.yes }),
+              /* @__PURE__ */ jsx(Text, { fontWeight: "medium", color: value === true ? "green.600" : "fg", children: yesLabel })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Box,
+          {
+            flex: 1,
+            p: 4,
+            borderWidth: "2px",
+            borderColor: value === false ? "red.500" : "border",
+            borderRadius: "lg",
+            cursor: resolvedDisabled ? "default" : "pointer",
+            onClick: () => handleSelect(false),
+            bg: value === false ? "red.50" : "transparent",
+            _dark: value === false ? { bg: "red.900/20" } : void 0,
+            _hover: resolvedDisabled ? void 0 : { borderColor: "red.400", shadow: "sm" },
+            transition: "all 0.2s",
+            textAlign: "center",
+            opacity: resolvedDisabled ? 0.5 : 1,
+            role: "radio",
+            "aria-checked": value === false,
+            children: [
+              icons.no && /* @__PURE__ */ jsx(Text, { fontSize: "2xl", mb: 1, children: icons.no }),
+              /* @__PURE__ */ jsx(Text, { fontWeight: "medium", color: value === false ? "red.600" : "fg", children: noLabel })
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(FieldError, { hasError, errorMessage: formatFieldErrors(errors), helperText: resolvedHelperText })
+    ] });
+  } });
+}
+var computingFields = /* @__PURE__ */ new Set();
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let result = obj;
+  for (const part of parts) {
+    if (result && typeof result === "object") {
+      result = result[part];
+    } else {
+      return void 0;
+    }
+  }
+  return result;
+}
+function getDepsSnapshot(values, deps) {
+  return deps.map((dep) => getNestedValue(values, dep));
+}
+function areDepsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!Object.is(a[i], b[i])) return false;
+  }
+  return true;
+}
+function useComputedValue({
+  form,
+  compute,
+  deps,
+  debounce: debounceMs = 0,
+  fieldPath
+}) {
+  const prevDepsRef = useRef(null);
+  const cachedResultRef = useRef(void 0);
+  const subscribe = useCallback(
+    (callback) => {
+      const subscription = form.store.subscribe(callback);
+      if (typeof subscription === "function") {
+        return subscription;
+      }
+      return () => subscription.unsubscribe();
+    },
+    [form]
+  );
+  const getSnapshot = useCallback(() => {
+    const values = form.state.values;
+    if (deps && deps.length > 0) {
+      const currentDeps = getDepsSnapshot(values, deps);
+      if (prevDepsRef.current && areDepsEqual(prevDepsRef.current, currentDeps)) {
+        return cachedResultRef.current;
+      }
+      prevDepsRef.current = currentDeps;
+    }
+    if (computingFields.has(fieldPath)) {
+      if (process.env.NODE_ENV !== "production") {
+        console.error(
+          `[Form.Field.Calculated] \u041E\u0431\u043D\u0430\u0440\u0443\u0436\u0435\u043D\u0430 \u0446\u0438\u043A\u043B\u0438\u0447\u0435\u0441\u043A\u0430\u044F \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C: \u043F\u043E\u043B\u0435 "${fieldPath}" \u0443\u0436\u0435 \u0432\u044B\u0447\u0438\u0441\u043B\u044F\u0435\u0442\u0441\u044F. \u0422\u0435\u043A\u0443\u0449\u0430\u044F \u0446\u0435\u043F\u043E\u0447\u043A\u0430: ${[...computingFields].join(" \u2192 ")} \u2192 ${fieldPath}`
+        );
+      }
+      return cachedResultRef.current;
+    }
+    try {
+      computingFields.add(fieldPath);
+      const result = compute(values);
+      cachedResultRef.current = result;
+      return result;
+    } finally {
+      computingFields.delete(fieldPath);
+    }
+  }, [form, compute, deps, fieldPath]);
+  const rawValue = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const debouncedValue = useDebounce(rawValue, debounceMs);
+  return debounceMs > 0 ? debouncedValue : rawValue;
+}
+function CalculatedFieldInner({
+  field,
+  computedValue,
+  format,
+  hidden
+}) {
+  useEffect(() => {
+    if (!Object.is(field.state.value, computedValue)) {
+      field.handleChange(computedValue);
+    }
+  }, [computedValue, field]);
+  if (hidden) return null;
+  const displayValue = format ? format(computedValue) : String(computedValue ?? "");
+  return /* @__PURE__ */ jsx(Text, { fontSize: "md", fontWeight: "medium", py: "2", "data-testid": "calculated-value", children: displayValue });
+}
+function FieldCalculated({
+  name,
+  label,
+  compute,
+  format,
+  deps,
+  debounce = 0,
+  hidden,
+  helperText
+}) {
+  const { form, fullPath, ...resolved } = useResolvedFieldProps(name, {
+    label,
+    helperText,
+    readOnly: true
+  });
+  const computedValue = useComputedValue({
+    form,
+    compute,
+    deps,
+    debounce,
+    fieldPath: fullPath
+  });
+  if (hidden) {
+    return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => /* @__PURE__ */ jsx(CalculatedFieldInner, { field, computedValue, hidden: true }) });
+  }
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => /* @__PURE__ */ jsx(FieldWrapper, { resolved, hasError: false, errorMessage: "", fullPath, children: /* @__PURE__ */ jsx(CalculatedFieldInner, { field, computedValue, format }) }) });
+}
+FieldCalculated.displayName = "FieldCalculated";
+function HiddenFieldInner({ field, value }) {
+  useEffect(() => {
+    if (value !== void 0 && !Object.is(field.state.value, value)) {
+      field.handleChange(value);
+    }
+  }, [value, field]);
+  return null;
+}
+function FieldHidden({ name, value }) {
+  const { form, fullPath } = useResolvedFieldProps(name, {});
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, children: (field) => /* @__PURE__ */ jsx(HiddenFieldInner, { field, value }) });
+}
+FieldHidden.displayName = "FieldHidden";
 function useIsDarkMode() {
   const [isDark, setIsDark] = useState(false);
   useEffect(() => {
@@ -1419,6 +2129,145 @@ function FormDebugValues({
     }
   ) });
 }
+function HoneypotField() {
+  const id = useId();
+  const nameRef = useRef(`hp_${id.replace(/:/g, "")}_${Math.random().toString(36).slice(2, 6)}`);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "aria-hidden": "true",
+      style: {
+        position: "absolute",
+        left: "-9999px",
+        width: 0,
+        height: 0,
+        overflow: "hidden",
+        opacity: 0,
+        pointerEvents: "none",
+        tabIndex: -1
+      },
+      children: [
+        /* @__PURE__ */ jsx("label", { htmlFor: nameRef.current, children: "Leave this field empty" }),
+        /* @__PURE__ */ jsx("input", { type: "text", id: nameRef.current, name: nameRef.current, autoComplete: "off", tabIndex: -1 })
+      ]
+    }
+  );
+}
+function useHoneypotCheck(enabled) {
+  const checkBot = useCallback(() => {
+    if (!enabled) return false;
+    const honeypotInputs = document.querySelectorAll('input[name^="hp_"][tabindex="-1"]');
+    for (const input of honeypotInputs) {
+      if (input.value.trim() !== "") {
+        return true;
+      }
+    }
+    return false;
+  }, [enabled]);
+  return { isBot: checkBot };
+}
+var STORAGE_KEY_PREFIX = "form-rate-limit:";
+function useRateLimit(config, formId) {
+  const [secondsLeft, setSecondsLeft] = useState(0);
+  const [isBlocked, setIsBlocked] = useState(false);
+  const [attemptVersion, setAttemptVersion] = useState(0);
+  const timerRef = useRef(null);
+  const storageKey = `${STORAGE_KEY_PREFIX}${formId ?? "default"}`;
+  const getAttempts = useCallback(() => {
+    if (!config) return [];
+    try {
+      const raw = sessionStorage.getItem(storageKey);
+      if (!raw) return [];
+      const attempts2 = JSON.parse(raw);
+      const now = Date.now();
+      return attempts2.filter((ts) => now - ts < config.windowMs);
+    } catch {
+      return [];
+    }
+  }, [config, storageKey]);
+  const saveAttempts = useCallback(
+    (attempts2) => {
+      try {
+        sessionStorage.setItem(storageKey, JSON.stringify(attempts2));
+      } catch {
+      }
+    },
+    [storageKey]
+  );
+  const startCountdown = useCallback(
+    (blockUntil) => {
+      if (timerRef.current) clearInterval(timerRef.current);
+      const updateTimer = () => {
+        const remaining = Math.ceil((blockUntil - Date.now()) / 1e3);
+        if (remaining <= 0) {
+          setIsBlocked(false);
+          setSecondsLeft(0);
+          if (timerRef.current) clearInterval(timerRef.current);
+          timerRef.current = null;
+          saveAttempts(getAttempts());
+        } else {
+          setSecondsLeft(remaining);
+        }
+      };
+      updateTimer();
+      timerRef.current = setInterval(updateTimer, 1e3);
+    },
+    [getAttempts, saveAttempts]
+  );
+  const recordAttempt = useCallback(() => {
+    if (!config) return true;
+    const attempts2 = getAttempts();
+    if (attempts2.length >= config.maxSubmits) {
+      setIsBlocked(true);
+      const oldestAttempt = Math.min(...attempts2);
+      const blockUntil = oldestAttempt + config.windowMs;
+      startCountdown(blockUntil);
+      return false;
+    }
+    attempts2.push(Date.now());
+    saveAttempts(attempts2);
+    setAttemptVersion((v) => v + 1);
+    return true;
+  }, [config, getAttempts, saveAttempts, startCountdown]);
+  const reset = useCallback(() => {
+    try {
+      sessionStorage.removeItem(storageKey);
+    } catch {
+    }
+    setIsBlocked(false);
+    setSecondsLeft(0);
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+  }, [storageKey]);
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current);
+    };
+  }, []);
+  useEffect(() => {
+    if (!config) return;
+    const attempts2 = getAttempts();
+    if (attempts2.length >= config.maxSubmits) {
+      setIsBlocked(true);
+      const oldestAttempt = Math.min(...attempts2);
+      const blockUntil = oldestAttempt + config.windowMs;
+      if (blockUntil > Date.now()) {
+        startCountdown(blockUntil);
+      }
+    }
+  }, [config, getAttempts, startCountdown]);
+  if (!config) return null;
+  const attempts = getAttempts();
+  return {
+    isBlocked,
+    remaining: Math.max(0, config.maxSubmits - attempts.length),
+    secondsLeft,
+    recordAttempt,
+    reset
+  };
+}
 
 // src/lib/declarative/form-root/form-validators.ts
 function buildValidators(schema, validateOn) {
@@ -1448,6 +2297,67 @@ function buildValidators(schema, validateOn) {
   }
   return Object.keys(validators).length > 0 ? validators : void 0;
 }
+function getNestedValue2(obj, path) {
+  const parts = path.split(".");
+  let result = obj;
+  for (const part of parts) {
+    if (result && typeof result === "object") {
+      result = result[part];
+    } else {
+      return void 0;
+    }
+  }
+  return result;
+}
+function useFieldChangeListeners(form, onFieldChange) {
+  const callbacksRef = useRef(onFieldChange);
+  callbacksRef.current = onFieldChange;
+  const prevValuesRef = useRef({});
+  const fieldChangeApi = useMemo(
+    () => ({
+      setFieldValue: (name, value) => {
+        form.setFieldValue(name, value);
+      },
+      getFieldValue: (name) => {
+        return getNestedValue2(form.state.values, name);
+      },
+      getValues: () => {
+        return form.state.values;
+      }
+    }),
+    [form]
+  );
+  const initPrevValues = useCallback(() => {
+    const callbacks = callbacksRef.current;
+    if (!callbacks) return;
+    const values = form.state.values;
+    const snapshot = {};
+    for (const key of Object.keys(callbacks)) {
+      snapshot[key] = getNestedValue2(values, key);
+    }
+    prevValuesRef.current = snapshot;
+  }, [form]);
+  useEffect(() => {
+    initPrevValues();
+    const subscription = form.store.subscribe(() => {
+      const callbacks = callbacksRef.current;
+      if (!callbacks) return;
+      const values = form.state.values;
+      const prev = prevValuesRef.current;
+      for (const key of Object.keys(callbacks)) {
+        const currentValue = getNestedValue2(values, key);
+        if (!Object.is(prev[key], currentValue)) {
+          prev[key] = currentValue;
+          callbacks[key](currentValue, fieldChangeApi);
+        }
+      }
+    });
+    if (typeof subscription === "function") {
+      return subscription;
+    }
+    return () => subscription.unsubscribe();
+  }, [form, fieldChangeApi, initPrevValues]);
+}
 var STORAGE_PREFIX = "form-persistence:";
 function useFormPersistence(config) {
   const {
@@ -1732,8 +2642,13 @@ function FormSimple({
   debug,
   middleware,
   addressProvider,
+  onFieldChange,
+  honeypot,
+  rateLimit,
   children
 }) {
+  const { isBot } = useHoneypotCheck(honeypot);
+  const rateLimitState = useRateLimit(rateLimit);
   const features = useFormFeatures({
     persistence,
     offline,
@@ -1745,6 +2660,8 @@ function FormSimple({
     defaultValues: initialValue,
     validators: buildValidators(schema, validateOn),
     onSubmit: async ({ value, formApi }) => {
+      if (isBot()) return;
+      if (rateLimitState && !rateLimitState.recordAttempt()) return;
       let dataToSubmit = value;
       if (middleware?.beforeSubmit) {
         const transformed = await middleware.beforeSubmit(dataToSubmit);
@@ -1767,6 +2684,7 @@ function FormSimple({
       }
     }
   });
+  useFieldChangeListeners(form, onFieldChange);
   useEffect(() => {
     return features.subscribeToFormChanges(form);
   }, [form, features]);
@@ -1804,6 +2722,12 @@ function FormSimple({
           form.handleSubmit();
         },
         children: [
+          honeypot && /* @__PURE__ */ jsx(HoneypotField, {}),
+          rateLimitState?.isBlocked && /* @__PURE__ */ jsxs("div", { role: "alert", style: { color: "var(--chakra-colors-fg-error, #e53e3e)", marginBottom: "1rem" }, children: [
+            "Too many attempts. Try again in ",
+            rateLimitState.secondsLeft,
+            "s."
+          ] }),
           children,
           debug && /* @__PURE__ */ jsx(FormDebugValues, { showInProduction: debug === "force" })
         ]
@@ -1880,8 +2804,13 @@ function FormWithApi({
   debug,
   middleware,
   addressProvider,
+  onFieldChange,
+  honeypot,
+  rateLimit,
   children
 }) {
+  const { isBot } = useHoneypotCheck(honeypot);
+  const rateLimitState = useRateLimit(rateLimit);
   const formApi = useFormApi(api);
   const features = useFormFeatures({
     persistence,
@@ -1896,6 +2825,8 @@ function FormWithApi({
     defaultValues,
     validators: buildValidators(schema, validateOn),
     onSubmit: async ({ value, formApi: tanstackFormApi }) => {
+      if (isBot()) return;
+      if (rateLimitState && !rateLimitState.recordAttempt()) return;
       let dataToSubmit = value;
       if (middleware?.beforeSubmit) {
         const transformed = await middleware.beforeSubmit(dataToSubmit);
@@ -1918,6 +2849,7 @@ function FormWithApi({
       }
     }
   });
+  useFieldChangeListeners(form, onFieldChange);
   useEffect(() => {
     return features.subscribeToFormChanges(form);
   }, [form, features]);
@@ -1964,6 +2896,12 @@ function FormWithApi({
           form.handleSubmit();
         },
         children: [
+          honeypot && /* @__PURE__ */ jsx(HoneypotField, {}),
+          rateLimitState?.isBlocked && /* @__PURE__ */ jsxs("div", { role: "alert", style: { color: "var(--chakra-colors-fg-error, #e53e3e)", marginBottom: "1rem" }, children: [
+            "Too many attempts. Try again in ",
+            rateLimitState.secondsLeft,
+            "s."
+          ] }),
           children,
           debug && /* @__PURE__ */ jsx(FormDebugValues, { showInProduction: debug === "force" })
         ]
@@ -1982,6 +2920,11 @@ function FormRoot({
   disabled,
   readOnly,
   debug,
+  middleware,
+  addressProvider,
+  onFieldChange,
+  honeypot,
+  rateLimit,
   children
 }) {
   if (api) {
@@ -1998,6 +2941,11 @@ function FormRoot({
         disabled,
         readOnly,
         debug,
+        middleware,
+        addressProvider,
+        onFieldChange,
+        honeypot,
+        rateLimit,
         children
       }
     );
@@ -2019,6 +2967,11 @@ function FormRoot({
       disabled,
       readOnly,
       debug,
+      middleware,
+      addressProvider,
+      onFieldChange,
+      honeypot,
+      rateLimit,
       children
     }
   );
@@ -2123,6 +3076,25 @@ function FormBuilder({
   );
 }
 FormBuilder.displayName = "FormBuilder";
+function FormDivider({
+  label,
+  icon,
+  variant = "solid",
+  size = "xs",
+  colorPalette = "gray"
+}) {
+  if (!label && !icon) {
+    return /* @__PURE__ */ jsx(Separator, { variant, size, colorPalette, my: 3 });
+  }
+  return /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 3, my: 3, children: [
+    /* @__PURE__ */ jsx(Separator, { flex: "1", variant, size, colorPalette }),
+    /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 1.5, flexShrink: 0, children: [
+      icon && /* @__PURE__ */ jsx(Box, { color: "fg.muted", children: icon }),
+      /* @__PURE__ */ jsx(Text, { fontSize: "sm", color: "fg.muted", fontWeight: "medium", whiteSpace: "nowrap", children: label })
+    ] }),
+    /* @__PURE__ */ jsx(Separator, { flex: "1", variant, size, colorPalette })
+  ] });
+}
 function extractAllErrors(errors) {
   const messages = [];
   for (const error of errors) {
@@ -2187,26 +3159,1318 @@ function FormErrors({
     }
   );
 }
-function FormFromSchema({
-  schema,
-  initialValue,
-  onSubmit,
-  submitLabel = "Save",
-  showReset = false,
-  resetLabel = "Reset",
-  exclude,
-  validateOn,
-  middleware,
-  disabled,
-  readOnly,
-  debug,
-  persistence,
-  offline,
-  beforeButtons,
-  afterButtons,
-  gap = 4
-}) {
-  return /* @__PURE__ */ jsx(
+function createDocumentField(config) {
+  return createField({
+    displayName: config.displayName,
+    render: ({ field, resolved, hasError, errorMessage }) => {
+      const maskRef = useCallback((element) => {
+        if (!element) return;
+        withMask(config.mask, {
+          showMaskOnFocus: false,
+          clearIncomplete: true,
+          autoUnmask: false
+        })(element);
+      }, []);
+      const customError = config.validate ? config.validate(String(field.state.value ?? "")) : void 0;
+      const showError = hasError || !!customError;
+      const displayError = customError ?? errorMessage;
+      return /* @__PURE__ */ jsxs(Field.Root, { invalid: showError, required: resolved.required, disabled: resolved.disabled, children: [
+        /* @__PURE__ */ jsx(FieldLabel, { label: resolved.label, tooltip: resolved.tooltip, required: resolved.required }),
+        /* @__PURE__ */ jsx(InputGroup, { startElement: /* @__PURE__ */ jsx(Icon, { color: "fg.muted", children: config.icon }), children: /* @__PURE__ */ jsx(
+          Input,
+          {
+            ref: maskRef,
+            value: String(field.state.value ?? ""),
+            onChange: (e) => field.handleChange(e.target.value),
+            onBlur: field.handleBlur,
+            placeholder: config.placeholder
+          }
+        ) }),
+        /* @__PURE__ */ jsx(FieldError, { hasError: showError, errorMessage: displayError, helperText: resolved.helperText })
+      ] });
+    }
+  });
+}
+var FieldBankAccount = createDocumentField({
+  displayName: "FieldBankAccount",
+  mask: "99999999999999999999",
+  placeholder: "40702810038000000001",
+  icon: /* @__PURE__ */ jsx(LuLandmark, {}),
+  validate: (value) => {
+    const digits = value.replace(/\D/g, "");
+    if (!digits) return void 0;
+    if (digits.length !== 20) return "\u0420\u0430\u0441\u0447\u0451\u0442\u043D\u044B\u0439 \u0441\u0447\u0451\u0442 \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C 20 \u0446\u0438\u0444\u0440";
+    return void 0;
+  }
+});
+var FieldCorrAccount = createDocumentField({
+  displayName: "FieldCorrAccount",
+  mask: "99999999999999999999",
+  placeholder: "30101810400000000225",
+  icon: /* @__PURE__ */ jsx(LuLandmark, {}),
+  validate: (value) => {
+    const digits = value.replace(/\D/g, "");
+    if (!digits) return void 0;
+    if (digits.length !== 20) return "\u041A\u043E\u0440\u0440. \u0441\u0447\u0451\u0442 \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C 20 \u0446\u0438\u0444\u0440";
+    if (!digits.startsWith("301")) return '\u041A\u043E\u0440\u0440. \u0441\u0447\u0451\u0442 \u0434\u043E\u043B\u0436\u0435\u043D \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "301"';
+    return void 0;
+  }
+});
+var FieldBIK = createDocumentField({
+  displayName: "FieldBIK",
+  mask: "999999999",
+  placeholder: "044525225",
+  icon: /* @__PURE__ */ jsx(LuLandmark, {}),
+  validate: (value) => {
+    const digits = value.replace(/\D/g, "");
+    if (!digits) return void 0;
+    if (digits.length !== 9) return "\u0411\u0418\u041A \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C 9 \u0446\u0438\u0444\u0440";
+    return validateBik(digits) ? void 0 : '\u0411\u0418\u041A \u0434\u043E\u043B\u0436\u0435\u043D \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "04"';
+  }
+});
+var FieldINN = createDocumentField({
+  displayName: "FieldINN",
+  mask: "999999999999",
+  // 12 цифр максимум
+  placeholder: "7707083893",
+  icon: /* @__PURE__ */ jsx(LuFileText, {}),
+  validate: (value) => {
+    const digits = value.replace(/\D/g, "");
+    if (!digits) return void 0;
+    if (digits.length === 10) {
+      return validateInn10(digits) ? void 0 : "\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u043A\u043E\u043D\u0442\u0440\u043E\u043B\u044C\u043D\u0430\u044F \u0441\u0443\u043C\u043C\u0430 \u0418\u041D\u041D";
+    }
+    if (digits.length === 12) {
+      return validateInn12(digits) ? void 0 : "\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u043A\u043E\u043D\u0442\u0440\u043E\u043B\u044C\u043D\u0430\u044F \u0441\u0443\u043C\u043C\u0430 \u0418\u041D\u041D";
+    }
+    return "\u0418\u041D\u041D \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C 10 \u0438\u043B\u0438 12 \u0446\u0438\u0444\u0440";
+  }
+});
+var FieldKPP = createDocumentField({
+  displayName: "FieldKPP",
+  mask: "*********",
+  // 9 символов (цифры или буквы)
+  placeholder: "770701001",
+  icon: /* @__PURE__ */ jsx(LuFileText, {}),
+  validate: (value) => {
+    const clean = value.replace(/[\s-]/g, "").toUpperCase();
+    if (!clean) return void 0;
+    if (clean.length !== 9) return "\u041A\u041F\u041F \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C 9 \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432";
+    return validateKpp(clean) ? void 0 : "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442 \u041A\u041F\u041F";
+  }
+});
+var FieldOGRN = createDocumentField({
+  displayName: "FieldOGRN",
+  mask: "9999999999999",
+  placeholder: "1027700132195",
+  icon: /* @__PURE__ */ jsx(LuFileText, {}),
+  validate: (value) => {
+    const digits = value.replace(/\D/g, "");
+    if (!digits) return void 0;
+    if (digits.length !== 13) return "\u041E\u0413\u0420\u041D \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C 13 \u0446\u0438\u0444\u0440";
+    return validateOgrn(digits) ? void 0 : "\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u043A\u043E\u043D\u0442\u0440\u043E\u043B\u044C\u043D\u0430\u044F \u0441\u0443\u043C\u043C\u0430 \u041E\u0413\u0420\u041D";
+  }
+});
+var FieldPassport = createDocumentField({
+  displayName: "FieldPassport",
+  mask: "99 99 999999",
+  placeholder: "45 06 123456",
+  icon: /* @__PURE__ */ jsx(LuBookOpen, {}),
+  validate: (value) => {
+    const digits = value.replace(/\D/g, "");
+    if (!digits) return void 0;
+    if (digits.length !== 10) return "\u041F\u0430\u0441\u043F\u043E\u0440\u0442: \u0441\u0435\u0440\u0438\u044F (4 \u0446\u0438\u0444\u0440\u044B) + \u043D\u043E\u043C\u0435\u0440 (6 \u0446\u0438\u0444\u0440)";
+    return void 0;
+  }
+});
+var FieldSNILS = createDocumentField({
+  displayName: "FieldSNILS",
+  mask: "999-999-999 99",
+  placeholder: "123-456-789 00",
+  icon: /* @__PURE__ */ jsx(LuShield, {}),
+  validate: (value) => {
+    const digits = value.replace(/\D/g, "");
+    if (!digits) return void 0;
+    if (digits.length !== 11) return "\u0421\u041D\u0418\u041B\u0421 \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C 11 \u0446\u0438\u0444\u0440";
+    return validateSnils(digits) ? void 0 : "\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u043A\u043E\u043D\u0442\u0440\u043E\u043B\u044C\u043D\u0430\u044F \u0441\u0443\u043C\u043C\u0430 \u0421\u041D\u0418\u041B\u0421";
+  }
+});
+function mapZodType(zodType) {
+  switch (zodType) {
+    case "string":
+      return "string";
+    case "number":
+    case "bigint":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "date";
+    case "enum":
+    case "literal":
+      return "enum";
+    default:
+      return "unknown";
+  }
+}
+function getArrayElementFields(schema, arrayPath) {
+  const allFields = traverseSchema(schema);
+  const field = findFieldByPath(allFields, arrayPath);
+  if (field?.zodType === "array" && field.element?.children) {
+    return field.element.children;
+  }
+  return [];
+}
+function findFieldByPath(fields, path) {
+  const parts = path.split(".");
+  let current = fields;
+  for (let i = 0; i < parts.length; i++) {
+    const found = current.find((f) => f.name === parts[i]);
+    if (!found) return void 0;
+    if (i === parts.length - 1) return found;
+    if (found.children) {
+      current = found.children;
+    } else {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function fieldInfoToColumn(info) {
+  return {
+    name: info.name,
+    label: info.ui?.title ?? camelToTitle(info.name),
+    width: "auto",
+    align: mapZodType(info.zodType) === "number" ? "right" : "left",
+    fieldType: mapZodType(info.zodType),
+    readOnly: false,
+    required: info.required,
+    enumValues: info.enumValues,
+    placeholder: info.ui?.placeholder
+  };
+}
+function mergeColumns(userColumns, schemaColumns) {
+  return userColumns.filter((col) => !col.hidden).map((col) => {
+    const schemaCol = schemaColumns.find((sc) => sc.name === col.name);
+    if (col.computed) {
+      return {
+        name: col.name,
+        label: col.label ?? camelToTitle(col.name),
+        width: col.width ?? "auto",
+        align: col.align ?? "right",
+        fieldType: "number",
+        computed: col.computed,
+        format: col.format,
+        readOnly: true,
+        required: false
+      };
+    }
+    return {
+      name: col.name,
+      label: col.label ?? schemaCol?.label ?? camelToTitle(col.name),
+      width: col.width ?? schemaCol?.width ?? "auto",
+      align: col.align ?? schemaCol?.align ?? "left",
+      fieldType: schemaCol?.fieldType ?? "string",
+      readOnly: col.readOnly ?? schemaCol?.readOnly ?? false,
+      required: schemaCol?.required ?? false,
+      enumValues: schemaCol?.enumValues,
+      placeholder: schemaCol?.placeholder,
+      format: col.format
+    };
+  });
+}
+function camelToTitle(str) {
+  return str.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+}
+function useTableColumns(schema, arrayPath, userColumns) {
+  return useMemo(() => {
+    const schemaFields = getArrayElementFields(schema, arrayPath);
+    const autoColumns = schemaFields.map(fieldInfoToColumn);
+    if (!userColumns || userColumns.length === 0) {
+      return autoColumns;
+    }
+    return mergeColumns(userColumns, autoColumns);
+  }, [schema, arrayPath, userColumns]);
+}
+function FieldDataGrid({
+  name,
+  label,
+  columns: columnDefs,
+  pageSize = 20,
+  rowSelection = false,
+  onRowSave,
+  virtualized = false,
+  virtualHeight = "500px",
+  columnResizing = false,
+  size = "sm",
+  helperText,
+  disabled = false
+}) {
+  const { form, schema } = useDeclarativeForm();
+  const parentGroup = useFormGroup();
+  const fullPath = parentGroup ? `${parentGroup.name}.${name}` : name;
+  const resolvedCols = useTableColumns(schema, fullPath);
+  const [sorting, setSorting] = useState([]);
+  const [columnFilters, setColumnFilters] = useState([]);
+  const [columnOrder, setColumnOrder] = useState([]);
+  const [rowSelectionState, setRowSelectionState] = useState({});
+  const [editingCell, setEditingCell] = useState(null);
+  const [modifiedCells, setModifiedCells] = useState(/* @__PURE__ */ new Set());
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, mode: "array", children: (arrayField) => {
+    const data = arrayField.state.value ?? [];
+    const tableColumns = useMemo(() => {
+      const cols = [];
+      if (rowSelection) {
+        cols.push({
+          id: "select",
+          header: ({ table: table2 }) => /* @__PURE__ */ jsxs(
+            Checkbox.Root,
+            {
+              checked: table2.getIsAllPageRowsSelected() ? true : table2.getIsSomePageRowsSelected() ? "indeterminate" : false,
+              onCheckedChange: () => table2.toggleAllPageRowsSelected(),
+              size: "sm",
+              children: [
+                /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+                /* @__PURE__ */ jsx(Checkbox.Control, {})
+              ]
+            }
+          ),
+          cell: ({ row }) => /* @__PURE__ */ jsxs(
+            Checkbox.Root,
+            {
+              checked: row.getIsSelected(),
+              onCheckedChange: () => row.toggleSelected(),
+              size: "sm",
+              children: [
+                /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+                /* @__PURE__ */ jsx(Checkbox.Control, {})
+              ]
+            }
+          ),
+          size: 40,
+          enableSorting: false,
+          enableColumnFilter: false
+        });
+      }
+      for (const colDef of columnDefs) {
+        const resolved = resolvedCols.find((r) => r.name === colDef.name);
+        cols.push({
+          id: colDef.name,
+          accessorKey: colDef.name,
+          header: () => colDef.label ?? resolved?.label ?? colDef.name,
+          cell: ({ row, getValue }) => {
+            const rowIndex = row.index;
+            const value = getValue();
+            const isEditing = editingCell?.row === rowIndex && editingCell?.col === colDef.name;
+            if (isEditing && colDef.editable !== false) {
+              return /* @__PURE__ */ jsx(
+                EditableCell,
+                {
+                  value,
+                  fieldType: resolved?.fieldType ?? "string",
+                  onSave: (newValue) => {
+                    const fieldPath = `${fullPath}[${rowIndex}].${colDef.name}`;
+                    form.setFieldValue(fieldPath, newValue);
+                    setEditingCell(null);
+                    const cellKey2 = `${rowIndex}:${colDef.name}`;
+                    setModifiedCells((prev) => new Set(prev).add(cellKey2));
+                    if (onRowSave) {
+                      const updatedRow = { ...data[rowIndex], [colDef.name]: newValue };
+                      onRowSave(updatedRow, rowIndex);
+                    }
+                  },
+                  onCancel: () => setEditingCell(null)
+                }
+              );
+            }
+            const cellKey = `${rowIndex}:${colDef.name}`;
+            const isModified = modifiedCells.has(cellKey);
+            return /* @__PURE__ */ jsx(
+              Text,
+              {
+                cursor: colDef.editable !== false && !disabled ? "pointer" : "default",
+                onClick: () => {
+                  if (colDef.editable !== false && !disabled) {
+                    setEditingCell({ row: rowIndex, col: colDef.name });
+                  }
+                },
+                textAlign: colDef.align,
+                bg: isModified ? "yellow.100" : void 0,
+                _dark: isModified ? { bg: "yellow.900/20" } : void 0,
+                _hover: colDef.editable !== false && !disabled ? { bg: isModified ? "yellow.200" : "bg.subtle" } : void 0,
+                px: 1,
+                borderRadius: "sm",
+                transition: "background 0.3s",
+                children: value != null ? String(value) : "\u2014"
+              }
+            );
+          },
+          size: colDef.width ? parseInt(colDef.width) : void 0,
+          enableColumnFilter: !!colDef.filter,
+          enableSorting: true
+        });
+      }
+      return cols;
+    }, [columnDefs, resolvedCols, editingCell, disabled, fullPath, form, data, onRowSave, rowSelection]);
+    const table = useReactTable({
+      data,
+      columns: tableColumns,
+      state: {
+        sorting,
+        columnFilters,
+        rowSelection: rowSelectionState,
+        ...columnOrder.length > 0 ? { columnOrder } : {}
+      },
+      onSortingChange: setSorting,
+      onColumnFiltersChange: setColumnFilters,
+      onColumnOrderChange: setColumnOrder,
+      onRowSelectionChange: setRowSelectionState,
+      getCoreRowModel: getCoreRowModel(),
+      getSortedRowModel: getSortedRowModel(),
+      getFilteredRowModel: getFilteredRowModel(),
+      // Пагинация отключается при виртуализации
+      ...virtualized ? {} : { getPaginationRowModel: getPaginationRowModel() },
+      initialState: virtualized ? {} : { pagination: { pageSize } },
+      enableRowSelection: rowSelection,
+      enableColumnResizing: columnResizing,
+      columnResizeMode: "onChange"
+    });
+    const tableContainerRef = useRef(null);
+    const { rows: tableRows } = table.getRowModel();
+    const rowVirtualizer = useVirtualizer({
+      count: tableRows.length,
+      getScrollElement: () => tableContainerRef.current,
+      estimateSize: () => size === "sm" ? 36 : size === "md" ? 44 : 52,
+      overscan: 10,
+      enabled: virtualized
+    });
+    return /* @__PURE__ */ jsxs(Field.Root, { children: [
+      label && /* @__PURE__ */ jsx(Field.Label, { children: label }),
+      columnDefs.some((c) => c.filter) && /* @__PURE__ */ jsx(HStack, { gap: 2, mb: 2, flexWrap: "wrap", children: columnDefs.filter((c) => c.filter).map((colDef) => {
+        const column = table.getColumn(colDef.name);
+        if (!column) return null;
+        return /* @__PURE__ */ jsx(
+          Input,
+          {
+            size: "xs",
+            placeholder: `\u0424\u0438\u043B\u044C\u0442\u0440: ${colDef.label ?? colDef.name}`,
+            value: column.getFilterValue() ?? "",
+            onChange: (e) => column.setFilterValue(e.target.value || void 0),
+            maxW: "200px"
+          },
+          colDef.name
+        );
+      }) }),
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          ref: virtualized ? tableContainerRef : void 0,
+          overflowX: "auto",
+          overflowY: virtualized ? "auto" : void 0,
+          maxH: virtualized ? virtualHeight : void 0,
+          borderWidth: "1px",
+          borderRadius: "md",
+          children: /* @__PURE__ */ jsxs(Table.Root, { size, interactive: true, variant: "outline", children: [
+            /* @__PURE__ */ jsx(Table.Header, { children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx(Table.Row, { children: headerGroup.headers.map((header) => /* @__PURE__ */ jsxs(
+              Table.ColumnHeader,
+              {
+                cursor: header.column.getCanSort() ? "pointer" : "default",
+                onClick: header.column.getToggleSortingHandler(),
+                userSelect: "none",
+                w: columnResizing ? `${header.getSize()}px` : void 0,
+                position: "relative",
+                draggable: header.column.id !== "select",
+                onDragStart: (e) => {
+                  e.dataTransfer.setData("text/plain", header.column.id);
+                  e.dataTransfer.effectAllowed = "move";
+                },
+                onDragOver: (e) => e.preventDefault(),
+                onDrop: (e) => {
+                  e.preventDefault();
+                  const fromId = e.dataTransfer.getData("text/plain");
+                  const toId = header.column.id;
+                  if (fromId === toId) return;
+                  const currentOrder = columnOrder.length > 0 ? columnOrder : table.getAllLeafColumns().map((c) => c.id);
+                  const fromIdx = currentOrder.indexOf(fromId);
+                  const toIdx = currentOrder.indexOf(toId);
+                  if (fromIdx === -1 || toIdx === -1) return;
+                  const next = [...currentOrder];
+                  next.splice(fromIdx, 1);
+                  next.splice(toIdx, 0, fromId);
+                  setColumnOrder(next);
+                },
+                children: [
+                  /* @__PURE__ */ jsxs(HStack, { gap: 1, children: [
+                    /* @__PURE__ */ jsx(Text, { children: flexRender(header.column.columnDef.header, header.getContext()) }),
+                    header.column.getIsSorted() === "asc" && /* @__PURE__ */ jsx(Text, { fontSize: "xs", children: "\u2191" }),
+                    header.column.getIsSorted() === "desc" && /* @__PURE__ */ jsx(Text, { fontSize: "xs", children: "\u2193" })
+                  ] }),
+                  columnResizing && /* @__PURE__ */ jsx(
+                    Box,
+                    {
+                      position: "absolute",
+                      right: "0",
+                      top: "0",
+                      bottom: "0",
+                      w: "4px",
+                      cursor: "col-resize",
+                      userSelect: "none",
+                      onMouseDown: header.getResizeHandler(),
+                      onTouchStart: header.getResizeHandler(),
+                      bg: header.column.getIsResizing() ? "blue.500" : "transparent",
+                      _hover: { bg: "blue.300" }
+                    }
+                  )
+                ]
+              },
+              header.id
+            )) }, headerGroup.id)) }),
+            /* @__PURE__ */ jsx(Table.Body, { children: tableRows.length === 0 ? /* @__PURE__ */ jsx(Table.Row, { children: /* @__PURE__ */ jsx(Table.Cell, { colSpan: tableColumns.length, textAlign: "center", py: 8, children: /* @__PURE__ */ jsx(Text, { color: "fg.muted", children: "\u041D\u0435\u0442 \u0434\u0430\u043D\u043D\u044B\u0445" }) }) }) : virtualized ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+              rowVirtualizer.getVirtualItems().length > 0 && /* @__PURE__ */ jsx(Table.Row, { style: { height: `${rowVirtualizer.getVirtualItems()[0]?.start ?? 0}px` }, children: /* @__PURE__ */ jsx(Table.Cell, { colSpan: tableColumns.length, p: "0" }) }),
+              rowVirtualizer.getVirtualItems().map((virtualRow) => {
+                const row = tableRows[virtualRow.index];
+                return /* @__PURE__ */ jsx(
+                  Table.Row,
+                  {
+                    bg: row.getIsSelected() ? "blue.50" : void 0,
+                    _dark: row.getIsSelected() ? { bg: "blue.900/20" } : void 0,
+                    style: { height: `${virtualRow.size}px` },
+                    children: row.getVisibleCells().map((cell) => /* @__PURE__ */ jsx(Table.Cell, { children: flexRender(cell.column.columnDef.cell, cell.getContext()) }, cell.id))
+                  },
+                  row.id
+                );
+              }),
+              /* @__PURE__ */ jsx(
+                Table.Row,
+                {
+                  style: {
+                    height: `${rowVirtualizer.getTotalSize() - (rowVirtualizer.getVirtualItems().at(-1)?.end ?? 0)}px`
+                  },
+                  children: /* @__PURE__ */ jsx(Table.Cell, { colSpan: tableColumns.length, p: "0" })
+                }
+              )
+            ] }) : tableRows.map((row) => /* @__PURE__ */ jsx(
+              Table.Row,
+              {
+                bg: row.getIsSelected() ? "blue.50" : void 0,
+                _dark: row.getIsSelected() ? { bg: "blue.900/20" } : void 0,
+                children: row.getVisibleCells().map((cell) => /* @__PURE__ */ jsx(Table.Cell, { children: flexRender(cell.column.columnDef.cell, cell.getContext()) }, cell.id))
+              },
+              row.id
+            )) })
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsxs(HStack, { justify: "space-between", py: 2, children: [
+        /* @__PURE__ */ jsxs(HStack, { gap: 2, children: [
+          !virtualized && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "xs",
+                variant: "outline",
+                onClick: () => table.previousPage(),
+                disabled: !table.getCanPreviousPage(),
+                children: "\u2190 \u041D\u0430\u0437\u0430\u0434"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "xs",
+                variant: "outline",
+                onClick: () => table.nextPage(),
+                disabled: !table.getCanNextPage(),
+                children: "\u0414\u0430\u043B\u0435\u0435 \u2192"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "xs",
+              variant: "ghost",
+              onClick: () => {
+                const headers = columnDefs.map((c) => c.label ?? c.name).join(",");
+                const csvRows = data.map(
+                  (row) => columnDefs.map((c) => {
+                    const val = row[c.name];
+                    const str = String(val ?? "");
+                    return str.includes(",") ? `"${str}"` : str;
+                  }).join(",")
+                );
+                const csv = [headers, ...csvRows].join("\n");
+                const blob = new Blob([csv], { type: "text/csv;charset=utf-8;" });
+                const url = URL.createObjectURL(blob);
+                const a = document.createElement("a");
+                a.href = url;
+                a.download = `${name}-export.csv`;
+                a.click();
+                URL.revokeObjectURL(url);
+              },
+              children: "\u2193 CSV"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "fg.muted", children: virtualized ? `${data.length} \u0437\u0430\u043F\u0438\u0441\u0435\u0439` : `\u0421\u0442\u0440\u0430\u043D\u0438\u0446\u0430 ${table.getState().pagination.pageIndex + 1} \u0438\u0437 ${table.getPageCount()} (${data.length} \u0437\u0430\u043F\u0438\u0441\u0435\u0439)` })
+      ] }),
+      rowSelection && Object.keys(rowSelectionState).length > 0 && /* @__PURE__ */ jsx(HStack, { gap: 2, children: /* @__PURE__ */ jsxs(
+        Button,
+        {
+          size: "xs",
+          colorPalette: "red",
+          variant: "ghost",
+          onClick: () => {
+            const indices = Object.keys(rowSelectionState).filter((k) => rowSelectionState[k]).map(Number).sort((a, b) => b - a);
+            for (const idx of indices) {
+              arrayField.removeValue(idx);
+            }
+            setRowSelectionState({});
+          },
+          disabled,
+          children: [
+            "\u0423\u0434\u0430\u043B\u0438\u0442\u044C \u0432\u044B\u0431\u0440\u0430\u043D\u043D\u044B\u0435 (",
+            Object.values(rowSelectionState).filter(Boolean).length,
+            ")"
+          ]
+        }
+      ) }),
+      helperText && /* @__PURE__ */ jsx(Field.HelperText, { children: helperText })
+    ] });
+  } });
+}
+function EditableCell({
+  value,
+  fieldType,
+  onSave,
+  onCancel
+}) {
+  const [localValue, setLocalValue] = useState(String(value ?? ""));
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter") {
+      const coerced = fieldType === "number" ? Number(localValue) || 0 : localValue;
+      onSave(coerced);
+    }
+    if (e.key === "Escape") {
+      onCancel();
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Input,
+    {
+      size: "xs",
+      value: localValue,
+      onChange: (e) => setLocalValue(e.target.value),
+      onBlur: () => {
+        const coerced = fieldType === "number" ? Number(localValue) || 0 : localValue;
+        onSave(coerced);
+      },
+      onKeyDown: handleKeyDown,
+      type: fieldType === "number" ? "number" : "text",
+      autoFocus: true,
+      borderRadius: "0"
+    }
+  );
+}
+var TableEditorContext = createContext(null);
+function useTableEditorContext() {
+  const ctx = useContext(TableEditorContext);
+  if (!ctx) {
+    throw new Error("useTableEditorContext must be used inside <Form.Field.TableEditor>");
+  }
+  return ctx;
+}
+
+// src/lib/declarative/form-fields/table/table-utils.ts
+function formatCellValue(value, column) {
+  if (value === null || value === void 0 || value === "") return "";
+  if (column.format) {
+    return column.format(value);
+  }
+  if (column.fieldType === "boolean") {
+    return value ? "\u2713" : "\u2717";
+  }
+  if (column.fieldType === "date" && value instanceof Date) {
+    return value.toLocaleDateString();
+  }
+  if (column.fieldType === "number" && typeof value === "number") {
+    return value.toLocaleString();
+  }
+  return String(value);
+}
+function getDefaultRow(columns) {
+  const row = {};
+  for (const col of columns) {
+    if (col.computed) continue;
+    switch (col.fieldType) {
+      case "string":
+        row[col.name] = "";
+        break;
+      case "number":
+        row[col.name] = 0;
+        break;
+      case "boolean":
+        row[col.name] = false;
+        break;
+      case "date":
+        row[col.name] = "";
+        break;
+      case "enum":
+        row[col.name] = col.enumValues?.[0] ?? "";
+        break;
+      default:
+        row[col.name] = "";
+    }
+  }
+  return row;
+}
+function coerceValue(raw, column) {
+  const trimmed = raw.trim();
+  switch (column.fieldType) {
+    case "number": {
+      const normalized = trimmed.replace(",", ".").replace(/\s/g, "");
+      const num = Number(normalized);
+      return Number.isNaN(num) ? 0 : num;
+    }
+    case "boolean":
+      return ["true", "1", "\u0434\u0430", "yes", "\u2713"].includes(trimmed.toLowerCase());
+    case "date":
+      return trimmed;
+    default:
+      return trimmed;
+  }
+}
+function parseTSV(text) {
+  return text.split("\n").map((line) => line.split("	")).filter((row) => row.some((cell) => cell.trim() !== ""));
+}
+function computeAggregate(rows, columnName, type, computeFn) {
+  const values = rows.map((row) => {
+    const raw = computeFn ? computeFn(row) : row[columnName];
+    return typeof raw === "number" ? raw : Number(raw);
+  }).filter((v) => !Number.isNaN(v));
+  if (values.length === 0) return 0;
+  switch (type) {
+    case "sum":
+      return values.reduce((a, b) => a + b, 0);
+    case "avg":
+      return values.reduce((a, b) => a + b, 0) / values.length;
+    case "count":
+      return values.length;
+    case "min":
+      return Math.min(...values);
+    case "max":
+      return Math.max(...values);
+  }
+}
+function TableEditorFooter({ footerDefs, selectable, sortable }) {
+  const { columns, rows, readOnly } = useTableEditorContext();
+  if (footerDefs.length === 0 || rows.length === 0) return null;
+  const aggregates = /* @__PURE__ */ new Map();
+  for (const def of footerDefs) {
+    const col = columns.find((c) => c.name === def.column);
+    const value = computeAggregate(rows, def.column, def.aggregate, col?.computed);
+    aggregates.set(def.column, { value, def });
+  }
+  return /* @__PURE__ */ jsx(Table.Footer, { children: /* @__PURE__ */ jsxs(Table.Row, { fontWeight: "bold", children: [
+    sortable && !readOnly && /* @__PURE__ */ jsx(Table.Cell, {}),
+    selectable && !readOnly && /* @__PURE__ */ jsx(Table.Cell, {}),
+    columns.map((col) => {
+      const agg = aggregates.get(col.name);
+      return /* @__PURE__ */ jsx(Table.Cell, { textAlign: col.align, children: agg ? /* @__PURE__ */ jsxs(Text, { children: [
+        agg.def.label && /* @__PURE__ */ jsx(Text, { as: "span", color: "fg.muted", mr: "1", children: agg.def.label }),
+        agg.def.format ? agg.def.format(agg.value) : agg.value.toLocaleString()
+      ] }) : null }, col.name);
+    }),
+    !readOnly && /* @__PURE__ */ jsx(Table.Cell, {})
+  ] }) });
+}
+function TableEditorHeader({ selectable, sortable }) {
+  const { columns, rows, selectedRows, toggleSelectAll, readOnly } = useTableEditorContext();
+  const allSelected = rows.length > 0 && selectedRows.size === rows.length;
+  const someSelected = selectedRows.size > 0 && !allSelected;
+  return /* @__PURE__ */ jsx(Table.Header, { children: /* @__PURE__ */ jsxs(Table.Row, { children: [
+    sortable && !readOnly && /* @__PURE__ */ jsx(Table.ColumnHeader, { w: "40px" }),
+    selectable && !readOnly && /* @__PURE__ */ jsx(Table.ColumnHeader, { w: "40px", textAlign: "center", children: /* @__PURE__ */ jsxs(
+      Checkbox.Root,
+      {
+        checked: allSelected ? true : someSelected ? "indeterminate" : false,
+        onCheckedChange: () => toggleSelectAll(),
+        size: "sm",
+        children: [
+          /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+          /* @__PURE__ */ jsx(Checkbox.Control, {})
+        ]
+      }
+    ) }),
+    columns.map((col) => /* @__PURE__ */ jsxs(Table.ColumnHeader, { w: col.width, textAlign: col.align, children: [
+      col.label,
+      col.required && /* @__PURE__ */ jsx("span", { style: { color: "var(--chakra-colors-red-500)", marginLeft: "2px" }, children: "*" })
+    ] }, col.name)),
+    !readOnly && /* @__PURE__ */ jsx(Table.ColumnHeader, { w: "40px" })
+  ] }) });
+}
+function TableMobileView() {
+  const { columns, rows, addRow, removeRow, canAdd, canRemove, readOnly, disabled } = useTableEditorContext();
+  return /* @__PURE__ */ jsxs(VStack, { gap: 3, align: "stretch", children: [
+    rows.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "fg.muted", textAlign: "center", py: 6, children: "\u041D\u0435\u0442 \u0434\u0430\u043D\u043D\u044B\u0445" }) : rows.map((rowData, rowIndex) => /* @__PURE__ */ jsxs(Box, { p: 3, borderWidth: "1px", borderRadius: "md", position: "relative", children: [
+      /* @__PURE__ */ jsxs(HStack, { justify: "space-between", mb: 2, children: [
+        /* @__PURE__ */ jsxs(Text, { fontSize: "xs", color: "fg.muted", fontWeight: "bold", children: [
+          "#",
+          rowIndex + 1
+        ] }),
+        !readOnly && /* @__PURE__ */ jsx(
+          IconButton,
+          {
+            "aria-label": "\u0423\u0434\u0430\u043B\u0438\u0442\u044C",
+            size: "xs",
+            variant: "ghost",
+            colorPalette: "red",
+            onClick: () => removeRow(rowIndex),
+            disabled: !canRemove || disabled,
+            children: "\u2715"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(VStack, { gap: 1, align: "stretch", children: columns.map((col) => {
+        const value = col.computed ? col.computed(rowData) : rowData[col.name];
+        return /* @__PURE__ */ jsxs(HStack, { justify: "space-between", fontSize: "sm", children: [
+          /* @__PURE__ */ jsx(Text, { color: "fg.muted", fontWeight: "medium", minW: "80px", children: col.label }),
+          /* @__PURE__ */ jsx(Text, { textAlign: "right", children: formatCellValue(value, col) || "\u2014" })
+        ] }, col.name);
+      }) })
+    ] }, rowIndex)),
+    !readOnly && /* @__PURE__ */ jsx(Button, { size: "sm", variant: "outline", onClick: addRow, disabled: !canAdd || disabled, children: "+ \u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C" })
+  ] });
+}
+function TableCell({ rowIndex, colIndex, column, rowData }) {
+  const { form } = useDeclarativeForm();
+  const { navigation, setEditingCell, setFocusedCell, fullPath, disabled, readOnly } = useTableEditorContext();
+  const inputRef = useRef(null);
+  const cellRef = useRef(null);
+  const isEditing = navigation.editingCell?.row === rowIndex && navigation.editingCell?.col === colIndex;
+  const isComputed = !!column.computed;
+  const isReadOnly = readOnly || column.readOnly || isComputed || disabled;
+  const fieldPath = `${fullPath}[${rowIndex}].${column.name}`;
+  const startEdit = useCallback(() => {
+    if (isReadOnly) return;
+    setEditingCell({ row: rowIndex, col: colIndex });
+  }, [isReadOnly, setEditingCell, rowIndex, colIndex]);
+  const handleCellKeyDown = useCallback(
+    (e) => {
+      if (isReadOnly) return;
+      if (e.key === "Enter" || e.key === "F2") {
+        e.preventDefault();
+        startEdit();
+      }
+    },
+    [isReadOnly, startEdit]
+  );
+  if (isComputed) {
+    const computedValue = column.computed(rowData);
+    return /* @__PURE__ */ jsx(Table.Cell, { textAlign: column.align, "data-row": rowIndex, "data-col": colIndex, ref: cellRef, children: formatCellValue(computedValue, column) });
+  }
+  return /* @__PURE__ */ jsx(form.Field, { name: fieldPath, children: (field) => {
+    const errors = field.state.meta.errors;
+    const hasError = hasFieldErrors(errors);
+    const value = field.state.value;
+    if (isEditing) {
+      return /* @__PURE__ */ jsx(
+        EditingCell,
+        {
+          ref: inputRef,
+          column,
+          value,
+          hasError,
+          errors,
+          onBlur: (newValue) => {
+            field.handleChange(newValue);
+            setEditingCell(null);
+          },
+          onChange: (newValue) => field.handleChange(newValue),
+          rowIndex,
+          colIndex
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      Table.Cell,
+      {
+        ref: cellRef,
+        textAlign: column.align,
+        "data-row": rowIndex,
+        "data-col": colIndex,
+        tabIndex: isReadOnly ? void 0 : 0,
+        cursor: isReadOnly ? "default" : "pointer",
+        onClick: startEdit,
+        onKeyDown: handleCellKeyDown,
+        onFocus: () => setFocusedCell({ row: rowIndex, col: colIndex }),
+        borderColor: hasError ? "red.500" : void 0,
+        borderWidth: hasError ? "1px" : void 0,
+        title: hasError ? formatFieldErrors(errors) : void 0,
+        _hover: isReadOnly ? void 0 : { bg: "bg.subtle" },
+        children: formatCellValue(value, column) || /* @__PURE__ */ jsx("span", { style: { opacity: 0.4 }, children: column.placeholder ?? "\u2014" })
+      }
+    );
+  } });
+}
+function EditingCell({
+  column,
+  value,
+  hasError,
+  errors,
+  onBlur,
+  onChange,
+  rowIndex,
+  colIndex,
+  ref
+}) {
+  const { setEditingCell } = useTableEditorContext();
+  const [localValue, setLocalValue] = useState(String(value ?? ""));
+  useEffect(() => {
+    const el = ref.current;
+    if (el) {
+      el.focus();
+      if ("select" in el) {
+        el.select();
+      }
+    }
+  }, [ref]);
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        setEditingCell(null);
+      }
+      if (e.key === "Tab" || e.key === "Enter") ;
+    },
+    [setEditingCell]
+  );
+  if (column.fieldType === "enum" && column.enumValues) {
+    return /* @__PURE__ */ jsx(Table.Cell, { "data-row": rowIndex, "data-col": colIndex, p: "0", children: /* @__PURE__ */ jsx(NativeSelect.Root, { size: "sm", children: /* @__PURE__ */ jsxs(
+      NativeSelect.Field,
+      {
+        ref,
+        value: String(value ?? ""),
+        onChange: (e) => onChange(e.target.value),
+        onBlur: () => onBlur(value),
+        onKeyDown: handleKeyDown,
+        borderColor: hasError ? "red.500" : void 0,
+        children: [
+          /* @__PURE__ */ jsx("option", { value: "", children: "\u2014" }),
+          column.enumValues.map((v) => /* @__PURE__ */ jsx("option", { value: v, children: v }, v))
+        ]
+      }
+    ) }) });
+  }
+  if (column.fieldType === "boolean") {
+    return /* @__PURE__ */ jsx(Table.Cell, { "data-row": rowIndex, "data-col": colIndex, textAlign: "center", p: "0", children: /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref,
+        type: "checkbox",
+        checked: !!value,
+        onChange: (e) => {
+          onChange(e.target.checked);
+          onBlur(e.target.checked);
+        },
+        onKeyDown: handleKeyDown
+      }
+    ) });
+  }
+  const inputType = column.fieldType === "number" ? "number" : "text";
+  return /* @__PURE__ */ jsx(Table.Cell, { "data-row": rowIndex, "data-col": colIndex, p: "0", children: /* @__PURE__ */ jsx(
+    Input,
+    {
+      ref,
+      size: "sm",
+      type: inputType,
+      value: localValue,
+      onChange: (e) => setLocalValue(e.target.value),
+      onBlur: () => {
+        const coerced = column.fieldType === "number" ? Number(localValue) || 0 : localValue;
+        onBlur(coerced);
+      },
+      onKeyDown: handleKeyDown,
+      textAlign: column.align,
+      borderColor: hasError ? "red.500" : void 0,
+      borderRadius: "0",
+      title: hasError ? formatFieldErrors(errors) : void 0
+    }
+  ) });
+}
+function TableEditorRow({ rowIndex, rowData, selectable, sortable }) {
+  const { columns, removeRow, canRemove, selectedRows, toggleRowSelection, readOnly, disabled } = useTableEditorContext();
+  const isSelected = selectedRows.has(rowIndex);
+  return /* @__PURE__ */ jsxs(
+    Table.Row,
+    {
+      "data-row-index": rowIndex,
+      bg: isSelected ? "blue.50" : void 0,
+      _dark: isSelected ? { bg: "blue.900/20" } : void 0,
+      children: [
+        sortable && !readOnly && /* @__PURE__ */ jsx(Table.Cell, { w: "40px", cursor: "grab", textAlign: "center", color: "fg.muted", children: "\u283F" }),
+        selectable && !readOnly && /* @__PURE__ */ jsx(Table.Cell, { w: "40px", textAlign: "center", children: /* @__PURE__ */ jsxs(Checkbox.Root, { checked: isSelected, onCheckedChange: () => toggleRowSelection(rowIndex), size: "sm", children: [
+          /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+          /* @__PURE__ */ jsx(Checkbox.Control, {})
+        ] }) }),
+        columns.map((col, colIndex) => /* @__PURE__ */ jsx(TableCell, { rowIndex, colIndex, column: col, rowData }, col.name)),
+        !readOnly && /* @__PURE__ */ jsx(Table.Cell, { w: "40px", textAlign: "center", children: /* @__PURE__ */ jsx(
+          IconButton,
+          {
+            "aria-label": "\u0423\u0434\u0430\u043B\u0438\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u0443",
+            size: "xs",
+            variant: "ghost",
+            colorPalette: "red",
+            onClick: () => removeRow(rowIndex),
+            disabled: !canRemove || disabled,
+            children: "\u2715"
+          }
+        ) })
+      ]
+    }
+  );
+}
+function TableEditorToolbar({ addLabel = "\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u0443", actions }) {
+  const { rows, canAdd, addRow, selectedRows, removeRow, readOnly, disabled } = useTableEditorContext();
+  const handleBulkDelete = () => {
+    const indices = [...selectedRows].sort((a, b) => b - a);
+    for (const idx of indices) {
+      removeRow(idx);
+    }
+  };
+  return /* @__PURE__ */ jsxs(HStack, { justify: "space-between", py: "2", children: [
+    /* @__PURE__ */ jsxs(HStack, { gap: "2", children: [
+      !readOnly && /* @__PURE__ */ jsxs(Button, { size: "sm", variant: "outline", onClick: addRow, disabled: !canAdd || disabled, children: [
+        "+ ",
+        addLabel
+      ] }),
+      !readOnly && selectedRows.size > 0 && /* @__PURE__ */ jsxs(Button, { size: "sm", variant: "ghost", colorPalette: "red", onClick: handleBulkDelete, disabled, children: [
+        "\u0423\u0434\u0430\u043B\u0438\u0442\u044C \u0432\u044B\u0431\u0440\u0430\u043D\u043D\u044B\u0435 (",
+        selectedRows.size,
+        ")"
+      ] }),
+      actions
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { fontSize: "sm", color: "fg.muted", children: [
+      rows.length,
+      " ",
+      rows.length === 1 ? "\u0441\u0442\u0440\u043E\u043A\u0430" : rows.length < 5 ? "\u0441\u0442\u0440\u043E\u043A\u0438" : "\u0441\u0442\u0440\u043E\u043A"
+    ] })
+  ] });
+}
+function getEditableColIndices(columns) {
+  return columns.map((col, i) => !col.computed && !col.readOnly ? i : -1).filter((i) => i !== -1);
+}
+function useTableNavigation({
+  columns,
+  rowCount,
+  editingCell,
+  setEditingCell,
+  addRow,
+  canAdd,
+  readOnly
+}) {
+  const containerRef = useRef(null);
+  const editableIndices = getEditableColIndices(columns);
+  const focusCell = useCallback((row, col) => {
+    const container = containerRef.current;
+    if (!container) return;
+    const cell = container.querySelector(`[data-row="${row}"][data-col="${col}"]`);
+    if (cell instanceof HTMLElement) {
+      const input = cell.querySelector("input, select");
+      if (input) {
+        input.focus();
+      } else {
+        cell.focus();
+      }
+    }
+  }, []);
+  const moveToNext = useCallback(
+    (currentRow, currentCol, reverse = false) => {
+      if (readOnly || editableIndices.length === 0) return;
+      const currentEditIdx = editableIndices.indexOf(currentCol);
+      if (currentEditIdx === -1) return;
+      if (!reverse) {
+        if (currentEditIdx < editableIndices.length - 1) {
+          const nextCol = editableIndices[currentEditIdx + 1];
+          setEditingCell({ row: currentRow, col: nextCol });
+          requestAnimationFrame(() => focusCell(currentRow, nextCol));
+        } else if (currentRow < rowCount - 1) {
+          const nextCol = editableIndices[0];
+          setEditingCell({ row: currentRow + 1, col: nextCol });
+          requestAnimationFrame(() => focusCell(currentRow + 1, nextCol));
+        } else if (canAdd) {
+          addRow();
+          const nextCol = editableIndices[0];
+          requestAnimationFrame(() => {
+            setEditingCell({ row: currentRow + 1, col: nextCol });
+            requestAnimationFrame(() => focusCell(currentRow + 1, nextCol));
+          });
+        }
+      } else {
+        if (currentEditIdx > 0) {
+          const prevCol = editableIndices[currentEditIdx - 1];
+          setEditingCell({ row: currentRow, col: prevCol });
+          requestAnimationFrame(() => focusCell(currentRow, prevCol));
+        } else if (currentRow > 0) {
+          const prevCol = editableIndices[editableIndices.length - 1];
+          setEditingCell({ row: currentRow - 1, col: prevCol });
+          requestAnimationFrame(() => focusCell(currentRow - 1, prevCol));
+        }
+      }
+    },
+    [readOnly, editableIndices, rowCount, canAdd, addRow, setEditingCell, focusCell]
+  );
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (!editingCell) return;
+      const { row, col } = editingCell;
+      switch (e.key) {
+        case "Tab":
+          e.preventDefault();
+          setEditingCell(null);
+          requestAnimationFrame(() => moveToNext(row, col, e.shiftKey));
+          break;
+        case "Enter":
+          e.preventDefault();
+          setEditingCell(null);
+          requestAnimationFrame(() => moveToNext(row, col, false));
+          break;
+        case "Escape":
+          e.preventDefault();
+          setEditingCell(null);
+          requestAnimationFrame(() => focusCell(row, col));
+          break;
+        case "ArrowUp":
+          if (row > 0) {
+            e.preventDefault();
+            setEditingCell(null);
+            setEditingCell({ row: row - 1, col });
+            requestAnimationFrame(() => focusCell(row - 1, col));
+          }
+          break;
+        case "ArrowDown":
+          if (row < rowCount - 1) {
+            e.preventDefault();
+            setEditingCell(null);
+            setEditingCell({ row: row + 1, col });
+            requestAnimationFrame(() => focusCell(row + 1, col));
+          }
+          break;
+      }
+    },
+    [editingCell, setEditingCell, moveToNext, focusCell, rowCount]
+  );
+  return { containerRef, handleKeyDown, focusCell };
+}
+function FieldTableEditor({
+  name,
+  label,
+  columns: columnDefs,
+  addLabel,
+  sortable = false,
+  selectable = false,
+  footer,
+  maxRows: maxRowsProp,
+  minRows: minRowsProp,
+  clipboard = true,
+  emptyText = '\u041D\u0435\u0442 \u0434\u0430\u043D\u043D\u044B\u0445. \u041D\u0430\u0436\u043C\u0438\u0442\u0435 "\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u0443"',
+  size = "sm",
+  striped = false,
+  toolbarActions,
+  helperText,
+  disabled = false,
+  readOnly = false
+}) {
+  const { form, schema } = useDeclarativeForm();
+  const parentGroup = useFormGroup();
+  const fullPath = parentGroup ? `${parentGroup.name}.${name}` : name;
+  const columns = useTableColumns(schema, fullPath, columnDefs);
+  const constraints = getZodConstraints(schema, fullPath);
+  const maxRows = maxRowsProp ?? constraints.array?.maxItems;
+  const minRows = minRowsProp ?? constraints.array?.minItems;
+  const [navigation, setNavigation] = useState({
+    editingCell: null,
+    focusedCell: null
+  });
+  const [selectedRows, setSelectedRows] = useState(/* @__PURE__ */ new Set());
+  const setEditingCell = useCallback((cell) => {
+    setNavigation((prev) => ({ ...prev, editingCell: cell }));
+  }, []);
+  const setFocusedCell = useCallback((cell) => {
+    setNavigation((prev) => ({ ...prev, focusedCell: cell }));
+  }, []);
+  const toggleRowSelection = useCallback((index) => {
+    setSelectedRows((prev) => {
+      const next = new Set(prev);
+      if (next.has(index)) {
+        next.delete(index);
+      } else {
+        next.add(index);
+      }
+      return next;
+    });
+  }, []);
+  const addRowRef = { current: () => {
+  } };
+  const rowCountRef = { current: 0 };
+  const canAddRef = { current: false };
+  const { containerRef, handleKeyDown } = useTableNavigation({
+    columns,
+    rowCount: rowCountRef.current,
+    editingCell: navigation.editingCell,
+    setEditingCell,
+    addRow: () => addRowRef.current(),
+    canAdd: canAddRef.current,
+    readOnly
+  });
+  return /* @__PURE__ */ jsx(form.Field, { name: fullPath, mode: "array", children: (arrayField) => {
+    const rows = arrayField.state.value ?? [];
+    const canAdd = maxRows === void 0 || rows.length < maxRows;
+    const canRemove = minRows === void 0 || rows.length > minRows;
+    rowCountRef.current = rows.length;
+    canAddRef.current = canAdd;
+    const addRow = () => {
+      if (!canAdd) return;
+      arrayField.pushValue(getDefaultRow(columns));
+    };
+    addRowRef.current = addRow;
+    const removeRow = (index) => {
+      if (!canRemove) return;
+      arrayField.removeValue(index);
+      setSelectedRows((prev) => {
+        const next = /* @__PURE__ */ new Set();
+        for (const i of prev) {
+          if (i < index) next.add(i);
+          else if (i > index) next.add(i - 1);
+        }
+        return next;
+      });
+    };
+    const moveRow = (from, to) => {
+      arrayField.moveValue(from, to);
+    };
+    const toggleSelectAll = () => {
+      if (selectedRows.size === rows.length) {
+        setSelectedRows(/* @__PURE__ */ new Set());
+      } else {
+        setSelectedRows(new Set(rows.map((_, i) => i)));
+      }
+    };
+    const contextValue = {
+      columns,
+      rows,
+      fullPath,
+      canAdd,
+      canRemove,
+      addRow,
+      removeRow,
+      moveRow,
+      navigation,
+      setEditingCell,
+      setFocusedCell,
+      selectedRows,
+      toggleRowSelection,
+      toggleSelectAll,
+      disabled,
+      readOnly,
+      size
+    };
+    return /* @__PURE__ */ jsx(TableEditorContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxs(Field.Root, { children: [
+      label && /* @__PURE__ */ jsx(Field.Label, { children: label }),
+      /* @__PURE__ */ jsx(Box, { display: { base: "block", md: "none" }, children: /* @__PURE__ */ jsx(TableMobileView, {}) }),
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          ref: containerRef,
+          display: { base: "none", md: "block" },
+          overflowX: "auto",
+          borderWidth: "1px",
+          borderRadius: "md",
+          onKeyDown: handleKeyDown,
+          onPaste: clipboard ? (e) => {
+            const target = e.target;
+            if (target.tagName === "INPUT" || target.tagName === "TEXTAREA") return;
+            if (disabled || readOnly || !canAdd) return;
+            const text = e.clipboardData?.getData("text/plain");
+            if (!text) return;
+            const parsed = parseTSV(text);
+            if (parsed.length === 0) return;
+            e.preventDefault();
+            const editableCols = columns.filter((col) => !col.computed && !col.readOnly);
+            for (const rawRow of parsed) {
+              if (maxRows !== void 0 && rows.length >= maxRows) break;
+              const row = {};
+              for (let i = 0; i < editableCols.length && i < rawRow.length; i++) {
+                row[editableCols[i].name] = coerceValue(rawRow[i], editableCols[i]);
+              }
+              arrayField.pushValue(row);
+            }
+          } : void 0,
+          children: /* @__PURE__ */ jsxs(Table.Root, { size, striped, interactive: true, variant: "outline", children: [
+            /* @__PURE__ */ jsx(TableEditorHeader, { selectable, sortable }),
+            /* @__PURE__ */ jsx(Table.Body, { children: rows.length === 0 ? /* @__PURE__ */ jsx(Table.Row, { children: /* @__PURE__ */ jsx(
+              Table.Cell,
+              {
+                colSpan: columns.length + (selectable && !readOnly ? 1 : 0) + (sortable && !readOnly ? 1 : 0) + (!readOnly ? 1 : 0),
+                textAlign: "center",
+                py: "8",
+                children: /* @__PURE__ */ jsx(Text, { color: "fg.muted", children: emptyText })
+              }
+            ) }) : sortable && !readOnly ? /* @__PURE__ */ jsx(
+              SortableWrapper,
+              {
+                items: rows.map((_, i) => `${fullPath}-${i}`),
+                onReorder: (oldIdx, newIdx) => moveRow(oldIdx, newIdx),
+                children: rows.map((rowData, rowIndex) => /* @__PURE__ */ jsx(SortableItem, { id: `${fullPath}-${rowIndex}`, children: /* @__PURE__ */ jsx(
+                  TableEditorRow,
+                  {
+                    rowIndex,
+                    rowData,
+                    selectable,
+                    sortable
+                  }
+                ) }, `${fullPath}-${rowIndex}`))
+              }
+            ) : rows.map((rowData, rowIndex) => /* @__PURE__ */ jsx(
+              TableEditorRow,
+              {
+                rowIndex,
+                rowData,
+                selectable,
+                sortable
+              },
+              rowIndex
+            )) }),
+            footer && footer.length > 0 && /* @__PURE__ */ jsx(TableEditorFooter, { footerDefs: footer, selectable, sortable })
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsx(TableEditorToolbar, { addLabel, actions: toolbarActions }),
+      helperText && /* @__PURE__ */ jsx(Field.HelperText, { children: helperText })
+    ] }) });
+  } });
+}
+function FormFromSchema({
+  schema,
+  initialValue,
+  onSubmit,
+  submitLabel = "Save",
+  showReset = false,
+  resetLabel = "Reset",
+  exclude,
+  validateOn,
+  middleware,
+  disabled,
+  readOnly,
+  debug,
+  persistence,
+  offline,
+  beforeButtons,
+  afterButtons,
+  gap = 4
+}) {
+  return /* @__PURE__ */ jsx(
     FormSimple,
     {
       schema,
@@ -2232,6 +4496,37 @@ function FormFromSchema({
   );
 }
 FormFromSchema.displayName = "FormFromSchema";
+var STATUS_MAP = {
+  info: "info",
+  warning: "warning",
+  error: "error",
+  success: "success",
+  tip: "info"
+};
+var COLOR_MAP = {
+  info: "blue",
+  warning: "orange",
+  error: "red",
+  success: "green",
+  tip: "teal"
+};
+function FormInfoBlock({
+  variant = "info",
+  title,
+  children,
+  appearance = "subtle",
+  size = "md"
+}) {
+  const status = STATUS_MAP[variant] ?? "info";
+  const colorPalette = COLOR_MAP[variant] ?? "blue";
+  return /* @__PURE__ */ jsxs(Alert.Root, { status, variant: appearance, size, colorPalette, children: [
+    /* @__PURE__ */ jsx(Alert.Indicator, {}),
+    title ? /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Alert.Title, { children: title }),
+      /* @__PURE__ */ jsx(Alert.Description, { children })
+    ] }) : /* @__PURE__ */ jsx(Alert.Description, { children })
+  ] });
+}
 var FormStepsContext = createContext(null);
 function useFormStepsContext() {
   const context = useContext(FormStepsContext);
@@ -2827,7 +5122,7 @@ function evaluateWhenCondition(when, fieldValue) {
   }
   return Boolean(fieldValue);
 }
-function getNestedValue(values, path) {
+function getNestedValue3(values, path) {
   const parts = path.split(".");
   let value = values;
   for (const part of parts) {
@@ -2857,7 +5152,7 @@ function FormStepsStep({
     if (!when) {
       return true;
     }
-    const fieldValue = getNestedValue(form.state.values, when.field);
+    const fieldValue = getNestedValue3(form.state.values, when.field);
     return evaluateWhenCondition(when, fieldValue);
   });
   const indexRef = useRef(-1);
@@ -2867,7 +5162,7 @@ function FormStepsStep({
       return;
     }
     const subscription = form.store.subscribe(() => {
-      const fieldValue = getNestedValue(form.state.values, when.field);
+      const fieldValue = getNestedValue3(form.state.values, when.field);
       const newIsVisible = evaluateWhenCondition(when, fieldValue);
       if (newIsVisible !== wasVisibleRef.current) {
         wasVisibleRef.current = newIsVisible;
@@ -2996,6 +5291,68 @@ function FormStepsStep({
   ) }) });
 }
 FormStepsStep.displayName = "FormStepsStep";
+function getNestedValue4(obj, path) {
+  const parts = path.split(".");
+  let result = obj;
+  for (const part of parts) {
+    if (result && typeof result === "object") {
+      result = result[part];
+    } else {
+      return void 0;
+    }
+  }
+  return result;
+}
+function FormWatch({ field, onChange }) {
+  const { form } = useDeclarativeForm();
+  const parentGroup = useFormGroup();
+  const fullPath = parentGroup ? `${parentGroup.name}.${field}` : field;
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const subscribe = useCallback(
+    (callback) => {
+      const subscription = form.store.subscribe(callback);
+      if (typeof subscription === "function") {
+        return subscription;
+      }
+      return () => subscription.unsubscribe();
+    },
+    [form]
+  );
+  const getValueSnapshot = useCallback(
+    () => getNestedValue4(form.state.values, fullPath),
+    [form, fullPath]
+  );
+  const value = useSyncExternalStore(subscribe, getValueSnapshot, getValueSnapshot);
+  const fieldChangeApi = useMemo(
+    () => ({
+      setFieldValue: (name, val) => {
+        form.setFieldValue(name, val);
+      },
+      getFieldValue: (name) => {
+        return getNestedValue4(form.state.values, name);
+      },
+      getValues: () => {
+        return form.state.values;
+      }
+    }),
+    [form]
+  );
+  const prevValueRef = useRef(value);
+  const isFirstRender = useRef(true);
+  useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      prevValueRef.current = value;
+      return;
+    }
+    if (!Object.is(prevValueRef.current, value)) {
+      prevValueRef.current = value;
+      onChangeRef.current(value, fieldChangeApi);
+    }
+  }, [value, fieldChangeApi]);
+  return null;
+}
 function extractFieldNames2(children, parentPath = "") {
   const names = [];
   Children.forEach(children, (child) => {
@@ -3096,6 +5453,207 @@ function FormWhen({
     return /* @__PURE__ */ jsx(FormWhenContent, { shouldRender, fallback, parentPath, children });
   } });
 }
+function FormFromTemplate({
+  template,
+  onSubmit,
+  initialValue,
+  override,
+  submitLabel = "\u041E\u0442\u043F\u0440\u0430\u0432\u0438\u0442\u044C",
+  debug = false
+}) {
+  const mergedInitialValue = initialValue ? { ...template.defaultValues, ...initialValue } : template.defaultValues;
+  return /* @__PURE__ */ jsx(
+    Form2.FromSchema,
+    {
+      schema: template.schema,
+      initialValue: mergedInitialValue,
+      onSubmit,
+      exclude: override?.exclude,
+      debug,
+      submitLabel
+    }
+  );
+}
+var loginSchema = z.object({
+  email: z.email("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 email"),
+  password: z.string().min(6, "\u041C\u0438\u043D\u0438\u043C\u0443\u043C 6 \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432")
+}).strip();
+var loginForm = {
+  name: "loginForm",
+  title: "\u0412\u0445\u043E\u0434",
+  description: "\u0424\u043E\u0440\u043C\u0430 \u0432\u0445\u043E\u0434\u0430: email + \u043F\u0430\u0440\u043E\u043B\u044C",
+  category: "auth",
+  schema: loginSchema,
+  defaultValues: { email: "", password: "" },
+  renderFields: () => null
+  // Рендеринг через FormFromTemplate
+};
+var registerSchema = z.object({
+  name: z.string().min(2, "\u041C\u0438\u043D\u0438\u043C\u0443\u043C 2 \u0441\u0438\u043C\u0432\u043E\u043B\u0430"),
+  email: z.email("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 email"),
+  password: z.string().min(8, "\u041C\u0438\u043D\u0438\u043C\u0443\u043C 8 \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432"),
+  confirmPassword: z.string()
+}).strip().refine((d) => d.password === d.confirmPassword, {
+  message: "\u041F\u0430\u0440\u043E\u043B\u0438 \u043D\u0435 \u0441\u043E\u0432\u043F\u0430\u0434\u0430\u044E\u0442",
+  path: ["confirmPassword"]
+});
+var registerForm = {
+  name: "registerForm",
+  title: "\u0420\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F",
+  description: "\u0424\u043E\u0440\u043C\u0430 \u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u0438: \u0438\u043C\u044F, email, \u043F\u0430\u0440\u043E\u043B\u044C, \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435",
+  category: "auth",
+  schema: registerSchema,
+  defaultValues: { name: "", email: "", password: "", confirmPassword: "" },
+  renderFields: () => null
+};
+var forgotPasswordSchema = z.object({
+  email: z.email("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 email")
+}).strip();
+var forgotPasswordForm = {
+  name: "forgotPasswordForm",
+  title: "\u0412\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 \u043F\u0430\u0440\u043E\u043B\u044F",
+  description: "\u0424\u043E\u0440\u043C\u0430 \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F \u043F\u0430\u0440\u043E\u043B\u044F: email",
+  category: "auth",
+  schema: forgotPasswordSchema,
+  defaultValues: { email: "" },
+  renderFields: () => null
+};
+var contactSchema = z.object({
+  name: z.string().min(2, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0438\u043C\u044F"),
+  email: z.email("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 email"),
+  phone: z.string().optional(),
+  message: z.string().min(10, "\u041C\u0438\u043D\u0438\u043C\u0443\u043C 10 \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432")
+}).strip();
+var contactForm = {
+  name: "contactForm",
+  title: "\u041A\u043E\u043D\u0442\u0430\u043A\u0442\u043D\u0430\u044F \u0444\u043E\u0440\u043C\u0430",
+  description: "\u041E\u0431\u0440\u0430\u0442\u043D\u0430\u044F \u0441\u0432\u044F\u0437\u044C: \u0438\u043C\u044F, email, \u0442\u0435\u043B\u0435\u0444\u043E\u043D, \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435",
+  category: "feedback",
+  schema: contactSchema,
+  defaultValues: { name: "", email: "", phone: "", message: "" },
+  renderFields: () => null
+};
+var feedbackSchema = z.object({
+  rating: z.number().min(1).max(5),
+  category: z.string().min(1, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u043A\u0430\u0442\u0435\u0433\u043E\u0440\u0438\u044E"),
+  message: z.string().min(5, "\u041E\u043F\u0438\u0448\u0438\u0442\u0435 \u043F\u043E\u0434\u0440\u043E\u0431\u043D\u0435\u0435"),
+  email: z.email().optional()
+}).strip();
+var feedbackForm = {
+  name: "feedbackForm",
+  title: "\u041E\u0442\u0437\u044B\u0432",
+  description: "\u0424\u043E\u0440\u043C\u0430 \u043E\u0442\u0437\u044B\u0432\u0430: \u0440\u0435\u0439\u0442\u0438\u043D\u0433, \u043A\u0430\u0442\u0435\u0433\u043E\u0440\u0438\u044F, \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435",
+  category: "feedback",
+  schema: feedbackSchema,
+  defaultValues: { rating: 0, category: "", message: "", email: "" },
+  renderFields: () => null
+};
+var npsSchema = z.object({
+  score: z.number().min(0).max(10),
+  reason: z.string().optional(),
+  email: z.email().optional()
+}).strip();
+var npsForm = {
+  name: "npsForm",
+  title: "NPS-\u043E\u043F\u0440\u043E\u0441",
+  description: "Net Promoter Score: \u043E\u0446\u0435\u043D\u043A\u0430 0-10, \u043F\u0440\u0438\u0447\u0438\u043D\u0430, email",
+  category: "survey",
+  schema: npsSchema,
+  defaultValues: { score: 0, reason: "", email: "" },
+  renderFields: () => null
+};
+var companyRegistrationSchema = z.object({
+  inn: z.string().min(10, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0418\u041D\u041D"),
+  kpp: z.string().optional(),
+  ogrn: z.string().optional(),
+  name: z.string().min(2, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u043D\u0430\u0437\u0432\u0430\u043D\u0438\u0435"),
+  address: z.string().min(5, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0430\u0434\u0440\u0435\u0441"),
+  bik: z.string().optional(),
+  account: z.string().optional(),
+  corrAccount: z.string().optional()
+}).strip();
+var companyRegistrationForm = {
+  name: "companyRegistration",
+  title: "\u0420\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F \u043A\u043E\u043C\u043F\u0430\u043D\u0438\u0438",
+  description: "\u0420\u0435\u043A\u0432\u0438\u0437\u0438\u0442\u044B: \u0418\u041D\u041D, \u041A\u041F\u041F, \u041E\u0413\u0420\u041D, \u043D\u0430\u0437\u0432\u0430\u043D\u0438\u0435, \u0430\u0434\u0440\u0435\u0441, \u0431\u0430\u043D\u043A\u043E\u0432\u0441\u043A\u0438\u0435 \u0440\u0435\u043A\u0432\u0438\u0437\u0438\u0442\u044B",
+  category: "business",
+  schema: companyRegistrationSchema,
+  defaultValues: { inn: "", kpp: "", ogrn: "", name: "", address: "", bik: "", account: "", corrAccount: "" },
+  renderFields: () => null
+};
+var orderItemSchema = z.object({
+  product: z.string().min(1),
+  qty: z.number().min(1),
+  price: z.number().min(0)
+});
+var orderSchema = z.object({
+  customer: z.string().min(2, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0438\u043C\u044F"),
+  email: z.email("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 email"),
+  phone: z.string().optional(),
+  address: z.string().min(5, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0430\u0434\u0440\u0435\u0441"),
+  items: z.array(orderItemSchema).min(1, "\u0414\u043E\u0431\u0430\u0432\u044C\u0442\u0435 \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D \u0442\u043E\u0432\u0430\u0440"),
+  comment: z.string().optional()
+}).strip();
+var orderForm = {
+  name: "orderForm",
+  title: "\u0417\u0430\u043A\u0430\u0437",
+  description: "\u041E\u0444\u043E\u0440\u043C\u043B\u0435\u043D\u0438\u0435 \u0437\u0430\u043A\u0430\u0437\u0430: \u043A\u043B\u0438\u0435\u043D\u0442, \u0430\u0434\u0440\u0435\u0441, \u0442\u043E\u0432\u0430\u0440\u044B",
+  category: "ecommerce",
+  schema: orderSchema,
+  defaultValues: {
+    customer: "",
+    email: "",
+    phone: "",
+    address: "",
+    items: [{ product: "", qty: 1, price: 0 }],
+    comment: ""
+  },
+  renderFields: () => null
+};
+var profileSchema = z.object({
+  firstName: z.string().min(2, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0438\u043C\u044F"),
+  lastName: z.string().min(2, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0444\u0430\u043C\u0438\u043B\u0438\u044E"),
+  email: z.email("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 email"),
+  phone: z.string().optional()
+}).strip();
+var profileForm = {
+  name: "profileForm",
+  title: "\u041F\u0440\u043E\u0444\u0438\u043B\u044C",
+  description: "\u041B\u0438\u0447\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435: \u0438\u043C\u044F, \u0444\u0430\u043C\u0438\u043B\u0438\u044F, email, \u0442\u0435\u043B\u0435\u0444\u043E\u043D",
+  category: "profile",
+  schema: profileSchema,
+  defaultValues: { firstName: "", lastName: "", email: "", phone: "" },
+  renderFields: () => null
+};
+var addressSchema = z.object({
+  country: z.string().min(1, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0441\u0442\u0440\u0430\u043D\u0443"),
+  city: z.string().min(2, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0433\u043E\u0440\u043E\u0434"),
+  street: z.string().min(3, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0443\u043B\u0438\u0446\u0443"),
+  building: z.string().min(1, "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0434\u043E\u043C"),
+  apartment: z.string().optional(),
+  zip: z.string().optional()
+}).strip();
+var addressForm = {
+  name: "addressForm",
+  title: "\u0410\u0434\u0440\u0435\u0441",
+  description: "\u0410\u0434\u0440\u0435\u0441 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0438: \u0441\u0442\u0440\u0430\u043D\u0430, \u0433\u043E\u0440\u043E\u0434, \u0443\u043B\u0438\u0446\u0430, \u0434\u043E\u043C, \u043A\u0432\u0430\u0440\u0442\u0438\u0440\u0430, \u0438\u043D\u0434\u0435\u043A\u0441",
+  category: "address",
+  schema: addressSchema,
+  defaultValues: { country: "", city: "", street: "", building: "", apartment: "", zip: "" },
+  renderFields: () => null
+};
+var templates = {
+  loginForm,
+  registerForm,
+  forgotPasswordForm,
+  contactForm,
+  feedbackForm,
+  npsForm,
+  companyRegistration: companyRegistrationForm,
+  orderForm,
+  profileForm,
+  addressForm
+};
 function createLazyComponent(importFn, fallbackHeight = "40px") {
   const LazyComponent = lazy(async () => {
     const module = await importFn();
@@ -3119,8 +5677,6 @@ function createLazyComponents(imports, fallbackHeight = "40px") {
     {}
   );
 }
-
-// src/lib/declarative/create-form.tsx
 function createForm(options = {}) {
   const {
     extraFields = {},
@@ -3131,7 +5687,8 @@ function createForm(options = {}) {
     lazySelects = {},
     lazyComboboxes = {},
     lazyListboxes = {},
-    addressProvider
+    addressProvider,
+    captcha
   } = options;
   const lazySelectComponents = createLazyComponents(lazySelects);
   const lazyComboboxComponents = createLazyComponents(lazyComboboxes);
@@ -3157,10 +5714,14 @@ function createForm(options = {}) {
     ...lazyListboxComponents
   };
   const ExtendedForm = Object.assign(
-    // Root component
+    // Root component — оборачивает в CaptchaContext если captcha задан
     function ExtendedFormRoot(props) {
       const mergedProps = addressProvider && !props.addressProvider ? { ...props, addressProvider } : props;
-      return Form2(mergedProps);
+      const formElement = Form2(mergedProps);
+      if (captcha) {
+        return /* @__PURE__ */ jsx(CaptchaContext, { value: captcha, children: formElement });
+      }
+      return formElement;
     },
     {
       Group: Form2.Group,
@@ -3172,6 +5733,7 @@ function createForm(options = {}) {
       Errors: Form2.Errors,
       DebugValues: Form2.DebugValues,
       DirtyGuard: Form2.DirtyGuard,
+      Captcha: CaptchaField,
       When: Form2.When,
       Steps: Form2.Steps,
       AutoFields: Form2.AutoFields,
@@ -3185,7 +5747,7 @@ function useFieldActions(fieldName) {
   const { form } = useDeclarativeForm();
   const parentGroup = useFormGroup();
   const fullPath = parentGroup ? `${parentGroup.name}.${fieldName}` : fieldName;
-  const getNestedValue2 = useCallback(
+  const getNestedValue5 = useCallback(
     (values) => {
       const parts = fullPath.split(".");
       let result = values;
@@ -3211,8 +5773,8 @@ function useFieldActions(fieldName) {
     [form]
   );
   const getValueSnapshot = useCallback(
-    () => getNestedValue2(form.state.values),
-    [form, getNestedValue2]
+    () => getNestedValue5(form.state.values),
+    [form, getNestedValue5]
   );
   const getMetaSnapshot = useCallback(() => {
     const meta = form.store.state.fieldMeta[fullPath];
@@ -3445,6 +6007,271 @@ function dateMeta(config) {
     }
   };
 }
+function useConversationalState(totalFields) {
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const [isCompleted, setIsCompleted] = useState(false);
+  const next = useCallback(() => {
+    if (currentIndex < totalFields - 1) {
+      setCurrentIndex((i) => i + 1);
+    } else {
+      setIsCompleted(true);
+    }
+  }, [currentIndex, totalFields]);
+  const prev = useCallback(() => {
+    if (currentIndex > 0) {
+      setCurrentIndex((i) => i - 1);
+    }
+  }, [currentIndex]);
+  const goTo = useCallback((index) => {
+    if (index >= 0 && index < totalFields) {
+      setCurrentIndex(index);
+      setIsCompleted(false);
+    }
+  }, [totalFields]);
+  return {
+    currentIndex,
+    totalFields,
+    next,
+    prev,
+    goTo,
+    isFirst: currentIndex === 0,
+    isLast: currentIndex === totalFields - 1,
+    isCompleted,
+    progress: totalFields > 0 ? (currentIndex + 1) / totalFields : 0
+  };
+}
+function ConversationalMode({
+  children,
+  welcomeScreen,
+  completedScreen,
+  nextLabel = "\u0414\u0430\u043B\u0435\u0435",
+  prevLabel = "\u041D\u0430\u0437\u0430\u0434",
+  submitLabel = "\u041E\u0442\u043F\u0440\u0430\u0432\u0438\u0442\u044C",
+  showQuestionNumber = true,
+  showProgress = true,
+  onComplete
+}) {
+  const childArray = Children.toArray(children);
+  const state = useConversationalState(childArray.length);
+  const containerRef = useRef(null);
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey) {
+        const target = e.target;
+        if (target.tagName === "TEXTAREA") return;
+        e.preventDefault();
+        if (state.isLast) {
+          onComplete?.();
+        } else {
+          state.next();
+        }
+      }
+      if (e.key === "ArrowUp" && e.altKey) {
+        e.preventDefault();
+        state.prev();
+      }
+      if (e.key === "ArrowDown" && e.altKey) {
+        e.preventDefault();
+        state.next();
+      }
+    },
+    [state, onComplete]
+  );
+  if (state.isCompleted) {
+    return /* @__PURE__ */ jsx(VStack, { minH: "300px", justify: "center", align: "center", gap: 4, py: 12, children: completedScreen ?? /* @__PURE__ */ jsx(Text, { fontSize: "lg", children: "\u0413\u043E\u0442\u043E\u0432\u043E!" }) });
+  }
+  const currentChild = childArray[state.currentIndex];
+  return /* @__PURE__ */ jsxs(VStack, { gap: 6, align: "stretch", ref: containerRef, onKeyDown: handleKeyDown, children: [
+    showProgress && /* @__PURE__ */ jsx(Progress.Root, { value: state.progress * 100, size: "xs", colorPalette: "blue", children: /* @__PURE__ */ jsx(Progress.Track, { children: /* @__PURE__ */ jsx(Progress.Range, {}) }) }),
+    showQuestionNumber && /* @__PURE__ */ jsxs(Text, { fontSize: "sm", color: "fg.muted", children: [
+      "\u0412\u043E\u043F\u0440\u043E\u0441 ",
+      state.currentIndex + 1,
+      " \u0438\u0437 ",
+      state.totalFields
+    ] }),
+    /* @__PURE__ */ jsx(
+      Box,
+      {
+        minH: "150px",
+        py: 4,
+        css: {
+          animation: "fadeInUp 0.3s ease-out",
+          "@keyframes fadeInUp": {
+            from: { opacity: 0, transform: "translateY(20px)" },
+            to: { opacity: 1, transform: "translateY(0)" }
+          }
+        },
+        children: currentChild
+      },
+      state.currentIndex
+    ),
+    /* @__PURE__ */ jsxs(Flex, { justify: "space-between", pt: 2, children: [
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: "ghost",
+          onClick: state.prev,
+          disabled: state.isFirst,
+          size: "sm",
+          children: [
+            "\u2190 ",
+            prevLabel
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs(HStack, { gap: 2, children: [
+        /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "fg.muted", children: "Enter \u21B5" }),
+        state.isLast ? /* @__PURE__ */ jsx(Button, { colorPalette: "blue", onClick: onComplete, size: "sm", children: submitLabel }) : /* @__PURE__ */ jsxs(Button, { colorPalette: "blue", onClick: state.next, size: "sm", children: [
+          nextLabel,
+          " \u2192"
+        ] })
+      ] })
+    ] })
+  ] });
+}
+function useFormAutosave(form, config) {
+  const {
+    endpoint,
+    interval = 5e3,
+    debounce = 1e3,
+    draftId,
+    method = "POST",
+    headers = {},
+    onSave,
+    onError
+  } = config;
+  const [status, setStatus] = useState("idle");
+  const [lastSavedAt, setLastSavedAt] = useState(null);
+  const [error, setError] = useState(null);
+  const lastSavedDataRef = useRef("");
+  const timerRef = useRef(null);
+  const debounceRef = useRef(null);
+  const save = useCallback(
+    async (data) => {
+      const serialized = JSON.stringify(data);
+      if (serialized === lastSavedDataRef.current) return;
+      if (typeof navigator !== "undefined" && !navigator.onLine) {
+        if (draftId) {
+          try {
+            localStorage.setItem(`autosave:${draftId}`, serialized);
+          } catch {
+          }
+        }
+        return;
+      }
+      setStatus("saving");
+      setError(null);
+      try {
+        const url = draftId ? `${endpoint}?draftId=${encodeURIComponent(draftId)}` : endpoint;
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: serialized
+        });
+        if (!response.ok) {
+          throw new Error(`Autosave failed: ${response.status}`);
+        }
+        const result = await response.json().catch(() => null);
+        lastSavedDataRef.current = serialized;
+        setStatus("saved");
+        setLastSavedAt(/* @__PURE__ */ new Date());
+        onSave?.(result);
+        if (draftId) {
+          try {
+            localStorage.removeItem(`autosave:${draftId}`);
+          } catch {
+          }
+        }
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : "\u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u0438\u044F";
+        setStatus("error");
+        setError(errorMsg);
+        onError?.(err instanceof Error ? err : new Error(errorMsg));
+        if (draftId) {
+          try {
+            localStorage.setItem(`autosave:${draftId}`, serialized);
+          } catch {
+          }
+        }
+      }
+    },
+    [endpoint, method, headers, draftId, onSave, onError]
+  );
+  const saveNow = useCallback(async () => {
+    const values = form.state.values;
+    await save(values);
+  }, [form, save]);
+  const loadDraft = useCallback(async () => {
+    if (!draftId) return null;
+    if (typeof navigator === "undefined" || navigator.onLine) {
+      try {
+        const url = `${endpoint}?draftId=${encodeURIComponent(draftId)}`;
+        const response = await fetch(url);
+        if (response.ok) {
+          const data = await response.json();
+          return data;
+        }
+      } catch {
+      }
+    }
+    try {
+      const stored = localStorage.getItem(`autosave:${draftId}`);
+      if (stored) return JSON.parse(stored);
+    } catch {
+    }
+    return null;
+  }, [endpoint, draftId]);
+  useEffect(() => {
+    const tick = () => {
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+      debounceRef.current = setTimeout(() => {
+        const values = form.state.values;
+        save(values);
+      }, debounce);
+    };
+    timerRef.current = setInterval(tick, interval);
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current);
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    };
+  }, [form, save, interval, debounce]);
+  return { status, lastSavedAt, error, saveNow, loadDraft };
+}
+function AutosaveIndicator({
+  status,
+  lastSavedAt,
+  error,
+  labels
+}) {
+  if (status === "idle") return null;
+  const defaultLabels = {
+    idle: "",
+    saving: "\u0421\u043E\u0445\u0440\u0430\u043D\u044F\u044E...",
+    saved: "\u0421\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u043E",
+    error: "\u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u0438\u044F"
+  };
+  const l = { ...defaultLabels, ...labels };
+  return /* @__PURE__ */ jsxs(HStack, { gap: 2, fontSize: "xs", color: "fg.muted", children: [
+    status === "saving" && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+      /* @__PURE__ */ jsx(Spinner, { size: "xs" }),
+      /* @__PURE__ */ jsx(Text, { children: l.saving })
+    ] }),
+    status === "saved" && /* @__PURE__ */ jsxs(Text, { color: "green.500", children: [
+      "\u2713 ",
+      l.saved,
+      lastSavedAt && ` (${lastSavedAt.toLocaleTimeString()})`
+    ] }),
+    status === "error" && /* @__PURE__ */ jsxs(Text, { color: "red.500", children: [
+      "\u2715 ",
+      l.error,
+      ": ",
+      error
+    ] })
+  ] });
+}
 
 // src/lib/declarative/index.ts
 var ListButton = {
@@ -3505,7 +6332,31 @@ var FormField2 = {
   PinInput: FieldPinInput,
   OTPInput: FieldOTPInput,
   ColorPicker: FieldColorPicker,
-  FileUpload: FieldFileUpload
+  FileUpload: FieldFileUpload,
+  Signature: FieldSignature,
+  // Поля для опросников
+  MatrixChoice: FieldMatrixChoice,
+  ImageChoice: FieldImageChoice,
+  Likert: FieldLikert,
+  YesNo: FieldYesNo,
+  // Утилитарные поля
+  Hidden: FieldHidden,
+  Calculated: FieldCalculated,
+  // Табличные редакторы
+  TableEditor: FieldTableEditor,
+  DataGrid: FieldDataGrid,
+  // Банковская карта
+  CreditCard: CreditCardField
+};
+var FormDocument = {
+  INN: FieldINN,
+  KPP: FieldKPP,
+  OGRN: FieldOGRN,
+  BIK: FieldBIK,
+  BankAccount: FieldBankAccount,
+  CorrAccount: FieldCorrAccount,
+  SNILS: FieldSNILS,
+  Passport: FieldPassport
 };
 var FormButton = {
   Submit: ButtonSubmit,
@@ -3524,15 +6375,23 @@ var Form2 = Object.assign(Form, {
   Errors: FormErrors,
   DebugValues: FormDebugValues,
   DirtyGuard,
+  InfoBlock: FormInfoBlock,
+  Divider: FormDivider,
+  Watch: FormWatch,
   When: FormWhen,
   Steps: FormSteps2,
   Builder: FormBuilder,
   // Schema-based generation
   AutoFields: FormAutoFields,
   FromSchema: FormFromSchema,
+  FromTemplate: FormFromTemplate,
   // Offline support
   OfflineIndicator: FormOfflineIndicator,
-  SyncStatus: FormSyncStatus
+  SyncStatus: FormSyncStatus,
+  // Russian documents (ИНН, ОГРН, БИК, СНИЛС, паспорт)
+  Document: FormDocument,
+  // CAPTCHA (Turnstile / reCAPTCHA / hCaptcha)
+  Captcha: CaptchaField
 });
 function createSafeContext(contextName) {
   const Context = createContext(null);
@@ -3558,6 +6417,364 @@ function createNamedGroupContext(contextName) {
   return createSafeContext(contextName);
 }
 
-export { ButtonSubmit, ChakraFormField, Form2 as Form, FormField, FormGroupDeclarative, FormGroupList, FormGroupListDeclarative, FormGroupListItem, RelationFieldProvider, TanStackFormField, booleanMeta, commonMeta, createForm, createNamedGroupContext, createSafeContext, dateMeta, enumMeta, fieldContext, formContext, numberMeta, relationMeta, textMeta, useAppForm, useFieldActions, useFieldContext, useFormApi, useFormContext, useFormField, useFormGroupList, useFormGroupListItem, useFormStepsContext, useRelationFieldContext, useRelationOptions, useTanStackFormField, useTypedFormContext, useTypedFormSubscribe, withForm, withRelations, withUIMeta, withUIMetaDeep };
+// src/lib/captcha/verify.ts
+var VERIFY_URLS = {
+  turnstile: "https://challenges.cloudflare.com/turnstile/v0/siteverify",
+  recaptcha: "https://www.google.com/recaptcha/api/siteverify",
+  hcaptcha: "https://api.hcaptcha.com/siteverify"
+};
+async function verifyCaptcha(token, options) {
+  if (!token) {
+    return { success: false, errorCodes: ["missing-input-response"] };
+  }
+  const { provider, secretKey, remoteIp } = options;
+  const url = VERIFY_URLS[provider];
+  if (!url) {
+    return { success: false, errorCodes: ["unknown-provider"] };
+  }
+  const body = new URLSearchParams({
+    secret: secretKey,
+    response: token,
+    ...remoteIp ? { remoteip: remoteIp } : {}
+  });
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    return { success: false, errorCodes: ["network-error"] };
+  }
+  const data = await response.json();
+  return {
+    success: Boolean(data.success),
+    errorCodes: data["error-codes"] ?? data.errorCodes,
+    hostname: data.hostname,
+    challengeTs: data.challenge_ts ?? data.challengeTs
+  };
+}
+function HistoryControls({
+  history,
+  showCounter = true,
+  size = "sm"
+}) {
+  return /* @__PURE__ */ jsxs(HStack, { gap: 1, children: [
+    /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        "aria-label": "Undo (Ctrl+Z)",
+        size,
+        variant: "ghost",
+        disabled: !history.canUndo,
+        onClick: history.undo,
+        title: "\u041E\u0442\u043C\u0435\u043D\u0438\u0442\u044C (Ctrl+Z)",
+        children: "\u21A9"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        "aria-label": "Redo (Ctrl+Y)",
+        size,
+        variant: "ghost",
+        disabled: !history.canRedo,
+        onClick: history.redo,
+        title: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u044C (Ctrl+Y)",
+        children: "\u21AA"
+      }
+    ),
+    showCounter && /* @__PURE__ */ jsxs(Text, { fontSize: "xs", color: "fg.muted", minW: "40px", textAlign: "center", children: [
+      history.currentIndex + 1,
+      "/",
+      history.historyLength
+    ] })
+  ] });
+}
+function useFormHistory(form, config) {
+  const {
+    maxHistory = 50,
+    debounceMs = 500,
+    persist = false,
+    persistKey = "form-history",
+    keyboard = true
+  } = config ?? {};
+  const [history, setHistory] = useState(() => {
+    if (persist && typeof window !== "undefined") {
+      try {
+        const saved = sessionStorage.getItem(persistKey);
+        if (saved) return JSON.parse(saved);
+      } catch {
+      }
+    }
+    return [{ values: form.state.values, timestamp: Date.now() }];
+  });
+  const [currentIndex, setCurrentIndex] = useState(() => {
+    if (persist && typeof window !== "undefined") {
+      try {
+        const saved = sessionStorage.getItem(`${persistKey}-index`);
+        if (saved) return parseInt(saved, 10);
+      } catch {
+      }
+    }
+    return 0;
+  });
+  const debounceRef = useRef(null);
+  const isUndoRedoRef = useRef(false);
+  const pushSnapshot = useCallback((values) => {
+    setHistory((prev) => {
+      const base = prev.slice(0, currentIndex + 1);
+      const entry = { values: structuredClone(values), timestamp: Date.now() };
+      const next = [...base, entry];
+      const trimmed = next.length > maxHistory ? next.slice(next.length - maxHistory) : next;
+      return trimmed;
+    });
+    setCurrentIndex((prev) => {
+      const newIndex = Math.min(prev + 1, maxHistory - 1);
+      return newIndex;
+    });
+  }, [currentIndex, maxHistory]);
+  useEffect(() => {
+    const unsub = form.store.subscribe(() => {
+      if (isUndoRedoRef.current) return;
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+      debounceRef.current = setTimeout(() => {
+        pushSnapshot(form.state.values);
+      }, debounceMs);
+    });
+    return () => {
+      unsub();
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    };
+  }, [form.store, form.state.values, debounceMs, pushSnapshot]);
+  useEffect(() => {
+    if (!persist) return;
+    try {
+      sessionStorage.setItem(persistKey, JSON.stringify(history));
+      sessionStorage.setItem(`${persistKey}-index`, String(currentIndex));
+    } catch {
+    }
+  }, [history, currentIndex, persist, persistKey]);
+  const applySnapshot = useCallback((entry) => {
+    isUndoRedoRef.current = true;
+    const values = entry.values;
+    for (const [key, value] of Object.entries(values)) {
+      form.setFieldValue(key, value);
+    }
+    setTimeout(() => {
+      isUndoRedoRef.current = false;
+    }, 0);
+  }, [form]);
+  const undo = useCallback(() => {
+    if (currentIndex <= 0) return;
+    const newIndex = currentIndex - 1;
+    setCurrentIndex(newIndex);
+    applySnapshot(history[newIndex]);
+  }, [currentIndex, history, applySnapshot]);
+  const redo = useCallback(() => {
+    if (currentIndex >= history.length - 1) return;
+    const newIndex = currentIndex + 1;
+    setCurrentIndex(newIndex);
+    applySnapshot(history[newIndex]);
+  }, [currentIndex, history, applySnapshot]);
+  const clear = useCallback(() => {
+    const initial = { values: form.state.values, timestamp: Date.now() };
+    setHistory([initial]);
+    setCurrentIndex(0);
+    if (persist) {
+      try {
+        sessionStorage.removeItem(persistKey);
+        sessionStorage.removeItem(`${persistKey}-index`);
+      } catch {
+      }
+    }
+  }, [form.state.values, persist, persistKey]);
+  useEffect(() => {
+    if (!keyboard || typeof window === "undefined") return;
+    const handler = (e) => {
+      const isCtrl = e.ctrlKey || e.metaKey;
+      if (!isCtrl) return;
+      if (e.key === "z" && !e.shiftKey) {
+        e.preventDefault();
+        undo();
+      } else if (e.key === "z" && e.shiftKey || e.key === "y") {
+        e.preventDefault();
+        redo();
+      }
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [keyboard, undo, redo]);
+  return {
+    undo,
+    redo,
+    canUndo: currentIndex > 0,
+    canRedo: currentIndex < history.length - 1,
+    currentIndex,
+    historyLength: history.length,
+    clear,
+    history
+  };
+}
+function FormReadOnlyView({
+  data,
+  schema,
+  labels = {},
+  exclude = [],
+  include,
+  formatters = {},
+  compact = false
+}) {
+  const schemaLabels = {};
+  if (schema?._def?.shape) {
+    try {
+      const shape = schema._def.shape();
+      for (const [key, fieldSchema] of Object.entries(shape)) {
+        const title = fieldSchema?._def?.meta?.ui?.title;
+        if (title) schemaLabels[key] = title;
+      }
+    } catch {
+    }
+  }
+  const entries = Object.entries(data).filter(([key]) => {
+    if (exclude.includes(key)) return false;
+    if (include && !include.includes(key)) return false;
+    return true;
+  });
+  return /* @__PURE__ */ jsx(VStack, { gap: compact ? 2 : 4, align: "stretch", children: entries.map(([key, value], index) => {
+    const label = labels[key] ?? schemaLabels[key] ?? humanizeKey(key);
+    const formatter = formatters[key];
+    const displayValue = formatter ? formatter(value) : formatValue(value);
+    return compact ? /* @__PURE__ */ jsxs(HStack, { justify: "space-between", fontSize: "sm", children: [
+      /* @__PURE__ */ jsx(Text, { color: "fg.muted", fontWeight: "medium", children: label }),
+      /* @__PURE__ */ jsx(Text, { children: displayValue })
+    ] }, key) : /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "fg.muted", fontWeight: "medium", mb: 1, children: label }),
+      /* @__PURE__ */ jsx(Text, { fontSize: "sm", children: displayValue }),
+      index < entries.length - 1 && /* @__PURE__ */ jsx(Separator, { mt: 3 })
+    ] }, key);
+  }) });
+}
+function humanizeKey(key) {
+  return key.replace(/([A-Z])/g, " $1").replace(/[_-]/g, " ").trim().replace(/^\w/, (c) => c.toUpperCase());
+}
+function formatValue(value) {
+  if (value == null) return "\u2014";
+  if (typeof value === "boolean") return value ? "\u0414\u0430" : "\u041D\u0435\u0442";
+  if (value instanceof Date) return value.toLocaleDateString("ru-RU");
+  if (Array.isArray(value)) return value.join(", ");
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function FormSkeleton({
+  fields = 5,
+  showSubmit = true,
+  fieldHeight = "60px",
+  gap = 4
+}) {
+  let fieldCount;
+  if (typeof fields === "number") {
+    fieldCount = fields;
+  } else if (fields?._def?.shape) {
+    try {
+      fieldCount = Object.keys(fields._def.shape()).length;
+    } catch {
+      fieldCount = 5;
+    }
+  } else {
+    fieldCount = 5;
+  }
+  return /* @__PURE__ */ jsxs(VStack, { gap, align: "stretch", children: [
+    Array.from({ length: fieldCount }, (_, i) => /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Skeleton, { height: "14px", width: `${60 + Math.random() * 40}%`, mb: 2 }),
+      /* @__PURE__ */ jsx(Skeleton, { height: fieldHeight, borderRadius: "md" })
+    ] }, i)),
+    showSubmit && /* @__PURE__ */ jsx(Box, { pt: 2, children: /* @__PURE__ */ jsx(Skeleton, { height: "40px", width: "140px", borderRadius: "md" }) })
+  ] });
+}
+function FormComparison({
+  original,
+  current,
+  schema,
+  labels = {},
+  onlyChanged = false,
+  exclude = []
+}) {
+  const schemaLabels = {};
+  if (schema?._def?.shape) {
+    try {
+      const shape = schema._def.shape();
+      for (const [key, fieldSchema] of Object.entries(shape)) {
+        const title = fieldSchema?._def?.meta?.ui?.title;
+        if (title) schemaLabels[key] = title;
+      }
+    } catch {
+    }
+  }
+  const allKeys = [.../* @__PURE__ */ new Set([...Object.keys(original), ...Object.keys(current)])].filter((key) => !exclude.includes(key));
+  const entries = allKeys.map((key) => ({
+    key,
+    label: labels[key] ?? schemaLabels[key] ?? humanizeKey2(key),
+    oldValue: original[key],
+    newValue: current[key],
+    changed: JSON.stringify(original[key]) !== JSON.stringify(current[key])
+  })).filter((entry) => !onlyChanged || entry.changed);
+  if (entries.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "fg.muted", fontSize: "sm", children: "\u041D\u0435\u0442 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439" });
+  }
+  return /* @__PURE__ */ jsx(VStack, { gap: 3, align: "stretch", children: entries.map((entry, index) => /* @__PURE__ */ jsxs(
+    Box,
+    {
+      p: 3,
+      borderRadius: "md",
+      bg: entry.changed ? "yellow.50" : "transparent",
+      _dark: entry.changed ? { bg: "yellow.900/20" } : {},
+      children: [
+        /* @__PURE__ */ jsxs(Text, { fontSize: "xs", color: "fg.muted", fontWeight: "medium", mb: 1, children: [
+          entry.label,
+          entry.changed && /* @__PURE__ */ jsx(Text, { as: "span", color: "orange.500", ml: 1, children: "\u25CF" })
+        ] }),
+        entry.changed ? /* @__PURE__ */ jsxs(HStack, { gap: 4, fontSize: "sm", children: [
+          /* @__PURE__ */ jsxs(Box, { flex: 1, children: [
+            /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "red.500", mb: 0.5, children: "\u0411\u044B\u043B\u043E:" }),
+            /* @__PURE__ */ jsx(Text, { textDecoration: "line-through", color: "fg.muted", children: formatValue2(entry.oldValue) })
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { flex: 1, children: [
+            /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "green.500", mb: 0.5, children: "\u0421\u0442\u0430\u043B\u043E:" }),
+            /* @__PURE__ */ jsx(Text, { fontWeight: "medium", children: formatValue2(entry.newValue) })
+          ] })
+        ] }) : /* @__PURE__ */ jsx(Text, { fontSize: "sm", children: formatValue2(entry.newValue) }),
+        index < entries.length - 1 && /* @__PURE__ */ jsx(Separator, { mt: 2 })
+      ]
+    },
+    entry.key
+  )) });
+}
+function humanizeKey2(key) {
+  return key.replace(/([A-Z])/g, " $1").replace(/[_-]/g, " ").trim().replace(/^\w/, (c) => c.toUpperCase());
+}
+function formatValue2(value) {
+  if (value == null) return "\u2014";
+  if (typeof value === "boolean") return value ? "\u0414\u0430" : "\u041D\u0435\u0442";
+  if (value instanceof Date) return value.toLocaleDateString("ru-RU");
+  if (Array.isArray(value)) return value.join(", ");
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function FormDependsOn({ field, cases, fallback }) {
+  const { form } = useDeclarativeForm();
+  return /* @__PURE__ */ jsx(form.Subscribe, { selector: (state) => state.values[field], children: (value) => {
+    const key = String(value ?? "");
+    const content = cases[key];
+    if (content !== void 0) {
+      return /* @__PURE__ */ jsx(Fragment$1, { children: content });
+    }
+    if (fallback !== void 0) {
+      return /* @__PURE__ */ jsx(Fragment$1, { children: fallback });
+    }
+    return null;
+  } });
+}
+
+export { AutosaveIndicator, ButtonSubmit, CAPTCHA_TOKEN_FIELD, CaptchaContext, CaptchaField, ChakraFormField, ConversationalMode, FieldCalculated, FieldHidden, Form2 as Form, FormComparison, FormDependsOn, FormDivider, FormField, FormFromTemplate, FormGroupDeclarative, FormGroupList, FormGroupListDeclarative, FormGroupListItem, FormInfoBlock, FormReadOnlyView, FormSkeleton, FormWatch, HistoryControls, RelationFieldProvider, TanStackFormField, booleanMeta, commonMeta, createForm, createNamedGroupContext, createSafeContext, dateMeta, enumMeta, fieldContext, formContext, numberMeta, relationMeta, templates, textMeta, useAppForm, useCaptchaConfig, useConversationalState, useFieldActions, useFieldContext, useFormApi, useFormAutosave, useFormContext, useFormField, useFormGroupList, useFormGroupListItem, useFormHistory, useFormStepsContext, useRateLimit, useRelationFieldContext, useRelationOptions, useTanStackFormField, useTypedFormContext, useTypedFormSubscribe, verifyCaptcha, withForm, withRelations, withUIMeta, withUIMetaDeep };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map