screamer 2.2.0__tar.gz → 2.2.1__tar.gz

{screamer-2.2.0 → screamer-2.2.1}/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.18)
-project(screamer VERSION 2.2.0 LANGUAGES CXX)
+project(screamer VERSION 2.2.1 LANGUAGES CXX)
 
 # Set the default build type to Release for optimizations
 if(NOT CMAKE_BUILD_TYPE)

{screamer-2.2.0 → screamer-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: screamer
-Version: 2.2.0
+Version: 2.2.1
 Summary: Screamingly fast financial technical indicators with C++ performance and Python simplicity, built for both time series analysis and real-time, event-driven streaming.
 Keywords: streaming,indicators,real-time,algorithmic,trading,low-latency
 Author-Email: Thijs van den Berg <thijs@sitmo.com>

{screamer-2.2.0 → screamer-2.2.1}/js/README.md

@@ -25,6 +25,21 @@ await ready();
 const op = RollingMean(3);
 ```
 
+## Node, bundlers, and the browser
+
+The import above works in Node (18+) and through any bundler (Vite, Next.js, webpack,
+esbuild), which inlines the embedded-WASM module. In a plain browser with no build step,
+import from a CDN URL instead (browser use needs 2.2.1 or newer):
+
+```html
+<script type="module">
+  import { ready, RollingMean }
+    from "https://cdn.jsdelivr.net/npm/@screamer-labs/screamer@2.2.1/dist/index.js";
+  await ready();
+  const sma = RollingMean(3);
+</script>
+```
+
 ## Calling an op: four input regimes
 
 An op factory like `RollingMean(3)` returns a callable. That callable dispatches on its
@@ -94,8 +109,16 @@ package: same operators, same causal semantics, same numerics. Its outputs are
 verified against the Python package's outputs, and batch and streaming calls on the
 same data give identical results.
 
+## Live demo
+
+Watch the smoothing operators run on a live exchange trade feed in the browser:
+[screamer-labs.github.io/screamer/live-trades.html](https://screamer-labs.github.io/screamer/live-trades.html).
+The self-contained source is [`examples/live-trades.html`](examples/live-trades.html).
+
 ## Learn more
 
-Full documentation, the function reference, and example notebooks are at
+The JavaScript reference and guide are at
+[screamer-labs.github.io/screamer](https://screamer-labs.github.io/screamer/). Full documentation,
+the function reference, and example notebooks are at
 [screamer.readthedocs.io](https://screamer.readthedocs.io/en/latest/). Source and
 issues live at [github.com/screamer-labs/screamer](https://github.com/screamer-labs/screamer).

screamer-2.2.1/js/docs-guide/environments.md

@@ -0,0 +1,80 @@
+---
+title: Node, bundlers, and the browser
+---
+
+# Node, bundlers, and the browser
+
+screamer.js is one package that runs in Node and in the browser. The API is identical everywhere;
+only how you point the runtime at the package differs. In every environment the rule is the same:
+call `await ready()` once before constructing any operator, because the WebAssembly module loads
+asynchronously.
+
+Browser use (a bundler or a CDN) requires version **2.2.1 or newer**. Earlier versions load only
+under Node.
+
+## Node
+
+Node 18 or newer. Install and import by name:
+
+```js
+// npm i @screamer-labs/screamer
+import { ready, RollingMean } from "@screamer-labs/screamer";
+
+await ready();
+const sma = RollingMean(3);
+console.log(sma([1, 2, 3, 4])); // [ NaN, NaN, 2, 3 ]
+```
+
+The package ships one self-contained module with the WebAssembly embedded, so there is no separate
+`.wasm` file to resolve.
+
+## Browser with a bundler
+
+Vite, Next.js, webpack, Rollup, esbuild, and similar tools need no special configuration. Install
+and import exactly as in Node; the bundler inlines the embedded-WASM module into your output:
+
+```js
+// npm i @screamer-labs/screamer
+import { ready, RollingMean } from "@screamer-labs/screamer";
+
+await ready();
+const sma = RollingMean(3);
+```
+
+The bare specifier `@screamer-labs/screamer` resolves through the bundler (or an import map). A raw
+browser cannot resolve a bare specifier, which is what the CDN form below handles.
+
+## Browser without a build step (CDN)
+
+Import from a full URL inside a module script. jsDelivr serves the published module directly:
+
+```html
+<script type="module">
+  import { ready, RollingMean }
+    from "https://cdn.jsdelivr.net/npm/@screamer-labs/screamer@2.2.1/dist/index.js";
+
+  await ready();
+
+  const sma = RollingMean(3);
+  console.log(Array.from(sma(new Float64Array([1, 2, 3, 4])))); // [ NaN, NaN, 2, 3 ]
+</script>
+```
+
+Pin the version (`@2.2.1`) so loads are reproducible. The module embeds its WebAssembly, so nothing
+else needs to be fetched or configured.
+
+To avoid a third-party origin (for offline use, a strict Content-Security-Policy, or full control),
+copy the package's `dist/` directory next to your page and import it with a relative URL. The
+[Live demo](./live-demo.md) does this; its
+[source](https://github.com/screamer-labs/screamer/blob/main/js/examples/live-trades.html) shows
+the pattern.
+
+## The rule in every environment
+
+`await ready()` resolves the WebAssembly module once and caches it; a second call awaits the same
+load. Construct operators after it, never before. Each op owns memory on the WASM side, so call
+`.dispose()` when you are done with it (or use `using` where your runtime supports it). See
+[Lifecycle](./lifecycle.md).
+
+Requirements: Node 18+, or any browser with WebAssembly, which is every current browser on desktop
+and mobile.

{screamer-2.2.0 → screamer-2.2.1}/js/docs-guide/getting-started.md

@@ -9,6 +9,10 @@ npm i @screamer-labs/screamer
 The package ships one self-contained WASM module. There is no separate `.wasm` asset to fetch
 and no build step on the consumer side.
 
+The examples below use a bare import, which resolves under Node or a bundler. To load screamer in
+the browser (through a bundler or straight from a CDN with no build step), see
+[Node, bundlers, and the browser](./environments.md).
+
 ## Load the module once
 
 screamer.js compiles to WebAssembly, and WebAssembly modules instantiate asynchronously

{screamer-2.2.0 → screamer-2.2.1}/js/docs-guide/index.md

@@ -37,4 +37,5 @@ RollingMean(3)(new Float64Array([1, 2, 3, 4])); // Float64Array [NaN, NaN, 2, 3]
 ```
 
 Start with [Getting started](./getting-started.md) for the async load step and your first
-`Pipeline`.
+`Pipeline`, or watch the operators run on a live trade feed in the
+[Live demo](./live-demo.md).

screamer-2.2.1/js/docs-guide/live-demo.md

@@ -0,0 +1,51 @@
+---
+title: Live demo
+---
+
+# Live demo
+
+**[Open the live demo](https://screamer-labs.github.io/screamer/live-trades.html)** to watch
+screamer smoothing operators run on a live crypto trade feed in your browser.
+
+The page connects to a public exchange WebSocket (Coinbase or Binance, no API key), keeps a
+fixed window of the most recent trades, and pushes each incoming trade through four operators as
+it arrives. It plots the raw price with an EWMA (span 12), a slower EWMA (span 40), a 30-trade
+simple moving average, and an Ehlers SuperSmoother, updating on every trade.
+
+## What it shows
+
+Each operator is called one trade at a time, scalar in and scalar out:
+
+```js
+import { ready, EwMean, RollingMean, SuperSmoother } from "@screamer-labs/screamer";
+
+await ready();
+
+const fast = EwMean(undefined, 12);   // EWMA, span 12
+const slow = EwMean(undefined, 40);   // EWMA, span 40
+const sma  = RollingMean(30);         // simple moving average, 30 trades
+const ss   = SuperSmoother(30);       // Ehlers SuperSmoother, period 30
+
+// on each trade from the feed:
+function onTrade(price) {
+  const a = fast(price);
+  const b = slow(price);
+  const c = sma(price);   // NaN until the 30-trade window fills
+  const d = ss(price);
+  // ...plot a, b, c, d against the raw price
+}
+```
+
+These are the same operators, with the same numerics, you would call on a stored array. Feeding
+them a live stream one value at a time and feeding them a historical array in one pass produce
+identical results, so a strategy tested on history runs unchanged on the live feed. See
+[Parity with Python](./parity.md) and the four input regimes in
+[Getting started](./getting-started.md).
+
+## Running it yourself
+
+The demo is a single self-contained HTML file at
+[`js/examples/live-trades.html`](https://github.com/screamer-labs/screamer/blob/main/js/examples/live-trades.html).
+It loads screamer from a CDN, so it needs internet access for both the module and the trade feed.
+If the chart stays empty, the default exchange may be restricted in your region; switch the feed
+selector to the other exchange.

screamer-2.2.1/js/examples/live-trades.html

@@ -0,0 +1,387 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>screamer.js — live trades + streaming filters</title>
+<style>
+  :root {
+    --bg: #0d1117; --panel: #161b22; --line: #232a33;
+    --fg: #e6edf3; --muted: #8b949e;
+    --raw: #c9d1d9;
+    --live: #3fb950; --warn: #d29922; --dead: #f85149;
+  }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; height: 100%; }
+  body {
+    background: var(--bg); color: var(--fg);
+    font: 14px/1.45 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    display: flex; flex-direction: column; min-height: 100%;
+  }
+  header { padding: 16px 20px 8px; }
+  h1 { margin: 0; font-size: 17px; font-weight: 650; letter-spacing: .2px; }
+  h1 .mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; color: #58a6ff; }
+  .sub { color: var(--muted); font-size: 12.5px; margin-top: 3px; }
+  .bar {
+    display: flex; flex-wrap: wrap; gap: 10px 16px; align-items: center;
+    padding: 6px 20px 12px;
+  }
+  .bar label { color: var(--muted); font-size: 12px; margin-right: 5px; }
+  select, button {
+    background: var(--panel); color: var(--fg); border: 1px solid var(--line);
+    border-radius: 6px; padding: 5px 9px; font-size: 12.5px; cursor: pointer;
+  }
+  button:hover, select:hover { border-color: #3d4653; }
+  .pill {
+    display: inline-flex; align-items: center; gap: 7px;
+    background: var(--panel); border: 1px solid var(--line);
+    border-radius: 999px; padding: 4px 11px; font-size: 12px; color: var(--muted);
+  }
+  .dot { width: 8px; height: 8px; border-radius: 50%; background: var(--muted); }
+  .dot.live { background: var(--live); box-shadow: 0 0 0 3px rgba(63,185,80,.18); }
+  .dot.connecting { background: var(--warn); }
+  .dot.dead { background: var(--dead); }
+  .price { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 13px; color: var(--fg); }
+  .grow { flex: 1; }
+  #wrap { flex: 1; padding: 0 12px 4px; min-height: 260px; position: relative; }
+  canvas { width: 100%; height: 100%; display: block; }
+  #overlay {
+    position: absolute; inset: 0; display: none; align-items: center; justify-content: center;
+    text-align: center; padding: 24px; color: var(--muted);
+  }
+  #overlay .box { max-width: 460px; }
+  #overlay code { color: #f0883e; font-family: ui-monospace, Menlo, monospace; }
+  .legend {
+    display: flex; flex-wrap: wrap; gap: 8px 18px; padding: 8px 20px 4px;
+  }
+  .lg { display: inline-flex; align-items: center; gap: 7px; font-size: 12.5px; }
+  .sw { width: 22px; height: 3px; border-radius: 2px; }
+  .lg .nm { color: var(--muted); }
+  .lg .vl { font-family: ui-monospace, Menlo, monospace; min-width: 62px; }
+  footer { color: var(--muted); font-size: 11.5px; padding: 4px 20px 14px; }
+  footer a { color: #58a6ff; text-decoration: none; }
+</style>
+</head>
+<body>
+  <header>
+    <h1><span class="mono">screamer.js</span> &nbsp;·&nbsp; live trades with streaming filters</h1>
+    <div class="sub">
+      Each incoming trade is pushed through the smoothing operators one value at a time, the exact
+      same operators you would run on a historical array, running here in WebAssembly.
+    </div>
+  </header>
+
+  <div class="bar">
+    <span><label>feed</label>
+      <select id="source">
+        <option value="coinbase">Coinbase · BTC-USD</option>
+        <option value="binance">Binance · BTC/USDT</option>
+      </select>
+    </span>
+    <span><label>window</label>
+      <select id="window">
+        <option value="120">120 trades</option>
+        <option value="240" selected>240 trades</option>
+        <option value="480">480 trades</option>
+      </select>
+    </span>
+    <button id="pause">Pause</button>
+    <button id="reset">Reset</button>
+    <span class="grow"></span>
+    <span class="pill"><span id="dot" class="dot"></span><span id="status">starting…</span></span>
+    <span class="pill">last <span id="last" class="price">—</span></span>
+    <span class="pill"><span id="rate">0</span> trades/s</span>
+  </div>
+
+  <div id="wrap">
+    <canvas id="chart"></canvas>
+    <div id="overlay"><div class="box"></div></div>
+  </div>
+
+  <div class="legend" id="legend"></div>
+
+  <footer>
+    Powered by <a href="https://www.npmjs.com/package/@screamer-labs/screamer" target="_blank" rel="noopener">@screamer-labs/screamer</a>.
+    Public trade feeds, no API key. If a feed shows no data it may be geo-restricted, switch feeds above.
+  </footer>
+
+<script type="module">
+// ---------------------------------------------------------------------------
+// Load screamer.js. On the docs site a same-origin bundle sits next to this
+// page (built to a broad target, most robust across browsers incl. mobile
+// Safari); the CDN entries are fallbacks when the file is opened standalone.
+// ---------------------------------------------------------------------------
+const SOURCES = [
+  new URL("./vendor/screamer/index.js", import.meta.url).href,                 // same-origin (docs site)
+  "https://cdn.jsdelivr.net/npm/@screamer-labs/screamer@2.2.0/dist/index.js",  // raw published ESM
+  "https://esm.sh/@screamer-labs/screamer@2.2.0",                             // transformed fallback
+];
+async function loadScreamer() {
+  const errs = [];
+  for (const url of SOURCES) {
+    try { return await import(url); }
+    catch (e) {
+      const where = url.startsWith("http") ? new URL(url).host : "same-origin";
+      errs.push(where + " — " + String((e && e.message) || e));
+    }
+  }
+  throw new Error(errs.join("\n"));
+}
+
+const overlay = document.getElementById("overlay");
+function fail(html) {
+  overlay.querySelector(".box").innerHTML = html;
+  overlay.style.display = "flex";
+}
+
+let S;
+try {
+  S = await loadScreamer();
+  await S.ready();
+} catch (e) {
+  const detail = String((e && e.message) || e)
+    .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\n/g, "<br>");
+  fail(`Could not load <code>@screamer-labs/screamer</code>.<br><br>` +
+       `This page needs internet access for the module and the trade feed.<br><br>` +
+       `<small style="color:#f0883e">${detail}</small>`);
+  throw e;
+}
+
+// ---------------------------------------------------------------------------
+// Smoothing operators. Each is a screamer op called once per trade (streaming
+// scalar in, scalar out). Rebuilt on reset so their state starts clean.
+// ---------------------------------------------------------------------------
+const SPECS = [
+  { name: "EWMA · span 12",     color: "#f5a623", make: () => S.EwMean(undefined, 12) },
+  { name: "EWMA · span 40",     color: "#4a90e2", make: () => S.EwMean(undefined, 40) },
+  { name: "SMA · 30",           color: "#7ed321", make: () => S.RollingMean(30) },
+  { name: "SuperSmoother · 30", color: "#e05a8f", make: () => S.SuperSmoother(30) },
+];
+
+let N = 240;                 // fixed display window (number of recent trades)
+let prices = [];             // raw trade prices, newest last
+let filters = [];            // { name, color, op, buf[] }
+let paused = false;
+let dirty = true;
+const arrivals = [];         // recent arrival timestamps, for trades/sec
+
+function buildFilters() {
+  filters = SPECS.map(s => ({ name: s.name, color: s.color, op: s.make(), buf: [] }));
+}
+function reset() {
+  prices = [];
+  buildFilters();
+  arrivals.length = 0;
+  dirty = true;
+}
+buildFilters();
+
+function onTrade(price) {
+  arrivals.push(performance.now());
+  prices.push(price);
+  for (const f of filters) f.buf.push(f.op(price));   // <- streaming, one trade at a time
+  while (prices.length > N) {
+    prices.shift();
+    for (const f of filters) f.buf.shift();
+  }
+  document.getElementById("last").textContent = fmt(price);
+  dirty = true;
+}
+
+// ---------------------------------------------------------------------------
+// Public trade feeds. Each normalizes its messages to a numeric price.
+// ---------------------------------------------------------------------------
+const FEEDS = {
+  coinbase: {
+    label: "Coinbase BTC-USD",
+    url: "wss://ws-feed.exchange.coinbase.com",
+    onopen: (ws) => ws.send(JSON.stringify({
+      type: "subscribe", product_ids: ["BTC-USD"], channels: ["matches"],
+    })),
+    price: (m) => (m.type === "match" || m.type === "last_match") ? parseFloat(m.price) : NaN,
+  },
+  binance: {
+    label: "Binance BTC/USDT",
+    url: "wss://stream.binance.com:9443/ws/btcusdt@trade",
+    onopen: null,
+    price: (m) => m.e === "trade" ? parseFloat(m.p) : NaN,
+  },
+};
+
+let ws = null, source = "coinbase", retry = 0, reconnectTimer = null;
+
+function setStatus(state, text) {
+  document.getElementById("dot").className = "dot " + (state || "");
+  document.getElementById("status").textContent = text;
+}
+
+function connect() {
+  clearTimeout(reconnectTimer);
+  const feed = FEEDS[source];
+  setStatus("connecting", "connecting to " + feed.label + "…");
+  let sock;
+  try { sock = new WebSocket(feed.url); }
+  catch (e) { scheduleReconnect(); return; }
+  ws = sock;
+  sock.onopen = () => {
+    retry = 0;
+    if (feed.onopen) feed.onopen(sock);
+    setStatus("live", "live · " + feed.label);
+  };
+  sock.onmessage = (ev) => {
+    if (paused) return;
+    let m; try { m = JSON.parse(ev.data); } catch { return; }
+    const p = feed.price(m);
+    if (Number.isFinite(p)) onTrade(p);
+  };
+  sock.onerror = () => { try { sock.close(); } catch {} };
+  sock.onclose = () => {
+    if (sock !== ws) return;              // superseded by a newer connection
+    setStatus("dead", "disconnected · retrying…");
+    scheduleReconnect();
+  };
+}
+function scheduleReconnect() {
+  retry = Math.min(retry + 1, 6);
+  reconnectTimer = setTimeout(connect, 400 * retry);
+}
+function switchFeed(next) {
+  source = next;
+  if (ws) { ws.onclose = null; try { ws.close(); } catch {} ws = null; }
+  reset();
+  connect();
+}
+
+// ---------------------------------------------------------------------------
+// Canvas rendering. Fixed, right-anchored scrolling window. The price axis is
+// scaled from the raw trades only; filter lines are clipped to the plot, so a
+// filter's warm-up transient never distorts the view.
+// ---------------------------------------------------------------------------
+const canvas = document.getElementById("chart");
+const ctx = canvas.getContext("2d");
+let cssW = 0, cssH = 0, dpr = 1;
+
+function resize() {
+  const r = canvas.getBoundingClientRect();
+  cssW = Math.max(320, r.width); cssH = Math.max(240, r.height);
+  dpr = window.devicePixelRatio || 1;
+  canvas.width = Math.round(cssW * dpr);
+  canvas.height = Math.round(cssH * dpr);
+  ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+  dirty = true;
+}
+window.addEventListener("resize", resize);
+
+const PADL = 12, PADR = 74, PADT = 14, PADB = 20;
+
+function fmt(v) {
+  if (!Number.isFinite(v)) return "—";
+  return v.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+
+function lastFinite(arr) {
+  for (let i = arr.length - 1; i >= 0; i--) if (Number.isFinite(arr[i])) return arr[i];
+  return NaN;
+}
+
+function render() {
+  requestAnimationFrame(render);
+
+  // trades/sec (rolling 1s), refreshed every frame regardless of new data
+  const now = performance.now();
+  while (arrivals.length && now - arrivals[0] > 1000) arrivals.shift();
+  document.getElementById("rate").textContent = arrivals.length;
+
+  if (!dirty) return;
+  dirty = false;
+
+  ctx.clearRect(0, 0, cssW, cssH);
+  const plotW = cssW - PADL - PADR, plotH = cssH - PADT - PADB;
+
+  const finite = prices.filter(Number.isFinite);
+  if (finite.length < 2) {
+    ctx.fillStyle = "#8b949e"; ctx.font = "13px -apple-system, sans-serif";
+    ctx.textAlign = "center";
+    ctx.fillText("waiting for trades…", PADL + plotW / 2, PADT + plotH / 2);
+    return;
+  }
+
+  let lo = Math.min(...finite), hi = Math.max(...finite);
+  if (hi - lo < 1e-9) { hi += 1; lo -= 1; }
+  const pad = (hi - lo) * 0.08; lo -= pad; hi += pad;
+
+  const len = prices.length;
+  const step = plotW / (N - 1);
+  const X = (i) => PADL + plotW - (len - 1 - i) * step;
+  const Y = (p) => PADT + (1 - (p - lo) / (hi - lo)) * plotH;
+
+  // grid + right-side price labels
+  ctx.strokeStyle = "#232a33"; ctx.fillStyle = "#8b949e";
+  ctx.lineWidth = 1; ctx.font = "11px ui-monospace, Menlo, monospace"; ctx.textAlign = "left";
+  const ROWS = 5;
+  for (let k = 0; k <= ROWS; k++) {
+    const y = PADT + (k / ROWS) * plotH;
+    ctx.beginPath(); ctx.moveTo(PADL, y); ctx.lineTo(PADL + plotW, y); ctx.stroke();
+    const price = hi - (k / ROWS) * (hi - lo);
+    ctx.fillText(fmt(price), PADL + plotW + 8, y + 3);
+  }
+
+  // clip everything data-related to the plot rectangle
+  ctx.save();
+  ctx.beginPath(); ctx.rect(PADL, PADT, plotW, plotH); ctx.clip();
+
+  // raw price
+  drawLine(prices, "#c9d1d9", 1, 0.55, X, Y);
+  // filters
+  for (const f of filters) drawLine(f.buf, f.color, 1.8, 1, X, Y);
+
+  ctx.restore();
+
+  // legend values
+  const legend = document.getElementById("legend");
+  const rows = [
+    { name: "raw price", color: "#c9d1d9", v: lastFinite(prices) },
+    ...filters.map(f => ({ name: f.name, color: f.color, v: lastFinite(f.buf) })),
+  ];
+  legend.innerHTML = rows.map(r =>
+    `<span class="lg"><span class="sw" style="background:${r.color}"></span>` +
+    `<span class="nm">${r.name}</span><span class="vl">${fmt(r.v)}</span></span>`
+  ).join("");
+}
+
+function drawLine(arr, color, w, alpha, X, Y) {
+  ctx.strokeStyle = color; ctx.lineWidth = w; ctx.globalAlpha = alpha;
+  ctx.lineJoin = "round"; ctx.beginPath();
+  let pen = false;
+  for (let i = 0; i < arr.length; i++) {
+    const v = arr[i];
+    if (!Number.isFinite(v)) { pen = false; continue; }   // break the line on NaN (warm-up)
+    const x = X(i), y = Y(v);
+    if (pen) ctx.lineTo(x, y); else { ctx.moveTo(x, y); pen = true; }
+  }
+  ctx.stroke(); ctx.globalAlpha = 1;
+}
+
+// ---------------------------------------------------------------------------
+// Controls
+// ---------------------------------------------------------------------------
+document.getElementById("source").addEventListener("change", (e) => switchFeed(e.target.value));
+document.getElementById("window").addEventListener("change", (e) => {
+  N = parseInt(e.target.value, 10);
+  while (prices.length > N) { prices.shift(); for (const f of filters) f.buf.shift(); }
+  dirty = true;
+});
+document.getElementById("pause").addEventListener("click", (e) => {
+  paused = !paused; e.target.textContent = paused ? "Resume" : "Pause";
+});
+document.getElementById("reset").addEventListener("click", reset);
+
+// ---------------------------------------------------------------------------
+// Go
+// ---------------------------------------------------------------------------
+resize();
+connect();
+requestAnimationFrame(render);
+</script>
+</body>
+</html>

{screamer-2.2.0 → screamer-2.2.1}/js/package-lock.json

@@ -10,6 +10,7 @@
       "license": "MIT",
       "devDependencies": {
         "@types/node": "^20.0.0",
+        "esbuild": "^0.28.1",
         "tsx": "^4.0.0",
         "typedoc": "^0.28.20",
         "typescript": "^5.5.0"

{screamer-2.2.0 → screamer-2.2.1}/js/package.json

@@ -55,10 +55,12 @@
     "prepack": "npm run build:wasm:single && npm run build",
     "pack-smoke": "bash scripts/pack-smoke.sh",
     "test": "node --import tsx --test test/*.test.ts",
-    "docs": "npm run build:wasm && typedoc"
+    "docs": "npm run build:wasm:single && typedoc && npm run build:esm && npm run docs:demo",
+    "docs:demo": "mkdir -p docs-site/vendor/screamer/generated && esbuild dist/index.js --bundle --format=esm --target=es2017 --outfile=docs-site/vendor/screamer/index.js && cp dist/generated/screamer.mjs docs-site/vendor/screamer/generated/screamer.mjs && cp examples/live-trades.html docs-site/live-trades.html"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "esbuild": "^0.28.1",
     "tsx": "^4.0.0",
     "typedoc": "^0.28.20",
     "typescript": "^5.5.0"

{screamer-2.2.0 → screamer-2.2.1}/js/src/codes.ts

@@ -63,6 +63,8 @@ export const CODES = {
 };
 
 // `node --import tsx src/codes.ts --dump` prints CODES as JSON for the gate.
-if (process.argv.includes("--dump")) {
+// Guarded so this module also evaluates in the browser, where `process` is
+// undefined (importing it otherwise throws "process is not defined").
+if (typeof process !== "undefined" && process.argv?.includes("--dump")) {
   process.stdout.write(JSON.stringify(CODES));
 }

{screamer-2.2.0 → screamer-2.2.1}/js/typedoc.json

@@ -6,6 +6,8 @@
   "readme": "docs-guide/index.md",
   "projectDocuments": [
     "docs-guide/getting-started.md",
+    "docs-guide/environments.md",
+    "docs-guide/live-demo.md",
     "docs-guide/regimes.md",
     "docs-guide/lifecycle.md",
     "docs-guide/pipeline.md",
@@ -15,6 +17,7 @@
   "excludeExternals": true,
   "categorizeByGroup": true,
   "navigationLinks": {
+    "Live demo": "https://screamer-labs.github.io/screamer/live-trades.html",
     "Python docs": "https://screamer.readthedocs.io/",
     "GitHub": "https://github.com/screamer-labs/screamer"
   }

{screamer-2.2.0 → screamer-2.2.1}/pyproject.toml

@@ -2,7 +2,7 @@
 
 name = "screamer"
 
-version = "2.2.0"
+version = "2.2.1"
 
 requires-python = ">=3.12"
 
@@ -115,7 +115,7 @@ dev = [
 
 [tool.poetry]
 name = "screamer"
-version = "2.2.0"
+version = "2.2.1"
 description = "Screamingly fast financial technical indicators with C++ performance and Python simplicity, built for both time series analysis and real-time, event-driven streaming."
 # Package author. Per-operator contributors are credited in AUTHORS.md.
 authors = ["Thijs van den Berg <thijs@sitmo.com>"]
@@ -202,7 +202,7 @@ build-backend = "scikit_build_core.build"
 wheel.py-api = "cp312"
 
 [tool.bumpversion]
-current_version = "2.2.0"
+current_version = "2.2.1"
 commit = true
 tag = true
 allow_dirty = false