@hapticjs/core 0.2.1 → 0.3.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,347 @@ 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/index.ts
@@ -1397,14 +2634,25 @@ exports.HapticEngine = HapticEngine;
 exports.IoSAudioAdapter = IoSAudioAdapter;
 exports.NoopAdapter = NoopAdapter;
 exports.PatternComposer = PatternComposer;
+exports.PatternRecorder = PatternRecorder;
+exports.SensoryEngine = SensoryEngine;
+exports.SoundEngine = SoundEngine;
+exports.ThemeManager = ThemeManager;
+exports.VisualEngine = VisualEngine;
 exports.WebVibrationAdapter = WebVibrationAdapter;
 exports.accessibility = accessibility;
+exports.bounce = bounce;
 exports.compile = compile;
 exports.detectAdapter = detectAdapter;
 exports.detectPlatform = detectPlatform;
+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.notifications = notifications;
 exports.optimizeSteps = optimizeSteps;
@@ -1413,10 +2661,15 @@ exports.patternFromDataURL = patternFromDataURL;
 exports.patternFromJSON = patternFromJSON;
 exports.patternToDataURL = patternToDataURL;
 exports.patternToJSON = patternToJSON;
+exports.pendulum = pendulum;
+exports.physics = physics;
 exports.presets = presets;
+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