@hyperfixi/behaviors 2.5.1 → 2.7.0

package/src/behaviors/tabs.ts

@@ -1,8 +1,15 @@
 /**
- * Tabs Behavior — Imperative Implementation
+ * Tabs Behavior
  *
  * WAI-ARIA compliant tabs with roving tabindex keyboard navigation.
- * Auto-wires role, aria-selected, aria-controls, and aria-labelledby.
+ * Auto-wires role, aria-selected, aria-controls, and aria-labelledby. The ARIA
+ * 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
+ * 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';
@@ -12,157 +19,9 @@ import { resolveRuntime } from '../schemas/types';
 export const tabsSource = tabsSchema.source;
 export const tabsMetadata = tabsSchema;
 
-let idCounter = 0;
-
-function ensureId(el: HTMLElement, prefix: string): string {
-  if (!el.id) {
-    el.id = `${prefix}-${++idCounter}`;
-  }
-  return el.id;
-}
-
-/**
- * Imperative installer for Tabs behavior.
- */
-function installTabs(element: HTMLElement, params: Record<string, any>): void {
-  const orientation = params.orientation === 'vertical' ? 'vertical' : 'horizontal';
-  const wrap = params.wrap !== false;
-  const activeClass = (params.activeClass as string) || 'active';
-  const initialIndex = typeof params.activeTab === 'number' ? params.activeTab : 0;
-
-  // Discover tabs and panels
-  const tabs = Array.from(element.querySelectorAll<HTMLElement>('[role="tab"]'));
-  const panels = Array.from(element.querySelectorAll<HTMLElement>('[role="tabpanel"]'));
-
-  if (tabs.length === 0 || panels.length === 0) return;
-
-  // Find or mark the tablist
-  const tablist = element.querySelector<HTMLElement>('[role="tablist"]') || tabs[0].parentElement;
-  if (tablist && !tablist.getAttribute('role')) {
-    tablist.setAttribute('role', 'tablist');
-  }
-  if (tablist) {
-    tablist.setAttribute('aria-orientation', orientation);
-  }
-
-  // Wire IDs, aria-controls, aria-labelledby
-  const count = Math.min(tabs.length, panels.length);
-  for (let i = 0; i < count; i++) {
-    const tabId = ensureId(tabs[i], 'tab');
-    const panelId = ensureId(panels[i], 'tabpanel');
-    tabs[i].setAttribute('aria-controls', panelId);
-    panels[i].setAttribute('aria-labelledby', tabId);
-  }
-
-  let currentIndex = -1;
-
-  function selectTab(index: number, previousIndex: number): boolean {
-    if (index === previousIndex || index < 0 || index >= count) return false;
-
-    const detail = {
-      tab: tabs[index],
-      panel: panels[index],
-      index,
-      previousIndex,
-    };
-
-    // Cancelable before-event
-    const changeEvent = new CustomEvent('tabs:change', {
-      bubbles: true,
-      cancelable: true,
-      detail,
-    });
-    element.dispatchEvent(changeEvent);
-    if (changeEvent.defaultPrevented) return false;
-
-    // Deactivate previous
-    if (previousIndex >= 0 && previousIndex < count) {
-      tabs[previousIndex].setAttribute('aria-selected', 'false');
-      tabs[previousIndex].setAttribute('tabindex', '-1');
-      tabs[previousIndex].classList.remove(activeClass);
-      panels[previousIndex].setAttribute('aria-hidden', 'true');
-      panels[previousIndex].classList.remove(activeClass);
-    }
-
-    // Activate new
-    tabs[index].setAttribute('aria-selected', 'true');
-    tabs[index].setAttribute('tabindex', '0');
-    tabs[index].classList.add(activeClass);
-    panels[index].setAttribute('aria-hidden', 'false');
-    panels[index].classList.add(activeClass);
-
-    currentIndex = index;
-
-    element.dispatchEvent(new CustomEvent('tabs:changed', { bubbles: true, detail }));
-    return true;
-  }
-
-  // Initialize all tabs as inactive, then activate initial
-  for (let i = 0; i < count; i++) {
-    tabs[i].setAttribute('aria-selected', 'false');
-    tabs[i].setAttribute('tabindex', '-1');
-    tabs[i].classList.remove(activeClass);
-    panels[i].setAttribute('aria-hidden', 'true');
-    panels[i].classList.remove(activeClass);
-  }
-
-  const clamped = Math.max(0, Math.min(initialIndex, count - 1));
-  // Directly activate without firing change event on init
-  tabs[clamped].setAttribute('aria-selected', 'true');
-  tabs[clamped].setAttribute('tabindex', '0');
-  tabs[clamped].classList.add(activeClass);
-  panels[clamped].setAttribute('aria-hidden', 'false');
-  panels[clamped].classList.add(activeClass);
-  currentIndex = clamped;
-
-  // Click handler
-  for (let i = 0; i < count; i++) {
-    tabs[i].addEventListener('click', () => {
-      selectTab(i, currentIndex);
-      tabs[i].focus();
-    });
-  }
-
-  // Keyboard handler on tablist
-  const keyTarget = tablist || element;
-  keyTarget.addEventListener('keydown', (e: KeyboardEvent) => {
-    const isHorizontal = orientation === 'horizontal';
-    const nextKey = isHorizontal ? 'ArrowRight' : 'ArrowDown';
-    const prevKey = isHorizontal ? 'ArrowLeft' : 'ArrowUp';
-
-    let nextIndex: number | null = null;
-
-    if (e.key === nextKey) {
-      nextIndex = currentIndex + 1;
-      if (nextIndex >= count) nextIndex = wrap ? 0 : null;
-    } else if (e.key === prevKey) {
-      nextIndex = currentIndex - 1;
-      if (nextIndex < 0) nextIndex = wrap ? count - 1 : null;
-    } else if (e.key === 'Home') {
-      nextIndex = 0;
-    } else if (e.key === 'End') {
-      nextIndex = count - 1;
-    }
-
-    if (nextIndex !== null) {
-      e.preventDefault();
-      if (selectTab(nextIndex, currentIndex)) {
-        tabs[nextIndex].focus();
-      }
-    }
-  });
-
-  // Programmatic tab selection
-  element.addEventListener('tabs:select', ((e: CustomEvent) => {
-    const index = e.detail?.index;
-    if (typeof index === 'number') {
-      selectTab(index, currentIndex);
-    }
-  }) as EventListener);
-}
-
 /**
- * Register the Tabs behavior with LokaScript.
+ * Register the Tabs behavior with LokaScript by compiling its
+ * hyperscript source and executing the resulting behavior definition.
  */
 export async function registerTabs(hyperfixi?: LokaScriptInstance): Promise<void> {
   const hf = hyperfixi || resolveRuntime();
@@ -173,15 +32,14 @@ export async function registerTabs(hyperfixi?: LokaScriptInstance): Promise<void
     );
   }
 
