neuroalpha 0.0.0-stage → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (46) hide show
  1. package/README.md +164 -3
  2. package/bin/cli.js +69 -0
  3. package/config/strategy.json +33 -0
  4. package/docs//320/230/320/235/320/241/320/242/320/240/320/243/320/232/320/246/320/230/320/257.md +156 -0
  5. package/package.json +43 -6
  6. package/public/app.js +2410 -0
  7. package/public/index.html +337 -0
  8. package/public/landing.html +870 -0
  9. package/public/legal.html +90 -0
  10. package/public/styles.css +343 -0
  11. package/server/api/routes.js +333 -0
  12. package/server/auth/index.js +340 -0
  13. package/server/billing/yookassa.js +132 -0
  14. package/server/brokers/index.js +645 -0
  15. package/server/config.js +44 -0
  16. package/server/data/moex.js +165 -0
  17. package/server/db.js +420 -0
  18. package/server/hub.js +14 -0
  19. package/server/index.js +92 -0
  20. package/server/llm/client.js +187 -0
  21. package/server/llm/providers.js +355 -0
  22. package/server/model/dataset.js +352 -0
  23. package/server/model/forecast.js +121 -0
  24. package/server/model/gpu-worker.html +11 -0
  25. package/server/model/gpu-worker.js +60 -0
  26. package/server/model/linalg.js +142 -0
  27. package/server/model/live.js +486 -0
  28. package/server/model/metrics.js +134 -0
  29. package/server/model/models.js +459 -0
  30. package/server/model/profiles.js +166 -0
  31. package/server/model/research.js +880 -0
  32. package/server/model/tf-node.js +26 -0
  33. package/server/model/transformer-core.js +330 -0
  34. package/server/model/transformer-gpu.js +221 -0
  35. package/server/model/transformer-pool.js +200 -0
  36. package/server/model/transformer-worker.js +28 -0
  37. package/server/model/transformer.js +57 -0
  38. package/server/model/vocab.js +28 -0
  39. package/server/news/index.js +309 -0
  40. package/server/notify/index.js +168 -0
  41. package/server/params-meta.js +63 -0
  42. package/server/settings.js +79 -0
  43. package/server/strategist/analytics.js +150 -0
  44. package/server/strategist/index.js +484 -0
  45. package/server/strategist/tools.js +302 -0
  46. package/server/util.js +9 -0
