stock-market-gen 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# stock-market-gen
+
+Generate realistic fake stock market data plus SVG charts and standalone HTML pages. Pure JS, zero dependencies, works in Node and the browser.
+
+A modern, more capable replacement for the old `fake-stock-market-generator` package.
+
+## Install
+
+```bash
+npm install stock-market-gen
+```
+
+## Quick start
+
+```js
+import { generateStock, renderLineChart } from 'stock-market-gen';
+
+const stock = generateStock({ bars: 100, interval: '1d', seed: 'demo' });
+const svg = renderLineChart(stock);
+```
+
+CommonJS works too:
+
+```js
+const { generateStock, renderLineChart } = require('stock-market-gen');
+```
+
+## What you can generate
+
+- single stocks or whole markets
+- OHLCV bars (open, high, low, close, volume)
+- pick any time interval — `"1m"`, `"5m"`, `"1h"`, `"1d"`, `"1w"`, `"1mo"`, `"1y"` or raw milliseconds
+- override anything: symbol, name, sector, start price, drift, volatility, start date
+- pass a `stocks` array to define each company yourself
+- reproducible output via a seed
+
+## Chart types
+
+- `line` — close price line
+- `area` — line plus filled area
+- `bar` — OHLC bar (tick-left, tick-right)
+- `candlestick` — classic candles, green up / red down
+
+All renderers return a complete SVG string. Save it to a file, drop it into HTML, or pipe it anywhere.
+
+## Customize anything
+
+Every field is optional. Set the ones you care about, the rest are generated for you. The package only invents the symbol and the price series — `name`, `sector`, `startDate`, etc. are yours to provide.
+
+```js
+import { generateStock } from 'stock-market-gen';
+
+const stock = generateStock({
+  symbol: 'YOUR_SYMBOL',
+  name: 'Your Company Name',
+  sector: 'Your Sector',
+  startPrice: 180,
+  drift: 0.12,         // +12% per year
+  volatility: 0.28,    // 28% per year
+  bars: 60,
+  interval: '1w',      // weekly bars
+  startDate: '2024-01-01',
+  seed: 'anything'
+});
+```
+
+Same idea for a market — pass a `stocks` array and pin whatever you want per company:
+
+```js
+import { generateMarket } from 'stock-market-gen';
+
+const market = generateMarket({
+  bars: 90,
+  interval: '1mo',
+  startDate: '2023-01-01',
+  seed: 'demo',
+  stocks: [
+    { symbol: 'YOUR1', name: 'Your Company 1', sector: 'Your Sector' },
+    { symbol: 'YOUR2', name: 'Your Company 2', sector: 'Your Sector', volatility: 0.45 },
+    { symbol: 'YOUR3' } // name and sector left empty
+  ]
+});
+```
+
+Or skip the array entirely and just get random tickers with no company info:
+
+```js
+const market = generateMarket({ count: 8, bars: 90, seed: 'demo' });
+```
+
+## API
+
+### `generateStock(options) -> Stock`
+
+| Option        | Type                       | Default          | Notes |
+|---------------|----------------------------|------------------|-------|
+| `symbol`      | `string`                   | random 2-5 chars |       |
+| `name`        | `string`                   | none (you supply it) | optional company name |
+| `sector`      | `string`                   | none (you supply it) | optional sector label |
+| `startPrice`  | `number`                   | 50–500           |       |
+| `drift`       | `number`                   | random           | annualised, e.g. `0.05` = +5%/yr |
+| `volatility`  | `number`                   | random           | annualised, e.g. `0.3` = 30%/yr |
+| `bars`        | `number`                   | `100`            | positive integer |
+| `interval`    | `number \| string`         | `"1d"`           | ms or `"1m"`/`"1h"`/`"1d"`/`"1w"`/`"1mo"`/`"1y"` |
+| `startDate`   | `Date \| number \| string` | `now - bars*interval` | first bar timestamp |
+| `seed`        | `number \| string`         | random           | reproducible output |
+
+### `generateMarket({ count, stocks, ...stockOptions }) -> Stock[]`
+
+Generate several unique tickers in one call. Pass `count` for an auto-generated market (random symbols, no name or sector), or `stocks` to define each company yourself. Any other option is applied as a shared default.
+
+```js
+// Auto-generated, 8 random tickers, all daily, same seed -> same market
+const market = generateMarket({ count: 8, bars: 90, interval: '1d', seed: 'demo' });
+
+// Hand-picked companies, with shared defaults
+const market = generateMarket({
+  bars: 60,
+  interval: '1w',
+  seed: 'custom',
+  stocks: [
+    { symbol: 'YOUR1', name: 'Your Company 1', sector: 'Your Sector', startPrice: 180 },
+    { symbol: 'YOUR2', name: 'Your Company 2', sector: 'Your Sector', volatility: 0.45 },
+    { symbol: 'YOUR3' }
+  ]
+});
+```
+
+### `renderChart(stock, type, options)`
+
+`type` is `"line"`, `"area"`, `"bar"` or `"candlestick"`. Or call the dedicated renderers: `renderLineChart`, `renderAreaChart`, `renderBarChart`, `renderCandlestickChart`.
+
+Chart options:
+
+```js
+{
+  width: 800,
+  height: 400,
+  theme: 'light',          // 'light' | 'dark'
+  title: 'AAPL — daily',
+  showGrid: true,
+  showAxes: true,
+  padding: { top: 24, right: 16, bottom: 36, left: 56 },
+  colors: { line: '#2563eb' } // override any single color
+}
+```
+
+### `renderHtmlPage(marketOrStock, options) -> string`
+
+Builds a self-contained HTML page with embedded SVG charts. Pass an array (whole market) or a single stock.
+
+```js
+import { generateMarket, renderHtmlPage } from 'stock-market-gen';
+import { writeFileSync } from 'node:fs';
+
+const market = generateMarket({ count: 8, bars: 90, seed: 'page' });
+writeFileSync('market.html', renderHtmlPage(market, { theme: 'dark', chartType: 'area' }));
+```
+
+## Examples
+
+```bash
+npm run example       # writes out/line.svg and out/candle.svg
+npm run example:page  # writes out/market.html
+```
+
+## License
+
+MIT

