palistor 0.0.25 → 0.0.26

package/dist/store/resolvePipeline/applyPendingWrites.d.ts

@@ -3,24 +3,24 @@ import { type PendingWrite } from "./createValuesTrackingProxy";
 import type { FieldState } from "../compute/index";
 import type { ValuesCache } from "../valuesCache/valuesCache";
 /**
- * Сбрасывает все буферизированные записи из одного запуска резолвера в реальное хранилище.
+ * Flushes all writes buffered during one resolver run into the real store.
  *
- * Преобразует каждый плоский путь (через точку) обратно во вложенную структуру патча,
- * которую понимает applyPatch(), затем применяет его.
+ * Converts each flat (dot-separated) path back into the nested patch
+ * structure applyPatch() understands, then applies it.
  *
- * Пример:
+ * Example:
  *   PendingWrite { path: "user.vehicleExists", value: false }
  *   → patch = { user: { vehicleExists: false } }
  *   → applyPatch(rootConfig, nodeState, patch, changed, valuesCache)
  *
- * Несколько уровней вложенности работают аналогично:
+ * Deeper nesting works the same way:
  *   path: "a.b.c" → patch = { a: { b: { c: value } } }
  *
- * @param writes      — записи, буферизированные createValuesTrackingProxy во время выполнения резолвера
- * @param rootConfig  — корень дерева конфига полей (используется applyPatch для поиска узлов)
- * @param nodeState   — состояние узлов в рантайме (флаги dirty, ошибки и т.д.)
- * @param valuesCache — изменяемый кэш значений, который applyPatch обновляет на месте
- * @returns           — множество узлов конфига, значение которых реально изменилось (для отслеживания зависимостей)
+ * @param writes      — writes buffered by createValuesTrackingProxy during the resolver run
+ * @param rootConfig  — root of the field config tree (used by applyPatch to find nodes)
+ * @param nodeState   — runtime node state (dirty flags, errors, etc.)
+ * @param valuesCache — mutable values cache that applyPatch updates in place
+ * @returns           — set of config nodes whose value actually changed (for dependency tracking)
  */
 export declare function applyPendingWrites(writes: PendingWrite[], rootConfig: AnyConfigNode, nodeState: WeakMap<object, FieldState>, valuesCache: ValuesCache): Set<object>;
 //# sourceMappingURL=applyPendingWrites.d.ts.map

