@hyperfixi/behaviors 3.3.0 → 4.0.1

package/src/behaviors/resizable.ts

@@ -1,9 +1,9 @@
 /**
  * Resizable Behavior
  *
- * 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
+ * Makes elements resizable by dragging. Defined from its hyperscript `source`
+ * (single source of truth) — no imperative installer. The source reads the start
+ * size from `my offsetWidth` / `my offsetHeight`, runs a `repeat until event pointerup` loop, clamps to
  * min/max dimensions, and writes `*width` / `*height` inline styles.
  *
  * @example
@@ -15,34 +15,19 @@
  */
 
 import { resizableSchema } from '../schemas/resizable.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 resizableSource = resizableSchema.source;
 export const resizableMetadata = resizableSchema;
 
 /**
- * Register the Resizable behavior with LokaScript by compiling its hyperscript
- * source and executing the resulting behavior definition.
+ * Define the Resizable behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerResizable(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(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(result.ast, ctx);
+export async function registerResizable(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(resizableSchema, host);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/scrollreveal.test.ts

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

package/src/behaviors/scrollreveal.ts

@@ -5,41 +5,26 @@
  * 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
+ * Defined from its hyperscript `source` — the single source of truth shared with
+ * the browser 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';
-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 scrollRevealSource = scrollRevealSchema.source;
 export const scrollRevealMetadata = scrollRevealSchema;
 
 /**
- * Register the ScrollReveal behavior with LokaScript by compiling its
- * hyperscript source and executing the resulting behavior definition.
+ * Define the ScrollReveal behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerScrollReveal(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(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(result.ast, ctx);
+export async function registerScrollReveal(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(scrollRevealSchema, host);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/sortable.ts

@@ -2,7 +2,7 @@
  * Sortable Behavior
  *
  * Drag-and-drop reordering of list items. Apply to a container element; its
- * `<li>` children become sortable. Compiled from its hyperscript `source` (single
+ * `<li>` children become sortable. Defined from its hyperscript `source` (single
  * source of truth) — no imperative installer.
  *
  * Note: This behavior fires lifecycle events but does NOT automatically reorder
@@ -18,34 +18,19 @@
  */
 
 import { sortableSchema } from '../schemas/sortable.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 sortableSource = sortableSchema.source;
 export const sortableMetadata = sortableSchema;
 
 /**
- * Register the Sortable behavior with LokaScript by compiling its hyperscript
- * source and executing the resulting behavior definition.
+ * Define the Sortable behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerSortable(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(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(result.ast, ctx);
+export async function registerSortable(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(sortableSchema, host);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/tabs.test.ts

@@ -2,50 +2,28 @@ import { describe, it, expect, vi } from 'vitest';
 
 describe('Tabs behavior', () => {
   describe('registerTabs', () => {
-    it('should compile its hyperscript source and execute', async () => {
+    it('defines the behavior on the host from its hyperscript source', async () => {
       const { registerTabs, tabsSource } = await import('./tabs');
-      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 registerTabs(mock);
+      await registerTabs(host);
 
-      expect(mock.compileSync).toHaveBeenCalledWith(tabsSource, { traditional: true });
-      expect(mock.execute).toHaveBeenCalledWith(
-        { type: 'behavior' },
-        expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
-      );
+      expect(host.evaluate).toHaveBeenCalledWith(tabsSource);
     });
 
-    it('should throw on compile failure', async () => {
+    it('should throw when the host rejects the source', 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() }),
+      const host = {
+        evaluate: vi.fn(() => {
+          throw new Error('boom');
+        }),
       };
-      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/);
+      await expect(registerTabs(host)).rejects.toThrowError(/Failed to define Tabs/);
     });
 
-    it('should fall back to manual context when createContext is missing', async () => {
+    it('should throw when no host is available', async () => {
       const { registerTabs } = await import('./tabs');
-      const mock = {
-        compileSync: vi.fn().mockReturnValue({ ok: true, ast: { type: 'behavior' } }),
-        execute: vi.fn().mockResolvedValue(undefined),
-      };
-
-      await registerTabs(mock as any);
-      expect(mock.execute).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
-      );
+      await expect(registerTabs(undefined)).rejects.toThrowError(/No hyperscript host/);
     });
   });
 

package/src/behaviors/tabs.ts

@@ -6,40 +6,25 @@
  * wiring / keyboard-navigation 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 Tabs onto the one
+ * Defined from its hyperscript `source` — the single source of truth shared with
+ * the browser bundle and patterns-reference. This collapses Tabs onto the one
  * runtime path (no more imperative-installer fork between CDN and npm);
  * see docs-internal/BEHAVIORS_CONSOLIDATION_PLAN.md §3d.
  */
 
 import { tabsSchema } from '../schemas/tabs.schema';
