minterm 0.1.0

package/src/adapters/base-adapter.js

@@ -0,0 +1,59 @@
+/** Base data adapter — all adapters extend this */
+
+import { Emitter } from '../emitter.js';
+
+export class BaseAdapter extends Emitter {
+  /**
+   * @param {object} [opts]
+   * @param {number} [opts.throttle=0] — min ms between emissions (0=no throttle)
+   * @param {(raw:any)=>any} [opts.transform] — transform raw data before emitting
+   */
+  constructor(opts = {}) {
+    super();
+    this._throttle = opts.throttle || 0;
+    this._transform = opts.transform || null;
+    this._lastEmit = -Infinity;
+    this._pending = null;
+    this._throttleTimer = null;
+  }
+
+  /** Subclasses call this to emit data through the throttle/transform pipeline */
+  _emitData(raw) {
+    const data = this._transform ? this._transform(raw) : raw;
+    if (data == null) return;
+
+    if (this._throttle <= 0) {
+      this.emit('data', data);
+      return;
+    }
+
+    const now = performance.now();
+    const elapsed = now - this._lastEmit;
+    if (elapsed >= this._throttle) {
+      this._lastEmit = now;
+      this.emit('data', data);
+    } else {
+      // Keep latest, drop intermediates
+      this._pending = data;
+      if (!this._throttleTimer) {
+        this._throttleTimer = setTimeout(() => {
+          this._throttleTimer = null;
+          if (this._pending != null) {
+            this._lastEmit = performance.now();
+            this.emit('data', this._pending);
+            this._pending = null;
+          }
+        }, this._throttle - elapsed);
+      }
+    }
+  }
+
+  /** Override in subclass */
+  connect() {}
+
+  /** Override in subclass */
+  disconnect() {
+    if (this._throttleTimer) clearTimeout(this._throttleTimer);
+    this._pending = null;
+  }
+}

package/src/adapters/manual-adapter.js

@@ -0,0 +1,14 @@
+/** Manual push adapter — call .push(data) to emit */
+
+import { BaseAdapter } from './base-adapter.js';
+
+export class ManualAdapter extends BaseAdapter {
+  constructor(opts = {}) {
+    super(opts);
+  }
+
+  /** Push data through the adapter pipeline */
+  push(data) {
+    this._emitData(data);
+  }
+}

package/src/adapters/nats-adapter.js

@@ -0,0 +1,42 @@
+/** NATS adapter — requires nats.ws at runtime */
+
+import { BaseAdapter } from './base-adapter.js';
+
+export class NatsAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts
+   * @param {string} opts.servers — NATS server URL (e.g. 'wss://nats.example.com')
+   * @param {string} opts.subject — NATS subject to subscribe to
+   * @param {object} [opts.natsConnect] — the `connect` function from nats.ws (injected to avoid hard dependency)
+   * @param {number} [opts.throttle=0]
+   * @param {(raw:any)=>any} [opts.transform]
+   */
+  constructor(opts = {}) {
+    super(opts);
+    this._servers = opts.servers;
+    this._subject = opts.subject;
+    this._natsConnect = opts.natsConnect;
+    this._nc = null;
+    this._sub = null;
+  }
+
+  async connect() {
+    if (!this._natsConnect) throw new Error('NatsAdapter requires opts.natsConnect (from nats.ws)');
+    this._nc = await this._natsConnect({ servers: this._servers });
+    this.emit('open');
+    this._sub = this._nc.subscribe(this._subject);
+    (async () => {
+      for await (const msg of this._sub) {
+        let data;
+        try { data = JSON.parse(msg.data); } catch { data = msg.string(); }
+        this._emitData(data);
+      }
+    })();
+  }
+
+  async disconnect() {
+    if (this._sub) { this._sub.unsubscribe(); this._sub = null; }
+    if (this._nc) { await this._nc.close(); this._nc = null; }
+    super.disconnect();
+  }
+}

package/src/adapters/redis-adapter.js

