@hyperfixi/behaviors 2.5.1 → 2.7.0

package/src/behaviors/optional-runtime.test.ts

@@ -0,0 +1,251 @@
+// @vitest-environment happy-dom
+/**
+ * Optional behaviors — REAL runtime behavior tests.
+ *
+ * The optional three (FocusTrap / ScrollReveal / Tabs) were converted from
+ * imperative installers onto the single source-compiled runtime path
+ * (BEHAVIORS_CONSOLIDATION_PLAN.md §3d follow-up). Like curated-runtime.test.ts,
+ * these exercise each behavior's actual hyperscript `source` through the real
+ * @hyperfixi/core runtime — register → install on an element → drive the DOM →
+ * assert both the effect AND the documented lifecycle events.
+ *
+ * This is the "parses ≠ works" guard (§2/§5): the mock-based unit tests only prove
+ * `register*()` calls compileSync; these prove the `init`-block `js()` bodies (the
+ * focus model, the IntersectionObserver, the ARIA/keyboard wiring) actually run
+ * correctly once compiled — exactly the class of bug the imperative path masked.
+ */
+import { describe, it, expect, beforeAll, afterEach, vi } from 'vitest';
+import { hyperscript } from '@hyperfixi/core';
+import { registerFocusTrap } from './focustrap';
+import { registerScrollReveal } from './scrollreveal';
+import { registerTabs } from './tabs';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const hf = hyperscript as any;
+
+const tick = (ms = 30) => new Promise(r => setTimeout(r, ms));
+
+async function install(code: string, el: HTMLElement): Promise<void> {
+  const r = hyperscript.compileSync(code, { traditional: true });
+  if (!r.ok) throw new Error(`install compile failed: ${JSON.stringify(r.errors)}`);
+  await hyperscript.execute(r.ast, hyperscript.createContext(el));
+}
+
+beforeAll(async () => {
+  // Behavior registry is a runtime singleton; register the optional set once.
+  await registerFocusTrap(hf);
+  await registerScrollReveal(hf);
+  await registerTabs(hf);
+});
+
+afterEach(() => {
+  document.body.innerHTML = '';
+});
+
+describe('FocusTrap — runtime', () => {
+  function buildTrap(): { trap: HTMLElement; buttons: HTMLButtonElement[] } {
+    const trap = document.createElement('div');
+    const buttons = [0, 1, 2].map(i => {
+      const b = document.createElement('button');
+      b.textContent = `b${i}`;
+      trap.appendChild(b);
+      return b;
+    });
+    document.body.appendChild(trap);
+    return { trap, buttons };
+  }
+
+  it('activates on install: sets aria-modal, focuses first, fires focustrap:activated', async () => {
+    const { trap, buttons } = buildTrap();
+    const activated = vi.fn();
+    trap.addEventListener('focustrap:activated', activated);
+
+    await install('install FocusTrap', trap);
+
+    expect(trap.getAttribute('aria-modal')).toBe('true');
+    expect(activated).toHaveBeenCalledTimes(1);
+    expect(document.activeElement).toBe(buttons[0]);
+  });
+
+  it('traps Tab: wraps forward off the last element and backward off the first', async () => {
+    const { trap, buttons } = buildTrap();
+    await install('install FocusTrap', trap);
+
+    // Forward Tab from first → second.
+    buttons[0].focus();
+    trap.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+    expect(document.activeElement).toBe(buttons[1]);
+
+    // Forward Tab off the last element → wraps to first.
+    buttons[2].focus();
+    trap.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true }));
+    expect(document.activeElement).toBe(buttons[0]);
+
+    // Shift+Tab off the first element → wraps to last.
+    buttons[0].focus();
+    trap.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', shiftKey: true, bubbles: true }));
+    expect(document.activeElement).toBe(buttons[2]);
+  });
+
+  it('deactivates via custom event: removes aria-modal and fires focustrap:deactivated', async () => {
+    const { trap } = buildTrap();
+    const deactivated = vi.fn();
+    trap.addEventListener('focustrap:deactivated', deactivated);
+
+    await install('install FocusTrap', trap);
+    expect(trap.getAttribute('aria-modal')).toBe('true');
+
+    trap.dispatchEvent(new CustomEvent('focustrap:deactivate'));
+    await tick();
+
+    expect(trap.hasAttribute('aria-modal')).toBe(false);
+    expect(deactivated).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('ScrollReveal — runtime', () => {
+  // happy-dom ships an IntersectionObserver that never fires its callback (no
+  // layout engine). Stub it so we can drive the intersection deterministically and
+  // assert the js() body's class/event/disconnect logic actually runs.
+  let lastCallback: ((entries: Array<{ isIntersecting: boolean }>) => void) | null = null;
+  let disconnected = false;
+  let observed: Element | null = null;
+
+  class MockIntersectionObserver {
+    constructor(cb: (entries: Array<{ isIntersecting: boolean }>) => void) {
+      lastCallback = cb;
+    }
+    observe(el: Element) {
+      observed = el;
+    }
+    disconnect() {
+      disconnected = true;
+    }
+    unobserve() {}
+    takeRecords() {
+      return [];
+    }
+  }
+
+  beforeAll(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).IntersectionObserver = MockIntersectionObserver;
+  });
+
+  afterEach(() => {
+    lastCallback = null;
+    disconnected = false;
+    observed = null;
+  });
+
+  it('observes the element and adds the class + fires enter on intersection (once)', async () => {
+    const el = document.createElement('div');
+    document.body.appendChild(el);
+    const enter = vi.fn();
+    el.addEventListener('scrollreveal:enter', enter);
+
+    await install('install ScrollReveal', el);
+
+    expect(observed).toBe(el);
+    expect(lastCallback).toBeTypeOf('function');
+
+    // Simulate the element scrolling into view.
+    lastCallback!([{ isIntersecting: true }]);
+
+    expect(el.classList.contains('revealed')).toBe(true);
+    expect(enter).toHaveBeenCalledTimes(1);
+    // once defaults to true → observer disconnects after the first reveal.
+    expect(disconnected).toBe(true);
+  });
+
+  it('honors a custom class parameter', async () => {
+    const el = document.createElement('div');
+    document.body.appendChild(el);
+
+    await install('install ScrollReveal(cls: "shown")', el);
+    lastCallback!([{ isIntersecting: true }]);
+
+    expect(el.classList.contains('shown')).toBe(true);
+  });
+});
+
+describe('Tabs — runtime', () => {
+  function buildTabs(): {
+    root: HTMLElement;
+    tabs: HTMLElement[];
+    panels: HTMLElement[];
+  } {
+    const root = document.createElement('div');
+    const tablist = document.createElement('div');
+    tablist.setAttribute('role', 'tablist');
+    root.appendChild(tablist);
+
+    const tabs: HTMLElement[] = [];
+    const panels: HTMLElement[] = [];
+    for (let i = 0; i < 3; i++) {
+      const tab = document.createElement('button');
+      tab.setAttribute('role', 'tab');
+      tab.textContent = `Tab ${i}`;
+      tablist.appendChild(tab);
+      tabs.push(tab);
+
+      const panel = document.createElement('div');
+      panel.setAttribute('role', 'tabpanel');
+      panel.textContent = `Panel ${i}`;
+      root.appendChild(panel);
+      panels.push(panel);
+    }
+    document.body.appendChild(root);
+    return { root, tabs, panels };
+  }
+
+  it('wires ARIA on install: first tab selected, roving tabindex, controls/labelledby', async () => {
+    const { root, tabs, panels } = buildTabs();
+
+    await install('install Tabs', root);
+
+    expect(tabs[0].getAttribute('aria-selected')).toBe('true');
+    expect(tabs[0].getAttribute('tabindex')).toBe('0');
+    expect(tabs[1].getAttribute('aria-selected')).toBe('false');
+    expect(tabs[1].getAttribute('tabindex')).toBe('-1');
+
+    // aria-controls / aria-labelledby cross-link tab[i] <-> panel[i].
+    expect(tabs[0].getAttribute('aria-controls')).toBe(panels[0].id);
+    expect(panels[0].getAttribute('aria-labelledby')).toBe(tabs[0].id);
+    expect(panels[0].getAttribute('aria-hidden')).toBe('false');
+    expect(panels[1].getAttribute('aria-hidden')).toBe('true');
+  });
+
+  it('selects a tab on click and fires tabs:changed', async () => {
+    const { root, tabs, panels } = buildTabs();
+    const changed = vi.fn();
+    root.addEventListener('tabs:changed', changed);
+
+    await install('install Tabs', root);
+
+    tabs[1].click();
+    await tick();
+
+    expect(tabs[1].getAttribute('aria-selected')).toBe('true');
+    expect(tabs[1].classList.contains('active')).toBe(true);
+    expect(tabs[0].getAttribute('aria-selected')).toBe('false');
+    expect(panels[1].getAttribute('aria-hidden')).toBe('false');
+    expect(changed).toHaveBeenCalledTimes(1);
+  });
+
+  it('navigates with ArrowRight and is cancelable via tabs:change', async () => {
+    const { root, tabs } = buildTabs();
+    await install('install Tabs', root);
+
+    // ArrowRight on the tablist advances selection.
+    const tablist = root.querySelector('[role="tablist"]')!;
+    tablist.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }));
+    expect(tabs[1].getAttribute('aria-selected')).toBe('true');
+
+    // preventDefault on the cancelable tabs:change blocks the next switch.
+    root.addEventListener('tabs:change', e => e.preventDefault(), { once: true });
+    tablist.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }));
+    expect(tabs[2].getAttribute('aria-selected')).toBe('false');
+    expect(tabs[1].getAttribute('aria-selected')).toBe('true');
+  });
+});