-  const syntheticNode = {
-    type: 'behavior',
-    name: 'Tabs',
-    parameters: ['orientation', 'activeTab', 'wrap', 'activeClass'],
-    eventHandlers: [],
-    imperativeInstaller: installTabs,
-  };
+  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(syntheticNode, ctx);
+  await hf.execute(result.ast, ctx);
 }
 
 // Auto-register when loaded as a script tag

package/src/behaviors/toggleable.ts

@@ -1,12 +1,13 @@
 /**
- * Toggleable Behavior — Imperative Implementation
+ * Toggleable Behavior
  *
  * A behavior that toggles a CSS class on click.
  * Useful for accordions, dropdowns, and toggle buttons.
  *
- * Uses direct DOM APIs instead of compiling hyperscript source,
- * because `toggle .{cls}` template interpolation doesn't resolve
- * behavior parameters at runtime.
+ * 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`.
  *
  * @example
  * ```html
@@ -25,35 +26,8 @@ export const toggleableSource = toggleableSchema.source;
 export const toggleableMetadata = toggleableSchema;
 
 /**
- * Imperative installer for Toggleable behavior.
- * Called directly by the runtime when `install Toggleable` is executed.
- */
-function installToggleable(element: HTMLElement, params: Record<string, any>): void {
-  const cls = params.cls || 'active';
-
-  // Resolve target element
-  let targetEl: HTMLElement = element;
-  if (params.target && params.target !== 'me') {
-    if (typeof params.target === 'string') {
-      const found = document.querySelector(params.target);
-      if (found instanceof HTMLElement) targetEl = found;
-    } else if (params.target instanceof HTMLElement) {
-      targetEl = params.target;
-    }
-  }
-
-  element.addEventListener('click', () => {
-    const wasOn = targetEl.classList.contains(cls);
-    targetEl.classList.toggle(cls);
-    targetEl.dispatchEvent(
-      new CustomEvent(wasOn ? 'toggleable:off' : 'toggleable:on', { bubbles: true })
-    );
-  });
-}
-
-/**
- * Register the Toggleable behavior with LokaScript.
- * Uses imperative installer via synthetic behavior node.
+ * Register the Toggleable behavior with LokaScript by compiling its
+ * hyperscript source and executing the resulting behavior definition.
  */
 export async function registerToggleable(hyperfixi?: LokaScriptInstance): Promise<void> {
   const hf = hyperfixi || resolveRuntime();
@@ -64,15 +38,14 @@ export async function registerToggleable(hyperfixi?: LokaScriptInstance): Promis
     );
   }
 