@@ -0,0 +1,83 @@
+/** Redis Pub/Sub adapter — requires a redis client at runtime */
+
+import { BaseAdapter } from './base-adapter.js';
+
+export class RedisAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts
+   * @param {object} opts.client — a redis client instance (e.g. from 'redis' or 'ioredis')
+   * @param {string|string[]} opts.channels — channel(s) to subscribe to
+   * @param {string|string[]} [opts.patterns] — pattern(s) to psubscribe to (e.g. 'sensor:*')
+   * @param {number} [opts.throttle=0]
+   * @param {(raw:any)=>any} [opts.transform]
+   */
+  constructor(opts = {}) {
+    super(opts);
+    this._client = opts.client;
+    this._channels = opts.channels ? [].concat(opts.channels) : [];
+    this._patterns = opts.patterns ? [].concat(opts.patterns) : [];
+    this._sub = null;
+    this._handler = (msg, channel) => {
+      let data;
+      try { data = JSON.parse(msg); } catch { data = msg; }
+      this._emitData({ channel, data });
+    };
+    this._pHandler = (msg, channel, pattern) => {
+      let data;
+      try { data = JSON.parse(msg); } catch { data = msg; }
+      this._emitData({ channel, pattern, data });
+    };
+  }
+
+  async connect() {
+    if (!this._client) throw new Error('RedisAdapter requires opts.client (redis/ioredis instance)');
+
+    // ioredis: client.duplicate() exists; node-redis: client.duplicate() exists
+    // We need a dedicated subscriber since redis clients in subscribe mode can't run other commands
+    if (typeof this._client.duplicate === 'function') {
+      this._sub = this._client.duplicate();
+    } else {
+      this._sub = this._client;
+    }
+
+    // node-redis v4 requires explicit connect
+    if (typeof this._sub.connect === 'function' && !this._sub.isOpen) {
+      await this._sub.connect();
+    }
+
+    // Detect API style: ioredis uses .on('message'), node-redis v4 uses .subscribe(channel, callback)
+    if (typeof this._sub.on === 'function' && typeof this._sub.subscribe === 'function') {
+      // ioredis style
+      if (this._channels.length) {
+        this._sub.on('message', this._handler);
+        await this._sub.subscribe(...this._channels);
+      }
+      if (this._patterns.length) {
+        this._sub.on('pmessage', this._pHandler);
+        await this._sub.psubscribe(...this._patterns);
+      }
+    }
+
+    this.emit('open');
+  }
+
+  async disconnect() {
+    if (this._sub) {
+      if (this._channels.length && typeof this._sub.unsubscribe === 'function') {
+        await this._sub.unsubscribe(...this._channels);
+      }
+      if (this._patterns.length && typeof this._sub.punsubscribe === 'function') {
+        await this._sub.punsubscribe(...this._patterns);
+      }
+      if (typeof this._sub.removeListener === 'function') {
+        this._sub.removeListener('message', this._handler);
+        this._sub.removeListener('pmessage', this._pHandler);
+      }
+      if (typeof this._sub.quit === 'function') {
+        await this._sub.quit();
+      }
+      this._sub = null;
+    }
+    super.disconnect();
+  }
+}

package/src/adapters/rest-poller.js

@@ -0,0 +1,42 @@
+/** REST polling adapter — fetches a URL on an interval */
+
+import { BaseAdapter } from './base-adapter.js';
+
+export class RestPoller extends BaseAdapter {
+  /**
+   * @param {string} url
+   * @param {object} [opts]
+   * @param {number} [opts.interval=5000] — polling interval ms
+   * @param {RequestInit} [opts.fetchOpts] — passed to fetch()
+   * @param {number} [opts.throttle=0]
+   * @param {(raw:any)=>any} [opts.transform]
+   */
+  constructor(url, opts = {}) {
+    super(opts);
+    this._url = url;
+    this._interval = opts.interval ?? 5000;
+    this._fetchOpts = opts.fetchOpts || {};
+    this._timer = null;
+  }
+
+  connect() {
+    this._poll();
+    this._timer = setInterval(() => this._poll(), this._interval);
+  }
+
+  disconnect() {
+    if (this._timer) { clearInterval(this._timer); this._timer = null; }
+    super.disconnect();
+  }
+
+  async _poll() {
+    try {
+      const res = await fetch(this._url, this._fetchOpts);
+      if (!res.ok) { this.emit('error', new Error(`HTTP ${res.status}`)); return; }
+      const data = await res.json();
+      this._emitData(data);
+    } catch (err) {
+      this.emit('error', err);
+    }
+  }
+}