-import type { LokaScriptInstance } from '../schemas/types';
-import { resolveRuntime } from '../schemas/types';
+import { defineBehavior, resolveRuntime } from '../schemas/types';
+import type { HyperscriptHost } from '../schemas/types';
 
 export const tabsSource = tabsSchema.source;
 export const tabsMetadata = tabsSchema;
 
 /**
- * Register the Tabs behavior with LokaScript by compiling its
- * hyperscript source and executing the resulting behavior definition.
+ * Define the Tabs behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerTabs(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(tabsSchema.source, { traditional: true });
-
-  if (!result.ok) {
-    throw new Error(`Failed to compile Tabs 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 registerTabs(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(tabsSchema, host);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/toggleable.ts

@@ -4,48 +4,32 @@
  * A behavior that toggles a CSS class on click.
  * Useful for accordions, dropdowns, and toggle buttons.
  *
- * Compiled from its hyperscript `source` (the single source of truth shared with
- * the CDN resolver bundle and patterns-reference). The `.{cls}` dynamic class
- * selector resolves the behavior's `cls` parameter at runtime — see
- * `packages/core/src/commands/behaviors/__tests__/template-interpolation.test.ts`.
+ * Defined from its hyperscript `source` (the single source of truth shared with
+ * the browser bundle and patterns-reference). The `.{cls}` dynamic class
+ * selector resolves the behavior's `cls` parameter at runtime.
  *
  * @example
  * ```html
  * <button _="install Toggleable">Toggle</button>
  *
- * <button _="install Toggleable(cls: expanded, target: #menu)">Menu</button>
+ * <button _="install Toggleable(cls: 'expanded', targetEl: #menu)">Menu</button>
  * ```
  */
 
 import { toggleableSchema } from '../schemas/toggleable.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 toggleableSource = toggleableSchema.source;
 export const toggleableMetadata = toggleableSchema;
 
 /**
- * Register the Toggleable behavior with LokaScript by compiling its
- * hyperscript source and executing the resulting behavior definition.
+ * Define the Toggleable behavior on a hyperscript host (`window.hyperfixi` when none is given)
+ * from its source, as a `<script type="text/hyperscript">` would.
  */