-  const syntheticNode = {
-    type: 'behavior',
-    name: 'Toggleable',
-    parameters: ['cls', 'target'],
-    eventHandlers: [],
-    imperativeInstaller: installToggleable,
-  };
+  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(syntheticNode, ctx);
+  await hf.execute(result.ast, ctx);
 }
 
 // Auto-register when loaded as a script tag

package/src/curation.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import {
+  CURATED_BEHAVIORS,
+  OPTIONAL_BEHAVIORS,
+  EXPERIMENTAL_BEHAVIORS,
+  CURATION_STATUS,
+  curationStatusOf,
+  isCurated,
+} from './curation';
+import { ALL_BEHAVIOR_NAMES } from './generated/metadata';
+
+describe('curation', () => {
+  it('partitions all behaviors into exactly one status', () => {
+    const all = [...CURATED_BEHAVIORS, ...OPTIONAL_BEHAVIORS, ...EXPERIMENTAL_BEHAVIORS];
+    // No overlaps.
+    expect(new Set(all).size).toBe(all.length);
+    // Covers exactly the known behavior set.
+    expect(new Set(all)).toEqual(new Set(ALL_BEHAVIOR_NAMES));
+  });
+
+  it('marks the curated 5', () => {
+    expect([...CURATED_BEHAVIORS].sort()).toEqual(
+      ['AutoDismiss', 'ClickOutside', 'Clipboard', 'Removable', 'Toggleable'].sort()
+    );
+  });
+
+  it('marks the experimental 3 (beyond the boundary)', () => {
+    expect([...EXPERIMENTAL_BEHAVIORS].sort()).toEqual(['Draggable', 'Resizable', 'Sortable']);
+  });
+
+  it('curationStatusOf / isCurated agree with the table', () => {
+    expect(curationStatusOf('Toggleable')).toBe('curated');
+    expect(curationStatusOf('Draggable')).toBe('experimental');
+    expect(curationStatusOf('Tabs')).toBe('optional');
+    expect(curationStatusOf('Nope')).toBeUndefined();
+    expect(isCurated('Clipboard')).toBe(true);
+    expect(isCurated('Sortable')).toBe(false);
+  });
+
+  it('every behavior has a status', () => {
+    for (const name of ALL_BEHAVIOR_NAMES) {
+      expect(CURATION_STATUS[name]).toBeDefined();
+    }
+  });
+});

package/src/curation.ts