package/src/adapters/websocket-adapter.js

@@ -0,0 +1,59 @@
+/** WebSocket data adapter with auto-reconnect */
+
+import { BaseAdapter } from './base-adapter.js';
+
+export class WebSocketAdapter extends BaseAdapter {
+  /**
+   * @param {string} url — WebSocket URL
+   * @param {object} [opts]
+   * @param {boolean} [opts.reconnect=true] — auto-reconnect on close
+   * @param {number} [opts.reconnectDelay=3000] — ms before reconnect
+   * @param {number} [opts.throttle=0]
+   * @param {(raw:any)=>any} [opts.transform]
+   */
+  constructor(url, opts = {}) {
+    super(opts);
+    this._url = url;
+    this._reconnect = opts.reconnect !== false;
+    this._reconnectDelay = opts.reconnectDelay ?? 3000;
+    this._ws = null;
+    this._closing = false;
+    this._reconnectTimer = null;
+  }
+
+  connect() {
+    this._closing = false;
+    this._ws = new WebSocket(this._url);
+
+    this._ws.onopen = () => this.emit('open');
+
+    this._ws.onmessage = (e) => {
+      let data;
+      try { data = JSON.parse(e.data); } catch { data = e.data; }
+      this._emitData(data);
+    };
+
+    this._ws.onclose = () => {
+      this.emit('close');
+      if (this._reconnect && !this._closing) {
+        this._reconnectTimer = setTimeout(() => this.connect(), this._reconnectDelay);
+      }
+    };
+
+    this._ws.onerror = (err) => this.emit('error', err);
+  }
+
+  disconnect() {
+    this._closing = true;
+    if (this._reconnectTimer) clearTimeout(this._reconnectTimer);
+    if (this._ws) { this._ws.close(); this._ws = null; }
+    super.disconnect();
+  }
+
+  /** Send data to the WebSocket */
+  send(data) {
+    if (this._ws?.readyState === WebSocket.OPEN) {
+      this._ws.send(typeof data === 'string' ? data : JSON.stringify(data));
+    }
+  }
+}

package/src/arrow-overlay.js

