@hapticjs/core 0.1.0 → 0.2.1

package/dist/index.cjs

@@ -34,6 +34,66 @@ var NoopAdapter = class {
   }
 };
 
+// src/adapters/web-vibration.adapter.ts
+var WebVibrationAdapter = class {
+  constructor() {
+    this.name = "web-vibration";
+    this.supported = typeof navigator !== "undefined" && "vibrate" in navigator;
+  }
+  capabilities() {
+    return {
+      maxIntensityLevels: 1,
+      minDuration: 20,
+      maxDuration: 1e4,
+      supportsPattern: true,
+      supportsIntensity: false,
+      dualMotor: false
+    };
+  }
+  async pulse(_intensity, duration) {
+    if (!this.supported) return;
+    navigator.vibrate(Math.max(duration, 20));
+  }
+  async playSequence(steps) {
+    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);
+        if (lastType === "vibrate") {
+          pattern[pattern.length - 1] += dur;
+        } else {
+          pattern.push(dur);
+        }
+        lastType = "vibrate";
+      } else {
+        const dur = Math.max(step.duration, 10);
+        if (lastType === "pause") {
+          pattern[pattern.length - 1] += dur;
+        } else {
+          pattern.push(dur);
+        }
+        lastType = "pause";
+      }
+    }
+    if (pattern.length > 0) {
+      if (steps[0]?.type === "pause" || steps[0]?.type === "vibrate" && steps[0]?.intensity <= 0.05) {
+        pattern.unshift(0);
+      }
+      navigator.vibrate(pattern);
+    }
+  }
+  cancel() {
+    if (this.supported) {
+      navigator.vibrate(0);
+    }
+  }
+  dispose() {
+    this.cancel();
+  }
+};
+
 // src/utils/scheduling.ts
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -45,49 +105,37 @@ function normalizeIntensity(intensity) {
   return clamp(intensity, 0, 1);
 }
 
