@fogpipe/forma-react 0.9.0 → 0.10.1

package/src/__tests__/FormRenderer.test.tsx

@@ -799,5 +799,172 @@ describe("FormRenderer", () => {
         expect(screen.queryByTestId("array-item-items-1")).not.toBeInTheDocument();
       });
     });
+
+    // Stale closure regression tests - these verify the fix for the bug where
+    // cached array helper functions captured stale forma state
+    describe("stale closure regression", () => {
+      it("should add multiple items consecutively without losing items", async () => {
+        const user = userEvent.setup();
+        const spec = createTestSpec({
+          fields: {
+            items: {
+              type: "array",
+              label: "Items",
+              itemFields: { name: { type: "text" } },
+            },
+          },
+        });
+
+        render(
+          <FormRenderer
+            spec={spec}
+            initialData={{ items: [] }}
+            components={createTestComponentMap()}
+          />
+        );
+
+        const addButton = screen.getByTestId("add-items");
+
+        // Add first item
+        await user.click(addButton);
+        await waitFor(() => {
+          expect(screen.getByTestId("array-item-items-0")).toBeInTheDocument();
+        });
+
+        // Add second item - this would fail with stale closure bug
+        await user.click(addButton);
+        await waitFor(() => {
+          expect(screen.getByTestId("array-item-items-0")).toBeInTheDocument();
+          expect(screen.getByTestId("array-item-items-1")).toBeInTheDocument();
+        });
+
+        // Add third item - verifies the fix works across multiple operations
+        await user.click(addButton);
+        await waitFor(() => {
+          expect(screen.getByTestId("array-item-items-0")).toBeInTheDocument();
+          expect(screen.getByTestId("array-item-items-1")).toBeInTheDocument();
+          expect(screen.getByTestId("array-item-items-2")).toBeInTheDocument();
+        });
+      });
+
+      it("should remove items correctly after adding multiple items", async () => {
+        const user = userEvent.setup();
+        const spec = createTestSpec({
+          fields: {
+            items: {
+              type: "array",
+              label: "Items",
+              itemFields: { name: { type: "text" } },
+            },
+          },
+        });
+
+        render(
+          <FormRenderer
+            spec={spec}
+            initialData={{ items: [] }}
+            components={createTestComponentMap()}
+          />
+        );
+
+        const addButton = screen.getByTestId("add-items");
+
+        // Add three items
+        await user.click(addButton);
+        await user.click(addButton);
+        await user.click(addButton);
+
+        await waitFor(() => {
+          expect(screen.getByTestId("array-item-items-2")).toBeInTheDocument();
+        });
+
+        // Remove middle item - this would fail with stale closure bug
+        const removeMiddle = screen.getByTestId("remove-items-1");
+        await user.click(removeMiddle);
+
+        await waitFor(() => {
+          // Should have 2 items remaining (indices 0 and 1)
+          expect(screen.getByTestId("array-item-items-0")).toBeInTheDocument();
+          expect(screen.getByTestId("array-item-items-1")).toBeInTheDocument();
+          expect(screen.queryByTestId("array-item-items-2")).not.toBeInTheDocument();
+        });
+      });
+
+      it("should preserve existing items when adding to non-empty array", async () => {
+        const user = userEvent.setup();
+        const onChange = vi.fn();
+        const spec = createTestSpec({
+          fields: {
+            items: {
+              type: "array",
+              label: "Items",
+              itemFields: { name: { type: "text" } },
+            },
+          },
+        });
+
+        render(
+          <FormRenderer
+            spec={spec}
+            initialData={{ items: [{ name: "Existing Item" }] }}
+            components={createTestComponentMap()}
+            onChange={onChange}
+          />
+        );
+
+        // Verify initial state
+        expect(screen.getByTestId("array-item-items-0")).toBeInTheDocument();
+
+        // Add new item
+        const addButton = screen.getByTestId("add-items");
+        await user.click(addButton);
+
+        await waitFor(() => {
+          expect(screen.getByTestId("array-item-items-0")).toBeInTheDocument();
+          expect(screen.getByTestId("array-item-items-1")).toBeInTheDocument();
+        });
+
+        // Verify onChange was called with both items
+        const lastCall = onChange.mock.calls[onChange.mock.calls.length - 1];
+        const data = lastCall[0];
+        expect(data.items).toHaveLength(2);
+        expect(data.items[0]).toEqual({ name: "Existing Item" });
+      });
+
+      it("should handle rapid consecutive add operations", async () => {
+        const user = userEvent.setup();
+        const spec = createTestSpec({
+          fields: {
+            items: {
+              type: "array",
+              label: "Items",
+              itemFields: { name: { type: "text" } },
+            },
+          },
+        });
+
+        render(
+          <FormRenderer
+            spec={spec}
+            initialData={{ items: [] }}
+            components={createTestComponentMap()}
+          />
+        );
+
+        const addButton = screen.getByTestId("add-items");
+
+        // Rapidly add 5 items
+        for (let i = 0; i < 5; i++) {
+          await user.click(addButton);
+        }
+
+        // All 5 items should be present
+        await waitFor(() => {
+          for (let i = 0; i < 5; i++) {
+            expect(screen.getByTestId(`array-item-items-${i}`)).toBeInTheDocument();
+          }
+        });
+      });
+    });
   });
 });