@@ -0,0 +1,250 @@
+/** SVG arrow overlay — draws arrows between windows, auto-updates on drag/focus */
+
+import { Emitter } from './emitter.js';
+
+const SVG_NS = 'http://www.w3.org/2000/svg';
+
+export class ArrowOverlay extends Emitter {
+  /**
+   * @param {import('./window-manager.js').WindowManager} wm
+   * @param {object} [opts]
+   * @param {string} [opts.classPrefix='mt']
+   * @param {string} [opts.defaultColor='#0ff']
+   */
+  constructor(wm, opts = {}) {
+    super();
+    this._wm = wm;
+    this._pfx = opts.classPrefix || 'mt';
+    this._defaultColor = opts.defaultColor || '#0ff';
+    this._arrows = {};  // id → arrow config
+    this._groups = {};  // id → { g, line, dot, glow, text } — cached SVG nodes
+    this._svg = null;
+    this._dirty = false;
+    this._rafId = 0;
+
+    const repaint = () => this._schedulePaint();
+    wm.on('window:move', repaint);
+    wm.on('window:resize', repaint);
+    wm.on('window:focus', ({ id, el }) => this._raiseArrowsForWindow(id, el));
+  }
+
+  /**
+   * Set or update an arrow.
+   * @param {string} id — unique arrow id
+   * @param {object} arrow
+   * @param {string} arrow.fromWindow — source window id
+   * @param {string} arrow.toWindow — target window id
+   * @param {number} [arrow.progress=0] — 0-1 position of traveling dot
+   * @param {string} [arrow.label] — text label at midpoint
+   * @param {string} [arrow.color] — arrow color
+   */
+  setArrow(id, arrow) {
+    this._arrows[id] = arrow;
+    this._schedulePaint();
+  }
+
+  removeArrow(id) {
+    delete this._arrows[id];
+    const cached = this._groups[id];
+    if (cached) { cached.g.remove(); delete this._groups[id]; }
+    this._schedulePaint();
+  }
+
+  clearArrows() {
+    this._arrows = {};
+    for (const id in this._groups) { this._groups[id].g.remove(); }
+    this._groups = {};
+  }
+
+  _ensureSvg() {
+    if (this._svg) return this._svg;
+    const svg = document.createElementNS(SVG_NS, 'svg');
+    svg.setAttribute('class', `${this._pfx}-arrow-svg`);
+    svg.innerHTML = '<defs></defs>';
+    document.body.appendChild(svg);
+    this._svg = svg;
+    return svg;
+  }
+
+  _getOrCreateMarker(color) {
+    const svg = this._ensureSvg();
+    const defs = svg.querySelector('defs');
+    const markerId = `${this._pfx}-ah-${color.replace('#', '')}`;
+    if (!defs.querySelector(`#${markerId}`)) {
+      const marker = document.createElementNS(SVG_NS, 'marker');
+      marker.id = markerId;
+      setAttrs(marker, { markerWidth: '8', markerHeight: '6', refX: '7', refY: '3', orient: 'auto' });
+      const poly = document.createElementNS(SVG_NS, 'polygon');
+      setAttrs(poly, { points: '0 0, 8 3, 0 6', fill: color, opacity: '0.8' });
+      marker.appendChild(poly);
+      defs.appendChild(marker);
+    }
+    return markerId;
+  }
+
+  _schedulePaint() {
+    if (this._dirty) return;
+    this._dirty = true;
+    this._rafId = requestAnimationFrame(() => {
+      this._dirty = false;
+      this._paint();
+    });
+  }
+
+  _paint() {
+    const svg = this._ensureSvg();
+    const pfx = this._pfx;
+    const seen = new Set();
+
+    for (const id in this._arrows) {
+      seen.add(id);
+      const arrow = this._arrows[id];
+      const fromEl = this._wm.getWindow(arrow.fromWindow);
+      const toEl = this._wm.getWindow(arrow.toWindow);
+      if (!fromEl || !toEl || fromEl === toEl) {
+        if (this._groups[id]) { this._groups[id].g.style.display = 'none'; }
+        continue;
+      }
+
+      const fromRect = fromEl.getBoundingClientRect();
+      const toRect = toEl.getBoundingClientRect();
+      const fromR = { x: fromRect.left, y: fromRect.top, w: fromRect.width, h: fromRect.height };
+      const toR = { x: toRect.left, y: toRect.top, w: toRect.width, h: toRect.height };
+      const pts = getEdgePoints(fromR, toR);
+      const color = arrow.color || this._defaultColor;
+      const markerId = this._getOrCreateMarker(color);
+      const progress = arrow.progress ?? 0;
+      const dotX = pts.x1 + (pts.x2 - pts.x1) * progress;
+      const dotY = pts.y1 + (pts.y2 - pts.y1) * progress;
+
+      let cached = this._groups[id];
+      if (!cached) {
+        // Create group with all children once
+        const g = document.createElementNS(SVG_NS, 'g');
+        g.setAttribute('class', `${pfx}-arrow-group`);
+        g.dataset.arrowId = id;
+        const line = document.createElementNS(SVG_NS, 'line');
+        line.setAttribute('class', `${pfx}-arrow-line`);
+        setAttrs(line, { 'stroke-width': '1.5', 'stroke-dasharray': '3 5', opacity: '0.6' });
+        const glow = document.createElementNS(SVG_NS, 'circle');
+        setAttrs(glow, { r: '7', opacity: '0.15' });
+        glow.setAttribute('class', `${pfx}-arrow-glow`);
+        const dot = document.createElementNS(SVG_NS, 'circle');
+        setAttrs(dot, { r: '3.5' });
+        dot.setAttribute('class', `${pfx}-arrow-dot`);
+        const text = document.createElementNS(SVG_NS, 'text');
+        text.setAttribute('class', `${pfx}-arrow-label`);
+        g.appendChild(line);
+        g.appendChild(glow);
+        g.appendChild(dot);
+        g.appendChild(text);
+        svg.appendChild(g);
+        cached = { g, line, dot, glow, text };
+        this._groups[id] = cached;
+      }
+
+      // Update attributes (no DOM structure changes)
+      cached.g.style.display = '';
+      cached.g.dataset.arrowFrom = arrow.fromWindow;
+      cached.g.dataset.arrowTo = arrow.toWindow;
+
+      setAttrs(cached.line, {
+        x1: pts.x1, y1: pts.y1, x2: pts.x2, y2: pts.y2,
+        stroke: color, 'marker-end': `url(#${markerId})`,
+      });
+      setAttrs(cached.dot, { cx: dotX, cy: dotY, fill: color });
+      setAttrs(cached.glow, { cx: dotX, cy: dotY, fill: color });
+
+      if (arrow.label) {
+        cached.text.style.display = '';
+        const midX = (pts.x1 + pts.x2) / 2;
+        const midY = (pts.y1 + pts.y2) / 2 - 8;
+        setAttrs(cached.text, { x: midX, y: midY, fill: color });
+        cached.text.textContent = arrow.label;
+      } else {
+        cached.text.style.display = 'none';
+      }
+    }
+
+    // Remove stale groups
+    for (const id in this._groups) {
+      if (!seen.has(id)) {
+        this._groups[id].g.remove();
+        delete this._groups[id];
+      }
+    }
+  }
+
+  _raiseArrowsForWindow(winId, winEl) {
+    if (!this._svg) return;
+    const pfx = this._pfx;
+    let hasMatch = false;
+    for (const g of this._svg.querySelectorAll(`.${pfx}-arrow-group`)) {
+      if (g.dataset.arrowFrom === winId || g.dataset.arrowTo === winId) {
+        this._svg.appendChild(g);
+        hasMatch = true;
+      }
+    }
+    if (hasMatch && winEl) {
+      this._svg.style.zIndex = parseInt(winEl.style.zIndex || 0) + 1;
+    }
+  }
+
+  destroy() {
+    if (this._rafId) cancelAnimationFrame(this._rafId);
+    if (this._svg) { this._svg.remove(); this._svg = null; }
+    this._arrows = {};
+    this._groups = {};
+    super.destroy();
+  }
+}
+
+function setAttrs(el, attrs) {
+  for (const k in attrs) el.setAttribute(k, attrs[k]);
+}
+
+/** Compute edge-to-edge connection points between two rects */
+function getEdgePoints(fromR, toR) {
+  const fromCx = fromR.x + fromR.w / 2, fromCy = fromR.y + fromR.h / 2;
+  const toCx = toR.x + toR.w / 2, toCy = toR.y + toR.h / 2;
+
+  const gap = 6;
+  const hOverlap = fromR.x < toR.x + toR.w + gap && toR.x < fromR.x + fromR.w + gap;
+  const vOverlap = fromR.y < toR.y + toR.h + gap && toR.y < fromR.y + fromR.h + gap;
+
+  if (hOverlap && vOverlap) {
+    const touchBottom = Math.abs((fromR.y + fromR.h) - toR.y) < gap;
+    const touchTop = Math.abs(fromR.y - (toR.y + toR.h)) < gap;
+    const touchRight = Math.abs((fromR.x + fromR.w) - toR.x) < gap;
+    const touchLeft = Math.abs(fromR.x - (toR.x + toR.w)) < gap;
+
+    if (touchBottom || touchTop) {
+      if (fromCx <= toCx) return { x1: fromR.x, y1: fromCy, x2: toR.x, y2: toCy };
+      return { x1: fromR.x + fromR.w, y1: fromCy, x2: toR.x + toR.w, y2: toCy };
+    }
+    if (touchRight || touchLeft) {
+      if (fromCy <= toCy) return { x1: fromCx, y1: fromR.y, x2: toCx, y2: toR.y };
+      return { x1: fromCx, y1: fromR.y + fromR.h, x2: toCx, y2: toR.y + toR.h };
+    }
+  }
+
+  const angle = Math.atan2(toCy - fromCy, toCx - fromCx);
+  const cos = Math.cos(angle), sin = Math.sin(angle);
+
+  const fhw = fromR.w / 2, fhh = fromR.h / 2;
+  const fs = Math.min(
+    cos !== 0 ? fhw / Math.abs(cos) : Infinity,
+    sin !== 0 ? fhh / Math.abs(sin) : Infinity
+  );
+  const x1 = fromCx + cos * fs, y1 = fromCy + sin * fs;
+
+  const cos2 = -cos, sin2 = -sin;
+  const thw = toR.w / 2, thh = toR.h / 2;
+  const ts = Math.min(
+    cos2 !== 0 ? thw / Math.abs(cos2) : Infinity,
+    sin2 !== 0 ? thh / Math.abs(sin2) : Infinity
+  );
+  const x2 = toCx + cos2 * ts, y2 = toCy + sin2 * ts;
+
+  return { x1, y1, x2, y2 };
+}