-// src/adapters/web-vibration.adapter.ts
-var WebVibrationAdapter = class {
+// src/adapters/ios-audio.adapter.ts
+var IoSAudioAdapter = class {
   constructor() {
-    this.name = "web-vibration";
+    this.name = "ios-audio";
+    this._audioCtx = null;
+    this._activeOscillator = null;
+    this._activeGain = null;
     this._cancelled = false;
-    this.supported = typeof navigator !== "undefined" && "vibrate" in navigator;
+    this.supported = this._detectSupport();
   }
   capabilities() {
     return {
-      maxIntensityLevels: 1,
-      // on/off only
-      minDuration: 10,
-      maxDuration: 1e4,
+      maxIntensityLevels: 100,
+      minDuration: 5,
+      maxDuration: 5e3,
       supportsPattern: true,
-      supportsIntensity: false,
+      supportsIntensity: true,
       dualMotor: false
     };
   }
-  async pulse(_intensity, duration) {
+  async pulse(intensity, duration) {
     if (!this.supported) return;
-    navigator.vibrate(duration);
+    await this._playTone(intensity, duration);
   }
   async playSequence(steps) {
     if (!this.supported || steps.length === 0) return;
     this._cancelled = false;
-    const pattern = this._toVibrationPattern(steps);
-    if (this._canUseNativePattern(steps)) {
-      navigator.vibrate(pattern);
-      return;
-    }
     for (const step of steps) {
       if (this._cancelled) break;
-      if (step.type === "vibrate") {
-        if (step.intensity > 0.1) {
-          if (step.intensity < 0.5) {
-            await this._pwmVibrate(step.duration, step.intensity);
-          } else {
-            navigator.vibrate(step.duration);
-            await delay(step.duration);
-          }
-        } else {
-          await delay(step.duration);
-        }
+      if (step.type === "vibrate" && step.intensity > 0) {
+        await this._playTone(step.intensity, step.duration);
       } else {
         await delay(step.duration);
       }
@@ -95,40 +143,82 @@ var WebVibrationAdapter = class {
   }
   cancel() {
     this._cancelled = true;
-    if (this.supported) {
-      navigator.vibrate(0);
-    }
+    this._stopOscillator();
   }
   dispose() {
     this.cancel();
-  }
-  /** Convert steps to Vibration API pattern array */
-  _toVibrationPattern(steps) {
-    const pattern = [];
-    for (const step of steps) {
-      pattern.push(step.duration);
+    if (this._audioCtx) {
+      void this._audioCtx.close();
+      this._audioCtx = null;
     }
-    return pattern;
   }
-  /** Check if all steps can be played with native pattern (no intensity variation) */
-  _canUseNativePattern(steps) {
-    return steps.every(
-      (s) => s.type === "pause" || s.type === "vibrate" && s.intensity >= 0.5
+  // ─── Internal ──────────────────────────────────────────────
+  _detectSupport() {
+    if (typeof window === "undefined") return false;
+    const hasAudioContext = typeof AudioContext !== "undefined" || typeof window.webkitAudioContext !== "undefined";
+    if (!hasAudioContext) return false;
+    const ua = navigator.userAgent;
+    const isIOS = /iPad|iPhone|iPod/.test(ua) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+    return isIOS;
+  }
+  /** Get or create the AudioContext, resuming if suspended */
+  async _getAudioContext() {
+    if (!this._audioCtx) {
+      const Ctor = typeof AudioContext !== "undefined" ? AudioContext : window.webkitAudioContext;
+      this._audioCtx = new Ctor();
+    }
+    if (this._audioCtx.state === "suspended") {
+      await this._audioCtx.resume();
+    }
+    return this._audioCtx;
+  }
+  /** Map intensity (0-1) to frequency in the 20-60 Hz sub-bass range */
+  _intensityToFrequency(intensity) {
+    return 20 + intensity * 40;
+  }
+  /** Play a single oscillator tone for the given duration */
+  async _playTone(intensity, duration) {
+    const ctx = await this._getAudioContext();
+    const oscillator = ctx.createOscillator();
+    const gainNode = ctx.createGain();
+    oscillator.type = "sine";
+    oscillator.frequency.setValueAtTime(
+      this._intensityToFrequency(intensity),
+      ctx.currentTime
     );
-  }
-  /** Simulate lower intensity via pulse-width modulation */
-  async _pwmVibrate(duration, intensity) {
-    const cycleTime = 20;
-    const onTime = Math.round(cycleTime * intensity);
-    const offTime = cycleTime - onTime;
-    const cycles = Math.floor(duration / cycleTime);
-    const pattern = [];
-    for (let i = 0; i < cycles; i++) {
-      pattern.push(onTime, offTime);
+    gainNode.gain.setValueAtTime(intensity, ctx.currentTime);
+    oscillator.connect(gainNode);
+    gainNode.connect(ctx.destination);
+    this._activeOscillator = oscillator;
+    this._activeGain = gainNode;
+    oscillator.start(ctx.currentTime);
+    oscillator.stop(ctx.currentTime + duration / 1e3);
+    await new Promise((resolve) => {
+      oscillator.onended = () => {
+        oscillator.disconnect();
+        gainNode.disconnect();
+        this._activeOscillator = null;
+        this._activeGain = null;
+        resolve();
+      };
+    });
+  }
+  /** Immediately stop the active oscillator if any */
+  _stopOscillator() {
+    if (this._activeOscillator) {
+      try {
+        this._activeOscillator.stop();
+        this._activeOscillator.disconnect();
+      } catch {
+      }
+      this._activeOscillator = null;
     }
-    if (pattern.length > 0) {
-      navigator.vibrate(pattern);
-      await delay(duration);
+    if (this._activeGain) {
+      try {
+        this._activeGain.disconnect();
+      } catch {
+      }
+      this._activeGain = null;
     }
   }
 };
@@ -162,6 +252,12 @@ function detectAdapter() {
   if (platform.hasVibrationAPI) {
     return new WebVibrationAdapter();
   }
+  if (platform.isIOS && platform.isWeb) {
+    const iosAdapter = new IoSAudioAdapter();
+    if (iosAdapter.supported) {
+      return iosAdapter;
+    }
+  }
   return new NoopAdapter();
 }
 
@@ -196,13 +292,13 @@ var FallbackManager = class {
   /** Execute fallback feedback for the given steps */
   async execute(steps) {
     if (this.config.type === "none") return;
-    const totalDuration = steps.reduce((sum, s) => sum + s.duration, 0);
+    const totalDuration2 = steps.reduce((sum, s) => sum + s.duration, 0);
     const maxIntensity = Math.max(...steps.filter((s) => s.type === "vibrate").map((s) => s.intensity), 0);
     if (this.config.type === "visual" || this.config.type === "both") {
-      await this._visualFallback(totalDuration, maxIntensity);
+      await this._visualFallback(totalDuration2, maxIntensity);
     }
     if (this.config.type === "audio" || this.config.type === "both") {
-      await this._audioFallback(totalDuration, maxIntensity);
+      await this._audioFallback(totalDuration2, maxIntensity);
     }
   }
   async _visualFallback(duration, intensity) {
@@ -607,14 +703,14 @@ var HapticEngine = class _HapticEngine {
   // ─── Semantic API ──────────────────────────────────────────
   /** Light tap feedback */
   async tap(intensity = 0.6) {
-    await this._playSteps([{ type: "vibrate", duration: 10, intensity }]);
+    await this._playSteps([{ type: "vibrate", duration: 30, intensity }]);
   }
   /** Double tap */
   async doubleTap(intensity = 0.6) {
     await this._playSteps([
-      { type: "vibrate", duration: 10, intensity },
+      { type: "vibrate", duration: 25, intensity },
       { type: "pause", duration: 80, intensity: 0 },
-      { type: "vibrate", duration: 10, intensity }
+      { type: "vibrate", duration: 25, intensity }
     ]);
   }
   /** Long press feedback */
@@ -649,24 +745,24 @@ var HapticEngine = class _HapticEngine {
   }
   /** Selection change feedback */
   async selection() {
-    await this._playSteps([{ type: "vibrate", duration: 8, intensity: 0.4 }]);
+    await this._playSteps([{ type: "vibrate", duration: 25, intensity: 0.5 }]);
   }
   /** Toggle feedback */
   async toggle(on) {
     if (on) {
-      await this._playSteps([{ type: "vibrate", duration: 15, intensity: 0.6 }]);
+      await this._playSteps([{ type: "vibrate", duration: 30, intensity: 0.6 }]);
     } else {
-      await this._playSteps([{ type: "vibrate", duration: 10, intensity: 0.3 }]);
+      await this._playSteps([{ type: "vibrate", duration: 25, intensity: 0.4 }]);
     }
   }
   /** Impact with style (matches iOS UIImpactFeedbackGenerator) */
   async impact(style = "medium") {
     const presets2 = {
-      light: [{ type: "vibrate", duration: 10, intensity: 0.3 }],
-      medium: [{ type: "vibrate", duration: 15, intensity: 0.6 }],
-      heavy: [{ type: "vibrate", duration: 25, intensity: 1 }],
-      rigid: [{ type: "vibrate", duration: 8, intensity: 0.9 }],
-      soft: [{ type: "vibrate", duration: 30, intensity: 0.4 }]
+      light: [{ type: "vibrate", duration: 25, intensity: 0.4 }],
+      medium: [{ type: "vibrate", duration: 35, intensity: 0.7 }],
+      heavy: [{ type: "vibrate", duration: 50, intensity: 1 }],
+      rigid: [{ type: "vibrate", duration: 30, intensity: 0.9 }],
+      soft: [{ type: "vibrate", duration: 35, intensity: 0.5 }]
     };
     await this._playSteps(presets2[style]);
   }
@@ -787,20 +883,135 @@ function validateHPL(input) {
   return { valid: errors.length === 0, errors };
 }
 
+// src/patterns/sharing.ts
+function totalDuration(steps) {
+  return steps.reduce((sum, s) => sum + s.duration, 0);
+}
+function resolveInput(input) {
+  if (typeof input === "string") {
+    const ast = parseHPL(input);
+    return { steps: compile(ast), hpl: input };
+  }
+  if (Array.isArray(input)) {
+    return { steps: input };
+  }
+  return { steps: input.steps, name: input.name };
+}
+function exportPattern(input, options = {}) {
+  const resolved = resolveInput(input);
+  const steps = resolved.steps;
+  const name = options.name ?? resolved.name ?? "Untitled Pattern";
+  const result = {
+    version: 1,
+    name,
+    steps
+  };
+  if (options.description) {
+    result.description = options.description;
+  }
+  if (resolved.hpl) {
+    result.hpl = resolved.hpl;
+  }
+  const hasMetadataFields = options.author || options.tags;
+  if (hasMetadataFields || steps.length > 0) {
+    result.metadata = {
+      duration: totalDuration(steps),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (options.author) {
+      result.metadata.author = options.author;
+    }
+    if (options.tags) {
+      result.metadata.tags = options.tags;
+    }
+  }
+  return result;
+}
+function validateExport(data) {
+  if (data === null || typeof data !== "object") {
+    throw new Error("Invalid pattern data: expected an object");
+  }
+  const obj = data;
+  if (obj.version !== 1) {
+    throw new Error(
+      `Unsupported pattern version: ${String(obj.version)}. Expected version 1`
+    );
+  }
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    throw new Error('Invalid pattern data: "name" must be a non-empty string');
+  }
+  if (!Array.isArray(obj.steps)) {
+    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") {
+      throw new Error(
+        `Invalid step at index ${i}: "type" must be "vibrate" or "pause"`
+      );
+    }
+    if (typeof step.duration !== "number" || step.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) {
+      throw new Error(
+        `Invalid step at index ${i}: "intensity" must be a number between 0 and 1`
+      );
+    }
+  }
+}
+function importPattern(data) {
+  const parsed = typeof data === "string" ? JSON.parse(data) : data;
+  validateExport(parsed);
+  const pattern = {
+    name: parsed.name,
+    steps: parsed.steps.map((s) => ({ ...s }))
+  };
+  if (parsed.metadata) {
+    pattern.metadata = { ...parsed.metadata };
+  }
+  return pattern;
+}
+function patternToJSON(input, options = {}) {
+  const exported = exportPattern(input, options);
+  return JSON.stringify(exported, null, 2);
+}
+function patternFromJSON(json) {
+  return importPattern(json);
+}
+function patternToDataURL(input, options = {}) {
+  const json = patternToJSON(input, options);
+  const encoded = btoa(json);
+  return `data:application/haptic+json;base64,${encoded}`;
+}
+function patternFromDataURL(url) {
+  const prefix = "data:application/haptic+json;base64,";
+  if (!url.startsWith(prefix)) {
+    throw new Error(
+      'Invalid haptic data URL: expected "data:application/haptic+json;base64," prefix'
+    );
+  }
+  const encoded = url.slice(prefix.length);
+  const json = atob(encoded);
+  return patternFromJSON(json);
+}
+
 // src/presets/ui.ts
 var ui = {
   /** Light button tap */
   tap: {
     name: "ui.tap",
-    steps: [{ type: "vibrate", duration: 10, intensity: 0.6 }]
+    steps: [{ type: "vibrate", duration: 30, intensity: 0.6 }]
   },
   /** Double tap */
   doubleTap: {
     name: "ui.doubleTap",
     steps: [
-      { type: "vibrate", duration: 10, intensity: 0.6 },
+      { type: "vibrate", duration: 25, intensity: 0.6 },
       { type: "pause", duration: 80, intensity: 0 },
-      { type: "vibrate", duration: 10, intensity: 0.6 }
+      { type: "vibrate", duration: 25, intensity: 0.6 }
     ]
   },
   /** Long press acknowledgment */
@@ -811,58 +1022,58 @@ var ui = {
   /** Toggle switch on */
   toggleOn: {
     name: "ui.toggleOn",
-    steps: [{ type: "vibrate", duration: 15, intensity: 0.6 }]
+    steps: [{ type: "vibrate", duration: 30, intensity: 0.6 }]
   },
   /** Toggle switch off */
   toggleOff: {
     name: "ui.toggleOff",
-    steps: [{ type: "vibrate", duration: 10, intensity: 0.3 }]
+    steps: [{ type: "vibrate", duration: 25, intensity: 0.4 }]
   },
   /** Slider snap to value */
   sliderSnap: {
     name: "ui.sliderSnap",
-    steps: [{ type: "vibrate", duration: 5, intensity: 0.4 }]
+    steps: [{ type: "vibrate", duration: 25, intensity: 0.5 }]
   },
   /** Selection changed */
   selection: {
     name: "ui.selection",
-    steps: [{ type: "vibrate", duration: 8, intensity: 0.4 }]
+    steps: [{ type: "vibrate", duration: 25, intensity: 0.5 }]
   },
   /** Pull to refresh threshold reached */
   pullToRefresh: {
     name: "ui.pullToRefresh",
     steps: [
-      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 40, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.7 }
+      { type: "vibrate", duration: 40, intensity: 0.7 }
     ]
   },
   /** Swipe action triggered */
   swipe: {
     name: "ui.swipe",
     steps: [
-      { type: "vibrate", duration: 12, intensity: 0.4 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 30, intensity: 0 },
-      { type: "vibrate", duration: 8, intensity: 0.3 }
+      { type: "vibrate", duration: 25, intensity: 0.4 }
     ]
   },
   /** Context menu appearance */
   contextMenu: {
     name: "ui.contextMenu",
-    steps: [{ type: "vibrate", duration: 20, intensity: 0.7 }]
+    steps: [{ type: "vibrate", duration: 35, intensity: 0.7 }]
   },
   /** Drag start */
   dragStart: {
     name: "ui.dragStart",
-    steps: [{ type: "vibrate", duration: 12, intensity: 0.5 }]
+    steps: [{ type: "vibrate", duration: 30, intensity: 0.5 }]
   },
   /** Drag drop */
   drop: {
     name: "ui.drop",
     steps: [
-      { type: "vibrate", duration: 20, intensity: 0.8 },
+      { type: "vibrate", duration: 30, intensity: 0.8 },
       { type: "pause", duration: 30, intensity: 0 },
-      { type: "vibrate", duration: 10, intensity: 0.4 }
+      { type: "vibrate", duration: 25, intensity: 0.5 }
     ]
   }
 };
@@ -873,9 +1084,9 @@ var notifications = {
   success: {
     name: "notifications.success",
     steps: [
-      { type: "vibrate", duration: 30, intensity: 0.5 },
+      { type: "vibrate", duration: 35, intensity: 0.5 },
       { type: "pause", duration: 60, intensity: 0 },
-      { type: "vibrate", duration: 40, intensity: 0.8 }
+      { type: "vibrate", duration: 45, intensity: 0.8 }
     ]
   },
   /** Warning — three even pulses */
@@ -902,16 +1113,16 @@ var notifications = {
   info: {
     name: "notifications.info",
     steps: [
-      { type: "vibrate", duration: 20, intensity: 0.4 }
+      { type: "vibrate", duration: 35, intensity: 0.5 }
     ]
   },
   /** Message received */
   messageReceived: {
     name: "notifications.messageReceived",
     steps: [
-      { type: "vibrate", duration: 15, intensity: 0.5 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 100, intensity: 0 },
-      { type: "vibrate", duration: 15, intensity: 0.5 }
+      { type: "vibrate", duration: 30, intensity: 0.5 }
     ]
   },
   /** Alarm — urgent repeating pattern */
@@ -935,9 +1146,9 @@ var notifications = {
   reminder: {
     name: "notifications.reminder",
     steps: [
-      { type: "vibrate", duration: 25, intensity: 0.5 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 150, intensity: 0 },
-      { type: "vibrate", duration: 25, intensity: 0.5 }
+      { type: "vibrate", duration: 30, intensity: 0.5 }
     ]
   }
 };
@@ -951,26 +1162,25 @@ var gaming = {
       { type: "vibrate", duration: 100, intensity: 1 },
       { type: "vibrate", duration: 80, intensity: 0.8 },
       { type: "vibrate", duration: 60, intensity: 0.5 },
-      { type: "vibrate", duration: 40, intensity: 0.3 },
-      { type: "vibrate", duration: 30, intensity: 0.1 }
+      { type: "vibrate", duration: 40, intensity: 0.3 }
     ]
   },
   /** Collision — sharp impact */
   collision: {
     name: "gaming.collision",
     steps: [
-      { type: "vibrate", duration: 30, intensity: 1 },
-      { type: "pause", duration: 20, intensity: 0 },
-      { type: "vibrate", duration: 15, intensity: 0.5 }
+      { type: "vibrate", duration: 40, intensity: 1 },
+      { type: "pause", duration: 30, intensity: 0 },
+      { type: "vibrate", duration: 25, intensity: 0.5 }
     ]
   },
   /** Heartbeat — rhythmic pulse */
   heartbeat: {
     name: "gaming.heartbeat",
     steps: [
-      { type: "vibrate", duration: 20, intensity: 0.8 },
+      { type: "vibrate", duration: 30, intensity: 0.8 },
       { type: "pause", duration: 80, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 1 },
+      { type: "vibrate", duration: 40, intensity: 1 },
       { type: "pause", duration: 400, intensity: 0 }
     ]
   },
@@ -978,17 +1188,17 @@ var gaming = {
   gunshot: {
     name: "gaming.gunshot",
     steps: [
-      { type: "vibrate", duration: 15, intensity: 1 },
-      { type: "vibrate", duration: 30, intensity: 0.4 }
+      { type: "vibrate", duration: 30, intensity: 1 },
+      { type: "vibrate", duration: 40, intensity: 0.4 }
     ]
   },
   /** Sword clash — metallic ring */
   swordClash: {
     name: "gaming.swordClash",
     steps: [
-      { type: "vibrate", duration: 10, intensity: 1 },
-      { type: "pause", duration: 10, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.6 },
+      { type: "vibrate", duration: 25, intensity: 1 },
+      { type: "pause", duration: 20, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.6 },
       { type: "vibrate", duration: 50, intensity: 0.3 }
     ]
   },
@@ -996,10 +1206,10 @@ var gaming = {
   powerUp: {
     name: "gaming.powerUp",
     steps: [
-      { type: "vibrate", duration: 40, intensity: 0.2 },
-      { type: "vibrate", duration: 40, intensity: 0.4 },
-      { type: "vibrate", duration: 40, intensity: 0.6 },
-      { type: "vibrate", duration: 40, intensity: 0.8 },
+      { type: "vibrate", duration: 40, intensity: 0.3 },
+      { type: "vibrate", duration: 40, intensity: 0.5 },
+      { type: "vibrate", duration: 40, intensity: 0.7 },
+      { type: "vibrate", duration: 40, intensity: 0.9 },
       { type: "vibrate", duration: 60, intensity: 1 }
     ]
   },
@@ -1007,46 +1217,46 @@ var gaming = {
   damage: {
     name: "gaming.damage",
     steps: [
-      { type: "vibrate", duration: 40, intensity: 0.9 },
-      { type: "pause", duration: 20, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.6 },
-      { type: "pause", duration: 20, intensity: 0 },
-      { type: "vibrate", duration: 20, intensity: 0.3 }
+      { type: "vibrate", duration: 50, intensity: 0.9 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.6 },
+      { type: "pause", duration: 25, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.4 }
     ]
   },
   /** Item pickup — light cheerful */
   pickup: {
     name: "gaming.pickup",
     steps: [
-      { type: "vibrate", duration: 10, intensity: 0.3 },
+      { type: "vibrate", duration: 25, intensity: 0.4 },
       { type: "pause", duration: 40, intensity: 0 },
-      { type: "vibrate", duration: 15, intensity: 0.6 }
+      { type: "vibrate", duration: 30, intensity: 0.7 }
     ]
   },
   /** Level complete — celebratory */
   levelComplete: {
     name: "gaming.levelComplete",
     steps: [
-      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 60, intensity: 0 },
-      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 60, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.7 },
+      { type: "vibrate", duration: 40, intensity: 0.7 },
       { type: "pause", duration: 60, intensity: 0 },
-      { type: "vibrate", duration: 50, intensity: 1 }
+      { type: "vibrate", duration: 60, intensity: 1 }
     ]
   },
   /** Engine rumble — continuous vibration */
   engineRumble: {
     name: "gaming.engineRumble",
     steps: [
-      { type: "vibrate", duration: 30, intensity: 0.4 },
-      { type: "pause", duration: 10, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.5 },
-      { type: "pause", duration: 10, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.4 },
-      { type: "pause", duration: 10, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.5 }
+      { type: "vibrate", duration: 40, intensity: 0.5 },
+      { type: "pause", duration: 15, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.6 },
+      { type: "pause", duration: 15, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.5 },
+      { type: "pause", duration: 15, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.6 }
     ]
   }
 };
@@ -1057,9 +1267,9 @@ var accessibility = {
   confirm: {
     name: "accessibility.confirm",
     steps: [
-      { type: "vibrate", duration: 30, intensity: 0.7 },
+      { type: "vibrate", duration: 35, intensity: 0.7 },
       { type: "pause", duration: 100, intensity: 0 },
-      { type: "vibrate", duration: 30, intensity: 0.7 }
+      { type: "vibrate", duration: 35, intensity: 0.7 }
     ]
   },
   /** Deny/reject — long single buzz */
@@ -1073,41 +1283,41 @@ var accessibility = {
   boundary: {
     name: "accessibility.boundary",
     steps: [
-      { type: "vibrate", duration: 15, intensity: 1 }
+      { type: "vibrate", duration: 30, intensity: 1 }
     ]
   },
   /** Focus change — subtle tick */
   focusChange: {
     name: "accessibility.focusChange",
     steps: [
-      { type: "vibrate", duration: 5, intensity: 0.3 }
+      { type: "vibrate", duration: 25, intensity: 0.5 }
     ]
   },
   /** Counting rhythm — one tick per count */
   countTick: {
     name: "accessibility.countTick",
     steps: [
-      { type: "vibrate", duration: 8, intensity: 0.5 }
+      { type: "vibrate", duration: 25, intensity: 0.5 }
     ]
   },
   /** Navigation landmark reached */
   landmark: {
     name: "accessibility.landmark",
     steps: [
-      { type: "vibrate", duration: 15, intensity: 0.6 },
+      { type: "vibrate", duration: 25, intensity: 0.6 },
       { type: "pause", duration: 40, intensity: 0 },
-      { type: "vibrate", duration: 15, intensity: 0.6 },
+      { type: "vibrate", duration: 25, intensity: 0.6 },
       { type: "pause", duration: 40, intensity: 0 },
-      { type: "vibrate", duration: 15, intensity: 0.6 }
+      { type: "vibrate", duration: 25, intensity: 0.6 }
     ]
   },
   /** Progress checkpoint — escalating feedback */
   progressCheckpoint: {
     name: "accessibility.progressCheckpoint",
     steps: [
-      { type: "vibrate", duration: 20, intensity: 0.4 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 60, intensity: 0 },
-      { type: "vibrate", duration: 25, intensity: 0.7 }
+      { type: "vibrate", duration: 35, intensity: 0.7 }
     ]
   }
 };
@@ -1117,51 +1327,51 @@ var system = {
   /** Keyboard key press */
   keyPress: {
     name: "system.keyPress",
-    steps: [{ type: "vibrate", duration: 5, intensity: 0.3 }]
+    steps: [{ type: "vibrate", duration: 25, intensity: 0.5 }]
   },
   /** Scroll tick (detent-like) */
   scrollTick: {
     name: "system.scrollTick",
-    steps: [{ type: "vibrate", duration: 3, intensity: 0.2 }]
+    steps: [{ type: "vibrate", duration: 20, intensity: 0.4 }]
   },
   /** Scroll boundary reached */
   scrollBounce: {
     name: "system.scrollBounce",
     steps: [
-      { type: "vibrate", duration: 10, intensity: 0.5 },
-      { type: "vibrate", duration: 20, intensity: 0.3 }
+      { type: "vibrate", duration: 25, intensity: 0.6 },
+      { type: "vibrate", duration: 30, intensity: 0.4 }
     ]
   },
   /** Delete action */
   delete: {
     name: "system.delete",
     steps: [
-      { type: "vibrate", duration: 15, intensity: 0.5 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 50, intensity: 0 },
-      { type: "vibrate", duration: 25, intensity: 0.8 }
+      { type: "vibrate", duration: 40, intensity: 0.8 }
     ]
   },
   /** Undo action */
   undo: {
     name: "system.undo",
     steps: [
-      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "vibrate", duration: 30, intensity: 0.5 },
       { type: "pause", duration: 80, intensity: 0 },
-      { type: "vibrate", duration: 10, intensity: 0.3 }
+      { type: "vibrate", duration: 25, intensity: 0.4 }
     ]
   },
   /** Copy to clipboard */
   copy: {
     name: "system.copy",
-    steps: [{ type: "vibrate", duration: 12, intensity: 0.4 }]
+    steps: [{ type: "vibrate", duration: 30, intensity: 0.5 }]
   },
   /** Paste from clipboard */
   paste: {
     name: "system.paste",
     steps: [
-      { type: "vibrate", duration: 8, intensity: 0.3 },
+      { type: "vibrate", duration: 25, intensity: 0.4 },
       { type: "pause", duration: 30, intensity: 0 },
-      { type: "vibrate", duration: 12, intensity: 0.5 }
+      { type: "vibrate", duration: 30, intensity: 0.6 }
     ]
   }
 };
@@ -1184,6 +1394,7 @@ exports.HPLParser = HPLParser;
 exports.HPLParserError = HPLParserError;
 exports.HPLTokenizerError = HPLTokenizerError;
 exports.HapticEngine = HapticEngine;
+exports.IoSAudioAdapter = IoSAudioAdapter;
 exports.NoopAdapter = NoopAdapter;
 exports.PatternComposer = PatternComposer;
 exports.WebVibrationAdapter = WebVibrationAdapter;
@@ -1191,11 +1402,17 @@ exports.accessibility = accessibility;
 exports.compile = compile;
 exports.detectAdapter = detectAdapter;
 exports.detectPlatform = detectPlatform;
+exports.exportPattern = exportPattern;
 exports.gaming = gaming;
 exports.haptic = haptic;
+exports.importPattern = importPattern;
 exports.notifications = notifications;
 exports.optimizeSteps = optimizeSteps;
 exports.parseHPL = parseHPL;
+exports.patternFromDataURL = patternFromDataURL;
+exports.patternFromJSON = patternFromJSON;
+exports.patternToDataURL = patternToDataURL;
+exports.patternToJSON = patternToJSON;
 exports.presets = presets;
 exports.system = system;
 exports.tokenize = tokenize;