-export async function registerToggleable(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(toggleableSchema.source, { traditional: true });
-
-  if (!result.ok) {
-    throw new Error(`Failed to compile Toggleable 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 registerToggleable(host?: HyperscriptHost): Promise<void> {
+  defineBehavior(toggleableSchema, host);
 }
 
 // Auto-register when loaded as a script tag

package/src/browser-resolver-bundle.ts

@@ -1,40 +1,30 @@
 /**
- * Browser Behavior Resolver Bundle
+ * The behaviors browser bundle: `resolver.browser.global.js`.
  *
- * Pre-registers all standard behavior definitions with the hyperfixi runtime.
- * Include after hyperfixi.js — all standard behaviors become available.
+ * Defines every standard behavior on the hyperscript host, so `install Toggleable`,
+ * `install Draggable`, … just work. Include it after the host's script:
  *
- * Usage:
- *   <script src="hyperfixi.js"></script>
- *   <script src="hyperfixi-behaviors.js"></script>
- *   <!-- install Toggleable, Draggable, etc. just work -->
+ *   <script src="hyperfixi-hs.js"></script>
+ *   <script src="resolver.browser.global.js"></script>
+ *
+ * The host is `@hyperfixi/engine` (`window.hyperfixi`, also `window._hyperscript`) or
+ * upstream `_hyperscript` itself: each source is defined with `evaluate`, as a page's
+ * `<script type="text/hyperscript">` would be. Loaded before the document is ready, this runs
+ * before the host reads the page, so every `install` finds its behavior; loaded later, the
+ * document is processed again so the installs can succeed now.
  */
 
-import { BEHAVIOR_SOURCES } from './behavior-resolver';
-
-function init() {
-  const hf = (window as any).hyperfixi;
-  if (!hf?.compileSync || !hf?.execute) return;
-
-  // Compile and register each behavior definition with the runtime.
-  // This is equivalent to having them in a <script type="text/hyperscript"> block.
-  for (const source of Object.values(BEHAVIOR_SOURCES)) {
-    const result = hf.compileSync(source, { traditional: true });
-    if (result?.ok && result.ast) {
-      // execute() registers the behavior in the runtime's behaviorRegistry
-      hf.execute(result.ast).catch(() => {
-        // Async — errors handled silently
-      });
-    }
-  }
+import { defineBehaviors } from './behavior-resolver';
+import { resolveRuntime } from './schemas/types';
 
-  // Re-scan: the attribute processor may have already processed elements
-  // and failed (behaviors weren't registered). Reset and re-init.
-  const ap = hf.attributeProcessor;
-  if (ap) {
-    ap.reset();
-    ap.init();
+function init(): void {
+  const host = resolveRuntime();
+  if (!host) {
+    console.error('[behaviors] no hyperscript host: load hyperfixi-hs.js before this bundle');
+    return;
   }
+  defineBehaviors(host);
+  if (document.readyState !== 'loading') host.processNode?.(document.body);
 }
 
 if (typeof window !== 'undefined') {

package/src/core-bundle.ts

@@ -11,25 +11,25 @@ export { registerToggleable, toggleableSource, toggleableMetadata } from './beha
 
 import { registerDraggable } from './behaviors/draggable';
 import { registerToggleable } from './behaviors/toggleable';
-import type { LokaScriptInstance, LokaScriptWindow } from './schemas/types';
+import type { HyperscriptHost } from './schemas/types';
+import { resolveRuntime } from './schemas/types';
 
 /**
- * Register all core tier behaviors.
+ * Define the core tier behaviors on a hyperscript host.
  */
-export async function registerCore(hyperfixi?: LokaScriptInstance): Promise<void> {
-  await Promise.all([registerDraggable(hyperfixi), registerToggleable(hyperfixi)]);
+export async function registerCore(host?: HyperscriptHost): Promise<void> {
+  await Promise.all([registerDraggable(host), registerToggleable(host)]);
 }
 
 /**
- * Promise that resolves when core behaviors are registered.
- * Set when the package auto-registers in browser environments.
+ * Resolves when the core behaviors are defined, when the package was loaded as a script tag
+ * after the host; `null` otherwise.
  */
 export let ready: Promise<void> | null = null;
 
-// Auto-register when loaded in browser
-if (typeof window !== 'undefined' && (window as unknown as LokaScriptWindow).lokascript) {
-  ready = registerCore();
-  ready.catch(err => {
-    console.error('[behaviors] Core auto-registration failed:', err);
+const _host = resolveRuntime();
+if (_host) {
+  ready = registerCore(_host).catch(err => {
+    console.error('[behaviors] Core auto-definition failed:', err);
   });
 }

package/src/index.test.ts

@@ -195,7 +195,7 @@ describe('@hyperfixi/behaviors', () => {
 
     it('should use triggerEl parameter (not trigger)', () => {
       expect(removableSource).toContain('behavior Removable(triggerEl');
-      expect(removableSource).toContain('on click from triggerEl');
+      expect(removableSource).toContain('on click from (triggerEl or me)');
     });
   });
 
@@ -211,7 +211,7 @@ describe('@hyperfixi/behaviors', () => {
     });
 
     it('should default to "active" class', () => {
-      expect(toggleableSource).toContain('set cls to "active"');
+      expect(toggleableSource).toContain(`set element's cls to "active"`);
     });
   });
 

package/src/index.ts

@@ -26,7 +26,7 @@
  *
  * @example CDN usage
  * ```html
- * <script src="lokascript-browser.js"></script>
+ * <script src="hyperfixi-hs.js"></script>
  * <script src="@hyperfixi/behaviors/draggable.browser.js"></script>
  * <!-- Draggable is auto-registered -->
  * ```
@@ -119,7 +119,8 @@ export type {
   ParameterSchema,
   EventSchema,
   BehaviorModule,
-  LokaScriptInstance,
+  HyperscriptHost,
+  HyperscriptWindow,
 } from './schemas/types';
 
 // =============================================================================
