@hyperfixi/behaviors 3.3.0 → 4.0.1

package/src/behaviors/clipboard.test.ts

@@ -2,50 +2,28 @@ import { describe, it, expect, vi } from 'vitest';
 
 describe('Clipboard behavior', () => {
   describe('registerClipboard', () => {
-    it('should compile its hyperscript source and execute', async () => {
+    it('defines the behavior on the host from its hyperscript source', async () => {
       const { registerClipboard, clipboardSource } = await import('./clipboard');
-      const mock = {
-        compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
-        execute: vi.fn().mockResolvedValue(undefined),
-        createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
-      };
+      const host = { evaluate: vi.fn() };
 
-      await registerClipboard(mock);
+      await registerClipboard(host);
 
-      expect(mock.compileSync).toHaveBeenCalledWith(clipboardSource, { traditional: true });
-      expect(mock.execute).toHaveBeenCalledWith(
-        { type: 'behavior' },
-        expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
-      );
+      expect(host.evaluate).toHaveBeenCalledWith(clipboardSource);
     });
 
-    it('should throw on compile failure', async () => {
+    it('should throw when the host rejects the source', async () => {
       const { registerClipboard } = await import('./clipboard');
-      const mock = {
-        compileSync: vi.fn().mockReturnValue({ ok: false, errors: [{ message: 'boom' }] }),
-        execute: vi.fn(),
-        createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
+      const host = {
+        evaluate: vi.fn(() => {
+          throw new Error('boom');
+        }),
       };
-      await expect(registerClipboard(mock)).rejects.toThrowError(/Failed to compile Clipboard/);
-    });
-
-    it('should throw when no runtime available', async () => {
-      const { registerClipboard } = await import('./clipboard');
-      await expect(registerClipboard(undefined)).rejects.toThrowError(/LokaScript not found/);
+      await expect(registerClipboard(host)).rejects.toThrowError(/Failed to define Clipboard/);
     });
 
-    it('should fall back to manual context when createContext is missing', async () => {
+    it('should throw when no host is available', async () => {
       const { registerClipboard } = await import('./clipboard');
-      const mock = {
-        compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
-        execute: vi.fn().mockResolvedValue(undefined),
-      };
-
-      await registerClipboard(mock as any);
-      expect(mock.execute).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
-      );
+      await expect(registerClipboard(undefined)).rejects.toThrowError(/No hyperscript host/);
     });
   });
 

package/src/behaviors/clipboard.ts

@@ -5,39 +5,24 @@
  * Uses navigator.clipboard.writeText() with execCommand fallback (in its
  * hyperscript `source`'s js() body).
  *
- * Compiled from its hyperscript `source` (the single source of truth shared with
- * the CDN resolver bundle and patterns-reference).
+ * Defined from its hyperscript `source` (the single source of truth shared with
+ * the browser bundle and patterns-reference).
  */
 
 import { clipboardSchema } from '../schemas/clipboard.schema';
-import type { LokaScriptInstance } from '../schemas/types';
-import { resolveRuntime } from '../schemas/types';
+import { defineBehavior, resolveRuntime } from '../schemas/types';
+import type { HyperscriptHost } from '../schemas/types';
 
 // Re-export schema-derived values
 export const clipboardSource = clipboardSchema.source;
 export const clipboardMetadata = clipboardSchema;
 
 /**
- * Register the Clipboard behavior with LokaScript by compiling its
- * hyperscript source and executing the resulting behavior definition.
+ * Define the Clipboard behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerClipboard(hyperfixi?: LokaScriptInstance): Promise<void> {
-  const hf = hyperfixi || resolveRuntime();
-
-  if (!hf) {
-    throw new Error(
-      'LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors.'
-    );
-  }
-
-  const result = hf.compileSync(clipboardSchema.source, { traditional: true });
-
-  if (!result.ok) {
-    throw new Error(`Failed to compile Clipboard behavior: ${JSON.stringify(result.errors)}`);
-  }
-
-  const ctx = hf.createContext ? hf.createContext() : { locals: new Map(), globals: new Map() };
-  await hf.execute(result.ast, ctx);
+export async function registerClipboard(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(clipboardSchema, host);
 }
 
 // Auto-register when loaded as a script tag

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

@@ -1,45 +1,43 @@
 // @vitest-environment happy-dom
 /**
- * Curated behaviors — REAL runtime behavior tests (Phase 2).
+ * Curated behaviors — REAL runtime behavior tests.
  *
- * 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 exercise each curated behavior's actual hyperscript `source` on the real
+ * @hyperfixi/engine: define → install on an element → drive the DOM → assert both the
+ * effect AND the documented lifecycle events. This is the "parses ≠ works" guard — the
+ * mock-based unit tests only prove `register*()` hands the source to the host; these prove
+ * the sources do the right thing when they run.
  *
- * 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.
+ * The engine runs the same source the pages do, and upstream _hyperscript runs it the same
+ * way (measured in a browser, 2026-10-03, with at least one argument given: upstream's
+ * `install X` without parentheses throws; `install X()` works there).
  */
 import { describe, it, expect, beforeAll, afterEach, vi } from 'vitest';
-import { hyperscript } from '@hyperfixi/core';
+import { api, everything, processNode, register } from '@hyperfixi/engine';
 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));
 
+/** Install from an attribute, as a page does: the engine reads `_` and runs the install. */
 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));
+  el.setAttribute('_', code);
+  processNode(el);
+  await tick();
 }
 
 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);
+  // The engine is assembled from modules; this bundle is every one. Behaviors are globals
+  // (`window.Toggleable`), so define the set once per file.
+  register(...everything);
+  await registerToggleable(api);
+  await registerRemovable(api);
+  await registerClickOutside(api);
+  await registerClipboard(api);
+  await registerAutoDismiss(api);
 });
 
 afterEach(() => {

package/src/behaviors/draggable.ts

@@ -1,11 +1,12 @@
 /**
  * Draggable Behavior
  *
- * Makes elements draggable with pointer events. Compiled from its hyperscript
- * `source` (the single source of truth shared with the CDN resolver bundle and
+ * Makes elements draggable with pointer events. Defined from its hyperscript
+ * `source` (the single source of truth shared with the browser 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.
+ * drag loop, `my offsetLeft` / `my offsetTop` for the start offset, and
+ * `add { left: ${…}px }` to move.
  *
  * @example
  * ```html
@@ -21,34 +22,19 @@
  */
 
 import { draggableSchema } from '../schemas/draggable.schema';
-import type { LokaScriptInstance } from '../schemas/types';
-import { resolveRuntime } from '../schemas/types';
+import { defineBehavior, resolveRuntime } from '../schemas/types';
+import type { HyperscriptHost } from '../schemas/types';
 
 // Re-export schema-derived values for backwards compatibility
 export const draggableSource = draggableSchema.source;
 export const draggableMetadata = draggableSchema;
 
 /**
- * Register the Draggable behavior with LokaScript by compiling its hyperscript
- * source and executing the resulting behavior definition.
+ * Define the Draggable behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerDraggable(hyperfixi?: LokaScriptInstance): Promise<void> {
-  const hf = hyperfixi || resolveRuntime();
-
-  if (!hf) {
-    throw new Error(
-      'LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors.'
-    );
-  }
-
-  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(result.ast, ctx);
+export async function registerDraggable(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(draggableSchema, host);
 }
 
 // Auto-register when loaded as a script tag

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

@@ -2,39 +2,40 @@
 /**
  * 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.
+ * Draggable / Sortable / Resizable are defined from their hyperscript `source` like every
+ * other behavior (the "no imperative JS" rule). These tests are the "parses ≠ works" guard:
+ * define → install → drive pointer events → assert the DOM effect AND the 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.
+ * happy-dom has no PointerEvent and zero layout (`my offsetLeft` and `my offsetWidth` read
+ * 0), 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 { api, everything, processNode, register } from '@hyperfixi/engine';
 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 });
 }
 
+/** Install from an attribute, as a page does: the engine reads `_` and runs the install. */
 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));
+  el.setAttribute('_', code);
+  processNode(el);
+  await tick();
 }
 
 beforeAll(async () => {
-  await registerDraggable(hf);
-  await registerSortable(hf);
-  await registerResizable(hf);
+  // The engine is assembled from modules; this bundle is every one. Behaviors are globals
+  // (`window.Toggleable`), so define the set once per file.
+  register(...everything);
+  await registerDraggable(api);
+  await registerSortable(api);
+  await registerResizable(api);
 });
 
 afterEach(() => {
@@ -63,7 +64,7 @@ describe('Draggable — runtime (source-compiled)', () => {
     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
+    // offsetLeft/offsetTop = 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');
@@ -126,7 +127,7 @@ describe('Resizable — runtime (source-compiled)', () => {
     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
+    // offsetWidth/offsetHeight = 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');

package/src/behaviors/focustrap.test.ts

@@ -2,36 +2,28 @@ import { describe, it, expect, vi } from 'vitest';
 
 describe('FocusTrap behavior', () => {
   describe('registerFocusTrap', () => {
-    it('should compile its hyperscript source and execute', async () => {
+    it('defines the behavior on the host from its hyperscript source', async () => {
       const { registerFocusTrap, focusTrapSource } = await import('./focustrap');
-      const mock = {
-        compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
-        execute: vi.fn().mockResolvedValue(undefined),
-        createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
-      };
+      const host = { evaluate: vi.fn() };
 
-      await registerFocusTrap(mock);
+      await registerFocusTrap(host);
 
-      expect(mock.compileSync).toHaveBeenCalledWith(focusTrapSource, { traditional: true });
-      expect(mock.execute).toHaveBeenCalledWith(
-        { type: 'behavior' },
-        expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
-      );
+      expect(host.evaluate).toHaveBeenCalledWith(focusTrapSource);
     });
 
-    it('should throw on compile failure', async () => {
+    it('should throw when the host rejects the source', 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() }),
+      const host = {
+        evaluate: vi.fn(() => {
+          throw new Error('boom');
+        }),
       };
-      await expect(registerFocusTrap(mock)).rejects.toThrowError(/Failed to compile FocusTrap/);
+      await expect(registerFocusTrap(host)).rejects.toThrowError(/Failed to define FocusTrap/);
     });
 
-    it('should throw when no runtime available', async () => {
+    it('should throw when no host is available', async () => {
       const { registerFocusTrap } = await import('./focustrap');
-      await expect(registerFocusTrap(undefined)).rejects.toThrowError(/LokaScript not found/);
+      await expect(registerFocusTrap(undefined)).rejects.toThrowError(/No hyperscript host/);
     });
   });
 

package/src/behaviors/focustrap.ts

@@ -5,41 +5,26 @@
  * 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
+ * Defined from its hyperscript `source` — the single source of truth shared with
+ * the browser 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';
-import type { LokaScriptInstance } from '../schemas/types';
-import { resolveRuntime } from '../schemas/types';
+import { defineBehavior, resolveRuntime } from '../schemas/types';
+import type { HyperscriptHost } from '../schemas/types';
 
 // Re-export schema-derived values
 export const focusTrapSource = focusTrapSchema.source;
 export const focusTrapMetadata = focusTrapSchema;
 
 /**
- * Register the FocusTrap behavior with LokaScript by compiling its
- * hyperscript source and executing the resulting behavior definition.
+ * Define the FocusTrap behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerFocusTrap(hyperfixi?: LokaScriptInstance): Promise<void> {
-  const hf = hyperfixi || resolveRuntime();
-
-  if (!hf) {
-    throw new Error(
-      'LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors.'
-    );
-  }
-
-  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(result.ast, ctx);
+export async function registerFocusTrap(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(focusTrapSchema, host);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/integration.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import type { LokaScriptInstance } from '../schemas/types';
+import type { HyperscriptHost } from '../schemas/types';
 import { registerDraggable, draggableSource } from './draggable';
 import { registerToggleable, toggleableSource } from './toggleable';
 import { registerRemovable, removableSource } from './removable';
@@ -12,21 +12,15 @@ import { registerFocusTrap, focusTrapSource } from './focustrap';
 import { registerScrollReveal, scrollRevealSource } from './scrollreveal';
 import { registerTabs, tabsSource } from './tabs';
 
-function createMockInstance(overrides: Partial<LokaScriptInstance> = {}): LokaScriptInstance {
-  return {
-    compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
-    execute: vi.fn().mockResolvedValue(undefined),
-    createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
-    ...overrides,
-  };
+function createMockHost(overrides: Partial<HyperscriptHost> = {}): HyperscriptHost {
+  return { evaluate: vi.fn(), ...overrides };
 }
 
-// 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
+// EVERY behavior is defined from its hyperscript `source` with the host's `evaluate` — one
+// 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.
+// pointer-drag loops via `repeat until event` — all through the single path.
 const compiledBehaviors = [
   { name: 'Removable', register: registerRemovable, source: removableSource },
   { name: 'Toggleable', register: registerToggleable, source: toggleableSource },
@@ -42,57 +36,28 @@ const compiledBehaviors = [
 ] as const;
 
 describe('behavior registration integration', () => {
-  describe('source-compiled behaviors', () => {
+  describe('source-defined behaviors', () => {
     for (const { name, register, source } of compiledBehaviors) {
       describe(name, () => {
-        it('should compile with traditional parser', async () => {
-          const mock = createMockInstance();
-          await register(mock);
+        it('should define the source on the host', async () => {
+          const host = createMockHost();
+          await register(host);
 
-          expect(mock.compileSync).toHaveBeenCalledWith(source, { traditional: true });
+          expect(host.evaluate).toHaveBeenCalledWith(source);
         });
 
-        it('should create context and execute', async () => {
-          const mock = createMockInstance();
-          await register(mock);
-
-          expect(mock.createContext).toHaveBeenCalled();
-          expect(mock.execute).toHaveBeenCalledWith(
-            { type: 'behavior' },
-            { locals: expect.any(Map), globals: expect.any(Map) }
-          );
-        });
-
-        it('should throw on compile failure', async () => {
-          const mock = createMockInstance({
-            compileSync: vi.fn().mockReturnValue({
-              ok: false,
-              errors: [{ message: 'syntax error', line: 1 }],
+        it('should throw when the host rejects the source', async () => {
+          const host = createMockHost({
+            evaluate: vi.fn(() => {
+              throw new Error('syntax error');
             }),
           });
 
-          await expect(register(mock)).rejects.toThrowError(
-            new RegExp(`Failed to compile ${name}`)
-          );
+          await expect(register(host)).rejects.toThrowError(new RegExp(`Failed to define ${name}`));
         });
 
-        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(
-            { type: 'behavior' },
-            expect.objectContaining({
-              locals: expect.any(Map),
-              globals: expect.any(Map),
-            })
-          );
+        it('should throw when no host is available', async () => {
+          await expect(register(undefined)).rejects.toThrowError(/No hyperscript host/);
         });
       });
     }

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

@@ -2,40 +2,35 @@
 /**
  * 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.
+ * Like curated-runtime.test.ts, these exercise each behavior's actual hyperscript `source`
+ * on the real @hyperfixi/engine — define → install on an element → drive the DOM → assert
+ * both the effect AND the documented lifecycle events. The optional three carry their
+ * web-API logic (a focus model, an IntersectionObserver, ARIA/keyboard wiring) in an
+ * `init`-block `js()` body; these prove those bodies run correctly once the source is
+ * defined — exactly the class of bug a parse check cannot see.
  */
 import { describe, it, expect, beforeAll, afterEach, vi } from 'vitest';
-import { hyperscript } from '@hyperfixi/core';
+import { api, everything, processNode, register } from '@hyperfixi/engine';
 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));
 
+/** Install from an attribute, as a page does: the engine reads `_` and runs the install. */
 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));
+  el.setAttribute('_', code);
+  processNode(el);
+  await tick();
 }
 
 beforeAll(async () => {
-  // Behavior registry is a runtime singleton; register the optional set once.
-  await registerFocusTrap(hf);
-  await registerScrollReveal(hf);
-  await registerTabs(hf);
+  // The engine is assembled from modules; this bundle is every one. Behaviors are globals
+  // (`window.Toggleable`), so define the set once per file.
+  register(...everything);
+  await registerFocusTrap(api);
+  await registerScrollReveal(api);
+  await registerTabs(api);
 });
 
 afterEach(() => {

package/src/behaviors/removable.ts

@@ -13,33 +13,19 @@
  */
 
 import { removableSchema } from '../schemas/removable.schema';
-import type { LokaScriptInstance } from '../schemas/types';
-import { resolveRuntime } from '../schemas/types';
+import { defineBehavior, resolveRuntime } from '../schemas/types';
+import type { HyperscriptHost } from '../schemas/types';
 
 // Re-export schema-derived values for backwards compatibility
 export const removableSource = removableSchema.source;
 export const removableMetadata = removableSchema;
 
 /**
- * Register the Removable behavior with LokaScript.
+ * Define the Removable behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerRemovable(hyperfixi?: LokaScriptInstance): Promise<void> {
-  const hf = hyperfixi || resolveRuntime();
-
-  if (!hf) {
-    throw new Error(
-      'LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors.'
-    );
-  }
-
-  const result = hf.compileSync(removableSchema.source, { traditional: true });
-
-  if (!result.ok) {
-    throw new Error(`Failed to compile Removable behavior: ${JSON.stringify(result.errors)}`);
-  }
-
-  const ctx = hf.createContext ? hf.createContext() : { locals: new Map(), globals: new Map() };
-  await hf.execute(result.ast, ctx);
+export async function registerRemovable(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(removableSchema, host);
 }
 
 // Auto-register when loaded as a script tag