@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-5XOBKSOT.js

@@ -0,0 +1,213 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/field-path.ts
+var isFieldPathSegment = (seg) => {
+  if (!seg) return false;
+  if (seg === "*") return false;
+  if (/^\d+$/.test(seg)) return false;
+  if (seg.includes("[") || seg.includes("]")) return false;
+  return true;
+};
+var normalizeFieldPath = (input) => {
+  const segs = typeof input === "string" ? splitSegments(input) : input.slice();
+  if (!segs || segs.length === 0) return void 0;
+  const normalized = segs.filter(isFieldPathSegment);
+  return normalized.length > 0 ? normalized : void 0;
+};
+var compareFieldPath = (a, b) => {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const as = a[i];
+    const bs = b[i];
+    if (as === bs) continue;
+    return as < bs ? -1 : 1;
+  }
+  return a.length - b.length;
+};
+var isPrefixOf = (prefix, full) => {
+  if (prefix.length > full.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (prefix[i] !== full[i]) return false;
+  }
+  return true;
+};
+var toPathString = (path) => path.join(".");
+var canonicalizeRootsFast = (roots) => {
+  const sorted = Array.from(roots).sort(compareFieldPath);
+  const out = [];
+  for (const next of sorted) {
+    const prev = out[out.length - 1];
+    if (prev && isPrefixOf(prev, next)) continue;
+    out.push(next);
+  }
+  return out;
+};
+var makeFieldPathIdRegistry = (fieldPaths) => {
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (let id = 0; id < fieldPaths.length; id++) {
+    const path = fieldPaths[id];
+    let node = root;
+    for (const seg of path) {
+      const children = node.children;
+      let next = children.get(seg);
+      if (!next) {
+        next = { children: /* @__PURE__ */ new Map() };
+        children.set(seg, next);
+      }
+      node = next;
+    }
+    node.id = id;
+  }
+  return { fieldPaths, root };
+};
+var getFieldPathId = (registry, path) => {
+  let node = registry.root;
+  for (const seg of path) {
+    const next = node.children.get(seg);
+    if (!next) return void 0;
+    node = next;
+  }
+  return node.id;
+};
+var hashFieldPathIds = (ids) => {
+  let hash = 2166136261 >>> 0;
+  for (const id of ids) {
+    hash ^= id >>> 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var dirtyPathsToDirtySet = (dirtyPaths) => {
+  let sawStar = false;
+  let hasInvalid = false;
+  const roots = [];
+  for (const raw of dirtyPaths ?? []) {
+    if (raw === "*") {
+      sawStar = true;
+      continue;
+    }
+    const normalized = normalizeFieldPath(raw);
+    if (!normalized) {
+      hasInvalid = true;
+      continue;
+    }
+    roots.push(normalized);
+  }
+  if (hasInvalid) {
+    return { dirtyAll: true, reason: "nonTrackablePatch" };
+  }
+  const canonical = canonicalizeRootsFast(roots).map(toPathString);
+  if (canonical.length === 0) {
+    return { dirtyAll: true, reason: sawStar ? "unknownWrite" : "unknownWrite" };
+  }
+  return { dirtyAll: false, paths: canonical };
+};
+var dirtyPathsToRootIds = (options) => {
+  let sawStar = false;
+  let hasInvalid = false;
+  const roots = [];
+  for (const raw of options.dirtyPaths ?? []) {
+    if (raw === "*") {
+      sawStar = true;
+      continue;
+    }
+    const normalized = normalizeFieldPath(raw);
+    if (!normalized) {
+      hasInvalid = true;
+      continue;
+    }
+    roots.push(normalized);
+  }
+  const canonical = canonicalizeRootsFast(roots);
+  const rootIds = [];
+  let missing = false;
+  for (const root of canonical) {
+    const id = getFieldPathId(options.registry, root);
+    if (id == null) {
+      missing = true;
+      continue;
+    }
+    rootIds.push(id);
+  }
+  const hasSpecific = rootIds.length > 0;
+  if (hasInvalid) {
+    return {
+      dirtyAll: true,
+      reason: "nonTrackablePatch",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  rootIds.sort((a, b) => a - b);
+  if (missing) {
+    return {
+      dirtyAll: true,
+      reason: "fallbackPolicy",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  if (!hasSpecific && sawStar) {
+    return {
+      dirtyAll: true,
+      reason: "unknownWrite",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  const keyHash = hashFieldPathIds(rootIds);
+  return {
+    dirtyAll: false,
+    rootIds,
+    rootCount: rootIds.length,
+    keySize: rootIds.length,
+    keyHash
+  };
+};
+var splitSegments = (path) => {
+  if (!path) return void 0;
+  if (path === "*") return void 0;
+  const parts = path.split(".").filter((p) => p.length > 0);
+  const segs = [];
+  for (const part of parts) {
+    if (!part) continue;
+    if (part === "*") {
+      return void 0;
+    }
+    if (part.endsWith("[]")) {
+      const base = part.slice(0, -2);
+      if (base) segs.push(base);
+      continue;
+    }
+    const bracket = /^(.+)\[(\d+)\]$/.exec(part);
+    if (bracket) {
+      segs.push(bracket[1]);
+      continue;
+    }
+    if (/^\d+$/.test(part)) {
+      continue;
+    }
+    if (part.includes("[") || part.includes("]")) {
+      return void 0;
+    }
+    segs.push(part);
+  }
+  return segs;
+};
+
+export {
+  normalizeFieldPath,
+  compareFieldPath,
+  makeFieldPathIdRegistry,
+  getFieldPathId,
+  dirtyPathsToDirtySet,
+  dirtyPathsToRootIds
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/field-path.ts"],
  "sourcesContent": ["export type FieldPath = ReadonlyArray<string>\nexport type FieldPathId = number\n\nexport type DirtyAllReason =\n  | \"unknownWrite\"\n  | \"customMutation\"\n  | \"nonTrackablePatch\"\n  | \"fallbackPolicy\"\n\nexport type DirtySet =\n  | {\n      readonly dirtyAll: true\n      readonly reason: DirtyAllReason\n    }\n  | {\n      readonly dirtyAll: false\n      readonly paths: ReadonlyArray<string>\n    }\n\ninterface FieldPathTrieNode {\n  id?: FieldPathId\n  children: Map<string, FieldPathTrieNode>\n}\n\nexport interface FieldPathIdRegistry {\n  readonly fieldPaths: ReadonlyArray<FieldPath>\n  readonly root: FieldPathTrieNode\n}\n\nexport const isFieldPathSegment = (seg: string): boolean => {\n  if (!seg) return false\n  if (seg === \"*\") return false\n  if (/^\\d+$/.test(seg)) return false\n  if (seg.includes(\"[\") || seg.includes(\"]\")) return false\n  return true\n}\n\nexport const normalizeFieldPath = (input: string | FieldPath): FieldPath | undefined => {\n  const segs = typeof input === \"string\"\n    ? splitSegments(input)\n    : input.slice()\n\n  if (!segs || segs.length === 0) return undefined\n  const normalized = segs.filter(isFieldPathSegment)\n  return normalized.length > 0 ? normalized : undefined\n}\n\nexport const compareFieldPath = (a: FieldPath, b: FieldPath): number => {\n  const len = Math.min(a.length, b.length)\n  for (let i = 0; i < len; i++) {\n    const as = a[i]!\n    const bs = b[i]!\n    if (as === bs) continue\n    return as < bs ? -1 : 1\n  }\n  return a.length - b.length\n}\n\nexport const isPrefixOf = (prefix: FieldPath, full: FieldPath): boolean => {\n  if (prefix.length > full.length) return false\n  for (let i = 0; i < prefix.length; i++) {\n    if (prefix[i] !== full[i]) return false\n  }\n  return true\n}\n\nexport const toKey = (path: FieldPath): string => JSON.stringify(path)\n\nexport const toPathString = (path: FieldPath): string => path.join(\".\")\n\nexport const canonicalizeRoots = (\n  roots: Iterable<FieldPath>,\n): ReadonlyArray<FieldPath> => {\n  const byKey = new Map<string, FieldPath>()\n  for (const root of roots) {\n    const key = toKey(root)\n    if (!byKey.has(key)) byKey.set(key, root)\n  }\n\n  const sorted = Array.from(byKey.values()).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) {\n      continue\n    }\n    out.push(next)\n  }\n  return out\n}\n\nexport const canonicalizeRootsFast = (\n  roots: Iterable<FieldPath>,\n): ReadonlyArray<FieldPath> => {\n  const sorted = Array.from(roots).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) continue\n    out.push(next)\n  }\n  return out\n}\n\nexport const makeFieldPathIdRegistry = (\n  fieldPaths: ReadonlyArray<FieldPath>,\n): FieldPathIdRegistry => {\n  const root: FieldPathTrieNode = { children: new Map() }\n\n  for (let id = 0; id < fieldPaths.length; id++) {\n    const path = fieldPaths[id]!\n    let node = root\n    for (const seg of path) {\n      const children = node.children\n      let next = children.get(seg)\n      if (!next) {\n        next = { children: new Map() }\n        children.set(seg, next)\n      }\n      node = next\n    }\n    node.id = id\n  }\n\n  return { fieldPaths, root }\n}\n\nexport const getFieldPathId = (\n  registry: FieldPathIdRegistry,\n  path: FieldPath,\n): FieldPathId | undefined => {\n  let node = registry.root\n  for (const seg of path) {\n    const next = node.children.get(seg)\n    if (!next) return undefined\n    node = next\n  }\n  return node.id\n}\n\nexport const getFieldPathIdFromString = (\n  registry: FieldPathIdRegistry,\n  path: string,\n): FieldPathId | undefined => {\n  if (!path || path === \"*\") return undefined\n  const normalized = normalizeFieldPath(path)\n  if (!normalized) return undefined\n  return getFieldPathId(registry, normalized)\n}\n\nexport const hashFieldPathIds = (ids: ReadonlyArray<number>): number => {\n  // FNV-1a (32-bit)\n  let hash = 2166136261 >>> 0\n  for (const id of ids) {\n    hash ^= (id >>> 0)\n    hash = Math.imul(hash, 16777619)\n  }\n  return hash >>> 0\n}\n\nexport interface DirtyRootIds {\n  readonly dirtyAll: boolean\n  readonly reason?: DirtyAllReason\n  readonly rootIds: ReadonlyArray<FieldPathId>\n  readonly rootCount: number\n  readonly keySize: number\n  readonly keyHash: number\n}\n\nexport const dirtyPathsToDirtySet = (dirtyPaths?: Iterable<string>): DirtySet => {\n  let sawStar = false\n  let hasInvalid = false\n\n  const roots: Array<FieldPath> = []\n  for (const raw of dirtyPaths ?? []) {\n    if (raw === \"*\") {\n      sawStar = true\n      continue\n    }\n    const normalized = normalizeFieldPath(raw)\n    if (!normalized) {\n      hasInvalid = true\n      continue\n    }\n    roots.push(normalized)\n  }\n\n  if (hasInvalid) {\n    return { dirtyAll: true, reason: \"nonTrackablePatch\" }\n  }\n\n  const canonical = canonicalizeRootsFast(roots).map(toPathString)\n\n  if (canonical.length === 0) {\n    return { dirtyAll: true, reason: sawStar ? \"unknownWrite\" : \"unknownWrite\" }\n  }\n\n  return { dirtyAll: false, paths: canonical }\n}\n\nexport const dirtyPathsToRootIds = (options: {\n  readonly dirtyPaths?: Iterable<string>\n  readonly registry: FieldPathIdRegistry\n}): DirtyRootIds => {\n  let sawStar = false\n  let hasInvalid = false\n\n  const roots: Array<FieldPath> = []\n  for (const raw of options.dirtyPaths ?? []) {\n    if (raw === \"*\") {\n      sawStar = true\n      continue\n    }\n    const normalized = normalizeFieldPath(raw)\n    if (!normalized) {\n      hasInvalid = true\n      continue\n    }\n    roots.push(normalized)\n  }\n\n  const canonical = canonicalizeRootsFast(roots)\n  const rootIds: Array<number> = []\n  let missing = false\n  for (const root of canonical) {\n    const id = getFieldPathId(options.registry, root)\n    if (id == null) {\n      missing = true\n      continue\n    }\n    rootIds.push(id)\n  }\n\n  const hasSpecific = rootIds.length > 0\n  if (hasInvalid) {\n    return {\n      dirtyAll: true,\n      reason: \"nonTrackablePatch\",\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  rootIds.sort((a, b) => a - b)\n\n  if (missing) {\n    return {\n      dirtyAll: true,\n      reason: \"fallbackPolicy\",\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  if (!hasSpecific && sawStar) {\n    return {\n      dirtyAll: true,\n      reason: \"unknownWrite\",\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  const keyHash = hashFieldPathIds(rootIds)\n  return {\n    dirtyAll: false,\n    rootIds,\n    rootCount: rootIds.length,\n    keySize: rootIds.length,\n    keyHash,\n  }\n}\n\nconst splitSegments = (path: string): Array<string> | undefined => {\n  if (!path) return undefined\n  if (path === \"*\") return undefined\n\n  const parts = path.split(\".\").filter((p) => p.length > 0)\n  const segs: Array<string> = []\n\n  for (const part of parts) {\n    if (!part) continue\n    if (part === \"*\") {\n      return undefined\n    }\n    if (part.endsWith(\"[]\")) {\n      const base = part.slice(0, -2)\n      if (base) segs.push(base)\n      continue\n    }\n    const bracket = /^(.+)\\[(\\d+)\\]$/.exec(part)\n    if (bracket) {\n      segs.push(bracket[1]!)\n      continue\n    }\n    if (/^\\d+$/.test(part)) {\n      continue\n    }\n    if (part.includes(\"[\") || part.includes(\"]\")) {\n      return undefined\n    }\n    segs.push(part)\n  }\n\n  return segs\n}\n"],
  "mappings": "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",
  "names": []
}


package/public/sandbox/chunks/chunk-67RVISUC.js

@@ -0,0 +1,313 @@
+// @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 idx = fieldPath.indexOf("[]");
+  if (idx < 0) return void 0;
+  if (fieldPath.indexOf("[]", idx + 2) >= 0) return void 0;
+  const listPath = fieldPath.slice(0, idx);
+  const rest = fieldPath.slice(idx + 2);
+  const itemPath = rest.startsWith(".") ? rest.slice(1) : rest;
+  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.nextRowSeq = 0;
+    this.makeRowId = () => {
+      this.nextRowSeq += 1;
+      return this.instanceId ? `${this.instanceId}::r${this.nextRowSeq}` : `r${this.nextRowSeq}`;
+    };
+  }
+  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) {
+    const state = this.lists.get(listPath);
+    return state ? state.ids[index] : void 0;
+  }
+  getIndex(listPath, rowId) {
+    const state = this.lists.get(listPath);
+    if (!state) return void 0;
+    return state.indexById.get(rowId);
+  }
+  /**
+   * ensureList：
+   * - 让指定 listPath 的 RowID 映射与当前 items 对齐；
+   * - 返回最新的 ids（index -> RowId）。
+   */
+  ensureList(listPath, items, trackBy) {
+    const prev = this.lists.get(listPath);
+    const { ids, removed } = reconcileIds(prev, items, trackBy ?? prev?.trackBy, this.makeRowId);
+    const next = {
+      itemsRef: items,
+      ids,
+      indexById: buildIndexById(ids),
+      trackBy: trackBy ?? prev?.trackBy
+    };
+    this.lists.set(listPath, next);
+    if (removed.length > 0) {
+      const listeners = this.removalListeners.get(listPath);
+      if (listeners && listeners.size > 0) {
+        for (const rowId of removed) {
+          for (const fn of listeners) {
+            try {
+              fn(rowId);
+            } catch {
+            }
+          }
+        }
+      }
+    }
+    return ids;
+  }
+  /**
+   * updateAll：
+   * - 在每次提交后对齐所有已知 list 的 RowID 映射；
+   * - configs 来自 StateTraitProgram.spec 中的 list 声明（可携带 trackBy）。
+   */
+  updateAll(state, configs) {
+    for (const cfg of configs) {
+      const value = getAtPath(state, cfg.path);
+      const items = Array.isArray(value) ? value : [];
+      this.ensureList(cfg.path, items, cfg.trackBy);
+    }
+  }
+};
+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 * - \u4EC5\u652F\u6301\u5355\u5C42 \"[]\"\uFF0C\u591A\u5C42\u5D4C\u5957\u6570\u7EC4\u5728\u540E\u7EED\u9636\u6BB5\u518D\u589E\u5F3A\u3002\n */\nexport const parseListItemFieldPath = (fieldPath: string): ListItemFieldPath | undefined => {\n  const idx = fieldPath.indexOf(\"[]\")\n  if (idx < 0) return undefined\n  if (fieldPath.indexOf(\"[]\", idx + 2) >= 0) return undefined\n\n  const listPath = fieldPath.slice(0, idx)\n  const rest = fieldPath.slice(idx + 2)\n  const itemPath = rest.startsWith(\".\") ? rest.slice(1) : rest\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 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 nextRowSeq = 0\n\n  constructor(\n    private readonly instanceId?: string,\n  ) {}\n\n  private makeRowId = (): RowId => {\n    this.nextRowSeq += 1\n    return this.instanceId ? `${this.instanceId}::r${this.nextRowSeq}` : `r${this.nextRowSeq}`\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): RowId | undefined {\n    const state = this.lists.get(listPath)\n    return state ? state.ids[index] : undefined\n  }\n\n  getIndex(listPath: string, rowId: RowId): number | undefined {\n    const state = this.lists.get(listPath)\n    if (!state) return undefined\n    return state.indexById.get(rowId)\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  ): ReadonlyArray<RowId> {\n    const prev = this.lists.get(listPath)\n    const { ids, removed } = reconcileIds(prev, items, trackBy ?? prev?.trackBy, this.makeRowId)\n\n    const next: ListState = {\n      itemsRef: items,\n      ids,\n      indexById: buildIndexById(ids),\n      trackBy: trackBy ?? prev?.trackBy,\n    }\n    this.lists.set(listPath, next)\n\n    if (removed.length > 0) {\n      const listeners = this.removalListeners.get(listPath)\n      if (listeners && listeners.size > 0) {\n        for (const rowId of removed) {\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    }\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    for (const cfg of configs) {\n      const value = getAtPath(state as any, cfg.path)\n      const items = Array.isArray(value) ? (value as ReadonlyArray<unknown>) : []\n      this.ensureList(cfg.path, items, cfg.trackBy)\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": []
}


package/public/sandbox/chunks/chunk-6ELJEKZS.js

@@ -0,0 +1,12 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K