@@ -0,0 +1,142 @@
1
+ // Небольшая линейная алгебра без зависимостей: матрицы — массивы Float64Array (строки)
2
+
3
+ export const matrix = (n, m) => Array.from({ length: n }, () => new Float64Array(m));
4
+
5
+ // Собственные значения и векторы симметричной матрицы (метод Якоби). Возвращает по убыванию.
6
+ export function eigenSym(A0, { maxSweeps = 60, eps = 1e-10 } = {}) {
7
+ const n = A0.length;
8
+ const A = A0.map((r) => Float64Array.from(r));
9
+ const V = matrix(n, n);
10
+ for (let i = 0; i < n; i++) V[i][i] = 1;
11
+ for (let sweep = 0; sweep < maxSweeps; sweep++) {
12
+ let off = 0;
13
+ for (let p = 0; p < n; p++) for (let q = p + 1; q < n; q++) off += A[p][q] * A[p][q];
14
+ if (off < eps) break;
15
+ for (let p = 0; p < n; p++) {
16
+ for (let q = p + 1; q < n; q++) {
17
+ const apq = A[p][q];
18
+ if (Math.abs(apq) < 1e-14) continue;
19
+ const theta = (A[q][q] - A[p][p]) / (2 * apq);
20
+ const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
21
+ const c = 1 / Math.sqrt(t * t + 1), s = t * c;
22
+ for (let k = 0; k < n; k++) {
23
+ const akp = A[k][p], akq = A[k][q];
24
+ A[k][p] = c * akp - s * akq;
25
+ A[k][q] = s * akp + c * akq;
26
+ }
27
+ for (let k = 0; k < n; k++) {
28
+ const apk = A[p][k], aqk = A[q][k];
29
+ A[p][k] = c * apk - s * aqk;
30
+ A[q][k] = s * apk + c * aqk;
31
+ }
32
+ for (let k = 0; k < n; k++) {
33
+ const vkp = V[k][p], vkq = V[k][q];
34
+ V[k][p] = c * vkp - s * vkq;
35
+ V[k][q] = s * vkp + c * vkq;
36
+ }
37
+ }
38
+ }
39
+ }
40
+ const order = [...Array(n).keys()].sort((a, b) => A[b][b] - A[a][a]);
41
+ return {
42
+ values: order.map((i) => A[i][i]),
43
+ vectors: order.map((i) => Float64Array.from({ length: n }, (_, k) => V[k][i])), // vectors[c][k] — k-я координата c-го вектора
44
+ };
45
+ }
46
+
47
+ // Решение (A + lambda*I) X = B методом Холецкого. A: p×p, B: p×m (строки). Возвращает X p×m.
48
+ export function ridgeSolve(A, B, lambda) {
49
+ const p = A.length, m = B[0].length;
50
+ const L = matrix(p, p);
51
+ for (let i = 0; i < p; i++) {
52
+ for (let j = 0; j <= i; j++) {
53
+ let s = A[i][j] + (i === j ? lambda : 0);
54
+ const Li = L[i], Lj = L[j];
55
+ for (let k = 0; k < j; k++) s -= Li[k] * Lj[k];
56
+ if (i === j) L[i][i] = Math.sqrt(Math.max(s, 1e-12));
57
+ else L[i][j] = s / L[j][j];
58
+ }
59
+ }
60
+ const X = matrix(p, m);
61
+ const y = new Float64Array(p);
62
+ for (let c = 0; c < m; c++) {
63
+ for (let i = 0; i < p; i++) {
64
+ let s = B[i][c];
65
+ for (let k = 0; k < i; k++) s -= L[i][k] * y[k];
66
+ y[i] = s / L[i][i];
67
+ }
68
+ for (let i = p - 1; i >= 0; i--) {
69
+ let s = y[i];
70
+ for (let k = i + 1; k < p; k++) s -= L[k][i] * X[k][c];
71
+ X[i][c] = s / L[i][i];
72
+ }
73
+ }
74
+ return X;
75
+ }
76
+
77
+ export function pearson(a, b, n = a.length) {
78
+ let sa = 0, sb = 0;
79
+ for (let i = 0; i < n; i++) { sa += a[i]; sb += b[i]; }
80
+ const ma = sa / n, mb = sb / n;
81
+ let cov = 0, va = 0, vb = 0;
82
+ for (let i = 0; i < n; i++) {
83
+ const da = a[i] - ma, db = b[i] - mb;
84
+ cov += da * db; va += da * da; vb += db * db;
85
+ }
86
+ return va > 0 && vb > 0 ? cov / Math.sqrt(va * vb) : 0;
87
+ }
88
+
89
+ function ranks(a) {
90
+ const idx = [...a.keys()].sort((i, j) => a[i] - a[j]);
91
+ const r = new Float64Array(a.length);
92
+ for (let k = 0; k < idx.length;) {
93
+ let e = k;
94
+ while (e + 1 < idx.length && a[idx[e + 1]] === a[idx[k]]) e++;
95
+ const avg = (k + e) / 2;
96
+ for (let q = k; q <= e; q++) r[idx[q]] = avg;
97
+ k = e + 1;
98
+ }
99
+ return r;
100
+ }
101
+
102
+ export const spearman = (a, b) => (a.length < 5 ? 0 : pearson(ranks(a), ranks(b)));
103
+
104
+ export function mulberry32(seed) {
105
+ return () => {
106
+ seed |= 0; seed = (seed + 0x6d2b79f5) | 0;
107
+ let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
108
+ t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
109
+ return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
110
+ };
111
+ }
112
+
113
+ // k-средних с детерминированной инициализацией k-means++
114
+ export function kmeans(points, k, { iters = 50, seed = 7 } = {}) {
115
+ const n = points.length, d = points[0].length;
116
+ const rnd = mulberry32(seed);
117
+ const dist2 = (a, b) => { let s = 0; for (let i = 0; i < d; i++) s += (a[i] - b[i]) ** 2; return s; };
118
+ const centers = [Float64Array.from(points[Math.floor(rnd() * n)])];
119
+ while (centers.length < k) {
120
+ const ds = points.map((p) => Math.min(...centers.map((c) => dist2(p, c))));
121
+ const sum = ds.reduce((a, b) => a + b, 0);
122
+ let r = rnd() * sum, i = 0;
123
+ while (i < n - 1 && (r -= ds[i]) > 0) i++;
124
+ centers.push(Float64Array.from(points[i]));
125
+ }
126
+ const assign = new Int32Array(n);
127
+ for (let it = 0; it < iters; it++) {
128
+ let changed = false;
129
+ for (let i = 0; i < n; i++) {
130
+ let best = 0, bd = Infinity;
131
+ for (let c = 0; c < k; c++) { const dd = dist2(points[i], centers[c]); if (dd < bd) { bd = dd; best = c; } }
132
+ if (assign[i] !== best) { assign[i] = best; changed = true; }
133
+ }
134
+ for (let c = 0; c < k; c++) {
135
+ const acc = new Float64Array(d); let cnt = 0;
136
+ for (let i = 0; i < n; i++) if (assign[i] === c) { cnt++; for (let q = 0; q < d; q++) acc[q] += points[i][q]; }
137
+ if (cnt) centers[c] = acc.map((v) => v / cnt);
138
+ }
139
+ if (!changed && it > 0) break;
140
+ }
141
+ return Array.from(assign);
142
+ }
@@ -0,0 +1,486 @@
1
+ import { createRun, finishRun, saveTrade, updateRunMetrics, getRun, getTrades, deleteRun, kvGet, kvSet } from '../db.js';
2
+ import { normalizeParams } from '../settings.js';
3
+ import { round, DAY, MSK, fmtBarMsk } from '../util.js';
4
+ import { hub } from '../hub.js';
5
+ import { latestBarTs } from '../data/moex.js';
6
+ import { loadDataset, barsFromHours, BAR_MS, BAR_INTERVAL } from './dataset.js';
7
+ import { predictAt, lastClosedIndex } from './forecast.js';
8
+ import { computeReport, downsample } from './metrics.js';
9
+ import { MODELS } from './models.js';
10
+ import { blockingNews } from '../news/index.js';
11
+ import { currentUserId } from '../auth/index.js';
12
+ import { notifyUser } from '../notify/index.js';
13
+
14
+ const dayKey = (ts) => new Date(ts + MSK).toISOString().slice(0, 10);
15
+
16
+ function buildBenchmark(baseRunId) {
17
+ if (!baseRunId) return null;
18
+ const br = getRun(Number(baseRunId));
19
+ if (!br?.metrics?.full) return null;
20
+ const f = br.metrics.full;
21
+ const days = Math.max(1, Math.round(((br.metrics.period?.till || 0) - (br.metrics.period?.from || 0)) / DAY));
22
+ return {
23
+ runId: br.id,
24
+ returnPct: f.returnPct,
25
+ marketPct: f.marketPct,
26
+ maxDrawdownPct: f.maxDrawdownPct,
27
+ trades: f.trades,
28
+ periodDays: days,
29
+ dailyPct: round(f.returnPct / days, 4),
30
+ };
31
+ }
32
+
33
+ // Движок виртуальных счетов: поддерживает несколько независимых счетов одновременно.
34
+ // Каждый счёт замораживает свои настройки при запуске (эксперименты в песочнице его не меняют)
35
+ // и при запуске «из прогона» сверяет фактический результат с историческим коридором этого прогона.
36
+ class LiveEngine {
37
+ constructor() {
38
+ this.accounts = new Map(); // runId -> state
39
+ this.timer = null;
40
+ }
41
+
42
+ #direction(s) {
43
+ return s.params.modelDirection || 'long';
44
+ }
45
+
46
+ #borrow(s, h, ts) {
47
+ return h.alloc * ((s.params.modelShortFeePct ?? 0) / 100) * ((ts - h.entryTs) / DAY / 365);
48
+ }
49
+
50
+ #openPnl(s, h, price, ts) {
51
+ return h.side === 'short' ? h.alloc * (1 - price / h.entryPrice) - this.#borrow(s, h, ts) : h.alloc * (price / h.entryPrice - 1);
52
+ }
53
+
54
+ snapshotOf(s, ts = Date.now()) {
55
+ let mtm = 0;
56
+ const positions = [...s.held.entries()].map(([symbol, h]) => {
57
+ const pnl = this.#openPnl(s, h, h.lastPrice, ts);
58
+ mtm += pnl;
59
+ return {
60
+ symbol, side: h.side || 'long', qty: round(h.alloc / h.entryPrice, 2),
61
+ entryTs: h.entryTs, entryPrice: round(h.entryPrice, 4), lastPrice: round(h.lastPrice, 4),
62
+ pnl: round(pnl - h.entryCost, 2), expectedPct: h.expectedPct,
63
+ };
64
+ });
65
+ return { equity: round(s.equity + mtm, 2), cash: round(s.equity, 2), positions, pending: s.pending.map((o) => ({ action: o.action, symbol: o.symbol })) };
66
+ }
67
+
68
+ snapshot(ts = Date.now()) {
69
+ const p = this.#primary();
70
+ return p ? this.snapshotOf(p, ts) : { equity: 0, cash: 0, positions: [], pending: [] };
71
+ }
72
+
73
+ #primary() {
74
+ const list = [...this.accounts.values()].sort((a, b) => b.runId - a.runId);
75
+ return list.find((a) => a.running) || list[0] || null;
76
+ }
77
+
78
+ #accountStatus(s) {
79
+ const snap = this.snapshotOf(s);
80
+ const cap = s.params.capital || 1000000;
81
+ const pnl = round(snap.equity - cap, 2);
82
+ const returnPct = round((pnl / cap) * 100, 2);
83
+ const endTs = s.running ? Date.now() : (s.stoppedAt || Date.now());
84
+ const elapsedDays = Math.max(0.05, round((endTs - s.startedAt) / DAY, 2));
85
+ let corridor = null;
86
+ if (s.benchmark) {
87
+ const expPct = round(s.benchmark.dailyPct * elapsedDays, 2);
88
+ const bandPct = round(Math.max(1.5, (s.benchmark.maxDrawdownPct || 10) * Math.sqrt(elapsedDays / Math.max(30, s.benchmark.periodDays))), 1);
89
+ const status = returnPct < expPct - bandPct ? 'below' : returnPct > expPct + bandPct ? 'above' : 'inside';
90
+ corridor = { runId: s.benchmark.runId, expectedPct: expPct, bandPct, minPct: round(expPct - bandPct, 1), maxPct: round(expPct + bandPct, 1), histReturnPct: s.benchmark.returnPct, histMaxDdPct: s.benchmark.maxDrawdownPct, status };
91
+ }
92
+ return {
93
+ running: s.running, runId: s.runId, name: s.name || `Виртуальный счёт №${s.runId}`,
94
+ baseRunId: s.baseRunId || null, benchmark: s.benchmark || null, corridor,
95
+ params: s.params, startedAt: s.startedAt, stoppedAt: s.stoppedAt || null, lastBarTs: s.lastBarTs,
96
+ error: s.error, busy: s.busy, snapshot: snap, returnPct, pnl,
97
+ recent: s.recent.slice(0, 20), metrics: s.metrics,
98
+ };
99
+ }
100
+
101
+ status(uid = currentUserId()) {
102
+ const list = [...this.accounts.values()].filter((s) => (s.userId || 1) === (uid || 1)).sort((a, b) => b.runId - a.runId).map((s) => this.#accountStatus(s));
103
+ const primary = list.find((a) => a.running) || list[0] || null;
104
+ if (!primary) return { running: false, accounts: [] };
105
+ return {
106
+ ...primary,
107
+ running: list.some((a) => a.running),
108
+ accounts: list,
109
+ };
110
+ }
111
+
112
+ #ensureTimer() {
113
+ const running = [...this.accounts.values()].filter((a) => a.running);
114
+ if (!running.length) {
115
+ if (this.timer) { clearInterval(this.timer); this.timer = null; }
116
+ return;
117
+ }
118
+ if (!this.timer) {
119
+ const pollSec = Math.max(15, Math.min(...running.map((a) => Number(a.params.paperPollSec) || 60)));
120
+ this.timer = setInterval(() => this.tick(), pollSec * 1000);
121
+ }
122
+ }
123
+
124
+ async start(input, { source = 'user', name = '', baseRunId = null, capital = null, maxAccounts = 5 } = {}) {
125
+ const uid = currentUserId();
126
+ const runningCount = [...this.accounts.values()].filter((a) => a.running && (a.userId || 1) === uid).length;
127
+ if (runningCount >= maxAccounts) throw new Error(`По вашему тарифу доступно одновременно не более ${maxAccounts} виртуальных счетов`);
128
+ const baseRun = baseRunId ? getRun(Number(baseRunId)) : null;
129
+ const rawParams = baseRun?.params ? { ...baseRun.params, ...input } : input;
130
+ const params = normalizeParams(rawParams);
131
+ if (capital && Number(capital) >= 10000) params.capital = Math.round(Number(capital));
132
+ const benchmark = buildBenchmark(baseRunId);
133
+ const accName = String(name || '').trim() || (baseRunId ? `Из эксперимента №${baseRunId} (${MODELS[params.modelType]?.label || params.modelType}, ${params.modelTopK} акц.)` : `Счёт · ${MODELS[params.modelType]?.label || params.modelType}, ${params.modelTopK} акц.`);
134
+ const runId = createRun('paper', { ...params, _source: source, _baseRunId: baseRunId || null, _name: accName }, uid);
135
+ const s = {
136
+ userId: uid, running: true, runId, name: accName, baseRunId: baseRunId ? Number(baseRunId) : null, benchmark,
137
+ params, source, startedAt: Date.now(), stoppedAt: null, lastBarTs: null, lastSeenTs: null, error: null, busy: false,
138
+ equity: params.capital, held: new Map(), pending: [], trades: [], curve: [], recent: [], metrics: null,
139
+ barsSinceRebalance: Infinity, day: null, dayStartEquity: params.capital, dayTrades: [],
140
+ };
141
+ this.accounts.set(runId, s);
142
+ this.#persist();
143
+ hub.emit({ type: 'paper:started', runId, source, name: accName, baseRunId: s.baseRunId });
144
+ hub.emit({ type: 'paper:status', status: this.status() });
145
+ this.#ensureTimer();
146
+ this.tick();
147
+ return runId;
148
+ }
149
+
150
+ #serialize(s) {
151
+ return {
152
+ userId: s.userId || 1, runId: s.runId, name: s.name, baseRunId: s.baseRunId, benchmark: s.benchmark,
153
+ running: s.running, params: s.params, source: s.source, startedAt: s.startedAt, stoppedAt: s.stoppedAt,
154
+ equity: s.equity, held: [...s.held.entries()], pending: s.pending, curve: s.curve.slice(-3000),
155
+ lastBarTs: s.lastBarTs, lastSeenTs: s.lastSeenTs, decisionTs: s.decisionTs ?? null,
156
+ barsSinceRebalance: Number.isFinite(s.barsSinceRebalance) ? s.barsSinceRebalance : null,
157
+ day: s.day, dayStartEquity: s.dayStartEquity, dayTrades: s.dayTrades, recent: s.recent.slice(0, 20), savedAt: Date.now(),
158
+ };
159
+ }
160
+
161
+ #persist() {
162
+ const arr = [...this.accounts.values()].map((s) => this.#serialize(s));
163
+ kvSet('liveAccounts', arr);
164
+ const prim = this.#primary();
165
+ kvSet('liveState', prim && prim.running ? this.#serialize(prim) : null);
166
+ }
167
+
168
+ resume() {
169
+ let list = kvGet('liveAccounts');
170
+ if (!Array.isArray(list) || !list.length) {
171
+ const legacy = kvGet('liveState');
172
+ list = legacy?.runId ? [legacy] : [];
173
+ }
174
+ let resumedAny = false;
175
+ for (const st of list) {
176
+ if (!st?.runId || this.accounts.has(st.runId)) continue;
177
+ const run = getRun(st.runId);
178
+ if (!run || run.mode !== 'paper' || !st.params?.modelHorizon) continue;
179
+ const isRunning = Boolean(st.running && run.status === 'running');
180
+ const trades = getTrades(st.runId).map((t) => ({
181
+ symbol: t.symbol, side: t.side, pnl: t.pnl, pnlPct: t.pnl_pct, entryTs: t.entry_ts, exitTs: t.exit_ts, commission: t.commission,
182
+ barsHeld: Math.round((t.exit_ts - t.entry_ts) / 600000) * BAR_INTERVAL,
183
+ }));
184
+ const curve = st.curve || [];
185
+ const s = {
186
+ userId: st.userId || run.user_id || 1,
187
+ running: isRunning, runId: st.runId, name: String(st.name || run.params?._name || `Виртуальный счёт №${st.runId}`).replace(/^Из прогона/i, 'Из эксперимента'),
188
+ baseRunId: st.baseRunId ?? run.params?._baseRunId ?? null,
189
+ benchmark: st.benchmark ?? buildBenchmark(st.baseRunId ?? run.params?._baseRunId),
190
+ params: st.params, source: st.source || 'user', startedAt: st.startedAt, stoppedAt: st.stoppedAt || null,
191
+ lastBarTs: st.lastBarTs ?? null, lastSeenTs: null, decisionTs: st.decisionTs ?? undefined, error: null, busy: false,
192
+ equity: st.equity, held: new Map((st.held || []).map(([sym, h]) => [sym, { side: 'long', ...h }])),
193
+ pending: st.pending || [], trades, curve, recent: st.recent || [],
194
+ metrics: computeReport(trades, curve.length ? curve : [{ ts: Date.now(), equity: st.params.capital }], st.params.capital, 0),
195
+ barsSinceRebalance: st.barsSinceRebalance ?? Infinity, day: st.day ?? null,
196
+ dayStartEquity: st.dayStartEquity ?? st.params.capital, dayTrades: st.dayTrades || [],
197
+ };
198
+ this.accounts.set(s.runId, s);
199
+ if (isRunning) {
200
+ resumedAny = true;
201
+ hub.emit({ type: 'paper:resumed', runId: s.runId });
202
+ }
203
+ }
204
+ if (this.accounts.size) {
205
+ this.#persist();
206
+ hub.emit({ type: 'paper:status', status: this.status() });
207
+ }
208
+ if (resumedAny) {
209
+ this.#ensureTimer();
210
+ this.tick();
211
+ }
212
+ return resumedAny;
213
+ }
214
+
215
+ async suspend() {
216
+ if (this.timer) { clearInterval(this.timer); this.timer = null; }
217
+ for (const s of this.accounts.values()) s.suspended = true;
218
+ for (let i = 0; i < 15 && [...this.accounts.values()].some((s) => s.busy); i++) await new Promise((r) => setTimeout(r, 100));
219
+ this.#persist();
220
+ return true;
221
+ }
222
+
223
+ async tick() {
224
+ const running = [...this.accounts.values()].filter((s) => s.running && !s.busy && !s.suspended);
225
+ if (!running.length) return;
226
+ let latest = null;
227
+ try { latest = await latestBarTs('IMOEX', BAR_INTERVAL); } catch { /* проверим в самом счёте */ }
228
+ for (const s of running) {
229
+ await this.#tickAccount(s, latest);
230
+ }
231
+ }
232
+
233
+ async #tickAccount(s, latest) {
234
+ if (!s.running || s.busy || s.suspended) return;
235
+ if (latest !== null && latest === s.lastSeenTs) return;
236
+ s.busy = true;
237
+ let changed = false;
238
+ try {
239
+ const p = s.params;
240
+ const now = Date.now();
241
+ const ds = await loadDataset({ fromTs: now - Math.ceil(p.modelTrainDays * 1.5 + 25) * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends !== false });
242
+ s.lastSeenTs = latest;
243
+ changed = true;
244
+ const bySym = new Map(ds.tokens.map((t, i) => [t.symbol, i]));
245
+ const last = lastClosedIndex(ds, now);
246
+
247
+ if (s.lastBarTs !== null && last >= 0) {
248
+ for (let j = 0; j < last; j++) {
249
+ const t = ds.timeline[j];
250
+ if (t <= s.lastBarTs) continue;
251
+ let mtm = 0;
252
+ for (const [sym, h] of s.held) {
253
+ const i = bySym.get(sym);
254
+ const px = i !== undefined ? ds.tokens[i].close[j] : 0;
255
+ if (px > 0) mtm += this.#openPnl(s, h, px, t);
256
+ }
257
+ s.curve.push({ ts: t, equity: round(s.equity + mtm, 2) });
258
+ }
259
+ }
260
+
261
+ if (s.deleted) return;
262
+ if (s.pending.length) {
263
+ const k = ds.timeline.findIndex((t) => t > s.decisionTs);
264
+ if (k >= 0) this.#execute(s, ds, k, bySym);
265
+ }
266
+ if (last >= 0 && ds.timeline[last] !== s.lastBarTs && (s.lastBarTs === null || ds.timeline[last] > s.lastBarTs)) {
267
+ await this.#onBar(s, ds, last, bySym);
268
+ }
269
+ s.error = null;
270
+ } catch (e) {
271
+ s.error = e.message;
272
+ if (s.running && !s.deleted) hub.emit({ type: 'log', level: 'error', text: `${s.name}: ${e.message}` });
273
+ } finally {
274
+ s.busy = false;
275
+ if (changed && !s.suspended && !s.deleted) this.#persist();
276
+ hub.emit({ type: 'paper:status', status: this.status() });
277
+ }
278
+ }
279
+
280
+ #execute(s, ds, k, bySym) {
281
+ const cost = (s.params.commissionPct + s.params.slippagePct) / 100;
282
+ const ts = ds.timeline[k];
283
+ const price = (sym) => { const i = bySym.get(sym); const tk = ds.tokens[i]; return tk && (tk.open[k] > 0 ? tk.open[k] : tk.close[k]); };
284
+ for (const o of s.pending.filter((x) => x.action === 'sell' || x.action === 'cover')) {
285
+ const h = s.held.get(o.symbol);
286
+ const px = price(o.symbol);
287
+ if (!h || !(px > 0)) continue;
288
+ const short = h.side === 'short';
289
+ const gross = short ? h.alloc * (1 - px / h.entryPrice) : h.alloc * (px / h.entryPrice - 1);
290
+ const fee = (short ? h.alloc - gross : h.alloc + gross) * cost;
291
+ const borrow = short ? this.#borrow(s, h, ts) : 0;
292
+ s.equity += gross - fee - borrow;
293
+ const pnl = gross - fee - borrow - h.entryCost;
294
+ const t = {
295
+ symbol: o.symbol, side: h.side, qty: round(h.alloc / h.entryPrice, 2), entryTs: h.entryTs, entryPrice: round(h.entryPrice, 4),
296
+ exitTs: ts, exitPrice: round(px, 4), stop: null, take: null, pnl: round(pnl, 2), pnlPct: round((pnl / h.alloc) * 100, 3),
297
+ commission: round(fee + h.entryCost, 2), barsHeld: Math.round((ts - h.entryTs) / 600000) * BAR_INTERVAL, reasonEntry: h.reason, reasonExit: o.reason,
298
+ meta: { model: s.params.modelType, exitKind: 'signal', source: 'model', ...(short ? { borrow: round(borrow, 2) } : {}) },
299
+ };
300
+ s.held.delete(o.symbol);
301
+ s.trades.push(t);
302
+ s.dayTrades.push(t);
303
+ saveTrade(s.runId, t);
304
+ hub.emit({ type: 'paper:trade', runId: s.runId, trade: t });
305
+ }
306
+ const K = s.params.modelTopK;
307
+ const dir = this.#direction(s);
308
+ const slots = dir === 'long' ? K : 2 * K;
309
+ const autoAdapt = s.params.modelAutoAdapt !== false;
310
+ const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.35 / K)) : (dir === 'neutral' ? Math.min(0.22, 1 / (2 * K)) : Math.min(0.30, 1.2 / (2 * K)));
311
+ const invVol = s.params.modelAllocMode === 'invvol';
312
+ const buyOrders = s.pending.filter((x) => x.action === 'buy' || x.action === 'short');
313
+ const usedStart = [...s.held.values()].reduce((sum, h) => sum + h.alloc, 0);
314
+ let avail = Math.max(0, s.equity * 0.99 - usedStart);
315
+ for (let idx = 0; idx < buyOrders.length; idx++) {
316
+ const o = buyOrders[idx];
317
+ const side = o.action === 'short' ? 'short' : 'long';
318
+ const px = price(o.symbol);
319
+ if (s.held.has(o.symbol) || !(px > 0) || [...s.held.values()].filter((h) => h.side === side).length >= K) continue;
320
+ const baseAlloc = autoAdapt ? Math.min(s.equity * maxSlotWeight, avail / Math.max(1, buyOrders.length - idx)) : Math.min(s.equity / slots, avail / Math.max(1, buyOrders.length - idx));
321
+ let alloc = baseAlloc;
322
+ if (invVol && o.weight > 0) {
323
+ alloc = Math.min(baseAlloc * o.weight, avail / Math.max(1, buyOrders.length - idx));
324
+ }
325
+ if (!(alloc > 1000)) continue;
326
+ avail = Math.max(0, avail - alloc);
327
+ const fee = alloc * cost;
328
+ s.equity -= fee;
329
+ s.held.set(o.symbol, { side, entryTs: ts, entryPrice: px, lastPrice: px, alloc, entryCost: fee, reason: o.reason, expectedPct: o.expectedPct });
330
+ hub.emit({ type: 'paper:fill', runId: s.runId, position: { symbol: o.symbol, side, qty: round(alloc / px, 2), price: px } });
331
+ notifyUser(s.userId || 1, `НейроАльфа · Виртуальный счёт «${s.name}»\n${side === 'short' ? 'Открыт шорт' : 'Куплено'}: ${o.symbol} по ${round(px, 3)} ₽ на ${round(alloc, 0)} ₽`).catch(() => {});
332
+ }
333
+ s.pending = [];
334
+ }
335
+
336
+ async #onBar(s, ds, idx, bySym) {
337
+ const p = s.params;
338
+ const ts = ds.timeline[idx];
339
+ const d = dayKey(ts);
340
+ if (s.day && d !== s.day) {
341
+ hub.emit({ type: 'paper:day_end', runId: s.runId, day: s.day, startEquity: s.dayStartEquity, endEquity: this.snapshotOf(s).equity, trades: s.dayTrades, snapshot: this.snapshotOf(s), params: p });
342
+ s.dayTrades = [];
343
+ s.dayStartEquity = this.snapshotOf(s).equity;
344
+ }
345
+ s.day = d;
346
+ for (const [sym, h] of s.held) { const i = bySym.get(sym); if (i !== undefined && ds.tokens[i].close[idx] > 0) h.lastPrice = ds.tokens[i].close[idx]; }
347
+ s.curve.push({ ts, equity: this.snapshotOf(s).equity });
348
+ s.lastBarTs = ts;
349
+
350
+ const step = { ts, bar: fmtBarMsk(ts), decisions: [], top: [] };
351
+ s.barsSinceRebalance++;
352
+ const H = barsFromHours(p.modelHorizon);
353
+ const autoAdapt = p.modelAutoAdapt !== false;
354
+ const stepBars = autoAdapt ? Math.max(2, Math.floor(H / 2)) : H;
355
+ if (s.barsSinceRebalance >= stepBars) {
356
+ await new Promise((r) => setImmediate(r));
357
+ const r = await predictAt(ds, p, idx);
358
+ const row = new Map(r.rows.map((x) => [x.symbol, x]));
359
+ const dir = this.#direction(s);
360
+ const K = p.modelTopK;
361
+ const closing = new Set();
362
+ const closePos = (sym, why) => {
363
+ const x = row.get(sym);
364
+ const short = s.held.get(sym).side === 'short';
365
+ const action = short ? 'cover' : 'sell';
366
+ s.pending.push({ action, symbol: sym, reason: why || `Прогноз ослаб: ожидание ${x ? x.expectedPct : '—'}% за ${round(p.modelHorizon, 2)} ч` });
367
+ step.decisions.push({ action, symbol: sym, text: `${short ? 'закрыть продажу' : 'продать'} — ${why ? why.toLowerCase() : `прогноз ослаб (${x ? x.expectedPct : '—'}%)`}` });
368
+ closing.add(sym);
369
+ };
370
+ const exitRatio = autoAdapt ? 0.75 : Number(p.modelExitRatio ?? 0.5);
371
+ const minHoldBars = p.modelMinHoldHours > 0 ? barsFromHours(p.modelMinHoldHours) : 0;
372
+ const mktDown = p.modelMarketFilter === 'ma' && dir !== 'neutral' && r.marketDown;
373
+ const quarantined = new Set();
374
+ if (autoAdapt && s.trades.length >= 3) {
375
+ const stMap = new Map();
376
+ for (const t of s.trades) {
377
+ // затухание прошлых штрафов с возрастом сделки (~15 торговых дней полураспада)
378
+ const ageSteps = Math.max(0, (ts - (t.exitTs || ts)) / (stepBars * BAR_MS));
379
+ const wDecay = Math.pow(0.99, ageSteps);
380
+ const cur = stMap.get(t.symbol) || { pnl: 0, cnt: 0 };
381
+ cur.pnl = cur.pnl * 0.90 + (Number(t.pnlPct || 0) / 100) * wDecay;
382
+ cur.cnt += wDecay;
383
+ stMap.set(t.symbol, cur);
384
+ }
385
+ for (const [sym, st] of stMap) if (st.cnt >= 3 && st.pnl < -0.012) quarantined.add(sym);
386
+ }
387
+ for (const [sym, h] of s.held) {
388
+ const x = row.get(sym);
389
+ const heldBars = Math.round((ts - h.entryTs) / BAR_MS);
390
+ const lock = minHoldBars > 0 && heldBars < minHoldBars && x && x.liquid && (h.side === 'short' ? x.expected <= 0 : x.expected >= 0);
391
+ const req = r.threshold * (autoAdapt && heldBars < H ? 0.35 : exitRatio);
392
+ if (!lock && !(x && x.liquid && (h.side === 'short' ? x.expected < -req : x.expected > req))) closePos(sym);
393
+ }
394
+ const sideHeld = (side) => [...s.held].filter(([sym, h]) => h.side === side && !closing.has(sym));
395
+ const nb = p.newsFilter ? blockingNews(6) : null;
396
+ const take = (list, side, n) => {
397
+ const lim = Math.max(0, n);
398
+ const out = [];
399
+ for (const x of list) {
400
+ if (out.length >= lim) break;
401
+ if (quarantined.has(x.symbol)) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: 'Пропущена: в карантине после серии убыточных сделок' }); continue; }
402
+ const b = nb?.get(x.symbol)?.[side === 'buy' ? 'bad' : 'good'];
403
+ if (b) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: `Пропущена: ${side === 'buy' ? 'плохая' : 'хорошая'} новость — ${b.gist}` }); continue; }
404
+ out.push(x);
405
+ }
406
+ return out;
407
+ };
408
+ let entries;
409
+ if (dir === 'long') {
410
+ const free = K - s.held.size + s.pending.filter((o) => o.action === 'sell').length;
411
+ const candL = mktDown ? [] : r.rows.filter((x) => x.signal && !s.held.has(x.symbol)).sort((a, b) => b.expected - a.expected);
412
+ if (mktDown && free > 0) step.decisions.push({ action: 'skip', symbol: 'IMOEX', text: 'Новые покупки пропущены: индекс Мосбиржи падает' });
413
+ entries = take(candL, 'buy', free).map((x) => [x, 'buy']);
414
+ } else {
415
+ const open = (x) => !s.held.has(x.symbol) || closing.has(x.symbol);
416
+ const candL = mktDown ? [] : r.rows.filter((x) => x.signal && open(x)).sort((a, b) => b.expected - a.expected);
417
+ const candS = r.rows.filter((x) => x.shortSignal && open(x)).sort((a, b) => a.expected - b.expected);
418
+ if (mktDown && dir === 'longshort') step.decisions.push({ action: 'skip', symbol: 'IMOEX', text: 'Новые покупки пропущены: индекс Мосбиржи падает' });
419
+ let nL, nS;
420
+ if (dir === 'longshort') {
421
+ nL = K - sideHeld('long').length;
422
+ nS = K - sideHeld('short').length;
423
+ } else {
424
+ const pairs = Math.min(K, sideHeld('long').length + candL.length, countSideShort(sideHeld('short').length, candS.length));
425
+ if (!autoAdapt) {
426
+ for (const side of ['long', 'short']) {
427
+ const extra = sideHeld(side).sort((a, b) => (side === 'long' ? 1 : -1) * ((row.get(a[0])?.expected ?? 0) - (row.get(b[0])?.expected ?? 0)));
428
+ for (const [sym] of extra.slice(0, Math.max(0, extra.length - pairs))) closePos(sym, 'Нет пары с другой стороны');
429
+ }
430
+ }
431
+ nL = Math.max(0, pairs - sideHeld('long').length);
432
+ nS = Math.max(0, pairs - sideHeld('short').length);
433
+ }
434
+ entries = [...take(candL, 'buy', nL).map((x) => [x, 'buy']), ...take(candS, 'short', nS).map((x) => [x, 'short'])];
435
+ }
436
+ for (const [x, action] of entries) {
437
+ const infl = x.influences?.length ? x.influences.map((n) => n.symbol).join(', ') : '';
438
+ const exp = `${x.expectedPct > 0 ? '+' : ''}${x.expectedPct}`;
439
+ const why = `Стратегия «${MODELS[r.chosen].label}»: ${action === 'short' ? 'продажа: ' : ''}ожидание ${exp}% за ${round(p.modelHorizon, 2)} ч относительно рынка${infl ? `; влияют ${infl}` : ''}`;
440
+ s.pending.push({ action, symbol: x.symbol, reason: why, expectedPct: x.expectedPct, weight: x.weight ?? 1 });
441
+ step.decisions.push({ action, symbol: symName(x), text: `${action === 'short' ? 'продать без покупки' : 'купить'} — ожидание ${exp}%${infl ? `, влияют ${infl}` : ''}` });
442
+ }
443
+ step.top = [...r.rows].sort((a, b) => b.expected - a.expected).slice(0, 5).map((x) => ({ symbol: x.symbol, expectedPct: x.expectedPct, signal: x.signal }));
444
+ step.thresholdPct = round(r.threshold * 100, 3);
445
+ if (s.pending.length) s.decisionTs = ts;
446
+ s.barsSinceRebalance = 0;
447
+ }
448
+ s.recent.unshift(step);
449
+ s.recent.length = Math.min(s.recent.length, 50);
450
+ s.metrics = computeReport(s.trades, s.curve, p.capital, 0);
451
+ updateRunMetrics(s.runId, s.metrics, downsample(s.curve));
452
+ hub.emit({ type: 'paper:step', runId: s.runId, step, snapshot: this.snapshotOf(s) });
453
+ }
454
+
455
+ stop(runId = null) {
456
+ const target = runId ? this.accounts.get(Number(runId)) : [...this.accounts.values()].find((a) => a.running);
457
+ if (!target || !target.running) return false;
458
+ target.running = false;
459
+ target.stoppedAt = Date.now();
460
+ target.metrics = computeReport(target.trades, target.curve.length ? target.curve : [{ ts: Date.now(), equity: target.params.capital }], target.params.capital, 0);
461
+ finishRun(target.runId, { status: 'stopped', metrics: target.metrics, equity: downsample(target.curve) });
462
+ this.#ensureTimer();
463
+ this.#persist();
464
+ hub.emit({ type: 'paper:stopped', runId: target.runId, metrics: target.metrics, open: this.snapshotOf(target).positions.length });
465
+ hub.emit({ type: 'paper:status', status: this.status() });
466
+ return true;
467
+ }
468
+
469
+ remove(runId) {
470
+ const id = Number(runId);
471
+ const s = this.accounts.get(id);
472
+ if (!s) return false;
473
+ s.deleted = true;
474
+ if (s.running) this.stop(id);
475
+ this.accounts.delete(id);
476
+ deleteRun(id);
477
+ this.#persist();
478
+ hub.emit({ type: 'paper:status', status: this.status() });
479
+ return true;
480
+ }
481
+ }
482
+
483
+ const countSideShort = (a, b) => a + b;
484
+ const symName = (x) => x.symbol;
485
+
486
+ export const live = new LiveEngine();