package/dist/store/resolvePipeline/applyPendingWrites.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applyPendingWrites.d.ts","sourceRoot":"","sources":["../../../store/resolvePipeline/applyPendingWrites.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAiB9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EAAE,EACtB,UAAU,EAAE,aAAa,EACzB,SAAS,EAAE,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,EACtC,WAAW,EAAE,WAAW,GACvB,GAAG,CAAC,MAAM,CAAC,CAkCb"}
+{"version":3,"file":"applyPendingWrites.d.ts","sourceRoot":"","sources":["../../../store/resolvePipeline/applyPendingWrites.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAiB9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EAAE,EACtB,UAAU,EAAE,aAAa,EACzB,SAAS,EAAE,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,EACtC,WAAW,EAAE,WAAW,GACvB,GAAG,CAAC,MAAM,CAAC,CA+Bb"}

package/dist/store/resolvePipeline/applyPendingWrites.js

@@ -1,68 +1,65 @@
 import { applyPatch } from "../applyPatch/applyPatch";
-// ─── Применение буферизированных записей ────────────────────────────────────
+// ─── Applying buffered writes ────────────────────────────────────────────────
 //
-// Это вторая половина пайплайна отложенных записей.
+// This is the second half of the deferred-write pipeline.
 //
-// КРАТКОЕ ОПИСАНИЕ ПОТОКА:
-//   1. Резолвер запускается с прокси из createValuesTrackingProxy().
-//   2. Каждое `values.x.y = z` внутри резолвера перехватывается и сохраняется как
-//      PendingWrite { path: "x.y", value: z } — ничего не мутируется.
-//   3. После возврата резолвера вызывается applyPendingWrites() со
-//      собранным списком PendingWrite-записей.
-//   4. Для каждой записи восстанавливаем вложенный патч-объект, который ожидает applyPatch(),
-//      затем вызываем applyPatch() для реальной записи в хранилище.
-//   5. applyPatch() фиксирует узлы конфига, которые изменились, в множество `changed`.
-//   6. Вызывающий код использует `changed`, чтобы решить, какие зависимые резолверы перезапустить.
+// FLOW OVERVIEW:
+//   1. The resolver runs with the proxy from createValuesTrackingProxy().
+//   2. Every `values.x.y = z` inside the resolver is intercepted and stored as
+//      PendingWrite { path: "x.y", value: z } — nothing is mutated.
+//   3. After the resolver returns, applyPendingWrites() is called with the
+//      collected PendingWrite list.
+//   4. For each write, the nested patch object applyPatch() expects is rebuilt,
+//      then applyPatch() performs the real store write.
+//   5. applyPatch() records the config nodes that changed into the `changed` set.
+//   6. The caller uses `changed` to decide which dependent resolvers to re-run.
 /**
- * Сбрасывает все буферизированные записи из одного запуска резолвера в реальное хранилище.
+ * Flushes all writes buffered during one resolver run into the real store.
  *
- * Преобразует каждый плоский путь (через точку) обратно во вложенную структуру патча,
- * которую понимает applyPatch(), затем применяет его.
+ * Converts each flat (dot-separated) path back into the nested patch
+ * structure applyPatch() understands, then applies it.
  *
- * Пример:
+ * Example:
  *   PendingWrite { path: "user.vehicleExists", value: false }
  *   → patch = { user: { vehicleExists: false } }
  *   → applyPatch(rootConfig, nodeState, patch, changed, valuesCache)
  *
- * Несколько уровней вложенности работают аналогично:
+ * Deeper nesting works the same way:
  *   path: "a.b.c" → patch = { a: { b: { c: value } } }
  *
- * @param writes      — записи, буферизированные createValuesTrackingProxy во время выполнения резолвера
- * @param rootConfig  — корень дерева конфига полей (используется applyPatch для поиска узлов)
- * @param nodeState   — состояние узлов в рантайме (флаги dirty, ошибки и т.д.)
- * @param valuesCache — изменяемый кэш значений, который applyPatch обновляет на месте
- * @returns           — множество узлов конфига, значение которых реально изменилось (для отслеживания зависимостей)
+ * @param writes      — writes buffered by createValuesTrackingProxy during the resolver run
+ * @param rootConfig  — root of the field config tree (used by applyPatch to find nodes)
+ * @param nodeState   — runtime node state (dirty flags, errors, etc.)
+ * @param valuesCache — mutable values cache that applyPatch updates in place
+ * @returns           — set of config nodes whose value actually changed (for dependency tracking)
  */
 export function applyPendingWrites(writes, rootConfig, nodeState, valuesCache) {
-    // Накапливает все узлы конфига, значение которых реально изменилось в ходе этого сброса.
-    // Возвращается вызывающему коду, чтобы тот мог запланировать повторный запуск зависимых резолверов.
+    // Accumulates all config nodes whose value actually changed during this flush.
+    // Returned to the caller so it can schedule re-runs of dependent resolvers.
     const changed = new Set();
     for (const { path, value } of writes) {
-        // ── Восстанавливаем вложенный патч из пути через точку ──────────────────
-        // applyPatch() ожидает вложенный объект, зеркалирующий дерево конфига, а не плоский путь.
-        // Строим его вручную, обходя сегменты пути и вкладывая объекты друг в друга.
+        // ── Rebuild the nested patch from the dot-path ───────────────────────────
+        // applyPatch() expects a nested object mirroring the config tree, not a
+        // flat path. Build it manually by nesting objects along the path segments.
         //
-        // Пример: path = "user.vehicleExists"
+        // Example: path = "user.vehicleExists"
         //   parts = ["user", "vehicleExists"]
-        //   После цикла: patch = { user: { vehicleExists: <value> } }
+        //   After the loop: patch = { user: { vehicleExists: <value> } }
         const parts = path.split(".");
         let patch = {};
-        let current = patch; // курсор `current` идёт вглубь строящегося вложенного объекта
+        let current = patch; // the `current` cursor descends into the nested object being built
         for (let i = 0; i < parts.length - 1; i++) {
-            // Создаём промежуточный пустой объект для каждого сегмента пути, кроме последнего.
             current[parts[i]] = {};
             current = current[parts[i]];
         }
-        // Помещаем реальное значение на листе (последний сегмент).
+        // Place the actual value at the leaf (the last segment).
         current[parts[parts.length - 1]] = value;
-        // ── Применяем патч к реальному хранилищу ────────────────────────────────
-        // applyPatch обходит rootConfig по форме патча, записывает значения в
-        // valuesCache, обновляет nodeState (флаги dirty и т.д.) и фиксирует
-        // в `changed` все узлы, значение которых изменилось.
+        // ── Apply the patch to the real store ────────────────────────────────────
+        // applyPatch walks rootConfig following the patch shape, writes values into
+        // valuesCache, updates nodeState (dirty flags etc.) and records every node
+        // whose value changed into `changed`.
         applyPatch(rootConfig, nodeState, patch, changed, valuesCache);
     }
-    // Возвращаем множество изменённых узлов, чтобы пайплайн резолвов мог
-    // запланировать повторные запуски для всего, что зависело от этих значений.
     return changed;
 }
 //# sourceMappingURL=applyPendingWrites.js.map

package/dist/store/resolvePipeline/applyPendingWrites.js.map

@@ -1 +1 @@
-{"version":3,"file":"applyPendingWrites.js","sourceRoot":"","sources":["../../../store/resolvePipeline/applyPendingWrites.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAMtD,+EAA+E;AAC/E,EAAE;AACF,oDAAoD;AACpD,EAAE;AACF,2BAA2B;AAC3B,qEAAqE;AACrE,kFAAkF;AAClF,sEAAsE;AACtE,mEAAmE;AACnE,+CAA+C;AAC/C,8FAA8F;AAC9F,oEAAoE;AACpE,uFAAuF;AACvF,mGAAmG;AAEnG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAsB,EACtB,UAAyB,EACzB,SAAsC,EACtC,WAAwB;IAExB,yFAAyF;IACzF,oGAAoG;IACpG,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAElC,KAAK,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,MAAM,EAAE,CAAC;QACrC,2EAA2E;QAC3E,0FAA0F;QAC1F,6EAA6E;QAC7E,EAAE;QACF,sCAAsC;QACtC,sCAAsC;QACtC,8DAA8D;QAC9D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,KAAK,GAA4B,EAAE,CAAC;QACxC,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,8DAA8D;QACnF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,mFAAmF;YACnF,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YACvB,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAA4B,CAAC;QACzD,CAAC;QACD,2DAA2D;QAC3D,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QAEzC,2EAA2E;QAC3E,sEAAsE;QACtE,oEAAoE;QACpE,qDAAqD;QACrD,UAAU,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;IACjE,CAAC;IAED,qEAAqE;IACrE,4EAA4E;IAC5E,OAAO,OAAO,CAAC;AACjB,CAAC"}
+{"version":3,"file":"applyPendingWrites.js","sourceRoot":"","sources":["../../../store/resolvePipeline/applyPendingWrites.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAMtD,gFAAgF;AAChF,EAAE;AACF,0DAA0D;AAC1D,EAAE;AACF,iBAAiB;AACjB,0EAA0E;AAC1E,+EAA+E;AAC/E,oEAAoE;AACpE,2EAA2E;AAC3E,oCAAoC;AACpC,gFAAgF;AAChF,wDAAwD;AACxD,kFAAkF;AAClF,gFAAgF;AAEhF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAsB,EACtB,UAAyB,EACzB,SAAsC,EACtC,WAAwB;IAExB,+EAA+E;IAC/E,4EAA4E;IAC5E,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAElC,KAAK,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,MAAM,EAAE,CAAC;QACrC,4EAA4E;QAC5E,wEAAwE;QACxE,2EAA2E;QAC3E,EAAE;QACF,uCAAuC;QACvC,sCAAsC;QACtC,iEAAiE;QACjE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,KAAK,GAA4B,EAAE,CAAC;QACxC,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,mEAAmE;QACxF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YACvB,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAA4B,CAAC;QACzD,CAAC;QACD,yDAAyD;QACzD,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QAEzC,4EAA4E;QAC5E,4EAA4E;QAC5E,2EAA2E;QAC3E,sCAAsC;QACtC,UAAU,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/store/resolvePipeline/createContextTrackingProxy.d.ts

@@ -1,15 +1,16 @@
 /**
- * createContextTrackingProxy — оборачивает плоский объект контекста в read-only Proxy,
- * который записывает ключи, к которым обращался резолвер.
+ * createContextTrackingProxy — wraps the flat context object in a read-only
+ * Proxy that records the keys the resolver accessed.
  *
- * Используется в executeResolve для автоматического определения контекстных зависимостей:
- * если резолвер читает `store.context.accountId`, то `$context.accountId` добавляется
- * в auto-deps, и резолвер перезапустится при изменении этого ключа через `setContext`.
+ * Used in executeResolve to detect context dependencies automatically:
+ * when a resolver reads `store.context.accountId`, `$context.accountId` is
+ * added to the auto-deps, and the resolver re-runs when that key changes via
+ * `setContext`.
  */
 export interface ContextTrackingResult {
-    /** Прокси над context — передаётся внутри storeProxy в resolver */
+    /** Proxy over the context — handed to the resolver inside storeProxy */
     proxy: Record<string, unknown>;
-    /** Ключи контекста, к которым обратился резолвер */
+    /** Context keys the resolver accessed */
     getAccessedKeys: () => Set<string>;
 }
 export declare function createContextTrackingProxy(context: Record<string, unknown>): ContextTrackingResult;

package/dist/store/resolvePipeline/createContextTrackingProxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createContextTrackingProxy.d.ts","sourceRoot":"","sources":["../../../store/resolvePipeline/createContextTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,qBAAqB;IACpC,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,oDAAoD;IACpD,eAAe,EAAE,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,qBAAqB,CAoBvB"}
+{"version":3,"file":"createContextTrackingProxy.d.ts","sourceRoot":"","sources":["../../../store/resolvePipeline/createContextTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,yCAAyC;IACzC,eAAe,EAAE,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,qBAAqB,CAoBvB"}

package/dist/store/resolvePipeline/createContextTrackingProxy.js

@@ -1,10 +1,11 @@
 /**
- * createContextTrackingProxy — оборачивает плоский объект контекста в read-only Proxy,
- * который записывает ключи, к которым обращался резолвер.
+ * createContextTrackingProxy — wraps the flat context object in a read-only
+ * Proxy that records the keys the resolver accessed.
  *
- * Используется в executeResolve для автоматического определения контекстных зависимостей:
- * если резолвер читает `store.context.accountId`, то `$context.accountId` добавляется
- * в auto-deps, и резолвер перезапустится при изменении этого ключа через `setContext`.
+ * Used in executeResolve to detect context dependencies automatically:
+ * when a resolver reads `store.context.accountId`, `$context.accountId` is
+ * added to the auto-deps, and the resolver re-runs when that key changes via
+ * `setContext`.
  */
 export function createContextTrackingProxy(context) {
     const accessedKeys = new Set();

package/dist/store/resolvePipeline/createContextTrackingProxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"createContextTrackingProxy.js","sourceRoot":"","sources":["../../../store/resolvePipeline/createContextTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,MAAM,UAAU,0BAA0B,CACxC,OAAgC;IAEhC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IAEvC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE;QAC/B,GAAG,CAAC,OAAO,EAAE,GAAG;YACd,8DAA8D;YAC9D,IAAI,OAAO,GAAG,KAAK,QAAQ;gBAAE,OAAO,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;YAC9D,YAAY,CAAC,GAAG,CAAC,GAAa,CAAC,CAAC;YAChC,OAAO,OAAO,CAAC,GAAa,CAAC,CAAC;QAChC,CAAC;QACD,GAAG;YACD,wCAAwC;YACxC,MAAM,IAAI,SAAS,CAAC,8CAA8C,CAAC,CAAC;QACtE,CAAC;KACF,CAAC,CAAC;IAEH,OAAO;QACL,KAAK;QACL,eAAe,EAAE,GAAG,EAAE,CAAC,YAAY;KACpC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"createContextTrackingProxy.js","sourceRoot":"","sources":["../../../store/resolvePipeline/createContextTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH,MAAM,UAAU,0BAA0B,CACxC,OAAgC;IAEhC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IAEvC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE;QAC/B,GAAG,CAAC,OAAO,EAAE,GAAG;YACd,8DAA8D;YAC9D,IAAI,OAAO,GAAG,KAAK,QAAQ;gBAAE,OAAO,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;YAC9D,YAAY,CAAC,GAAG,CAAC,GAAa,CAAC,CAAC;YAChC,OAAO,OAAO,CAAC,GAAa,CAAC,CAAC;QAChC,CAAC;QACD,GAAG;YACD,wCAAwC;YACxC,MAAM,IAAI,SAAS,CAAC,8CAA8C,CAAC,CAAC;QACtE,CAAC;KACF,CAAC,CAAC;IAEH,OAAO;QACL,KAAK;QACL,eAAe,EAAE,GAAG,EAAE,CAAC,YAAY;KACpC,CAAC;AACJ,CAAC"}

package/dist/store/resolvePipeline/createValuesTrackingProxy.d.ts

@@ -1,75 +1,75 @@
 /**
- * createValuesTrackingProxy — оборачивает дерево значений в Proxy, который:
- *   - ЧТЕНИЕ: отслеживает обращённые пути (автоматические зависимости для повторного запуска резолвера)
- *   - ЗАПИСЬ: буферизирует побочные эффекты (пакетный режим, без промежуточных ре-рендеров)
+ * createValuesTrackingProxy — wraps the values tree in a Proxy that:
+ *   - READS: tracks accessed paths (automatic dependencies for resolver re-runs)
+ *   - WRITES: buffers side effects (batch mode, no intermediate re-renders)
  *
- * Используется внутри выполнения резолвера: резолвер получает этот прокси вместо реального объекта.
- * После завершения резолвера обращённые пути сохраняются для отслеживания зависимостей,
- * а буферизированные записи сбрасываются одним пакетом.
+ * Used inside resolver execution: the resolver receives this proxy instead of
+ * the real object. After the resolver finishes, the accessed paths are stored
+ * for dependency tracking and the buffered writes are flushed in one batch.
  *
- * ─── КАК ЭТО РАБОТАЕТ ────────────────────────────────────────────────────────
+ * ─── HOW IT WORKS ────────────────────────────────────────────────────────────
  *
- * Дерево значений выглядит как обычный вложенный объект:
+ * The values tree looks like a regular nested object:
  *   { user: { name: "Alice", vehicleExists: true }, payment: { amount: 100 } }
  *
- * Когда резолвер запускается, он получает этот прокси вместо реального объекта.
- * Прокси перехватывает каждое обращение к свойству:
+ * When the resolver runs, it receives this proxy instead of the real object.
+ * The proxy intercepts every property access:
  *
- *   ЧТЕНИЕ:  values.user.name
- *     → прокси возвращает вложенный прокси для "user"
- *     → вложенный прокси перехватывает "name", записывает путь "user.name" в accessedPaths
- *     → возвращает реальное значение
+ *   READ:  values.user.name
+ *     → the proxy returns a nested proxy for "user"
+ *     → the nested proxy intercepts "name", records the path "user.name" in accessedPaths
+ *     → returns the real value
  *
- *   ЗАПИСЬ: values.user.vehicleExists = false
- *     → прокси перехватывает присваивание, записывает { path: "user.vehicleExists", value: false }
- *       в pendingWrites[]
- *     → НЕ трогает реальный объект значений — запись отложена!
+ *   WRITE: values.user.vehicleExists = false
+ *     → the proxy intercepts the assignment, records { path: "user.vehicleExists", value: false }
+ *       into pendingWrites[]
+ *     → the real values object is NOT touched — the write is deferred!
  *
- * После возврата резолвера:
- *   1. getAccessedPaths() → используется для перестройки графа зависимостей этого резолвера
- *      (при следующем изменении любого из этих путей резолвер запустится снова)
- *   2. getPendingWrites() → передаётся в applyPendingWrites(), который превращает каждый
- *      путь обратно во вложенный патч и вызывает applyPatch() на реальном хранилище
+ * After the resolver returns:
+ *   1. getAccessedPaths() → used to rebuild this resolver's dependency graph
+ *      (the resolver re-runs the next time any of these paths changes)
+ *   2. getPendingWrites() → passed to applyPendingWrites(), which turns each
+ *      path back into a nested patch and calls applyPatch() on the real store
  *
- * ЗАЧЕМ БУФЕРИЗИРОВАТЬ ЗАПИСИ вместо немедленного применения?
- *   - Предотвращает каскадные ре-рендеры в середине работы резолвера
- *   - Все мутации применяются одним атомарным пакетом → согласованное состояние после каждого тика пайплайна
- *   - Записи резолвера A случайно не запускают резолвер B в процессе его выполнения
+ * WHY BUFFER WRITES instead of applying immediately?
+ *   - Prevents cascading re-renders in the middle of a resolver run
+ *   - All mutations are applied in one atomic batch → consistent state after every pipeline tick
+ *   - Resolver A's writes don't accidentally trigger resolver B mid-run
  */
 export interface PendingWrite {
     /**
-     * Путь в дереве значений, разделённый точками, например "user.vehicleExists" или "payment.amount".
-     * Отражает структуру объекта values (аналогично valuesCache.values).
-     * applyPendingWrites() разбивает этот путь по "." для построения вложенного патч-объекта.
+     * Dot-separated path in the values tree, e.g. "user.vehicleExists" or "payment.amount".
+     * Mirrors the structure of the values object (like valuesCache.values).
+     * applyPendingWrites() splits this path on "." to build a nested patch object.
      */
     path: string;
-    /** Новое значение, которое резолвер хочет записать по этому пути. */
+    /** The new value the resolver wants to write at this path. */
     value: unknown;
 }
 export interface ValuesTrackingResult {
-    /** Отслеживающий прокси с поддержкой записи для передачи резолверу. Чтения трекаются, записи буферизируются. */
+    /** Writable tracking proxy handed to the resolver. Reads are tracked, writes buffered. */
     proxy: Record<string, unknown>;
     /**
-     * Возвращает все пути (через точку), которые были ПРОЧИТАНЫ в ходе выполнения резолвера.
-     * Используется после возврата резолвера для обновления графа зависимостей:
-     * резолвер повторно запустится при изменении любого из этих путей.
+     * Returns all (dot-separated) paths that were READ during the resolver run.
+     * Used after the resolver returns to update the dependency graph:
+     * the resolver re-runs when any of these paths changes.
      */
     getAccessedPaths: () => Set<string>;
     /**
-     * Возвращает все операции записи, буферизированные во время выполнения резолвера.
-     * Ни одна из этих записей ещё не применена к реальному хранилищу —
-     * они сбрасываются одним пакетом через applyPendingWrites() после возврата резолвера.
+     * Returns all write operations buffered during the resolver run.
+     * None of these writes has been applied to the real store yet —
+     * they are flushed in one batch via applyPendingWrites() after the resolver returns.
      */
     getPendingWrites: () => PendingWrite[];
 }
 /**
- * Создаёт отслеживающий прокси с поддержкой записи для дерева значений.
+ * Creates a writable tracking proxy for the values tree.
  *
- * - Чтение примитива записывает полный путь (например "user.id") в accessedPaths
- * - Чтение объекта возвращает вложенный прокси (рекурсивно), не трекается до обращения к листу
- * - Запись по ЛЮБОМУ пути буферизирует присваивание в pendingWrites[], не затрагивая реальные данные
+ * - Reading a primitive records the full path (e.g. "user.id") in accessedPaths
+ * - Reading an object returns a nested proxy (recursively); not tracked until a leaf is read
+ * - Writing to ANY path buffers the assignment in pendingWrites[] without touching real data
  *
- * @param values — текущий снапшот значений (из valuesCache.values), здесь считается только для чтения
+ * @param values — current values snapshot (from valuesCache.values), treated as read-only here
  */
 export declare function createValuesTrackingProxy(values: Record<string, unknown>): ValuesTrackingResult;
 //# sourceMappingURL=createValuesTrackingProxy.d.ts.map

package/dist/store/resolvePipeline/createValuesTrackingProxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createValuesTrackingProxy.d.ts","sourceRoot":"","sources":["../../../store/resolvePipeline/createValuesTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,gHAAgH;IAChH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;IACpC;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,YAAY,EAAE,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,oBAAoB,CAwFtB"}
+{"version":3,"file":"createValuesTrackingProxy.d.ts","sourceRoot":"","sources":["../../../store/resolvePipeline/createValuesTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;IACpC;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,YAAY,EAAE,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,oBAAoB,CAwFtB"}