dexbot 1.4.16 → 1.4.17

package/analysis/bot_usage/kibana_bot_queries.ts

@@ -0,0 +1,427 @@
+/**
+ * KIBANA BOT QUERIES
+ *
+ * Elasticsearch query builders for analyzing DEXBot / DEXBot2 order activity
+ * on the BitShares blockchain via the public Kibana instance.
+ *
+ * Data source:
+ *   https://kibana.bitshares.dev / bitshares-* index
+ *   Time field: block_data.block_time
+ *
+ * BitShares operation types used here:
+ *   1 = limit_order_create  (field: op_object.seller)
+ *   2 = limit_order_cancel  (field: op_object.fee_paying_account)
+ *   4 = fill_order          (field: op_object.account_id)
+ *
+ * Relevant ES field paths:
+ *   limit_order_create:
+ *     op_object.seller                    — account that placed the order
+ *     op_object.amount_to_sell.amount     — integer sell amount
+ *     op_object.amount_to_sell.asset_id   — sell asset ID (e.g. '1.3.0' = BTS)
+ *     op_object.min_to_receive.amount     — integer min-receive (= limit price numerator)
+ *     op_object.min_to_receive.asset_id   — receive asset ID
+ *     op_object.expiration                — ISO datetime
+ *
+ *   fill_order:
+ *     op_object.account_id                — whose order was filled
+ *     op_object.pays.amount / .asset_id   — what was paid
+ *     op_object.receives.amount / .asset_id — what was received
+ *     op_object.order_id                  — the limit order that filled
+ *
+ *   limit_order_cancel:
+ *     op_object.fee_paying_account        — account that cancelled
+ *     op_object.order                     — the order ID cancelled
+ */
+
+
+import { toIntervalLabel } from '../../market_adapter/interval_utils.js';
+import { kibanaSearch, DEFAULT_CONFIG as BASE_CONFIG } from '../../market_adapter/core/kibana_client.js';
+'use strict';
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+const OP_LIMIT_ORDER_CREATE = 1;
+const OP_LIMIT_ORDER_CANCEL = 2;
+const OP_FILL_ORDER         = 4;
+
+const DEFAULT_CONFIG = {
+    ...BASE_CONFIG,
+    timeout: 25000,
+};
+
+// ─── Aggregation query builders (size:0, for counts & timelines) ───────────────
+
+/**
+ * Time-bucketed count of limit_order_create ops for an account.
+ * Optionally filtered to orders selling a specific asset.
+ */
+function buildOrderCreateQuery(accountId: string, lookbackHours: number, intervalSeconds: number = 3600, sellAssetId: string | null = null) {
+    const filters = [
+        { term:  { operation_type: OP_LIMIT_ORDER_CREATE } },
+        { term:  { 'operation_history.op_object.seller.keyword': accountId } },
+        { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+    ];
+    if (sellAssetId) {
+        filters.push({ term: { 'operation_history.op_object.amount_to_sell.asset_id.keyword': sellAssetId } } as any);
+    }
+    return {
+        size: 0,
+        query: { bool: { filter: filters } },
+        aggs: {
+            by_time: {
+                date_histogram: {
+                    field:          'block_data.block_time',
+                    fixed_interval: toIntervalLabel(intervalSeconds),
+                    min_doc_count:  1,
+                },
+            },
+            total: { value_count: { field: 'operation_type' } },
+        },
+    };
+}
+
+/**
+ * Time-bucketed count of fill_order ops for an account.
+ * Optionally filtered to fills where account pays a specific asset.
+ */
+function buildFillOrderQuery(accountId: string, lookbackHours: number, intervalSeconds: number = 3600, paysAssetId: string | null = null) {
+    const filters = [
+        { term:  { operation_type: OP_FILL_ORDER } },
+        { term:  { 'operation_history.op_object.account_id.keyword': accountId } },
+        { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+    ];
+    if (paysAssetId) {
+        filters.push({ term: { 'operation_history.op_object.pays.asset_id.keyword': paysAssetId } } as any);
+    }
+    return {
+        size: 0,
+        query: { bool: { filter: filters } },
+        aggs: {
+            by_time: {
+                date_histogram: {
+                    field:          'block_data.block_time',
+                    fixed_interval: toIntervalLabel(intervalSeconds),
+                    min_doc_count:  1,
+                },
+            },
+            total: { value_count: { field: 'operation_type' } },
+        },
+    };
+}
+
+/**
+ * Time-bucketed count of limit_order_cancel ops for an account.
+ */
+function buildOrderCancelQuery(accountId: string, lookbackHours: number, intervalSeconds: number = 3600) {
+    return {
+        size: 0,
+        query: {
+            bool: {
+                filter: [
+                    { term:  { operation_type: OP_LIMIT_ORDER_CANCEL } },
+                    { term:  { 'operation_history.op_object.fee_paying_account.keyword': accountId } },
+                    { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+                ],
+            },
+        },
+        aggs: {
+            by_time: {
+                date_histogram: {
+                    field:          'block_data.block_time',
+                    fixed_interval: toIntervalLabel(intervalSeconds),
+                    min_doc_count:  1,
+                },
+            },
+            total: { value_count: { field: 'operation_type' } },
+        },
+    };
+}
+
+/**
+ * Daily activity breakdown by operation type for an account.
+ * Merges creates (by seller), fills (by account_id), cancels (by fee_paying_account)
+ * into one aggregation using a filter per op type.
+ */
+function buildDailyActivityQuery(accountId: string, lookbackHours: number) {
+    return {
+        size: 0,
+        query: {
+            bool: {
+                filter: [
+                    { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+                ],
+            },
+        },
+        aggs: {
+            creates: {
+                filter: {
+                    bool: {
+                        filter: [
+                            { term: { operation_type: OP_LIMIT_ORDER_CREATE } },
+                            { term: { 'operation_history.op_object.seller.keyword': accountId } },
+                        ],
+                    },
+                },
+                aggs: {
+                    by_day: {
+                        date_histogram: { field: 'block_data.block_time', fixed_interval: '1d', min_doc_count: 1 },
+                    },
+                },
+            },
+            fills: {
+                filter: {
+                    bool: {
+                        filter: [
+                            { term: { operation_type: OP_FILL_ORDER } },
+                            { term: { 'operation_history.op_object.account_id.keyword': accountId } },
+                        ],
+                    },
+                },
+                aggs: {
+                    by_day: {
+                        date_histogram: { field: 'block_data.block_time', fixed_interval: '1d', min_doc_count: 1 },
+                    },
+                },
+            },
+            cancels: {
+                filter: {
+                    bool: {
+                        filter: [
+                            { term: { operation_type: OP_LIMIT_ORDER_CANCEL } },
+                            { term: { 'operation_history.op_object.fee_paying_account.keyword': accountId } },
+                        ],
+                    },
+                },
+                aggs: {
+                    by_day: {
+                        date_histogram: { field: 'block_data.block_time', fixed_interval: '1d', min_doc_count: 1 },
+                    },
+                },
+            },
+        },
+    };
+}
+
+// ─── Raw document query builders (size>0, for price/grid analysis) ────────────
+
+/**
+ * Fetch raw limit_order_create documents for grid spacing analysis.
+ * Returns the price-relevant fields plus timestamps.
+ *
+ * @param {string}  accountId
+ * @param {number}  lookbackHours
+ * @param {string}  [sellAssetId]   - optional: filter to one sell-side asset
+ * @param {number}  [maxResults]
+ * @returns {Object} Elasticsearch query object
+ */
+function buildOrderPriceQuery(accountId: string, lookbackHours: number, sellAssetId: string | null = null, maxResults: number = 1000) {
+    const filters = [
+        { term:  { operation_type: OP_LIMIT_ORDER_CREATE } },
+        { term:  { 'operation_history.op_object.seller.keyword': accountId } },
+        { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+    ];
+    if (sellAssetId) {
+        filters.push({ term: { 'operation_history.op_object.amount_to_sell.asset_id.keyword': sellAssetId } } as any);
+    }
+    return {
+        size: maxResults,
+        _source: [
+            'block_data.block_time',
+            'operation_history.op_object.amount_to_sell',
+            'operation_history.op_object.min_to_receive',
+            'operation_history.op_object.expiration',
+        ],
+        query: { bool: { filter: filters } },
+        sort:  [{ 'block_data.block_time': { order: 'desc' } }],
+    };
+}
+
+/**
+ * Fetch raw fill_order documents for fill-price analysis.
+ *
+ * @param {string}  accountId
+ * @param {number}  lookbackHours
+ * @param {string}  [paysAssetId]
+ * @param {number}  [maxResults]
+ * @returns {Object} Elasticsearch query object
+ */
+function buildFillPriceQuery(accountId: string, lookbackHours: number, paysAssetId: string | null = null, maxResults: number = 500) {
+    const filters = [
+        { term:  { operation_type: OP_FILL_ORDER } },
+        { term:  { 'operation_history.op_object.account_id.keyword': accountId } },
+        { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+    ];
+    if (paysAssetId) {
+        filters.push({ term: { 'operation_history.op_object.pays.asset_id.keyword': paysAssetId } } as any);
+    }
+    return {
+        size: maxResults,
+        _source: [
+            'block_data.block_time',
+            'operation_history.op_object.pays',
+            'operation_history.op_object.receives',
+            'operation_history.op_object.order_id',
+        ],
+        query: { bool: { filter: filters } },
+        sort:  [{ 'block_data.block_time': { order: 'desc' } }],
+    };
+}
+
+/**
+ * Discover which asset pairs an account trades by aggregating the sell asset IDs.
+ * Returns top asset IDs by order count.
+ */
+function buildAssetDiscoveryQuery(accountId: string, lookbackHours: number) {
+    return {
+        size: 0,
+        query: {
+            bool: {
+                filter: [
+                    { term:  { operation_type: OP_LIMIT_ORDER_CREATE } },
+                    { term:  { 'operation_history.op_object.seller.keyword': accountId } },
+                    { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+                ],
+            },
+        },
+        aggs: {
+            sell_assets: {
+                terms: {
+                    field: 'operation_history.op_object.amount_to_sell.asset_id.keyword',
+                    size:  10,
+                },
+            },
+            recv_assets: {
+                terms: {
+                    field: 'operation_history.op_object.min_to_receive.asset_id.keyword',
+                    size:  10,
+                },
+            },
+        },
+    };
+}
+
+// ─── Fetch helpers ────────────────────────────────────────────────────────────
+
+async function fetchOrderCreate(accountId: string, lookbackHours: number, config: any = {}, sellAssetId: string | null = null, intervalSeconds: number = 3600) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return kibanaSearch(cfg, buildOrderCreateQuery(accountId, lookbackHours, intervalSeconds, sellAssetId));
+}
+
+async function fetchFillOrder(accountId: string, lookbackHours: number, config: any = {}, paysAssetId: string | null = null, intervalSeconds: number = 3600) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return kibanaSearch(cfg, buildFillOrderQuery(accountId, lookbackHours, intervalSeconds, paysAssetId));
+}
+
+async function fetchOrderCancel(accountId: string, lookbackHours: number, config: any = {}, intervalSeconds: number = 3600) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return kibanaSearch(cfg, buildOrderCancelQuery(accountId, lookbackHours, intervalSeconds));
+}
+
+async function fetchOrderPrices(accountId: string, lookbackHours: number, config: any = {}, sellAssetId: string | null = null, maxResults: number = 1000) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return kibanaSearch(cfg, buildOrderPriceQuery(accountId, lookbackHours, sellAssetId, maxResults));
+}
+
+async function fetchFillPrices(accountId: string, lookbackHours: number, config: any = {}, paysAssetId: string | null = null, maxResults: number = 500) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return kibanaSearch(cfg, buildFillPriceQuery(accountId, lookbackHours, paysAssetId, maxResults));
+}
+
+async function fetchDailyActivity(accountId: string, lookbackHours: number, config: any = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return kibanaSearch(cfg, buildDailyActivityQuery(accountId, lookbackHours));
+}
+
+async function fetchAssetDiscovery(accountId: string, lookbackHours: number, config: any = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return kibanaSearch(cfg, buildAssetDiscoveryQuery(accountId, lookbackHours));
+}
+
+// ─── Discovery query builders ─────────────────────────────────────────────────
+
+/**
+ * Top N accounts by limit_order_create count (seller field).
+ * Use this to discover the most active order-placing accounts.
+ */
+function buildTopSellerAccountsQuery(lookbackHours: number, topN: number = 100, minCreates: number = 10) {
+    return {
+        size: 0,
+        query: {
+            bool: {
+                filter: [
+                    { term:  { operation_type: OP_LIMIT_ORDER_CREATE } },
+                    { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+                ],
+            },
+        },
+        aggs: {
+            by_account: {
+                terms: {
+                    field:          'operation_history.op_object.seller.keyword',
+                    size:           topN,
+                    min_doc_count:  minCreates,
+                    order:          { _count: 'desc' },
+                },
+            },
+        },
+    };
+}
+
+/**
+ * Top N accounts by limit_order_cancel count (fee_paying_account field).
+ */
+function buildTopCancellerAccountsQuery(lookbackHours: number, topN: number = 100, minCancels: number = 5) {
+    return {
+        size: 0,
+        query: {
+            bool: {
+                filter: [
+                    { term:  { operation_type: OP_LIMIT_ORDER_CANCEL } },
+                    { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+                ],
+            },
+        },
+        aggs: {
+            by_account: {
+                terms: {
+                    field:         'operation_history.op_object.fee_paying_account.keyword',
+                    size:          topN,
+                    min_doc_count: minCancels,
+                    order:         { _count: 'desc' },
+                },
+            },
+        },
+    };
+}
+
+/**
+ * Top N accounts by fill_order count (account_id field).
+ */
+function buildTopFilledAccountsQuery(lookbackHours: number, topN: number = 100, minFills: number = 3) {
+    return {
+        size: 0,
+        query: {
+            bool: {
+                filter: [
+                    { term:  { operation_type: OP_FILL_ORDER } },
+                    { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+                ],
+            },
+        },
+        aggs: {
+            by_account: {
+                terms: {
+                    field:         'operation_history.op_object.account_id.keyword',
+                    size:          topN,
+                    min_doc_count: minFills,
+                    order:         { _count: 'desc' },
+                },
+            },
+        },
+    };
+}
+
+// ─── Exports ──────────────────────────────────────────────────────────────────
+
+export { OP_LIMIT_ORDER_CREATE, OP_LIMIT_ORDER_CANCEL, OP_FILL_ORDER, DEFAULT_CONFIG, kibanaSearch, buildOrderCreateQuery, buildFillOrderQuery, buildOrderCancelQuery, buildDailyActivityQuery, buildAssetDiscoveryQuery, buildOrderPriceQuery, buildFillPriceQuery, fetchOrderCreate, fetchFillOrder, fetchOrderCancel, fetchOrderPrices, fetchFillPrices, fetchDailyActivity, fetchAssetDiscovery, buildTopSellerAccountsQuery, buildTopCancellerAccountsQuery, buildTopFilledAccountsQuery }
+

package/analysis/chart_css.ts

@@ -0,0 +1,60 @@
+
+'use strict';
+
+/**
+ * Shared CSS fragments for uPlot chart generators.
+ *
+ * All functions return raw CSS strings for interpolation into HTML template
+ * literals. Consumers compose these fragments inside their `<style>` blocks.
+ */
+
+function baseResetCSS(): string {
+    return `* { box-sizing: border-box; }
+        body { background: #0b0e14; color: #d1d5db; font-family: 'Segoe UI', sans-serif; margin: 0; padding: 0; overflow: hidden; }`;
+}
+
+function headerCSS(height = 45): string {
+    return `#header { padding: 10px 20px; background: #161b22; border-bottom: 1px solid #30363d; display: flex; align-items: center; justify-content: space-between; height: ${height}px; z-index: 100; }`;
+}
+
+function panelsCSS(headerHeight = 45): string {
+    return `#panels { display: flex; flex-direction: column; height: calc(100vh - ${headerHeight}px); width: 100vw; }`;
+}
+
+function uplotBgCSS(): string {
+    return `.uplot { background: #0b0e14; }`;
+}
+
+function dotCSS(): string {
+    return `.dot { width: 10px; height: 10px; border-radius: 2px; flex-shrink: 0; }`;
+}
+
+function cursorCSS(): string {
+    return `.u-cursor-x { border-left: 1px dashed rgba(255,255,255,0.3) !important; }
+        .u-cursor-y { border-top:  1px dashed rgba(255,255,255,0.3) !important; display: none; }
+        .is-hovered .u-cursor-y { display: block; }`;
+}
+
+function sectionLabelCSS(): string {
+    return `.section-label { position: absolute; top: 8px; right: 12px; font-size: 9px; color: #30363d; text-transform: uppercase; letter-spacing: 1px; z-index: 10; pointer-events: none; }`;
+}
+
+function legendCSS(): string {
+    return `.legend { position: absolute; top: 8px; left: 12px; font-size: 11px; pointer-events: none; z-index: 10; display: flex; gap: 14px; color: #adbac7; white-space: nowrap; align-items: center; }
+        .legend-item { display: flex; align-items: center; gap: 5px; }`;
+}
+
+function sharedChartCSS(): string {
+    return [
+        baseResetCSS(),
+        headerCSS(),
+        panelsCSS(),
+        uplotBgCSS(),
+        dotCSS(),
+        cursorCSS(),
+        sectionLabelCSS(),
+        legendCSS(),
+    ].join('\n        ');
+}
+
+export { baseResetCSS, headerCSS, panelsCSS, uplotBgCSS, dotCSS, cursorCSS, sectionLabelCSS, legendCSS, sharedChartCSS }

package/analysis/chart_ui.ts

@@ -0,0 +1,106 @@
+
+'use strict';
+
+/**
+ * Shared browser-side JavaScript helpers for uPlot chart generators.
+ *
+ * All functions return raw JS code strings for interpolation into inline
+ * `<script>` template literals. Consumers embed these alongside their own
+ * chart-specific logic.
+ */
+
+const Y_AXIS_SIZE = 58;
+
+/**
+ * Return the uPlot cursor config object literal.
+ * Consumers must define `SYNC_KEY` before calling this.
+ */
+function makeCursorConfig(): string {
+    return `{
+            show: true,
+            x: true,
+            y: true,
+            points: { show: false },
+            drag: { x: false, y: false, setScale: false },
+            sync: { key: SYNC_KEY, setSeries: false, scales: ['x', null] },
+            focus: { prox: -1 },
+        }`;
+}
+
+/**
+ * Return the `bindHoverState(chart)` function definition.
+ */
+function bindHoverStateFn(): string {
+    return `function bindHoverState(chart) {
+            const root = chart.root;
+            root.addEventListener('mouseenter', () => root.classList.add('is-hovered'));
+            root.addEventListener('mouseleave', () => root.classList.remove('is-hovered'));
+        }`;
+}
+
+/**
+ * Return the `fmtDate(ts)` browser-side function definition.
+ */
+function fmtDateFn(): string {
+    return `function fmtDate(ts) {
+            if (ts == null) return '-';
+            const d = new Date(ts * 1000);
+            return d.toLocaleDateString('en-GB', { day: '2-digit', month: 'short', year: '2-digit' })
+                 + ' ' + d.toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+        }`;
+}
+
+/**
+ * Return the chart event wiring loop that binds mousemove, mouseleave,
+ * hover-state, wheelZoom, and pan on each chart.
+ *
+ * @param chartsVar  JS variable name holding the charts array (e.g. `'charts'`)
+ * @param updateFn   name of the legend update function (e.g. `'updateLegend'`)
+ * @param fallback   expression for the mouseleave fallback index
+ *                   (e.g. `'lastLiveIdx'`, `'null'`, or `'shiftChart.cursor.idx ?? data.realBarCount - 1'`)
+ */
+function wireChartEvents(chartsVar: string, updateFn: string, fallback: string): string {
+    return `let leavePending = null;
+            ${chartsVar}.forEach(chart => {
+                chart.over.addEventListener('mousemove', () => {
+                    if (leavePending !== null) { clearTimeout(leavePending); leavePending = null; }
+                    ${updateFn}(chart.cursor.idx);
+                });
+                chart.over.addEventListener('mouseleave', () => {
+                    leavePending = setTimeout(() => { leavePending = null; ${updateFn}(${fallback}); }, 60);
+                });
+                bindHoverState(chart);
+                bindWheelZoom(chart);
+                bindPan(chart);
+            });`;
+}
+
+/**
+ * Return the Ctrl+0 zoom-reset keyboard shortcut handler.
+ * Consumers must define `xMin`, `xMax`, and `syncXRange` before calling this.
+ */
+function zoomResetScript(): string {
+    return `window.addEventListener('keydown', (e) => {
+            if ((e.ctrlKey || e.metaKey) && e.key === '0') syncXRange(xMin, xMax);
+        });`;
+}
+
+/**
+ * Return the `sizeCharts()` function definition.
+ *
+ * @param pairs  array of [chartVariableName, panelDomId] pairs
+ *               e.g. `[['priceChart', 'price-panel'], ['kalmanChart', 'kalman-panel']]`
+ */
+function sizeChartsFn(pairs: Array<[string, string]>): string {
+    const entries = pairs.map(([chartVar, panelId]) => `[${chartVar}, '${panelId}']`).join(', ');
+    const nullCheck = pairs.map(([chartVar]) => `!${chartVar}`).join(' || ');
+    return `function sizeCharts() {
+            if (${nullCheck}) return;
+            [${entries}].forEach(([chart, id]) => {
+                const el = document.getElementById(id);
+                chart.setSize({ width: el.offsetWidth, height: el.offsetHeight });
+            });
+        }`;
+}
+
+export { Y_AXIS_SIZE, makeCursorConfig, bindHoverStateFn, fmtDateFn, wireChartEvents, zoomResetScript, sizeChartsFn }

package/{dist/analysis/chart_utils.js → analysis/chart_utils.ts}

@@ -1,36 +1,42 @@
+
 import fs from 'node:fs';
 import path from 'node:path';
 import { getStorage } from '../modules/storage/index.js';
 const { ensureDir } = getStorage();
 'use strict';
+
 /**
  * Chart utilities for analysis HTML generators.
  */
-function escapeHtml(str) {
-    const map = {
+
+
+function escapeHtml(str: string) {
+    const map: Record<string, string> = {
         '&': '&amp;',
         '<': '&lt;',
         '>': '&gt;',
         '"': '&quot;',
         "'": '&#039;',
     };
-    return String(str).replace(/[&<>"']/g, (m) => map[m]);
+    return String(str).replace(/[&<>"']/g, (m: any) => map[m]);
 }
-function serializeJsonForScript(value) {
+
+function serializeJsonForScript(value: any) {
     return JSON.stringify(value).replace(/</g, '\\u003c');
 }
-function toEpochSeconds(ts, fallbackIdx) {
+
+function toEpochSeconds(ts: any, fallbackIdx: any) {
     const ms = new Date(ts).getTime();
-    if (Number.isFinite(ms))
-        return Math.floor(ms / 1000);
+    if (Number.isFinite(ms)) return Math.floor(ms / 1000);
     return fallbackIdx * 3600;
 }
-function writeChartFile(filePath, html) {
+
+function writeChartFile(filePath: any, html: any) {
     const chartDir = path.dirname(filePath);
-    if (!fs.existsSync(chartDir))
-        ensureDir(chartDir);
+    if (!fs.existsSync(chartDir)) ensureDir(chartDir);
     fs.writeFileSync(filePath, html, 'utf8');
 }
+
 /**
  * Serialize the exact source of the given pure functions for injection into a
  * generated HTML <script> block. Each function is emitted as a top-level
@@ -42,10 +48,11 @@ function writeChartFile(filePath, html) {
  * The emitted block is wrapped in marker comments so test harnesses can extract
  * the embedded sources reliably regardless of the function list or ordering.
  */
-function embedFunctionSources(fns) {
+function embedFunctionSources(fns: Array<Function>): string {
     const sources = fns.map((fn) => fn.toString()).join('\n\n');
     return `/* EMBEDDED_FUNCS_START */\n${sources}\n/* EMBEDDED_FUNCS_END */`;
 }
+
 /**
  * Shared uPlot interaction boilerplate for embedded browser scripts.
  * Consumers must define `xMin`, `xMax`, `charts`, `pendingRange`, and `pendingRangeRaf`
@@ -149,5 +156,6 @@ function bindPan(chart) {
     });
 }
 `;
-export { escapeHtml, serializeJsonForScript, toEpochSeconds, writeChartFile, embedFunctionSources, UPLOT_SHARED_SCRIPT };
-//# sourceMappingURL=chart_utils.js.map
+
+export { escapeHtml, serializeJsonForScript, toEpochSeconds, writeChartFile, embedFunctionSources, UPLOT_SHARED_SCRIPT }
+