package/src/__tests__/canProceed.test.ts

@@ -249,10 +249,12 @@ describe("canProceed", () => {
       expect(result.current.wizard?.canProceed).toBe(true);
     });
 
-    it("required boolean fields - undefined vs false", () => {
-      // Note: For boolean fields, "required" means "must have a value" (true or false),
-      // NOT "must be true". This is consistent with other field types where required
-      // means "not empty". For checkboxes that must be checked (like "Accept Terms"),
+    it("required boolean fields - auto-initialized to false", () => {
+      // Boolean fields are auto-initialized to false, which is a valid value.
+      // This provides better UX - the form is valid from the start since
+      // false is a valid answer to "Do you have pets?"
+      //
+      // For checkboxes that must be checked (like "Accept Terms"),
       // use a validation rule: { rule: "value = true", message: "Must accept terms" }
       const spec = createTestSpec({
         fields: {
@@ -263,13 +265,14 @@ describe("canProceed", () => {
         ],
       });
 
-      // undefined should be invalid (user hasn't answered)
-      const { result: resultUndefined } = renderHook(() =>
+      // With auto-initialization, boolean defaults to false (a valid value)
+      const { result: resultDefault } = renderHook(() =>
         useForma({ spec, initialData: {} })
       );
-      expect(resultUndefined.current.wizard?.canProceed).toBe(false);
+      expect(resultDefault.current.data.hasPets).toBe(false);
+      expect(resultDefault.current.wizard?.canProceed).toBe(true); // false is valid
 
-      // false should be valid (user answered "no")
+      // explicit false should be valid (user answered "no")
       const { result: resultFalse } = renderHook(() =>
         useForma({ spec, initialData: { hasPets: false } })
       );

package/src/__tests__/diabetes-trial-flow.test.ts

@@ -313,16 +313,23 @@ describe("diabetes trial enrollment wizard", () => {
       expect(pages?.[3].visible).toBe(true);
     });
 
-    it("should hide conditional pages initially", () => {
+    it("should show conditional pages based on auto-initialized boolean state", () => {
+      // With boolean auto-initialization to false:
+      // - All inclusion criteria (booleans) start as false → allInclusionMet = false
+      // - All exclusion criteria (booleans) start as false → anyExclusionMet = false
+      // - eligibilityDetermined = true (all fields have values)
+      // - ineligible = true (eligibilityDetermined AND NOT allInclusionMet)
+      // - eligible = false (allInclusionMet is false)
       const spec = createDiabetesTrialSpec();
       const { result } = renderHook(() => useForma({ spec }));
 
       const pages = result.current.wizard?.pages;
 
-      // Conditional pages hidden initially
+      // Ineligibility page is now visible (ineligible = true due to false inclusion criteria)
       expect(pages?.[4].id).toBe("ineligibility-documentation");
-      expect(pages?.[4].visible).toBe(false);
+      expect(pages?.[4].visible).toBe(true); // Changed: now visible
 
+      // Eligible-flow pages still hidden (eligible = false)
       expect(pages?.[5].id).toBe("main-consents");
       expect(pages?.[5].visible).toBe(false);
 
@@ -341,12 +348,21 @@ describe("diabetes trial enrollment wizard", () => {
   });
 
   describe("eligibility determination", () => {
-    it("should determine eligibility only after all criteria answered", () => {
+    it("should determine eligibility immediately with auto-initialized booleans", () => {
+      // With boolean auto-initialization, all criteria have values from the start,
+      // so eligibilityDetermined is true immediately.
+      // The user flow is now:
+      // 1. Initially ineligible (all inclusion criteria are false)
+      // 2. User must explicitly set inclusion criteria to true to become eligible
       const spec = createDiabetesTrialSpec();
       const { result } = renderHook(() => useForma({ spec }));
 
-      // Initially not determined
-      expect(result.current.computed?.eligibilityDetermined).toBeFalsy();
+      // Immediately determined (all booleans have values due to auto-init)
+      expect(result.current.computed?.eligibilityDetermined).toBe(true);
+
+      // Initially ineligible (all inclusion criteria are false)
+      expect(result.current.computed?.eligible).toBe(false);
+      expect(result.current.computed?.ineligible).toBe(true);
 
       // Fill inclusion criteria
       act(() => {
@@ -356,20 +372,10 @@ describe("diabetes trial enrollment wizard", () => {
         result.current.setFieldValue("inclusionConsent", true);
       });
 
-      // Still not determined - exclusion not answered
-      expect(result.current.computed?.eligibilityDetermined).toBeFalsy();
-
-      // Fill exclusion criteria
-      act(() => {
-        result.current.setFieldValue("exclusionPregnant", false);
-        result.current.setFieldValue("exclusionAllergy", false);
-        result.current.setFieldValue("exclusionRecentStudy", false);
-        result.current.setFieldValue("exclusionKidney", false);
-        result.current.setFieldValue("exclusionSglt2", false);
-      });
-
-      // Now determined
+      // Still determined, now eligible (exclusions already false via auto-init)
       expect(result.current.computed?.eligibilityDetermined).toBe(true);
+      expect(result.current.computed?.eligible).toBe(true);
+      expect(result.current.computed?.ineligible).toBe(false);
     });
 
     it("should mark eligible when all inclusion met and no exclusion met", () => {
@@ -754,6 +760,10 @@ describe("diabetes trial enrollment wizard", () => {
     });
 
     it("should skip hidden pages during navigation", () => {
+      // With auto-initialization, booleans default to false:
+      // - eligibilityDetermined = true (all fields have values)
+      // - ineligible = true (inclusion criteria all false)
+      // So the ineligibility-documentation page is visible
       const spec = createDiabetesTrialSpec();
       const { result } = renderHook(() => useForma({ spec }));
 
@@ -763,13 +773,20 @@ describe("diabetes trial enrollment wizard", () => {
       });
       expect(result.current.wizard?.currentPage?.id).toBe("exclusion-criteria");
 
-      // Without eligibility determined, next visible page count is limited
-      // The visible pages should be: study-info (0), participant-info (1), inclusion (2), exclusion (3)
-      // Pages 4-9 are conditional and hidden
+      // With auto-initialized booleans, visible pages are:
+      // study-info (0), participant-info (1), inclusion (2), exclusion (3), ineligibility-documentation (4)
+      // Pages 5-9 are for eligible flow and still hidden
       const visiblePages = result.current.wizard?.pages.filter(p => p.visible);
-      expect(visiblePages?.length).toBe(4);
+      expect(visiblePages?.length).toBe(5);
+
+      // Not on last visible page anymore (ineligibility page is visible)
+      expect(result.current.wizard?.isLastPage).toBe(false);
 
-      // Should be on last visible page
+      // Navigate to last visible page
+      act(() => {
+        result.current.wizard?.goToPage(4);
+      });
+      expect(result.current.wizard?.currentPage?.id).toBe("ineligibility-documentation");
       expect(result.current.wizard?.isLastPage).toBe(true);
     });
   });

package/src/__tests__/null-handling.test.ts

@@ -16,8 +16,8 @@ import { useForma } from "../useForma.js";
 import { createTestSpec } from "./test-utils.js";
 
 describe("FEEL null handling in visibility expressions", () => {
-  describe("boolean field null checks", () => {
-    it("should treat undefined boolean as not matching '= true'", () => {
+  describe("boolean field initialization", () => {
+    it("should auto-initialize boolean fields to false for better UX", () => {
       const spec = createTestSpec({
         fields: {
           accepted: { type: "boolean", label: "Accept terms" },
@@ -31,12 +31,11 @@ describe("FEEL null handling in visibility expressions", () => {
 
       const { result } = renderHook(() => useForma({ spec }));
 
-      // Field is undefined initially
-      expect(result.current.data.accepted).toBeUndefined();
+      // Boolean fields are auto-initialized to false (not undefined)
+      // This provides better UX - false is a valid answer for "Do you smoke?"
+      expect(result.current.data.accepted).toBe(false);
 
-      // The visibility expression "accepted = true" evaluates to null when accepted is undefined
-      // forma-core converts this null to false, so the field is hidden
-      // This happens to be the "correct" behavior by accident
+      // The visibility expression "accepted = true" evaluates properly to false
       expect(result.current.visibility.details).toBe(false);
 
       // When user explicitly sets to true, field becomes visible
@@ -46,7 +45,7 @@ describe("FEEL null handling in visibility expressions", () => {
       expect(result.current.visibility.details).toBe(true);
     });
 
-    it("should treat undefined boolean as not matching '= false'", () => {
+    it("should show fields dependent on '= false' immediately since booleans default to false", () => {
       const spec = createTestSpec({
         fields: {
           signingOnBehalf: { type: "boolean", label: "Signing on behalf?" },
@@ -60,22 +59,21 @@ describe("FEEL null handling in visibility expressions", () => {
 
       const { result } = renderHook(() => useForma({ spec }));
 
-      // Field is undefined initially
-      expect(result.current.data.signingOnBehalf).toBeUndefined();
+      // Boolean field is auto-initialized to false
+      expect(result.current.data.signingOnBehalf).toBe(false);
 
-      // The visibility expression "signingOnBehalf = false" evaluates to null when undefined
-      // This means the field is hidden even though the user hasn't made a choice yet
-      // This is problematic - the field should arguably be visible until the user chooses "true"
-      expect(result.current.visibility.participantName).toBe(false);
+      // The visibility expression "signingOnBehalf = false" evaluates to true
+      // This is the improved UX - participant fields are visible by default
+      expect(result.current.visibility.participantName).toBe(true);
 
-      // Only becomes visible when explicitly set to false
+      // Hidden when user sets to true
       act(() => {
-        result.current.setFieldValue("signingOnBehalf", false);
+        result.current.setFieldValue("signingOnBehalf", true);
       });
-      expect(result.current.visibility.participantName).toBe(true);
+      expect(result.current.visibility.participantName).toBe(false);
     });
 
-    it("should demonstrate the != null pattern also returns null on undefined", () => {
+    it("should work with != null pattern since booleans have initial value", () => {
       const spec = createTestSpec({
         fields: {
           accepted: { type: "boolean", label: "Accept" },
@@ -89,16 +87,13 @@ describe("FEEL null handling in visibility expressions", () => {
 
       const { result } = renderHook(() => useForma({ spec }));
 
-      // When accepted is undefined, "accepted != null" in FEEL returns null (not true or false)
-      // This is because FEEL's null comparison semantics are different from JavaScript
-      // The computed value becomes null, which may cause downstream issues
-      expect(result.current.data.accepted).toBeUndefined();
+      // Boolean fields start with false, so "accepted != null" is true
+      expect(result.current.data.accepted).toBe(false);
 
-      // Note: computed values that are null may show as null or undefined
-      // depending on how forma-core handles them
+      // Since the field has a value (false), it's not null
+      // Note: FEEL may still return null/false for != null comparisons
       const hasAnsweredValue = result.current.computed?.hasAnswered;
-      // This documents the actual behavior - it may be null instead of false
-      expect(hasAnsweredValue === null || hasAnsweredValue === false).toBe(true);
+      expect(hasAnsweredValue === true || hasAnsweredValue === null || hasAnsweredValue === false).toBe(true);
     });
   });
 
@@ -269,7 +264,8 @@ describe("FEEL null handling in visibility expressions", () => {
           accepted: { type: "boolean", label: "Accepted" },
         },
         computed: {
-          // Safer pattern: explicitly check for both true and false
+          // Pattern to check if field has been answered
+          // With auto-initialization to false, this always returns true
           hasAnswered: {
             expression: "accepted = true or accepted = false",
           },
@@ -278,10 +274,11 @@ describe("FEEL null handling in visibility expressions", () => {
 
       const { result } = renderHook(() => useForma({ spec }));
 
-      // When undefined: (undefined = true) or (undefined = false)
-      // → null or null → null (FEEL or short-circuits on null)
-      // This pattern may not actually help with FEEL's null semantics
-      expect(result.current.data.accepted).toBeUndefined();
+      // Boolean fields are auto-initialized to false
+      expect(result.current.data.accepted).toBe(false);
+
+      // Since accepted is false, "accepted = true or accepted = false" is true
+      expect(result.current.computed?.hasAnswered).toBe(true);
 
       // Set to true
       act(() => {
@@ -289,7 +286,7 @@ describe("FEEL null handling in visibility expressions", () => {
       });
       expect(result.current.computed?.hasAnswered).toBe(true);
 
-      // Set to false
+      // Set back to false
       act(() => {
         result.current.setFieldValue("accepted", false);
       });
@@ -299,8 +296,11 @@ describe("FEEL null handling in visibility expressions", () => {
 });
 
 describe("page navigation with conditional visibility", () => {
-  it("should handle complex eligibility determination pattern", () => {
-    // This test reproduces the diabetes trial enrollment pattern
+  it("should handle eligibility pattern with boolean auto-initialization", () => {
+    // With boolean auto-initialization to false, the eligibility pattern changes:
+    // - All booleans start as false
+    // - "field = true or field = false" is immediately true (since false = false is true)
+    // - Eligibility is determined immediately since all booleans have values
     const spec = createTestSpec({
       fields: {
         // Inclusion criteria (all must be true to be eligible)
@@ -313,15 +313,13 @@ describe("page navigation with conditional visibility", () => {
         consent: { type: "boolean", label: "I consent" },
       },
       computed: {
-        // Check if all inclusion answered
+        // With auto-initialization, these patterns always return true
         allInclusionAnswered: {
           expression: "ageOk != null and diagnosisOk != null",
         },
-        // Check if all exclusion answered
         allExclusionAnswered: {
           expression: "pregnant != null and allergy != null",
         },
-        // Eligibility determined when all criteria answered
         eligibilityDetermined: {
           expression:
             "computed.allInclusionAnswered = true and computed.allExclusionAnswered = true",
@@ -354,11 +352,26 @@ describe("page navigation with conditional visibility", () => {
 
     const { result } = renderHook(() => useForma({ spec }));
 
-    // Initially, all computed values are null due to undefined fields
+    // All booleans start as false
+    expect(result.current.data.ageOk).toBe(false);
+    expect(result.current.data.diagnosisOk).toBe(false);
+    expect(result.current.data.pregnant).toBe(false);
+    expect(result.current.data.allergy).toBe(false);
+
     const wizard = result.current.wizard;
     expect(wizard?.pages[0].visible).toBe(true); // Inclusion always visible
     expect(wizard?.pages[1].visible).toBe(true); // Exclusion always visible
-    expect(wizard?.pages[2].visible).toBe(false); // Consent hidden (computed.eligible is null)
+
+    // With auto-initialization:
+    // - eligibilityDetermined is true (all fields have values)
+    // - allInclusionMet is false (ageOk and diagnosisOk are false)
+    // - anyExclusionMet is false (pregnant and allergy are false)
+    // - eligible is false (allInclusionMet is false)
+    expect(result.current.computed?.eligibilityDetermined).toBe(true);
+    expect(result.current.computed?.allInclusionMet).toBe(false);
+    expect(result.current.computed?.anyExclusionMet).toBe(false);
+    expect(result.current.computed?.eligible).toBe(false);
+    expect(wizard?.pages[2].visible).toBe(false); // Consent hidden - not eligible yet
 
     // Fill inclusion criteria (both true)
     act(() => {
@@ -366,17 +379,7 @@ describe("page navigation with conditional visibility", () => {
       result.current.setFieldValue("diagnosisOk", true);
     });
 
-    // Still not eligible - exclusion not answered yet
-    expect(result.current.wizard?.pages[2].visible).toBe(false);
-
-    // Fill exclusion criteria (both false - no exclusions met)
-    act(() => {
-      result.current.setFieldValue("pregnant", false);
-      result.current.setFieldValue("allergy", false);
-    });
-
-    // Now eligible - consent page should be visible
-    expect(result.current.computed?.eligibilityDetermined).toBe(true);
+    // Now eligible - exclusion defaults are already false (no exclusions met)
     expect(result.current.computed?.allInclusionMet).toBe(true);
     expect(result.current.computed?.anyExclusionMet).toBe(false);
     expect(result.current.computed?.eligible).toBe(true);

package/src/__tests__/useForma.test.ts

@@ -1172,6 +1172,135 @@ describe("useForma", () => {
     });
   });
 
+  // ============================================================================
+  // Boolean Field Handling
+  // ============================================================================
+
+  describe("boolean field handling", () => {
+    it("should auto-initialize boolean fields to false", () => {
+      const spec = createTestSpec({
+        fields: {
+          acceptTerms: { type: "boolean" },
+          name: { type: "text" },
+        },
+      });
+
+      const { result } = renderHook(() => useForma({ spec }));
+
+      expect(result.current.data.acceptTerms).toBe(false);
+      expect(result.current.data.name).toBeUndefined();
+    });
+
+    it("should respect explicit initialData for booleans", () => {
+      const spec = createTestSpec({
+        fields: { acceptTerms: { type: "boolean" } },
+      });
+
+      const { result } = renderHook(() =>
+        useForma({ spec, initialData: { acceptTerms: true } })
+      );
+
+      expect(result.current.data.acceptTerms).toBe(true);
+    });
+
+    it("should set showRequiredIndicator=false for required boolean fields without validation (binary question)", () => {
+      // Binary question pattern: "Do you smoke?" - false is a valid answer
+      const spec = createTestSpec({
+        fields: {
+          isSmoker: { type: "boolean", label: "Do you smoke?", required: true },
+        },
+      });
+
+      const { result } = renderHook(() => useForma({ spec }));
+      const props = result.current.getFieldProps("isSmoker");
+
+      expect(props.required).toBe(true);
+      expect(props.showRequiredIndicator).toBe(false); // No asterisk for binary questions
+    });
+
+    it("should set showRequiredIndicator=true for required boolean fields with validation (consent pattern)", () => {
+      // Consent pattern: "I accept terms" - must explicitly check the box
+      const spec = createTestSpec({
+        fields: {
+          acceptTerms: {
+            type: "boolean",
+            label: "I accept the terms",
+            required: true,
+            validations: [{ rule: "value = true", message: "You must accept the terms" }],
+          },
+        },
+      });
+
+      const { result } = renderHook(() => useForma({ spec }));
+      const props = result.current.getFieldProps("acceptTerms");
+
+      expect(props.required).toBe(true);
+      expect(props.showRequiredIndicator).toBe(true); // Show asterisk for consent checkboxes
+    });
+
+    it("should set showRequiredIndicator=true for required non-boolean fields", () => {
+      const spec = createTestSpec({
+        fields: {
+          name: { type: "text", required: true },
+        },
+      });
+
+      const { result } = renderHook(() => useForma({ spec }));
+      const props = result.current.getFieldProps("name");
+
+      expect(props.required).toBe(true);
+      expect(props.showRequiredIndicator).toBe(true);
+    });
+
+    it("should set showRequiredIndicator=false for non-required fields", () => {
+      const spec = createTestSpec({
+        fields: {
+          name: { type: "text" },
+        },
+      });
+
+      const { result } = renderHook(() => useForma({ spec }));
+      const props = result.current.getFieldProps("name");
+
+      expect(props.required).toBe(false);
+      expect(props.showRequiredIndicator).toBe(false);
+    });
+
+    it("should initialize multiple boolean fields to false", () => {
+      const spec = createTestSpec({
+        fields: {
+          hasInsurance: { type: "boolean" },
+          isSmoker: { type: "boolean" },
+          hasAllergies: { type: "boolean" },
+          name: { type: "text" },
+        },
+      });
+
+      const { result } = renderHook(() => useForma({ spec }));
+
+      expect(result.current.data.hasInsurance).toBe(false);
+      expect(result.current.data.isSmoker).toBe(false);
+      expect(result.current.data.hasAllergies).toBe(false);
+      expect(result.current.data.name).toBeUndefined();
+    });
+
+    it("should pass validation for required boolean field with false value", () => {
+      const spec = createTestSpec({
+        fields: {
+          acceptTerms: { type: "boolean", required: true },
+        },
+      });
+
+      const { result } = renderHook(() => useForma({ spec }));
+
+      // Boolean field is auto-initialized to false
+      expect(result.current.data.acceptTerms).toBe(false);
+
+      // Form should be valid since false is a valid present value
+      expect(result.current.isValid).toBe(true);
+    });
+  });
+
   // ============================================================================
   // validateForm and validateField
   // ============================================================================