package/dist/generator.cjs

@@ -0,0 +1,230 @@
+// Price data generation.
+//
+// Uses Geometric Brownian Motion so prices stay positive and the variance
+// scales with the current price — closer to how real markets behave than a
+// plain random walk.
+//
+//   S_{t+1} = S_t * exp((mu - sigma^2 / 2) * dt + sigma * sqrt(dt) * Z)
+//
+// Each bar then gets an open/high/low/close and a synthetic volume.
+
+const { createRng } = require('./prng.cjs');
+const { makeSymbol } = require('./symbols.cjs');
+const { parseInterval } = require('./interval.cjs');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const YEAR_MS = 365 * DAY_MS;
+
+/**
+ * @typedef {Object} Bar
+ * @property {number} time   - Unix epoch in milliseconds
+ * @property {string} date   - ISO 8601 timestamp
+ * @property {number} open
+ * @property {number} high
+ * @property {number} low
+ * @property {number} close
+ * @property {number} volume
+ */
+
+/**
+ * @typedef {Object} Stock
+ * @property {string} symbol
+ * @property {string} name
+ * @property {string} sector
+ * @property {number} startPrice
+ * @property {number} interval - milliseconds between bars
+ * @property {Bar[]} bars
+ */
+
+/**
+ * @typedef {Object} GenerateStockOptions
+ * @property {string} [symbol]      - Override the generated symbol
+ * @property {string} [name]        - Override the generated company name
+ * @property {string} [sector]      - Override the generated sector
+ * @property {number} [startPrice]  - First bar's open price (default: 50-500)
+ * @property {number} [drift]       - Annualised drift, e.g. 0.05 = +5%/year
+ * @property {number} [volatility]  - Annualised volatility, e.g. 0.3 = 30%/year
+ * @property {number} [bars]        - Number of bars to generate (default: 100)
+ * @property {number|string} [interval] - Bar size; ms or "1m"/"1h"/"1d" (default: "1d")
+ * @property {Date|number|string} [startDate] - First bar timestamp (default: now - bars*interval)
+ * @property {number|string} [seed] - Reproducible output
+ */
+
+const DEFAULTS = {
+  bars: 100,
+  interval: '1d'
+};
+
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+function typeOf(v) {
+  if (v === null) return 'null';
+  if (Array.isArray(v)) return 'array';
+  return typeof v;
+}
+
+/**
+ * Generate price data for a single stock.
+ * @param {GenerateStockOptions} [options]
+ * @returns {Stock}
+ */
+function generateStock(options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  const rng = createRng(opts.seed);
+
+  if (!Number.isInteger(opts.bars) || opts.bars < 1) {
+    throw new Error(`"bars" must be a positive integer, got ${opts.bars}`);
+  }
+
+  // Optional fields: only validated when the caller actually provided them.
+  if (opts.symbol !== undefined && (typeof opts.symbol !== 'string' || opts.symbol.length === 0)) {
+    throw new Error(`"symbol" must be a non-empty string, got ${typeOf(opts.symbol)}`);
+  }
+  if (opts.name !== undefined && opts.name !== null && typeof opts.name !== 'string') {
+    throw new Error(`"name" must be a string, got ${typeOf(opts.name)}`);
+  }
+  if (opts.sector !== undefined && opts.sector !== null && typeof opts.sector !== 'string') {
+    throw new Error(`"sector" must be a string, got ${typeOf(opts.sector)}`);
+  }
+  if (opts.startPrice !== undefined && (!Number.isFinite(opts.startPrice) || opts.startPrice <= 0)) {
+    throw new Error(`"startPrice" must be a positive number, got ${opts.startPrice}`);
+  }
+  if (opts.drift !== undefined && !Number.isFinite(opts.drift)) {
+    throw new Error(`"drift" must be a finite number, got ${opts.drift}`);
+  }
+  if (opts.volatility !== undefined && (!Number.isFinite(opts.volatility) || opts.volatility < 0)) {
+    throw new Error(`"volatility" must be a non-negative number, got ${opts.volatility}`);
+  }
+  if (opts.startDate !== undefined) {
+    const t = new Date(opts.startDate).getTime();
+    if (!Number.isFinite(t)) {
+      throw new Error(`"startDate" is not a valid date: ${opts.startDate}`);
+    }
+  }
+
+  const intervalMs = parseInterval(opts.interval);
+
+  const symbol = opts.symbol ?? makeSymbol(rng);
+  const name = opts.name ?? null;
+  const sector = opts.sector ?? null;
+
+  const startPrice = opts.startPrice ?? round2(rng.next() * 450 + 50); // 50..500
+  // Drift roughly in [-15%, +25%] per year, vol in [10%, 60%] per year.
+  const drift = opts.drift ?? rng.next() * 0.4 - 0.15;
+  const volatility = opts.volatility ?? rng.next() * 0.5 + 0.1;
+
+  const startTime =
+    opts.startDate !== undefined
+      ? new Date(opts.startDate).getTime()
+      : Date.now() - opts.bars * intervalMs;
+
+  const dt = intervalMs / YEAR_MS;
+  const drift2 = (drift - (volatility * volatility) / 2) * dt;
+  const diffusion = volatility * Math.sqrt(dt);
+
+  const bars = new Array(opts.bars);
+  let price = startPrice;
+
+  for (let i = 0; i < opts.bars; i++) {
+    const open = price;
+
+    // Step the close using GBM
+    let close = open * Math.exp(drift2 + diffusion * rng.gauss());
+    if (close < 0.01) close = 0.01;
+
+    // High/low wick around the open-close range, scaled by volatility
+    const wick = Math.abs(open - close) + open * diffusion * (0.5 + rng.next());
+    const high = Math.max(open, close) + wick * rng.next();
+    const low = Math.max(0.01, Math.min(open, close) - wick * rng.next());
+
+    // Volume: log-normal-ish around 1M, with a kick on bigger moves
+    const move = Math.abs(close - open) / open;
+    const volume = Math.max(
+      1,
+      Math.round((500_000 + rng.next() * 1_500_000) * (1 + move * 20))
+    );
+
+    const time = startTime + i * intervalMs;
+    bars[i] = {
+      time,
+      date: new Date(time).toISOString(),
+      open: round2(open),
+      high: round2(high),
+      low: round2(low),
+      close: round2(close),
+      volume
+    };
+
+    price = close;
+  }
+
+  return {
+    symbol,
+    name,
+    sector,
+    startPrice: round2(startPrice),
+    interval: intervalMs,
+    bars
+  };
+}
+
+/**
+ * @typedef {Object} GenerateMarketOptions
+ * @property {number} [count]                  - Number of stocks (default: 5)
+ * @property {GenerateStockOptions[]} [stocks] - Per-stock overrides. When
+ *   provided, the market size matches this array's length and each entry can
+ *   pin its own `symbol`, `name`, `sector`, `startPrice`, etc.
+ *
+ * Any other field is treated as a shared default applied to every stock.
+ */
+
+/**
+ * Generate a whole market of stocks. Symbols stay unique within the market.
+ * @param {GenerateMarketOptions} [options]
+ * @returns {Stock[]}
+ */
+function generateMarket(options = {}) {
+  const { count, stocks, seed, ...sharedOpts } = options;
+
+  // Decide how many stocks we're producing
+  let perStock;
+  if (Array.isArray(stocks)) {
+    if (stocks.length < 1) {
+      throw new Error('"stocks" array must contain at least one entry');
+    }
+    perStock = stocks;
+  } else {
+    const n = count ?? 5;
+    if (!Number.isInteger(n) || n < 1) {
+      throw new Error(`"count" must be a positive integer, got ${n}`);
+    }
+    perStock = new Array(n).fill(null).map(() => ({}));
+  }
+
+  // A master RNG drives per-stock seeds so the whole market is reproducible
+  // from a single user seed.
+  const master = createRng(seed);
+  const used = new Set();
+
+  // Reserve any symbols the caller pinned, so generated ones don't collide.
+  for (const entry of perStock) {
+    if (entry && typeof entry.symbol === 'string') used.add(entry.symbol);
+  }
+
+  return perStock.map((entry) => {
+    const stockSeed = master.int(0, 0xFFFFFFFF);
+    const merged = { ...sharedOpts, ...entry, seed: entry?.seed ?? stockSeed };
+
+    if (typeof merged.symbol !== 'string') {
+      // Build a deterministic rng just to pick a unique symbol up front
+      const rng = createRng(merged.seed);
+      merged.symbol = makeSymbol(rng, used);
+    }
+
+    return generateStock(merged);
+  });
+}
+
+module.exports = { generateStock, generateMarket };

