@sarmal/core 0.25.1 → 0.27.0

package/dist/cli.js

@@ -0,0 +1,1048 @@
+#!/usr/bin/env node
+// src/engine.ts
+var TWO_PI = Math.PI * 2;
+var POINTS_PER_PERIOD_UNIT = 50;
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+var EMPTY_PARAMS = {};
+var CircularBuffer = class {
+  constructor(capacity) {
+    this.head = 0;
+    this.count = 0;
+    this.capacity = capacity;
+    this.data = Array.from({ length: capacity }, () => ({ x: 0, y: 0 }));
+    this.result = Array.from({ length: capacity }, () => ({ x: 0, y: 0 }));
+  }
+  /** Mutates in-place */
+  push(x, y) {
+    const slot = this.data[this.head];
+    slot.x = x;
+    slot.y = y;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) {
+      this.count++;
+    }
+  }
+  /**
+   * Copies ordered points into the pre-allocated result buffer and returns it
+   * Note: The *same* array reference is returned every call,
+   *  so `result.length` is also always `capacity`
+   */
+  toArray() {
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      const src = this.data[(start + i) % this.capacity];
+      const dst = this.result[i];
+      dst.x = src.x;
+      dst.y = src.y;
+    }
+    return this.result;
+  }
+  clear() {
+    this.head = 0;
+    this.count = 0;
+  }
+  get length() {
+    return this.count;
+  }
+};
+function resolveCurve(curveDef) {
+  const period = curveDef.period ?? TWO_PI;
+  if (!Number.isFinite(period) || period <= 0) {
+    throw new RangeError(`[sarmal] period must be a positive finite number, got ${period}`);
+  }
+  const speed = curveDef.speed ?? 1;
+  if (!Number.isFinite(speed)) {
+    throw new RangeError(`[sarmal] speed must be a finite number, got ${speed}`);
+  }
+  return {
+    name: curveDef.name,
+    fn: curveDef.fn,
+    period,
+    speed,
+    skeleton: curveDef.skeleton,
+    skeletonFn: curveDef.skeletonFn,
+  };
+}
+function createEngine(curveDef, trailLength = 120) {
+  if (!Number.isFinite(trailLength) || trailLength <= 0) {
+    throw new RangeError(
+      `[sarmal] trailLength must be a positive finite number, got ${trailLength}`,
+    );
+  }
+  let curve = resolveCurve(curveDef);
+  const trail = new CircularBuffer(trailLength);
+  let phase = 0;
+  let actualTime = 0;
+  let userSpeedOverride = null;
+  let morphCurveB = null;
+  let _morphAlpha = null;
+  let _morphStrategy = "normalized";
+  let _speedTransition = null;
+  function sampleSkeleton(c, samplePhase) {
+    if (c.skeletonFn) {
+      return c.skeletonFn(samplePhase);
+    }
+    if (c.skeleton === "live") {
+      return c.fn(samplePhase, actualTime, EMPTY_PARAMS);
+    }
+    return c.fn(samplePhase, 0, EMPTY_PARAMS);
+  }
+  return {
+    tick(deltaTime) {
+      if (_speedTransition !== null) {
+        _speedTransition.elapsed += deltaTime * 1e3;
+        const alpha = Math.min(_speedTransition.elapsed / _speedTransition.duration, 1);
+        userSpeedOverride = lerp(_speedTransition.from, _speedTransition.to, alpha);
+        if (alpha >= 1) {
+          userSpeedOverride = _speedTransition.to;
+          _speedTransition.resolve();
+          _speedTransition = null;
+        }
+      }
+      let effectiveSpeed = userSpeedOverride ?? curve.speed;
+      if (morphCurveB !== null && _morphAlpha !== null) {
+        effectiveSpeed = lerp(effectiveSpeed, morphCurveB.speed, _morphAlpha);
+      }
+      phase = (phase + effectiveSpeed * deltaTime) % curve.period;
+      actualTime += deltaTime;
+      if (morphCurveB !== null && _morphAlpha !== null) {
+        const a = curve.fn(phase, actualTime, EMPTY_PARAMS);
+        const phaseB =
+          _morphStrategy === "normalized" ? (phase / curve.period) * morphCurveB.period : phase;
+        const b = morphCurveB.fn(phaseB, actualTime, EMPTY_PARAMS);
+        trail.push(a.x + (b.x - a.x) * _morphAlpha, a.y + (b.y - a.y) * _morphAlpha);
+      } else {
+        const point = curve.fn(phase, actualTime, EMPTY_PARAMS);
+        trail.push(point.x, point.y);
+      }
+      return trail.toArray();
+    },
+    get trailCount() {
+      return trail.length;
+    },
+    get trailLength() {
+      return trailLength;
+    },
+    get isLiveSkeleton() {
+      return curve.skeleton === "live";
+    },
+    get morphAlpha() {
+      return _morphAlpha;
+    },
+    reset() {
+      phase = 0;
+      actualTime = 0;
+      trail.clear();
+    },
+    jump(newPhase, { clearTrail = false } = {}) {
+      phase = ((newPhase % curve.period) + curve.period) % curve.period;
+      if (clearTrail) {
+        trail.clear();
+      }
+    },
+    seek(targetPhase, { wrap = false, step = curve.period / trailLength } = {}) {
+      const advance = curve.speed * step;
+      const target = ((targetPhase % curve.period) + curve.period) % curve.period;
+      const targetTime = target / curve.speed;
+      phase = target;
+      actualTime = targetTime;
+      trail.clear();
+      const pointsFromStart = Math.floor(target / advance) + 1;
+      const count = wrap ? trailLength : Math.min(trailLength, pointsFromStart);
+      for (let i = count - 1; i >= 0; i--) {
+        const samplePhase = target - i * advance;
+        const wrappedPhase = ((samplePhase % curve.period) + curve.period) % curve.period;
+        const elapsed = targetTime - i * step;
+        const point = curve.fn(wrappedPhase, elapsed, EMPTY_PARAMS);
+        trail.push(point.x, point.y);
+      }
+    },
+    startMorph(target, strategy = "normalized") {
+      const resolvedTarget = resolveCurve(target);
+      if (morphCurveB !== null && _morphAlpha !== null) {
+        const frozenAlpha = _morphAlpha;
+        const frozenA = curve;
+        const frozenB = morphCurveB;
+        const frozenStrategy = _morphStrategy;
+        curve = {
+          ...frozenB,
+          fn: (samplePhase, elapsed, params) => {
+            const a = frozenA.fn(samplePhase, elapsed, params);
+            const phaseB =
+              frozenStrategy === "normalized"
+                ? (samplePhase / frozenA.period) * frozenB.period
+                : samplePhase;
+            const b = frozenB.fn(phaseB, elapsed, params);
+            return {
+              x: a.x + (b.x - a.x) * frozenAlpha,
+              y: a.y + (b.y - a.y) * frozenAlpha,
+            };
+          },
+        };
+      }
+      _morphStrategy = strategy;
+      morphCurveB = resolvedTarget;
+      _morphAlpha = 0;
+    },
+    setMorphAlpha(alpha) {
+      _morphAlpha = alpha;
+    },
+    completeMorph() {
+      if (morphCurveB !== null) {
+        if (_morphStrategy === "normalized" && curve.period !== morphCurveB.period) {
+          phase = (phase / curve.period) * morphCurveB.period;
+        }
+        curve = morphCurveB;
+      }
+      morphCurveB = null;
+      _morphAlpha = null;
+    },
+    getSarmalSkeleton() {
+      const steps = Math.ceil(curve.period * POINTS_PER_PERIOD_UNIT);
+      const points2 = new Array(steps);
+      if (morphCurveB !== null && _morphAlpha !== null) {
+        for (let i = 0; i < steps; i++) {
+          const samplePhase = (i / (steps - 1)) * curve.period;
+          const a = sampleSkeleton(curve, samplePhase);
+          const phaseB =
+            _morphStrategy === "normalized"
+              ? (samplePhase / curve.period) * morphCurveB.period
+              : samplePhase;
+          const b = sampleSkeleton(morphCurveB, phaseB);
+          points2[i] = {
+            x: a.x + (b.x - a.x) * _morphAlpha,
+            y: a.y + (b.y - a.y) * _morphAlpha,
+          };
+        }
+        return points2;
+      }
+      for (let i = 0; i < steps; i++) {
+        const samplePhase = (i / (steps - 1)) * curve.period;
+        points2[i] = sampleSkeleton(curve, samplePhase);
+      }
+      return points2;
+    },
+    setSpeed(speed) {
+      if (!Number.isFinite(speed)) {
+        throw new Error("speed must be a finite number");
+      }
+      if (_speedTransition !== null) {
+        _speedTransition.reject(new Error("Speed transition cancelled"));
+        _speedTransition = null;
+      }
+      userSpeedOverride = speed;
+    },
+    getSpeed() {
+      return userSpeedOverride ?? curve.speed;
+    },
+    resetSpeed() {
+      userSpeedOverride = null;
+    },
+    setSpeedOver(speed, duration) {
+      if (!Number.isFinite(speed)) {
+        throw new Error("speed must be a finite number");
+      }
+      if (!Number.isFinite(duration) || duration <= 0) {
+        throw new Error("duration must be a finite number greater than 0");
+      }
+      if (_speedTransition !== null) {
+        _speedTransition.reject(new Error("Speed transition cancelled"));
+        _speedTransition = null;
+      }
+      const from = userSpeedOverride ?? curve.speed;
+      return new Promise((resolve, reject) => {
+        _speedTransition = { from, to: speed, elapsed: 0, duration, resolve, reject };
+      });
+    },
+    cancelSpeedTransition() {
+      if (_speedTransition !== null) {
+        _speedTransition.reject(new Error("Speed transition cancelled"));
+        _speedTransition = null;
+      }
+    },
+  };
+}
+
+// src/renderer-shared.ts
+var FIT_PADDING = 0.1;
+var FIT_PADDING_MIN = 4;
+function computeBoundaries(pts, logicalWidth, logicalHeight, minPaddingPx = FIT_PADDING_MIN) {
+  if (pts.length === 0) return null;
+  const first = pts[0];
+  let minX = first.x,
+    maxX = first.x,
+    minY = first.y,
+    maxY = first.y;
+  for (const p of pts) {
+    if (p.x < minX) {
+      minX = p.x;
+    }
+    if (p.x > maxX) {
+      maxX = p.x;
+    }
+    if (p.y < minY) {
+      minY = p.y;
+    }
+    if (p.y > maxY) {
+      maxY = p.y;
+    }
+  }
+  const w = maxX - minX;
+  const h = maxY - minY;
+  if (w === 0 && h === 0) {
+    throw new Error(
+      "[sarmal] Degenerate curve: all skeleton points are identical. Check that your curve fn returns distinct points for different values of t.",
+    );
+  }
+  const scaleXProportional = logicalWidth / (w * (1 + FIT_PADDING * 2));
+  const scaleYProportional = logicalHeight / (h * (1 + FIT_PADDING * 2));
+  const scaleXMinPadding = (logicalWidth - minPaddingPx * 2) / w;
+  const scaleYMinPadding = (logicalHeight - minPaddingPx * 2) / h;
+  const scale = Math.min(
+    scaleXProportional,
+    scaleYProportional,
+    scaleXMinPadding,
+    scaleYMinPadding,
+  );
+  return {
+    scale,
+    offsetX: (logicalWidth - w * scale) / 2 - minX * scale,
+    offsetY: (logicalHeight - h * scale) / 2 - minY * scale,
+  };
+}
+function hexToRgb(hex) {
+  const n = parseInt(hex.slice(1), 16);
+  return { r: n >> 16, g: (n >> 8) & 255, b: n & 255 };
+}
+
+// src/terminal.ts
+var DEFAULT_TRAIL_HEX = "#ec5571";
+var DEFAULT_FPS = 30;
+var DEFAULT_SIZE = 16;
+var BRIGHTNESS_HEAD = 1;
+var BRIGHTNESS_TAIL = 0.15;
+var BRAILLE_BASE = 10240;
+var BRAILLE_BIT = [
+  [1, 8],
+  [2, 16],
+  [4, 32],
+  [64, 128],
+];
+function brailleChar(bits) {
+  return String.fromCodePoint(BRAILLE_BASE + (bits & 255));
+}
+function dotToCell(dotCol, dotRow) {
+  return {
+    charCol: Math.floor(dotCol / 2),
+    charRow: Math.floor(dotRow / 4),
+    dotColInCell: dotCol % 2,
+    dotRowInCell: dotRow % 4,
+  };
+}
+function detectColor() {
+  const colorterm = (process.env.COLORTERM ?? "").toLowerCase();
+  if (colorterm === "truecolor" || colorterm === "24bit") {
+    return "truecolor";
+  }
+  const term = (process.env.TERM ?? "").toLowerCase();
+  if (term.includes("256color")) {
+    return "256-color";
+  }
+  if (term.includes("truecolor") || term.includes("24bit")) {
+    return "truecolor";
+  }
+  if (colorterm !== "") {
+    return "256-color";
+  }
+  if (term !== "" && term !== "linux" && term !== "dumb") {
+    return "256-color";
+  }
+  return "monochrome";
+}
+function rgbTo256(r, g, b) {
+  const avg = Math.round((r + g + b) / 3);
+  if (Math.abs(r - avg) <= 4 && Math.abs(g - avg) <= 4 && Math.abs(b - avg) <= 4) {
+    if (avg <= 8) {
+      return 16;
+    }
+    return 232 + Math.min(23, Math.round((avg - 8) / 10));
+  }
+  const ri = Math.round((r / 255) * 5);
+  const gi = Math.round((g / 255) * 5);
+  const bi = Math.round((b / 255) * 5);
+  return 16 + 36 * ri + 6 * gi + bi;
+}
+var AR = "\x1B[0m";
+function ansiTruecolorFg(r, g, b) {
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+function ansi256Fg(code) {
+  return `\x1B[38;5;${code}m`;
+}
+function ansiColor(r, g, b, colorCap) {
+  if (colorCap === "truecolor") {
+    return ansiTruecolorFg(r, g, b);
+  }
+  if (colorCap === "256-color") {
+    return ansi256Fg(rgbTo256(r, g, b));
+  }
+  return "";
+}
+function snapCol(col, max) {
+  return Math.max(0, Math.min(max - 1, Math.round(col)));
+}
+function applyBoundary(x, y, scale, offsetX, offsetY) {
+  return {
+    screenX: x * scale + offsetX,
+    screenY: y * scale + offsetY,
+  };
+}
+function renderFrame(
+  trail,
+  trailCount,
+  charWidth,
+  charHeight,
+  scale,
+  offsetX,
+  offsetY,
+  trailRgb,
+  headRgb,
+  colorCap,
+) {
+  const dotWidth = charWidth * 2;
+  const dotHeight = charHeight * 4;
+  const grid = Array.from({ length: charHeight }, () =>
+    Array.from({ length: charWidth }, () => ({ bits: 0, brightness: 0, isHead: false })),
+  );
+  for (let i = 0; i < trailCount; i++) {
+    const pt = trail[i];
+    const t = trailCount > 1 ? i / (trailCount - 1) : 1;
+    const brightness = BRIGHTNESS_TAIL + (BRIGHTNESS_HEAD - BRIGHTNESS_TAIL) * t;
+    const { screenX, screenY } = applyBoundary(pt.x, pt.y, scale, offsetX, offsetY);
+    const dotCol = snapCol(screenX, dotWidth);
+    const dotRow = snapCol(screenY, dotHeight);
+    const cell = dotToCell(dotCol, dotRow);
+    if (
+      cell.charRow < 0 ||
+      cell.charRow >= charHeight ||
+      cell.charCol < 0 ||
+      cell.charCol >= charWidth
+    ) {
+      continue;
+    }
+    const c = grid[cell.charRow][cell.charCol];
+    c.bits |= BRAILLE_BIT[cell.dotRowInCell][cell.dotColInCell];
+    if (brightness > c.brightness) {
+      c.brightness = brightness;
+    }
+    if (i === trailCount - 1) {
+      c.isHead = true;
+    }
+  }
+  if (colorCap !== "monochrome") {
+    return renderColorFrame(grid, charWidth, charHeight, trailRgb, headRgb, colorCap);
+  }
+  return renderMonochromeFrame(grid, charWidth, charHeight);
+}
+function renderColorFrame(grid, charWidth, charHeight, trailRgb, headRgb, colorCap) {
+  const lines = [];
+  for (let row = 0; row < charHeight; row++) {
+    let line = "";
+    for (let col = 0; col < charWidth; col++) {
+      const cell = grid[row][col];
+      if (cell.bits === 0) {
+        line += " ";
+        continue;
+      }
+      const ch = brailleChar(cell.bits);
+      if (cell.isHead) {
+        line += ansiColor(headRgb.r, headRgb.g, headRgb.b, colorCap) + ch + AR;
+      } else {
+        const r = Math.round(trailRgb.r * cell.brightness);
+        const g = Math.round(trailRgb.g * cell.brightness);
+        const b = Math.round(trailRgb.b * cell.brightness);
+        line += ansiColor(r, g, b, colorCap) + ch + AR;
+      }
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+function renderMonochromeFrame(grid, charWidth, charHeight) {
+  const lines = [];
+  for (let row = 0; row < charHeight; row++) {
+    let line = "";
+    for (let col = 0; col < charWidth; col++) {
+      const cell = grid[row][col];
+      if (cell.bits === 0) {
+        line += " ";
+        continue;
+      }
+      if (cell.isHead) {
+        line += "\u28FF";
+      } else {
+        line += brailleChar(cell.bits);
+      }
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+function terminalSarmal(stream, curveDef, options) {
+  if (!stream.isTTY) {
+    return () => {};
+  }
+  const size = options?.size ?? DEFAULT_SIZE;
+  const fps = options?.fps ?? DEFAULT_FPS;
+  const trailHex = options?.trailColor ?? DEFAULT_TRAIL_HEX;
+  const headHex = options?.headColor ?? trailHex;
+  const userSpeed = options?.speed;
+  const colorCap = detectColor();
+  const trailRgb = hexToRgb(trailHex);
+  const headRgb = hexToRgb(headHex);
+  const engine = createEngine(curveDef);
+  if (userSpeed !== void 0) {
+    engine.setSpeed(userSpeed);
+  }
+  const charWidth = size;
+  const charHeight = Math.ceil(size / 2);
+  const skeleton = engine.getSarmalSkeleton();
+  const b = computeBoundaries(skeleton, charWidth * 2, charHeight * 4, 1);
+  if (!b) {
+    return () => {};
+  }
+  const { scale, offsetX, offsetY } = b;
+  let running = true;
+  let firstFrame = true;
+  stream.write("\x1B[?25l");
+  function cleanup() {
+    running = false;
+    stream.write("\x1B[?25h");
+    stream.write("\n");
+  }
+  const onSigint = () => {
+    cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", onSigint);
+  function render() {
+    const delta = 1 / fps;
+    const trail = engine.tick(delta);
+    const trailCount = engine.trailCount;
+    const frame = renderFrame(
+      trail,
+      trailCount,
+      charWidth,
+      charHeight,
+      scale,
+      offsetX,
+      offsetY,
+      trailRgb,
+      headRgb,
+      colorCap,
+    );
+    if (firstFrame) {
+      firstFrame = false;
+      stream.write(frame + "\n");
+      return;
+    }
+    const rows = charHeight;
+    stream.write(`\x1B[${rows}A`);
+    const lines = frame.split("\n");
+    for (const line of lines) {
+      stream.write(line + "\n");
+    }
+  }
+  render();
+  const interval = setInterval(() => {
+    if (!running) {
+      return;
+    }
+    render();
+  }, 1e3 / fps);
+  function stop() {
+    clearInterval(interval);
+    process.off("SIGINT", onSigint);
+    cleanup();
+  }
+  return stop;
+}
+
+// src/catmull-rom.ts
+var PERIOD = 2 * Math.PI;
+function catmullRom1D(p0, p1, p2, p3, u) {
+  const u2 = u * u;
+  const u3 = u2 * u;
+  return (
+    0.5 *
+    (2 * p1 +
+      (-p0 + p2) * u +
+      (2 * p0 - 5 * p1 + 4 * p2 - p3) * u2 +
+      (-p0 + 3 * p1 - 3 * p2 + p3) * u3)
+  );
+}
+function evaluateCatmullRom(points2, phase) {
+  const N = points2.length;
+  if (N === 0) {
+    return { x: 0, y: 0 };
+  }
+  if (N === 1) {
+    return { x: points2[0][0], y: points2[0][1] };
+  }
+  phase = ((phase % PERIOD) + PERIOD) % PERIOD;
+  const segmentSize = PERIOD / N;
+  let i = Math.floor(phase / segmentSize);
+  if (i >= N) {
+    i = N - 1;
+  }
+  let u = (phase - i * segmentSize) / segmentSize;
+  u = Math.max(0, Math.min(1, u));
+  const p0 = points2[(i - 1 + N) % N];
+  const p1 = points2[i];
+  const p2 = points2[(i + 1) % N];
+  const p3 = points2[(i + 2) % N];
+  return {
+    x: catmullRom1D(p0[0], p1[0], p2[0], p3[0], u),
+    y: catmullRom1D(p0[1], p1[1], p2[1], p3[1], u),
+  };
+}
+function drawCurve(points2, opts) {
+  if (points2.length < 3) {
+    throw new Error(`drawCurve requires at least 3 points, received ${points2.length}.`);
+  }
+  const first = points2[0];
+  if (points2.every((p) => p[0] === first[0] && p[1] === first[1])) {
+    console.warn(
+      "[sarmal].drawCurve: all control points are identical. The curve will be a single point.",
+    );
+  }
+  const maxAbs = points2.reduce((m, p) => Math.max(m, Math.abs(p[0]), Math.abs(p[1])), 0);
+  if (maxAbs > 2) {
+    console.warn(
+      `[sarmal].drawCurve: control points extend to \xB1${maxAbs.toFixed(1)}, which may render off-screen. Coordinates should be in [-1, 1].`,
+    );
+  }
+  const pts = points2.map(([x, y]) => [x, y]);
+  return {
+    name: opts?.name ?? "drawn",
+    fn: (phase) => evaluateCatmullRom(pts, phase),
+    period: PERIOD,
+  };
+}
+
+// src/curves/artemis2.ts
+var points = [
+  [-0.44, -0.45],
+  [-0.53, -0.77],
+  [-0.82, -0.66],
+  [-0.82, -0.18],
+  [-0.25, -0.04],
+  [0.16, -0.49],
+  [-0.03, -0.87],
+  [-0.68, -0.94],
+  [-0.95, -0.61],
+  [-0.87, -0],
+  [-0.34, 0.21],
+  [0.27, -0.04],
+  [0.87, 0.06],
+  [0.87, 0.57],
+  [0.32, 0.66],
+  [-0.21, -0.43],
+  [-0.43, -0.81],
+  [-0.69, -0.84],
+  [-0.87, -0.66],
+  [-0.9, -0.47],
+  [-0.76, -0.35],
+];
+var artemis2 = {
+  ...drawCurve(points, { name: "Artemis II" }),
+  speed: 0.7,
+};
+
+// src/curves/astroid.ts
+var TWO_PI2 = Math.PI * 2;
+function astroidFn(phase, _elapsed, _params) {
+  const c = Math.cos(phase);
+  const s = Math.sin(phase);
+  return {
+    x: c * c * c,
+    y: s * s * s,
+  };
+}
+var astroid = {
+  name: "Astroid",
+  fn: astroidFn,
+  period: TWO_PI2,
+  speed: 1.1,
+};
+
+// src/curves/deltoid.ts
+var TWO_PI3 = Math.PI * 2;
+function deltoidFn(phase, _elapsed, _params) {
+  return {
+    x: 2 * Math.cos(phase) + Math.cos(2 * phase),
+    y: 2 * Math.sin(phase) - Math.sin(2 * phase),
+  };
+}
+var deltoid = {
+  name: "Deltoid",
+  fn: deltoidFn,
+  period: TWO_PI3,
+  speed: 0.9,
+};
+
+// src/curves/epicycloid3.ts
+var TWO_PI4 = Math.PI * 2;
+function epicycloid3Fn(phase, _elapsed, _params) {
+  return {
+    x: 4 * Math.cos(phase) - Math.cos(4 * phase),
+    y: 4 * Math.sin(phase) - Math.sin(4 * phase),
+  };
+}
+var epicycloid3 = {
+  name: "Epicycloid (n=3)",
+  fn: epicycloid3Fn,
+  period: TWO_PI4,
+  speed: 0.75,
+};
+
+// src/curves/epitrochoid7.ts
+var TWO_PI5 = Math.PI * 2;
+function epitrochoid7Fn(phase, _elapsed, _params) {
+  const d = 1 + 0.55 * Math.sin(phase * 0.5);
+  return {
+    x: 7 * Math.cos(phase) - d * Math.cos(7 * phase),
+    y: 7 * Math.sin(phase) - d * Math.sin(7 * phase),
+  };
+}
+function epitrochoid7SkeletonFn(phase) {
+  const d = 1.275;
+  return {
+    x: 7 * Math.cos(phase) - d * Math.cos(7 * phase),
+    y: 7 * Math.sin(phase) - d * Math.sin(7 * phase),
+  };
+}
+var epitrochoid7 = {
+  name: "Epitrochoid",
+  fn: epitrochoid7Fn,
+  period: TWO_PI5,
+  speed: 1.4,
+  skeletonFn: epitrochoid7SkeletonFn,
+};
+
+// src/curves/lissajous32.ts
+var TWO_PI6 = Math.PI * 2;
+function lissajous32Fn(phase, elapsed, _params) {
+  const phi = elapsed * 0.45;
+  return {
+    x: Math.sin(3 * phase + phi),
+    y: Math.sin(2 * phase),
+  };
+}
+var lissajous32 = {
+  name: "Lissajous 3:2",
+  fn: lissajous32Fn,
+  period: TWO_PI6,
+  speed: 2,
+  skeleton: "live",
+};
+
+// src/curves/lissajous43.ts
+var TWO_PI7 = Math.PI * 2;
+function lissajous43Fn(phase, elapsed, _params) {
+  const phi = elapsed * 0.38;
+  return {
+    x: Math.sin(4 * phase + phi),
+    y: Math.sin(3 * phase),
+  };
+}
+var lissajous43 = {
+  name: "Lissajous 4:3",
+  fn: lissajous43Fn,
+  period: TWO_PI7,
+  speed: 1.8,
+  skeleton: "live",
+};
+
+// src/curves/lame.ts
+var TWO_PI8 = Math.PI * 2;
+function lameFn(phase, elapsed, _params) {
+  const p = 1.75 + 1.25 * Math.sin(elapsed * 0.48);
+  const c = Math.cos(phase),
+    s = Math.sin(phase);
+  return {
+    x: Math.sign(c) * Math.pow(Math.abs(c), p),
+    y: Math.sign(s) * Math.pow(Math.abs(s), p),
+  };
+}
+var lame = {
+  name: "Lam\xE9 Curve",
+  fn: lameFn,
+  period: TWO_PI8,
+  speed: 1,
+  skeleton: "live",
+};
+
+// src/curves/rose3.ts
+var TWO_PI9 = Math.PI * 2;
+function rose3Fn(phase, _elapsed, _params) {
+  const r = Math.cos(3 * phase);
+  return {
+    x: r * Math.cos(phase),
+    y: r * Math.sin(phase),
+  };
+}
+var rose3 = {
+  name: "Rose (n=3)",
+  fn: rose3Fn,
+  period: TWO_PI9,
+  speed: 1.15,
+};
+
+// src/curves/rose5.ts
+var TWO_PI10 = Math.PI * 2;
+function rose5Fn(phase, _elapsed, _params) {
+  const r = Math.cos(5 * phase);
+  return {
+    x: r * Math.cos(phase),
+    y: r * Math.sin(phase),
+  };
+}
+var rose5 = {
+  name: "Rose (n=5)",
+  fn: rose5Fn,
+  period: TWO_PI10,
+  speed: 1,
+};
+
+// src/curves/rose52.ts
+var FOUR_PI = Math.PI * 4;
+function rose52Fn(phase, _elapsed, _params) {
+  const r = Math.cos((5 / 2) * phase);
+  return {
+    x: r * Math.cos(phase),
+    y: r * Math.sin(phase),
+  };
+}
+var rose52 = {
+  name: "Rose (n=5/2)",
+  fn: rose52Fn,
+  period: FOUR_PI,
+  speed: 0.8,
+};
+
+// src/curves/star.ts
+var TWO_PI11 = Math.PI * 2;
+function starFn(phase, _elapsed, _params) {
+  const r =
+    Math.abs(Math.cos((5 / 2) * phase)) +
+    0.35 * Math.abs(Math.cos((15 / 2) * phase)) +
+    0.15 * Math.abs(Math.cos((25 / 2) * phase));
+  return {
+    x: r * Math.cos(phase),
+    y: r * Math.sin(phase),
+  };
+}
+var star = {
+  name: "Star",
+  fn: starFn,
+  period: TWO_PI11,
+  speed: 1,
+};
+
+// src/curves/star4.ts
+var TWO_PI12 = Math.PI * 2;
+function star4Fn(phase, _elapsed, _params) {
+  const r =
+    Math.abs(Math.cos(2 * phase)) +
+    0.35 * Math.abs(Math.cos(6 * phase)) +
+    0.15 * Math.abs(Math.cos(10 * phase));
+  return {
+    x: r * Math.cos(phase),
+    y: r * Math.sin(phase),
+  };
+}
+var star4 = {
+  name: "Star (4-arm)",
+  fn: star4Fn,
+  period: TWO_PI12,
+  speed: 1,
+};
+
+// src/curves/star7.ts
+var TWO_PI13 = Math.PI * 2;
+function star7Fn(phase, _elapsed, _params) {
+  const r =
+    Math.abs(Math.cos((7 / 2) * phase)) +
+    0.35 * Math.abs(Math.cos((21 / 2) * phase)) +
+    0.15 * Math.abs(Math.cos((35 / 2) * phase));
+  return {
+    x: r * Math.cos(phase),
+    y: r * Math.sin(phase),
+  };
+}
+var star7 = {
+  name: "Star (7-arm)",
+  fn: star7Fn,
+  period: TWO_PI13,
+  speed: 1,
+};
+
+// src/curves/index.ts
+var curves = {
+  artemis2,
+  epitrochoid7,
+  astroid,
+  deltoid,
+  rose3,
+  rose5,
+  rose52,
+  star,
+  star4,
+  star7,
+  lissajous32,
+  lissajous43,
+  epicycloid3,
+  lame,
+};
+
+// src/cli.ts
+function usage() {
+  process.stdout.write(
+    [
+      "Usage: npx @sarmal/core [options]",
+      "",
+      "Options:",
+      "  --name <id>    Curve name (e.g. deltoid, rose3). Random if omitted.",
+      "  --fps <num>    Frame rate (default: 30).",
+      "  --speed <num>  Animation speed multiplier (default: curve default).",
+      "  --size <num>   Spinner width in characters (default: 16).",
+      "  --color <hex>  Trail color as 6-digit hex (default: #ec5571).",
+      "  --verbose      Show curve name and hint above spinner.",
+      "  --help         Show this message.",
+      "",
+      "Examples:",
+      "  npx @sarmal/core",
+      "  npx @sarmal/core --name deltoid --verbose",
+      "  npx @sarmal/core --name rose3 --fps 15 --speed 3",
+      "",
+    ].join("\n") + "\n",
+  );
+}
+function matchArg(argv, i, flag) {
+  const value = argv[i + 1];
+  if (value === void 0 || value.startsWith("-")) {
+    process.stderr.write(`[sarmal] ${flag} requires a value
+`);
+    process.exit(1);
+  }
+  return value;
+}
+function main() {
+  const args = process.argv.slice(2);
+  let name;
+  let verbose = false;
+  let fps;
+  let speed;
+  let size;
+  let color;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--name": {
+        name = matchArg(args, i, "--name");
+        i++;
+        break;
+      }
+      case "--fps": {
+        const raw = matchArg(args, i, "--fps");
+        fps = Number(raw);
+        if (!Number.isFinite(fps) || fps <= 0) {
+          process.stderr.write(`[sarmal] --fps must be a positive number, got "${raw}"
+`);
+          process.exit(1);
+        }
+        i++;
+        break;
+      }
+      case "--speed": {
+        const raw = matchArg(args, i, "--speed");
+        speed = Number(raw);
+        if (!Number.isFinite(speed)) {
+          process.stderr.write(`[sarmal] --speed must be a finite number, got "${raw}"
+`);
+          process.exit(1);
+        }
+        i++;
+        break;
+      }
+      case "--size": {
+        const raw = matchArg(args, i, "--size");
+        size = Math.round(Number(raw));
+        if (!Number.isFinite(size) || size < 1) {
+          process.stderr.write(`[sarmal] --size must be a positive integer, got "${raw}"
+`);
+          process.exit(1);
+        }
+        i++;
+        break;
+      }
+      case "--color": {
+        const raw = matchArg(args, i, "--color");
+        if (!/^#[0-9a-fA-F]{6}$/.test(raw)) {
+          process.stderr.write(`[sarmal] --color must be a 6-digit hex string, got "${raw}"
+`);
+          process.exit(1);
+        }
+        color = raw;
+        i++;
+        break;
+      }
+      case "--verbose": {
+        verbose = true;
+        break;
+      }
+      case "--help": {
+        usage();
+        process.exit(0);
+      }
+      default: {
+        process.stderr.write(`[sarmal] Unknown option: ${arg}
+`);
+        process.stderr.write("Run with --help for usage.\n");
+        process.exit(1);
+      }
+    }
+  }
+  const allCurves = Object.values(curves);
+  let curve = allCurves[Math.floor(Math.random() * allCurves.length)];
+  if (name) {
+    const lower = name.toLowerCase();
+    const key = Object.keys(curves).find((k) => k.toLowerCase() === lower);
+    const found = key ? curves[key] : void 0;
+    if (!found) {
+      process.stderr.write(
+        `[sarmal] Unknown curve: "${name}". Available: ${Object.keys(curves).join(", ")}
+`,
+      );
+      process.exit(1);
+    }
+    curve = found;
+  }
+  if (verbose) {
+    process.stdout.write(`\x1B[2m${curve.name} \u2014 Ctrl+C to stop\x1B[0m
+
+`);
+  }
+  terminalSarmal(process.stdout, curve, {
+    ...(fps !== void 0 ? { fps } : {}),
+    ...(speed !== void 0 ? { speed } : {}),
+    ...(size !== void 0 ? { size } : {}),
+    ...(color !== void 0 ? { trailColor: color } : {}),
+  });
+}
+main();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map