@@ -0,0 +1,58 @@
+/**
+ * Curation status — the product decision about which behaviors are first-class.
+ *
+ * This is ORTHOGONAL to {@link BehaviorTier} (core/common/optional), which is about
+ * lazy-loading priority. Curation is about support level and the boundary rule:
+ *
+ *   A behavior is a named, parameterized, *reusable inline script* — `on event →
+ *   DOM action`. Not a component. When it needs an observer, a focus model, or an
+ *   async pointer loop, it has left hyperfixi's lane.
+ *
+ * See docs-internal/BEHAVIORS_CONSOLIDATION_PLAN.md for the full rationale.
+ */
+
+export type CurationStatus = 'curated' | 'optional' | 'experimental';
+
+/**
+ * Curated set — reliable, runtime-tested, multilingual. The supported story.
+ * Real `on event → DOM action` behaviors (Tier A) plus two honestly-labeled
+ * JS-backed conveniences (Clipboard, AutoDismiss).
+ */
+export const CURATED_BEHAVIORS = [
+  'Toggleable',
+  'Removable',
+  'ClickOutside',
+  'Clipboard',
+  'AutoDismiss',
+] as const;
+
+/**
+ * Optional — useful, kept, documented as primitives / nice-to-haves.
+ * FocusTrap + ClickOutside are the primitives a Modal composes from; ScrollReveal
+ * is a nice-to-have; Tabs is high-value but heavy.
+ */
+export const OPTIONAL_BEHAVIORS = ['FocusTrap', 'ScrollReveal', 'Tabs'] as const;
+
+/**
+ * Experimental — stateful async components (drag/sort/resize). These sit *beyond*
+ * the inline-scripting boundary; kept working but explicitly outside the curated,
+ * supported, marketed story.
+ */
+export const EXPERIMENTAL_BEHAVIORS = ['Draggable', 'Sortable', 'Resizable'] as const;
+
+/** Curation status for every behavior, keyed by name. */
+export const CURATION_STATUS: Record<string, CurationStatus> = {
+  ...Object.fromEntries(CURATED_BEHAVIORS.map(n => [n, 'curated' as const])),
+  ...Object.fromEntries(OPTIONAL_BEHAVIORS.map(n => [n, 'optional' as const])),
+  ...Object.fromEntries(EXPERIMENTAL_BEHAVIORS.map(n => [n, 'experimental' as const])),
+};
+
+/** Curation status for a behavior name, or undefined if unknown. */
+export function curationStatusOf(name: string): CurationStatus | undefined {
+  return CURATION_STATUS[name];
+}
+
+/** True for the curated, supported set. */
+export function isCurated(name: string): boolean {
+  return CURATION_STATUS[name] === 'curated';
+}

package/src/index.ts

@@ -185,6 +185,20 @@ export {
   BEHAVIOR_TIERS,
 } from './generated/metadata';
 
+// =============================================================================
+// Curation status (curated / optional / experimental) — see curation.ts
+// =============================================================================
+
+export type { CurationStatus } from './curation';
+export {
+  CURATED_BEHAVIORS,
+  OPTIONAL_BEHAVIORS,
+  EXPERIMENTAL_BEHAVIORS,
+  CURATION_STATUS,
+  curationStatusOf,
+  isCurated,
+} from './curation';
+
 // =============================================================================
 // Convenience functions
 // =============================================================================

package/src/registry.test.ts