package/src/emitter.js

@@ -0,0 +1,30 @@
+/** Tiny event emitter — on/off/emit/once/destroy */
+export class Emitter {
+  constructor() { this._e = Object.create(null); }
+
+  on(evt, fn) {
+    (this._e[evt] || (this._e[evt] = [])).push(fn);
+    return this;
+  }
+
+  off(evt, fn) {
+    const a = this._e[evt];
+    if (a) this._e[evt] = a.filter(f => f !== fn && f._w !== fn);
+    return this;
+  }
+
+  emit(evt, a, b) {
+    const list = this._e[evt];
+    if (!list) return this;
+    for (let i = 0, n = list.length; i < n; i++) list[i](a, b);
+    return this;
+  }
+
+  once(evt, fn) {
+    const w = (a, b) => { this.off(evt, w); fn(a, b); };
+    w._w = fn;
+    return this.on(evt, w);
+  }
+
+  destroy() { this._e = Object.create(null); }
+}

package/src/formatters.js

@@ -0,0 +1,41 @@
+/** Formatting helpers for numbers, quantities, and percentages */
+
+export function formatNum(n) {
+  if (n == null || isNaN(n)) return '0';
+  const sign = n < 0 ? '-' : '';
+  const a = Math.abs(n);
+  if (a >= 1e9) return sign + (a / 1e9).toFixed(a >= 1e10 ? 1 : 2) + 'bil';
+  if (a >= 1e6) return sign + (a / 1e6).toFixed(a >= 1e7 ? 1 : 2) + 'mil';
+  if (a >= 10000) return sign + (a / 1e3).toFixed(a >= 1e5 ? 0 : 1) + 'k';
+  if (a >= 1000) return sign + a.toLocaleString(undefined, { maximumFractionDigits: 2 });
+  if (a >= 1) return n.toFixed(2);
+  if (a >= 0.01) return n.toFixed(4);
+  if (a > 0) {
+    const digits = Math.max(4, -Math.floor(Math.log10(a)) + 2);
+    return n.toFixed(Math.min(digits, 12));
+  }
+  return '0';
+}
+
+/** @deprecated Use formatNum instead */
+export const formatPrice = formatNum;
+
+export function formatQty(q) {
+  if (q == null || isNaN(q)) return '0';
+  const a = Math.abs(q);
+  if (a >= 10000) return q.toLocaleString(undefined, { maximumFractionDigits: 0 });
+  if (a >= 100) return q.toLocaleString(undefined, { maximumFractionDigits: 2 });
+  if (a >= 1) return q.toFixed(2);
+  if (a >= 0.01) return q.toFixed(4);
+  if (a > 0) {
+    const digits = Math.max(4, -Math.floor(Math.log10(a)) + 2);
+    return q.toFixed(Math.min(digits, 12));
+  }
+  return '0';
+}
+
+export function formatPct(pct) {
+  if (pct == null || isNaN(pct)) return '0%';
+  const sign = pct > 0 ? '+' : '';
+  return `${sign}${pct.toFixed(1)}%`;
+}

