@hapticjs/core 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -58,9 +58,9 @@ var WebVibrationAdapter = class {
     if (!this.supported || steps.length === 0) return;
     const pattern = [];
     let lastType = null;
-    for (const step of steps) {
-      if (step.type === "vibrate" && step.intensity > 0.05) {
-        const dur = Math.max(step.duration, 20);
+    for (const step2 of steps) {
+      if (step2.type === "vibrate" && step2.intensity > 0.05) {
+        const dur = Math.max(step2.duration, 20);
         if (lastType === "vibrate") {
           pattern[pattern.length - 1] += dur;
         } else {
@@ -68,7 +68,7 @@ var WebVibrationAdapter = class {
         }
         lastType = "vibrate";
       } else {
-        const dur = Math.max(step.duration, 10);
+        const dur = Math.max(step2.duration, 10);
         if (lastType === "pause") {
           pattern[pattern.length - 1] += dur;
         } else {
@@ -132,12 +132,12 @@ var IoSAudioAdapter = class {
   async playSequence(steps) {
     if (!this.supported || steps.length === 0) return;
     this._cancelled = false;
-    for (const step of steps) {
+    for (const step2 of steps) {
       if (this._cancelled) break;
-      if (step.type === "vibrate" && step.intensity > 0) {
-        await this._playTone(step.intensity, step.duration);
+      if (step2.type === "vibrate" && step2.intensity > 0) {
+        await this._playTone(step2.intensity, step2.duration);
       } else {
-        await delay(step.duration);
+        await delay(step2.duration);
       }
     }
   }
@@ -264,10 +264,10 @@ function detectAdapter() {
 // src/engine/adaptive-engine.ts
 var AdaptiveEngine = class {
   adapt(steps, capabilities) {
-    return steps.map((step) => this._adaptStep(step, capabilities));
+    return steps.map((step2) => this._adaptStep(step2, capabilities));
   }
-  _adaptStep(step, caps) {
-    const adapted = { ...step };
+  _adaptStep(step2, caps) {
+    const adapted = { ...step2 };
     if (adapted.type === "vibrate") {
       adapted.duration = clamp(adapted.duration, caps.minDuration, caps.maxDuration);
     }
@@ -659,12 +659,12 @@ function compileNode(node) {
 }
 function mergeSustains(steps) {
   const result = [];
-  for (const step of steps) {
-    if (step.intensity === -1 && result.length > 0) {
+  for (const step2 of steps) {
+    if (step2.intensity === -1 && result.length > 0) {
       const prev = result[result.length - 1];
-      prev.duration += step.duration;
+      prev.duration += step2.duration;
     } else {
-      result.push({ ...step });
+      result.push({ ...step2 });
     }
   }
   return result;
@@ -845,6 +845,777 @@ var HapticEngine = class _HapticEngine {
   }
 };
 
+// src/sound/sound-engine.ts
+var NOTE_FREQUENCIES = {
+  C4: 261.63,
+  E4: 329.63,
+  G4: 392,
+  C5: 523.25
+};
+var SoundEngine = class {
+  constructor(options) {
+    this.ctx = null;
+    this._enabled = options?.enabled ?? true;
+    this.masterVolume = options?.volume ?? 0.5;
+    this._muted = options?.muted ?? false;
+  }
+  // ─── Public API ──────────────────────────────────────────
+  /** Short click sound */
+  async click(options) {
+    const pitchMap = { low: 800, mid: 1200, high: 2e3 };
+    const freq = pitchMap[options?.pitch ?? "mid"];
+    const vol = options?.volume ?? 0.3;
+    await this.playTone(freq, 4, { waveform: "sine", volume: vol, decay: true });
+  }
+  /** Ultra-short tick sound */
+  async tick() {
+    await this.playTone(4e3, 2, { waveform: "sine", volume: 0.15, decay: true });
+  }
+  /** Bubbly pop sound — quick frequency sweep high to low */
+  async pop() {
+    const ctx = this._getContext();
+    if (!ctx) return;
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+    const now = ctx.currentTime;
+    const vol = this._effectiveVolume(0.25);
+    osc.type = "sine";
+    osc.frequency.setValueAtTime(1600, now);
+    osc.frequency.exponentialRampToValueAtTime(300, now + 0.04);
+    gain.gain.setValueAtTime(vol, now);
+    gain.gain.exponentialRampToValueAtTime(1e-3, now + 0.06);
+    osc.start(now);
+    osc.stop(now + 0.06);
+  }
+  /** Swipe/swoosh sound — noise with quick fade */
+  async whoosh() {
+    const ctx = this._getContext();
+    if (!ctx) return;
+    const bufferSize = ctx.sampleRate * 0.08;
+    const buffer = ctx.createBuffer(1, bufferSize, ctx.sampleRate);
+    const data = buffer.getChannelData(0);
+    for (let i = 0; i < bufferSize; i++) {
+      data[i] = (Math.random() * 2 - 1) * (1 - i / bufferSize);
+    }
+    const source = ctx.createBufferSource();
+    const gain = ctx.createGain();
+    const filter = ctx.createBiquadFilter();
+    source.buffer = buffer;
+    filter.type = "bandpass";
+    filter.frequency.value = 2e3;
+    filter.Q.value = 0.5;
+    source.connect(filter);
+    filter.connect(gain);
+    gain.connect(ctx.destination);
+    const now = ctx.currentTime;
+    const vol = this._effectiveVolume(0.2);
+    gain.gain.setValueAtTime(vol, now);
+    gain.gain.exponentialRampToValueAtTime(1e-3, now + 0.08);
+    source.start(now);
+  }
+  /** Musical chime */
+  async chime(note = "C5") {
+    const freq = NOTE_FREQUENCIES[note] ?? 523;
+    await this.playTone(freq, 100, { waveform: "sine", volume: 0.2, decay: true });
+  }
+  /** Low buzzer/error tone — two descending tones */
+  async error() {
+    const ctx = this._getContext();
+    if (!ctx) return;
+    const now = ctx.currentTime;
+    this._scheduleTone(ctx, 400, now, 0.08, "square", 0.15);
+    this._scheduleTone(ctx, 280, now + 0.1, 0.1, "square", 0.15);
+  }
+  /** Ascending two-tone success sound */
+  async success() {
+    const ctx = this._getContext();
+    if (!ctx) return;
+    const now = ctx.currentTime;
+    this._scheduleTone(ctx, 880, now, 0.06, "sine", 0.15);
+    this._scheduleTone(ctx, 1320, now + 0.08, 0.08, "sine", 0.15);
+  }
+  /** Subtle tap sound */
+  async tap() {
+    await this.playTone(1e3, 3, { waveform: "sine", volume: 0.2, decay: true });
+  }
+  /** Toggle sound — ascending for on, descending for off */
+  async toggle(on) {
+    const ctx = this._getContext();
+    if (!ctx) return;
+    const now = ctx.currentTime;
+    if (on) {
+      this._scheduleTone(ctx, 600, now, 0.04, "sine", 0.15);
+      this._scheduleTone(ctx, 900, now + 0.06, 0.04, "sine", 0.15);
+    } else {
+      this._scheduleTone(ctx, 900, now, 0.04, "sine", 0.15);
+      this._scheduleTone(ctx, 600, now + 0.06, 0.04, "sine", 0.15);
+    }
+  }
+  /** Generic tone player */
+  async playTone(frequency, duration, options) {
+    const ctx = this._getContext();
+    if (!ctx) return;
+    const waveform = options?.waveform ?? "sine";
+    const vol = this._effectiveVolume(options?.volume ?? 0.3);
+    const decay = options?.decay ?? false;
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+    osc.type = waveform;
+    osc.frequency.value = frequency;
+    const now = ctx.currentTime;
+    const durSec = duration / 1e3;
+    gain.gain.setValueAtTime(vol, now);
+    if (decay) {
+      gain.gain.exponentialRampToValueAtTime(1e-3, now + durSec);
+    }
+    osc.start(now);
+    osc.stop(now + durSec);
+  }
+  /** Set master volume (0-1) */
+  setVolume(volume) {
+    this.masterVolume = Math.max(0, Math.min(1, volume));
+  }
+  /** Mute all sounds */
+  mute() {
+    this._muted = true;
+  }
+  /** Unmute sounds */
+  unmute() {
+    this._muted = false;
+  }
+  /** Whether sounds are currently muted */
+  get muted() {
+    return this._muted;
+  }
+  /** Current master volume */
+  get volume() {
+    return this.masterVolume;
+  }
+  /** Whether the engine is enabled */
+  get enabled() {
+    return this._enabled;
+  }
+  /** Close AudioContext and release resources */
+  dispose() {
+    if (this.ctx) {
+      this.ctx.close().catch(() => {
+      });
+      this.ctx = null;
+    }
+  }
+  // ─── Internal ──────────────────────────────────────────────
+  /** Lazily create and return AudioContext, handling autoplay policy */
+  _getContext() {
+    if (!this._enabled || this._muted) return null;
+    if (typeof AudioContext === "undefined") return null;
+    if (!this.ctx) {
+      this.ctx = new AudioContext();
+    }
+    if (this.ctx.state === "suspended") {
+      this.ctx.resume().catch(() => {
+      });
+    }
+    return this.ctx;
+  }
+  /** Compute effective volume from master + per-sound volume */
+  _effectiveVolume(soundVolume) {
+    return this.masterVolume * soundVolume;
+  }
+  /** Schedule a tone at a specific AudioContext time */
+  _scheduleTone(ctx, frequency, startTime, durationSec, waveform, volume) {
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+    osc.type = waveform;
+    osc.frequency.value = frequency;
+    const vol = this._effectiveVolume(volume);
+    gain.gain.setValueAtTime(vol, startTime);
+    gain.gain.exponentialRampToValueAtTime(1e-3, startTime + durationSec);
+    osc.start(startTime);
+    osc.stop(startTime + durationSec);
+  }
+};
+
+// src/visual/visual-engine.ts
+var STYLE_ID = "__hapticjs_visual_keyframes__";
+var VisualEngine = class {
+  constructor(options) {
+    this._styleInjected = false;
+    this._cleanups = [];
+    this._enabled = options?.enabled ?? true;
+    this._target = options?.target ?? null;
+    this._intensity = options?.intensity ?? 1;
+  }
+  // ─── Public API ──────────────────────────────────────────
+  /** Quick screen flash overlay */
+  flash(options) {
+    if (!this._canRun()) return;
+    const color = options?.color ?? "white";
+    const duration = options?.duration ?? 100;
+    const opacity = options?.opacity ?? 0.15;
+    const overlay = document.createElement("div");
+    Object.assign(overlay.style, {
+      position: "fixed",
+      inset: "0",
+      backgroundColor: color,
+      opacity: String(opacity * this._intensity),
+      pointerEvents: "none",
+      zIndex: "99999",
+      transition: `opacity ${duration}ms ease-out`
+    });
+    document.body.appendChild(overlay);
+    requestAnimationFrame(() => {
+      overlay.style.opacity = "0";
+    });
+    const timer = setTimeout(() => {
+      overlay.remove();
+      this._removeCleanup(cleanup);
+    }, duration + 50);
+    const cleanup = () => {
+      clearTimeout(timer);
+      overlay.remove();
+    };
+    this._cleanups.push(cleanup);
+  }
+  /** CSS shake animation on target */
+  shake(options) {
+    if (!this._canRun()) return;
+    this._injectStyles();
+    const target = this._getTarget();
+    const intensity = (options?.intensity ?? 3) * this._intensity;
+    const duration = options?.duration ?? 200;
+    const magnitude = Math.round(intensity);
+    const name = `hapticjs-shake-${magnitude}`;
+    this._ensureKeyframes(
+      name,
+      `0%,100%{transform:translateX(0)}10%,30%,50%,70%,90%{transform:translateX(-${magnitude}px)}20%,40%,60%,80%{transform:translateX(${magnitude}px)}`
+    );
+    this._applyAnimation(target, name, duration);
+  }
+  /** Scale pulse animation */
+  pulse(options) {
+    if (!this._canRun()) return;
+    this._injectStyles();
+    const target = this._getTarget();
+    const scale = options?.scale ?? 1.02;
+    const duration = options?.duration ?? 150;
+    const adjusted = 1 + (scale - 1) * this._intensity;
+    const name = `hapticjs-pulse-${Math.round(adjusted * 1e3)}`;
+    this._ensureKeyframes(
+      name,
+      `0%,100%{transform:scale(1)}50%{transform:scale(${adjusted})}`
+    );
+    this._applyAnimation(target, name, duration);
+  }
+  /** Material Design style ripple at coordinates */
+  ripple(x, y, options) {
+    if (!this._canRun()) return;
+    this._injectStyles();
+    const color = options?.color ?? "rgba(255,255,255,0.4)";
+    const size = options?.size ?? 100;
+    const duration = options?.duration ?? 400;
+    this._ensureKeyframes(
+      "hapticjs-ripple",
+      `0%{transform:scale(0);opacity:1}100%{transform:scale(4);opacity:0}`
+    );
+    const el = document.createElement("div");
+    const half = size / 2;
+    Object.assign(el.style, {
+      position: "fixed",
+      left: `${x - half}px`,
+      top: `${y - half}px`,
+      width: `${size}px`,
+      height: `${size}px`,
+      borderRadius: "50%",
+      backgroundColor: color,
+      pointerEvents: "none",
+      zIndex: "99999",
+      animation: `hapticjs-ripple ${duration}ms ease-out forwards`
+    });
+    document.body.appendChild(el);
+    const timer = setTimeout(() => {
+      el.remove();
+      this._removeCleanup(cleanup);
+    }, duration + 50);
+    const cleanup = () => {
+      clearTimeout(timer);
+      el.remove();
+    };
+    this._cleanups.push(cleanup);
+  }
+  /** Box shadow glow effect */
+  glow(options) {
+    if (!this._canRun()) return;
+    const target = this._getTarget();
+    const color = options?.color ?? "rgba(59,130,246,0.5)";
+    const duration = options?.duration ?? 300;
+    const size = (options?.size ?? 15) * this._intensity;
+    const prev = target.style.boxShadow;
+    const prevTransition = target.style.transition;
+    target.style.transition = `box-shadow ${duration / 2}ms ease-in-out`;
+    target.style.boxShadow = `0 0 ${size}px ${color}`;
+    const timer = setTimeout(() => {
+      target.style.boxShadow = prev;
+      setTimeout(() => {
+        target.style.transition = prevTransition;
+        this._removeCleanup(cleanup);
+      }, duration / 2);
+    }, duration / 2);
+    const cleanup = () => {
+      clearTimeout(timer);
+      target.style.boxShadow = prev;
+      target.style.transition = prevTransition;
+    };
+    this._cleanups.push(cleanup);
+  }
+  /** Bounce animation on target */
+  bounce(options) {
+    if (!this._canRun()) return;
+    this._injectStyles();
+    const target = this._getTarget();
+    const height = (options?.height ?? 8) * this._intensity;
+    const duration = options?.duration ?? 300;
+    const name = `hapticjs-bounce-${Math.round(height)}`;
+    this._ensureKeyframes(
+      name,
+      `0%,100%{transform:translateY(0)}40%{transform:translateY(-${height}px)}60%{transform:translateY(-${Math.round(height * 0.4)}px)}`
+    );
+    this._applyAnimation(target, name, duration);
+  }
+  /** Jello/wobble animation */
+  jello(options) {
+    if (!this._canRun()) return;
+    this._injectStyles();
+    const target = this._getTarget();
+    const intensity = (options?.intensity ?? 5) * this._intensity;
+    const duration = options?.duration ?? 400;
+    const skew = intensity;
+    const name = `hapticjs-jello-${Math.round(skew)}`;
+    this._ensureKeyframes(
+      name,
+      `0%,100%{transform:skew(0)}20%{transform:skew(-${skew}deg)}40%{transform:skew(${skew * 0.6}deg)}60%{transform:skew(-${skew * 0.3}deg)}80%{transform:skew(${skew * 0.1}deg)}`
+    );
+    this._applyAnimation(target, name, duration);
+  }
+  /** Rubber band scale effect */
+  rubber(options) {
+    if (!this._canRun()) return;
+    this._injectStyles();
+    const target = this._getTarget();
+    const scaleX = options?.scaleX ?? 1.15;
+    const scaleY = options?.scaleY ?? 0.85;
+    const duration = options?.duration ?? 300;
+    const name = `hapticjs-rubber-${Math.round(scaleX * 100)}-${Math.round(scaleY * 100)}`;
+    this._ensureKeyframes(
+      name,
+      `0%,100%{transform:scale(1,1)}30%{transform:scale(${scaleX},${scaleY})}60%{transform:scale(${2 - scaleX},${2 - scaleY})}`
+    );
+    this._applyAnimation(target, name, duration);
+  }
+  /** Brief background color highlight */
+  highlight(options) {
+    if (!this._canRun()) return;
+    const target = this._getTarget();
+    const color = options?.color ?? "rgba(255,255,0,0.2)";
+    const duration = options?.duration ?? 300;
+    const prev = target.style.backgroundColor;
+    const prevTransition = target.style.transition;
+    target.style.transition = `background-color ${duration / 2}ms ease-in-out`;
+    target.style.backgroundColor = color;
+    const timer = setTimeout(() => {
+      target.style.backgroundColor = prev;
+      setTimeout(() => {
+        target.style.transition = prevTransition;
+        this._removeCleanup(cleanup);
+      }, duration / 2);
+    }, duration / 2);
+    const cleanup = () => {
+      clearTimeout(timer);
+      target.style.backgroundColor = prev;
+      target.style.transition = prevTransition;
+    };
+    this._cleanups.push(cleanup);
+  }
+  /** Change the target element for animations */
+  setTarget(element) {
+    this._target = element;
+  }
+  /** Whether the engine is enabled */
+  get enabled() {
+    return this._enabled;
+  }
+  /** Current intensity multiplier */
+  get intensity() {
+    return this._intensity;
+  }
+  /** Remove all active animations and clean up */
+  dispose() {
+    for (const cleanup of this._cleanups) {
+      cleanup();
+    }
+    this._cleanups = [];
+  }
+  // ─── Internal ──────────────────────────────────────────────
+  _canRun() {
+    return this._enabled && typeof document !== "undefined";
+  }
+  _getTarget() {
+    return this._target ?? document.body;
+  }
+  /** Inject a <style> tag for keyframes on first use */
+  _injectStyles() {
+    if (this._styleInjected) return;
+    if (typeof document === "undefined") return;
+    if (!document.getElementById(STYLE_ID)) {
+      const style = document.createElement("style");
+      style.id = STYLE_ID;
+      style.textContent = "";
+      document.head.appendChild(style);
+    }
+    this._styleInjected = true;
+  }
+  /** Ensure a @keyframes rule exists in our style tag */
+  _ensureKeyframes(name, frames) {
+    const style = document.getElementById(STYLE_ID);
+    if (!style) return;
+    if (style.textContent?.includes(`@keyframes ${name}`)) return;
+    style.textContent += `@keyframes ${name}{${frames}}`;
+  }
+  /** Apply a CSS animation to an element and clean up after */
+  _applyAnimation(target, animationName, duration) {
+    const prev = target.style.animation;
+    target.style.animation = `${animationName} ${duration}ms ease-in-out`;
+    const timer = setTimeout(() => {
+      target.style.animation = prev;
+      this._removeCleanup(cleanup);
+    }, duration + 50);
+    const cleanup = () => {
+      clearTimeout(timer);
+      target.style.animation = prev;
+    };
+    this._cleanups.push(cleanup);
+  }
+  _removeCleanup(fn) {
+    const idx = this._cleanups.indexOf(fn);
+    if (idx !== -1) this._cleanups.splice(idx, 1);
+  }
+};
+
+// src/themes/theme-manager.ts
+var themes = {
+  default: {
+    name: "default",
+    hapticIntensity: 0.7,
+    soundEnabled: true,
+    soundVolume: 0.3,
+    visualEnabled: true,
+    visualStyle: "flash",
+    colors: {
+      primary: "#3b82f6",
+      success: "#22c55e",
+      error: "#ef4444",
+      warning: "#eab308"
+    }
+  },
+  gaming: {
+    name: "gaming",
+    hapticIntensity: 1,
+    soundEnabled: true,
+    soundVolume: 0.8,
+    visualEnabled: true,
+    visualStyle: "shake",
+    colors: {
+      primary: "#a855f7",
+      success: "#00ff88",
+      error: "#ff2222",
+      warning: "#ff8800"
+    }
+  },
+  minimal: {
+    name: "minimal",
+    hapticIntensity: 0.4,
+    soundEnabled: false,
+    soundVolume: 0,
+    visualEnabled: true,
+    visualStyle: "pulse",
+    colors: {
+      primary: "#6b7280",
+      success: "#9ca3af",
+      error: "#4b5563",
+      warning: "#d1d5db"
+    }
+  },
+  luxury: {
+    name: "luxury",
+    hapticIntensity: 0.6,
+    soundEnabled: true,
+    soundVolume: 0.25,
+    visualEnabled: true,
+    visualStyle: "glow",
+    colors: {
+      primary: "#d4af37",
+      success: "#50c878",
+      error: "#8b0000",
+      warning: "#cd853f"
+    }
+  },
+  retro: {
+    name: "retro",
+    hapticIntensity: 0.9,
+    soundEnabled: true,
+    soundVolume: 0.5,
+    visualEnabled: true,
+    visualStyle: "flash",
+    colors: {
+      primary: "#00ff00",
+      success: "#00ffff",
+      error: "#ff0000",
+      warning: "#ffff00"
+    }
+  },
+  nature: {
+    name: "nature",
+    hapticIntensity: 0.5,
+    soundEnabled: true,
+    soundVolume: 0.2,
+    visualEnabled: true,
+    visualStyle: "pulse",
+    colors: {
+      primary: "#2d6a4f",
+      success: "#40916c",
+      error: "#9b2226",
+      warning: "#ee9b00"
+    }
+  },
+  silent: {
+    name: "silent",
+    hapticIntensity: 0.7,
+    soundEnabled: false,
+    soundVolume: 0,
+    visualEnabled: false,
+    visualStyle: "flash",
+    colors: {
+      primary: "#3b82f6",
+      success: "#22c55e",
+      error: "#ef4444",
+      warning: "#eab308"
+    }
+  },
+  accessible: {
+    name: "accessible",
+    hapticIntensity: 1,
+    soundEnabled: true,
+    soundVolume: 0.6,
+    visualEnabled: true,
+    visualStyle: "flash",
+    colors: {
+      primary: "#0000ff",
+      success: "#008000",
+      error: "#ff0000",
+      warning: "#ff8c00"
+    }
+  }
+};
+var ThemeManager = class {
+  constructor() {
+    this._registry = new Map(Object.entries(themes));
+    this._current = themes.default;
+  }
+  /** Apply a theme by name or provide a custom preset */
+  setTheme(name) {
+    if (typeof name === "string") {
+      const preset = this._registry.get(name);
+      if (!preset) {
+        throw new Error(`Unknown theme: "${name}". Available: ${this.listThemes().join(", ")}`);
+      }
+      this._current = preset;
+    } else {
+      this._registry.set(name.name, name);
+      this._current = name;
+    }
+  }
+  /** Get the current theme preset */
+  getTheme() {
+    return this._current;
+  }
+  /** Current theme name */
+  get current() {
+    return this._current.name;
+  }
+  /** List all available theme names */
+  listThemes() {
+    return Array.from(this._registry.keys());
+  }
+  /** Register a custom theme preset */
+  registerTheme(preset) {
+    this._registry.set(preset.name, preset);
+  }
+};
+
+// src/engine/sensory-engine.ts
+var SensoryEngine = class _SensoryEngine {
+  constructor(options) {
+    this._haptic = new HapticEngine(options?.haptic);
+    this._sound = new SoundEngine(options?.sound);
+    this._visual = new VisualEngine(options?.visual);
+    this._themes = new ThemeManager();
+    if (options?.theme) {
+      this.setTheme(options.theme);
+    }
+  }
+  /** Factory method */
+  static create(options) {
+    return new _SensoryEngine(options);
+  }
+  // ─── Multi-sensory API ─────────────────────────────────────
+  /** Tap: vibrate + click sound + pulse visual */
+  async tap() {
+    const theme = this._themes.getTheme();
+    await Promise.all([
+      this._haptic.tap(),
+      theme.soundEnabled ? this._sound.click({ pitch: "mid" }) : Promise.resolve(),
+      theme.visualEnabled ? this._runVisual(theme, "tap") : Promise.resolve()
+    ]);
+  }
+  /** Success: haptic success + success sound + green glow */
+  async success() {
+    const theme = this._themes.getTheme();
+    await Promise.all([
+      this._haptic.success(),
+      theme.soundEnabled ? this._sound.success() : Promise.resolve(),
+      theme.visualEnabled ? this._visual.glow({ color: theme.colors.success, duration: 300 }) : Promise.resolve()
+    ]);
+  }
+  /** Error: haptic error + error sound + red flash */
+  async error() {
+    const theme = this._themes.getTheme();
+    await Promise.all([
+      this._haptic.error(),
+      theme.soundEnabled ? this._sound.error() : Promise.resolve(),
+      theme.visualEnabled ? this._visual.flash({ color: theme.colors.error, duration: 150, opacity: 0.2 }) : Promise.resolve()
+    ]);
+  }
+  /** Warning: haptic warning + warning sound + yellow flash */
+  async warning() {
+    const theme = this._themes.getTheme();
+    await Promise.all([
+      this._haptic.warning(),
+      theme.soundEnabled ? this._sound.chime("E4") : Promise.resolve(),
+      theme.visualEnabled ? this._visual.flash({ color: theme.colors.warning, duration: 150, opacity: 0.2 }) : Promise.resolve()
+    ]);
+  }
+  /** Selection: haptic selection + tick sound + subtle pulse */
+  async selection() {
+    const theme = this._themes.getTheme();
+    await Promise.all([
+      this._haptic.selection(),
+      theme.soundEnabled ? this._sound.tick() : Promise.resolve(),
+      theme.visualEnabled ? this._visual.pulse({ scale: 1.01, duration: 100 }) : Promise.resolve()
+    ]);
+  }
+  /** Toggle: haptic toggle + toggle sound + pulse */
+  async toggle(on) {
+    const theme = this._themes.getTheme();
+    await Promise.all([
+      this._haptic.toggle(on),
+      theme.soundEnabled ? this._sound.toggle(on) : Promise.resolve(),
+      theme.visualEnabled ? this._visual.pulse({ scale: on ? 1.03 : 0.98, duration: 150 }) : Promise.resolve()
+    ]);
+  }
+  /** Play a haptic pattern (sound/visual auto-mapped from theme) */
+  async play(pattern) {
+    const theme = this._themes.getTheme();
+    await Promise.all([
+      this._haptic.play(pattern),
+      theme.soundEnabled ? this._sound.tap() : Promise.resolve(),
+      theme.visualEnabled ? this._runVisual(theme, "play") : Promise.resolve()
+    ]);
+  }
+  // ─── Theme ─────────────────────────────────────────────────
+  /** Apply a theme by name or preset */
+  setTheme(name) {
+    this._themes.setTheme(name);
+    const theme = this._themes.getTheme();
+    this._haptic.configure({ intensity: theme.hapticIntensity });
+    this._sound.setVolume(theme.soundVolume);
+    if (!theme.soundEnabled) {
+      this._sound.mute();
+    } else {
+      this._sound.unmute();
+    }
+  }
+  // ─── Accessors ─────────────────────────────────────────────
+  /** Access the underlying HapticEngine */
+  get haptic() {
+    return this._haptic;
+  }
+  /** Access the SoundEngine */
+  get sound() {
+    return this._sound;
+  }
+  /** Access the VisualEngine */
+  get visual() {
+    return this._visual;
+  }
+  /** Access the ThemeManager */
+  get themes() {
+    return this._themes;
+  }
+  // ─── Configuration ─────────────────────────────────────────
+  /** Configure all engines */
+  configure(options) {
+    if (options.haptic) {
+      this._haptic.configure(options.haptic);
+    }
+    if (options.sound) {
+      this._sound = new SoundEngine(options.sound);
+    }
+    if (options.visual) {
+      this._visual = new VisualEngine(options.visual);
+    }
+    if (options.theme) {
+      this.setTheme(options.theme);
+    }
+  }
+  // ─── Lifecycle ─────────────────────────────────────────────
+  /** Clean up all engines */
+  dispose() {
+    this._haptic.dispose();
+    this._sound.dispose();
+    this._visual.dispose();
+  }
+  // ─── Internal ──────────────────────────────────────────────
+  /** Run the appropriate visual effect based on theme style */
+  _runVisual(theme, context) {
+    switch (theme.visualStyle) {
+      case "flash":
+        this._visual.flash({ color: theme.colors.primary });
+        break;
+      case "ripple":
+        if (typeof window !== "undefined") {
+          this._visual.ripple(window.innerWidth / 2, window.innerHeight / 2, {
+            color: theme.colors.primary
+          });
+        }
+        break;
+      case "shake":
+        this._visual.shake({ intensity: context === "play" ? 5 : 3 });
+        break;
+      case "glow":
+        this._visual.glow({ color: theme.colors.primary });
+        break;
+      case "pulse":
+        this._visual.pulse();
+        break;
+    }
+  }
+};
+
 // src/patterns/validator.ts
 var VALID_CHARS = new Set("~#@.|\\-[] 	\nx0123456789");
 function validateHPL(input) {
@@ -944,18 +1715,18 @@ function validateExport(data) {
     throw new Error('Invalid pattern data: "steps" must be an array');
   }
   for (let i = 0; i < obj.steps.length; i++) {
-    const step = obj.steps[i];
-    if (step.type !== "vibrate" && step.type !== "pause") {
+    const step2 = obj.steps[i];
+    if (step2.type !== "vibrate" && step2.type !== "pause") {
       throw new Error(
         `Invalid step at index ${i}: "type" must be "vibrate" or "pause"`
       );
     }
-    if (typeof step.duration !== "number" || step.duration < 0) {
+    if (typeof step2.duration !== "number" || step2.duration < 0) {
       throw new Error(
         `Invalid step at index ${i}: "duration" must be a non-negative number`
       );
     }
-    if (typeof step.intensity !== "number" || step.intensity < 0 || step.intensity > 1) {
+    if (typeof step2.intensity !== "number" || step2.intensity < 0 || step2.intensity > 1) {
       throw new Error(
         `Invalid step at index ${i}: "intensity" must be a number between 0 and 1`
       );
@@ -998,6 +1769,138 @@ function patternFromDataURL(url) {
   return patternFromJSON(json);
 }
 
+// src/recorder/pattern-recorder.ts
+var DEFAULT_TAP_DURATION = 10;
+var DEFAULT_GRID_MS = 50;
+var DEFAULT_INTENSITY = 0.6;
+var PatternRecorder = class {
+  constructor(options) {
+    this.taps = [];
+    this.recording = false;
+    this.startTime = 0;
+    this.stopTime = 0;
+    this.tapCallbacks = [];
+    this.nowFn = options?.now ?? (() => Date.now());
+  }
+  /** Whether the recorder is currently recording */
+  get isRecording() {
+    return this.recording;
+  }
+  /** Total duration of the recording in ms */
+  get duration() {
+    if (this.taps.length === 0) return 0;
+    if (this.recording) {
+      return this.nowFn() - this.startTime;
+    }
+    return this.stopTime - this.startTime;
+  }
+  /** Number of taps recorded */
+  get tapCount() {
+    return this.taps.length;
+  }
+  /** Begin recording. Records timestamps of tap events. */
+  start() {
+    this.taps = [];
+    this.recording = true;
+    this.startTime = this.nowFn();
+    this.stopTime = 0;
+  }
+  /** Register a tap at current time. */
+  tap(intensity = DEFAULT_INTENSITY) {
+    if (!this.recording) return;
+    const now = this.nowFn();
+    const time = now - this.startTime;
+    const clamped = Math.max(0, Math.min(1, intensity));
+    const recorded = { time, intensity: clamped };
+    this.taps.push(recorded);
+    for (const cb of this.tapCallbacks) {
+      cb(recorded, this.taps.length - 1);
+    }
+  }
+  /** Stop recording, return the recorded taps. */
+  stop() {
+    this.recording = false;
+    this.stopTime = this.nowFn();
+    return [...this.taps];
+  }
+  /** Register a callback for each tap (for visual feedback during recording). */
+  onTap(callback) {
+    this.tapCallbacks.push(callback);
+  }
+  /** Reset the recorder. */
+  clear() {
+    this.taps = [];
+    this.recording = false;
+    this.startTime = 0;
+    this.stopTime = 0;
+  }
+  /**
+   * Snap taps to a grid for cleaner patterns.
+   * @param gridMs Grid size in ms (default 50ms)
+   */
+  quantize(gridMs = DEFAULT_GRID_MS) {
+    this.taps = this.taps.map((tap) => ({
+      ...tap,
+      time: Math.round(tap.time / gridMs) * gridMs
+    }));
+  }
+  /**
+   * Convert recorded taps to an HPL string.
+   *
+   * Maps gaps between taps to `.` characters (each 50ms),
+   * and tap intensities to `~` (light), `#` (medium), `@` (heavy).
+   */
+  toHPL() {
+    if (this.taps.length === 0) return "";
+    const sorted = [...this.taps].sort((a, b) => a.time - b.time);
+    let hpl = "";
+    for (let i = 0; i < sorted.length; i++) {
+      if (i > 0) {
+        const gap = sorted[i].time - sorted[i - 1].time;
+        if (gap >= 25) {
+          const pauses = Math.round(gap / DEFAULT_GRID_MS);
+          hpl += ".".repeat(pauses);
+        }
+      }
+      hpl += intensityToChar(sorted[i].intensity);
+    }
+    return hpl;
+  }
+  /** Convert recorded taps to HapticStep[]. */
+  toSteps() {
+    if (this.taps.length === 0) return [];
+    const sorted = [...this.taps].sort((a, b) => a.time - b.time);
+    const steps = [];
+    for (let i = 0; i < sorted.length; i++) {
+      if (i > 0) {
+        const gap = sorted[i].time - sorted[i - 1].time;
+        if (gap >= 25) {
+          const quantized = Math.round(gap / DEFAULT_GRID_MS) * DEFAULT_GRID_MS;
+          steps.push({ type: "pause", duration: quantized, intensity: 0 });
+        }
+      }
+      steps.push({
+        type: "vibrate",
+        duration: DEFAULT_TAP_DURATION,
+        intensity: sorted[i].intensity
+      });
+    }
+    return steps;
+  }
+  /** Convert recorded taps to a HapticPattern. */
+  toPattern(name) {
+    return {
+      name: name ?? "recorded-pattern",
+      steps: this.toSteps()
+    };
+  }
+};
+function intensityToChar(intensity) {
+  if (intensity < 0.35) return "~";
+  if (intensity <= 0.7) return "#";
+  return "@";
+}
+
 // src/presets/ui.ts
 var ui = {
   /** Light button tap */
@@ -1376,13 +2279,1075 @@ var system = {
   }
 };
 
+// src/presets/emotions.ts
+var emotions = {
+  /** Excited — fast, energetic pulses building up */
+  excited: {
+    name: "emotions.excited",
+    steps: [
+      { type: "vibrate", duration: 30, intensity: 0.5 },
+      { type: "pause", duration: 30, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.6 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.7 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.8 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.9 },
+      { type: "vibrate", duration: 50, intensity: 1 }
+    ]
+  },
+  /** Calm — slow, gentle wave with soft sustained vibrations */
+  calm: {
+    name: "emotions.calm",
+    steps: [
+      { type: "vibrate", duration: 80, intensity: 0.2 },
+      { type: "pause", duration: 200, intensity: 0 },
+      { type: "vibrate", duration: 100, intensity: 0.25 },
+      { type: "pause", duration: 250, intensity: 0 },
+      { type: "vibrate", duration: 80, intensity: 0.2 },
+      { type: "pause", duration: 200, intensity: 0 },
+      { type: "vibrate", duration: 100, intensity: 0.15 }
+    ]
+  },
+  /** Tense — tight, irregular short heavy bursts */
+  tense: {
+    name: "emotions.tense",
+    steps: [
+      { type: "vibrate", duration: 35, intensity: 0.8 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.9 },
+      { type: "pause", duration: 30, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.85 },
+      { type: "pause", duration: 35, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.9 },
+      { type: "pause", duration: 45, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.8 }
+    ]
+  },
+  /** Happy — bouncy, playful ascending rhythm */
+  happy: {
+    name: "emotions.happy",
+    steps: [
+      { type: "vibrate", duration: 30, intensity: 0.4 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.5 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.6 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.7 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 45, intensity: 0.8 }
+    ]
+  },
+  /** Sad — slow, heavy, descending vibrations that fade */
+  sad: {
+    name: "emotions.sad",
+    steps: [
+      { type: "vibrate", duration: 100, intensity: 0.8 },
+      { type: "pause", duration: 120, intensity: 0 },
+      { type: "vibrate", duration: 90, intensity: 0.6 },
+      { type: "pause", duration: 140, intensity: 0 },
+      { type: "vibrate", duration: 80, intensity: 0.4 },
+      { type: "pause", duration: 160, intensity: 0 },
+      { type: "vibrate", duration: 70, intensity: 0.25 }
+    ]
+  },
+  /** Angry — aggressive, chaotic heavy rapid hits */
+  angry: {
+    name: "emotions.angry",
+    steps: [
+      { type: "vibrate", duration: 40, intensity: 1 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.9 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 45, intensity: 1 },
+      { type: "pause", duration: 30, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.95 },
+      { type: "vibrate", duration: 50, intensity: 1 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 45, intensity: 0.9 }
+    ]
+  },
+  /** Surprised — sharp sudden hit, silence, then lighter hit */
+  surprised: {
+    name: "emotions.surprised",
+    steps: [
+      { type: "vibrate", duration: 40, intensity: 1 },
+      { type: "pause", duration: 200, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.4 }
+    ]
+  },
+  /** Anxious — fast irregular heartbeat with inconsistent spacing */
+  anxious: {
+    name: "emotions.anxious",
+    steps: [
+      { type: "vibrate", duration: 30, intensity: 0.7 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.8 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 25, intensity: 0.6 },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.75 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.85 },
+      { type: "pause", duration: 35, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.7 }
+    ]
+  },
+  /** Confident — strong, steady, measured even pulses */
+  confident: {
+    name: "emotions.confident",
+    steps: [
+      { type: "vibrate", duration: 50, intensity: 0.8 },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 50, intensity: 0.8 },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 50, intensity: 0.8 },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 50, intensity: 0.8 }
+    ]
+  },
+  /** Playful — alternating light-heavy in bouncy rhythm */
+  playful: {
+    name: "emotions.playful",
+    steps: [
+      { type: "vibrate", duration: 25, intensity: 0.3 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.7 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 25, intensity: 0.35 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.75 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 25, intensity: 0.3 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 45, intensity: 0.8 }
+    ]
+  },
+  /** Romantic — gentle heartbeat rhythm, two soft pulses, long pause, repeat */
+  romantic: {
+    name: "emotions.romantic",
+    steps: [
+      { type: "vibrate", duration: 35, intensity: 0.4 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 45, intensity: 0.5 },
+      { type: "pause", duration: 300, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.4 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 45, intensity: 0.5 },
+      { type: "pause", duration: 300, intensity: 0 },
+      { type: "vibrate", duration: 35, intensity: 0.4 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 45, intensity: 0.5 }
+    ]
+  },
+  /** Peaceful — very subtle, barely-there ultra-light slow pulses */
+  peaceful: {
+    name: "emotions.peaceful",
+    steps: [
+      { type: "vibrate", duration: 60, intensity: 0.1 },
+      { type: "pause", duration: 300, intensity: 0 },
+      { type: "vibrate", duration: 70, intensity: 0.12 },
+      { type: "pause", duration: 350, intensity: 0 },
+      { type: "vibrate", duration: 60, intensity: 0.1 },
+      { type: "pause", duration: 300, intensity: 0 },
+      { type: "vibrate", duration: 70, intensity: 0.08 }
+    ]
+  }
+};
+
 // src/presets/index.ts
 var presets = {
   ui,
   notifications,
   gaming,
   accessibility,
-  system
+  system,
+  emotions
+};
+
+// src/physics/physics-patterns.ts
+var clamp2 = (v, min, max) => Math.min(max, Math.max(min, v));
+var step = (type, duration, intensity) => ({
+  type,
+  duration: Math.max(25, Math.round(duration)),
+  intensity: clamp2(Math.round(intensity * 100) / 100, 0, 1)
+});
+function spring(options) {
+  const stiffness = clamp2(options?.stiffness ?? 0.7, 0.5, 1);
+  const damping = clamp2(options?.damping ?? 0.3, 0.1, 0.9);
+  const duration = options?.duration ?? 500;
+  const numSteps = Math.round(10 + stiffness * 5);
+  const stepDuration = duration / numSteps;
+  const steps = [];
+  for (let i = 0; i < numSteps; i++) {
+    const t = i / (numSteps - 1);
+    const decay = Math.exp(-damping * t * 5);
+    const oscillation = Math.abs(Math.cos(t * Math.PI * stiffness * 4));
+    const intensity = decay * oscillation * stiffness;
+    if (intensity > 0.05) {
+      steps.push(step("vibrate", stepDuration, intensity));
+    } else {
+      steps.push(step("pause", stepDuration, 0));
+    }
+  }
+  return { name: "physics.spring", steps };
+}
+function bounce(options) {
+  const height = clamp2(options?.height ?? 1, 0.5, 1);
+  const bounciness = clamp2(options?.bounciness ?? 0.6, 0.3, 0.9);
+  const bounces = options?.bounces ?? 5;
+  const steps = [];
+  let currentHeight = height;
+  for (let i = 0; i < bounces; i++) {
+    const vibDuration = 40 + currentHeight * 60;
+    const pauseDuration = 30 + currentHeight * 70;
+    steps.push(step("vibrate", vibDuration, currentHeight));
+    if (i < bounces - 1) {
+      steps.push(step("pause", pauseDuration, 0));
+    }
+    currentHeight *= bounciness;
+  }
+  return { name: "physics.bounce", steps };
+}
+function friction(options) {
+  const roughness = clamp2(options?.roughness ?? 0.5, 0.1, 1);
+  const speed = clamp2(options?.speed ?? 0.5, 0.1, 1);
+  const duration = options?.duration ?? 300;
+  const pulseCount = Math.round(4 + speed * 8);
+  const pulseDuration = duration / pulseCount;
+  const steps = [];
+  for (let i = 0; i < pulseCount; i++) {
+    const variation = (Math.sin(i * 7.3) + 1) / 2 * roughness * 0.4;
+    const baseIntensity = 0.3 + roughness * 0.4;
+    const intensity = baseIntensity + variation;
+    steps.push(step("vibrate", pulseDuration * 0.7, intensity));
+    steps.push(step("pause", pulseDuration * 0.3, 0));
+  }
+  return { name: "physics.friction", steps };
+}
+function impact(options) {
+  const mass = clamp2(options?.mass ?? 0.5, 0.1, 1);
+  const hardness = clamp2(options?.hardness ?? 0.7, 0.1, 1);
+  const steps = [];
+  const hitDuration = 30 + mass * 50;
+  const hitIntensity = 0.5 + mass * 0.5;
+  steps.push(step("vibrate", hitDuration, hitIntensity));
+  const resonanceCount = Math.round(2 + hardness * 4);
+  let decayIntensity = hitIntensity * 0.6;
+  for (let i = 0; i < resonanceCount; i++) {
+    const pauseDur = 25 + (1 - hardness) * 30;
+    steps.push(step("pause", pauseDur, 0));
+    steps.push(step("vibrate", 25 + mass * 20, decayIntensity));
+    decayIntensity *= 0.5;
+  }
+  return { name: "physics.impact", steps };
+}
+function gravity(options) {
+  const distance = clamp2(options?.distance ?? 1, 0.3, 1);
+  const duration = options?.duration ?? 400;
+  const numSteps = Math.round(6 + distance * 4);
+  const stepDuration = duration / numSteps;
+  const steps = [];
+  for (let i = 0; i < numSteps; i++) {
+    const t = i / (numSteps - 1);
+    const intensity = t * t * distance;
+    steps.push(step("vibrate", stepDuration, Math.max(0.1, intensity)));
+  }
+  return { name: "physics.gravity", steps };
+}
+function elastic(options) {
+  const stretch = clamp2(options?.stretch ?? 0.7, 0.3, 1);
+  const snapSpeed = clamp2(options?.snapSpeed ?? 0.8, 0.3, 1);
+  const steps = [];
+  const tensionSteps = Math.round(3 + stretch * 3);
+  for (let i = 0; i < tensionSteps; i++) {
+    const t = (i + 1) / tensionSteps;
+    const intensity = t * stretch * 0.6;
+    steps.push(step("vibrate", 40 + (1 - snapSpeed) * 30, intensity));
+  }
+  steps.push(step("vibrate", 25 + (1 - snapSpeed) * 20, 0.8 + stretch * 0.2));
+  const recoilIntensity = 0.4 * snapSpeed;
+  steps.push(step("vibrate", 30, recoilIntensity));
+  steps.push(step("vibrate", 25, recoilIntensity * 0.4));
+  return { name: "physics.elastic", steps };
+}
+function wave(options) {
+  const amplitude = clamp2(options?.amplitude ?? 0.7, 0.3, 1);
+  const frequency = clamp2(options?.frequency ?? 1, 0.5, 2);
+  const cycles = options?.cycles ?? 2;
+  const stepsPerCycle = Math.round(8 / frequency);
+  const totalSteps = stepsPerCycle * cycles;
+  const stepDuration = 400 / frequency / stepsPerCycle;
+  const steps = [];
+  for (let i = 0; i < totalSteps; i++) {
+    const t = i / stepsPerCycle;
+    const sineValue = (Math.sin(t * 2 * Math.PI) + 1) / 2;
+    const intensity = 0.1 + sineValue * amplitude * 0.9;
+    steps.push(step("vibrate", stepDuration, intensity));
+  }
+  return { name: "physics.wave", steps };
+}
+function pendulum(options) {
+  const energy = clamp2(options?.energy ?? 0.8, 0.3, 1);
+  const swings = options?.swings ?? 3;
+  const stepsPerSwing = 6;
+  const steps = [];
+  for (let s = 0; s < swings; s++) {
+    const swingEnergy = energy * Math.pow(0.8, s);
+    for (let i = 0; i < stepsPerSwing; i++) {
+      const t = i / (stepsPerSwing - 1);
+      const swing = Math.abs(Math.cos(t * Math.PI));
+      const intensity = swing * swingEnergy;
+      if (intensity > 0.05) {
+        steps.push(step("vibrate", 35, intensity));
+      } else {
+        steps.push(step("pause", 35, 0));
+      }
+    }
+  }
+  return { name: "physics.pendulum", steps };
+}
+
+// src/physics/index.ts
+var physics = {
+  spring,
+  bounce,
+  friction,
+  impact,
+  gravity,
+  elastic,
+  wave,
+  pendulum
+};
+
+// src/middleware/middleware.ts
+var MiddlewareManager = class {
+  constructor() {
+    this.middleware = [];
+  }
+  /** Register a middleware */
+  use(middleware) {
+    this.middleware.push(middleware);
+  }
+  /** Remove a middleware by name */
+  remove(name) {
+    this.middleware = this.middleware.filter((m) => m.name !== name);
+  }
+  /** Run all middleware in order */
+  process(steps) {
+    let result = steps;
+    for (const m of this.middleware) {
+      result = m.process(result);
+    }
+    return result;
+  }
+  /** Remove all middleware */
+  clear() {
+    this.middleware = [];
+  }
+  /** List registered middleware names */
+  list() {
+    return this.middleware.map((m) => m.name);
+  }
+};
+function intensityScaler(scale) {
+  return {
+    name: "intensityScaler",
+    process: (steps) => steps.map((s) => ({
+      ...s,
+      intensity: Math.min(1, Math.max(0, s.intensity * scale))
+    }))
+  };
+}
+function durationScaler(scale) {
+  return {
+    name: "durationScaler",
+    process: (steps) => steps.map((s) => ({
+      ...s,
+      duration: Math.max(20, Math.round(s.duration * scale))
+    }))
+  };
+}
+function intensityClamper(min, max) {
+  return {
+    name: "intensityClamper",
+    process: (steps) => steps.map((s) => ({
+      ...s,
+      intensity: Math.min(max, Math.max(min, s.intensity))
+    }))
+  };
+}
+function patternRepeater(times) {
+  return {
+    name: "patternRepeater",
+    process: (steps) => {
+      const result = [];
+      for (let i = 0; i < times; i++) {
+        result.push(...steps.map((s) => ({ ...s })));
+      }
+      return result;
+    }
+  };
+}
+function reverser() {
+  return {
+    name: "reverser",
+    process: (steps) => [...steps].reverse()
+  };
+}
+function accessibilityBooster() {
+  return {
+    name: "accessibilityBooster",
+    process: (steps) => steps.map((s) => ({
+      ...s,
+      intensity: Math.min(1, s.intensity * 1.3),
+      duration: Math.max(20, Math.round(s.duration * 1.2))
+    }))
+  };
+}
+
+// src/profiles/intensity-profiles.ts
+var profiles = {
+  off: {
+    name: "off",
+    hapticScale: 0,
+    durationScale: 0,
+    soundEnabled: false,
+    soundVolume: 0,
+    visualEnabled: false
+  },
+  subtle: {
+    name: "subtle",
+    hapticScale: 0.5,
+    durationScale: 0.7,
+    soundEnabled: true,
+    soundVolume: 0.1,
+    visualEnabled: true
+  },
+  normal: {
+    name: "normal",
+    hapticScale: 1,
+    durationScale: 1,
+    soundEnabled: true,
+    soundVolume: 0.3,
+    visualEnabled: true
+  },
+  strong: {
+    name: "strong",
+    hapticScale: 1.3,
+    durationScale: 1.2,
+    soundEnabled: true,
+    soundVolume: 0.5,
+    visualEnabled: true
+  },
+  intense: {
+    name: "intense",
+    hapticScale: 1.8,
+    durationScale: 1.5,
+    soundEnabled: true,
+    soundVolume: 0.7,
+    visualEnabled: true
+  },
+  accessible: {
+    name: "accessible",
+    hapticScale: 1.5,
+    durationScale: 1.3,
+    soundEnabled: true,
+    soundVolume: 0.6,
+    visualEnabled: true
+  }
+};
+var ProfileManager = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+    for (const [name, profile] of Object.entries(profiles)) {
+      this.registry.set(name, profile);
+    }
+    this.currentProfile = profiles.normal;
+  }
+  /** Apply a profile by name or custom profile object */
+  setProfile(name) {
+    if (typeof name === "string") {
+      const profile = this.registry.get(name);
+      if (!profile) {
+        throw new Error(`Unknown profile: "${name}"`);
+      }
+      this.currentProfile = profile;
+    } else {
+      this.registry.set(name.name, name);
+      this.currentProfile = name;
+    }
+  }
+  /** Get the current profile */
+  getProfile() {
+    return this.currentProfile;
+  }
+  /** List available profile names */
+  listProfiles() {
+    return Array.from(this.registry.keys());
+  }
+  /** Register a custom profile */
+  registerProfile(profile) {
+    this.registry.set(profile.name, profile);
+  }
+  /** Convert current profile to a HapticMiddleware (intensity + duration scaling) */
+  toMiddleware() {
+    const profile = this.currentProfile;
+    const iScaler = intensityScaler(profile.hapticScale);
+    const dScaler = durationScaler(profile.durationScale);
+    return {
+      name: `profile:${profile.name}`,
+      process: (steps) => dScaler.process(iScaler.process(steps))
+    };
+  }
+  /** Current profile name */
+  get current() {
+    return this.currentProfile.name;
+  }
+};
+
+// src/experiment/ab-testing.ts
+var HapticExperiment = class {
+  constructor(name, variants) {
+    this.assignments = /* @__PURE__ */ new Map();
+    this.tracking = [];
+    this._name = name;
+    this.variants = variants;
+    this.variantNames = Object.keys(variants);
+    if (this.variantNames.length === 0) {
+      throw new Error("Experiment must have at least one variant");
+    }
+  }
+  /** Experiment name */
+  get name() {
+    return this._name;
+  }
+  /**
+   * Randomly assign a variant (consistent for same userId via simple hash).
+   * If no userId is provided, generates a random assignment.
+   */
+  assign(userId) {
+    const id = userId ?? `anon-${Math.random().toString(36).slice(2)}`;
+    const existing = this.assignments.get(id);
+    if (existing) return existing;
+    const hash = this._hash(id);
+    const index = hash % this.variantNames.length;
+    const variant = this.variantNames[index];
+    this.assignments.set(id, variant);
+    return variant;
+  }
+  /** Get the assigned variant pattern for a user */
+  getVariant(userId) {
+    const id = userId ?? void 0;
+    if (!id) return void 0;
+    const variant = this.assignments.get(id);
+    if (!variant) return void 0;
+    return this.variants[variant];
+  }
+  /** Track an event for a user */
+  track(userId, event, value) {
+    const variant = this.assignments.get(userId);
+    if (!variant) return;
+    this.tracking.push({
+      userId,
+      variant,
+      event,
+      value,
+      timestamp: Date.now()
+    });
+  }
+  /** Get aggregated results per variant */
+  getResults() {
+    const results = {};
+    for (const name of this.variantNames) {
+      results[name] = { assignments: 0, events: {} };
+    }
+    for (const variant of this.assignments.values()) {
+      if (results[variant]) {
+        results[variant].assignments++;
+      }
+    }
+    for (const entry of this.tracking) {
+      if (results[entry.variant]) {
+        const events = results[entry.variant].events;
+        events[entry.event] = (events[entry.event] ?? 0) + 1;
+      }
+    }
+    return results;
+  }
+  /** Clear all tracking data and assignments */
+  reset() {
+    this.assignments.clear();
+    this.tracking = [];
+  }
+  /** Simple string hash for deterministic variant assignment */
+  _hash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  }
+};
+
+// src/rhythm/rhythm-sync.ts
+var RhythmSync = class {
+  constructor(options = {}) {
+    // reserved for pattern-based rhythm
+    this._isPlaying = false;
+    this._beatCount = 0;
+    this._intervalId = null;
+    this._callbacks = [];
+    this._tapTimestamps = [];
+    this._audioElement = null;
+    this._syncEngine = null;
+    this._syncEffect = "tap";
+    this._bpm = Math.min(300, Math.max(60, options.bpm ?? 120));
+    this._intensity = Math.min(1, Math.max(0, options.intensity ?? 0.7));
+    this._pattern = options.pattern ?? "";
+  }
+  // ─── BPM Control ─────────────────────────────────────────
+  /** Set beats per minute (clamped to 60-300) */
+  setBPM(bpm) {
+    this._bpm = Math.min(300, Math.max(60, bpm));
+    if (this._isPlaying) {
+      this._stopInterval();
+      this._startInterval();
+    }
+  }
+  /**
+   * Store an audio element reference for sync.
+   * Since Web Audio API's AnalyserNode isn't reliably available in all
+   * environments, use tapTempo() for BPM detection instead.
+   */
+  detectBPM(audioElement) {
+    this._audioElement = audioElement;
+  }
+  /**
+   * Tap tempo — call repeatedly to set BPM from tap intervals.
+   * Calculates average BPM from the last 4-8 taps.
+   * Returns the current estimated BPM.
+   */
+  tapTempo() {
+    const now = Date.now();
+    this._tapTimestamps.push(now);
+    if (this._tapTimestamps.length > 8) {
+      this._tapTimestamps = this._tapTimestamps.slice(-8);
+    }
+    if (this._tapTimestamps.length < 2) {
+      return this._bpm;
+    }
+    const timestamps = this._tapTimestamps.slice(-8);
+    const intervals = [];
+    for (let i = 1; i < timestamps.length; i++) {
+      intervals.push(timestamps[i] - timestamps[i - 1]);
+    }
+    const avgInterval = intervals.reduce((sum, v) => sum + v, 0) / intervals.length;
+    if (avgInterval > 0) {
+      const estimatedBPM = Math.round(6e4 / avgInterval);
+      this._bpm = Math.min(300, Math.max(60, estimatedBPM));
+    }
+    return this._bpm;
+  }
+  // ─── Playback ────────────────────────────────────────────
+  /** Start emitting beats at the current BPM */
+  start(callback) {
+    if (this._isPlaying) return;
+    if (callback) {
+      this._callbacks.push(callback);
+    }
+    this._isPlaying = true;
+    this._beatCount = 0;
+    this._startInterval();
+  }
+  /** Stop the rhythm */
+  stop() {
+    this._isPlaying = false;
+    this._stopInterval();
+  }
+  /** Register a beat callback */
+  onBeat(callback) {
+    this._callbacks.push(callback);
+  }
+  // ─── Haptic Sync ────────────────────────────────────────
+  /**
+   * Auto-trigger a haptic effect on each beat.
+   * Calls engine.tap() by default, or the specified semantic method.
+   */
+  syncHaptic(engine, effect = "tap") {
+    this._syncEngine = engine;
+    this._syncEffect = effect;
+  }
+  // ─── Getters ─────────────────────────────────────────────
+  /** Current BPM */
+  get bpm() {
+    return this._bpm;
+  }
+  /** Whether rhythm is active */
+  get isPlaying() {
+    return this._isPlaying;
+  }
+  /** Total beats since start */
+  get beatCount() {
+    return this._beatCount;
+  }
+  /** Current pattern string */
+  get pattern() {
+    return this._pattern;
+  }
+  /** The attached audio element, if any */
+  get audioElement() {
+    return this._audioElement;
+  }
+  // ─── Lifecycle ───────────────────────────────────────────
+  /** Clean up intervals and callbacks */
+  dispose() {
+    this.stop();
+    this._callbacks = [];
+    this._tapTimestamps = [];
+    this._syncEngine = null;
+    this._audioElement = null;
+  }
+  // ─── Internal ────────────────────────────────────────────
+  _startInterval() {
+    const intervalMs = 6e4 / this._bpm;
+    this._intervalId = setInterval(() => {
+      this._beatCount++;
+      const beat = this._beatCount;
+      for (const cb of this._callbacks) {
+        cb(beat);
+      }
+      if (this._syncEngine) {
+        const engine = this._syncEngine;
+        if (typeof engine[this._syncEffect] === "function") {
+          engine[this._syncEffect](this._intensity);
+        } else if (typeof engine.tap === "function") {
+          engine.tap(this._intensity);
+        }
+      }
+    }, intervalMs);
+  }
+  _stopInterval() {
+    if (this._intervalId !== null) {
+      clearInterval(this._intervalId);
+      this._intervalId = null;
+    }
+  }
+};
+
+// src/motion/motion-detector.ts
+var MotionDetector = class {
+  constructor(options = {}) {
+    this._isListening = false;
+    this._callbacks = {
+      shake: [],
+      tilt: [],
+      rotation: [],
+      flip: []
+    };
+    this._lastOrientation = null;
+    this._lastFlipState = null;
+    this._boundMotionHandler = null;
+    this._boundOrientationHandler = null;
+    this._shakeThreshold = options.shakeThreshold ?? 15;
+    this._tiltThreshold = options.tiltThreshold ?? 10;
+  }
+  // ─── Detection ───────────────────────────────────────────
+  /** Whether DeviceMotion API is available */
+  get isSupported() {
+    if (typeof window === "undefined") return false;
+    return "DeviceMotionEvent" in window;
+  }
+  /** Whether currently listening for motion events */
+  get isListening() {
+    return this._isListening;
+  }
+  // ─── Permission ──────────────────────────────────────────
+  /**
+   * Request permission for motion events (required on iOS 13+).
+   * Returns true if permission was granted.
+   */
+  async requestPermission() {
+    if (typeof window === "undefined") return false;
+    const DeviceMotionEventRef = window.DeviceMotionEvent;
+    if (DeviceMotionEventRef && typeof DeviceMotionEventRef.requestPermission === "function") {
+      try {
+        const result = await DeviceMotionEventRef.requestPermission();
+        return result === "granted";
+      } catch {
+        return false;
+      }
+    }
+    return this.isSupported;
+  }
+  // ─── Lifecycle ───────────────────────────────────────────
+  /** Begin listening to device motion and orientation events */
+  start() {
+    if (this._isListening) return;
+    if (typeof window === "undefined") return;
+    this._boundMotionHandler = this._handleMotion.bind(this);
+    this._boundOrientationHandler = this._handleOrientation.bind(this);
+    window.addEventListener("devicemotion", this._boundMotionHandler);
+    window.addEventListener("deviceorientation", this._boundOrientationHandler);
+    this._isListening = true;
+  }
+  /** Stop listening to motion events */
+  stop() {
+    if (!this._isListening) return;
+    if (typeof window === "undefined") return;
+    if (this._boundMotionHandler) {
+      window.removeEventListener("devicemotion", this._boundMotionHandler);
+    }
+    if (this._boundOrientationHandler) {
+      window.removeEventListener("deviceorientation", this._boundOrientationHandler);
+    }
+    this._isListening = false;
+    this._lastOrientation = null;
+    this._lastFlipState = null;
+  }
+  // ─── Callbacks ───────────────────────────────────────────
+  /** Register callback for shake events. Intensity is 0-1 based on acceleration. */
+  onShake(callback) {
+    this._callbacks.shake.push(callback);
+  }
+  /** Register callback for tilt changes. Direction x/y are -1 to 1. */
+  onTilt(callback) {
+    this._callbacks.tilt.push(callback);
+  }
+  /** Register callback for rotation. Angle in degrees. */
+  onRotation(callback) {
+    this._callbacks.rotation.push(callback);
+  }
+  /** Register callback for device flip (face-down/up toggle). */
+  onFlip(callback) {
+    this._callbacks.flip.push(callback);
+  }
+  // ─── Cleanup ─────────────────────────────────────────────
+  /** Remove all listeners and callbacks */
+  dispose() {
+    this.stop();
+    this._callbacks = { shake: [], tilt: [], rotation: [], flip: [] };
+  }
+  // ─── Internal ────────────────────────────────────────────
+  _handleMotion(event) {
+    const accel = event.accelerationIncludingGravity;
+    if (!accel) return;
+    const { x, y, z } = accel;
+    if (x == null || y == null || z == null) return;
+    const magnitude = Math.sqrt(x * x + y * y + z * z) - 9.81;
+    if (magnitude > this._shakeThreshold) {
+      const intensity = Math.min(
+        1,
+        (magnitude - this._shakeThreshold) / this._shakeThreshold
+      );
+      for (const cb of this._callbacks.shake) {
+        cb(intensity);
+      }
+    }
+  }
+  _handleOrientation(event) {
+    const { alpha, beta, gamma } = event;
+    if (beta == null || gamma == null) return;
+    if (this._lastOrientation) {
+      const deltaBeta = Math.abs(beta - this._lastOrientation.beta);
+      const deltaGamma = Math.abs(gamma - this._lastOrientation.gamma);
+      if (deltaBeta > this._tiltThreshold || deltaGamma > this._tiltThreshold) {
+        const tiltX = Math.max(-1, Math.min(1, gamma / 90));
+        const tiltY = Math.max(-1, Math.min(1, beta / 180));
+        for (const cb of this._callbacks.tilt) {
+          cb({ x: tiltX, y: tiltY });
+        }
+      }
+    }
+    this._lastOrientation = { beta, gamma };
+    if (alpha != null) {
+      for (const cb of this._callbacks.rotation) {
+        cb(alpha);
+      }
+    }
+    const isFaceDown = Math.abs(beta) > 140;
+    if (this._lastFlipState !== null && isFaceDown !== this._lastFlipState) {
+      for (const cb of this._callbacks.flip) {
+        cb();
+      }
+    }
+    this._lastFlipState = isFaceDown;
+  }
+};
+
+// src/accessibility/haptic-a11y.ts
+var HapticA11y = class {
+  constructor(engine, options = {}) {
+    this._isAttached = false;
+    this._root = null;
+    this._observer = null;
+    this._focusChangeCallback = null;
+    this._formErrorCallback = null;
+    // Bound handlers for cleanup
+    this._handleFocusIn = null;
+    this._handleFocusOut = null;
+    this._handleInvalid = null;
+    this._handleClick = null;
+    this.engine = engine;
+    this.options = {
+      focusChange: options.focusChange ?? true,
+      formErrors: options.formErrors ?? true,
+      navigation: options.navigation ?? true,
+      announcements: options.announcements ?? true
+    };
+  }
+  /** Whether currently attached and listening */
+  get isAttached() {
+    return this._isAttached;
+  }
+  // ─── Attach / Detach ─────────────────────────────────────
+  /**
+   * Attach to a root element and begin listening for interactions.
+   * Defaults to document.body if no root is provided.
+   */
+  attach(root) {
+    if (this._isAttached) return;
+    if (typeof document === "undefined") return;
+    this._root = root ?? document.body;
+    if (!this._root) return;
+    this._bindHandlers();
+    this._attachListeners();
+    this._startObserver();
+    this._isAttached = true;
+  }
+  /** Remove all listeners and stop observing */
+  detach() {
+    if (!this._isAttached) return;
+    this._removeListeners();
+    this._stopObserver();
+    this._isAttached = false;
+    this._root = null;
+  }
+  // ─── Custom Handlers ─────────────────────────────────────
+  /** Set a custom handler for focus changes */
+  onFocusChange(callback) {
+    this._focusChangeCallback = callback ?? null;
+  }
+  /** Set a custom handler for form errors */
+  onFormError(callback) {
+    this._formErrorCallback = callback ?? null;
+  }
+  // ─── Cleanup ─────────────────────────────────────────────
+  /** Clean up all listeners, observers, and callbacks */
+  dispose() {
+    this.detach();
+    this._focusChangeCallback = null;
+    this._formErrorCallback = null;
+  }
+  // ─── Internal ────────────────────────────────────────────
+  _bindHandlers() {
+    this._handleFocusIn = (e) => {
+      if (!this.options.focusChange) return;
+      if (this._focusChangeCallback) {
+        this._focusChangeCallback(e);
+        return;
+      }
+      this._safeCall(() => this.engine.selection());
+    };
+    this._handleFocusOut = (_e) => {
+    };
+    this._handleInvalid = (e) => {
+      if (!this.options.formErrors) return;
+      if (this._formErrorCallback) {
+        this._formErrorCallback(e);
+        return;
+      }
+      this._safeCall(() => this.engine.error());
+    };
+    this._handleClick = (e) => {
+      const target = e.target;
+      if (!target) return;
+      const tagName = target.tagName?.toLowerCase();
+      if (tagName === "button" || target.getAttribute?.("role") === "button") {
+        this._safeCall(() => this.engine.tap());
+        return;
+      }
+      if (tagName === "a" && this.options.navigation) {
+        this._safeCall(() => this.engine.selection());
+        return;
+      }
+      if (tagName === "input") {
+        const inputType = target.type?.toLowerCase();
+        if (inputType === "checkbox" || inputType === "radio") {
+          const checked = target.checked;
+          this._safeCall(() => this.engine.toggle(checked));
+        }
+      }
+    };
+  }
+  _attachListeners() {
+    if (!this._root) return;
+    this._root.addEventListener("focusin", this._handleFocusIn, true);
+    this._root.addEventListener("focusout", this._handleFocusOut, true);
+    this._root.addEventListener("invalid", this._handleInvalid, true);
+    this._root.addEventListener("click", this._handleClick, true);
+  }
+  _removeListeners() {
+    if (!this._root) return;
+    this._root.removeEventListener("focusin", this._handleFocusIn, true);
+    this._root.removeEventListener("focusout", this._handleFocusOut, true);
+    this._root.removeEventListener("invalid", this._handleInvalid, true);
+    this._root.removeEventListener("click", this._handleClick, true);
+  }
+  _startObserver() {
+    if (typeof MutationObserver === "undefined") return;
+    if (!this.options.announcements) return;
+    this._observer = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        for (const node of mutation.addedNodes) {
+          if (node.nodeType !== 1) continue;
+          const el = node;
+          const role = el.getAttribute?.("role");
+          const ariaLive = el.getAttribute?.("aria-live");
+          if (role === "alert" || role === "alertdialog") {
+            this._safeCall(() => this.engine.warning());
+          } else if (role === "status" || ariaLive === "polite" || ariaLive === "assertive") {
+            this._safeCall(() => this.engine.selection());
+          }
+          if (role === "dialog" || el.tagName?.toLowerCase() === "dialog") {
+            this._safeCall(() => this.engine.toggle(true));
+          }
+        }
+        for (const node of mutation.removedNodes) {
+          if (node.nodeType !== 1) continue;
+          const el = node;
+          const role = el.getAttribute?.("role");
+          if (role === "dialog" || el.tagName?.toLowerCase() === "dialog") {
+            this._safeCall(() => this.engine.toggle(false));
+          }
+        }
+      }
+    });
+    this._observer.observe(this._root, {
+      childList: true,
+      subtree: true
+    });
+  }
+  _stopObserver() {
+    if (this._observer) {
+      this._observer.disconnect();
+      this._observer = null;
+    }
+  }
+  _safeCall(fn) {
+    try {
+      const result = fn();
+      if (result && typeof result.catch === "function") {
+        result.catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
 };
 
 // src/index.ts
@@ -1393,30 +3358,59 @@ exports.FallbackManager = FallbackManager;
 exports.HPLParser = HPLParser;
 exports.HPLParserError = HPLParserError;
 exports.HPLTokenizerError = HPLTokenizerError;
+exports.HapticA11y = HapticA11y;
 exports.HapticEngine = HapticEngine;
+exports.HapticExperiment = HapticExperiment;
 exports.IoSAudioAdapter = IoSAudioAdapter;
+exports.MiddlewareManager = MiddlewareManager;
+exports.MotionDetector = MotionDetector;
 exports.NoopAdapter = NoopAdapter;
 exports.PatternComposer = PatternComposer;
+exports.PatternRecorder = PatternRecorder;
+exports.ProfileManager = ProfileManager;
+exports.RhythmSync = RhythmSync;
+exports.SensoryEngine = SensoryEngine;
+exports.SoundEngine = SoundEngine;
+exports.ThemeManager = ThemeManager;
+exports.VisualEngine = VisualEngine;
 exports.WebVibrationAdapter = WebVibrationAdapter;
 exports.accessibility = accessibility;
+exports.accessibilityBooster = accessibilityBooster;
+exports.bounce = bounce;
 exports.compile = compile;
 exports.detectAdapter = detectAdapter;
 exports.detectPlatform = detectPlatform;
+exports.durationScaler = durationScaler;
+exports.elastic = elastic;
+exports.emotions = emotions;
 exports.exportPattern = exportPattern;
+exports.friction = friction;
 exports.gaming = gaming;
+exports.gravity = gravity;
 exports.haptic = haptic;
+exports.impact = impact;
 exports.importPattern = importPattern;
+exports.intensityClamper = intensityClamper;
+exports.intensityScaler = intensityScaler;
 exports.notifications = notifications;
 exports.optimizeSteps = optimizeSteps;
 exports.parseHPL = parseHPL;
 exports.patternFromDataURL = patternFromDataURL;
 exports.patternFromJSON = patternFromJSON;
+exports.patternRepeater = patternRepeater;
 exports.patternToDataURL = patternToDataURL;
 exports.patternToJSON = patternToJSON;
+exports.pendulum = pendulum;
+exports.physics = physics;
 exports.presets = presets;
+exports.profiles = profiles;
+exports.reverser = reverser;
+exports.spring = spring;
 exports.system = system;
+exports.themes = themes;
 exports.tokenize = tokenize;
 exports.ui = ui;
 exports.validateHPL = validateHPL;
+exports.wave = wave;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map