package/src/behaviors/resizable.ts

@@ -1,8 +1,10 @@
 /**
- * Resizable Behavior — Imperative Implementation
+ * Resizable Behavior
  *
- * Makes elements resizable by dragging edges or corners.
- * Supports minimum/maximum dimensions and resize handles.
+ * Makes elements resizable by dragging. Compiled from its hyperscript `source`
+ * (single source of truth) — no imperative installer. The source measures the
+ * start size, runs a `repeat until event pointerup` loop, clamps to
+ * min/max dimensions, and writes `*width` / `*height` inline styles.
  *
  * @example
  * ```html
@@ -21,56 +23,8 @@ export const resizableSource = resizableSchema.source;
 export const resizableMetadata = resizableSchema;
 
 /**
- * Imperative installer for Resizable behavior.
- */
-function installResizable(element: HTMLElement, params: Record<string, any>): void {
-  // Resolve handle element
-  let handleEl: HTMLElement = element;
-  if (params.handle && params.handle !== 'me') {
-    if (typeof params.handle === 'string') {
-      const found = element.querySelector(params.handle);
-      if (found instanceof HTMLElement) handleEl = found;
-    } else if (params.handle instanceof HTMLElement) {
-      handleEl = params.handle;
-    }
-  }
-
-  const minW = params.minWidth ?? 50;
-  const minH = params.minHeight ?? 50;
-  const maxW = params.maxWidth ?? 9999;
-  const maxH = params.maxHeight ?? 9999;
-
-  handleEl.addEventListener('pointerdown', (e: PointerEvent) => {
-    e.preventDefault();
-    element.dispatchEvent(new CustomEvent('resizable:start', { bubbles: true }));
-
-    const startWidth = element.offsetWidth;
-    const startHeight = element.offsetHeight;
-    const startX = e.clientX;
-    const startY = e.clientY;
-
-    function onMove(ev: PointerEvent) {
-      const newWidth = Math.max(minW, Math.min(maxW, startWidth + (ev.clientX - startX)));
-      const newHeight = Math.max(minH, Math.min(maxH, startHeight + (ev.clientY - startY)));
-
-      element.style.width = `${newWidth}px`;
-      element.style.height = `${newHeight}px`;
-      element.dispatchEvent(new CustomEvent('resizable:resize', { bubbles: true }));
-    }
-
-    function onUp() {
-      document.removeEventListener('pointermove', onMove);
-      document.removeEventListener('pointerup', onUp);
-      element.dispatchEvent(new CustomEvent('resizable:end', { bubbles: true }));
-    }
-
-    document.addEventListener('pointermove', onMove);
-    document.addEventListener('pointerup', onUp);
-  });
-}
-
-/**
- * Register the Resizable behavior with LokaScript.
+ * Register the Resizable behavior with LokaScript by compiling its hyperscript
+ * source and executing the resulting behavior definition.
  */
 export async function registerResizable(hyperfixi?: LokaScriptInstance): Promise<void> {
   const hf = hyperfixi || resolveRuntime();
@@ -81,15 +35,14 @@ export async function registerResizable(hyperfixi?: LokaScriptInstance): Promise
     );
   }
 
