@hoox-sh/pynets 0.9.0 → 0.10.0

package/src/runtime/ta.ts

@@ -9,6 +9,7 @@
 export type Cell = number | null;
 
 import { PineArray } from "./array.ts";
+import { cloneValue } from "./clone.ts";
 
 interface SmaState {
   period: number;
@@ -602,6 +603,33 @@ export class TaEngine {
   private readonly momentumFilterSites = new Map<string, { momentum: Cell[]; volume: Cell[] }>();
   private readonly volatilityRegimeSites = new Map<string, Cell[]>();
 
+  /**
+   * Snapshot every per-site window (Python `_snapshot_ta_state`).
+   * Intermediate realtime ticks push one sample per call site; without
+   * rollback the same bar would be counted N times.
+   */
+  snapshot(): Array<[string, Map<string, unknown>]> {
+    const out: Array<[string, Map<string, unknown>]> = [];
+    for (const [key, value] of Object.entries(this as unknown as Record<string, unknown>)) {
+      if (!(value instanceof Map)) continue;
+      const copy = new Map<string, unknown>();
+      for (const [site, state] of value) copy.set(site, cloneValue(state));
+      out.push([key, copy]);
+    }
+    return out;
+  }
+
+  /** Copy-on-restore (Python `_restore_ta_state`); never throws. */
+  restore(snap: Array<[string, Map<string, unknown>]>): void {
+    const self = this as unknown as Record<string, unknown>;
+    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: string, source: Cell, period: number): Cell {
     const n = pinePeriod(period);
     if (n === null) return null;

package/src/runtime/udt.ts

@@ -7,6 +7,8 @@
  * remain the source of truth — interpret registers TypeDef / EnumDef later.
  */
 
+import { cloneValue } from "./clone.ts";
+
 export type UdtField = { name: string; default: unknown };
 
 /** Stored method; `body` is opaque (interpret owns FunctionDef). */
@@ -83,6 +85,26 @@ export class UdtInstance {
   getMethod(name: string): UdtMethod | undefined {
     return this.type.getMethod(name);
   }
+
+  /** Deep clone (realtime tick snapshots). */
+  clone(): UdtInstance {
+    const out = new UdtInstance(this.type);
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+
+  /** Deep-cloned field values for realtime tick rollback. */
+  snapshotContents(): Array<[string, unknown]> {
+    const out: Array<[string, unknown]> = [];
+    for (const [k, v] of this.values) out.push([k, cloneValue(v)]);
+    return out;
+  }
+
+  /** Replace fields with clones of `snap` — same instance for aliases. */
+  restoreContents(snap: Array<[string, unknown]>): void {
+    this.values.clear();
+    for (const [k, v] of snap) this.values.set(k, cloneValue(v));
+  }
 }
 
 export class EnumMember {