palistor 0.0.24 → 0.0.26

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"}

package/dist/store/resolvePipeline/createValuesTrackingProxy.js

@@ -1,123 +1,123 @@
 /**
- * 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
  */
 /**
- * Создаёт отслеживающий прокси с поддержкой записи для дерева значений.
+ * 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 function createValuesTrackingProxy(values) {
-    // Собирает все пути к примитивам, которые резолвер читает.
-    // Пример после работы резолвера: Set { "user.name", "user.vehicleExists" }
+    // Collects every primitive path the resolver reads.
+    // Example after a resolver run: Set { "user.name", "user.vehicleExists" }
     const accessedPaths = new Set();
-    // Собирает все записи, которые резолвер выполняет, в порядке их появления.
-    // Ни одна не применяется до вызова applyPendingWrites() после возврата резолвера.
-    // Пример: [{ path: "user.vehicleExists", value: false }, { path: "payment.amount", value: 200 }]
+    // Collects every write the resolver performs, in order of appearance.
+    // None is applied until applyPendingWrites() runs after the resolver returns.
+    // Example: [{ path: "user.vehicleExists", value: false }, { path: "payment.amount", value: 200 }]
     const pendingWrites = [];
-    // Кэширует вложенные прокси по их префиксу пути, чтобы при повторном обращении
-    // к одному и тому же вложенному объекту возвращался тот же экземпляр прокси.
-    // Ключ: префикс пути через точку (например "user"), или "__root__" для корневого уровня.
+    // Caches nested proxies by their path prefix so repeated access to the same
+    // nested object returns the same proxy instance.
+    // Key: dot-separated path prefix (e.g. "user"), or "__root__" for the root level.
     const proxyCache = new Map();
     /**
-     * Рекурсивно оборачивает `target` в Proxy, который отслеживает чтения и буферизирует записи.
+     * Recursively wraps `target` in a Proxy that tracks reads and buffers writes.
      *
-     * @param target     — реальный объект значений (или вложенный подобъект) для обёртки
-     * @param parentPath — накопленный префикс пути через точку, например "" для корня или "user" для вложенного
+     * @param target     — the real values object (or nested sub-object) to wrap
+     * @param parentPath — accumulated dot-path prefix, e.g. "" for the root or "user" for a nested one
      */
     function buildValuesProxy(target, parentPath) {
-        // Возвращаем закэшированный прокси для данного пути, чтобы не создавать дублирующие прокси
-        // для одного узла (важно для проверок ссылочного равенства внутри резолверов).
+        // Return the cached proxy for this path so we don't create duplicate
+        // proxies for one node (matters for referential equality checks inside resolvers).
         const cacheKey = parentPath || "__root__";
         if (proxyCache.has(cacheKey))
             return proxyCache.get(cacheKey);
         const p = new Proxy(target, {
-            // ─── GET-ловушка ──────────────────────────────────────────────────────
-            // Перехватывает каждое чтение свойства. Строит полный путь через точку, затем:
-            //   • если значение — вложенный простой объект → возвращает вложенный прокси
-            //     (промежуточные пути не трекаем, только чтения листьев)
-            //   • если значение — примитив → записывает путь в accessedPaths и возвращает его
+            // ─── GET trap ─────────────────────────────────────────────────────────
+            // Intercepts every property read. Builds the full dot-path, then:
+            //   • nested plain object → returns a nested proxy
+            //     (intermediate paths are not tracked, only leaf reads)
+            //   • primitive → records the path in accessedPaths and returns it
             get(_t, key) {
-                // Игнорируем символьные ключи (например Symbol.toPrimitive, Symbol.iterator) —
-                // это внутренние ключи фреймворка/рантайма, не часть дерева значений.
+                // Ignore symbol keys (e.g. Symbol.toPrimitive, Symbol.iterator) —
+                // framework/runtime internals, not part of the values tree.
                 if (typeof key === "symbol")
                     return undefined;
-                // Формируем полный путь через точку для данного обращения, например "user" + "." + "name" = "user.name"
+                // Full dot-path for this access, e.g. "user" + "." + "name" = "user.name"
                 const fullPath = parentPath ? `${parentPath}.${key}` : key;
                 const val = target[key];
-                // Если значение — простой объект, оборачиваем его в ещё один прокси, чтобы
-                // продолжать отслеживать более глубокие чтения, например values.user.address.city.
-                // Массивы и Date считаются листовыми значениями (не рекурсируем).
+                // Plain objects are wrapped in another proxy to keep tracking deeper
+                // reads, e.g. values.user.address.city.
+                // Arrays and Dates are treated as leaf values (no recursion).
                 if (val !== null && typeof val === "object" && !Array.isArray(val) && !(val instanceof Date)) {
                     return buildValuesProxy(val, fullPath);
                 }
-                // Чтение листа — записываем путь, чтобы резолвер мог быть перезапущен позже,
-                // когда это конкретное значение изменится в хранилище.
+                // Leaf read — record the path so the resolver can be re-triggered
+                // later when this specific value changes in the store.
                 accessedPaths.add(fullPath);
                 return val;
             },
-            // ─── SET-ловушка ──────────────────────────────────────────────────────
-            // Перехватывает каждое присваивание. Вместо мутации реального объекта значений
-            // помещаем дескриптор PendingWrite в буфер.
+            // ─── SET trap ─────────────────────────────────────────────────────────
+            // Intercepts every assignment. Instead of mutating the real values
+            // object, pushes a PendingWrite descriptor into the buffer.
             //
-            // Запись намеренно откладывается:
-            //   1. Резолвер может выполнить несколько записей подряд; сначала собираем все.
-            //   2. applyPendingWrites() вызывается после возврата резолвера, поэтому все
-            //      мутации применяются атомарно за один вызов applyPatch().
-            //   3. Это не позволяет резолверу наблюдать собственные частично применённые записи.
+            // Writes are deliberately deferred:
+            //   1. A resolver may perform several writes in a row; collect them all first.
+            //   2. applyPendingWrites() runs after the resolver returns, so all
+            //      mutations are applied atomically in a single applyPatch() call.
+            //   3. The resolver cannot observe its own partially applied writes.
             set(_t, key, newValue) {
                 if (typeof key === "symbol")
                     return false;
                 const fullPath = parentPath ? `${parentPath}.${key}` : key;
-                // Буферизируем запись — реальное хранилище пока не трогаем.
+                // Buffer the write — the real store is untouched for now.
                 pendingWrites.push({ path: fullPath, value: newValue });
-                // Возврат true сообщает Proxy, что присваивание «принято»
-                // (предотвращает TypeError в strict-режиме, несмотря на отсутствие реальной мутации).
+                // Returning true tells the Proxy the assignment was "accepted"
+                // (prevents a strict-mode TypeError despite no real mutation happening).
                 return true;
             },
         });
         proxyCache.set(cacheKey, p);
         return p;
     }