-  const syntheticNode = {
-    type: 'behavior',
-    name: 'Resizable',
-    parameters: [],
-    eventHandlers: [],
-    imperativeInstaller: installResizable,
-  };
+  const result = hf.compileSync(resizableSchema.source, { traditional: true });
+
+  if (!result.ok) {
+    throw new Error(`Failed to compile Resizable behavior: ${JSON.stringify(result.errors)}`);
+  }
+
   const ctx = hf.createContext ? hf.createContext() : { locals: new Map(), globals: new Map() };
-  await hf.execute(syntheticNode, ctx);
+  await hf.execute(result.ast, ctx);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/scrollreveal.test.ts

@@ -2,27 +2,35 @@ import { describe, it, expect, vi } from 'vitest';
 
 describe('ScrollReveal behavior', () => {
   describe('registerScrollReveal', () => {
-    it('should register with synthetic node via execute', async () => {
-      const { registerScrollReveal } = await import('./scrollreveal');
+    it('should compile its hyperscript source and execute', async () => {
+      const { registerScrollReveal, scrollRevealSource } = await import('./scrollreveal');
       const mock = {
-        compileSync: vi.fn(),
+        compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
         execute: vi.fn().mockResolvedValue(undefined),
         createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
       };
 
       await registerScrollReveal(mock);
 
-      expect(mock.compileSync).not.toHaveBeenCalled();
+      expect(mock.compileSync).toHaveBeenCalledWith(scrollRevealSource, { traditional: true });
       expect(mock.execute).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'behavior',
-          name: 'ScrollReveal',
-          imperativeInstaller: expect.any(Function),
-        }),
+        { type: 'behavior' },
         expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
       );
     });
 
+    it('should throw on compile failure', async () => {
+      const { registerScrollReveal } = await import('./scrollreveal');
+      const mock = {
+        compileSync: vi.fn().mockReturnValue({ ok: false, errors: [{ message: 'boom' }] }),
+        execute: vi.fn(),
+        createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
+      };
+      await expect(registerScrollReveal(mock)).rejects.toThrowError(
+        /Failed to compile ScrollReveal/
+      );
+    });
+
     it('should throw when no runtime available', async () => {
       const { registerScrollReveal } = await import('./scrollreveal');
       await expect(registerScrollReveal(undefined)).rejects.toThrowError(/LokaScript not found/);

package/src/behaviors/scrollreveal.ts

@@ -1,8 +1,14 @@
 /**
- * ScrollReveal Behavior — Imperative Implementation
+ * ScrollReveal Behavior
  *
  * Adds a class or fires events when the element enters or exits the viewport.
- * Uses the IntersectionObserver web standard API.
+ * Uses the IntersectionObserver web standard API (in its hyperscript `source`'s
+ * `init`-block `js()` body).
+ *
+ * Compiled from its hyperscript `source` — the single source of truth shared with
+ * the CDN resolver bundle and patterns-reference. This collapses ScrollReveal onto
+ * the one runtime path (no more imperative-installer fork between CDN and npm);
+ * see docs-internal/BEHAVIORS_CONSOLIDATION_PLAN.md §3d.
  */
 
 import { scrollRevealSchema } from '../schemas/scrollreveal.schema';
@@ -14,37 +20,8 @@ export const scrollRevealSource = scrollRevealSchema.source;
 export const scrollRevealMetadata = scrollRevealSchema;
 
 /**
- * Imperative installer for ScrollReveal behavior.
- */
-function installScrollReveal(element: HTMLElement, params: Record<string, any>): void {
-  const cls = typeof params.cls === 'string' ? params.cls : 'revealed';
-  const threshold = typeof params.threshold === 'number' ? params.threshold : 0.1;
-  const once = params.once !== false;
-  const rootMargin = typeof params.rootMargin === 'string' ? params.rootMargin : '0px';
-
-  const observer = new IntersectionObserver(
-    entries => {
-      for (const entry of entries) {
-        if (entry.isIntersecting) {
-          element.classList.add(cls);
-          element.dispatchEvent(new CustomEvent('scrollreveal:enter', { bubbles: true }));
-          if (once) {
-            observer.disconnect();
-          }
-        } else if (!once) {
-          element.classList.remove(cls);
-          element.dispatchEvent(new CustomEvent('scrollreveal:exit', { bubbles: true }));
-        }
-      }
-    },
-    { threshold, rootMargin }
-  );
-
-  observer.observe(element);
-}
-
-/**
- * Register the ScrollReveal behavior with LokaScript.
+ * Register the ScrollReveal behavior with LokaScript by compiling its
+ * hyperscript source and executing the resulting behavior definition.
  */
 export async function registerScrollReveal(hyperfixi?: LokaScriptInstance): Promise<void> {
   const hf = hyperfixi || resolveRuntime();
@@ -55,15 +32,14 @@ export async function registerScrollReveal(hyperfixi?: LokaScriptInstance): Prom
     );
   }
 
-  const syntheticNode = {
-    type: 'behavior',
-    name: 'ScrollReveal',
-    parameters: ['cls', 'threshold', 'once', 'rootMargin'],
-    eventHandlers: [],
-    imperativeInstaller: installScrollReveal,
-  };
+  const result = hf.compileSync(scrollRevealSchema.source, { traditional: true });
+
+  if (!result.ok) {
+    throw new Error(`Failed to compile ScrollReveal behavior: ${JSON.stringify(result.errors)}`);
+  }
+
   const ctx = hf.createContext ? hf.createContext() : { locals: new Map(), globals: new Map() };
-  await hf.execute(syntheticNode, ctx);
+  await hf.execute(result.ast, ctx);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/sortable.ts

@@ -1,12 +1,12 @@
 /**
- * Sortable Behavior — Imperative Implementation
+ * Sortable Behavior
  *
- * Drag-and-drop reordering of list items.
- * Apply to a container element; children become sortable.
+ * Drag-and-drop reordering of list items. Apply to a container element; its
+ * `<li>` children become sortable. Compiled from its hyperscript `source` (single
+ * source of truth) — no imperative installer.
  *
- * Note: This behavior fires lifecycle events but does NOT automatically
- * reorder DOM elements. Users must handle actual reordering in their
- * `sortable:move` event handlers.
+ * Note: This behavior fires lifecycle events but does NOT automatically reorder
+ * DOM elements. Users handle actual reordering in their `sortable:move` handlers.
  *
  * @example
  * ```html
@@ -26,50 +26,8 @@ export const sortableSource = sortableSchema.source;
 export const sortableMetadata = sortableSchema;
 
 /**
- * Imperative installer for Sortable behavior.
- */
-function installSortable(element: HTMLElement, params: Record<string, any>): void {
-  const dragClass = params.dragClass || 'sorting';
-  const handleSelector = params.handle || null;
-
-  element.addEventListener('pointerdown', (e: PointerEvent) => {
-    const target = e.target as HTMLElement;
-    const item = target.closest('li');
-    if (!item || !element.contains(item)) return;
-
-    // If a handle selector is specified, only start drag from the handle
-    if (handleSelector) {
-      const handleEl = target.closest(handleSelector);
-      if (!handleEl) return;
-    }
-
-    e.preventDefault();
-    item.classList.add(dragClass);
-    element.dispatchEvent(new CustomEvent('sortable:start', { bubbles: true, detail: { item } }));
-
-    function onMove(ev: PointerEvent) {
-      element.dispatchEvent(
-        new CustomEvent('sortable:move', {
-          bubbles: true,
-          detail: { clientY: ev.clientY, item },
-        })
-      );
-    }
-
-    function onUp() {
-      document.removeEventListener('pointermove', onMove);
-      document.removeEventListener('pointerup', onUp);
-      item!.classList.remove(dragClass);
-      element.dispatchEvent(new CustomEvent('sortable:end', { bubbles: true, detail: { item } }));
-    }
-
-    document.addEventListener('pointermove', onMove);
-    document.addEventListener('pointerup', onUp);
-  });
-}
-
-/**
- * Register the Sortable behavior with LokaScript.
+ * Register the Sortable behavior with LokaScript by compiling its hyperscript
+ * source and executing the resulting behavior definition.
  */
 export async function registerSortable(hyperfixi?: LokaScriptInstance): Promise<void> {
   const hf = hyperfixi || resolveRuntime();
@@ -80,15 +38,14 @@ export async function registerSortable(hyperfixi?: LokaScriptInstance): Promise<
     );
   }
 
-  const syntheticNode = {
-    type: 'behavior',
-    name: 'Sortable',
-    parameters: ['dragClass'],
-    eventHandlers: [],
-    imperativeInstaller: installSortable,
-  };
+  const result = hf.compileSync(sortableSchema.source, { traditional: true });
+
+  if (!result.ok) {
+    throw new Error(`Failed to compile Sortable behavior: ${JSON.stringify(result.errors)}`);
+  }
+
   const ctx = hf.createContext ? hf.createContext() : { locals: new Map(), globals: new Map() };
-  await hf.execute(syntheticNode, ctx);
+  await hf.execute(result.ast, ctx);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/tabs.test.ts

@@ -2,27 +2,33 @@ import { describe, it, expect, vi } from 'vitest';
 
 describe('Tabs behavior', () => {
   describe('registerTabs', () => {
-    it('should register with synthetic node via execute', async () => {
-      const { registerTabs } = await import('./tabs');
+    it('should compile its hyperscript source and execute', async () => {
+      const { registerTabs, tabsSource } = await import('./tabs');
       const mock = {
-        compileSync: vi.fn(),
+        compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
         execute: vi.fn().mockResolvedValue(undefined),
         createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
       };
 
       await registerTabs(mock);
 
-      expect(mock.compileSync).not.toHaveBeenCalled();
+      expect(mock.compileSync).toHaveBeenCalledWith(tabsSource, { traditional: true });
       expect(mock.execute).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'behavior',
-          name: 'Tabs',
-          imperativeInstaller: expect.any(Function),
-        }),
+        { type: 'behavior' },
         expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
       );
     });
 
+    it('should throw on compile failure', async () => {
+      const { registerTabs } = await import('./tabs');
+      const mock = {
+        compileSync: vi.fn().mockReturnValue({ ok: false, errors: [{ message: 'boom' }] }),
+        execute: vi.fn(),
+        createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
+      };
+      await expect(registerTabs(mock)).rejects.toThrowError(/Failed to compile Tabs/);
+    });
+
     it('should throw when no runtime available', async () => {
       const { registerTabs } = await import('./tabs');
       await expect(registerTabs(undefined)).rejects.toThrowError(/LokaScript not found/);
@@ -31,7 +37,7 @@ describe('Tabs behavior', () => {
     it('should fall back to manual context when createContext is missing', async () => {
       const { registerTabs } = await import('./tabs');
       const mock = {
-        compileSync: vi.fn(),
+        compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
         execute: vi.fn().mockResolvedValue(undefined),
       };