@hapticjs/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1181 @@
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  intensity: 1,
+  enabled: true,
+  fallback: { type: "none" },
+  respectSystemSettings: true
+};
+
+// src/adapters/noop.adapter.ts
+var NoopAdapter = class {
+  constructor() {
+    this.name = "noop";
+    this.supported = false;
+  }
+  capabilities() {
+    return {
+      maxIntensityLevels: 0,
+      minDuration: 0,
+      maxDuration: 0,
+      supportsPattern: false,
+      supportsIntensity: false,
+      dualMotor: false
+    };
+  }
+  async pulse(_intensity, _duration) {
+  }
+  async playSequence(_steps) {
+  }
+  cancel() {
+  }
+  dispose() {
+  }
+};
+
+// src/utils/scheduling.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function normalizeIntensity(intensity) {
+  return clamp(intensity, 0, 1);
+}
+
+// src/adapters/web-vibration.adapter.ts
+var WebVibrationAdapter = class {
+  constructor() {
+    this.name = "web-vibration";
+    this._cancelled = false;
+    this.supported = typeof navigator !== "undefined" && "vibrate" in navigator;
+  }
+  capabilities() {
+    return {
+      maxIntensityLevels: 1,
+      // on/off only
+      minDuration: 10,
+      maxDuration: 1e4,
+      supportsPattern: true,
+      supportsIntensity: false,
+      dualMotor: false
+    };
+  }
+  async pulse(_intensity, duration) {
+    if (!this.supported) return;
+    navigator.vibrate(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);
+        }
+      } else {
+        await delay(step.duration);
+      }
+    }
+  }
+  cancel() {
+    this._cancelled = true;
+    if (this.supported) {
+      navigator.vibrate(0);
+    }
+  }
+  dispose() {
+    this.cancel();
+  }
+  /** Convert steps to Vibration API pattern array */
+  _toVibrationPattern(steps) {
+    const pattern = [];
+    for (const step of steps) {
+      pattern.push(step.duration);
+    }
+    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
+    );
+  }
+  /** 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);
+    }
+    if (pattern.length > 0) {
+      navigator.vibrate(pattern);
+      await delay(duration);
+    }
+  }
+};
+
+// src/utils/platform.ts
+function detectPlatform() {
+  const isWeb = typeof window !== "undefined" && typeof document !== "undefined";
+  const isNode = typeof globalThis !== "undefined" && typeof globalThis.process === "object" && typeof globalThis.process?.versions === "object";
+  const isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+  const hasVibrationAPI = isWeb && "vibrate" in navigator;
+  const hasGamepadAPI = isWeb && "getGamepads" in navigator;
+  const ua = isWeb ? navigator.userAgent : "";
+  const isIOS = /iPad|iPhone|iPod/.test(ua) || isWeb && navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+  const isAndroid = /Android/.test(ua);
+  const isMobile = isIOS || isAndroid;
+  return {
+    isWeb,
+    isNode,
+    isReactNative,
+    hasVibrationAPI,
+    hasGamepadAPI,
+    isIOS,
+    isAndroid,
+    isMobile
+  };
+}
+
+// src/engine/capability-detector.ts
+function detectAdapter() {
+  const platform = detectPlatform();
+  if (platform.hasVibrationAPI) {
+    return new WebVibrationAdapter();
+  }
+  return new NoopAdapter();
+}
+
+// src/engine/adaptive-engine.ts
+var AdaptiveEngine = class {
+  adapt(steps, capabilities) {
+    return steps.map((step) => this._adaptStep(step, capabilities));
+  }
+  _adaptStep(step, caps) {
+    const adapted = { ...step };
+    if (adapted.type === "vibrate") {
+      adapted.duration = clamp(adapted.duration, caps.minDuration, caps.maxDuration);
+    }
+    if (!caps.supportsIntensity && adapted.type === "vibrate") {
+      adapted.intensity = adapted.intensity > 0.1 ? 1 : 0;
+    } else if (caps.maxIntensityLevels > 1 && caps.maxIntensityLevels < 100) {
+      const levels = caps.maxIntensityLevels;
+      adapted.intensity = Math.round(adapted.intensity * levels) / levels;
+    }
+    return adapted;
+  }
+};
+
+// src/engine/fallback-manager.ts
+var FallbackManager = class {
+  constructor(config) {
+    this.config = config;
+  }
+  updateConfig(config) {
+    this.config = config;
+  }
+  /** 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 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);
+    }
+    if (this.config.type === "audio" || this.config.type === "both") {
+      await this._audioFallback(totalDuration, maxIntensity);
+    }
+  }
+  async _visualFallback(duration, intensity) {
+    const visual = this.config.visual;
+    if (!visual || typeof document === "undefined") return;
+    const element = visual.element ?? document.body;
+    const style = visual.style ?? "pulse";
+    const className = visual.className;
+    if (className) {
+      element.classList.add(className);
+      setTimeout(() => element.classList.remove(className), duration);
+      return;
+    }
+    switch (style) {
+      case "flash": {
+        const opacity = 0.1 + intensity * 0.3;
+        const overlay = document.createElement("div");
+        Object.assign(overlay.style, {
+          position: "fixed",
+          inset: "0",
+          backgroundColor: `rgba(0, 0, 0, ${opacity})`,
+          pointerEvents: "none",
+          zIndex: "99999",
+          transition: `opacity ${duration}ms ease-out`
+        });
+        document.body.appendChild(overlay);
+        requestAnimationFrame(() => {
+          overlay.style.opacity = "0";
+        });
+        setTimeout(() => overlay.remove(), duration + 100);
+        break;
+      }
+      case "shake": {
+        const magnitude = Math.round(intensity * 5);
+        element.style.transition = "none";
+        element.style.transform = `translateX(${magnitude}px)`;
+        setTimeout(() => {
+          element.style.transition = `transform ${duration}ms ease-out`;
+          element.style.transform = "";
+        }, 50);
+        break;
+      }
+      case "pulse": {
+        const scale = 1 + intensity * 0.02;
+        element.style.transition = `transform ${duration}ms ease-out`;
+        element.style.transform = `scale(${scale})`;
+        setTimeout(() => {
+          element.style.transform = "";
+        }, duration);
+        break;
+      }
+    }
+  }
+  async _audioFallback(duration, intensity) {
+    const audio = this.config.audio;
+    if (!audio?.enabled || typeof AudioContext === "undefined") return;
+    try {
+      const ctx = new AudioContext();
+      const oscillator = ctx.createOscillator();
+      const gainNode = ctx.createGain();
+      oscillator.connect(gainNode);
+      gainNode.connect(ctx.destination);
+      oscillator.frequency.value = 200 + intensity * 200;
+      gainNode.gain.value = audio.volume * intensity * 0.1;
+      oscillator.start();
+      oscillator.stop(ctx.currentTime + duration / 1e3);
+      await new Promise((resolve) => {
+        oscillator.onended = () => {
+          ctx.close();
+          resolve();
+        };
+      });
+    } catch {
+    }
+  }
+};
+
+// src/composer/pattern-composer.ts
+var PatternComposer = class {
+  constructor() {
+    this.steps = [];
+  }
+  /** Register a play callback (used by HapticEngine) */
+  onPlay(fn) {
+    this._onPlay = fn;
+    return this;
+  }
+  /** Add a short tap vibration */
+  tap(intensity = 0.6) {
+    this.steps.push({ type: "vibrate", duration: 10, intensity });
+    return this;
+  }
+  /** Add a vibration with specified duration and intensity */
+  vibrate(duration, intensity = 1) {
+    this.steps.push({ type: "vibrate", duration, intensity });
+    return this;
+  }
+  /** Add a buzz (medium-length vibration) */
+  buzz(duration = 100, intensity = 0.7) {
+    this.steps.push({ type: "vibrate", duration, intensity });
+    return this;
+  }
+  /** Add a pause */
+  pause(duration = 50) {
+    this.steps.push({ type: "pause", duration, intensity: 0 });
+    return this;
+  }
+  /** Add an intensity ramp from start to end intensity over duration */
+  ramp(startIntensity, endIntensity, duration, easing = "linear") {
+    const stepCount = Math.max(1, Math.floor(duration / 20));
+    const stepDuration = duration / stepCount;
+    for (let i = 0; i < stepCount; i++) {
+      const t = i / (stepCount - 1 || 1);
+      const easedT = applyEasing(t, easing);
+      const intensity = startIntensity + (endIntensity - startIntensity) * easedT;
+      this.steps.push({ type: "vibrate", duration: stepDuration, intensity });
+    }
+    return this;
+  }
+  /** Add a pulse pattern (on-off-on-off) */
+  pulse(count, onDuration = 50, offDuration = 50, intensity = 0.8) {
+    for (let i = 0; i < count; i++) {
+      this.steps.push({ type: "vibrate", duration: onDuration, intensity });
+      if (i < count - 1) {
+        this.steps.push({ type: "pause", duration: offDuration, intensity: 0 });
+      }
+    }
+    return this;
+  }
+  /** Repeat the entire current sequence N times */
+  repeat(times) {
+    const original = [...this.steps];
+    for (let i = 1; i < times; i++) {
+      this.steps.push(...original.map((s) => ({ ...s })));
+    }
+    return this;
+  }
+  /** Build and return the step array */
+  build() {
+    return [...this.steps];
+  }
+  /** Build and immediately play the pattern */
+  async play() {
+    if (this._onPlay) {
+      await this._onPlay(this.steps);
+    }
+  }
+  /** Reset the composer */
+  clear() {
+    this.steps = [];
+    return this;
+  }
+  /** Get total duration in ms */
+  get duration() {
+    return this.steps.reduce((sum, s) => sum + s.duration, 0);
+  }
+};
+function applyEasing(t, easing) {
+  switch (easing) {
+    case "linear":
+      return t;
+    case "ease-in":
+      return t * t;
+    case "ease-out":
+      return t * (2 - t);
+    case "ease-in-out":
+      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+  }
+}
+
+// src/patterns/tokenizer.ts
+var TOKEN_MAP = {
+  "~": "LIGHT",
+  "#": "MEDIUM",
+  "@": "HEAVY",
+  ".": "PAUSE",
+  "|": "TAP",
+  "-": "SUSTAIN",
+  "[": "GROUP_START",
+  "]": "GROUP_END"
+};
+var HPLTokenizerError = class extends Error {
+  constructor(message, position) {
+    super(`HPL Tokenizer Error at position ${position}: ${message}`);
+    this.position = position;
+    this.name = "HPLTokenizerError";
+  }
+};
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (char === " " || char === "	" || char === "\n") {
+      i++;
+      continue;
+    }
+    if (char === "x" && i + 1 < input.length) {
+      let numStr = "";
+      let j = i + 1;
+      while (j < input.length && input[j] >= "0" && input[j] <= "9") {
+        numStr += input[j];
+        j++;
+      }
+      if (numStr.length > 0) {
+        tokens.push({
+          type: "REPEAT",
+          value: `x${numStr}`,
+          repeatCount: parseInt(numStr, 10)
+        });
+        i = j;
+        continue;
+      }
+    }
+    const tokenType = TOKEN_MAP[char];
+    if (tokenType) {
+      tokens.push({ type: tokenType, value: char });
+      i++;
+      continue;
+    }
+    throw new HPLTokenizerError(`Unexpected character '${char}'`, i);
+  }
+  return tokens;
+}
+
+// src/patterns/parser.ts
+var UNIT_DURATION = 50;
+var TAP_DURATION = 10;
+var INTENSITY_MAP = {
+  LIGHT: 0.3,
+  MEDIUM: 0.6,
+  HEAVY: 1
+};
+var HPLParserError = class extends Error {
+  constructor(message) {
+    super(`HPL Parser Error: ${message}`);
+    this.name = "HPLParserError";
+  }
+};
+var HPLParser = class {
+  constructor() {
+    this.tokens = [];
+    this.pos = 0;
+  }
+  parse(input) {
+    this.tokens = tokenize(input);
+    this.pos = 0;
+    if (this.tokens.length === 0) {
+      return { type: "sequence", children: [] };
+    }
+    const children = this._parseSegments();
+    if (this.pos < this.tokens.length) {
+      throw new HPLParserError(
+        `Unexpected token '${this.tokens[this.pos].value}' at position ${this.pos}`
+      );
+    }
+    return { type: "sequence", children };
+  }
+  _parseSegments() {
+    const nodes = [];
+    while (this.pos < this.tokens.length) {
+      const token = this.tokens[this.pos];
+      if (token.type === "GROUP_END") {
+        break;
+      }
+      nodes.push(this._parseSegment());
+    }
+    return nodes;
+  }
+  _parseSegment() {
+    const token = this.tokens[this.pos];
+    if (token.type === "GROUP_START") {
+      return this._parseGroup();
+    }
+    return this._parseAtom();
+  }
+  _parseGroup() {
+    this.pos++;
+    const children = this._parseSegments();
+    if (this.pos >= this.tokens.length || this.tokens[this.pos].type !== "GROUP_END") {
+      throw new HPLParserError('Unclosed group \u2014 expected "]"');
+    }
+    this.pos++;
+    let repeat = 1;
+    if (this.pos < this.tokens.length && this.tokens[this.pos].type === "REPEAT") {
+      repeat = this.tokens[this.pos].repeatCount ?? 1;
+      this.pos++;
+    }
+    return { type: "group", children, repeat };
+  }
+  _parseAtom() {
+    const token = this.tokens[this.pos];
+    this.pos++;
+    switch (token.type) {
+      case "LIGHT":
+      case "MEDIUM":
+      case "HEAVY":
+        return this._makeVibrate(token.type);
+      case "PAUSE":
+        return this._makePause();
+      case "TAP":
+        return this._makeTap();
+      case "SUSTAIN":
+        return this._makeSustain();
+      default:
+        throw new HPLParserError(`Unexpected token type '${token.type}'`);
+    }
+  }
+  _makeVibrate(level) {
+    return {
+      type: "vibrate",
+      intensity: INTENSITY_MAP[level] ?? 0.5,
+      duration: UNIT_DURATION
+    };
+  }
+  _makePause() {
+    return { type: "pause", duration: UNIT_DURATION };
+  }
+  _makeTap() {
+    return { type: "tap", duration: TAP_DURATION, intensity: 1 };
+  }
+  _makeSustain() {
+    return { type: "sustain", extension: UNIT_DURATION };
+  }
+};
+function parseHPL(input) {
+  const parser = new HPLParser();
+  return parser.parse(input);
+}
+
+// src/patterns/compiler.ts
+function compile(ast) {
+  const raw = compileNode(ast);
+  return mergeSustains(raw);
+}
+function compileNode(node) {
+  switch (node.type) {
+    case "vibrate":
+      return [{ type: "vibrate", duration: node.duration, intensity: node.intensity }];
+    case "pause":
+      return [{ type: "pause", duration: node.duration, intensity: 0 }];
+    case "tap":
+      return [{ type: "vibrate", duration: node.duration, intensity: node.intensity }];
+    case "sustain":
+      return [{ type: "vibrate", duration: node.extension, intensity: -1 }];
+    // sentinel
+    case "group": {
+      const groupSteps = node.children.flatMap(compileNode);
+      const result = [];
+      for (let i = 0; i < node.repeat; i++) {
+        result.push(...groupSteps.map((s) => ({ ...s })));
+      }
+      return result;
+    }
+    case "sequence":
+      return node.children.flatMap(compileNode);
+  }
+}
+function mergeSustains(steps) {
+  const result = [];
+  for (const step of steps) {
+    if (step.intensity === -1 && result.length > 0) {
+      const prev = result[result.length - 1];
+      prev.duration += step.duration;
+    } else {
+      result.push({ ...step });
+    }
+  }
+  return result;
+}
+function optimizeSteps(steps) {
+  if (steps.length === 0) return [];
+  const result = [{ ...steps[0] }];
+  for (let i = 1; i < steps.length; i++) {
+    const current = steps[i];
+    const prev = result[result.length - 1];
+    if (current.type === "pause" && prev.type === "pause") {
+      prev.duration += current.duration;
+      continue;
+    }
+    if (current.type === "vibrate" && prev.type === "vibrate" && Math.abs(current.intensity - prev.intensity) < 0.01) {
+      prev.duration += current.duration;
+      continue;
+    }
+    result.push({ ...current });
+  }
+  return result;
+}
+
+// src/engine/haptic-engine.ts
+var HapticEngine = class _HapticEngine {
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.adapter = this.config.adapter ?? detectAdapter();
+    this.adaptive = new AdaptiveEngine();
+    this.fallback = new FallbackManager(this.config.fallback);
+  }
+  /** Create a new engine with auto-detected adapter */
+  static create(config) {
+    return new _HapticEngine(config);
+  }
+  // ─── Semantic API ──────────────────────────────────────────
+  /** Light tap feedback */
+  async tap(intensity = 0.6) {
+    await this._playSteps([{ type: "vibrate", duration: 10, intensity }]);
+  }
+  /** Double tap */
+  async doubleTap(intensity = 0.6) {
+    await this._playSteps([
+      { type: "vibrate", duration: 10, intensity },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 10, intensity }
+    ]);
+  }
+  /** Long press feedback */
+  async longPress(intensity = 0.8) {
+    await this._playSteps([{ type: "vibrate", duration: 50, intensity }]);
+  }
+  /** Success notification */
+  async success() {
+    await this._playSteps([
+      { type: "vibrate", duration: 30, intensity: 0.5 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.8 }
+    ]);
+  }
+  /** Warning notification */
+  async warning() {
+    await this._playSteps([
+      { type: "vibrate", duration: 40, intensity: 0.7 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.7 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.7 }
+    ]);
+  }
+  /** Error notification */
+  async error() {
+    await this._playSteps([
+      { type: "vibrate", duration: 80, intensity: 1 },
+      { type: "pause", duration: 100, intensity: 0 },
+      { type: "vibrate", duration: 80, intensity: 1 }
+    ]);
+  }
+  /** Selection change feedback */
+  async selection() {
+    await this._playSteps([{ type: "vibrate", duration: 8, intensity: 0.4 }]);
+  }
+  /** Toggle feedback */
+  async toggle(on) {
+    if (on) {
+      await this._playSteps([{ type: "vibrate", duration: 15, intensity: 0.6 }]);
+    } else {
+      await this._playSteps([{ type: "vibrate", duration: 10, intensity: 0.3 }]);
+    }
+  }
+  /** 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 }]
+    };
+    await this._playSteps(presets2[style]);
+  }
+  // ─── Parametric API ────────────────────────────────────────
+  /** Vibrate for a specified duration */
+  async vibrate(duration, intensity = 1) {
+    await this._playSteps([
+      { type: "vibrate", duration, intensity: normalizeIntensity(intensity) }
+    ]);
+  }
+  /**
+   * Play a haptic pattern.
+   * Accepts:
+   *   - HPL string: "~~..##..@@"
+   *   - HapticPattern object
+   *   - Raw HapticStep array
+   */
+  async play(pattern) {
+    let steps;
+    if (typeof pattern === "string") {
+      const ast = parseHPL(pattern);
+      steps = compile(ast);
+    } else if (Array.isArray(pattern)) {
+      steps = pattern;
+    } else {
+      steps = pattern.steps;
+    }
+    await this._playSteps(steps);
+  }
+  // ─── Composer ──────────────────────────────────────────────
+  /** Create a new pattern composer */
+  compose() {
+    const composer = new PatternComposer();
+    composer.onPlay((steps) => this._playSteps(steps));
+    return composer;
+  }
+  // ─── Configuration ─────────────────────────────────────────
+  /** Update engine configuration */
+  configure(config) {
+    Object.assign(this.config, config);
+    if (config.adapter) {
+      this.adapter = config.adapter;
+    }
+    if (config.fallback) {
+      this.fallback.updateConfig(this.config.fallback);
+    }
+  }
+  /** Check if haptics are supported on this device */
+  get isSupported() {
+    return this.adapter.supported;
+  }
+  /** Get the current adapter name */
+  get adapterName() {
+    return this.adapter.name;
+  }
+  // ─── Lifecycle ─────────────────────────────────────────────
+  /** Cancel any ongoing haptic effect */
+  cancel() {
+    this.adapter.cancel();
+  }
+  /** Clean up resources */
+  dispose() {
+    this.adapter.dispose();
+  }
+  // ─── Internal ──────────────────────────────────────────────
+  async _playSteps(steps) {
+    if (!this.config.enabled || steps.length === 0) return;
+    let adjusted = steps.map((s) => ({
+      ...s,
+      intensity: s.type === "vibrate" ? normalizeIntensity(s.intensity * this.config.intensity) : 0
+    }));
+    const caps = this.adapter.capabilities();
+    adjusted = this.adaptive.adapt(adjusted, caps);
+    adjusted = optimizeSteps(adjusted);
+    if (this.adapter.supported) {
+      await this.adapter.playSequence(adjusted);
+    } else {
+      await this.fallback.execute(adjusted);
+    }
+  }
+};
+
+// src/patterns/validator.ts
+var VALID_CHARS = new Set("~#@.|\\-[] 	\nx0123456789");
+function validateHPL(input) {
+  const errors = [];
+  if (input.length === 0) {
+    return { valid: true, errors: [] };
+  }
+  for (let i = 0; i < input.length; i++) {
+    if (!VALID_CHARS.has(input[i])) {
+      errors.push(`Invalid character '${input[i]}' at position ${i}`);
+    }
+  }
+  let depth = 0;
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] === "[") depth++;
+    if (input[i] === "]") depth--;
+    if (depth < 0) {
+      errors.push(`Unmatched ']' at position ${i}`);
+    }
+  }
+  if (depth > 0) {
+    errors.push(`${depth} unclosed '[' bracket(s)`);
+  }
+  for (let i = 0; i < input.length - 1; i++) {
+    if (input[i] === "[" && input[i + 1] === "]") {
+      errors.push(`Empty group at position ${i}`);
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] === "x" && i + 1 < input.length && /\d/.test(input[i + 1])) {
+      if (i === 0) {
+        errors.push(`Repeat modifier 'x' at position ${i} must follow a group or atom`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/presets/ui.ts
+var ui = {
+  /** Light button tap */
+  tap: {
+    name: "ui.tap",
+    steps: [{ type: "vibrate", duration: 10, intensity: 0.6 }]
+  },
+  /** Double tap */
+  doubleTap: {
+    name: "ui.doubleTap",
+    steps: [
+      { type: "vibrate", duration: 10, intensity: 0.6 },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 10, intensity: 0.6 }
+    ]
+  },
+  /** Long press acknowledgment */
+  longPress: {
+    name: "ui.longPress",
+    steps: [{ type: "vibrate", duration: 50, intensity: 0.8 }]
+  },
+  /** Toggle switch on */
+  toggleOn: {
+    name: "ui.toggleOn",
+    steps: [{ type: "vibrate", duration: 15, intensity: 0.6 }]
+  },
+  /** Toggle switch off */
+  toggleOff: {
+    name: "ui.toggleOff",
+    steps: [{ type: "vibrate", duration: 10, intensity: 0.3 }]
+  },
+  /** Slider snap to value */
+  sliderSnap: {
+    name: "ui.sliderSnap",
+    steps: [{ type: "vibrate", duration: 5, intensity: 0.4 }]
+  },
+  /** Selection changed */
+  selection: {
+    name: "ui.selection",
+    steps: [{ type: "vibrate", duration: 8, intensity: 0.4 }]
+  },
+  /** Pull to refresh threshold reached */
+  pullToRefresh: {
+    name: "ui.pullToRefresh",
+    steps: [
+      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.7 }
+    ]
+  },
+  /** Swipe action triggered */
+  swipe: {
+    name: "ui.swipe",
+    steps: [
+      { type: "vibrate", duration: 12, intensity: 0.4 },
+      { type: "pause", duration: 30, intensity: 0 },
+      { type: "vibrate", duration: 8, intensity: 0.3 }
+    ]
+  },
+  /** Context menu appearance */
+  contextMenu: {
+    name: "ui.contextMenu",
+    steps: [{ type: "vibrate", duration: 20, intensity: 0.7 }]
+  },
+  /** Drag start */
+  dragStart: {
+    name: "ui.dragStart",
+    steps: [{ type: "vibrate", duration: 12, intensity: 0.5 }]
+  },
+  /** Drag drop */
+  drop: {
+    name: "ui.drop",
+    steps: [
+      { type: "vibrate", duration: 20, intensity: 0.8 },
+      { type: "pause", duration: 30, intensity: 0 },
+      { type: "vibrate", duration: 10, intensity: 0.4 }
+    ]
+  }
+};
+
+// src/presets/notifications.ts
+var notifications = {
+  /** Success — two ascending pulses */
+  success: {
+    name: "notifications.success",
+    steps: [
+      { type: "vibrate", duration: 30, intensity: 0.5 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.8 }
+    ]
+  },
+  /** Warning — three even pulses */
+  warning: {
+    name: "notifications.warning",
+    steps: [
+      { type: "vibrate", duration: 40, intensity: 0.7 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.7 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 40, intensity: 0.7 }
+    ]
+  },
+  /** Error — two heavy pulses */
+  error: {
+    name: "notifications.error",
+    steps: [
+      { type: "vibrate", duration: 80, intensity: 1 },
+      { type: "pause", duration: 100, intensity: 0 },
+      { type: "vibrate", duration: 80, intensity: 1 }
+    ]
+  },
+  /** Info — soft single pulse */
+  info: {
+    name: "notifications.info",
+    steps: [
+      { type: "vibrate", duration: 20, intensity: 0.4 }
+    ]
+  },
+  /** Message received */
+  messageReceived: {
+    name: "notifications.messageReceived",
+    steps: [
+      { type: "vibrate", duration: 15, intensity: 0.5 },
+      { type: "pause", duration: 100, intensity: 0 },
+      { type: "vibrate", duration: 15, intensity: 0.5 }
+    ]
+  },
+  /** Alarm — urgent repeating pattern */
+  alarm: {
+    name: "notifications.alarm",
+    steps: [
+      { type: "vibrate", duration: 100, intensity: 1 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 100, intensity: 1 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 100, intensity: 1 },
+      { type: "pause", duration: 200, intensity: 0 },
+      { type: "vibrate", duration: 100, intensity: 1 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 100, intensity: 1 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 100, intensity: 1 }
+    ]
+  },
+  /** Reminder — gentle nudge */
+  reminder: {
+    name: "notifications.reminder",
+    steps: [
+      { type: "vibrate", duration: 25, intensity: 0.5 },
+      { type: "pause", duration: 150, intensity: 0 },
+      { type: "vibrate", duration: 25, intensity: 0.5 }
+    ]
+  }
+};
+
+// src/presets/gaming.ts
+var gaming = {
+  /** Explosion — heavy descending */
+  explosion: {
+    name: "gaming.explosion",
+    steps: [
+      { 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 }
+    ]
+  },
+  /** 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 }
+    ]
+  },
+  /** Heartbeat — rhythmic pulse */
+  heartbeat: {
+    name: "gaming.heartbeat",
+    steps: [
+      { type: "vibrate", duration: 20, intensity: 0.8 },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 1 },
+      { type: "pause", duration: 400, intensity: 0 }
+    ]
+  },
+  /** Gunshot — sharp burst */
+  gunshot: {
+    name: "gaming.gunshot",
+    steps: [
+      { type: "vibrate", duration: 15, intensity: 1 },
+      { type: "vibrate", duration: 30, 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: 50, intensity: 0.3 }
+    ]
+  },
+  /** Power up — ascending intensity */
+  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: 60, intensity: 1 }
+    ]
+  },
+  /** Damage taken — heavy stutter */
+  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 }
+    ]
+  },
+  /** Item pickup — light cheerful */
+  pickup: {
+    name: "gaming.pickup",
+    steps: [
+      { type: "vibrate", duration: 10, intensity: 0.3 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 15, intensity: 0.6 }
+    ]
+  },
+  /** Level complete — celebratory */
+  levelComplete: {
+    name: "gaming.levelComplete",
+    steps: [
+      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.7 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 50, 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 }
+    ]
+  }
+};
+
+// src/presets/accessibility.ts
+var accessibility = {
+  /** Confirm action — clear double pulse */
+  confirm: {
+    name: "accessibility.confirm",
+    steps: [
+      { type: "vibrate", duration: 30, intensity: 0.7 },
+      { type: "pause", duration: 100, intensity: 0 },
+      { type: "vibrate", duration: 30, intensity: 0.7 }
+    ]
+  },
+  /** Deny/reject — long single buzz */
+  deny: {
+    name: "accessibility.deny",
+    steps: [
+      { type: "vibrate", duration: 200, intensity: 0.8 }
+    ]
+  },
+  /** Boundary reached (e.g., scroll limit, min/max value) */
+  boundary: {
+    name: "accessibility.boundary",
+    steps: [
+      { type: "vibrate", duration: 15, intensity: 1 }
+    ]
+  },
+  /** Focus change — subtle tick */
+  focusChange: {
+    name: "accessibility.focusChange",
+    steps: [
+      { type: "vibrate", duration: 5, intensity: 0.3 }
+    ]
+  },
+  /** Counting rhythm — one tick per count */
+  countTick: {
+    name: "accessibility.countTick",
+    steps: [
+      { type: "vibrate", duration: 8, intensity: 0.5 }
+    ]
+  },
+  /** Navigation landmark reached */
+  landmark: {
+    name: "accessibility.landmark",
+    steps: [
+      { type: "vibrate", duration: 15, intensity: 0.6 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 15, intensity: 0.6 },
+      { type: "pause", duration: 40, intensity: 0 },
+      { type: "vibrate", duration: 15, intensity: 0.6 }
+    ]
+  },
+  /** Progress checkpoint — escalating feedback */
+  progressCheckpoint: {
+    name: "accessibility.progressCheckpoint",
+    steps: [
+      { type: "vibrate", duration: 20, intensity: 0.4 },
+      { type: "pause", duration: 60, intensity: 0 },
+      { type: "vibrate", duration: 25, intensity: 0.7 }
+    ]
+  }
+};
+
+// src/presets/system.ts
+var system = {
+  /** Keyboard key press */
+  keyPress: {
+    name: "system.keyPress",
+    steps: [{ type: "vibrate", duration: 5, intensity: 0.3 }]
+  },
+  /** Scroll tick (detent-like) */
+  scrollTick: {
+    name: "system.scrollTick",
+    steps: [{ type: "vibrate", duration: 3, intensity: 0.2 }]
+  },
+  /** Scroll boundary reached */
+  scrollBounce: {
+    name: "system.scrollBounce",
+    steps: [
+      { type: "vibrate", duration: 10, intensity: 0.5 },
+      { type: "vibrate", duration: 20, intensity: 0.3 }
+    ]
+  },
+  /** Delete action */
+  delete: {
+    name: "system.delete",
+    steps: [
+      { type: "vibrate", duration: 15, intensity: 0.5 },
+      { type: "pause", duration: 50, intensity: 0 },
+      { type: "vibrate", duration: 25, intensity: 0.8 }
+    ]
+  },
+  /** Undo action */
+  undo: {
+    name: "system.undo",
+    steps: [
+      { type: "vibrate", duration: 20, intensity: 0.5 },
+      { type: "pause", duration: 80, intensity: 0 },
+      { type: "vibrate", duration: 10, intensity: 0.3 }
+    ]
+  },
+  /** Copy to clipboard */
+  copy: {
+    name: "system.copy",
+    steps: [{ type: "vibrate", duration: 12, intensity: 0.4 }]
+  },
+  /** Paste from clipboard */
+  paste: {
+    name: "system.paste",
+    steps: [
+      { type: "vibrate", duration: 8, intensity: 0.3 },
+      { type: "pause", duration: 30, intensity: 0 },
+      { type: "vibrate", duration: 12, intensity: 0.5 }
+    ]
+  }
+};
+
+// src/presets/index.ts
+var presets = {
+  ui,
+  notifications,
+  gaming,
+  accessibility,
+  system
+};
+
+// src/index.ts
+var haptic = HapticEngine.create();
+
+export { AdaptiveEngine, FallbackManager, HPLParser, HPLParserError, HPLTokenizerError, HapticEngine, NoopAdapter, PatternComposer, WebVibrationAdapter, accessibility, compile, detectAdapter, detectPlatform, gaming, haptic, notifications, optimizeSteps, parseHPL, presets, system, tokenize, ui, validateHPL };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map