-    // Строим прокси корневого уровня (parentPath = "" означает отсутствие префикса).
+    // Build the root-level proxy (parentPath = "" means no prefix).
     const proxy = buildValuesProxy(values, "");
     return {
         proxy,

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

@@ -1 +1 @@
-{"version":3,"file":"createValuesTrackingProxy.js","sourceRoot":"","sources":["../../../store/resolvePipeline/createValuesTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AA8BH;;;;;;;;GAQG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAA+B;IAE/B,2DAA2D;IAC3D,2EAA2E;IAC3E,MAAM,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IAExC,2EAA2E;IAC3E,kFAAkF;IAClF,iGAAiG;IACjG,MAAM,aAAa,GAAmB,EAAE,CAAC;IAEzC,+EAA+E;IAC/E,6EAA6E;IAC7E,yFAAyF;IACzF,MAAM,UAAU,GAAG,IAAI,GAAG,EAAmB,CAAC;IAE9C;;;;;OAKG;IACH,SAAS,gBAAgB,CAAC,MAA+B,EAAE,UAAkB;QAC3E,2FAA2F;QAC3F,+EAA+E;QAC/E,MAAM,QAAQ,GAAG,UAAU,IAAI,UAAU,CAAC;QAC1C,IAAI,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,OAAO,UAAU,CAAC,GAAG,CAAC,QAAQ,CAA4B,CAAC;QAEzF,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;YAC1B,yEAAyE;YACzE,+EAA+E;YAC/E,6EAA6E;YAC7E,6DAA6D;YAC7D,kFAAkF;YAClF,GAAG,CAAC,EAAE,EAAE,GAAoB;gBAC1B,+EAA+E;gBAC/E,sEAAsE;gBACtE,IAAI,OAAO,GAAG,KAAK,QAAQ;oBAAE,OAAO,SAAS,CAAC;gBAE9C,wGAAwG;gBACxG,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;gBAC3D,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBAExB,2EAA2E;gBAC3E,mFAAmF;gBACnF,kEAAkE;gBAClE,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,YAAY,IAAI,CAAC,EAAE,CAAC;oBAC7F,OAAO,gBAAgB,CAAC,GAA8B,EAAE,QAAQ,CAAC,CAAC;gBACpE,CAAC;gBAED,6EAA6E;gBAC7E,uDAAuD;gBACvD,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAC5B,OAAO,GAAG,CAAC;YACb,CAAC;YAED,yEAAyE;YACzE,+EAA+E;YAC/E,4CAA4C;YAC5C,EAAE;YACF,kCAAkC;YAClC,gFAAgF;YAChF,6EAA6E;YAC7E,gEAAgE;YAChE,qFAAqF;YACrF,GAAG,CAAC,EAAE,EAAE,GAAoB,EAAE,QAAiB;gBAC7C,IAAI,OAAO,GAAG,KAAK,QAAQ;oBAAE,OAAO,KAAK,CAAC;gBAE1C,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;gBAC3D,4DAA4D;gBAC5D,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;gBACxD,0DAA0D;gBAC1D,sFAAsF;gBACtF,OAAO,IAAI,CAAC;YACd,CAAC;SACF,CAAC,CAAC;QAEH,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAC5B,OAAO,CAA4B,CAAC;IACtC,CAAC;IAED,iFAAiF;IACjF,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAE3C,OAAO;QACL,KAAK;QACL,gBAAgB,EAAE,GAAG,EAAE,CAAC,aAAa;QACrC,gBAAgB,EAAE,GAAG,EAAE,CAAC,aAAa;KACtC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"createValuesTrackingProxy.js","sourceRoot":"","sources":["../../../store/resolvePipeline/createValuesTrackingProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AA8BH;;;;;;;;GAQG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAA+B;IAE/B,oDAAoD;IACpD,0EAA0E;IAC1E,MAAM,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IAExC,sEAAsE;IACtE,8EAA8E;IAC9E,kGAAkG;IAClG,MAAM,aAAa,GAAmB,EAAE,CAAC;IAEzC,4EAA4E;IAC5E,iDAAiD;IACjD,kFAAkF;IAClF,MAAM,UAAU,GAAG,IAAI,GAAG,EAAmB,CAAC;IAE9C;;;;;OAKG;IACH,SAAS,gBAAgB,CAAC,MAA+B,EAAE,UAAkB;QAC3E,qEAAqE;QACrE,mFAAmF;QACnF,MAAM,QAAQ,GAAG,UAAU,IAAI,UAAU,CAAC;QAC1C,IAAI,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,OAAO,UAAU,CAAC,GAAG,CAAC,QAAQ,CAA4B,CAAC;QAEzF,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;YAC1B,yEAAyE;YACzE,kEAAkE;YAClE,mDAAmD;YACnD,4DAA4D;YAC5D,mEAAmE;YACnE,GAAG,CAAC,EAAE,EAAE,GAAoB;gBAC1B,kEAAkE;gBAClE,4DAA4D;gBAC5D,IAAI,OAAO,GAAG,KAAK,QAAQ;oBAAE,OAAO,SAAS,CAAC;gBAE9C,0EAA0E;gBAC1E,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;gBAC3D,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBAExB,qEAAqE;gBACrE,wCAAwC;gBACxC,8DAA8D;gBAC9D,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,YAAY,IAAI,CAAC,EAAE,CAAC;oBAC7F,OAAO,gBAAgB,CAAC,GAA8B,EAAE,QAAQ,CAAC,CAAC;gBACpE,CAAC;gBAED,kEAAkE;gBAClE,uDAAuD;gBACvD,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAC5B,OAAO,GAAG,CAAC;YACb,CAAC;YAED,yEAAyE;YACzE,mEAAmE;YACnE,4DAA4D;YAC5D,EAAE;YACF,oCAAoC;YACpC,+EAA+E;YAC/E,oEAAoE;YACpE,uEAAuE;YACvE,qEAAqE;YACrE,GAAG,CAAC,EAAE,EAAE,GAAoB,EAAE,QAAiB;gBAC7C,IAAI,OAAO,GAAG,KAAK,QAAQ;oBAAE,OAAO,KAAK,CAAC;gBAE1C,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;gBAC3D,0DAA0D;gBAC1D,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;gBACxD,+DAA+D;gBAC/D,yEAAyE;gBACzE,OAAO,IAAI,CAAC;YACd,CAAC;SACF,CAAC,CAAC;QAEH,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAC5B,OAAO,CAA4B,CAAC;IACtC,CAAC;IAED,gEAAgE;IAChE,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAE3C,OAAO;QACL,KAAK;QACL,gBAAgB,EAAE,GAAG,EAAE,CAAC,aAAa;QACrC,gBAAgB,EAAE,GAAG,EAAE,CAAC,aAAa;KACtC,CAAC;AACJ,CAAC"}