@@ -214,15 +215,14 @@ import { registerClickOutside } from './behaviors/clickoutside';
 import { registerFocusTrap } from './behaviors/focustrap';
 import { registerScrollReveal } from './behaviors/scrollreveal';
 import { registerTabs } from './behaviors/tabs';
-import type { LokaScriptInstance } from './schemas/types';
+import type { HyperscriptHost } from './schemas/types';
 import { resolveRuntime } from './schemas/types';
-import type { LokaScriptWindow } from './schemas/types';
 
 /**
- * Register all behaviors with HyperFixi.
+ * Define every behavior on a hyperscript host.
  *
- * @param hyperfixi - The hyperfixi instance (defaults to window.hyperfixi)
- * @returns Promise that resolves when all behaviors are registered
+ * @param host - The host (`@hyperfixi/engine`'s `window.hyperfixi`, or upstream's
+ *   `window._hyperscript`); defaults to the one on `window`
  *
  * @example
  * ```javascript
@@ -230,59 +230,42 @@ import type { LokaScriptWindow } from './schemas/types';
  * await registerAll();
  * ```
  */
-export async function registerAll(hyperfixi?: LokaScriptInstance): Promise<void> {
+export async function registerAll(host?: HyperscriptHost): Promise<void> {
   await Promise.all([
-    registerDraggable(hyperfixi),
-    registerRemovable(hyperfixi),
-    registerToggleable(hyperfixi),
-    registerSortable(hyperfixi),
-    registerResizable(hyperfixi),
-    registerClipboard(hyperfixi),
-    registerAutoDismiss(hyperfixi),
-    registerClickOutside(hyperfixi),
-    registerFocusTrap(hyperfixi),
-    registerScrollReveal(hyperfixi),
-    registerTabs(hyperfixi),
+    registerDraggable(host),
+    registerRemovable(host),
+    registerToggleable(host),
+    registerSortable(host),
+    registerResizable(host),
+    registerClipboard(host),
+    registerAutoDismiss(host),
+    registerClickOutside(host),
+    registerFocusTrap(host),
+    registerScrollReveal(host),
+    registerTabs(host),
   ]);
 }
 
 // =============================================================================
-// Auto-registration for browser
+// Auto-definition for the browser bundles
 // =============================================================================
 
 /**
- * Promise that resolves when all behaviors are registered.
- * This is set when the package auto-registers in browser environments.
+ * Resolves when every behavior is defined, when the package was loaded as a script tag after
+ * the host; `null` otherwise.
  */
 export let ready: Promise<void> | null = null;
 
-// Auto-register all behaviors when loaded in browser with hyperfixi available
-const _runtime = resolveRuntime();
-if (_runtime) {
-  const lsWin = window as unknown as LokaScriptWindow;
-  ready = registerAll(_runtime);
-
-  lsWin.__hyperfixi_behaviors_ready = ready;
-
-  ready
+// Loaded as a script tag after the host, before the document is ready, this runs before the
+// host reads the page, so every `install` finds its behavior. Loaded later, the elements the
+// host has already seen are processed again, so their installs can succeed now.
+const _host = resolveRuntime();
+if (_host) {
+  ready = registerAll(_host)
     .then(() => {
-      const hf = _runtime as LokaScriptInstance & {
-        attributeProcessor?: { scanAndProcessAll: () => Promise<void> };
-        processNode?: (node: Document) => void;
-      };
-      const savedPromise = lsWin.__hyperfixi_behaviors_ready;
-      delete lsWin.__hyperfixi_behaviors_ready;
-
-      if (hf.attributeProcessor?.scanAndProcessAll) {
-        hf.attributeProcessor.scanAndProcessAll().finally(() => {
-          lsWin.__hyperfixi_behaviors_ready = savedPromise;
-        });
-      } else if (hf.processNode) {
-        hf.processNode(document);
-        lsWin.__hyperfixi_behaviors_ready = savedPromise;
-      }
+      if (document.readyState !== 'loading') _host.processNode?.(document.body);
     })
     .catch(err => {
-      console.error('[behaviors] Auto-registration failed:', err);
+      console.error('[behaviors] Auto-definition failed:', err);
     });
 }