package/dist/html.cjs

@@ -0,0 +1,154 @@
+// Standalone HTML page renderer. Builds a self-contained document with the
+// market summary and embedded SVG charts. No external assets, no JS.
+
+const { renderChart } = require('./svg.cjs');
+
+function escapeHtml(str) {
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function changePct(stock) {
+  const first = stock.bars[0].open;
+  const last = stock.bars[stock.bars.length - 1].close;
+  return ((last - first) / first) * 100;
+}
+
+function buildStyles(theme) {
+  const dark = theme === 'dark';
+  return `
+    :root {
+      --bg: ${dark ? '#0b1220' : '#f9fafb'};
+      --card: ${dark ? '#111827' : '#ffffff'};
+      --border: ${dark ? '#1f2937' : '#e5e7eb'};
+      --text: ${dark ? '#e5e7eb' : '#111827'};
+      --muted: ${dark ? '#9ca3af' : '#6b7280'};
+      --up: ${dark ? '#22c55e' : '#16a34a'};
+      --down: ${dark ? '#ef4444' : '#dc2626'};
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background: var(--bg);
+      color: var(--text);
+      font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+      padding: 24px;
+    }
+    h1 { margin: 0 0 4px; font-size: 22px; }
+    p.lead { margin: 0 0 24px; color: var(--muted); }
+    .grid {
+      display: grid;
+      gap: 16px;
+      grid-template-columns: repeat(auto-fill, minmax(360px, 1fr));
+    }
+    .card {
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: 10px;
+      padding: 16px;
+    }
+    .header {
+      display: flex;
+      align-items: baseline;
+      justify-content: space-between;
+      margin-bottom: 8px;
+      gap: 12px;
+    }
+    .symbol { font-weight: 700; font-size: 16px; }
+    .name { color: var(--muted); font-size: 13px; }
+    .price { font-variant-numeric: tabular-nums; font-weight: 600; }
+    .up { color: var(--up); }
+    .down { color: var(--down); }
+    .meta {
+      display: flex;
+      gap: 12px;
+      color: var(--muted);
+      font-size: 12px;
+      margin-top: 8px;
+      flex-wrap: wrap;
+    }
+    svg { display: block; width: 100%; height: auto; }
+  `;
+}
+
+/**
+ * @typedef {Object} HtmlPageOptions
+ * @property {string} [title]                                   - Page title
+ * @property {'light'|'dark'} [theme]                           - Page + chart theme
+ * @property {'line'|'area'|'bar'|'candlestick'} [chartType]    - Chart style
+ * @property {import('./svg.js').ChartOptions} [chartOptions]   - Forwarded to renderer
+ */
+
+/**
+ * Render a self-contained HTML page for a single stock or a market.
+ * @param {import('./generator.js').Stock | import('./generator.js').Stock[]} marketOrStock
+ * @param {HtmlPageOptions} [options]
+ * @returns {string} HTML document
+ */
+function renderHtmlPage(marketOrStock, options = {}) {
+  const stocks = Array.isArray(marketOrStock) ? marketOrStock : [marketOrStock];
+  const theme = options.theme === 'dark' ? 'dark' : 'light';
+  const chartType = options.chartType || 'line';
+  const chartOptions = {
+    width: 520,
+    height: 260,
+    theme,
+    ...(options.chartOptions || {})
+  };
+  const title = options.title || 'Fake Stock Market';
+
+  const cards = stocks
+    .map((stock) => {
+      const last = stock.bars[stock.bars.length - 1].close;
+      const pct = changePct(stock);
+      const cls = pct >= 0 ? 'up' : 'down';
+      const sign = pct >= 0 ? '+' : '';
+      const chart = renderChart(stock, chartType, {
+        ...chartOptions,
+        title: '' // header in card already shows the symbol
+      });
+      return `
+        <div class="card">
+          <div class="header">
+            <div>
+              <div class="symbol">${escapeHtml(stock.symbol)}</div>
+              ${stock.name ? `<div class="name">${escapeHtml(stock.name)}</div>` : ''}
+            </div>
+            <div>
+              <span class="price">${last.toFixed(2)}</span>
+              <span class="${cls}">${sign}${pct.toFixed(2)}%</span>
+            </div>
+          </div>
+          ${chart}
+          <div class="meta">
+            ${stock.sector ? `<span>${escapeHtml(stock.sector)}</span>` : ''}
+            <span>${stock.bars.length} bars</span>
+          </div>
+        </div>
+      `;
+    })
+    .join('\n');
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>${buildStyles(theme)}</style>
+</head>
+<body>
+<h1>${escapeHtml(title)}</h1>
+<p class="lead">Generated with stock-market-gen — fake data, no real market info.</p>
+<div class="grid">
+${cards}
+</div>
+</body>
+</html>`;
+}
+
+module.exports = { renderHtmlPage };

package/dist/index.cjs

@@ -0,0 +1,9 @@
+// Public API.
+
+const { generateStock, generateMarket } = require('./generator.cjs');
+const { renderChart, renderLineChart, renderAreaChart, renderBarChart, renderCandlestickChart } = require('./svg.cjs');
+const { renderHtmlPage } = require('./html.cjs');
+const { createRng } = require('./prng.cjs');
+const { parseInterval } = require('./interval.cjs');
+
+module.exports = { generateStock, generateMarket, renderChart, renderLineChart, renderAreaChart, renderBarChart, renderCandlestickChart, renderHtmlPage, createRng, parseInterval };

package/dist/interval.cjs

@@ -0,0 +1,40 @@
+// Interval parsing. Accepts a number of milliseconds or a shorthand string
+// like "1m", "5m", "1h", "1d", "1w", "1y".
+
+const UNIT_MS = {
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000,
+  w: 7 * 24 * 60 * 60 * 1000,
+  mo: 30 * 24 * 60 * 60 * 1000,
+  y: 365 * 24 * 60 * 60 * 1000
+};
+
+/**
+ * Convert an interval (number in ms, or shorthand string) into milliseconds.
+ * @param {number|string} interval
+ * @returns {number}
+ */
+function parseInterval(interval) {
+  if (typeof interval === 'number') {
+    if (!Number.isFinite(interval) || interval <= 0) {
+      throw new Error(`Invalid interval: ${interval}`);
+    }
+    return interval;
+  }
+  if (typeof interval !== 'string') {
+    throw new Error(`Invalid interval: ${interval}`);
+  }
+  // "mo" must be matched before "m" so "1mo" doesn't read as "1m" + "o".
+  const match = /^(\d+)\s*(mo|m|h|d|w|y)$/i.exec(interval.trim());
+  if (!match) {
+    throw new Error(
+      `Invalid interval string: "${interval}". Use e.g. "1m", "1h", "1d", "1w", "1mo", "1y".`
+    );
+  }
+  const n = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  return n * UNIT_MS[unit];
+}
+
+module.exports = { parseInterval };

package/dist/prng.cjs

@@ -0,0 +1,73 @@
+// Seeded pseudo-random number generator.
+// Mulberry32 is small, fast and good enough for fake data.
+// Reference: https://stackoverflow.com/a/47593316
+
+/**
+ * Hash a string seed into a 32-bit integer.
+ * @param {string} str
+ * @returns {number}
+ */
+function hashSeed(str) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < str.length; i++) {
+    h = Math.imul(h ^ str.charCodeAt(i), 16777619);
+  }
+  return h >>> 0;
+}
+
+/**
+ * Create a seeded random generator.
+ * @param {number|string|undefined} seed
+ * @returns {{ next: () => number, int: (min: number, max: number) => number, gauss: () => number, pick: <T>(arr: T[]) => T }}
+ */
+function createRng(seed) {
+  let state;
+  if (seed === undefined || seed === null) {
+    state = (Math.random() * 2 ** 32) >>> 0;
+  } else if (typeof seed === 'number') {
+    state = seed >>> 0;
+  } else {
+    state = hashSeed(String(seed));
+  }
+
+  // Mulberry32 — uniform [0, 1)
+  function next() {
+    state = (state + 0x6D2B79F5) >>> 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  }
+
+  // Integer in [min, max] inclusive
+  function int(min, max) {
+    return Math.floor(next() * (max - min + 1)) + min;
+  }
+
+  // Standard normal via Box-Muller. Cached pair to avoid wasting samples.
+  let cached = null;
+  function gauss() {
+    if (cached !== null) {
+      const v = cached;
+      cached = null;
+      return v;
+    }
+    let u1 = next();
+    let u2 = next();
+    // Avoid log(0)
+    if (u1 < 1e-12) u1 = 1e-12;
+    const mag = Math.sqrt(-2 * Math.log(u1));
+    const z0 = mag * Math.cos(2 * Math.PI * u2);
+    const z1 = mag * Math.sin(2 * Math.PI * u2);
+    cached = z1;
+    return z0;
+  }
+
+  function pick(arr) {
+    return arr[int(0, arr.length - 1)];
+  }
+
+  return { next, int, gauss, pick };
+}
+
+module.exports = { createRng };