package/src/modal-manager.js

@@ -0,0 +1,70 @@
+/** Modal dialog manager — wraps WindowManager */
+
+export class ModalManager {
+  /**
+   * @param {import('./window-manager.js').WindowManager} wm
+   */
+  constructor(wm) {
+    this._wm = wm;
+    this._pfx = wm._pfx || 'mt';
+    this._id = `${this._pfx}-modal`;
+  }
+
+  show(html, opts = {}) {
+    this.hide();
+    const { width = 380, title = '' } = opts;
+    const cx = Math.floor(window.innerWidth / 2) - Math.floor(width / 2);
+    const cy = Math.floor(window.innerHeight / 2) - 120;
+    this._wm.createWindow(this._id, { x: cx, y: cy, width, closable: true, title });
+    const body = this._wm.getBody(this._id);
+    if (body) body.innerHTML = html;
+    this._wm.focus(this._id);
+  }
+
+  hide() {
+    if (this._wm.has(this._id)) this._wm.closeWindow(this._id);
+  }
+
+  confirm(message, opts = {}) {
+    const { okText = 'OK', cancelText = 'Cancel', title = 'Confirm' } = opts;
+    const pfx = this._pfx;
+    return new Promise(resolve => {
+      this.show(`
+        <div class="${pfx}-modal-body">${message}</div>
+        <div class="${pfx}-modal-footer">
+          <button class="${pfx}-btn ${pfx}-modal-ok">${okText}</button>
+          <button class="${pfx}-btn ${pfx}-modal-cancel">${cancelText}</button>
+        </div>`, { title });
+      const body = this._wm.getBody(this._id);
+      if (!body) return resolve(false);
+      body.querySelector(`.${pfx}-modal-ok`).onclick = () => { this.hide(); resolve(true); };
+      body.querySelector(`.${pfx}-modal-cancel`).onclick = () => { this.hide(); resolve(false); };
+    });
+  }
+
+  prompt(message, opts = {}) {
+    const { defaultValue = '', okText = 'OK', cancelText = 'Cancel', title = 'Input' } = opts;
+    const pfx = this._pfx;
+    return new Promise(resolve => {
+      this.show(`
+        <div class="${pfx}-modal-body">${message}</div>
+        <input class="${pfx}-input ${pfx}-modal-input" type="text" value="${defaultValue}">
+        <div class="${pfx}-modal-footer">
+          <button class="${pfx}-btn ${pfx}-modal-ok">${okText}</button>
+          <button class="${pfx}-btn ${pfx}-modal-cancel">${cancelText}</button>
+        </div>`, { title });
+      const body = this._wm.getBody(this._id);
+      if (!body) return resolve(null);
+      const input = body.querySelector(`.${pfx}-modal-input`);
+      body.querySelector(`.${pfx}-modal-ok`).onclick = () => { this.hide(); resolve(input.value); };
+      body.querySelector(`.${pfx}-modal-cancel`).onclick = () => { this.hide(); resolve(null); };
+      input.focus();
+      input.onkeydown = (e) => {
+        if (e.key === 'Enter') { this.hide(); resolve(input.value); }
+        if (e.key === 'Escape') { this.hide(); resolve(null); }
+      };
+    });
+  }
+
+  get isOpen() { return this._wm.has(this._id); }
+}