@@ -175,7 +175,7 @@ describe('registry', () => {
   });
 
   describe('registerWithRuntime', () => {
-    it('should load and call module.register (imperative behavior)', async () => {
+    it('should load and call module.register (Draggable — now source-compiled)', async () => {
       const mockInstance = {
         compileSync: vi.fn().mockReturnValue({ ok: true, ast: {} }),
         execute: vi.fn().mockResolvedValue(undefined),
@@ -185,15 +185,10 @@ describe('registry', () => {
       await loadBehavior('Draggable');
       await registerWithRuntime('Draggable', mockInstance);
 
-      // Imperative behaviors use execute with synthetic node, not compileSync
-      expect(mockInstance.execute).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'behavior',
-          name: 'Draggable',
-          imperativeInstaller: expect.any(Function),
-        }),
-        expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
-      );
+      // Draggable used to install imperatively; it now compiles its hyperscript
+      // `source` like every other behavior (no imperative installer).
+      expect(mockInstance.compileSync).toHaveBeenCalled();
+      expect(mockInstance.execute).toHaveBeenCalled();
     });
 
     it('should load and call module.register (compiled behavior)', async () => {
@@ -221,7 +216,7 @@ describe('registry', () => {
 
       await loadAll();
       await registerAllWithRuntime(mockInstance);
-      // execute called for each behavior (imperative + compiled)
+      // execute called for each behavior (all source-compiled now)
       expect(mockInstance.execute.mock.calls.length).toBeGreaterThanOrEqual(10);
     });
   });

package/src/schemas/clickoutside.schema.ts

@@ -41,7 +41,7 @@ behavior ClickOutside(active)
     end
   end
   on pointerdown from document
-    js(me, active)
+    js(me, active, event)
       if (!me.isConnected) return;
       if (active && !me.contains(event.target)) {
         me.dispatchEvent(new CustomEvent('clickoutside', { bubbles: true }));

package/src/schemas/clipboard.schema.ts

@@ -65,29 +65,32 @@ behavior Clipboard(text, source, feedback, feedbackDuration)
       set copyText to source's textContent
     end
     js(me, copyText, feedback, feedbackDuration)
-      async function copyToClipboard(t) {
-        if (navigator.clipboard && navigator.clipboard.writeText) {
-          await navigator.clipboard.writeText(t);
-          return;
+      // Wrapped in an async IIFE: hyperscript's js() block has no top-level await.
+      (async function() {
+        async function copyToClipboard(t) {
+          if (navigator.clipboard && navigator.clipboard.writeText) {
+            await navigator.clipboard.writeText(t);
+            return;
+          }
+          var ta = document.createElement('textarea');
+          ta.value = t;
+          ta.style.position = 'fixed';
+          ta.style.opacity = '0';
+          document.body.appendChild(ta);
+          ta.select();
+          try { document.execCommand('copy'); } finally { document.body.removeChild(ta); }
         }
-        var ta = document.createElement('textarea');
-        ta.value = t;
-        ta.style.position = 'fixed';
-        ta.style.opacity = '0';
-        document.body.appendChild(ta);
-        ta.select();
-        try { document.execCommand('copy'); } finally { document.body.removeChild(ta); }
-      }
-      try {
-        await copyToClipboard(copyText);
-        var feedbackEl = feedback ? (typeof feedback === 'string' ? document.querySelector(feedback) : feedback) : me;
-        if (!feedbackEl) feedbackEl = me;
-        feedbackEl.classList.add('copied');
-        me.dispatchEvent(new CustomEvent('clipboard:copied', { bubbles: true, detail: { text: copyText } }));
-        setTimeout(function() { feedbackEl.classList.remove('copied'); }, feedbackDuration);
-      } catch(err) {
-        me.dispatchEvent(new CustomEvent('clipboard:error', { bubbles: true, detail: { error: err } }));
-      }
+        try {
+          await copyToClipboard(copyText);
+          var feedbackEl = feedback ? (typeof feedback === 'string' ? document.querySelector(feedback) : feedback) : me;
+          if (!feedbackEl) feedbackEl = me;
+          feedbackEl.classList.add('copied');
+          me.dispatchEvent(new CustomEvent('clipboard:copied', { bubbles: true, detail: { text: copyText } }));
+          setTimeout(function() { feedbackEl.classList.remove('copied'); }, feedbackDuration);
+        } catch(err) {
+          me.dispatchEvent(new CustomEvent('clipboard:error', { bubbles: true, detail: { error: err } }));
+        }
+      })();
     end
   end
 end`.trim(),

package/src/schemas/draggable.schema.ts

@@ -11,7 +11,8 @@ export const draggableSchema: BehaviorSchema = {
   category: 'ui',
   tier: 'core',
   version: '1.0.0',
-  description: 'Makes elements draggable with pointer events',
+  description:
+    'Makes elements draggable with pointer events (EXPERIMENTAL — stateful async component, beyond the inline-scripting boundary; not part of the curated set)',
   parameters: [
     {
       name: 'dragHandle',

package/src/schemas/resizable.schema.ts

@@ -11,7 +11,8 @@ export const resizableSchema: BehaviorSchema = {
   category: 'ui',
   tier: 'optional',
   version: '1.0.0',
-  description: 'Makes elements resizable by dragging',
+  description:
+    'Makes elements resizable by dragging (EXPERIMENTAL — stateful async component, beyond the inline-scripting boundary; not part of the curated set)',
   parameters: [
     {
       name: 'minWidth',
@@ -59,15 +60,15 @@ behavior Resizable(minWidth, minHeight, maxWidth, maxHeight)
     set startX to clientX
     set startY to clientY
     repeat until event pointerup from document
-      wait for pointermove(clientX, clientY) from document
+      wait for pointermove(clientX, clientY) or pointerup(clientX, clientY) from document
       set newWidth to startWidth + clientX - startX
       set newHeight to startHeight + clientY - startY
       if newWidth < minWidth then set newWidth to minWidth end
       if newWidth > maxWidth then set newWidth to maxWidth end
       if newHeight < minHeight then set newHeight to minHeight end
       if newHeight > maxHeight then set newHeight to maxHeight end
-      set my style.width to newWidth + "px"
-      set my style.height to newHeight + "px"
+      set my *width to newWidth + "px"
+      set my *height to newHeight + "px"
       trigger resizable:resize
     end
     trigger resizable:end

package/src/schemas/sortable.schema.ts

@@ -15,7 +15,8 @@ export const sortableSchema: BehaviorSchema = {
   category: 'ui',
   tier: 'common',
   version: '1.0.0',
-  description: 'Makes child elements reorderable via drag-and-drop',
+  description:
+    'Makes child elements reorderable via drag-and-drop (EXPERIMENTAL — stateful async component, beyond the inline-scripting boundary; not part of the curated set)',
   parameters: [
     {
       name: 'dragClass',
@@ -42,7 +43,7 @@ behavior Sortable(dragClass)
     end
   end
   on pointerdown(clientY) from me
-    set item to the closest <li/> to the target
+    set item to the target.closest("li")
     if item is null
       exit
     end
@@ -50,7 +51,7 @@ behavior Sortable(dragClass)
     add .{dragClass} to item
     trigger sortable:start on me
     repeat until event pointerup from document
-      wait for pointermove(clientY) from document
+      wait for pointermove(clientY) or pointerup(clientY) from document
       trigger sortable:move on me
     end
     remove .{dragClass} from item

package/dist/chunk-7O7UOSBH.js

@@ -1,99 +0,0 @@
-import {
-  clipboardSchema
-} from "./chunk-WOTZO7K4.js";
-import {
-  resolveRuntime
-} from "./chunk-6TJXDCAQ.js";
-
-// src/behaviors/clipboard.ts
-var clipboardSource = clipboardSchema.source;
-var clipboardMetadata = clipboardSchema;
-async function copyToClipboard(text) {
-  if (navigator.clipboard?.writeText) {
-    await navigator.clipboard.writeText(text);
-    return;
-  }
-  const textarea = document.createElement("textarea");
-  textarea.value = text;
-  textarea.style.position = "fixed";
-  textarea.style.opacity = "0";
-  document.body.appendChild(textarea);
-  textarea.select();
-  try {
-    document.execCommand("copy");
-  } finally {
-    document.body.removeChild(textarea);
-  }
-}
-function resolveElement(element, param) {
-  if (!param || param === "me") return element;
-  if (param instanceof HTMLElement) return param;
-  if (typeof param === "string") {
-    return element.querySelector(param) || document.querySelector(param) || null;
-  }
-  return null;
-}
-function installClipboard(element, params) {
-  const feedbackDuration = typeof params.feedbackDuration === "number" ? params.feedbackDuration : 2e3;
-  element.addEventListener("click", async () => {
-    let copyText;
-    if (params.text != null) {
-      copyText = String(params.text);
-    } else {
-      const sourceEl = resolveElement(element, params.source) || element;
-      copyText = sourceEl.value ?? sourceEl.textContent ?? "";
-    }
-    try {
-      await copyToClipboard(copyText);
-      const feedbackEl = resolveElement(element, params.feedback) || element;
-      feedbackEl.classList.add("copied");
-      setTimeout(() => feedbackEl.classList.remove("copied"), feedbackDuration);
-      element.dispatchEvent(
-        new CustomEvent("clipboard:copied", {
-          bubbles: true,
-          detail: { text: copyText }
-        })
-      );
-    } catch (error) {
-      element.dispatchEvent(
-        new CustomEvent("clipboard:error", {
-          bubbles: true,
-          detail: { error }
-        })
-      );
-    }
-  });
-}
-async function registerClipboard(hyperfixi) {
-  const hf = hyperfixi || resolveRuntime();
-  if (!hf) {
-    throw new Error(
-      "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
-    );
-  }
-  const syntheticNode = {
-    type: "behavior",
-    name: "Clipboard",
-    parameters: ["text", "source", "feedback", "feedbackDuration"],
-    eventHandlers: [],
-    imperativeInstaller: installClipboard
-  };
-  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
-  await hf.execute(syntheticNode, ctx);
-}
-if (resolveRuntime()) {
-  registerClipboard().catch(console.error);
-}
-var clipboard_default = {
-  source: clipboardSchema.source,
-  metadata: clipboardSchema,
-  register: registerClipboard
-};
-
-export {
-  clipboardSource,
-  clipboardMetadata,
-  registerClipboard,
-  clipboard_default
-};
-//# sourceMappingURL=chunk-7O7UOSBH.js.map