@hyperfixi/behaviors 2.5.1 → 2.7.0

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

@@ -0,0 +1,158 @@
+// @vitest-environment happy-dom
+/**
+ * Curated behaviors — REAL runtime behavior tests (Phase 2).
+ *
+ * These exercise each curated 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 (BEHAVIORS_CONSOLIDATION_PLAN.md §2/§5) — the mock-based
+ * unit tests only prove `register*()` calls compileSync; these prove the js()
+ * bodies actually do the right thing at runtime.
+ *
+ * These tests already paid for themselves: they surfaced two source bugs the
+ * imperative path was masking — ClickOutside read `event.target` without passing
+ * `event` into its js() block, and Clipboard used top-level `await` (invalid in a
+ * js() block). Both are fixed in the schema sources.
+ */
+import { describe, it, expect, beforeAll, afterEach, vi } from 'vitest';
+import { hyperscript } from '@hyperfixi/core';
+import { registerToggleable } from './toggleable';
+import { registerRemovable } from './removable';
+import { registerClickOutside } from './clickoutside';
+import { registerClipboard } from './clipboard';
+import { registerAutoDismiss } from './autodismiss';
+
+// 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 curated set once.
+  await registerToggleable(hf);
+  await registerRemovable(hf);
+  await registerClickOutside(hf);
+  await registerClipboard(hf);
+  await registerAutoDismiss(hf);
+});
+
+afterEach(() => {
+  document.body.innerHTML = '';
+});
+
+describe('Toggleable — runtime', () => {
+  it('toggles the parameterized class and fires on/off lifecycle events', async () => {
+    const el = document.createElement('button');
+    document.body.appendChild(el);
+    const on = vi.fn();
+    const off = vi.fn();
+    el.addEventListener('toggleable:on', on);
+    el.addEventListener('toggleable:off', off);
+
+    await install('install Toggleable(cls: "hl")', el);
+
+    el.click();
+    await tick();
+    expect(el.classList.contains('hl')).toBe(true);
+    expect(on).toHaveBeenCalledTimes(1);
+
+    el.click();
+    await tick();
+    expect(el.classList.contains('hl')).toBe(false);
+    expect(off).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('Removable — runtime', () => {
+  it('removes the element on click and fires before/removed events', async () => {
+    const el = document.createElement('div');
+    el.id = 'rm-target';
+    document.body.appendChild(el);
+    const before = vi.fn();
+    const removed = vi.fn();
+    el.addEventListener('removable:before', before);
+    document.addEventListener('removable:removed', removed, { once: true });
+
+    await install('install Removable', el);
+
+    el.click();
+    await tick();
+
+    expect(document.getElementById('rm-target')).toBeNull();
+    expect(before).toHaveBeenCalledTimes(1);
+    expect(removed).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('ClickOutside — runtime', () => {
+  it('fires clickoutside for outside presses but not inside', async () => {
+    const el = document.createElement('div');
+    const outside = document.createElement('button');
+    document.body.append(el, outside);
+    const fired = vi.fn();
+    el.addEventListener('clickoutside', fired);
+
+    await install('install ClickOutside', el);
+
+    // The source passes `event` into its js() block, so dispatch sets event.target.
+    const press = (target: HTMLElement) =>
+      target.dispatchEvent(new Event('pointerdown', { bubbles: true }));
+
+    press(outside);
+    await tick();
+    expect(fired).toHaveBeenCalledTimes(1);
+
+    fired.mockClear();
+    press(el);
+    await tick();
+    expect(fired).not.toHaveBeenCalled();
+  });
+});
+
+describe('Clipboard — runtime', () => {
+  it('writes literal text, adds .copied feedback, and fires clipboard:copied', async () => {
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    Object.defineProperty(navigator, 'clipboard', { value: { writeText }, configurable: true });
+
+    const el = document.createElement('button');
+    document.body.appendChild(el);
+    const copied = vi.fn();
+    el.addEventListener('clipboard:copied', copied);
+
+    await install('install Clipboard(text: "hello")', el);
+
+    el.click();
+    await tick();
+
+    expect(writeText).toHaveBeenCalledWith('hello');
+    expect(el.classList.contains('copied')).toBe(true);
+    expect(copied).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('AutoDismiss — runtime', () => {
+  it('fires start, then removes the element after the delay and fires dismissed', async () => {
+    const el = document.createElement('div');
+    el.id = 'ad-target';
+    document.body.appendChild(el);
+    const start = vi.fn();
+    const dismissed = vi.fn();
+    el.addEventListener('autodismiss:start', start);
+    document.addEventListener('autodismiss:dismissed', dismissed, { once: true });
+
+    await install('install AutoDismiss(delay: 10)', el);
+
+    expect(start).toHaveBeenCalledTimes(1);
+
+    await tick(80);
+
+    expect(document.getElementById('ad-target')).toBeNull();
+    expect(dismissed).toHaveBeenCalledTimes(1);
+  });
+});

package/src/behaviors/draggable.ts

@@ -1,9 +1,11 @@
 /**
- * Draggable Behavior — Imperative Implementation
+ * Draggable Behavior
  *
- * Makes elements draggable with pointer events.
- * Uses direct DOM APIs instead of compiling hyperscript source,
- * bypassing the complex repeat-until-event + wait-for async pattern.
+ * Makes elements draggable with pointer events. Compiled from its hyperscript
+ * `source` (the single source of truth shared with the CDN resolver bundle and
+ * patterns-reference) — no imperative installer. The source uses
+ * `repeat until event pointerup` + `wait for pointermove or pointerup` to run the
+ * drag loop, `measure` for the start offset, and `add { left: ${…}px }` to move.
  *
  * @example
  * ```html
@@ -27,51 +29,8 @@ export const draggableSource = draggableSchema.source;
 export const draggableMetadata = draggableSchema;
 
 /**
- * Imperative installer for Draggable behavior.
- * Called directly by the runtime when `install Draggable` is executed.
- */
-function installDraggable(element: HTMLElement, params: Record<string, any>): void {
-  // Resolve drag handle: parameter value, CSS selector, or the element itself
-  let dragHandle: HTMLElement = element;
-  if (params.dragHandle && params.dragHandle !== 'me') {
-    if (typeof params.dragHandle === 'string') {
-      const found = element.querySelector(params.dragHandle);
-      if (found instanceof HTMLElement) dragHandle = found;
-    } else if (params.dragHandle instanceof HTMLElement) {
-      dragHandle = params.dragHandle;
-    }
-  }
-
-  dragHandle.addEventListener('pointerdown', (e: PointerEvent) => {
-    e.preventDefault();
-    e.stopPropagation();
-    element.dispatchEvent(new CustomEvent('draggable:start', { bubbles: true }));
-
-    const startX = element.offsetLeft;
-    const startY = element.offsetTop;
-    const xoff = e.clientX - startX;
-    const yoff = e.clientY - startY;
-
-    function onMove(ev: PointerEvent) {
-      element.style.left = `${ev.clientX - xoff}px`;
-      element.style.top = `${ev.clientY - yoff}px`;
-      element.dispatchEvent(new CustomEvent('draggable:move', { bubbles: true }));
-    }
-
-    function onUp() {
-      document.removeEventListener('pointermove', onMove);
-      document.removeEventListener('pointerup', onUp);
-      element.dispatchEvent(new CustomEvent('draggable:end', { bubbles: true }));
-    }
-
-    document.addEventListener('pointermove', onMove);
-    document.addEventListener('pointerup', onUp);
-  });
-}
-
-/**
- * Register the Draggable behavior with LokaScript.
- * Uses imperative installer via synthetic behavior node.
+ * Register the Draggable behavior with LokaScript by compiling its hyperscript
+ * source and executing the resulting behavior definition.
  */
 export async function registerDraggable(hyperfixi?: LokaScriptInstance): Promise<void> {
   const hf = hyperfixi || resolveRuntime();
@@ -82,17 +41,14 @@ export async function registerDraggable(hyperfixi?: LokaScriptInstance): Promise
     );
   }
 
-  // Register via execute() with a synthetic behavior node containing the imperative installer.
-  // The runtime detects imperativeInstaller and stores it directly in the behaviorRegistry.
-  const syntheticNode = {
-    type: 'behavior',
-    name: 'Draggable',
-    parameters: ['dragHandle'],
-    eventHandlers: [],
-    imperativeInstaller: installDraggable,
-  };
+  const result = hf.compileSync(draggableSchema.source, { traditional: true });
+
+  if (!result.ok) {
+    throw new Error(`Failed to compile Draggable 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/experimental-runtime.test.ts

@@ -0,0 +1,136 @@
+// @vitest-environment happy-dom
+/**
+ * Experimental behaviors — REAL runtime tests.
+ *
+ * Draggable / Sortable / Resizable used to run imperative JS installers. They now
+ * compile from their hyperscript `source` like every other behavior (the
+ * "no imperative JS" rule — no behavior may carry an imperative installer field).
+ * These tests are the "parses ≠ works" guard: register → install → drive pointer
+ * events → assert the DOM effect AND the documented lifecycle events.
+ *
+ * happy-dom has no PointerEvent and zero layout, so we drive `MouseEvent`s (which
+ * carry clientX/clientY) and assert deltas, which are layout-independent.
+ */
+import { describe, it, expect, beforeAll, afterEach } from 'vitest';
+import { hyperscript } from '@hyperfixi/core';
+import { registerDraggable } from './draggable';
+import { registerSortable } from './sortable';
+import { registerResizable } from './resizable';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const hf = hyperscript as any;
+const tick = (ms = 30) => new Promise(r => setTimeout(r, ms));
+
+function pointer(type: string, x: number, y: number): MouseEvent {
+  return new MouseEvent(type, { clientX: x, clientY: y, bubbles: true, cancelable: true });
+}
+
+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 () => {
+  await registerDraggable(hf);
+  await registerSortable(hf);
+  await registerResizable(hf);
+});
+
+afterEach(() => {
+  document.body.innerHTML = '';
+});
+
+describe('Draggable — runtime (source-compiled)', () => {
+  it('moves the element by the pointer delta and fires start/move/end', async () => {
+    const el = document.createElement('div');
+    el.style.position = 'absolute';
+    el.style.left = '0px';
+    el.style.top = '0px';
+    document.body.appendChild(el);
+
+    const ev: string[] = [];
+    el.addEventListener('draggable:start', () => ev.push('start'));
+    el.addEventListener('draggable:move', () => ev.push('move'));
+    el.addEventListener('draggable:end', () => ev.push('end'));
+
+    await install('install Draggable', el);
+
+    el.dispatchEvent(pointer('pointerdown', 10, 10));
+    await tick();
+    document.dispatchEvent(pointer('pointermove', 60, 80));
+    await tick();
+    document.dispatchEvent(pointer('pointerup', 60, 80));
+    await tick(40);
+
+    // measure x/y = 0 in happy-dom → xoff = 10, so left = 60 - 10 = 50, top = 80 - 10 = 70
+    expect(el.style.left).toBe('50px');
+    expect(el.style.top).toBe('70px');
+    expect(ev).toContain('start');
+    expect(ev).toContain('move');
+    expect(ev).toContain('end');
+  });
+});
+
+describe('Sortable — runtime (source-compiled)', () => {
+  it('toggles the drag class on the <li> and fires start/move/end', async () => {
+    const ul = document.createElement('ul');
+    ul.innerHTML = '<li id="a">A</li><li id="b">B</li>';
+    document.body.appendChild(ul);
+
+    const ev: string[] = [];
+    ul.addEventListener('sortable:start', () => ev.push('start'));
+    ul.addEventListener('sortable:move', () => ev.push('move'));
+    ul.addEventListener('sortable:end', () => ev.push('end'));
+
+    await install('install Sortable', ul);
+
+    const li = ul.querySelector('#a') as HTMLElement;
+    li.dispatchEvent(pointer('pointerdown', 0, 5));
+    await tick();
+    const classDuringDrag = li.classList.contains('sorting');
+    document.dispatchEvent(pointer('pointermove', 0, 40));
+    await tick();
+    document.dispatchEvent(pointer('pointerup', 0, 40));
+    await tick(40);
+
+    expect(classDuringDrag).toBe(true); // dragClass added on pointerdown
+    expect(li.classList.contains('sorting')).toBe(false); // removed on pointerup
+    expect(ev).toContain('start');
+    expect(ev).toContain('move');
+    expect(ev).toContain('end');
+  });
+});
+
+describe('Resizable — runtime (source-compiled)', () => {
+  it('resizes by the pointer delta and fires start/resize/end', async () => {
+    const box = document.createElement('div');
+    box.style.width = '100px';
+    box.style.height = '100px';
+    document.body.appendChild(box);
+
+    const ev: string[] = [];
+    box.addEventListener('resizable:start', () => ev.push('start'));
+    box.addEventListener('resizable:resize', () => ev.push('resize'));
+    box.addEventListener('resizable:end', () => ev.push('end'));
+
+    await install(
+      'install Resizable(minWidth: 10, minHeight: 10, maxWidth: 999, maxHeight: 999)',
+      box
+    );
+
+    box.dispatchEvent(pointer('pointerdown', 10, 10));
+    await tick();
+    document.dispatchEvent(pointer('pointermove', 60, 40));
+    await tick();
+    document.dispatchEvent(pointer('pointerup', 60, 40));
+    await tick(40);
+
+    // measure width/height = 0 in happy-dom → newWidth = 0 + 60 - 10 = 50, newHeight = 0 + 40 - 10 = 30
+    expect(box.style.width).toBe('50px');
+    expect(box.style.height).toBe('30px');
+    expect(ev).toContain('start');
+    expect(ev).toContain('resize');
+    expect(ev).toContain('end');
+  });
+});

package/src/behaviors/focustrap.test.ts

@@ -2,27 +2,33 @@ import { describe, it, expect, vi } from 'vitest';
 
 describe('FocusTrap behavior', () => {
   describe('registerFocusTrap', () => {
-    it('should register with synthetic node via execute', async () => {
-      const { registerFocusTrap } = await import('./focustrap');
+    it('should compile its hyperscript source and execute', async () => {
+      const { registerFocusTrap, focusTrapSource } = await import('./focustrap');
       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 registerFocusTrap(mock);
 
-      expect(mock.compileSync).not.toHaveBeenCalled();
+      expect(mock.compileSync).toHaveBeenCalledWith(focusTrapSource, { traditional: true });
       expect(mock.execute).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'behavior',
-          name: 'FocusTrap',
-          imperativeInstaller: expect.any(Function),
-        }),
+        { type: 'behavior' },
         expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
       );
     });
 
+    it('should throw on compile failure', async () => {
+      const { registerFocusTrap } = await import('./focustrap');
+      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(registerFocusTrap(mock)).rejects.toThrowError(/Failed to compile FocusTrap/);
+    });
+
     it('should throw when no runtime available', async () => {
       const { registerFocusTrap } = await import('./focustrap');
       await expect(registerFocusTrap(undefined)).rejects.toThrowError(/LokaScript not found/);

package/src/behaviors/focustrap.ts

@@ -1,8 +1,14 @@
 /**
- * FocusTrap Behavior — Imperative Implementation
+ * FocusTrap Behavior
  *
  * Confines Tab navigation inside an element, manages aria-modal,
- * and restores focus on deactivation.
+ * and restores focus on deactivation. The Tab-trapping / focus-model logic
+ * lives in the schema's hyperscript `source` (an `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 FocusTrap onto
+ * the one runtime path (no more imperative-installer fork between CDN and npm);
+ * see docs-internal/BEHAVIORS_CONSOLIDATION_PLAN.md §3d.
  */
 
 import { focusTrapSchema } from '../schemas/focustrap.schema';
@@ -13,118 +19,9 @@ import { resolveRuntime } from '../schemas/types';
 export const focusTrapSource = focusTrapSchema.source;
 export const focusTrapMetadata = focusTrapSchema;
 
-const FOCUSABLE_SELECTOR = [
-  'a[href]',
-  'button:not(:disabled)',
-  'input:not(:disabled)',
-  'select:not(:disabled)',
-  'textarea:not(:disabled)',
-  '[tabindex]:not([tabindex="-1"])',
-].join(', ');
-
-/**
- * Resolve a selector parameter to an HTMLElement within the container.
- */
-function resolveElement(container: HTMLElement, param: unknown): HTMLElement | null {
-  if (!param) return null;
-  if (param instanceof HTMLElement) return param;
-  if (typeof param === 'string') {
-    return (
-      (container.querySelector(param) as HTMLElement) ||
-      (document.querySelector(param) as HTMLElement) ||
-      null
-    );
-  }
-  return null;
-}
-
 /**
- * Imperative installer for FocusTrap behavior.
- */
-function installFocusTrap(element: HTMLElement, params: Record<string, any>): void {
-  const returnFocus = params.returnFocus !== false;
-  let isActive = false;
-  let previouslyFocused: Element | null = null;
-
-  function getFocusableElements(): HTMLElement[] {
-    return Array.from(element.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
-  }
-
-  function onKeyDown(e: KeyboardEvent) {
-    if (!isActive || e.key !== 'Tab') return;
-
-    const focusable = getFocusableElements();
-    if (focusable.length === 0) {
-      e.preventDefault();
-      return;
-    }
-
-    // Always prevent default Tab and manually manage focus.
-    // This ensures focus never escapes to elements outside the trap,
-    // even when the modal is embedded in a page with other focusable elements.
-    e.preventDefault();
-
-    const currentIndex = focusable.indexOf(document.activeElement as HTMLElement);
-
-    if (e.shiftKey) {
-      const prevIndex = currentIndex <= 0 ? focusable.length - 1 : currentIndex - 1;
-      focusable[prevIndex].focus();
-    } else {
-      const nextIndex = currentIndex >= focusable.length - 1 ? 0 : currentIndex + 1;
-      focusable[nextIndex].focus();
-    }
-  }
-
-  function activate() {
-    if (isActive) return;
-    isActive = true;
-    previouslyFocused = document.activeElement;
-
-    element.setAttribute('aria-modal', 'true');
-
-    // Focus initialFocus element or first focusable
-    const initialEl = resolveElement(element, params.initialFocus);
-    if (initialEl) {
-      initialEl.focus();
-    } else {
-      const focusable = getFocusableElements();
-      if (focusable.length > 0) {
-        focusable[0].focus();
-      }
-    }
-
-    element.dispatchEvent(new CustomEvent('focustrap:activated', { bubbles: true }));
-  }
-
-  function deactivate() {
-    if (!isActive) return;
-    isActive = false;
-
-    element.removeAttribute('aria-modal');
-
-    if (returnFocus && previouslyFocused instanceof HTMLElement) {
-      previouslyFocused.focus();
-    }
-    previouslyFocused = null;
-
-    element.dispatchEvent(new CustomEvent('focustrap:deactivated', { bubbles: true }));
-  }
-
-  // Keydown handler for Tab trapping
-  element.addEventListener('keydown', onKeyDown);
-
-  // Programmatic activation/deactivation via custom events
-  element.addEventListener('focustrap:activate', () => activate());
-  element.addEventListener('focustrap:deactivate', () => deactivate());
-
-  // Activate immediately if requested
-  if (params.active !== false) {
-    activate();
-  }
-}
-
-/**
- * Register the FocusTrap behavior with LokaScript.
+ * Register the FocusTrap behavior with LokaScript by compiling its
+ * hyperscript source and executing the resulting behavior definition.
  */
 export async function registerFocusTrap(hyperfixi?: LokaScriptInstance): Promise<void> {
   const hf = hyperfixi || resolveRuntime();
@@ -135,15 +32,14 @@ export async function registerFocusTrap(hyperfixi?: LokaScriptInstance): Promise
     );
   }
 
-  const syntheticNode = {
-    type: 'behavior',
-    name: 'FocusTrap',
-    parameters: ['active', 'initialFocus', 'returnFocus'],
-    eventHandlers: [],
-    imperativeInstaller: installFocusTrap,
-  };
+  const result = hf.compileSync(focusTrapSchema.source, { traditional: true });
+
+  if (!result.ok) {
+    throw new Error(`Failed to compile FocusTrap 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/integration.test.ts

@@ -21,23 +21,24 @@ function createMockInstance(overrides: Partial<LokaScriptInstance> = {}): LokaSc
   };
 }
 
-// Source-compiled behaviors (use compileSync + execute)
+// Source-compiled behaviors (use compileSync + execute).
+// EVERY behavior compiles its hyperscript `source` — one runtime path, identical
+// browser/npm, no imperative JS installer (the "no imperative JS" rule). The optional
+// three (FocusTrap/ScrollReveal/Tabs) carry their web-API logic in an `init`-block
+// `js()` body, and the experimental three (Draggable/Sortable/Resizable) run their
+// pointer-drag loops via `repeat until event` — all through the single compile path.
 const compiledBehaviors = [
   { name: 'Removable', register: registerRemovable, source: removableSource },
-] as const;
-
-// Imperative behaviors (use synthetic node with imperativeInstaller)
-const imperativeBehaviors = [
-  { name: 'Draggable', register: registerDraggable, source: draggableSource },
   { name: 'Toggleable', register: registerToggleable, source: toggleableSource },
-  { name: 'Sortable', register: registerSortable, source: sortableSource },
-  { name: 'Resizable', register: registerResizable, source: resizableSource },
   { name: 'Clipboard', register: registerClipboard, source: clipboardSource },
   { name: 'AutoDismiss', register: registerAutoDismiss, source: autoDismissSource },
   { name: 'ClickOutside', register: registerClickOutside, source: clickOutsideSource },
   { name: 'FocusTrap', register: registerFocusTrap, source: focusTrapSource },
   { name: 'ScrollReveal', register: registerScrollReveal, source: scrollRevealSource },
   { name: 'Tabs', register: registerTabs, source: tabsSource },
+  { name: 'Draggable', register: registerDraggable, source: draggableSource },
+  { name: 'Sortable', register: registerSortable, source: sortableSource },
+  { name: 'Resizable', register: registerResizable, source: resizableSource },
 ] as const;
 
 describe('behavior registration integration', () => {
@@ -96,60 +97,4 @@ describe('behavior registration integration', () => {
       });
     }
   });
-
-  describe('imperative behaviors', () => {
-    for (const { name, register } of imperativeBehaviors) {
-      describe(name, () => {
-        it('should register via synthetic node with imperativeInstaller', async () => {
-          const mock = createMockInstance();
-          await register(mock);
-
-          // Imperative behaviors do NOT call compileSync
-          expect(mock.compileSync).not.toHaveBeenCalled();
-
-          // They call execute with a synthetic node containing imperativeInstaller
-          expect(mock.execute).toHaveBeenCalledWith(
-            expect.objectContaining({
-              type: 'behavior',
-              name,
-              imperativeInstaller: expect.any(Function),
-            }),
-            expect.objectContaining({
-              locals: expect.any(Map),
-              globals: expect.any(Map),
-            })
-          );
-        });
-
-        it('should create context', async () => {
-          const mock = createMockInstance();
-          await register(mock);
-          expect(mock.createContext).toHaveBeenCalled();
-        });
-
-        it('should throw when lokascript is not available', async () => {
-          await expect(register(undefined)).rejects.toThrowError(/LokaScript not found/);
-        });
-
-        it('should fall back to manual context when createContext is missing', async () => {
-          const mock = createMockInstance();
-          delete (mock as Partial<LokaScriptInstance>).createContext;
-
-          await register(mock);
-
-          expect(mock.execute).toHaveBeenCalledWith(
-            expect.objectContaining({
-              type: 'behavior',
-              name,
-              imperativeInstaller: expect.any(Function),
-            }),
-            expect.objectContaining({
-              locals: expect.any(Map),
-              globals: expect.any(Map),
-            })
-          );
-        });
-      });
-    }
-  });
 });