@hoox-sh/pynets 0.9.0 → 0.10.0

package/dist/index.js

@@ -33581,6 +33581,31 @@ function tokenize(source) {
   }
   return tokens;
 }
+// src/runtime/clone.ts
+function cloneValue(v) {
+  if (v == null)
+    return v;
+  if (typeof v !== "object")
+    return v;
+  if (Array.isArray(v))
+    return v.map(cloneValue);
+  if (v instanceof Map) {
+    const out = new Map;
+    for (const [k, x] of v)
+      out.set(k, cloneValue(x));
+    return out;
+  }
+  if (v instanceof Set)
+    return new Set(v);
+  const clone = v.clone;
+  if (typeof clone === "function")
+    return clone.call(v);
+  const out = {};
+  for (const [k, x] of Object.entries(v))
+    out[k] = cloneValue(x);
+  return out;
+}
+
 // src/runtime/udt.ts
 class UdtType {
   name;
@@ -33637,6 +33662,22 @@ class UdtInstance {
   getMethod(name) {
     return this.type.getMethod(name);
   }
+  clone() {
+    const out = new UdtInstance(this.type);
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+  snapshotContents() {
+    const out = [];
+    for (const [k, v] of this.values)
+      out.push([k, cloneValue(v)]);
+    return out;
+  }
+  restoreContents(snap) {
+    this.values.clear();
+    for (const [k, v] of snap)
+      this.values.set(k, cloneValue(v));
+  }
 }
 
 class EnumMember {
@@ -33910,6 +33951,19 @@ class PineArray {
       out.push(v);
     return out;
   }
+  clone() {
+    const out = new PineArray;
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+  snapshotContents() {
+    return this.cells.map(cloneValue);
+  }
+  restoreContents(snap) {
+    this.cells.length = 0;
+    for (const c of snap)
+      this.cells.push(cloneValue(c));
+  }
   reverse() {
     this.cells.reverse();
   }
@@ -36928,6 +36982,12 @@ class PineSeries {
     else
       this.data[this.data.length - 1] = value;
   }
+  truncate(len) {
+    if (len < 0)
+      return;
+    if (this.data.length > len)
+      this.data.length = len;
+  }
   get current() {
     return this.data.length === 0 ? NA : this.data[this.data.length - 1];
   }
@@ -37555,6 +37615,30 @@ class StrategyBook {
     if (settings)
       this.applyDeclSettings(settings);
   }
+  snapshot() {
+    const out = {};
+    for (const [key, value] of Object.entries(this)) {
+      if (typeof value === "function")
+        continue;
+      out[key] = cloneValue(value);
+    }
+    return out;
+  }
+  restore(snap) {
+    const self = this;
+    for (const [key, value] of Object.entries(snap)) {
+      const live = self[key];
+      if (Array.isArray(live)) {
+        live.length = 0;
+        for (const item of value)
+          live.push(cloneValue(item));
+      } else if (live !== null && typeof live === "object" && value !== null && typeof value === "object") {
+        Object.assign(live, value);
+      } else {
+        self[key] = cloneValue(value);
+      }
+    }
+  }
   capitalHeld() {
     let notional = 0;
     for (const t of this.openTrades) {
@@ -38847,6 +38931,25 @@ class PineMap {
       out.put(decodeKey(k), this.data.get(k));
     return out;
   }
+  clone() {
+    const out = new PineMap;
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+  snapshotContents() {
+    const data = [];
+    for (const [k, v] of this.data)
+      data.push([k, cloneValue(v)]);
+    return { data, order: [...this.order] };
+  }
+  restoreContents(snap) {
+    this.data.clear();
+    this.order.length = 0;
+    for (const [k, v] of snap.data)
+      this.data.set(k, cloneValue(v));
+    for (const k of snap.order)
+      this.order.push(k);
+  }
   putAll(other) {
     if (!(other instanceof PineMap))
       return;
@@ -39436,6 +39539,25 @@ class PineMatrix {
         row[j] = value;
     }
   }
+  clone() {
+    const out = new PineMatrix(this.nRows, this.nCols);
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+  snapshotContents() {
+    return {
+      cells: this.cells.map((row) => row.map(cloneValue)),
+      nRows: this.nRows,
+      nCols: this.nCols
+    };
+  }
+  restoreContents(snap) {
+    this.cells.length = 0;
+    for (const row of snap.cells)
+      this.cells.push(row.map(cloneValue));
+    this.nRows = snap.nRows;
+    this.nCols = snap.nCols;
+  }
   transpose() {
     const t = new PineMatrix(this.nCols, this.nRows);
     for (let i = 0;i < this.nRows; i++) {
@@ -40538,6 +40660,29 @@ class TaEngine {
   historySites = new Map;
   momentumFilterSites = new Map;
   volatilityRegimeSites = new Map;
+  snapshot() {
+    const out = [];
+    for (const [key, value] of Object.entries(this)) {
+      if (!(value instanceof Map))
+        continue;
+      const copy = new Map;
+      for (const [site, state] of value)
+        copy.set(site, cloneValue(state));
+      out.push([key, copy]);
+    }
+    return out;
+  }
+  restore(snap) {
+    const self = this;
+    for (const [key, copy] of snap) {
+      const live = self[key];
+      if (!(live instanceof Map))
+        continue;
+      live.clear();
+      for (const [site, state] of copy)
+        live.set(site, cloneValue(state));
+    }
+  }
   sma(site, source, period) {
     const n = pinePeriod(period);
     if (n === null)
@@ -45293,6 +45438,15 @@ function unwrapSpecialize(node) {
     return n.value;
   return node;
 }
+function isArrayReturningCall(func) {
+  const { name } = resolveCallee(func);
+  if (name === "ta_gamma_levels" || name === "gamma_levels")
+    return true;
+  if (name === "array_from" || name === "array_copy" || name === "array_concat" || name === "array_slice") {
+    return true;
+  }
+  return name.startsWith("array_new");
+}
 function collectArgs(node, visit) {
   const pos = [];
   const kw = {};
@@ -47341,6 +47495,7 @@ var RESERVED2 = new Set([
 function newEmitCtx() {
   return {
     arrays: new Set,
+    arrayNames: new Set,
     plots: [],
     varNames: new Set,
     functions: [],
@@ -48155,6 +48310,9 @@ function emitAttribute(state, node) {
 function emitSubscript(state, node) {
   const slice = node.slice != null ? emitExpr2(state, node.slice) : "0";
   const arr = histArray(state, node.value);
+  if (node.value.kind === "Name" && state.ctx.arrayNames.has(node.value.id)) {
+    return `__h.array.sub(${arr}[__bar_idx], ${slice})`;
+  }
   return `__h.hist(${arr}, __bar_idx, ${slice})`;
 }
 function histArray(state, value) {
@@ -48253,11 +48411,22 @@ function emitImport2(state, node) {
 function emitAssign2(state, node) {
   const rhs = node.value != null ? emitExpr2(state, node.value) : "null";
   const isVar = isVarMode2(node.mode);
+  trackArrayName(state, node.target, node.value);
   return emitStore(state, node.target, rhs, isVar);
 }
 function emitReAssign2(state, node) {
+  trackArrayName(state, node.target, node.value);
   return emitStore(state, node.target, emitExpr2(state, node.value), false);
 }
+function trackArrayName(state, target, value) {
+  if (target.kind !== "Name")
+    return;
+  if (value != null && value.kind === "Call" && isArrayReturningCall(value.func)) {
+    state.ctx.arrayNames.add(target.id);
+  } else {
+    state.ctx.arrayNames.delete(target.id);
+  }
+}
 function emitAugAssign2(state, node) {
   if (node.target.kind === "Attribute") {
     return emitStore(state, node.target, emitExpr2(state, node.value), false);
@@ -48903,6 +49072,15 @@ var compileArray = {
   get(id, index) {
     return asArray(id)?.get(n2(index, 0)) ?? null;
   },
+  sub(id, offset) {
+    const a = asArray(id);
+    const off = cell(offset);
+    if (a == null || off == null || off < 0)
+      return null;
+    const size = a.size();
+    const i = size - 1 - Math.trunc(off);
+    return i < 0 || i >= size ? null : a.get(i);
+  },
   set(id, index, value) {
     asArray(id)?.set(n2(index, 0), store(value));
     return id ?? null;
@@ -50903,6 +51081,12 @@ class Runtime {
     const extraOpts = extra && !isPlainInputs(extra) ? extra : undefined;
     const mode = extraOpts?.mode ?? this.mode;
     const inputs = mergeInputs(this.inputs, extra);
+    const rt = resolveRealtimeWindow(ohlcv.length, {
+      realtimeLastBar: extraOpts?.realtimeLastBar,
+      realtimeTicks: extraOpts?.realtimeTicks,
+      realtimeBars: extraOpts?.realtimeBars,
+      realtimeFromBar: extraOpts?.realtimeFromBar
+    });
     const host = {
       symbol: this.symbol,
       inputs,
@@ -50910,7 +51094,8 @@ class Runtime {
       timeframe: extraOpts?.timeframe ?? this.timeframe,
       libraries: extraOpts?.libraries != null ? resolveLibraries(extraOpts.libraries) : this.libraries,
       timeout_seconds: extraOpts?.timeout_seconds ?? this.timeout_seconds,
-      realtime_last_bar: extraOpts?.realtimeLastBar ?? false
+      realtime_first: rt.first,
+      realtime_ticks: rt.ticks
     };
     if (mode === "compile") {
       return runCompiled(source, ohlcv, host);
@@ -51018,6 +51203,106 @@ function interpret(source, ohlcv) {
     throw new Error(out.error);
   return { plots: out.plots };
 }
+function isSnapshotContainer(v) {
+  return v !== null && typeof v === "object" && typeof v.snapshotContents === "function";
+}
+function isRestoreContainer(v) {
+  return v !== null && typeof v === "object" && typeof v.restoreContents === "function";
+}
+function snapshotTickState(env) {
+  const containers = [];
+  for (const [id, v] of Object.entries(env.ctx)) {
+    if (isSnapshotContainer(v)) {
+      containers.push([id, v.snapshotContents()]);
+    }
+  }
+  const plotsLens = new Map;
+  for (const [key, arr] of Object.entries(env.plots))
+    plotsLens.set(key, arr.length);
+  const udfSites = [];
+  for (const [key, f] of env.udfSites) {
+    const seriesLens = new Map;
+    for (const [name, s] of f.series)
+      seriesLens.set(name, s.length);
+    udfSites.push([key, { ...f.ctx }, new Set(f.varInited), seriesLens]);
+  }
+  return {
+    ctx: { ...env.ctx },
+    containers,
+    varInited: new Set(env.varInited),
+    plotsLens,
+    plotMetaLen: env.plot_meta.length,
+    ta: env.ta.snapshot(),
+    book: env.book.snapshot(),
+    udfSites
+  };
+}
+function restoreTickState(env, snap) {
+  const varips = env.varipNames;
+  for (const key of Object.keys(env.ctx)) {
+    if (!(key in snap.ctx) && !varips.has(key))
+      delete env.ctx[key];
+  }
+  for (const [key, value] of Object.entries(snap.ctx)) {
+    if (varips.has(key))
+      continue;
+    env.ctx[key] = value;
+  }
+  for (const [id, contents] of snap.containers) {
+    if (varips.has(id))
+      continue;
+    const cur = env.ctx[id];
+    if (isRestoreContainer(cur)) {
+      cur.restoreContents(contents);
+    }
+  }
+  const restoredInited = new Set(snap.varInited);
+  for (const id of varips) {
+    if (env.varInited.has(id))
+      restoredInited.add(id);
+  }
+  env.varInited = restoredInited;
+  for (const key of Object.keys(env.plots)) {
+    const len = snap.plotsLens.get(key);
+    if (len === undefined)
+      delete env.plots[key];
+    else if (env.plots[key].length > len)
+      env.plots[key].length = len;
+  }
+  env.plot_meta.length = snap.plotMetaLen;
+  env.ta.restore(snap.ta);
+  env.book.restore(snap.book);
+  const siteKeys = new Set(snap.udfSites.map(([key]) => key));
+  for (const key of [...env.udfSites.keys()]) {
+    if (!siteKeys.has(key))
+      env.udfSites.delete(key);
+  }
+  for (const [key, ctx, varInited, seriesLens] of snap.udfSites) {
+    const f = env.udfSites.get(key);
+    if (f == null)
+      continue;
+    for (const k of Object.keys(f.ctx)) {
+      if (!(k in ctx) && !varips.has(k))
+        delete f.ctx[k];
+    }
+    for (const [k, v] of Object.entries(ctx)) {
+      if (varips.has(k))
+        continue;
+      f.ctx[k] = v;
+    }
+    for (const [name, len] of seriesLens) {
+      const s = f.series.get(name);
+      if (s != null && s.length > len)
+        s.truncate(len);
+    }
+    const restored = new Set(varInited);
+    for (const id of varips) {
+      if (f.varInited.has(id))
+        restored.add(id);
+    }
+    f.varInited = restored;
+  }
+}
 function interpretTree(tree, ohlcv, host) {
   const scriptNode = tree.kind === "Script" ? tree : null;
   const body = scriptNode?.body ?? [];
@@ -51054,7 +51339,12 @@ function interpretTree(tree, ohlcv, host) {
     onceFired: new WeakSet,
     maxBarsBackDecls: [],
     alertFireBars: new Map,
-    realtimeLastBar: host?.realtime_last_bar ?? false
+    realtimeFirst: host?.realtime_first ?? null,
+    realtimeTicks: Math.max(1, host?.realtime_ticks ?? 1),
+    barRealtime: false,
+    tickIndex: 0,
+    tickCount: 1,
+    varipNames: new Set
   };
   const n = ohlcv.length;
   let runError;
@@ -51062,8 +51352,9 @@ function interpretTree(tree, ohlcv, host) {
   let barsDone = n;
   const timeoutSec = host?.timeout_seconds;
   const deadline = timeoutSec != null && Number.isFinite(timeoutSec) ? performance.now() + timeoutSec * 1000 : null;
+  let aborted = false;
   try {
-    for (let i = 0;i < n; i++) {
+    for (let i = 0;i < n && !aborted; i++) {
       if (deadline != null && (i & 31) === 0 && performance.now() > deadline) {
         timedOut = true;
         barsDone = i;
@@ -51078,33 +51369,44 @@ function interpretTree(tree, ohlcv, host) {
         time: num2(env.ctx.time) ?? undefined
       });
       env.book.markOpenTrades(num2(env.ctx.high) ?? num2(env.ctx.close) ?? 0, num2(env.ctx.low) ?? num2(env.ctx.close) ?? 0, num2(env.ctx.close) ?? 0);
-      try {
-        for (const stmt of body) {
-          const decl = captureDecl(stmt);
-          if (decl) {
-            if (script_name == null)
-              script_name = decl.name;
-            if (decl.kind === "strategy") {
-              script_type = "strategy";
-              applyStrategyDecl(stmt, env);
-            } else if (decl.kind === "library") {
-              script_type = "library";
-              applyDrawingDecl(stmt, env);
-            } else {
-              applyDrawingDecl(stmt, env);
+      const barRt = env.realtimeFirst != null && i >= env.realtimeFirst;
+      const ticks = barRt ? env.realtimeTicks : 1;
+      env.barRealtime = barRt;
+      env.tickCount = ticks;
+      for (let tick = 0;tick < ticks; tick++) {
+        env.tickIndex = tick;
+        const snap = barRt && tick < ticks - 1 ? snapshotTickState(env) : null;
+        try {
+          for (const stmt of body) {
+            const decl = captureDecl(stmt);
+            if (decl) {
+              if (script_name == null)
+                script_name = decl.name;
+              if (decl.kind === "strategy") {
+                script_type = "strategy";
+                applyStrategyDecl(stmt, env);
+              } else if (decl.kind === "library") {
+                script_type = "library";
+                applyDrawingDecl(stmt, env);
+              } else {
+                applyDrawingDecl(stmt, env);
+              }
+              continue;
             }
-            continue;
+            execStmt(stmt, env);
           }
-          execStmt(stmt, env);
-        }
-        if (i === 0 && script_type === "library" && script_name) {
-          finalizeLibrary(env, script_name);
+          if (i === 0 && script_type === "library" && script_name) {
+            finalizeLibrary(env, script_name);
+          }
+        } catch (err) {
+          if (err === LOOP_BREAK || err === LOOP_CONTINUE)
+            break;
+          runError = { error: formatRunError(err), error_kind: "runtime" };
+          aborted = true;
+          break;
         }
-      } catch (err) {
-        if (err === LOOP_BREAK || err === LOOP_CONTINUE)
-          continue;
-        runError = { error: formatRunError(err), error_kind: "runtime" };
-        break;
+        if (snap)
+          restoreTickState(env, snap);
       }
     }
   } catch (err) {
@@ -51371,7 +51673,7 @@ function uniquifyPlotKey(env, node, title) {
   return key;
 }
 function isVarMode3(stmt) {
-  return stmt.mode?.kind === "Var";
+  return stmt.mode?.kind === "Var" || stmt.mode?.kind === "VarIp";
 }
 function isTuple(v) {
   return typeof v === "object" && v !== null && v.__tuple === true;
@@ -51486,6 +51788,15 @@ function evalAssign(stmt, env) {
   if (stmt.target.kind !== "Name")
     return NA;
   const id = stmt.target.id;
+  const isVarip = stmt.mode?.kind === "VarIp";
+  if (isVarip)
+    env.varipNames.add(id);
+  if (isVarip && env.barRealtime) {
+    const value = evalExpr(stmt.value, env);
+    bindName(env, id, value);
+    inited.add(id);
+    return value;
+  }
   if (isVarMode3(stmt) && (inited.has(id) || env.barIndex !== 0 && ctxGet(env, id) !== undefined)) {
     inited.add(id);
     const cur = ctxGet(env, id);
@@ -51754,6 +52065,12 @@ function evalExpr(node, env) {
         const s = seriesGet(env, node.value.id);
         if (s)
           return s.get(offset);
+        const v = ctxGet(env, node.value.id);
+        if (v instanceof PineArray) {
+          const size = v.size();
+          const i = size - 1 - offset;
+          return i < 0 || i >= size ? NA : v.get(i);
+        }
       }
       return NA;
     }
@@ -52151,21 +52468,21 @@ function evalAttribute(node, env) {
     }
     if (node.value.id === "barstate") {
       const last = env.barIndex === env.barCount - 1;
-      const realtime = env.realtimeLastBar && last;
+      const rt = env.barRealtime;
       if (node.attr === "isfirst")
         return env.barIndex === 0 ? 1 : 0;
       if (node.attr === "islast")
         return last ? 1 : 0;
       if (node.attr === "ishistory")
-        return realtime ? 0 : 1;
+        return rt ? 0 : 1;
       if (node.attr === "isconfirmed")
-        return 1;
+        return barIsConfirmed(env) ? 1 : 0;
       if (node.attr === "isnew")
-        return 1;
+        return rt && env.tickIndex > 0 ? 0 : 1;
       if (node.attr === "isrealtime")
-        return realtime ? 1 : 0;
+        return rt ? 1 : 0;
       if (node.attr === "islastconfirmedhistory")
-        return realtime ? 0 : last ? 1 : 0;
+        return rt ? 0 : last ? 1 : 0;
     }
     if (node.value.id === "session") {
       if (node.attr === "regular")
@@ -52933,8 +53250,35 @@ function formatRunError(err) {
   }
   return "runtime error";
 }
+function resolveRealtimeWindow(nBars, opts) {
+  const intOr = (v, fallback) => {
+    if (v == null || !Number.isFinite(v))
+      return fallback;
+    return Math.trunc(v);
+  };
+  let ticks = intOr(opts.realtimeTicks, 1);
+  if (ticks < 1)
+    ticks = 1;
+  let rtBars = intOr(opts.realtimeBars, 0);
+  if (rtBars < 0)
+    rtBars = 0;
+  if (opts.realtimeFromBar != null) {
+    let first = intOr(opts.realtimeFromBar, 0);
+    if (first < 0)
+      first = 0;
+    if (first >= nBars)
+      return { first: null, ticks };
+    return { first, ticks };
+  }
+  if (rtBars > 0)
+    return { first: nBars > rtBars ? nBars - rtBars : 0, ticks };
+  if (opts.realtimeLastBar || ticks > 1) {
+    return { first: nBars > 0 ? nBars - 1 : null, ticks };
+  }
+  return { first: null, ticks };
+}
 function isPlainInputs(extra) {
-  return !("inputs" in extra) && !("broker" in extra) && !("timeframe" in extra) && !("libraries" in extra) && !("mode" in extra) && !("timeout_seconds" in extra) && !("realtimeLastBar" in extra);
+  return !("inputs" in extra) && !("broker" in extra) && !("timeframe" in extra) && !("libraries" in extra) && !("mode" in extra) && !("timeout_seconds" in extra) && !("realtimeLastBar" in extra) && !("realtimeTicks" in extra) && !("realtimeBars" in extra) && !("realtimeFromBar" in extra);
 }
 function resolveLibraries(libs) {
   if (libs instanceof LibraryRegistry)
@@ -53106,8 +53450,8 @@ function normalizeAlertFreq(freq) {
   const s = String(freq).trim().toLowerCase().replace(/ /g, "_");
   return ALERT_FREQ_ALIASES[s] ?? (s ? s : FREQ_ONCE_PER_BAR);
 }
-function barIsConfirmed(_env) {
-  return true;
+function barIsConfirmed(env) {
+  return !env.barRealtime || env.tickIndex === env.tickCount - 1;
 }
 function shouldFireAlert(env, source, title, message, freq) {
   const freqN = normalizeAlertFreq(freq);
@@ -56816,6 +57160,7 @@ export {
   mapJsonBars,
   parse,
   parseTimestampString,
+  resolveRealtimeWindow,
   runScript,
   runtimeError,
   tickerHeikinashi,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoox-sh/pynets",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "license": "AGPL-3.0-or-later",
   "author": "jango_blockchained",

package/src/cli/rich.ts

@@ -12,7 +12,7 @@ const MUTED = [203, 204, 189] as const;
 const FAIL = [231, 0, 11] as const;
 const WARN = [235, 169, 65] as const;
 
-export const VERSION = "0.9.0";
+export const VERSION = "0.10.0";
 
 type Rgb = readonly [number, number, number];
 

package/src/index.ts

@@ -9,7 +9,7 @@
 export { dump, parse, tokenize, unparse, PinescriptSyntaxError } from "./ast/helper.ts";
 export type { ParseMode } from "./ast/helper.ts";
 export type { AST, Script, Expression } from "./ast/nodes.ts";
-export { Runtime, RuntimeStream, interpret, interpretTree } from "./runtime/interpret.ts";
+export { Runtime, RuntimeStream, interpret, interpretTree, resolveRealtimeWindow } from "./runtime/interpret.ts";
 export type {
   DrawingEvent,
   InputOverrides,

package/src/runtime/array.ts

@@ -8,6 +8,7 @@
  */
 
 import { UdtInstance } from "./udt.ts";
+import { cloneValue } from "./clone.ts";
 
 /** Numeric/na cell. Arrays may also store UDT instances, strings, and bools. */
 export type Cell = number | null;
@@ -245,6 +246,24 @@ export class PineArray {
     return out;
   }
 
+  /** Deep clone (realtime tick snapshots). */
+  clone(): PineArray {
+    const out = new PineArray();
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+
+  /** Deep-cloned slots for realtime tick rollback. */
+  snapshotContents(): unknown[] {
+    return this.cells.map(cloneValue);
+  }
+
+  /** Replace slots with clones of `snap` — same instance, aliases keep identity. */
+  restoreContents(snap: unknown[]): void {
+    this.cells.length = 0;
+    for (const c of snap) this.cells.push(cloneValue(c));
+  }
+
   reverse(): void {
     this.cells.reverse();
   }

package/src/runtime/clone.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Deep-clone runtime values for realtime tick snapshots (Python
+ * `_snapshot_realtime_scope` / `_snapshot_ta_state` analog). Containers
+ * duck-type `clone()` so this module stays import-free.
+ */
+
+/** Deep clone: primitives, arrays, Map/Set, containers (via `clone()`), plain objects. */
+export function cloneValue(v: unknown): unknown {
+  if (v == null) return v;
+  if (typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map(cloneValue);
+  if (v instanceof Map) {
+    const out = new Map<unknown, unknown>();
+    for (const [k, x] of v) out.set(k, cloneValue(x));
+    return out;
+  }
+  if (v instanceof Set) return new Set(v);
+  const clone = (v as { clone?: () => unknown }).clone;
+  if (typeof clone === "function") return clone.call(v);
+  const out: Record<string, unknown> = {};
+  for (const [k, x] of Object.entries(v)) out[k] = cloneValue(x);
+  return out;
+}