@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-A6OFCXDQ.js

@@ -0,0 +1,397 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/state-trait/rowid.ts
+var parseSegments = (path) => {
+  if (!path) return [];
+  return path.split(".").map(
+    (seg) => /^[0-9]+$/.test(seg) ? Number(seg) : seg
+  );
+};
+var getAtPath = (state, path) => {
+  if (!path || state == null) return state;
+  const segments = parseSegments(path);
+  let current = state;
+  for (const seg of segments) {
+    if (current == null) return void 0;
+    if (typeof seg === "number") {
+      current = Array.isArray(current) ? current[seg] : current[String(seg)];
+      continue;
+    }
+    current = current[seg];
+  }
+  return current;
+};
+var setAtPathMutating = (draft, path, value) => {
+  if (!path) return;
+  const segments = parseSegments(path);
+  if (segments.length === 0) return;
+  let current = draft;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const key = segments[i];
+    const nextKey = segments[i + 1];
+    const next = current?.[key];
+    if (next == null || typeof next !== "object") {
+      current[key] = typeof nextKey === "number" ? [] : {};
+    }
+    current = current[key];
+  }
+  const last = segments[segments.length - 1];
+  current[last] = value;
+};
+var unsetAtPathMutating = (draft, path) => {
+  if (!path) return;
+  const segments = parseSegments(path);
+  if (segments.length === 0) return;
+  let current = draft;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const key = segments[i];
+    const next = current?.[key];
+    if (next == null || typeof next !== "object") {
+      return;
+    }
+    current = next;
+  }
+  const last = segments[segments.length - 1];
+  if (Array.isArray(current) && typeof last === "number") {
+    current[last] = void 0;
+    return;
+  }
+  if (current && typeof current === "object") {
+    delete current[last];
+  }
+};
+var parseListItemFieldPath = (fieldPath) => {
+  const raw = typeof fieldPath === "string" ? fieldPath.trim() : "";
+  if (!raw) return void 0;
+  const segments = raw.split(".").filter(Boolean);
+  let lastListSeg = -1;
+  for (let i = 0; i < segments.length; i++) {
+    if (segments[i].endsWith("[]")) lastListSeg = i;
+  }
+  if (lastListSeg < 0) return void 0;
+  const strip = (seg) => seg.endsWith("[]") ? seg.slice(0, -2) : seg;
+  const listPath = segments.slice(0, lastListSeg + 1).map(strip).join(".");
+  const itemPath = segments.slice(lastListSeg + 1).map(strip).join(".");
+  return { listPath, itemPath };
+};
+var toListItemValuePath = (listPath, index, itemPath) => itemPath ? `${listPath}.${index}.${itemPath}` : `${listPath}.${index}`;
+var readTrackBy = (item, trackBy) => {
+  if (!item || typeof item !== "object") return void 0;
+  const segments = trackBy.split(".");
+  let current = item;
+  for (const seg of segments) {
+    if (current == null) return void 0;
+    current = current[seg];
+  }
+  return current;
+};
+var didReorderByReference = (prevItems, nextItems) => {
+  const buckets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < prevItems.length; i++) {
+    const item = prevItems[i];
+    const list = buckets.get(item) ?? [];
+    list.push(i);
+    buckets.set(item, list);
+  }
+  for (let nextIndex = 0; nextIndex < nextItems.length; nextIndex++) {
+    const item = nextItems[nextIndex];
+    const q = buckets.get(item);
+    if (!q || q.length === 0) continue;
+    const prevIndex = q.shift();
+    if (prevIndex !== nextIndex) {
+      return true;
+    }
+  }
+  return false;
+};
+var hasStableTrackByKeys = (items, trackBy) => items.every((item) => readTrackBy(item, trackBy) !== void 0);
+var isSameTrackBySequence = (prevItems, nextItems, trackBy) => {
+  if (prevItems.length !== nextItems.length) return false;
+  for (let i = 0; i < prevItems.length; i++) {
+    if (!Object.is(
+      readTrackBy(prevItems[i], trackBy),
+      readTrackBy(nextItems[i], trackBy)
+    )) {
+      return false;
+    }
+  }
+  return true;
+};
+var reconcileIds = (prev, nextItems, trackBy, makeRowId) => {
+  const nextRowId = makeRowId ?? /* @__PURE__ */ (() => {
+    let rowSeq = 0;
+    return () => {
+      rowSeq += 1;
+      return `r${rowSeq}`;
+    };
+  })();
+  if (!prev) {
+    return {
+      ids: nextItems.map(() => nextRowId()),
+      removed: []
+    };
+  }
+  if (prev.itemsRef === nextItems) {
+    return {
+      ids: prev.ids,
+      removed: []
+    };
+  }
+  const sameLength = prev.itemsRef.length === nextItems.length;
+  if (sameLength) {
+    if (trackBy) {
+      const canUseKeys = hasStableTrackByKeys(prev.itemsRef, trackBy) && hasStableTrackByKeys(nextItems, trackBy);
+      if (canUseKeys) {
+        if (isSameTrackBySequence(prev.itemsRef, nextItems, trackBy)) {
+          return {
+            ids: prev.ids,
+            removed: []
+          };
+        }
+      } else {
+        if (!didReorderByReference(prev.itemsRef, nextItems)) {
+          return {
+            ids: prev.ids,
+            removed: []
+          };
+        }
+      }
+    } else if (!didReorderByReference(prev.itemsRef, nextItems)) {
+      return {
+        ids: prev.ids,
+        removed: []
+      };
+    }
+  }
+  const keyOf = (item) => {
+    if (!trackBy) return item;
+    const k = readTrackBy(item, trackBy);
+    return k !== void 0 ? k : item;
+  };
+  const buckets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < prev.itemsRef.length; i++) {
+    const key = keyOf(prev.itemsRef[i]);
+    const list = buckets.get(key) ?? [];
+    list.push(prev.ids[i]);
+    buckets.set(key, list);
+  }
+  const ids = [];
+  for (let i = 0; i < nextItems.length; i++) {
+    const key = keyOf(nextItems[i]);
+    const list = buckets.get(key);
+    if (list && list.length > 0) {
+      ids.push(list.shift());
+    } else {
+      ids.push(nextRowId());
+    }
+  }
+  const removed = [];
+  for (const list of buckets.values()) {
+    removed.push(...list);
+  }
+  return { ids, removed };
+};
+var buildIndexById = (ids) => {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ids.length; i++) {
+    map.set(ids[i], i);
+  }
+  return map;
+};
+var RowIdStore = class {
+  constructor(instanceId) {
+    this.instanceId = instanceId;
+    this.lists = /* @__PURE__ */ new Map();
+    this.removalListeners = /* @__PURE__ */ new Map();
+    this.rowIdIndex = /* @__PURE__ */ new Map();
+    this.nextRowSeq = 0;
+    this.listKey = (listPath, parentRowId) => parentRowId ? `${listPath}@@${parentRowId}` : listPath;
+    this.makeRowId = () => {
+      this.nextRowSeq += 1;
+      return this.instanceId ? `${this.instanceId}::r${this.nextRowSeq}` : `r${this.nextRowSeq}`;
+    };
+  }
+  notifyRemoved(listPath, rowId) {
+    const listeners = this.removalListeners.get(listPath);
+    if (!listeners || listeners.size === 0) return;
+    for (const fn of listeners) {
+      try {
+        fn(rowId);
+      } catch {
+      }
+    }
+  }
+  removeDescendants(parentRowId) {
+    const keys = [];
+    for (const [k, st] of this.lists.entries()) {
+      if (st.parentRowId === parentRowId) keys.push(k);
+    }
+    for (const key of keys) {
+      const st = this.lists.get(key);
+      if (!st) continue;
+      this.lists.delete(key);
+      for (let i = 0; i < st.ids.length; i++) {
+        const rowId = st.ids[i];
+        this.rowIdIndex.delete(rowId);
+        this.notifyRemoved(st.listPath, rowId);
+        this.removeDescendants(rowId);
+      }
+    }
+  }
+  onRemoved(listPath, listener) {
+    const set = this.removalListeners.get(listPath) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.removalListeners.set(listPath, set);
+    return () => {
+      const current = this.removalListeners.get(listPath);
+      if (!current) return;
+      current.delete(listener);
+      if (current.size === 0) this.removalListeners.delete(listPath);
+    };
+  }
+  getRowId(listPath, index, parentRowId) {
+    const state = this.lists.get(this.listKey(listPath, parentRowId));
+    return state ? state.ids[index] : void 0;
+  }
+  getIndex(listPath, rowId) {
+    const info = this.rowIdIndex.get(rowId);
+    if (!info) return void 0;
+    if (info.listPath !== listPath) return void 0;
+    return info.index;
+  }
+  /**
+   * ensureList：
+   * - 让指定 listPath 的 RowID 映射与当前 items 对齐；
+   * - 返回最新的 ids（index -> RowId）。
+   */
+  ensureList(listPath, items, trackBy, parentRowId) {
+    const key = this.listKey(listPath, parentRowId);
+    const prev = this.lists.get(key);
+    const { ids, removed } = reconcileIds(prev, items, trackBy ?? prev?.trackBy, this.makeRowId);
+    const next = {
+      listPath,
+      parentRowId,
+      itemsRef: items,
+      ids,
+      indexById: buildIndexById(ids),
+      trackBy: trackBy ?? prev?.trackBy
+    };
+    this.lists.set(key, next);
+    if (removed.length > 0) {
+      for (const rowId of removed) {
+        this.rowIdIndex.delete(rowId);
+        this.notifyRemoved(listPath, rowId);
+        this.removeDescendants(rowId);
+      }
+    }
+    for (let i = 0; i < ids.length; i++) {
+      const rowId = ids[i];
+      this.rowIdIndex.set(rowId, { key, listPath, index: i });
+    }
+    return ids;
+  }
+  /**
+   * updateAll：
+   * - 在每次提交后对齐所有已知 list 的 RowID 映射；
+   * - configs 来自 StateTraitProgram.spec 中的 list 声明（可携带 trackBy）。
+   */
+  updateAll(state, configs) {
+    const cfgByPath = /* @__PURE__ */ new Map();
+    const paths = [];
+    for (const cfg of configs) {
+      if (!cfg || typeof cfg.path !== "string") continue;
+      const p = cfg.path.trim();
+      if (!p) continue;
+      cfgByPath.set(p, cfg);
+      paths.push(p);
+    }
+    const pathSet = new Set(paths);
+    const parentOf = (path) => {
+      const segments = path.split(".").filter(Boolean);
+      let best;
+      for (let i = 1; i < segments.length; i++) {
+        const prefix = segments.slice(0, i).join(".");
+        if (pathSet.has(prefix)) best = prefix;
+      }
+      return best;
+    };
+    const parentByPath = /* @__PURE__ */ new Map();
+    const suffixByPath = /* @__PURE__ */ new Map();
+    const childrenByParent = /* @__PURE__ */ new Map();
+    for (const path of paths) {
+      const parent = parentOf(path);
+      parentByPath.set(path, parent);
+      const suffix = parent ? path.slice(parent.length + 1) : path;
+      suffixByPath.set(path, suffix);
+      const list = childrenByParent.get(parent) ?? [];
+      list.push(path);
+      childrenByParent.set(parent, list);
+    }
+    const roots = (childrenByParent.get(void 0) ?? []).slice().sort((a, b) => a.localeCompare(b));
+    const visit = (listPath, parentRowId, listValue) => {
+      const cfg = cfgByPath.get(listPath);
+      const items = Array.isArray(listValue) ? listValue : [];
+      const ids = this.ensureList(listPath, items, cfg?.trackBy, parentRowId);
+      const children = (childrenByParent.get(listPath) ?? []).slice().sort((a, b) => a.localeCompare(b));
+      if (children.length === 0) return;
+      for (let i = 0; i < items.length; i++) {
+        const row = items[i];
+        const rowId = ids[i];
+        if (!rowId) continue;
+        for (const childPath of children) {
+          const suffix = suffixByPath.get(childPath) ?? "";
+          const childValue = suffix ? getAtPath(row, suffix) : void 0;
+          visit(childPath, rowId, childValue);
+        }
+      }
+    };
+    for (const root of roots) {
+      const value = getAtPath(state, root);
+      visit(root, void 0, value);
+    }
+  }
+};
+var collectListConfigs = (spec) => {
+  const configs = [];
+  for (const key in spec) {
+    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue;
+    const raw = spec[key];
+    if (!raw || typeof raw !== "object") continue;
+    const tag = raw._tag;
+    if (tag !== "StateTraitList") continue;
+    const trackBy = raw.identityHint?.trackBy;
+    configs.push({
+      path: key,
+      trackBy: typeof trackBy === "string" ? trackBy : void 0
+    });
+  }
+  return configs;
+};
+
+// ../logix-core/src/internal/runtime/core/ReplayLog.ts
+import { Context, Effect, Layer } from "../effect.js";
+var ReplayLog = class extends Context.Tag("@logix/core/ReplayLog")() {
+};
+var snapshot = Effect.gen(function* () {
+  const log = yield* ReplayLog;
+  return yield* log.snapshot;
+});
+var resetCursor = Effect.gen(
+  function* () {
+    const log = yield* ReplayLog;
+    yield* log.resetCursor;
+  }
+);
+
+export {
+  ReplayLog,
+  getAtPath,
+  setAtPathMutating,
+  unsetAtPathMutating,
+  parseListItemFieldPath,
+  toListItemValuePath,
+  RowIdStore,
+  collectListConfigs
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/rowid.ts", "../../../../logix-core/src/internal/runtime/core/ReplayLog.ts"],
  "sourcesContent": ["export type RowId = string\n\nexport interface ListConfig {\n  readonly path: string\n  readonly trackBy?: string\n}\n\nexport type ListRemovalListener = (rowId: RowId) => void\n\ntype Segment = string | number\n\nconst parseSegments = (path: string): ReadonlyArray<Segment> => {\n  if (!path) return []\n  return path.split(\".\").map((seg) =>\n    /^[0-9]+$/.test(seg) ? Number(seg) : seg,\n  )\n}\n\nexport const getAtPath = (state: any, path: string): any => {\n  if (!path || state == null) return state\n  const segments = parseSegments(path)\n  let current: any = state\n  for (const seg of segments) {\n    if (current == null) return undefined\n    if (typeof seg === \"number\") {\n      current = Array.isArray(current) ? current[seg] : current[String(seg)]\n      continue\n    }\n    current = current[seg]\n  }\n  return current\n}\n\nexport const setAtPathMutating = (draft: any, path: string, value: any): void => {\n  if (!path) return\n  const segments = parseSegments(path)\n  if (segments.length === 0) return\n\n  let current: any = draft\n  for (let i = 0; i < segments.length - 1; i++) {\n    const key = segments[i]!\n    const nextKey = segments[i + 1]!\n\n    const next = current?.[key as any]\n    if (next == null || typeof next !== \"object\") {\n      current[key as any] = typeof nextKey === \"number\" ? [] : {}\n    }\n    current = current[key as any]\n  }\n\n  const last = segments[segments.length - 1]!\n  current[last as any] = value\n}\n\nexport const unsetAtPathMutating = (draft: any, path: string): void => {\n  if (!path) return\n  const segments = parseSegments(path)\n  if (segments.length === 0) return\n\n  let current: any = draft\n  for (let i = 0; i < segments.length - 1; i++) {\n    const key = segments[i]!\n    const next = current?.[key as any]\n    if (next == null || typeof next !== \"object\") {\n      return\n    }\n    current = next\n  }\n\n  const last = segments[segments.length - 1]!\n  if (Array.isArray(current) && typeof last === \"number\") {\n    current[last] = undefined\n    return\n  }\n\n  if (current && typeof current === \"object\") {\n    delete current[last as any]\n  }\n}\n\nexport const joinPath = (prefix: string, suffix: string): string => {\n  if (!prefix) return suffix\n  if (!suffix) return prefix\n  return `${prefix}.${suffix}`\n}\n\nexport interface ListItemFieldPath {\n  readonly listPath: string\n  readonly itemPath: string\n}\n\n/**\n * parseListItemFieldPath\uFF1A\n * - \u8BC6\u522B\u5F62\u5982 \"items[].profileResource\" \u7684 list.item \u5B57\u6BB5\u8DEF\u5F84\uFF1B\n * - \u652F\u6301\u591A\u5C42\u5D4C\u5957\u6570\u7EC4\uFF1A\u8FD4\u56DE\u201C\u6700\u5185\u5C42 list\u201D\u7684 listPath \u4E0E\u5176 itemPath\u3002\n */\nexport const parseListItemFieldPath = (fieldPath: string): ListItemFieldPath | undefined => {\n  const raw = typeof fieldPath === \"string\" ? fieldPath.trim() : \"\"\n  if (!raw) return undefined\n\n  const segments = raw.split(\".\").filter(Boolean)\n  let lastListSeg = -1\n  for (let i = 0; i < segments.length; i++) {\n    if (segments[i]!.endsWith(\"[]\")) lastListSeg = i\n  }\n  if (lastListSeg < 0) return undefined\n\n  const strip = (seg: string): string => (seg.endsWith(\"[]\") ? seg.slice(0, -2) : seg)\n\n  const listPath = segments\n    .slice(0, lastListSeg + 1)\n    .map(strip)\n    .join(\".\")\n\n  const itemPath = segments\n    .slice(lastListSeg + 1)\n    .map(strip)\n    .join(\".\")\n\n  return { listPath, itemPath }\n}\n\nexport const toListItemValuePath = (\n  listPath: string,\n  index: number,\n  itemPath: string,\n): string =>\n  itemPath ? `${listPath}.${index}.${itemPath}` : `${listPath}.${index}`\n\ntype ListState = {\n  readonly listPath: string\n  readonly parentRowId?: RowId\n  readonly itemsRef: ReadonlyArray<unknown>\n  readonly ids: ReadonlyArray<RowId>\n  readonly indexById: ReadonlyMap<RowId, number>\n  readonly trackBy?: string\n}\n\nconst readTrackBy = (item: unknown, trackBy: string): unknown => {\n  if (!item || typeof item !== \"object\") return undefined\n  const segments = trackBy.split(\".\")\n  let current: any = item\n  for (const seg of segments) {\n    if (current == null) return undefined\n    current = current[seg as any]\n  }\n  return current\n}\n\nconst didReorderByReference = (\n  prevItems: ReadonlyArray<unknown>,\n  nextItems: ReadonlyArray<unknown>,\n): boolean => {\n  const buckets = new Map<unknown, Array<number>>()\n  for (let i = 0; i < prevItems.length; i++) {\n    const item = prevItems[i]\n    const list = buckets.get(item) ?? []\n    list.push(i)\n    buckets.set(item, list)\n  }\n\n  for (let nextIndex = 0; nextIndex < nextItems.length; nextIndex++) {\n    const item = nextItems[nextIndex]\n    const q = buckets.get(item)\n    if (!q || q.length === 0) continue\n    const prevIndex = q.shift()!\n    if (prevIndex !== nextIndex) {\n      return true\n    }\n  }\n\n  return false\n}\n\nconst hasStableTrackByKeys = (\n  items: ReadonlyArray<unknown>,\n  trackBy: string,\n): boolean => items.every((item) => readTrackBy(item, trackBy) !== undefined)\n\nconst isSameTrackBySequence = (\n  prevItems: ReadonlyArray<unknown>,\n  nextItems: ReadonlyArray<unknown>,\n  trackBy: string,\n): boolean => {\n  if (prevItems.length !== nextItems.length) return false\n  for (let i = 0; i < prevItems.length; i++) {\n    if (\n      !Object.is(\n        readTrackBy(prevItems[i], trackBy),\n        readTrackBy(nextItems[i], trackBy),\n      )\n    ) {\n      return false\n    }\n  }\n  return true\n}\n\nconst reconcileIds = (\n  prev: ListState | undefined,\n  nextItems: ReadonlyArray<unknown>,\n  trackBy?: string,\n  makeRowId?: () => RowId,\n): { readonly ids: ReadonlyArray<RowId>; readonly removed: ReadonlyArray<RowId> } => {\n  const nextRowId =\n    makeRowId ??\n    (() => {\n      let rowSeq = 0\n      return () => {\n        rowSeq += 1\n        return `r${rowSeq}`\n      }\n    })()\n\n  if (!prev) {\n    return {\n      ids: nextItems.map(() => nextRowId()),\n      removed: [],\n    }\n  }\n\n  if (prev.itemsRef === nextItems) {\n    return {\n      ids: prev.ids,\n      removed: [],\n    }\n  }\n\n  // \u91CD\u8981\uFF1A\u4FDD\u6301 RowId \u5728\u201C\u975E\u7ED3\u6784\u53D8\u66F4\u201D\uFF08\u4EC5\u5B57\u6BB5\u66F4\u65B0/\u5BF9\u8C61\u514B\u9686\uFF09\u4E0B\u7684\u7A33\u5B9A\u6027\uFF0C\n  // \u5426\u5219 in-flight / \u7F13\u5B58 \u4F1A\u88AB\u65E0\u610F\u4E49\u5730\u5931\u6548\u3002\n  const sameLength = prev.itemsRef.length === nextItems.length\n  if (sameLength) {\n    // trackBy \u573A\u666F\uFF1A\u82E5 key \u5E8F\u5217\u4E00\u81F4\uFF0C\u5219\u53EF\u76F4\u63A5\u590D\u7528\u65E7 ids\uFF1B\n    // \u5426\u5219\u5FC5\u987B\u8D70 key-based reconcile\uFF08\u907F\u514D clone + reorder \u65F6\u8BEF\u5224\u4E3A\u201C\u672A\u91CD\u6392\u201D\uFF09\u3002\n    if (trackBy) {\n      const canUseKeys =\n        hasStableTrackByKeys(prev.itemsRef, trackBy) &&\n        hasStableTrackByKeys(nextItems, trackBy)\n      if (canUseKeys) {\n        if (isSameTrackBySequence(prev.itemsRef, nextItems, trackBy)) {\n          return {\n            ids: prev.ids,\n            removed: [],\n          }\n        }\n      } else {\n        // trackBy key \u4E0D\u53EF\u7528\u65F6\u9000\u56DE\u5230\u5F15\u7528\u7EA7\u4FA6\u6D4B\uFF08\u5C3D\u91CF\u4FDD\u6301\u201C\u514B\u9686\u4F46\u4E0D\u91CD\u6392\u201D\u7684\u7A33\u5B9A\u6027\uFF09\u3002\n        if (!didReorderByReference(prev.itemsRef, nextItems)) {\n          return {\n            ids: prev.ids,\n            removed: [],\n          }\n        }\n      }\n    } else if (!didReorderByReference(prev.itemsRef, nextItems)) {\n      return {\n        ids: prev.ids,\n        removed: [],\n      }\n    }\n  }\n\n  const keyOf = (item: unknown): unknown => {\n    if (!trackBy) return item\n    const k = readTrackBy(item, trackBy)\n    return k !== undefined ? k : item\n  }\n\n  const buckets = new Map<unknown, Array<RowId>>()\n  for (let i = 0; i < prev.itemsRef.length; i++) {\n    const key = keyOf(prev.itemsRef[i])\n    const list = buckets.get(key) ?? []\n    list.push(prev.ids[i]!)\n    buckets.set(key, list)\n  }\n\n  const ids: Array<RowId> = []\n  for (let i = 0; i < nextItems.length; i++) {\n    const key = keyOf(nextItems[i])\n    const list = buckets.get(key)\n    if (list && list.length > 0) {\n      ids.push(list.shift()!)\n    } else {\n      ids.push(nextRowId())\n    }\n  }\n\n  const removed: Array<RowId> = []\n  for (const list of buckets.values()) {\n    removed.push(...list)\n  }\n\n  return { ids, removed }\n}\n\nconst buildIndexById = (ids: ReadonlyArray<RowId>): ReadonlyMap<RowId, number> => {\n  const map = new Map<RowId, number>()\n  for (let i = 0; i < ids.length; i++) {\n    map.set(ids[i]!, i)\n  }\n  return map\n}\n\nexport class RowIdStore {\n  private readonly lists = new Map<string, ListState>()\n  private readonly removalListeners = new Map<string, Set<ListRemovalListener>>()\n  private readonly rowIdIndex = new Map<RowId, { readonly key: string; readonly listPath: string; readonly index: number }>()\n  private nextRowSeq = 0\n\n  constructor(\n    private readonly instanceId?: string,\n  ) {}\n\n  private listKey = (listPath: string, parentRowId?: RowId): string =>\n    parentRowId ? `${listPath}@@${parentRowId}` : listPath\n\n  private makeRowId = (): RowId => {\n    this.nextRowSeq += 1\n    return this.instanceId ? `${this.instanceId}::r${this.nextRowSeq}` : `r${this.nextRowSeq}`\n  }\n\n  private notifyRemoved(listPath: string, rowId: RowId): void {\n    const listeners = this.removalListeners.get(listPath)\n    if (!listeners || listeners.size === 0) return\n    for (const fn of listeners) {\n      try {\n        fn(rowId)\n      } catch {\n        // listener failures should never break runtime behavior\n      }\n    }\n  }\n\n  private removeDescendants(parentRowId: RowId): void {\n    const keys: Array<string> = []\n    for (const [k, st] of this.lists.entries()) {\n      if (st.parentRowId === parentRowId) keys.push(k)\n    }\n\n    for (const key of keys) {\n      const st = this.lists.get(key)\n      if (!st) continue\n      this.lists.delete(key)\n      for (let i = 0; i < st.ids.length; i++) {\n        const rowId = st.ids[i]!\n        this.rowIdIndex.delete(rowId)\n        this.notifyRemoved(st.listPath, rowId)\n        this.removeDescendants(rowId)\n      }\n    }\n  }\n\n  onRemoved(listPath: string, listener: ListRemovalListener): () => void {\n    const set = this.removalListeners.get(listPath) ?? new Set<ListRemovalListener>()\n    set.add(listener)\n    this.removalListeners.set(listPath, set)\n    return () => {\n      const current = this.removalListeners.get(listPath)\n      if (!current) return\n      current.delete(listener)\n      if (current.size === 0) this.removalListeners.delete(listPath)\n    }\n  }\n\n  getRowId(listPath: string, index: number, parentRowId?: RowId): RowId | undefined {\n    const state = this.lists.get(this.listKey(listPath, parentRowId))\n    return state ? state.ids[index] : undefined\n  }\n\n  getIndex(listPath: string, rowId: RowId): number | undefined {\n    const info = this.rowIdIndex.get(rowId)\n    if (!info) return undefined\n    if (info.listPath !== listPath) return undefined\n    return info.index\n  }\n\n  /**\n   * ensureList\uFF1A\n   * - \u8BA9\u6307\u5B9A listPath \u7684 RowID \u6620\u5C04\u4E0E\u5F53\u524D items \u5BF9\u9F50\uFF1B\n   * - \u8FD4\u56DE\u6700\u65B0\u7684 ids\uFF08index -> RowId\uFF09\u3002\n   */\n  ensureList(\n    listPath: string,\n    items: ReadonlyArray<unknown>,\n    trackBy?: string,\n    parentRowId?: RowId,\n  ): ReadonlyArray<RowId> {\n    const key = this.listKey(listPath, parentRowId)\n    const prev = this.lists.get(key)\n    const { ids, removed } = reconcileIds(prev, items, trackBy ?? prev?.trackBy, this.makeRowId)\n\n    const next: ListState = {\n      listPath,\n      parentRowId,\n      itemsRef: items,\n      ids,\n      indexById: buildIndexById(ids),\n      trackBy: trackBy ?? prev?.trackBy,\n    }\n    this.lists.set(key, next)\n\n    if (removed.length > 0) {\n      for (const rowId of removed) {\n        this.rowIdIndex.delete(rowId)\n        this.notifyRemoved(listPath, rowId)\n        this.removeDescendants(rowId)\n      }\n    }\n\n    // \u5237\u65B0 rowId \u2192 index \u7684\u53CD\u5411\u6620\u5C04\uFF08\u5141\u8BB8 index \u53D8\u5316\uFF09\u3002\n    for (let i = 0; i < ids.length; i++) {\n      const rowId = ids[i]!\n      this.rowIdIndex.set(rowId, { key, listPath, index: i })\n    }\n\n    return ids\n  }\n\n  /**\n   * updateAll\uFF1A\n   * - \u5728\u6BCF\u6B21\u63D0\u4EA4\u540E\u5BF9\u9F50\u6240\u6709\u5DF2\u77E5 list \u7684 RowID \u6620\u5C04\uFF1B\n   * - configs \u6765\u81EA StateTraitProgram.spec \u4E2D\u7684 list \u58F0\u660E\uFF08\u53EF\u643A\u5E26 trackBy\uFF09\u3002\n   */\n  updateAll(state: unknown, configs: ReadonlyArray<ListConfig>): void {\n    const cfgByPath = new Map<string, ListConfig>()\n    const paths: Array<string> = []\n    for (const cfg of configs) {\n      if (!cfg || typeof cfg.path !== \"string\") continue\n      const p = cfg.path.trim()\n      if (!p) continue\n      cfgByPath.set(p, cfg)\n      paths.push(p)\n    }\n\n    const pathSet = new Set(paths)\n\n    const parentOf = (path: string): string | undefined => {\n      const segments = path.split(\".\").filter(Boolean)\n      let best: string | undefined\n      for (let i = 1; i < segments.length; i++) {\n        const prefix = segments.slice(0, i).join(\".\")\n        if (pathSet.has(prefix)) best = prefix\n      }\n      return best\n    }\n\n    const parentByPath = new Map<string, string | undefined>()\n    const suffixByPath = new Map<string, string>()\n    const childrenByParent = new Map<string | undefined, Array<string>>()\n\n    for (const path of paths) {\n      const parent = parentOf(path)\n      parentByPath.set(path, parent)\n      const suffix = parent ? path.slice(parent.length + 1) : path\n      suffixByPath.set(path, suffix)\n      const list = childrenByParent.get(parent) ?? []\n      list.push(path)\n      childrenByParent.set(parent, list)\n    }\n\n    // roots first (and deterministic traversal)\n    const roots = (childrenByParent.get(undefined) ?? []).slice().sort((a, b) => a.localeCompare(b))\n\n    const visit = (listPath: string, parentRowId: RowId | undefined, listValue: unknown): void => {\n      const cfg = cfgByPath.get(listPath)\n      const items = Array.isArray(listValue) ? (listValue as ReadonlyArray<unknown>) : []\n      const ids = this.ensureList(listPath, items, cfg?.trackBy, parentRowId)\n\n      const children = (childrenByParent.get(listPath) ?? []).slice().sort((a, b) => a.localeCompare(b))\n      if (children.length === 0) return\n\n      for (let i = 0; i < items.length; i++) {\n        const row = items[i]\n        const rowId = ids[i]\n        if (!rowId) continue\n        for (const childPath of children) {\n          const suffix = suffixByPath.get(childPath) ?? \"\"\n          const childValue = suffix ? getAtPath(row as any, suffix) : undefined\n          visit(childPath, rowId, childValue)\n        }\n      }\n    }\n\n    for (const root of roots) {\n      const value = getAtPath(state as any, root)\n      visit(root, undefined, value)\n    }\n  }\n}\n\nexport const collectListConfigs = (spec: Record<string, unknown>): ReadonlyArray<ListConfig> => {\n  const configs: Array<ListConfig> = []\n  for (const key in spec) {\n    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue\n    const raw = spec[key]\n    if (!raw || typeof raw !== \"object\") continue\n    const tag = (raw as any)._tag\n    if (tag !== \"StateTraitList\") continue\n    const trackBy = (raw as any).identityHint?.trackBy\n    configs.push({\n      path: key,\n      trackBy: typeof trackBy === \"string\" ? trackBy : undefined,\n    })\n  }\n  return configs\n}\n", "import { Context, Effect, Layer } from \"effect\"\n\nexport type ResourceSnapshotPhase = \"idle\" | \"loading\" | \"success\" | \"error\"\n\nexport type ReplayLogEvent =\n  | {\n      readonly _tag: \"ResourceSnapshot\"\n      readonly resourceId: string\n      readonly fieldPath: string\n      readonly keyHash?: string\n      readonly phase: ResourceSnapshotPhase\n      readonly snapshot: unknown\n      readonly timestamp: number\n      readonly moduleId?: string\n      readonly instanceId?: string\n    }\n  | {\n      readonly _tag: \"InvalidateRequest\"\n      readonly timestamp: number\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly kind: \"resource\" | \"query\"\n      readonly target: string\n      readonly meta?: unknown\n    }\n\nexport type ResourceSnapshotEvent = Extract<ReplayLogEvent, { readonly _tag: \"ResourceSnapshot\" }>\n\nexport interface ReplayLogService {\n  readonly record: (event: ReplayLogEvent) => Effect.Effect<void>\n  readonly snapshot: Effect.Effect<ReadonlyArray<ReplayLogEvent>>\n  readonly resetCursor: Effect.Effect<void>\n  readonly consumeNext: (\n    predicate: (event: ReplayLogEvent) => boolean,\n  ) => Effect.Effect<ReplayLogEvent | undefined>\n  readonly consumeNextResourceSnapshot: (params: {\n    readonly resourceId: string\n    readonly fieldPath: string\n    readonly keyHash?: string\n    readonly phase?: ResourceSnapshotPhase\n  }) => Effect.Effect<ResourceSnapshotEvent | undefined>\n}\n\nexport class ReplayLog extends Context.Tag(\"@logix/core/ReplayLog\")<\n  ReplayLog,\n  ReplayLogService\n>() {}\n\nexport const make = (\n  initial?: ReadonlyArray<ReplayLogEvent>,\n): ReplayLogService => {\n  const events: Array<ReplayLogEvent> = initial ? Array.from(initial) : []\n  let cursor = 0\n\n  const consumeNext = (\n    predicate: (event: ReplayLogEvent) => boolean,\n  ): Effect.Effect<ReplayLogEvent | undefined> =>\n    Effect.sync(() => {\n      for (let i = cursor; i < events.length; i++) {\n        const event = events[i]\n        if (!predicate(event)) continue\n        cursor = i + 1\n        return event\n      }\n      return undefined\n    })\n\n  const consumeNextResourceSnapshot = (params: {\n    readonly resourceId: string\n    readonly fieldPath: string\n    readonly keyHash?: string\n    readonly phase?: ResourceSnapshotPhase\n  }): Effect.Effect<ResourceSnapshotEvent | undefined> =>\n    consumeNext((event): event is ResourceSnapshotEvent => {\n      if (event._tag !== \"ResourceSnapshot\") return false\n      if (event.resourceId !== params.resourceId) return false\n      if (event.fieldPath !== params.fieldPath) return false\n      if (params.keyHash !== undefined && event.keyHash !== params.keyHash) {\n        return false\n      }\n      if (params.phase !== undefined && event.phase !== params.phase) {\n        return false\n      }\n      return true\n    }).pipe(Effect.map((event) => event as ResourceSnapshotEvent | undefined))\n\n  return {\n    record: (event) => Effect.sync(() => events.push(event)),\n    snapshot: Effect.sync(() => events.slice()),\n    resetCursor: Effect.sync(() => {\n      cursor = 0\n    }),\n    consumeNext,\n    consumeNextResourceSnapshot,\n  }\n}\n\nexport const layer = (\n  initial?: ReadonlyArray<ReplayLogEvent>,\n): Layer.Layer<ReplayLog, never, never> =>\n  Layer.succeed(ReplayLog, make(initial))\n\nexport const record = (\n  event: ReplayLogEvent,\n): Effect.Effect<void, never, ReplayLog> =>\n  Effect.gen(function* () {\n    const log = yield* ReplayLog\n    yield* log.record(event)\n  })\n\nexport const snapshot: Effect.Effect<\n  ReadonlyArray<ReplayLogEvent>,\n  never,\n  ReplayLog\n> = Effect.gen(function* () {\n  const log = yield* ReplayLog\n  return yield* log.snapshot\n})\n\nexport const resetCursor: Effect.Effect<void, never, ReplayLog> = Effect.gen(\n  function* () {\n    const log = yield* ReplayLog\n    yield* log.resetCursor\n  },\n)\n\nexport const consumeNextResourceSnapshot = (params: {\n  readonly resourceId: string\n  readonly fieldPath: string\n  readonly keyHash?: string\n  readonly phase?: ResourceSnapshotPhase\n}): Effect.Effect<ResourceSnapshotEvent | undefined, never, ReplayLog> =>\n  Effect.gen(function* () {\n    const log = yield* ReplayLog\n    return yield* log.consumeNextResourceSnapshot(params)\n  })\n"],
  "mappings": "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",
  "names": []
}
