@hyperfixi/behaviors 2.0.0 → 2.2.0

package/dist/index.cjs

@@ -74,6 +74,18 @@ end
   }
 });
 
+// src/schemas/types.ts
+function resolveRuntime() {
+  if (typeof window === "undefined") return null;
+  const win = window;
+  return win.lokascript || win.hyperfixi || null;
+}
+var init_types = __esm({
+  "src/schemas/types.ts"() {
+    "use strict";
+  }
+});
+
 // src/behaviors/draggable.ts
 var draggable_exports = {};
 __export(draggable_exports, {
@@ -82,28 +94,64 @@ __export(draggable_exports, {
   draggableSource: () => draggableSource,
   registerDraggable: () => registerDraggable
 });
+function installDraggable(element, params) {
+  let dragHandle = 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) => {
+    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) {
+      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);
+  });
+}
 async function registerDraggable(hyperfixi) {
-  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  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 syntheticNode = {
+    type: "behavior",
+    name: "Draggable",
+    parameters: ["dragHandle"],
+    eventHandlers: [],
+    imperativeInstaller: installDraggable
+  };
   const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
-  await hf.execute(result.ast, ctx);
+  await hf.execute(syntheticNode, ctx);
 }
 var draggableSource, draggableMetadata, draggable_default;
 var init_draggable = __esm({
   "src/behaviors/draggable.ts"() {
     "use strict";
     init_draggable_schema();
+    init_types();
     draggableSource = draggableSchema.source;
     draggableMetadata = draggableSchema;
-    if (typeof window !== "undefined" && window.lokascript) {
+    if (resolveRuntime()) {
       registerDraggable().catch(console.error);
     }
     draggable_default = {
@@ -188,7 +236,7 @@ __export(removable_exports, {
   removableSource: () => removableSource
 });
 async function registerRemovable(hyperfixi) {
-  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  const hf = hyperfixi || resolveRuntime();
   if (!hf) {
     throw new Error(
       "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
@@ -206,9 +254,10 @@ var init_removable = __esm({
   "src/behaviors/removable.ts"() {
     "use strict";
     init_removable_schema();
+    init_types();
     removableSource = removableSchema.source;
     removableMetadata = removableSchema;
-    if (typeof window !== "undefined" && window.lokascript) {
+    if (resolveRuntime()) {
       registerRemovable().catch(console.error);
     }
     removable_default = {
@@ -277,28 +326,51 @@ __export(toggleable_exports, {
   toggleableMetadata: () => toggleableMetadata,
   toggleableSource: () => toggleableSource
 });
+function installToggleable(element, params) {
+  const cls = params.cls || "active";
+  let targetEl = 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 })
+    );
+  });
+}
 async function registerToggleable(hyperfixi) {
-  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  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 syntheticNode = {
+    type: "behavior",
+    name: "Toggleable",
+    parameters: ["cls", "target"],
+    eventHandlers: [],
+    imperativeInstaller: installToggleable
+  };
   const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
-  await hf.execute(result.ast, ctx);
+  await hf.execute(syntheticNode, ctx);
 }
 var toggleableSource, toggleableMetadata, toggleable_default;
 var init_toggleable = __esm({
   "src/behaviors/toggleable.ts"() {
     "use strict";
     init_toggleable_schema();
+    init_types();
     toggleableSource = toggleableSchema.source;
     toggleableMetadata = toggleableSchema;
-    if (typeof window !== "undefined" && window.lokascript) {
+    if (resolveRuntime()) {
       registerToggleable().catch(console.error);
     }
     toggleable_default = {
@@ -381,28 +453,64 @@ __export(sortable_exports, {
   sortableMetadata: () => sortableMetadata,
   sortableSource: () => sortableSource
 });
+function installSortable(element, params) {
+  const dragClass = params.dragClass || "sorting";
+  const handleSelector = params.handle || null;
+  element.addEventListener("pointerdown", (e) => {
+    const target = e.target;
+    const item = target.closest("li");
+    if (!item || !element.contains(item)) return;
+    if (handleSelector) {
+      const handleEl = target.closest(handleSelector);
+      if (!handleEl) return;
+    }
+    e.preventDefault();
+    item.classList.add(dragClass);
+    element.dispatchEvent(new CustomEvent("sortable:start", { bubbles: true, detail: { item } }));
+    function onMove(ev) {
+      element.dispatchEvent(
+        new CustomEvent("sortable:move", {
+          bubbles: true,
+          detail: { clientY: ev.clientY, item }
+        })
+      );
+    }
+    function onUp() {
+      document.removeEventListener("pointermove", onMove);
+      document.removeEventListener("pointerup", onUp);
+      item.classList.remove(dragClass);
+      element.dispatchEvent(new CustomEvent("sortable:end", { bubbles: true, detail: { item } }));
+    }
+    document.addEventListener("pointermove", onMove);
+    document.addEventListener("pointerup", onUp);
+  });
+}
 async function registerSortable(hyperfixi) {
-  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  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 syntheticNode = {
+    type: "behavior",
+    name: "Sortable",
+    parameters: ["handle", "dragClass"],
+    eventHandlers: [],
+    imperativeInstaller: installSortable
+  };
   const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
-  await hf.execute(result.ast, ctx);
+  await hf.execute(syntheticNode, ctx);
 }
 var sortableSource, sortableMetadata, sortable_default;
 var init_sortable = __esm({
   "src/behaviors/sortable.ts"() {
     "use strict";
     init_sortable_schema();
+    init_types();
     sortableSource = sortableSchema.source;
     sortableMetadata = sortableSchema;
-    if (typeof window !== "undefined" && window.lokascript) {
+    if (resolveRuntime()) {
       registerSortable().catch(console.error);
     }
     sortable_default = {
@@ -512,28 +620,69 @@ __export(resizable_exports, {
   resizableMetadata: () => resizableMetadata,
   resizableSource: () => resizableSource
 });
+function installResizable(element, params) {
+  let handleEl = element;
+  if (params.handle && params.handle !== "me") {
+    if (typeof params.handle === "string") {
+      const found = element.querySelector(params.handle);
+      if (found instanceof HTMLElement) handleEl = found;
+    } else if (params.handle instanceof HTMLElement) {
+      handleEl = params.handle;
+    }
+  }
+  const minW = params.minWidth ?? 50;
+  const minH = params.minHeight ?? 50;
+  const maxW = params.maxWidth ?? 9999;
+  const maxH = params.maxHeight ?? 9999;
+  handleEl.addEventListener("pointerdown", (e) => {
+    e.preventDefault();
+    element.dispatchEvent(new CustomEvent("resizable:start", { bubbles: true }));
+    const startWidth = element.offsetWidth;
+    const startHeight = element.offsetHeight;
+    const startX = e.clientX;
+    const startY = e.clientY;
+    function onMove(ev) {
+      const newWidth = Math.max(minW, Math.min(maxW, startWidth + (ev.clientX - startX)));
+      const newHeight = Math.max(minH, Math.min(maxH, startHeight + (ev.clientY - startY)));
+      element.style.width = `${newWidth}px`;
+      element.style.height = `${newHeight}px`;
+      element.dispatchEvent(new CustomEvent("resizable:resize", { bubbles: true }));
+    }
+    function onUp() {
+      document.removeEventListener("pointermove", onMove);
+      document.removeEventListener("pointerup", onUp);
+      element.dispatchEvent(new CustomEvent("resizable:end", { bubbles: true }));
+    }
+    document.addEventListener("pointermove", onMove);
+    document.addEventListener("pointerup", onUp);
+  });
+}
 async function registerResizable(hyperfixi) {
-  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  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 syntheticNode = {
+    type: "behavior",
+    name: "Resizable",
+    parameters: ["handle", "minWidth", "minHeight", "maxWidth", "maxHeight"],
+    eventHandlers: [],
+    imperativeInstaller: installResizable
+  };
   const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
-  await hf.execute(result.ast, ctx);
+  await hf.execute(syntheticNode, ctx);
 }
 var resizableSource, resizableMetadata, resizable_default;
 var init_resizable = __esm({
   "src/behaviors/resizable.ts"() {
     "use strict";
     init_resizable_schema();
+    init_types();
     resizableSource = resizableSchema.source;
     resizableMetadata = resizableSchema;
-    if (typeof window !== "undefined" && window.lokascript) {
+    if (resolveRuntime()) {
       registerResizable().catch(console.error);
     }
     resizable_default = {
@@ -544,21 +693,989 @@ var init_resizable = __esm({
   }
 });
 
+// src/schemas/clipboard.schema.ts
+var clipboardSchema;
+var init_clipboard_schema = __esm({
+  "src/schemas/clipboard.schema.ts"() {
+    "use strict";
+    clipboardSchema = {
+      name: "Clipboard",
+      category: "ui",
+      tier: "core",
+      version: "1.0.0",
+      description: "Copies text to clipboard on click with visual feedback",
+      parameters: [
+        {
+          name: "text",
+          type: "string",
+          optional: true,
+          description: "Literal text to copy (takes priority over source)"
+        },
+        {
+          name: "source",
+          type: "selector",
+          optional: true,
+          default: "me",
+          description: "Element whose textContent or value is copied"
+        },
+        {
+          name: "feedback",
+          type: "selector",
+          optional: true,
+          description: "Element to show .copied feedback on (defaults to the installed element)"
+        },
+        {
+          name: "feedbackDuration",
+          type: "number",
+          optional: true,
+          default: 2e3,
+          description: "Duration in ms to show .copied class feedback"
+        }
+      ],
+      events: [
+        { name: "clipboard:copied", description: "Fired after text is copied successfully" },
+        { name: "clipboard:error", description: "Fired when clipboard write fails" }
+      ],
+      requirements: [
+        "navigator.clipboard.writeText() requires HTTPS or localhost",
+        'Falls back to document.execCommand("copy") for older browsers'
+      ],
+      source: [
+        "behavior Clipboard(text, source, feedback, feedbackDuration)",
+        "  init",
+        "    if feedbackDuration is undefined set feedbackDuration to 2000",
+        "    if source is undefined set source to me",
+        "  end",
+        "  on click",
+        "    if text is not undefined",
+        "      set copyText to text",
+        "    else",
+        "      set copyText to source's value or source's textContent",
+        "    end",
+        "    js(copyText) navigator.clipboard.writeText(copyText) end",
+        "    set feedbackEl to feedback or me",
+        "    add .copied to feedbackEl",
+        "    wait feedbackDuration ms",
+        "    remove .copied from feedbackEl",
+        "    trigger clipboard:copied",
+        "  end",
+        "end"
+      ].join("\n")
+    };
+  }
+});
+
+// src/behaviors/clipboard.ts
+var clipboard_exports = {};
+__export(clipboard_exports, {
+  clipboardMetadata: () => clipboardMetadata,
+  clipboardSource: () => clipboardSource,
+  default: () => clipboard_default,
+  registerClipboard: () => registerClipboard
+});
+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);
+}
+var clipboardSource, clipboardMetadata, clipboard_default;
+var init_clipboard = __esm({
+  "src/behaviors/clipboard.ts"() {
+    "use strict";
+    init_clipboard_schema();
+    init_types();
+    clipboardSource = clipboardSchema.source;
+    clipboardMetadata = clipboardSchema;
+    if (resolveRuntime()) {
+      registerClipboard().catch(console.error);
+    }
+    clipboard_default = {
+      source: clipboardSchema.source,
+      metadata: clipboardSchema,
+      register: registerClipboard
+    };
+  }
+});
+
+// src/schemas/autodismiss.schema.ts
+var autoDismissSchema;
+var init_autodismiss_schema = __esm({
+  "src/schemas/autodismiss.schema.ts"() {
+    "use strict";
+    autoDismissSchema = {
+      name: "AutoDismiss",
+      category: "ui",
+      tier: "core",
+      version: "1.0.0",
+      description: "Auto-removes elements after a delay with optional pause-on-hover",
+      parameters: [
+        {
+          name: "delay",
+          type: "number",
+          optional: true,
+          default: 5e3,
+          description: "Time in ms before the element is removed"
+        },
+        {
+          name: "pauseOnHover",
+          type: "boolean",
+          optional: true,
+          default: true,
+          description: "Pause the countdown when the mouse hovers over the element"
+        },
+        {
+          name: "effect",
+          type: "string",
+          optional: true,
+          default: "none",
+          enum: ["fade", "none"],
+          description: 'Transition effect before removal: "fade" or "none"'
+        }
+      ],
+      events: [
+        { name: "autodismiss:start", description: "Fired when the countdown timer starts" },
+        {
+          name: "autodismiss:dismissed",
+          description: "Fired before removal (cancelable via preventDefault)"
+        },
+        { name: "autodismiss:paused", description: "Fired when the timer is paused on hover" },
+        { name: "autodismiss:resumed", description: "Fired when the timer resumes on mouseleave" }
+      ],
+      source: [
+        "behavior AutoDismiss(delay, pauseOnHover, effect)",
+        "  init",
+        "    if delay is undefined set delay to 5000",
+        "    if pauseOnHover is undefined set pauseOnHover to true",
+        '    if effect is undefined set effect to "none"',
+        "  end",
+        "  on load",
+        "    trigger autodismiss:start",
+        "    wait delay ms",
+        "    trigger autodismiss:dismissed",
+        '    if effect is "fade"',
+        "      transition opacity to 0 over 300ms",
+        "    end",
+        "    remove me",
+        "  end",
+        "end"
+      ].join("\n")
+    };
+  }
+});
+
+// src/behaviors/autodismiss.ts
+var autodismiss_exports = {};
+__export(autodismiss_exports, {
+  autoDismissMetadata: () => autoDismissMetadata,
+  autoDismissSource: () => autoDismissSource,
+  default: () => autodismiss_default,
+  registerAutoDismiss: () => registerAutoDismiss
+});
+function installAutoDismiss(element, params) {
+  const delay = typeof params.delay === "number" ? params.delay : 5e3;
+  const pauseOnHover = params.pauseOnHover !== false;
+  const effect = params.effect === "fade" ? "fade" : "none";
+  let timerId = null;
+  let remaining = delay;
+  let startedAt = Date.now();
+  function dismiss() {
+    const event = new CustomEvent("autodismiss:dismissed", {
+      bubbles: true,
+      cancelable: true
+    });
+    element.dispatchEvent(event);
+    if (event.defaultPrevented) return;
+    if (effect === "fade") {
+      element.style.transition = "opacity 300ms";
+      element.style.opacity = "0";
+      setTimeout(() => element.remove(), 300);
+    } else {
+      element.remove();
+    }
+  }
+  function start() {
+    startedAt = Date.now();
+    timerId = setTimeout(dismiss, remaining);
+  }
+  element.dispatchEvent(new CustomEvent("autodismiss:start", { bubbles: true }));
+  start();
+  if (pauseOnHover) {
+    element.addEventListener("mouseenter", () => {
+      if (timerId != null) {
+        clearTimeout(timerId);
+        timerId = null;
+        remaining -= Date.now() - startedAt;
+        if (remaining < 0) remaining = 0;
+        element.dispatchEvent(new CustomEvent("autodismiss:paused", { bubbles: true }));
+      }
+    });
+    element.addEventListener("mouseleave", () => {
+      if (timerId == null && element.isConnected) {
+        element.dispatchEvent(new CustomEvent("autodismiss:resumed", { bubbles: true }));
+        start();
+      }
+    });
+  }
+}
+async function registerAutoDismiss(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: "AutoDismiss",
+    parameters: ["delay", "pauseOnHover", "effect"],
+    eventHandlers: [],
+    imperativeInstaller: installAutoDismiss
+  };
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(syntheticNode, ctx);
+}
+var autoDismissSource, autoDismissMetadata, autodismiss_default;
+var init_autodismiss = __esm({
+  "src/behaviors/autodismiss.ts"() {
+    "use strict";
+    init_autodismiss_schema();
+    init_types();
+    autoDismissSource = autoDismissSchema.source;
+    autoDismissMetadata = autoDismissSchema;
+    if (resolveRuntime()) {
+      registerAutoDismiss().catch(console.error);
+    }
+    autodismiss_default = {
+      source: autoDismissSchema.source,
+      metadata: autoDismissSchema,
+      register: registerAutoDismiss
+    };
+  }
+});
+
+// src/schemas/clickoutside.schema.ts
+var clickOutsideSchema;
+var init_clickoutside_schema = __esm({
+  "src/schemas/clickoutside.schema.ts"() {
+    "use strict";
+    clickOutsideSchema = {
+      name: "ClickOutside",
+      category: "ui",
+      tier: "core",
+      version: "1.0.0",
+      description: "Fires an event when the user clicks outside the element",
+      parameters: [
+        {
+          name: "active",
+          type: "boolean",
+          optional: true,
+          default: true,
+          description: "Whether the listener is active (can be toggled programmatically)"
+        }
+      ],
+      events: [
+        { name: "clickoutside", description: "Fired when a pointer press occurs outside the element" }
+      ],
+      requirements: ["Uses pointerdown instead of click to avoid timing issues with removed elements"],
+      source: `
+behavior ClickOutside(active)
+  init
+    if active is undefined set active to true
+  end
+  on pointerdown from document
+    if active and not me.contains(event.target)
+      trigger clickoutside on me
+    end
+  end
+end`.trim()
+    };
+  }
+});
+
+// src/behaviors/clickoutside.ts
+var clickoutside_exports = {};
+__export(clickoutside_exports, {
+  clickOutsideMetadata: () => clickOutsideMetadata,
+  clickOutsideSource: () => clickOutsideSource,
+  default: () => clickoutside_default,
+  registerClickOutside: () => registerClickOutside
+});
+function installClickOutside(element, params) {
+  let active = params.active !== false;
+  function onPointerDown(e) {
+    if (!element.isConnected) {
+      document.removeEventListener("pointerdown", onPointerDown);
+      return;
+    }
+    if (active && !element.contains(e.target)) {
+      element.dispatchEvent(new CustomEvent("clickoutside", { bubbles: true }));
+    }
+  }
+  document.addEventListener("pointerdown", onPointerDown);
+  element.addEventListener("clickoutside:activate", () => {
+    active = true;
+  });
+  element.addEventListener("clickoutside:deactivate", () => {
+    active = false;
+  });
+}
+async function registerClickOutside(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: "ClickOutside",
+    parameters: ["active"],
+    eventHandlers: [],
+    imperativeInstaller: installClickOutside
+  };
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(syntheticNode, ctx);
+}
+var clickOutsideSource, clickOutsideMetadata, clickoutside_default;
+var init_clickoutside = __esm({
+  "src/behaviors/clickoutside.ts"() {
+    "use strict";
+    init_clickoutside_schema();
+    init_types();
+    clickOutsideSource = clickOutsideSchema.source;
+    clickOutsideMetadata = clickOutsideSchema;
+    if (resolveRuntime()) {
+      registerClickOutside().catch(console.error);
+    }
+    clickoutside_default = {
+      source: clickOutsideSchema.source,
+      metadata: clickOutsideSchema,
+      register: registerClickOutside
+    };
+  }
+});
+
+// src/schemas/focustrap.schema.ts
+var focusTrapSchema;
+var init_focustrap_schema = __esm({
+  "src/schemas/focustrap.schema.ts"() {
+    "use strict";
+    focusTrapSchema = {
+      name: "FocusTrap",
+      category: "ui",
+      tier: "core",
+      version: "1.0.0",
+      description: "Confines Tab navigation inside an element with ARIA support",
+      parameters: [
+        {
+          name: "active",
+          type: "boolean",
+          optional: true,
+          default: true,
+          description: "Whether the trap is active on install"
+        },
+        {
+          name: "initialFocus",
+          type: "selector",
+          optional: true,
+          description: "Element to focus when the trap activates"
+        },
+        {
+          name: "returnFocus",
+          type: "boolean",
+          optional: true,
+          default: true,
+          description: "Restore focus to the previously focused element on deactivation"
+        }
+      ],
+      events: [
+        { name: "focustrap:activated", description: "Fired when the trap is activated" },
+        { name: "focustrap:deactivated", description: "Fired when the trap is deactivated" }
+      ],
+      requirements: [
+        'Sets aria-modal="true" on the element when active',
+        "Listens for focustrap:activate and focustrap:deactivate custom events for programmatic control"
+      ],
+      source: `
+behavior FocusTrap(active, initialFocus, returnFocus)
+  init
+    if active is undefined set active to true
+    if returnFocus is undefined set returnFocus to true
+  end
+  -- Imperative installer handles Tab key trapping and focus management
+end`.trim()
+    };
+  }
+});
+
+// src/behaviors/focustrap.ts
+var focustrap_exports = {};
+__export(focustrap_exports, {
+  default: () => focustrap_default,
+  focusTrapMetadata: () => focusTrapMetadata,
+  focusTrapSource: () => focusTrapSource,
+  registerFocusTrap: () => registerFocusTrap
+});
+function resolveElement2(container, param) {
+  if (!param) return null;
+  if (param instanceof HTMLElement) return param;
+  if (typeof param === "string") {
+    return container.querySelector(param) || document.querySelector(param) || null;
+  }
+  return null;
+}
+function installFocusTrap(element, params) {
+  const returnFocus = params.returnFocus !== false;
+  let isActive = false;
+  let previouslyFocused = null;
+  function getFocusableElements() {
+    return Array.from(element.querySelectorAll(FOCUSABLE_SELECTOR));
+  }
+  function onKeyDown(e) {
+    if (!isActive || e.key !== "Tab") return;
+    const focusable = getFocusableElements();
+    if (focusable.length === 0) {
+      e.preventDefault();
+      return;
+    }
+    e.preventDefault();
+    const currentIndex = focusable.indexOf(document.activeElement);
+    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");
+    const initialEl = resolveElement2(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 }));
+  }
+  element.addEventListener("keydown", onKeyDown);
+  element.addEventListener("focustrap:activate", () => activate());
+  element.addEventListener("focustrap:deactivate", () => deactivate());
+  if (params.active !== false) {
+    activate();
+  }
+}
+async function registerFocusTrap(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: "FocusTrap",
+    parameters: ["active", "initialFocus", "returnFocus"],
+    eventHandlers: [],
+    imperativeInstaller: installFocusTrap
+  };
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(syntheticNode, ctx);
+}
+var focusTrapSource, focusTrapMetadata, FOCUSABLE_SELECTOR, focustrap_default;
+var init_focustrap = __esm({
+  "src/behaviors/focustrap.ts"() {
+    "use strict";
+    init_focustrap_schema();
+    init_types();
+    focusTrapSource = focusTrapSchema.source;
+    focusTrapMetadata = focusTrapSchema;
+    FOCUSABLE_SELECTOR = [
+      "a[href]",
+      "button:not(:disabled)",
+      "input:not(:disabled)",
+      "select:not(:disabled)",
+      "textarea:not(:disabled)",
+      '[tabindex]:not([tabindex="-1"])'
+    ].join(", ");
+    if (resolveRuntime()) {
+      registerFocusTrap().catch(console.error);
+    }
+    focustrap_default = {
+      source: focusTrapSchema.source,
+      metadata: focusTrapSchema,
+      register: registerFocusTrap
+    };
+  }
+});
+
+// src/schemas/scrollreveal.schema.ts
+var scrollRevealSchema;
+var init_scrollreveal_schema = __esm({
+  "src/schemas/scrollreveal.schema.ts"() {
+    "use strict";
+    scrollRevealSchema = {
+      name: "ScrollReveal",
+      category: "layout",
+      tier: "common",
+      version: "1.0.0",
+      description: "Adds a class when the element enters the viewport via IntersectionObserver",
+      parameters: [
+        {
+          name: "cls",
+          type: "string",
+          optional: true,
+          default: "revealed",
+          description: "CSS class added when element enters viewport"
+        },
+        {
+          name: "threshold",
+          type: "number",
+          optional: true,
+          default: 0.1,
+          description: "Intersection ratio threshold (0-1) for triggering"
+        },
+        {
+          name: "once",
+          type: "boolean",
+          optional: true,
+          default: true,
+          description: "If true, disconnect observer after first intersection"
+        },
+        {
+          name: "rootMargin",
+          type: "string",
+          optional: true,
+          default: "0px",
+          description: "CSS margin around the viewport for triggering earlier or later"
+        }
+      ],
+      events: [
+        { name: "scrollreveal:enter", description: "Fired when the element enters the viewport" },
+        { name: "scrollreveal:exit", description: "Fired when the element exits the viewport" }
+      ],
+      requirements: ["Uses IntersectionObserver API (supported in all modern browsers)"],
+      source: `
+behavior ScrollReveal(cls, threshold, once, rootMargin)
+  init
+    if cls is undefined set cls to "revealed"
+    if threshold is undefined set threshold to 0.1
+    if once is undefined set once to true
+    if rootMargin is undefined set rootMargin to "0px"
+  end
+  -- Imperative installer handles IntersectionObserver setup
+end`.trim()
+    };
+  }
+});
+
+// src/behaviors/scrollreveal.ts
+var scrollreveal_exports = {};
+__export(scrollreveal_exports, {
+  default: () => scrollreveal_default,
+  registerScrollReveal: () => registerScrollReveal,
+  scrollRevealMetadata: () => scrollRevealMetadata,
+  scrollRevealSource: () => scrollRevealSource
+});
+function installScrollReveal(element, params) {
+  const cls = typeof params.cls === "string" ? params.cls : "revealed";
+  const threshold = typeof params.threshold === "number" ? params.threshold : 0.1;
+  const once = params.once !== false;
+  const rootMargin = typeof params.rootMargin === "string" ? params.rootMargin : "0px";
+  const observer = new IntersectionObserver(
+    (entries) => {
+      for (const entry of entries) {
+        if (entry.isIntersecting) {
+          element.classList.add(cls);
+          element.dispatchEvent(new CustomEvent("scrollreveal:enter", { bubbles: true }));
+          if (once) {
+            observer.disconnect();
+          }
+        } else if (!once) {
+          element.classList.remove(cls);
+          element.dispatchEvent(new CustomEvent("scrollreveal:exit", { bubbles: true }));
+        }
+      }
+    },
+    { threshold, rootMargin }
+  );
+  observer.observe(element);
+}
+async function registerScrollReveal(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: "ScrollReveal",
+    parameters: ["cls", "threshold", "once", "rootMargin"],
+    eventHandlers: [],
+    imperativeInstaller: installScrollReveal
+  };
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(syntheticNode, ctx);
+}
+var scrollRevealSource, scrollRevealMetadata, scrollreveal_default;
+var init_scrollreveal = __esm({
+  "src/behaviors/scrollreveal.ts"() {
+    "use strict";
+    init_scrollreveal_schema();
+    init_types();
+    scrollRevealSource = scrollRevealSchema.source;
+    scrollRevealMetadata = scrollRevealSchema;
+    if (resolveRuntime()) {
+      registerScrollReveal().catch(console.error);
+    }
+    scrollreveal_default = {
+      source: scrollRevealSchema.source,
+      metadata: scrollRevealSchema,
+      register: registerScrollReveal
+    };
+  }
+});
+
+// src/schemas/tabs.schema.ts
+var tabsSchema;
+var init_tabs_schema = __esm({
+  "src/schemas/tabs.schema.ts"() {
+    "use strict";
+    tabsSchema = {
+      name: "Tabs",
+      category: "ui",
+      tier: "core",
+      version: "1.0.0",
+      description: "WAI-ARIA compliant tabs with roving tabindex keyboard navigation. Auto-wires role, aria-selected, aria-controls, and aria-labelledby attributes.",
+      parameters: [
+        {
+          name: "orientation",
+          type: "string",
+          optional: true,
+          default: "horizontal",
+          enum: ["horizontal", "vertical"],
+          description: "Arrow key direction: horizontal (Left/Right) or vertical (Up/Down)"
+        },
+        {
+          name: "activeTab",
+          type: "number",
+          optional: true,
+          default: 0,
+          description: "Initial active tab index (zero-based)"
+        },
+        {
+          name: "wrap",
+          type: "boolean",
+          optional: true,
+          default: true,
+          description: "Wrap to first/last tab when navigating past the end"
+        },
+        {
+          name: "activeClass",
+          type: "string",
+          optional: true,
+          default: "active",
+          description: "CSS class applied to the active tab and its panel"
+        }
+      ],
+      events: [
+        {
+          name: "tabs:change",
+          description: "Fired before tab selection changes (cancelable via preventDefault)"
+        },
+        { name: "tabs:changed", description: "Fired after tab selection has changed" }
+      ],
+      requirements: [
+        'Sets role="tablist" on the tab container',
+        'Sets role="tab" on tab buttons and role="tabpanel" on content panels',
+        "Manages aria-selected, aria-controls, aria-labelledby, and tabindex",
+        "Keyboard: Arrow keys navigate, Home/End jump to first/last, Tab exits tablist"
+      ],
+      source: [
+        "behavior Tabs(orientation, activeTab, wrap, activeClass)",
+        "  init",
+        '    if orientation is undefined set orientation to "horizontal"',
+        "    if activeTab is undefined set activeTab to 0",
+        "    if wrap is undefined set wrap to true",
+        '    if activeClass is undefined set activeClass to "active"',
+        "  end",
+        "  -- Imperative installer handles ARIA wiring and keyboard navigation",
+        "end"
+      ].join("\n")
+    };
+  }
+});
+
+// src/behaviors/tabs.ts
+var tabs_exports = {};
+__export(tabs_exports, {
+  default: () => tabs_default,
+  registerTabs: () => registerTabs,
+  tabsMetadata: () => tabsMetadata,
+  tabsSource: () => tabsSource
+});
+function ensureId(el, prefix) {
+  if (!el.id) {
+    el.id = `${prefix}-${++idCounter}`;
+  }
+  return el.id;
+}
+function installTabs(element, params) {
+  const orientation = params.orientation === "vertical" ? "vertical" : "horizontal";
+  const wrap = params.wrap !== false;
+  const activeClass = params.activeClass || "active";
+  const initialIndex = typeof params.activeTab === "number" ? params.activeTab : 0;
+  const tabs = Array.from(element.querySelectorAll('[role="tab"]'));
+  const panels = Array.from(element.querySelectorAll('[role="tabpanel"]'));
+  if (tabs.length === 0 || panels.length === 0) return;
+  const tablist = element.querySelector('[role="tablist"]') || tabs[0].parentElement;
+  if (tablist && !tablist.getAttribute("role")) {
+    tablist.setAttribute("role", "tablist");
+  }
+  if (tablist) {
+    tablist.setAttribute("aria-orientation", orientation);
+  }
+  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, previousIndex) {
+    if (index === previousIndex || index < 0 || index >= count) return false;
+    const detail = {
+      tab: tabs[index],
+      panel: panels[index],
+      index,
+      previousIndex
+    };
+    const changeEvent = new CustomEvent("tabs:change", {
+      bubbles: true,
+      cancelable: true,
+      detail
+    });
+    element.dispatchEvent(changeEvent);
+    if (changeEvent.defaultPrevented) return false;
+    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);
+    }
+    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;
+  }
+  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));
+  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;
+  for (let i = 0; i < count; i++) {
+    tabs[i].addEventListener("click", () => {
+      selectTab(i, currentIndex);
+      tabs[i].focus();
+    });
+  }
+  const keyTarget = tablist || element;
+  keyTarget.addEventListener("keydown", (e) => {
+    const isHorizontal = orientation === "horizontal";
+    const nextKey = isHorizontal ? "ArrowRight" : "ArrowDown";
+    const prevKey = isHorizontal ? "ArrowLeft" : "ArrowUp";
+    let nextIndex = 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();
+      }
+    }
+  });
+  element.addEventListener("tabs:select", ((e) => {
+    const index = e.detail?.index;
+    if (typeof index === "number") {
+      selectTab(index, currentIndex);
+    }
+  }));
+}
+async function registerTabs(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: "Tabs",
+    parameters: ["orientation", "activeTab", "wrap", "activeClass"],
+    eventHandlers: [],
+    imperativeInstaller: installTabs
+  };
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(syntheticNode, ctx);
+}
+var tabsSource, tabsMetadata, idCounter, tabs_default;
+var init_tabs = __esm({
+  "src/behaviors/tabs.ts"() {
+    "use strict";
+    init_tabs_schema();
+    init_types();
+    tabsSource = tabsSchema.source;
+    tabsMetadata = tabsSchema;
+    idCounter = 0;
+    if (resolveRuntime()) {
+      registerTabs().catch(console.error);
+    }
+    tabs_default = {
+      source: tabsSchema.source,
+      metadata: tabsSchema,
+      register: registerTabs
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   ALL_BEHAVIOR_NAMES: () => ALL_BEHAVIOR_NAMES,
+  AutoDismiss: () => autodismiss_default,
   BEHAVIORS_BY_CATEGORY: () => BEHAVIORS_BY_CATEGORY,
   BEHAVIORS_BY_TIER: () => BEHAVIORS_BY_TIER,
   BEHAVIOR_CATEGORIES: () => BEHAVIOR_CATEGORIES,
   BEHAVIOR_TIERS: () => BEHAVIOR_TIERS,
+  ClickOutside: () => clickoutside_default,
+  Clipboard: () => clipboard_default,
   Draggable: () => draggable_default,
+  FocusTrap: () => focustrap_default,
   Removable: () => removable_default,
   Resizable: () => resizable_default,
+  ScrollReveal: () => scrollreveal_default,
   Sortable: () => sortable_default,
+  Tabs: () => tabs_default,
   Toggleable: () => toggleable_default,
+  autoDismissMetadata: () => autoDismissMetadata,
+  autoDismissSource: () => autoDismissSource,
+  clickOutsideMetadata: () => clickOutsideMetadata,
+  clickOutsideSource: () => clickOutsideSource,
+  clipboardMetadata: () => clipboardMetadata,
+  clipboardSource: () => clipboardSource,
   draggableMetadata: () => draggableMetadata,
   draggableSource: () => draggableSource,
+  focusTrapMetadata: () => focusTrapMetadata,
+  focusTrapSource: () => focusTrapSource,
   getAllSchemas: () => getAllSchemas,
   getAllSchemasRecord: () => getAllSchemasRecord,
   getAvailableBehaviors: () => getAvailableBehaviors,
@@ -576,21 +1693,31 @@ __export(index_exports, {
   ready: () => ready,
   registerAll: () => registerAll,
   registerAllWithRuntime: () => registerAllWithRuntime,
+  registerAutoDismiss: () => registerAutoDismiss,
   registerBehavior: () => registerBehavior,
+  registerClickOutside: () => registerClickOutside,
+  registerClipboard: () => registerClipboard,
   registerDraggable: () => registerDraggable,
+  registerFocusTrap: () => registerFocusTrap,
   registerLoader: () => registerLoader,
   registerRemovable: () => registerRemovable,
   registerResizable: () => registerResizable,
   registerSchema: () => registerSchema,
+  registerScrollReveal: () => registerScrollReveal,
   registerSortable: () => registerSortable,
+  registerTabs: () => registerTabs,
   registerToggleable: () => registerToggleable,
   registerWithRuntime: () => registerWithRuntime,
   removableMetadata: () => removableMetadata,
   removableSource: () => removableSource,
   resizableMetadata: () => resizableMetadata,
   resizableSource: () => resizableSource,
+  scrollRevealMetadata: () => scrollRevealMetadata,
+  scrollRevealSource: () => scrollRevealSource,
   sortableMetadata: () => sortableMetadata,
   sortableSource: () => sortableSource,
+  tabsMetadata: () => tabsMetadata,
+  tabsSource: () => tabsSource,
   toggleableMetadata: () => toggleableMetadata,
   toggleableSource: () => toggleableSource,
   tryGetBehavior: () => tryGetBehavior,
@@ -602,6 +1729,12 @@ init_removable();
 init_toggleable();
 init_sortable();
 init_resizable();
+init_clipboard();
+init_autodismiss();
+init_clickoutside();
+init_focustrap();
+init_scrollreveal();
+init_tabs();
 
 // src/registry.ts
 var behaviors = /* @__PURE__ */ new Map();
@@ -755,16 +1888,34 @@ init_sortable_schema();
 init_resizable_schema();
 init_removable_schema();
 init_toggleable_schema();
+init_clipboard_schema();
+init_autodismiss_schema();
+init_clickoutside_schema();
+init_focustrap_schema();
+init_scrollreveal_schema();
+init_tabs_schema();
 registerSchema(draggableSchema);
 registerSchema(sortableSchema);
 registerSchema(resizableSchema);
 registerSchema(removableSchema);
 registerSchema(toggleableSchema);
+registerSchema(clipboardSchema);
+registerSchema(autoDismissSchema);
+registerSchema(clickOutsideSchema);
+registerSchema(focusTrapSchema);
+registerSchema(scrollRevealSchema);
+registerSchema(tabsSchema);
 registerLoader("Draggable", () => Promise.resolve().then(() => (init_draggable(), draggable_exports)));
 registerLoader("Sortable", () => Promise.resolve().then(() => (init_sortable(), sortable_exports)));
 registerLoader("Resizable", () => Promise.resolve().then(() => (init_resizable(), resizable_exports)));
 registerLoader("Removable", () => Promise.resolve().then(() => (init_removable(), removable_exports)));
 registerLoader("Toggleable", () => Promise.resolve().then(() => (init_toggleable(), toggleable_exports)));
+registerLoader("Clipboard", () => Promise.resolve().then(() => (init_clipboard(), clipboard_exports)));
+registerLoader("AutoDismiss", () => Promise.resolve().then(() => (init_autodismiss(), autodismiss_exports)));
+registerLoader("ClickOutside", () => Promise.resolve().then(() => (init_clickoutside(), clickoutside_exports)));
+registerLoader("FocusTrap", () => Promise.resolve().then(() => (init_focustrap(), focustrap_exports)));
+registerLoader("ScrollReveal", () => Promise.resolve().then(() => (init_scrollreveal(), scrollreveal_exports)));
+registerLoader("Tabs", () => Promise.resolve().then(() => (init_tabs(), tabs_exports)));
 
 // src/generated/metadata.ts
 var ALL_BEHAVIOR_NAMES = [
@@ -772,13 +1923,24 @@ var ALL_BEHAVIOR_NAMES = [
   "Sortable",
   "Resizable",
   "Removable",
-  "Toggleable"
+  "Toggleable",
+  "Clipboard",
+  "AutoDismiss",
+  "ClickOutside",
+  "FocusTrap",
+  "ScrollReveal",
+  "Tabs"
 ];
 var BEHAVIORS_BY_CATEGORY = {
   "ui": [
     "Draggable",
     "Sortable",
-    "Resizable"
+    "Resizable",
+    "Clipboard",
+    "AutoDismiss",
+    "ClickOutside",
+    "FocusTrap",
+    "Tabs"
   ],
   "data": [
     "Removable"
@@ -787,16 +1949,24 @@ var BEHAVIORS_BY_CATEGORY = {
   "form": [
     "Toggleable"
   ],
-  "layout": []
+  "layout": [
+    "ScrollReveal"
+  ]
 };
 var BEHAVIORS_BY_TIER = {
   "core": [
     "Draggable",
-    "Toggleable"
+    "Toggleable",
+    "Clipboard",
+    "AutoDismiss",
+    "ClickOutside",
+    "FocusTrap",
+    "Tabs"
   ],
   "common": [
     "Sortable",
-    "Removable"
+    "Removable",
+    "ScrollReveal"
   ],
   "optional": [
     "Resizable"
@@ -807,14 +1977,26 @@ var BEHAVIOR_CATEGORIES = {
   "Sortable": "ui",
   "Resizable": "ui",
   "Removable": "data",
-  "Toggleable": "form"
+  "Toggleable": "form",
+  "Clipboard": "ui",
+  "AutoDismiss": "ui",
+  "ClickOutside": "ui",
+  "FocusTrap": "ui",
+  "ScrollReveal": "layout",
+  "Tabs": "ui"
 };
 var BEHAVIOR_TIERS = {
   "Draggable": "core",
   "Sortable": "common",
   "Resizable": "optional",
   "Removable": "common",
-  "Toggleable": "core"
+  "Toggleable": "core",
+  "Clipboard": "core",
+  "AutoDismiss": "core",
+  "ClickOutside": "core",
+  "FocusTrap": "core",
+  "ScrollReveal": "common",
+  "Tabs": "core"
 };
 
 // src/index.ts
@@ -823,31 +2005,45 @@ init_removable();
 init_toggleable();
 init_sortable();
 init_resizable();
+init_clipboard();
+init_autodismiss();
+init_clickoutside();
+init_focustrap();
+init_scrollreveal();
+init_tabs();
+init_types();
 async function registerAll(hyperfixi) {
   await Promise.all([
     registerDraggable(hyperfixi),
     registerRemovable(hyperfixi),
     registerToggleable(hyperfixi),
     registerSortable(hyperfixi),
-    registerResizable(hyperfixi)
+    registerResizable(hyperfixi),
+    registerClipboard(hyperfixi),
+    registerAutoDismiss(hyperfixi),
+    registerClickOutside(hyperfixi),
+    registerFocusTrap(hyperfixi),
+    registerScrollReveal(hyperfixi),
+    registerTabs(hyperfixi)
   ]);
 }
 var ready = null;
-if (typeof window !== "undefined" && window.lokascript) {
+var _runtime = resolveRuntime();
+if (_runtime) {
   const lsWin = window;
-  ready = registerAll();
-  lsWin.__lokascript_behaviors_ready = ready;
+  ready = registerAll(_runtime);
+  lsWin.__hyperfixi_behaviors_ready = ready;
   ready.then(() => {
-    const hyperfixi = lsWin.lokascript;
-    const savedPromise = lsWin.__lokascript_behaviors_ready;
-    delete lsWin.__lokascript_behaviors_ready;
-    if (hyperfixi.attributeProcessor?.scanAndProcessAll) {
-      hyperfixi.attributeProcessor.scanAndProcessAll().finally(() => {
-        lsWin.__lokascript_behaviors_ready = savedPromise;
+    const hf = _runtime;
+    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 (hyperfixi.processNode) {
-      hyperfixi.processNode(document);
-      lsWin.__lokascript_behaviors_ready = savedPromise;
+    } else if (hf.processNode) {
+      hf.processNode(document);
+      lsWin.__hyperfixi_behaviors_ready = savedPromise;
     }
   }).catch((err) => {
     console.error("[behaviors] Auto-registration failed:", err);
@@ -856,17 +2052,31 @@ if (typeof window !== "undefined" && window.lokascript) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_BEHAVIOR_NAMES,
+  AutoDismiss,
   BEHAVIORS_BY_CATEGORY,
   BEHAVIORS_BY_TIER,
   BEHAVIOR_CATEGORIES,
   BEHAVIOR_TIERS,
+  ClickOutside,
+  Clipboard,
   Draggable,
+  FocusTrap,
   Removable,
   Resizable,
+  ScrollReveal,
   Sortable,
+  Tabs,
   Toggleable,
+  autoDismissMetadata,
+  autoDismissSource,
+  clickOutsideMetadata,
+  clickOutsideSource,
+  clipboardMetadata,
+  clipboardSource,
   draggableMetadata,
   draggableSource,
+  focusTrapMetadata,
+  focusTrapSource,
   getAllSchemas,
   getAllSchemasRecord,
   getAvailableBehaviors,
@@ -884,21 +2094,31 @@ if (typeof window !== "undefined" && window.lokascript) {
   ready,
   registerAll,
   registerAllWithRuntime,
+  registerAutoDismiss,
   registerBehavior,
+  registerClickOutside,
+  registerClipboard,
   registerDraggable,
+  registerFocusTrap,
   registerLoader,
   registerRemovable,
   registerResizable,
   registerSchema,
+  registerScrollReveal,
   registerSortable,
+  registerTabs,
   registerToggleable,
   registerWithRuntime,
   removableMetadata,
   removableSource,
   resizableMetadata,
   resizableSource,
+  scrollRevealMetadata,
+  scrollRevealSource,
   sortableMetadata,
   sortableSource,
+  tabsMetadata,
+  tabsSource,
   toggleableMetadata,
   toggleableSource,
   tryGetBehavior,