@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,1140 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  Snapshot,
+  internal,
+  keyHash
+} from "./chunk-LIYPPU6I.js";
+import {
+  ReplayLog,
+  getAtPath,
+  parseListItemFieldPath,
+  setAtPathMutating,
+  toListItemValuePath
+} from "./chunk-PHV4HYHB.js";
+import {
+  create
+} from "./chunk-Y5I45PEB.js";
+import {
+  forceSourceRefresh,
+  inSyncTransactionFiber
+} from "./chunk-LYBBX6WM.js";
+import {
+  getBoundInternals
+} from "./chunk-6FKWRVP4.js";
+import {
+  ReplayModeConfigTag,
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  record
+} from "./chunk-4KIYG5E4.js";
+import {
+  EffectOpMiddlewareTag,
+  RunSessionTag,
+  make,
+  run
+} from "./chunk-O57OZBDR.js";
+
+// ../logix-core/src/internal/state-trait/source.ts
+import { Effect, Fiber, FiberRef, Option } from "../effect.js";
+
+// ../logix-core/src/internal/state-trait/deps-trace.ts
+var isTraceableObject = (value) => {
+  if (!value || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  if (value instanceof Date) return false;
+  if (value instanceof RegExp) return false;
+  if (value instanceof Error) return false;
+  if (value instanceof Map) return false;
+  if (value instanceof Set) return false;
+  if (value instanceof WeakMap) return false;
+  if (value instanceof WeakSet) return false;
+  return true;
+};
+var shouldIgnoreKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+var normalizeReads = (reads) => {
+  const all = Array.from(reads).filter((p) => typeof p === "string" && p.length > 0);
+  all.sort();
+  const isPrefix = (prefix, full) => full !== prefix && full.startsWith(prefix + ".");
+  const pruned = [];
+  for (const p of all) {
+    let hasMoreSpecific = false;
+    for (const other of all) {
+      if (isPrefix(p, other)) {
+        hasMoreSpecific = true;
+        break;
+      }
+    }
+    if (!hasMoreSpecific) {
+      pruned.push(p);
+    }
+  }
+  pruned.sort();
+  return pruned;
+};
+var covers = (declared, read) => declared === read || read.startsWith(declared + ".");
+var diffDeps = (declared, reads) => {
+  const declaredList = Array.from(new Set(declared)).filter((p) => typeof p === "string" && p.length > 0);
+  declaredList.sort();
+  const readList = Array.from(new Set(reads)).filter((p) => typeof p === "string" && p.length > 0);
+  readList.sort();
+  const missing = readList.filter((r) => declaredList.every((d) => !covers(d, r)));
+  const unused = declaredList.filter((d) => readList.every((r) => !covers(d, r)));
+  if (missing.length === 0 && unused.length === 0) return void 0;
+  return {
+    reads: readList,
+    declared: declaredList,
+    missing,
+    unused
+  };
+};
+var trace = (fn, state) => {
+  if (!isTraceableObject(state)) {
+    return { value: fn(state), reads: [] };
+  }
+  const reads = /* @__PURE__ */ new Set();
+  const proxyCache = /* @__PURE__ */ new WeakMap();
+  const proxyToTarget = /* @__PURE__ */ new WeakMap();
+  const wrap = (value2, path) => {
+    if (!isTraceableObject(value2)) return value2;
+    return getProxy(value2, path);
+  };
+  const unwrap = (value2) => {
+    if (value2 && (typeof value2 === "object" || typeof value2 === "function")) {
+      const target = proxyToTarget.get(value2);
+      if (target) return target;
+    }
+    return value2;
+  };
+  const getProxy = (target, basePath) => {
+    let byPath = proxyCache.get(target);
+    if (!byPath) {
+      byPath = /* @__PURE__ */ new Map();
+      proxyCache.set(target, byPath);
+    }
+    const cached = byPath.get(basePath);
+    if (cached) return cached;
+    const record2 = (path) => {
+      if (path) reads.add(path);
+    };
+    const proxy = new Proxy(target, {
+      get: (t, prop, receiver) => {
+        if (typeof prop === "symbol") {
+          return Reflect.get(t, prop, receiver);
+        }
+        const key = String(prop);
+        if (shouldIgnoreKey(key)) {
+          return Reflect.get(t, prop, receiver);
+        }
+        const nextPath = basePath ? `${basePath}.${key}` : key;
+        record2(nextPath);
+        const value2 = Reflect.get(t, prop, receiver);
+        return wrap(value2, nextPath);
+      },
+      has: (t, prop) => {
+        if (typeof prop === "symbol") return Reflect.has(t, prop);
+        const key = String(prop);
+        if (!shouldIgnoreKey(key)) {
+          const nextPath = basePath ? `${basePath}.${key}` : key;
+          record2(nextPath);
+        }
+        return Reflect.has(t, prop);
+      },
+      ownKeys: (t) => {
+        if (basePath) record2(basePath);
+        return Reflect.ownKeys(t);
+      },
+      getOwnPropertyDescriptor: (t, prop) => {
+        if (typeof prop === "symbol") {
+          return Reflect.getOwnPropertyDescriptor(t, prop);
+        }
+        const key = String(prop);
+        if (!shouldIgnoreKey(key)) {
+          const nextPath = basePath ? `${basePath}.${key}` : key;
+          record2(nextPath);
+        }
+        return Reflect.getOwnPropertyDescriptor(t, prop);
+      },
+      set: () => {
+        throw new Error(
+          "[deps-trace] Attempted to mutate state during deps tracing (state is readonly in dev-mode diagnostics)."
+        );
+      },
+      defineProperty: () => {
+        throw new Error(
+          "[deps-trace] Attempted to define property on state during deps tracing (state is readonly in dev-mode diagnostics)."
+        );
+      },
+      deleteProperty: () => {
+        throw new Error(
+          "[deps-trace] Attempted to delete property on state during deps tracing (state is readonly in dev-mode diagnostics)."
+        );
+      }
+    });
+    byPath.set(basePath, proxy);
+    proxyToTarget.set(proxy, target);
+    return proxy;
+  };
+  const root = getProxy(state, "");
+  const value = unwrap(fn(root));
+  return {
+    value,
+    reads: normalizeReads(reads)
+  };
+};
+
+// ../logix-core/src/internal/state-trait/source.ts
+var makePatch = (path, from, to, reason, stepId) => ({
+  path,
+  from,
+  to,
+  reason,
+  stepId
+});
+var onceInRunSession = (key) => Effect.serviceOption(RunSessionTag).pipe(
+  Effect.map(
+    (maybe) => Option.isSome(maybe) ? maybe.value.local.once(key) : true
+  )
+);
+var formatList = (items, limit = 10) => {
+  if (items.length === 0) return "";
+  if (items.length <= limit) return items.join(", ");
+  return `${items.slice(0, limit).join(", ")}, \u2026(+${items.length - limit})`;
+};
+var emitDepsMismatch = (params) => Effect.gen(function* () {
+  const key = `${params.instanceId ?? "unknown"}::${params.kind}::${params.fieldPath}`;
+  const shouldEmit = yield* onceInRunSession(`deps_mismatch:${key}`);
+  if (!shouldEmit) return;
+  yield* record({
+    type: "diagnostic",
+    moduleId: params.moduleId,
+    instanceId: params.instanceId,
+    code: "state_trait::deps_mismatch",
+    severity: "warning",
+    message: `[deps] ${params.kind} "${params.fieldPath}" declared=[${formatList(params.diff.declared)}] reads=[${formatList(params.diff.reads)}] missing=[${formatList(params.diff.missing)}] unused=[${formatList(params.diff.unused)}]`,
+    hint: 'deps is the single source of truth for dependencies: incremental scheduling / reverse closures / performance optimizations rely on deps only. Keep deps consistent with actual reads; if you really depend on the whole object, declare a coarser-grained dep (e.g. "profile") to cover sub-field reads.',
+    kind: `deps_mismatch:${params.kind}`
+  });
+});
+var getMiddlewareStack = () => Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  Effect.map(
+    (maybe) => Option.isSome(maybe) ? maybe.value.stack : []
+  )
+);
+var recordTraitPatch = (bound, patch) => {
+  try {
+    const internals = getBoundInternals(bound);
+    internals.txn.recordStatePatch(patch);
+  } catch {
+  }
+};
+var recordReplayEvent = (bound, event) => {
+  try {
+    const internals = getBoundInternals(bound);
+    internals.txn.recordReplayEvent(event);
+  } catch {
+  }
+};
+var getBoundScope = (bound) => {
+  try {
+    const internals = getBoundInternals(bound);
+    return { moduleId: internals.moduleId, instanceId: internals.instanceId };
+  } catch {
+    return { moduleId: void 0, instanceId: void 0 };
+  }
+};
+var setSnapshotInTxn = (bound, fieldPath, next, reason, stepId, traitNodeId) => Effect.gen(function* () {
+  let wrote = false;
+  yield* bound.state.mutate((draft) => {
+    const prev = getAtPath(draft, fieldPath);
+    if (Object.is(prev, next)) return;
+    wrote = true;
+    setAtPathMutating(draft, fieldPath, next);
+    recordTraitPatch(bound, {
+      path: fieldPath,
+      from: prev,
+      to: next,
+      reason,
+      stepId,
+      traitNodeId
+    });
+  });
+  return wrote;
+});
+var writebackIfCurrentKeyHash = (bound, fieldPath, keyHash2, next, reason, stepId, traitNodeId, replayEvent) => Effect.gen(function* () {
+  let wrote = false;
+  yield* bound.state.mutate((draft) => {
+    const current = getAtPath(draft, fieldPath);
+    const currentKeyHash = current && typeof current === "object" ? current.keyHash : void 0;
+    if (currentKeyHash !== keyHash2) return;
+    const prev = current;
+    if (Object.is(prev, next)) return;
+    wrote = true;
+    setAtPathMutating(draft, fieldPath, next);
+    if (replayEvent) {
+      recordReplayEvent(bound, replayEvent);
+    }
+    recordTraitPatch(bound, {
+      path: fieldPath,
+      from: prev,
+      to: next,
+      reason,
+      stepId,
+      traitNodeId
+    });
+  });
+  return wrote;
+});
+var syncIdleInTransaction = (program, ctx) => Effect.sync(() => {
+  const draft = ctx.getDraft();
+  const updates = [];
+  for (const entry of program.entries) {
+    if (entry.kind !== "source") continue;
+    const fieldPath = entry.fieldPath;
+    const listItem = parseListItemFieldPath(fieldPath);
+    if (listItem) {
+      const listValue = getAtPath(draft, listItem.listPath);
+      const items = Array.isArray(listValue) ? listValue : [];
+      for (let index = 0; index < items.length; index++) {
+        const item = items[index];
+        let key2;
+        try {
+          key2 = entry.meta.key(item);
+        } catch {
+          continue;
+        }
+        if (key2 !== void 0) continue;
+        const concretePath = toListItemValuePath(
+          listItem.listPath,
+          index,
+          listItem.itemPath
+        );
+        const prev2 = getAtPath(draft, concretePath);
+        const prevStatus2 = prev2 && typeof prev2 === "object" ? prev2.status : void 0;
+        if (prevStatus2 === "idle") {
+          const data = prev2?.data;
+          const error = prev2?.error;
+          if (data === void 0 && error === void 0) {
+            continue;
+          }
+        }
+        updates.push({ fieldPath: concretePath, prev: prev2 });
+      }
+      continue;
+    }
+    let key;
+    try {
+      key = entry.meta.key(draft);
+    } catch {
+      continue;
+    }
+    if (key !== void 0) continue;
+    const prev = getAtPath(draft, fieldPath);
+    const prevStatus = prev && typeof prev === "object" ? prev.status : void 0;
+    if (prevStatus === "idle") {
+      const data = prev?.data;
+      const error = prev?.error;
+      if (data === void 0 && error === void 0) {
+        continue;
+      }
+    }
+    updates.push({ fieldPath, prev });
+  }
+  if (updates.length === 0) return;
+  const reason = "source:idle";
+  const nextDraft = create(draft, (next) => {
+    for (const u of updates) {
+      setAtPathMutating(next, u.fieldPath, Snapshot.idle());
+    }
+  });
+  ctx.setDraft(nextDraft);
+  for (const u of updates) {
+    ctx.recordPatch(
+      makePatch(
+        u.fieldPath,
+        u.prev,
+        Snapshot.idle(),
+        reason,
+        `source:${u.fieldPath}:idle`
+      )
+    );
+  }
+});
+var installSourceRefresh = (bound, step, entry) => {
+  if (!step.targetFieldPath) return Effect.void;
+  const fieldPath = step.targetFieldPath;
+  const resourceId = step.resourceId ?? entry.meta.resource;
+  const listItem = parseListItemFieldPath(fieldPath);
+  let internals;
+  try {
+    internals = getBoundInternals(bound);
+  } catch {
+    return Effect.void;
+  }
+  const register = internals.traits.registerSourceRefresh;
+  const recordSnapshot = (replayMode, replayLog, input) => {
+    if (!replayLog) return Effect.void;
+    if (replayMode !== "live") return Effect.void;
+    const event = input && typeof input === "object" && input._tag === "ResourceSnapshot" ? input : {
+      _tag: "ResourceSnapshot",
+      resourceId,
+      fieldPath: input.fieldPath,
+      keyHash: input.keyHash,
+      concurrency: input.concurrency,
+      phase: input.phase,
+      snapshot: input.snapshot,
+      timestamp: Date.now(),
+      moduleId: input.moduleId,
+      instanceId: input.instanceId
+    };
+    return replayLog.record(event);
+  };
+  if (listItem) {
+    const store = internals.traits.rowIdStore;
+    if (!store) {
+      return Effect.void;
+    }
+    const listPath = listItem.listPath;
+    const itemPath = listItem.itemPath;
+    if (!itemPath) {
+      return Effect.void;
+    }
+    const concurrency2 = entry.meta.concurrency;
+    const mode2 = concurrency2 ?? "switch";
+    const inFlight2 = /* @__PURE__ */ new Map();
+    const trailing2 = /* @__PURE__ */ new Map();
+    let gen2 = 0;
+    store.onRemoved(listPath, (rowId) => {
+      trailing2.delete(rowId);
+      inFlight2.delete(rowId);
+    });
+    const setSnapshotForRowInTxn = (rowId, next, reason, stepId) => Effect.gen(function* () {
+      let wrotePath;
+      yield* bound.state.mutate((draft) => {
+        const index = store.getIndex(listPath, rowId);
+        if (index === void 0) return;
+        const concretePath = toListItemValuePath(listPath, index, itemPath);
+        const prev = getAtPath(draft, concretePath);
+        if (Object.is(prev, next)) return;
+        wrotePath = concretePath;
+        setAtPathMutating(draft, concretePath, next);
+        recordTraitPatch(bound, {
+          path: concretePath,
+          from: prev,
+          to: next,
+          reason,
+          stepId,
+          traitNodeId: step.debugInfo?.graphNodeId
+        });
+      });
+      return wrotePath;
+    });
+    const writebackIfCurrentKeyHashForRow = (rowId, keyHash2, next, reason, stepId, phase) => Effect.gen(function* () {
+      let wrotePath;
+      yield* bound.state.mutate((draft) => {
+        const index = store.getIndex(listPath, rowId);
+        if (index === void 0) return;
+        const concretePath = toListItemValuePath(listPath, index, itemPath);
+        const current = getAtPath(draft, concretePath);
+        const currentKeyHash = current && typeof current === "object" ? current.keyHash : void 0;
+        if (currentKeyHash !== keyHash2) return;
+        const prev = current;
+        if (Object.is(prev, next)) return;
+        wrotePath = concretePath;
+        setAtPathMutating(draft, concretePath, next);
+        if (phase) {
+          const { moduleId, instanceId } = getBoundScope(bound);
+          recordReplayEvent(bound, {
+            _tag: "ResourceSnapshot",
+            resourceId,
+            fieldPath: concretePath,
+            keyHash: keyHash2,
+            concurrency: mode2,
+            phase,
+            snapshot: next,
+            timestamp: Date.now(),
+            moduleId,
+            instanceId
+          });
+        }
+        recordTraitPatch(bound, {
+          path: concretePath,
+          from: prev,
+          to: next,
+          reason,
+          stepId,
+          traitNodeId: step.debugInfo?.graphNodeId
+        });
+      });
+      return wrotePath;
+    });
+    const startFetch2 = (rowId, key, keyHash2, replayMode, replayLog) => Effect.gen(function* () {
+      const { moduleId, instanceId } = getBoundScope(bound);
+      const indexForLog = store.getIndex(listPath, rowId);
+      const logFieldPath = indexForLog === void 0 ? void 0 : toListItemValuePath(listPath, indexForLog, itemPath);
+      let loadingSnapshot = Snapshot.loading({ keyHash: keyHash2 });
+      if (replayMode === "replay" && replayLog && logFieldPath) {
+        const replayLoading = yield* replayLog.consumeNextResourceSnapshot({
+          resourceId,
+          fieldPath: logFieldPath,
+          keyHash: keyHash2,
+          phase: "loading"
+        });
+        if (replayLoading) {
+          loadingSnapshot = replayLoading.snapshot;
+        }
+      }
+      const wroteLoadingPath = yield* setSnapshotForRowInTxn(
+        rowId,
+        loadingSnapshot,
+        "source:loading",
+        `source:${fieldPath}:${rowId}:loading`
+      );
+      if (wroteLoadingPath) {
+        const event = {
+          _tag: "ResourceSnapshot",
+          resourceId,
+          fieldPath: wroteLoadingPath,
+          keyHash: keyHash2,
+          concurrency: mode2,
+          phase: "loading",
+          snapshot: loadingSnapshot,
+          timestamp: Date.now(),
+          moduleId,
+          instanceId
+        };
+        recordReplayEvent(bound, event);
+        yield* recordSnapshot(replayMode, replayLog, event);
+      }
+      const io = Effect.gen(function* () {
+        if (replayMode === "replay" && replayLog) {
+          yield* Effect.yieldNow();
+          const consumePath = wroteLoadingPath ?? logFieldPath;
+          if (!consumePath) return yield* Effect.void;
+          const replayed = yield* replayLog.consumeNextResourceSnapshot({
+            resourceId,
+            fieldPath: consumePath,
+            keyHash: keyHash2
+          });
+          if (!replayed) return yield* Effect.void;
+          if (replayed.phase === "success") {
+            yield* writebackIfCurrentKeyHashForRow(
+              rowId,
+              keyHash2,
+              replayed.snapshot,
+              "source:success",
+              `source:${fieldPath}:${rowId}:success`,
+              "success"
+            );
+          } else if (replayed.phase === "error") {
+            yield* writebackIfCurrentKeyHashForRow(
+              rowId,
+              keyHash2,
+              replayed.snapshot,
+              "source:error",
+              `source:${fieldPath}:${rowId}:error`,
+              "error"
+            );
+          }
+          return yield* Effect.void;
+        }
+        const stack = yield* getMiddlewareStack();
+        const registryOpt = yield* Effect.serviceOption(internal.ResourceRegistryTag);
+        const registry = Option.isSome(registryOpt) ? registryOpt.value : void 0;
+        const spec = registry?.specs.get(resourceId);
+        if (!spec) {
+          return yield* Effect.void;
+        }
+        const loadEffect = spec.load(key);
+        const meta = {
+          moduleId,
+          instanceId,
+          fieldPath,
+          resourceId,
+          key,
+          keyHash: keyHash2,
+          rowId,
+          traitNodeId: step.debugInfo?.graphNodeId,
+          stepId: step.id
+        };
+        if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
+          const sessionOpt = yield* Effect.serviceOption(RunSessionTag);
+          if (Option.isSome(sessionOpt)) {
+            const seqKey = instanceId ?? "global";
+            meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", seqKey);
+          }
+        }
+        const op = make({
+          kind: "service",
+          name: resourceId,
+          effect: loadEffect,
+          meta
+        });
+        const exit = yield* Effect.exit(run(op, stack));
+        if (exit._tag === "Success") {
+          const successSnapshot = Snapshot.success({ keyHash: keyHash2, data: exit.value });
+          const wroteSuccessPath = yield* writebackIfCurrentKeyHashForRow(
+            rowId,
+            keyHash2,
+            successSnapshot,
+            "source:success",
+            `source:${fieldPath}:${rowId}:success`,
+            "success"
+          );
+          if (wroteSuccessPath) {
+            yield* recordSnapshot(replayMode, replayLog, {
+              _tag: "ResourceSnapshot",
+              resourceId,
+              fieldPath: wroteSuccessPath,
+              keyHash: keyHash2,
+              concurrency: mode2,
+              phase: "success",
+              snapshot: successSnapshot,
+              timestamp: Date.now(),
+              moduleId,
+              instanceId
+            });
+          }
+        } else {
+          const errorSnapshot = Snapshot.error({ keyHash: keyHash2, error: exit.cause });
+          const wroteErrorPath = yield* writebackIfCurrentKeyHashForRow(
+            rowId,
+            keyHash2,
+            errorSnapshot,
+            "source:error",
+            `source:${fieldPath}:${rowId}:error`,
+            "error"
+          );
+          if (wroteErrorPath) {
+            yield* recordSnapshot(replayMode, replayLog, {
+              _tag: "ResourceSnapshot",
+              resourceId,
+              fieldPath: wroteErrorPath,
+              keyHash: keyHash2,
+              concurrency: mode2,
+              phase: "error",
+              snapshot: errorSnapshot,
+              timestamp: Date.now(),
+              moduleId,
+              instanceId
+            });
+          }
+        }
+      }).pipe(Effect.catchAllCause(() => Effect.void));
+      const fiber = yield* Effect.forkScoped(
+        Effect.locally(inSyncTransactionFiber, false)(io)
+      );
+      const myGen = gen2 += 1;
+      inFlight2.set(rowId, { gen: myGen, fiber, keyHash: keyHash2 });
+      yield* Effect.forkScoped(
+        Effect.locally(inSyncTransactionFiber, false)(
+          Fiber.await(fiber).pipe(
+            Effect.zipRight(
+              Effect.sync(() => {
+                const current = inFlight2.get(rowId);
+                if (current && current.gen === myGen) {
+                  inFlight2.delete(rowId);
+                }
+              })
+            ),
+            Effect.zipRight(
+              mode2 === "exhaust-trailing" ? Effect.gen(function* () {
+                const next = trailing2.get(rowId);
+                trailing2.delete(rowId);
+                if (next) {
+                  yield* startFetch2(
+                    rowId,
+                    next.key,
+                    next.keyHash,
+                    replayMode,
+                    replayLog
+                  );
+                }
+              }) : Effect.void
+            ),
+            Effect.catchAllCause(() => Effect.void)
+          )
+        )
+      );
+    });
+    register(
+      fieldPath,
+      (state) => Effect.gen(function* () {
+        const { moduleId, instanceId } = getBoundScope(bound);
+        const replayModeOpt = yield* Effect.serviceOption(ReplayModeConfigTag);
+        const replayMode = Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+        const replayLogOpt = yield* Effect.serviceOption(ReplayLog);
+        const replayLog = Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+        const force = yield* FiberRef.get(forceSourceRefresh);
+        const listValue = getAtPath(state, listPath);
+        const items = Array.isArray(listValue) ? listValue : [];
+        const ids = store.ensureList(listPath, items);
+        const traceKey = `${instanceId ?? "unknown"}::source::${fieldPath}`;
+        if (isDevEnv() && (yield* onceInRunSession(`deps_trace_settled:${traceKey}`))) {
+          try {
+            const sample = items[0];
+            if (sample !== void 0) {
+              const traced = trace((s) => entry.meta.key(s), sample);
+              const prefixedReads = traced.reads.map(
+                (r) => r ? `${listPath}[].${r}` : `${listPath}[]`
+              );
+              const diff = diffDeps(
+                entry.meta.deps ?? [],
+                prefixedReads
+              );
+              if (diff) {
+                yield* emitDepsMismatch({
+                  moduleId,
+                  instanceId,
+                  kind: "source",
+                  fieldPath,
+                  diff
+                });
+              }
+            }
+          } catch {
+          }
+        }
+        for (let index = 0; index < items.length; index++) {
+          const rowId = ids[index];
+          if (!rowId) continue;
+          const concretePath = toListItemValuePath(listPath, index, itemPath);
+          const prevSnapshot = getAtPath(state, concretePath);
+          let key;
+          try {
+            key = entry.meta.key(items[index]);
+          } catch {
+            key = void 0;
+          }
+          const current = inFlight2.get(rowId);
+          if (key === void 0) {
+            trailing2.delete(rowId);
+            inFlight2.delete(rowId);
+            if (prevSnapshot && typeof prevSnapshot === "object" && prevSnapshot.status === "idle" && prevSnapshot.data === void 0 && prevSnapshot.error === void 0) {
+              continue;
+            }
+            const idleSnapshot = Snapshot.idle();
+            const wroteIdlePath = yield* setSnapshotForRowInTxn(
+              rowId,
+              idleSnapshot,
+              "source:idle",
+              `source:${fieldPath}:${rowId}:idle`
+            );
+            if (wroteIdlePath) {
+              const event = {
+                _tag: "ResourceSnapshot",
+                resourceId,
+                fieldPath: wroteIdlePath,
+                keyHash: void 0,
+                concurrency: mode2,
+                phase: "idle",
+                snapshot: idleSnapshot,
+                timestamp: Date.now(),
+                moduleId,
+                instanceId
+              };
+              recordReplayEvent(bound, event);
+              yield* recordSnapshot(replayMode, replayLog, event);
+            }
+            continue;
+          }
+          const h = keyHash(key);
+          if (!force && current && current.keyHash === h) {
+            continue;
+          }
+          const prevKeyHash = prevSnapshot && typeof prevSnapshot === "object" ? prevSnapshot.keyHash : void 0;
+          if (!force && !current && prevKeyHash === h) {
+            continue;
+          }
+          if (mode2 === "exhaust-trailing" && current) {
+            trailing2.set(rowId, { key, keyHash: h });
+            const loadingSnapshot = Snapshot.loading({ keyHash: h });
+            const wroteLoadingPath = yield* setSnapshotForRowInTxn(
+              rowId,
+              loadingSnapshot,
+              "source:loading",
+              `source:${fieldPath}:${rowId}:loading`
+            );
+            if (wroteLoadingPath) {
+              const event = {
+                _tag: "ResourceSnapshot",
+                resourceId,
+                fieldPath: wroteLoadingPath,
+                keyHash: h,
+                concurrency: mode2,
+                phase: "loading",
+                snapshot: loadingSnapshot,
+                timestamp: Date.now(),
+                moduleId,
+                instanceId
+              };
+              recordReplayEvent(bound, event);
+              yield* recordSnapshot(replayMode, replayLog, event);
+            }
+            continue;
+          }
+          if (mode2 === "switch" && current) {
+            trailing2.delete(rowId);
+            inFlight2.delete(rowId);
+          }
+          yield* startFetch2(rowId, key, h, replayMode, replayLog);
+        }
+      })
+    );
+    return Effect.void;
+  }
+  let inFlight;
+  let gen = 0;
+  let trailing;
+  const concurrency = entry.meta.concurrency;
+  const mode = concurrency ?? "switch";
+  const startFetch = (key, keyHash2, replayMode, replayLog) => Effect.gen(function* () {
+    const { moduleId, instanceId } = getBoundScope(bound);
+    let loadingSnapshot = Snapshot.loading({ keyHash: keyHash2 });
+    if (replayMode === "replay" && replayLog) {
+      const replayLoading = yield* replayLog.consumeNextResourceSnapshot({
+        resourceId,
+        fieldPath,
+        keyHash: keyHash2,
+        phase: "loading"
+      });
+      if (replayLoading) {
+        loadingSnapshot = replayLoading.snapshot;
+      }
+    }
+    const wroteLoading = yield* setSnapshotInTxn(
+      bound,
+      fieldPath,
+      loadingSnapshot,
+      "source:loading",
+      `source:${fieldPath}:loading`,
+      step.debugInfo?.graphNodeId
+    );
+    if (wroteLoading) {
+      const event = {
+        _tag: "ResourceSnapshot",
+        resourceId,
+        fieldPath,
+        keyHash: keyHash2,
+        concurrency: mode,
+        phase: "loading",
+        snapshot: loadingSnapshot,
+        timestamp: Date.now(),
+        moduleId,
+        instanceId
+      };
+      recordReplayEvent(bound, event);
+      yield* recordSnapshot(replayMode, replayLog, event);
+    }
+    const io = Effect.gen(function* () {
+      if (replayMode === "replay" && replayLog) {
+        yield* Effect.yieldNow();
+        const replayed = yield* replayLog.consumeNextResourceSnapshot({
+          resourceId,
+          fieldPath,
+          keyHash: keyHash2
+        });
+        if (!replayed) return yield* Effect.void;
+        if (replayed.phase === "success") {
+          const event = {
+            _tag: "ResourceSnapshot",
+            resourceId,
+            fieldPath,
+            keyHash: keyHash2,
+            concurrency: mode,
+            phase: "success",
+            snapshot: replayed.snapshot,
+            timestamp: Date.now(),
+            moduleId,
+            instanceId
+          };
+          yield* writebackIfCurrentKeyHash(
+            bound,
+            fieldPath,
+            keyHash2,
+            replayed.snapshot,
+            "source:success",
+            `source:${fieldPath}:success`,
+            step.debugInfo?.graphNodeId,
+            event
+          );
+        } else if (replayed.phase === "error") {
+          const event = {
+            _tag: "ResourceSnapshot",
+            resourceId,
+            fieldPath,
+            keyHash: keyHash2,
+            concurrency: mode,
+            phase: "error",
+            snapshot: replayed.snapshot,
+            timestamp: Date.now(),
+            moduleId,
+            instanceId
+          };
+          yield* writebackIfCurrentKeyHash(
+            bound,
+            fieldPath,
+            keyHash2,
+            replayed.snapshot,
+            "source:error",
+            `source:${fieldPath}:error`,
+            step.debugInfo?.graphNodeId,
+            event
+          );
+        }
+        return yield* Effect.void;
+      }
+      const stack = yield* getMiddlewareStack();
+      const registryOpt = yield* Effect.serviceOption(
+        internal.ResourceRegistryTag
+      );
+      const registry = Option.isSome(registryOpt) ? registryOpt.value : void 0;
+      const spec = registry?.specs.get(resourceId);
+      if (!spec) {
+        return yield* Effect.void;
+      }
+      const loadEffect = spec.load(key);
+      const meta = {
+        moduleId,
+        instanceId,
+        fieldPath,
+        resourceId,
+        key,
+        keyHash: keyHash2,
+        traitNodeId: step.debugInfo?.graphNodeId,
+        stepId: step.id
+      };
+      if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
+        const sessionOpt = yield* Effect.serviceOption(RunSessionTag);
+        if (Option.isSome(sessionOpt)) {
+          const seqKey = instanceId ?? "global";
+          meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", seqKey);
+        }
+      }
+      const op = make({
+        kind: "trait-source",
+        name: resourceId,
+        effect: loadEffect,
+        meta
+      });
+      const exit = yield* Effect.exit(run(op, stack));
+      if (exit._tag === "Success") {
+        const successSnapshot = Snapshot.success({ keyHash: keyHash2, data: exit.value });
+        const event = {
+          _tag: "ResourceSnapshot",
+          resourceId,
+          fieldPath,
+          keyHash: keyHash2,
+          concurrency: mode,
+          phase: "success",
+          snapshot: successSnapshot,
+          timestamp: Date.now(),
+          moduleId,
+          instanceId
+        };
+        const wroteSuccess = yield* writebackIfCurrentKeyHash(
+          bound,
+          fieldPath,
+          keyHash2,
+          successSnapshot,
+          "source:success",
+          `source:${fieldPath}:success`,
+          step.debugInfo?.graphNodeId,
+          event
+        );
+        if (wroteSuccess) {
+          yield* recordSnapshot(replayMode, replayLog, event);
+        }
+      } else {
+        const errorSnapshot = Snapshot.error({ keyHash: keyHash2, error: exit.cause });
+        const event = {
+          _tag: "ResourceSnapshot",
+          resourceId,
+          fieldPath,
+          keyHash: keyHash2,
+          concurrency: mode,
+          phase: "error",
+          snapshot: errorSnapshot,
+          timestamp: Date.now(),
+          moduleId,
+          instanceId
+        };
+        const wroteError = yield* writebackIfCurrentKeyHash(
+          bound,
+          fieldPath,
+          keyHash2,
+          errorSnapshot,
+          "source:error",
+          `source:${fieldPath}:error`,
+          step.debugInfo?.graphNodeId,
+          event
+        );
+        if (wroteError) {
+          yield* recordSnapshot(replayMode, replayLog, event);
+        }
+      }
+    }).pipe(
+      Effect.catchAllCause(() => Effect.void)
+    );
+    const fiber = yield* Effect.forkScoped(
+      Effect.locally(inSyncTransactionFiber, false)(io)
+    );
+    const myGen = gen += 1;
+    inFlight = { gen: myGen, fiber, keyHash: keyHash2 };
+    yield* Effect.forkScoped(
+      Effect.locally(inSyncTransactionFiber, false)(
+        Fiber.await(fiber).pipe(
+          Effect.zipRight(
+            Effect.sync(() => {
+              if (inFlight && inFlight.gen === myGen) {
+                inFlight = void 0;
+              }
+            })
+          ),
+          Effect.zipRight(
+            mode === "exhaust-trailing" ? Effect.gen(function* () {
+              const next = trailing;
+              trailing = void 0;
+              if (next) {
+                yield* startFetch(
+                  next.key,
+                  next.keyHash,
+                  replayMode,
+                  replayLog
+                );
+              }
+            }) : Effect.void
+          ),
+          Effect.catchAllCause(() => Effect.void)
+        )
+      )
+    );
+  });
+  register(
+    fieldPath,
+    (state) => Effect.gen(function* () {
+      const { moduleId, instanceId } = getBoundScope(bound);
+      const replayModeOpt = yield* Effect.serviceOption(ReplayModeConfigTag);
+      const replayMode = Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+      const replayLogOpt = yield* Effect.serviceOption(ReplayLog);
+      const replayLog = Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+      const force = yield* FiberRef.get(forceSourceRefresh);
+      let key;
+      try {
+        key = entry.meta.key(state);
+      } catch {
+        key = void 0;
+      }
+      const traceKey = `${instanceId ?? "unknown"}::source::${fieldPath}`;
+      if (isDevEnv() && (yield* onceInRunSession(`deps_trace_settled:${traceKey}`))) {
+        try {
+          const traced = trace((s) => entry.meta.key(s), state);
+          const diff = diffDeps(
+            entry.meta.deps ?? [],
+            traced.reads
+          );
+          if (diff) {
+            yield* emitDepsMismatch({
+              moduleId,
+              instanceId,
+              kind: "source",
+              fieldPath,
+              diff
+            });
+          }
+        } catch {
+        }
+      }
+      if (key === void 0) {
+        if (inFlight) {
+          yield* Fiber.interruptFork(inFlight.fiber);
+          inFlight = void 0;
+        }
+        trailing = void 0;
+        const idleSnapshot = Snapshot.idle();
+        const wroteIdle = yield* setSnapshotInTxn(
+          bound,
+          fieldPath,
+          idleSnapshot,
+          "source:idle",
+          `source:${fieldPath}:idle`,
+          step.debugInfo?.graphNodeId
+        );
+        if (wroteIdle) {
+          const event = {
+            _tag: "ResourceSnapshot",
+            resourceId,
+            fieldPath,
+            keyHash: void 0,
+            concurrency: mode,
+            phase: "idle",
+            snapshot: idleSnapshot,
+            timestamp: Date.now(),
+            moduleId,
+            instanceId
+          };
+          recordReplayEvent(bound, event);
+          yield* recordSnapshot(replayMode, replayLog, event);
+        }
+        return;
+      }
+      const h = keyHash(key);
+      if (!force) {
+        if (inFlight && inFlight.keyHash === h) {
+          return;
+        }
+        const currentSnapshot = getAtPath(state, fieldPath);
+        const currentKeyHash = currentSnapshot && typeof currentSnapshot === "object" ? currentSnapshot.keyHash : void 0;
+        const currentStatus = currentSnapshot && typeof currentSnapshot === "object" ? currentSnapshot.status : void 0;
+        if (currentStatus && currentStatus !== "idle" && currentKeyHash === h) {
+          return;
+        }
+      }
+      if (mode === "exhaust-trailing" && inFlight) {
+        trailing = { key, keyHash: h };
+        const loadingSnapshot = Snapshot.loading({ keyHash: h });
+        const wroteLoading = yield* setSnapshotInTxn(
+          bound,
+          fieldPath,
+          loadingSnapshot,
+          "source:loading",
+          `source:${fieldPath}:loading`,
+          step.debugInfo?.graphNodeId
+        );
+        if (wroteLoading) {
+          const event = {
+            _tag: "ResourceSnapshot",
+            resourceId,
+            fieldPath,
+            keyHash: h,
+            concurrency: mode,
+            phase: "loading",
+            snapshot: loadingSnapshot,
+            timestamp: Date.now(),
+            moduleId,
+            instanceId
+          };
+          recordReplayEvent(bound, event);
+          yield* recordSnapshot(replayMode, replayLog, event);
+        }
+        return;
+      }
+      if (mode === "switch" && inFlight) {
+        yield* Fiber.interruptFork(inFlight.fiber);
+        inFlight = void 0;
+        trailing = void 0;
+      }
+      yield* startFetch(key, h, replayMode, replayLog);
+    })
+  );
+  return Effect.void;
+};
+
+export {
+  diffDeps,
+  trace,
+  syncIdleInTransaction,
+  installSourceRefresh
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/source.ts", "../../../../logix-core/src/internal/state-trait/deps-trace.ts"],
  "sourcesContent": ["import { Effect, Fiber, FiberRef, Option } from \"effect\"\nimport { create } from \"mutative\"\nimport * as EffectOp from \"../effect-op.js\"\nimport { Snapshot, internal as ResourceInternal, keyHash as hashKey } from \"../resource.js\"\nimport * as EffectOpCore from \"../runtime/core/EffectOpCore.js\"\nimport * as Debug from \"../runtime/core/DebugSink.js\"\nimport * as TaskRunner from \"../runtime/core/TaskRunner.js\"\nimport { isDevEnv, ReplayModeConfigTag } from \"../runtime/core/env.js\"\nimport * as ReplayLog from \"../runtime/core/ReplayLog.js\"\nimport type { PatchReason, StatePatch } from \"../runtime/core/StateTransaction.js\"\nimport type { BoundApi } from \"../runtime/core/module.js\"\nimport { getBoundInternals } from \"../runtime/core/runtimeInternalsAccessor.js\"\nimport { RunSessionTag } from \"../observability/runSession.js\"\nimport * as DepsTrace from \"./deps-trace.js\"\nimport * as RowId from \"./rowid.js\"\nimport type {\n  StateTraitEntry,\n  StateTraitPlanStep,\n  StateTraitProgram,\n} from \"./model.js\"\n\nexport interface SourceSyncContext<S> {\n  readonly moduleId?: string\n  readonly instanceId?: string\n  readonly getDraft: () => S\n  readonly setDraft: (next: S) => void\n  readonly recordPatch: (patch: StatePatch) => void\n}\n\nconst makePatch = (\n  path: string,\n  from: unknown,\n  to: unknown,\n  reason: PatchReason,\n  stepId: string,\n): StatePatch => ({\n  path,\n  from,\n  to,\n  reason,\n  stepId,\n})\n\nconst onceInRunSession = (key: string): Effect.Effect<boolean, never, any> =>\n  Effect.serviceOption(RunSessionTag).pipe(\n    Effect.map((maybe) =>\n      Option.isSome(maybe) ? maybe.value.local.once(key) : true,\n    ),\n  )\n\nconst formatList = (items: ReadonlyArray<string>, limit = 10): string => {\n  if (items.length === 0) return \"\"\n  if (items.length <= limit) return items.join(\", \")\n  return `${items.slice(0, limit).join(\", \")}, \u2026(+${items.length - limit})`\n}\n\nconst emitDepsMismatch = (\n  params: {\n    readonly moduleId?: string\n    readonly instanceId?: string\n    readonly kind: \"computed\" | \"source\"\n    readonly fieldPath: string\n    readonly diff: DepsTrace.DepsDiff\n  },\n): Effect.Effect<void, never, any> =>\n  Effect.gen(function* () {\n    const key = `${params.instanceId ?? \"unknown\"}::${params.kind}::${params.fieldPath}`\n    const shouldEmit = yield* onceInRunSession(`deps_mismatch:${key}`)\n    if (!shouldEmit) return\n\n    yield* Debug.record({\n      type: \"diagnostic\",\n      moduleId: params.moduleId,\n      instanceId: params.instanceId,\n      code: \"state_trait::deps_mismatch\",\n      severity: \"warning\",\n      message:\n        `[deps] ${params.kind} \"${params.fieldPath}\" declared=[${formatList(params.diff.declared)}] ` +\n        `reads=[${formatList(params.diff.reads)}] missing=[${formatList(params.diff.missing)}] ` +\n        `unused=[${formatList(params.diff.unused)}]`,\n      hint:\n        \"deps is the single source of truth for dependencies: incremental scheduling / reverse closures / performance optimizations rely on deps only. \" +\n        \"Keep deps consistent with actual reads; if you really depend on the whole object, declare a coarser-grained dep (e.g. \\\"profile\\\") to cover sub-field reads.\",\n      kind: `deps_mismatch:${params.kind}`,\n    })\n  })\n\nconst getMiddlewareStack = (): Effect.Effect<\n  EffectOp.MiddlewareStack,\n  never,\n  any\n> =>\n  Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag).pipe(\n    Effect.map((maybe) =>\n      Option.isSome(maybe) ? maybe.value.stack : [],\n    ),\n  )\n\nconst recordTraitPatch = (\n  bound: BoundApi<any, any>,\n  patch: {\n    readonly path: string\n    readonly from?: unknown\n    readonly to?: unknown\n    readonly reason: PatchReason\n    readonly traitNodeId?: string\n    readonly stepId?: string\n  },\n): void => {\n  try {\n    const internals = getBoundInternals(bound as any)\n    internals.txn.recordStatePatch(patch as any)\n  } catch {\n    // no-op for legacy/mocked bound\n  }\n}\n\nconst recordReplayEvent = (\n  bound: BoundApi<any, any>,\n  event: ReplayLog.ReplayLogEvent,\n): void => {\n  try {\n    const internals = getBoundInternals(bound as any)\n    internals.txn.recordReplayEvent(event)\n  } catch {\n    // no-op for legacy/mocked bound\n  }\n}\n\nconst getBoundScope = (\n  bound: BoundApi<any, any>,\n): { readonly moduleId?: string; readonly instanceId?: string } => {\n  try {\n    const internals = getBoundInternals(bound as any)\n    return { moduleId: internals.moduleId, instanceId: internals.instanceId }\n  } catch {\n    return { moduleId: undefined, instanceId: undefined }\n  }\n}\n\nconst setSnapshotInTxn = (\n  bound: BoundApi<any, any>,\n  fieldPath: string,\n  next: unknown,\n  reason: PatchReason,\n  stepId: string,\n  traitNodeId?: string,\n): Effect.Effect<boolean, never, any> =>\n  Effect.gen(function* () {\n    let wrote = false\n    yield* (bound.state.mutate((draft: any) => {\n      const prev = RowId.getAtPath(draft, fieldPath)\n      if (Object.is(prev, next)) return\n      wrote = true\n      RowId.setAtPathMutating(draft, fieldPath, next)\n      recordTraitPatch(bound, {\n        path: fieldPath,\n        from: prev,\n        to: next,\n        reason,\n        stepId,\n        traitNodeId,\n      })\n    }) as Effect.Effect<void, never, any>)\n    return wrote\n  })\n\nconst writebackIfCurrentKeyHash = (\n  bound: BoundApi<any, any>,\n  fieldPath: string,\n  keyHash: string,\n  next: unknown,\n  reason: PatchReason,\n  stepId: string,\n  traitNodeId?: string,\n  replayEvent?: ReplayLog.ReplayLogEvent,\n): Effect.Effect<boolean, never, any> =>\n  Effect.gen(function* () {\n    let wrote = false\n    yield* (bound.state.mutate((draft: any) => {\n      const current = RowId.getAtPath(draft, fieldPath)\n      const currentKeyHash =\n        current && typeof current === \"object\" ? (current as any).keyHash : undefined\n      if (currentKeyHash !== keyHash) return\n\n      const prev = current\n      if (Object.is(prev, next)) return\n\n      wrote = true\n      RowId.setAtPathMutating(draft, fieldPath, next)\n      if (replayEvent) {\n        recordReplayEvent(bound, replayEvent)\n      }\n      recordTraitPatch(bound, {\n        path: fieldPath,\n        from: prev,\n        to: next,\n        reason,\n        stepId,\n        traitNodeId,\n      })\n    }) as Effect.Effect<void, never, any>)\n    return wrote\n  })\n\n/**\n * syncIdleInTransaction\uFF1A\n * - \u5728\u4E8B\u52A1\u7A97\u53E3\u5185\u540C\u6B65\u8BC4\u4F30\u6240\u6709 source.key(state)\uFF1B\n * - \u82E5 key \u53D8\u4E3A\u7A7A\uFF08undefined\uFF09\uFF0C\u5219\u540C\u6B65\u5C06\u5BF9\u5E94\u5B57\u6BB5\u91CD\u7F6E\u4E3A idle snapshot\uFF08\u907F\u514D tearing\uFF09\u3002\n */\nexport const syncIdleInTransaction = <S extends object>(\n  program: StateTraitProgram<S>,\n  ctx: SourceSyncContext<S>,\n): Effect.Effect<void> =>\n  Effect.sync(() => {\n    const draft = ctx.getDraft() as any\n    const updates: Array<{ readonly fieldPath: string; readonly prev: unknown }> = []\n\n    for (const entry of program.entries) {\n      if (entry.kind !== \"source\") continue\n      const fieldPath = entry.fieldPath\n      const listItem = RowId.parseListItemFieldPath(fieldPath)\n\n      if (listItem) {\n        // list.item scope\uFF1A\u6309 index \u9010\u884C\u8BC4\u4F30 key\uFF0C\u5E76\u5BF9\u672A\u6FC0\u6D3B\u884C\u540C\u6B65\u5199\u56DE idle\u3002\n        const listValue = RowId.getAtPath(draft, listItem.listPath)\n        const items: ReadonlyArray<unknown> = Array.isArray(listValue) ? listValue : []\n\n        for (let index = 0; index < items.length; index++) {\n          const item = items[index]\n\n          let key: unknown\n          try {\n            key = (entry.meta as any).key(item)\n          } catch {\n            continue\n          }\n\n          if (key !== undefined) continue\n\n          const concretePath = RowId.toListItemValuePath(\n            listItem.listPath,\n            index,\n            listItem.itemPath,\n          )\n          const prev = RowId.getAtPath(draft, concretePath)\n          const prevStatus =\n            prev && typeof prev === \"object\" ? (prev as any).status : undefined\n          if (prevStatus === \"idle\") {\n            const data = (prev as any)?.data\n            const error = (prev as any)?.error\n            if (data === undefined && error === undefined) {\n              continue\n            }\n          }\n\n          updates.push({ fieldPath: concretePath, prev })\n        }\n\n        continue\n      }\n\n      let key: unknown\n      try {\n        key = (entry.meta as any).key(draft)\n      } catch {\n        continue\n      }\n\n      if (key !== undefined) continue\n\n      const prev = RowId.getAtPath(draft, fieldPath)\n      const prevStatus =\n        prev && typeof prev === \"object\" ? (prev as any).status : undefined\n      if (prevStatus === \"idle\") {\n        // \u4ECD\u9700\u786E\u4FDD data/error \u88AB\u6E05\u7A7A\n        const data = (prev as any)?.data\n        const error = (prev as any)?.error\n        if (data === undefined && error === undefined) {\n          continue\n        }\n      }\n\n      updates.push({ fieldPath, prev })\n    }\n\n    if (updates.length === 0) return\n\n    const reason: PatchReason = \"source:idle\"\n\n    const nextDraft = create(draft, (next: any) => {\n      for (const u of updates) {\n        RowId.setAtPathMutating(next, u.fieldPath, Snapshot.idle())\n      }\n    })\n\n    ctx.setDraft(nextDraft as S)\n\n    for (const u of updates) {\n      ctx.recordPatch(\n        makePatch(\n          u.fieldPath,\n          u.prev,\n          Snapshot.idle(),\n          reason,\n          `source:${u.fieldPath}:idle`,\n        ),\n      )\n    }\n  })\n\n/**\n * installSourceRefresh\uFF1A\n * - \u4E3A\u5355\u4E2A source \u5B57\u6BB5\u6CE8\u518C\u5237\u65B0\u5B9E\u73B0\uFF08ResourceSnapshot + keyHash gate + concurrency\uFF09\u3002\n */\nexport const installSourceRefresh = <S>(\n  bound: BoundApi<any, any>,\n  step: StateTraitPlanStep,\n  entry: Extract<StateTraitEntry<S, string>, { readonly kind: \"source\" }>,\n): Effect.Effect<void, never, any> => {\n  if (!step.targetFieldPath) return Effect.void\n\n  const fieldPath = step.targetFieldPath\n  const resourceId = step.resourceId ?? entry.meta.resource\n  const listItem = RowId.parseListItemFieldPath(fieldPath)\n\n  let internals: ReturnType<typeof getBoundInternals> | undefined\n  try {\n    internals = getBoundInternals(bound as any)\n  } catch {\n    return Effect.void\n  }\n\n  const register = internals.traits.registerSourceRefresh\n\n  const recordSnapshot = (\n    replayMode: \"live\" | \"replay\",\n    replayLog: ReplayLog.ReplayLogService | undefined,\n    input:\n      | ReplayLog.ReplayLogEvent\n      | {\n          readonly moduleId?: string\n          readonly instanceId?: string\n          readonly fieldPath: string\n          readonly keyHash?: string\n          readonly concurrency?: string\n          readonly phase: ReplayLog.ResourceSnapshotPhase\n          readonly snapshot: unknown\n        },\n  ): Effect.Effect<void, never, any> => {\n    if (!replayLog) return Effect.void\n    if (replayMode !== \"live\") return Effect.void\n    const event: ReplayLog.ReplayLogEvent =\n      input && typeof input === \"object\" && (input as any)._tag === \"ResourceSnapshot\"\n        ? (input as ReplayLog.ReplayLogEvent)\n        : {\n            _tag: \"ResourceSnapshot\",\n            resourceId,\n            fieldPath: (input as any).fieldPath,\n            keyHash: (input as any).keyHash,\n            concurrency: (input as any).concurrency,\n            phase: (input as any).phase,\n            snapshot: (input as any).snapshot,\n            timestamp: Date.now(),\n            moduleId: (input as any).moduleId,\n            instanceId: (input as any).instanceId,\n          }\n    return replayLog.record(event)\n  }\n\n  // list.item scope\uFF1A\u6309 RowID \u505A in-flight \u95E8\u63A7\uFF08\u907F\u514D insert/remove/reorder \u4E0B\u5199\u9519\u884C\uFF09\u3002\n  if (listItem) {\n    const store = internals.traits.rowIdStore as RowId.RowIdStore | undefined\n    if (!store) {\n      return Effect.void\n    }\n\n    const listPath = listItem.listPath\n    const itemPath = listItem.itemPath\n    if (!itemPath) {\n      // \u7981\u6B62\u628A snapshot \u5199\u56DE\u5230\u6574\u4E2A item\uFF08\u4F1A\u8986\u76D6\u4E1A\u52A1 values\uFF09\u3002\n      return Effect.void\n    }\n\n    const concurrency = (entry.meta as any).concurrency as\n      | \"switch\"\n      | \"exhaust-trailing\"\n      | undefined\n    const mode = concurrency ?? \"switch\"\n\n    const inFlight = new Map<\n      RowId.RowId,\n      {\n        readonly gen: number\n        readonly fiber: Fiber.RuntimeFiber<void, never>\n        readonly keyHash: string\n      }\n    >()\n    const trailing = new Map<RowId.RowId, { readonly key: unknown; readonly keyHash: string }>()\n    let gen = 0\n\n    // row \u88AB\u79FB\u9664\uFF1A\u6E05\u7406 trailing/inFlight \u5F15\u7528\uFF0C\u907F\u514D\u540E\u7EED\u9519\u8BEF\u5F52\u5C5E\u6216\u5185\u5B58\u6CC4\u6F0F\u3002\n    store.onRemoved(listPath, (rowId) => {\n      trailing.delete(rowId)\n      inFlight.delete(rowId)\n    })\n\n    const setSnapshotForRowInTxn = (\n      rowId: RowId.RowId,\n      next: unknown,\n      reason: PatchReason,\n      stepId: string,\n    ): Effect.Effect<string | undefined, never, any> =>\n      Effect.gen(function* () {\n        let wrotePath: string | undefined\n        yield* (bound.state.mutate((draft: any) => {\n          const index = store.getIndex(listPath, rowId)\n          if (index === undefined) return\n          const concretePath = RowId.toListItemValuePath(listPath, index, itemPath)\n          const prev = RowId.getAtPath(draft, concretePath)\n          if (Object.is(prev, next)) return\n          wrotePath = concretePath\n          RowId.setAtPathMutating(draft, concretePath, next)\n          recordTraitPatch(bound, {\n            path: concretePath,\n            from: prev,\n            to: next,\n            reason,\n            stepId,\n            traitNodeId: step.debugInfo?.graphNodeId,\n          })\n        }) as Effect.Effect<void, never, any>)\n        return wrotePath\n      })\n\n    const writebackIfCurrentKeyHashForRow = (\n      rowId: RowId.RowId,\n      keyHash: string,\n      next: unknown,\n      reason: PatchReason,\n      stepId: string,\n      phase?: ReplayLog.ResourceSnapshotPhase,\n    ): Effect.Effect<string | undefined, never, any> =>\n      Effect.gen(function* () {\n        let wrotePath: string | undefined\n        yield* (bound.state.mutate((draft: any) => {\n          const index = store.getIndex(listPath, rowId)\n          if (index === undefined) return\n          const concretePath = RowId.toListItemValuePath(listPath, index, itemPath)\n\n          const current = RowId.getAtPath(draft, concretePath)\n          const currentKeyHash =\n            current && typeof current === \"object\" ? (current as any).keyHash : undefined\n          if (currentKeyHash !== keyHash) return\n\n          const prev = current\n          if (Object.is(prev, next)) return\n\n          wrotePath = concretePath\n          RowId.setAtPathMutating(draft, concretePath, next)\n          if (phase) {\n            const { moduleId, instanceId } = getBoundScope(bound)\n            recordReplayEvent(bound, {\n              _tag: \"ResourceSnapshot\",\n              resourceId,\n              fieldPath: concretePath,\n              keyHash,\n              concurrency: mode,\n              phase,\n              snapshot: next,\n              timestamp: Date.now(),\n              moduleId,\n              instanceId,\n            })\n          }\n          recordTraitPatch(bound, {\n            path: concretePath,\n            from: prev,\n            to: next,\n            reason,\n            stepId,\n            traitNodeId: step.debugInfo?.graphNodeId,\n          })\n        }) as Effect.Effect<void, never, any>)\n        return wrotePath\n      })\n\n    const startFetch = (\n      rowId: RowId.RowId,\n      key: unknown,\n      keyHash: string,\n      replayMode: \"live\" | \"replay\",\n      replayLog: ReplayLog.ReplayLogService | undefined,\n    ): Effect.Effect<void, never, any> =>\n      Effect.gen(function* () {\n        const { moduleId, instanceId } = getBoundScope(bound)\n\n        const indexForLog = store.getIndex(listPath, rowId)\n        const logFieldPath =\n          indexForLog === undefined\n            ? undefined\n            : RowId.toListItemValuePath(listPath, indexForLog, itemPath)\n\n        let loadingSnapshot: unknown = Snapshot.loading({ keyHash })\n        if (replayMode === \"replay\" && replayLog && logFieldPath) {\n          const replayLoading = yield* replayLog.consumeNextResourceSnapshot({\n            resourceId,\n            fieldPath: logFieldPath,\n            keyHash,\n            phase: \"loading\",\n          })\n          if (replayLoading) {\n            loadingSnapshot = replayLoading.snapshot\n          }\n        }\n        const wroteLoadingPath = yield* setSnapshotForRowInTxn(\n          rowId,\n          loadingSnapshot,\n          \"source:loading\",\n          `source:${fieldPath}:${rowId}:loading`,\n        )\n        if (wroteLoadingPath) {\n          const event: ReplayLog.ReplayLogEvent = {\n            _tag: \"ResourceSnapshot\",\n            resourceId,\n            fieldPath: wroteLoadingPath,\n            keyHash,\n            concurrency: mode,\n            phase: \"loading\",\n            snapshot: loadingSnapshot,\n            timestamp: Date.now(),\n            moduleId,\n            instanceId,\n          }\n          recordReplayEvent(bound, event)\n          yield* recordSnapshot(replayMode, replayLog, event)\n        }\n\n        const io = Effect.gen(function* () {\n          if (replayMode === \"replay\" && replayLog) {\n            // \u8BA9 loading \u63D0\u4EA4\u5148\u53EF\u89C1\uFF0C\u518D\u91CD\u8D5B\u7EC8\u6001\uFF08\u4FDD\u6301\u201C\u5F02\u6B65\u8D44\u6E90\u201D\u7684\u65F6\u95F4\u7EBF\u7ED3\u6784\uFF09\u3002\n            yield* Effect.yieldNow()\n            const consumePath = wroteLoadingPath ?? logFieldPath\n            if (!consumePath) return yield* Effect.void\n\n            const replayed = yield* replayLog.consumeNextResourceSnapshot({\n              resourceId,\n              fieldPath: consumePath,\n              keyHash,\n            })\n            if (!replayed) return yield* Effect.void\n\n            if (replayed.phase === \"success\") {\n              yield* writebackIfCurrentKeyHashForRow(\n                rowId,\n                keyHash,\n                replayed.snapshot,\n                \"source:success\",\n                `source:${fieldPath}:${rowId}:success`,\n                \"success\",\n              )\n            } else if (replayed.phase === \"error\") {\n              yield* writebackIfCurrentKeyHashForRow(\n                rowId,\n                keyHash,\n                replayed.snapshot,\n                \"source:error\",\n                `source:${fieldPath}:${rowId}:error`,\n                \"error\",\n              )\n            }\n\n            return yield* Effect.void\n          }\n\n          const stack = yield* getMiddlewareStack()\n\n          const registryOpt = yield* Effect.serviceOption(ResourceInternal.ResourceRegistryTag)\n          const registry = Option.isSome(registryOpt) ? registryOpt.value : undefined\n          const spec = registry?.specs.get(resourceId)\n\n          if (!spec) {\n            return yield* Effect.void\n          }\n\n          const loadEffect = (spec.load as any)(key) as Effect.Effect<any, any, any>\n\n          const meta: any = {\n            moduleId,\n            instanceId,\n            fieldPath,\n            resourceId,\n            key,\n            keyHash,\n            rowId,\n            traitNodeId: step.debugInfo?.graphNodeId,\n            stepId: step.id,\n          }\n\n          if (!(typeof meta.opSeq === \"number\" && Number.isFinite(meta.opSeq))) {\n            const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n            if (Option.isSome(sessionOpt)) {\n              const seqKey = instanceId ?? \"global\"\n              meta.opSeq = sessionOpt.value.local.nextSeq(\"opSeq\", seqKey)\n            }\n          }\n\n          const op = EffectOp.make<any, any, any>({\n            kind: \"service\",\n            name: resourceId,\n            effect: loadEffect,\n            meta,\n          })\n\n          const exit = yield* Effect.exit(EffectOp.run(op, stack))\n\n          if (exit._tag === \"Success\") {\n            const successSnapshot = Snapshot.success({ keyHash, data: exit.value })\n            const wroteSuccessPath = yield* writebackIfCurrentKeyHashForRow(\n              rowId,\n              keyHash,\n              successSnapshot,\n              \"source:success\",\n              `source:${fieldPath}:${rowId}:success`,\n              \"success\",\n            )\n            if (wroteSuccessPath) {\n              yield* recordSnapshot(replayMode, replayLog, {\n                _tag: \"ResourceSnapshot\",\n                resourceId,\n                fieldPath: wroteSuccessPath,\n                keyHash,\n                concurrency: mode,\n                phase: \"success\",\n                snapshot: successSnapshot,\n                timestamp: Date.now(),\n                moduleId,\n                instanceId,\n              })\n            }\n          } else {\n            const errorSnapshot = Snapshot.error({ keyHash, error: exit.cause })\n            const wroteErrorPath = yield* writebackIfCurrentKeyHashForRow(\n              rowId,\n              keyHash,\n              errorSnapshot,\n              \"source:error\",\n              `source:${fieldPath}:${rowId}:error`,\n              \"error\",\n            )\n            if (wroteErrorPath) {\n              yield* recordSnapshot(replayMode, replayLog, {\n                _tag: \"ResourceSnapshot\",\n                resourceId,\n                fieldPath: wroteErrorPath,\n                keyHash,\n                concurrency: mode,\n                phase: \"error\",\n                snapshot: errorSnapshot,\n                timestamp: Date.now(),\n                moduleId,\n                instanceId,\n              })\n            }\n          }\n        }).pipe(Effect.catchAllCause(() => Effect.void))\n\n        // list.item\uFF1AIO fiber \u5FC5\u987B\u8131\u79BB\u540C\u6B65\u4E8B\u52A1 FiberRef\uFF0C\u5426\u5219\u4F1A\u88AB\u8BEF\u5224\u4E3A\u201C\u4E8B\u52A1\u7A97\u53E3\u5185\u201D\uFF0C\u4ECE\u800C\u963B\u65AD\u540E\u7EED\u5199\u56DE\u5165\u53E3\u3002\n        const fiber = yield* Effect.forkScoped(\n          Effect.locally(TaskRunner.inSyncTransactionFiber, false)(io),\n        )\n        const myGen = (gen += 1)\n        inFlight.set(rowId, { gen: myGen, fiber, keyHash })\n\n        yield* Effect.forkScoped(\n          Effect.locally(TaskRunner.inSyncTransactionFiber, false)(\n            Fiber.await(fiber).pipe(\n              Effect.zipRight(\n                Effect.sync(() => {\n                  const current = inFlight.get(rowId)\n                  if (current && current.gen === myGen) {\n                    inFlight.delete(rowId)\n                  }\n                }),\n              ),\n              Effect.zipRight(\n                mode === \"exhaust-trailing\"\n                  ? Effect.gen(function* () {\n                      const next = trailing.get(rowId)\n                      trailing.delete(rowId)\n                      if (next) {\n                        yield* startFetch(\n                          rowId,\n                          next.key,\n                          next.keyHash,\n                          replayMode,\n                          replayLog,\n                        )\n                      }\n                    })\n                  : Effect.void,\n              ),\n              Effect.catchAllCause(() => Effect.void),\n            ),\n          ),\n        )\n      })\n\n    register(fieldPath, (state: any) =>\n      Effect.gen(function* () {\n        const { moduleId, instanceId } = getBoundScope(bound)\n        const replayModeOpt = yield* Effect.serviceOption(ReplayModeConfigTag)\n        const replayMode = Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : \"live\"\n        const replayLogOpt = yield* Effect.serviceOption(ReplayLog.ReplayLog)\n        const replayLog = Option.isSome(replayLogOpt) ? replayLogOpt.value : undefined\n        const force = yield* FiberRef.get(TaskRunner.forceSourceRefresh)\n\n        const listValue = RowId.getAtPath(state, listPath)\n        const items: ReadonlyArray<unknown> = Array.isArray(listValue) ? listValue : []\n        const ids = store.ensureList(listPath, items)\n\n        // dev-mode\uFF1A\u5BF9\u9996\u884C\u505A\u4E00\u6B21 deps trace\uFF08\u53EA\u505A\u8BCA\u65AD\uFF0C\u4E0D\u5F71\u54CD\u6267\u884C\u8BED\u4E49\uFF09\u3002\n        const traceKey = `${instanceId ?? \"unknown\"}::source::${fieldPath}`\n        if (isDevEnv() && (yield* onceInRunSession(`deps_trace_settled:${traceKey}`))) {\n          try {\n            const sample = items[0]\n            if (sample !== undefined) {\n              const traced = DepsTrace.trace((s) => (entry.meta as any).key(s), sample as any)\n              const prefixedReads = traced.reads.map((r) =>\n                r ? `${listPath}[].${r}` : `${listPath}[]`,\n              )\n              const diff = DepsTrace.diffDeps(\n                ((entry.meta as any).deps ?? []) as ReadonlyArray<string>,\n                prefixedReads,\n              )\n              if (diff) {\n                yield* emitDepsMismatch({\n                  moduleId,\n                  instanceId,\n                  kind: \"source\",\n                  fieldPath,\n                  diff,\n                })\n              }\n            }\n          } catch {\n            // tracing failure should never break refresh flow\n          }\n        }\n\n        for (let index = 0; index < items.length; index++) {\n          const rowId = ids[index]\n          if (!rowId) continue\n\n          const concretePath = RowId.toListItemValuePath(listPath, index, itemPath)\n          const prevSnapshot = RowId.getAtPath(state, concretePath) as any\n\n          let key: unknown\n          try {\n            key = (entry.meta as any).key(items[index])\n          } catch {\n            key = undefined\n          }\n\n          const current = inFlight.get(rowId)\n\n          if (key === undefined) {\n            trailing.delete(rowId)\n            inFlight.delete(rowId)\n\n            // \u82E5\u5DF2\u662F clean idle\uFF0C\u5219\u65E0\u9700\u91CD\u590D\u5199\u56DE\uFF08\u907F\u514D\u65E0\u610F\u4E49 patch \u5BFC\u81F4 UI \u6296\u52A8\uFF09\u3002\n            if (\n              prevSnapshot &&\n              typeof prevSnapshot === \"object\" &&\n              prevSnapshot.status === \"idle\" &&\n              prevSnapshot.data === undefined &&\n              prevSnapshot.error === undefined\n            ) {\n              continue\n            }\n\n            const idleSnapshot = Snapshot.idle()\n            const wroteIdlePath = yield* setSnapshotForRowInTxn(\n              rowId,\n              idleSnapshot,\n              \"source:idle\",\n              `source:${fieldPath}:${rowId}:idle`,\n            )\n            if (wroteIdlePath) {\n              const event: ReplayLog.ReplayLogEvent = {\n                _tag: \"ResourceSnapshot\",\n                resourceId,\n                fieldPath: wroteIdlePath,\n                keyHash: undefined,\n                concurrency: mode,\n                phase: \"idle\",\n                snapshot: idleSnapshot,\n                timestamp: Date.now(),\n                moduleId,\n                instanceId,\n              }\n              recordReplayEvent(bound, event)\n              yield* recordSnapshot(replayMode, replayLog, event)\n            }\n            continue\n          }\n\n          const h = hashKey(key)\n\n          // keyHash \u672A\u53D8\u5316\uFF1A\u907F\u514D\u65E0\u610F\u4E49\u91CD\u590D\u5237\u65B0\uFF08\u540C\u65F6\u4FDD\u4F4F in-flight\uFF09\u3002\n          if (!force && current && current.keyHash === h) {\n            continue\n          }\n\n          // \u975E in-flight\uFF1A\u82E5\u5F53\u524D snapshot.keyHash \u5DF2\u5339\u914D\uFF0C\u5219\u89C6\u4E3A\u5DF2\u662F\u6700\u65B0\u6570\u636E\uFF08\u907F\u514D\u5168\u91CF refresh \u9020\u6210\u6240\u6709\u884C\u6296\u52A8\uFF09\u3002\n          const prevKeyHash =\n            prevSnapshot && typeof prevSnapshot === \"object\"\n              ? (prevSnapshot as any).keyHash\n              : undefined\n          if (!force && !current && prevKeyHash === h) {\n            continue\n          }\n\n          if (mode === \"exhaust-trailing\" && current) {\n            trailing.set(rowId, { key, keyHash: h })\n            const loadingSnapshot = Snapshot.loading({ keyHash: h })\n            const wroteLoadingPath = yield* setSnapshotForRowInTxn(\n              rowId,\n              loadingSnapshot,\n              \"source:loading\",\n              `source:${fieldPath}:${rowId}:loading`,\n            )\n            if (wroteLoadingPath) {\n              const event: ReplayLog.ReplayLogEvent = {\n                _tag: \"ResourceSnapshot\",\n                resourceId,\n                fieldPath: wroteLoadingPath,\n                keyHash: h,\n                concurrency: mode,\n                phase: \"loading\",\n                snapshot: loadingSnapshot,\n                timestamp: Date.now(),\n                moduleId,\n                instanceId,\n              }\n              recordReplayEvent(bound, event)\n              yield* recordSnapshot(replayMode, replayLog, event)\n            }\n            continue\n          }\n\n          if (mode === \"switch\" && current) {\n            // \u4E0D\u4F9D\u8D56\u53D6\u6D88\u6B63\u786E\u6027\uFF1A\u65E7\u7ED3\u679C\u5199\u56DE\u4F1A\u88AB keyHash gate \u4E22\u5F03\u3002\n            trailing.delete(rowId)\n            inFlight.delete(rowId)\n          }\n\n          yield* startFetch(rowId, key, h, replayMode, replayLog)\n        }\n      }),\n    )\n\n    return Effect.void\n  }\n\n  // in-flight state (per field)\n  let inFlight:\n    | {\n        readonly gen: number\n        readonly fiber: Fiber.RuntimeFiber<void, never>\n        readonly keyHash: string\n      }\n    | undefined\n  let gen = 0\n  let trailing: { readonly key: unknown; readonly keyHash: string } | undefined\n\n  const concurrency = (entry.meta as any).concurrency as\n    | \"switch\"\n    | \"exhaust-trailing\"\n    | undefined\n  const mode = concurrency ?? \"switch\"\n\n  const startFetch = (\n    key: unknown,\n    keyHash: string,\n    replayMode: \"live\" | \"replay\",\n    replayLog: ReplayLog.ReplayLogService | undefined,\n  ): Effect.Effect<void, never, any> =>\n    Effect.gen(function* () {\n      const { moduleId, instanceId } = getBoundScope(bound)\n\n      // 1) pending\uFF1A\u540C\u6B65\u5199\u5165 loading snapshot\uFF08\u843D\u5728\u5F53\u524D\u4E8B\u52A1\u7A97\u53E3\uFF09\u3002\n      let loadingSnapshot: unknown = Snapshot.loading({ keyHash })\n      if (replayMode === \"replay\" && replayLog) {\n        const replayLoading = yield* replayLog.consumeNextResourceSnapshot({\n          resourceId,\n          fieldPath,\n          keyHash,\n          phase: \"loading\",\n        })\n        if (replayLoading) {\n          loadingSnapshot = replayLoading.snapshot\n        }\n      }\n      const wroteLoading = yield* setSnapshotInTxn(\n        bound,\n        fieldPath,\n        loadingSnapshot,\n        \"source:loading\",\n        `source:${fieldPath}:loading`,\n        step.debugInfo?.graphNodeId,\n      )\n      if (wroteLoading) {\n        const event: ReplayLog.ReplayLogEvent = {\n          _tag: \"ResourceSnapshot\",\n          resourceId,\n          fieldPath,\n          keyHash,\n          concurrency: mode,\n          phase: \"loading\",\n          snapshot: loadingSnapshot,\n          timestamp: Date.now(),\n          moduleId,\n          instanceId,\n        }\n        recordReplayEvent(bound, event)\n        yield* recordSnapshot(replayMode, replayLog, event)\n      }\n\n      // 2) IO\uFF1A\u5728\u540E\u53F0 fiber \u4E2D\u8FD0\u884C\uFF08\u907F\u514D\u963B\u585E\u5F53\u524D\u4E8B\u52A1\uFF09\u3002\n      const io = Effect.gen(function* () {\n        if (replayMode === \"replay\" && replayLog) {\n          // \u8BA9 loading \u63D0\u4EA4\u5148\u53EF\u89C1\uFF0C\u518D\u91CD\u8D5B\u7EC8\u6001\uFF08\u4FDD\u6301\u201C\u5F02\u6B65\u8D44\u6E90\u201D\u7684\u65F6\u95F4\u7EBF\u7ED3\u6784\uFF09\u3002\n          yield* Effect.yieldNow()\n          const replayed = yield* replayLog.consumeNextResourceSnapshot({\n            resourceId,\n            fieldPath,\n            keyHash,\n          })\n          if (!replayed) return yield* Effect.void\n\n          if (replayed.phase === \"success\") {\n            const event: ReplayLog.ReplayLogEvent = {\n              _tag: \"ResourceSnapshot\",\n              resourceId,\n              fieldPath,\n              keyHash,\n              concurrency: mode,\n              phase: \"success\",\n              snapshot: replayed.snapshot,\n              timestamp: Date.now(),\n              moduleId,\n              instanceId,\n            }\n            yield* writebackIfCurrentKeyHash(\n              bound,\n              fieldPath,\n              keyHash,\n              replayed.snapshot,\n              \"source:success\",\n              `source:${fieldPath}:success`,\n              step.debugInfo?.graphNodeId,\n              event,\n            )\n          } else if (replayed.phase === \"error\") {\n            const event: ReplayLog.ReplayLogEvent = {\n              _tag: \"ResourceSnapshot\",\n              resourceId,\n              fieldPath,\n              keyHash,\n              concurrency: mode,\n              phase: \"error\",\n              snapshot: replayed.snapshot,\n              timestamp: Date.now(),\n              moduleId,\n              instanceId,\n            }\n            yield* writebackIfCurrentKeyHash(\n              bound,\n              fieldPath,\n              keyHash,\n              replayed.snapshot,\n              \"source:error\",\n              `source:${fieldPath}:error`,\n              step.debugInfo?.graphNodeId,\n              event,\n            )\n          }\n\n          return yield* Effect.void\n        }\n\n        const stack = yield* getMiddlewareStack()\n\n        const registryOpt = yield* Effect.serviceOption(\n          ResourceInternal.ResourceRegistryTag,\n        )\n        const registry = Option.isSome(registryOpt) ? registryOpt.value : undefined\n        const spec = registry?.specs.get(resourceId)\n\n        if (!spec) {\n          return yield* Effect.void\n        }\n\n        const loadEffect = (spec.load as any)(key) as Effect.Effect<any, any, any>\n\n        const meta: any = {\n          moduleId,\n          instanceId,\n          fieldPath,\n          resourceId,\n          key,\n          keyHash,\n          traitNodeId: step.debugInfo?.graphNodeId,\n          stepId: step.id,\n        }\n\n        if (!(typeof meta.opSeq === \"number\" && Number.isFinite(meta.opSeq))) {\n          const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n          if (Option.isSome(sessionOpt)) {\n            const seqKey = instanceId ?? \"global\"\n            meta.opSeq = sessionOpt.value.local.nextSeq(\"opSeq\", seqKey)\n          }\n        }\n\n        const op = EffectOp.make<any, any, any>({\n          kind: \"trait-source\",\n          name: resourceId,\n          effect: loadEffect,\n          meta,\n        })\n\n        const exit = yield* Effect.exit(EffectOp.run(op, stack))\n\n        // 3) writeback\uFF1A\u4EE5 keyHash gate \u9632\u6B62\u65E7\u7ED3\u679C\u56DE\u5199\u5230\u65B0 key \u4E0A\u3002\n        if (exit._tag === \"Success\") {\n          const successSnapshot = Snapshot.success({ keyHash, data: exit.value })\n          const event: ReplayLog.ReplayLogEvent = {\n            _tag: \"ResourceSnapshot\",\n            resourceId,\n            fieldPath,\n            keyHash,\n            concurrency: mode,\n            phase: \"success\",\n            snapshot: successSnapshot,\n            timestamp: Date.now(),\n            moduleId,\n            instanceId,\n          }\n          const wroteSuccess = yield* writebackIfCurrentKeyHash(\n            bound,\n            fieldPath,\n            keyHash,\n            successSnapshot,\n            \"source:success\",\n            `source:${fieldPath}:success`,\n            step.debugInfo?.graphNodeId,\n            event,\n          )\n          if (wroteSuccess) {\n            yield* recordSnapshot(replayMode, replayLog, event)\n          }\n        } else {\n          const errorSnapshot = Snapshot.error({ keyHash, error: exit.cause })\n          const event: ReplayLog.ReplayLogEvent = {\n            _tag: \"ResourceSnapshot\",\n            resourceId,\n            fieldPath,\n            keyHash,\n            concurrency: mode,\n            phase: \"error\",\n            snapshot: errorSnapshot,\n            timestamp: Date.now(),\n            moduleId,\n            instanceId,\n          }\n          const wroteError = yield* writebackIfCurrentKeyHash(\n            bound,\n            fieldPath,\n            keyHash,\n            errorSnapshot,\n            \"source:error\",\n            `source:${fieldPath}:error`,\n            step.debugInfo?.graphNodeId,\n            event,\n          )\n          if (wroteError) {\n            yield* recordSnapshot(replayMode, replayLog, event)\n          }\n        }\n      }).pipe(\n        Effect.catchAllCause(() => Effect.void),\n      )\n\n      // \u4E0D\u7B49\u5F85 IO \u5B8C\u6210\uFF1AforkScoped \u6302\u5230 runtime scope\uFF0C\u4FDD\u8BC1\u5378\u8F7D\u65F6\u81EA\u52A8 interrupt\u3002\n      const fiber = yield* Effect.forkScoped(\n        Effect.locally(TaskRunner.inSyncTransactionFiber, false)(io),\n      )\n      const myGen = (gen += 1)\n      inFlight = { gen: myGen, fiber, keyHash }\n\n      // in-flight \u7ED3\u675F\u540E\u6E05\u7406\uFF0C\u5E76\u5728 exhaust-trailing \u6A21\u5F0F\u4E0B\u8865\u8DD1\u4E00\u6B21 trailing\u3002\n      yield* Effect.forkScoped(\n        Effect.locally(TaskRunner.inSyncTransactionFiber, false)(\n          Fiber.await(fiber).pipe(\n            Effect.zipRight(\n              Effect.sync(() => {\n                if (inFlight && inFlight.gen === myGen) {\n                  inFlight = undefined\n                }\n              }),\n            ),\n            Effect.zipRight(\n              mode === \"exhaust-trailing\"\n                ? Effect.gen(function* () {\n                    const next = trailing\n                    trailing = undefined\n                    if (next) {\n                      yield* startFetch(\n                        next.key,\n                        next.keyHash,\n                        replayMode,\n                        replayLog,\n                      )\n                    }\n                  })\n                : Effect.void,\n            ),\n            Effect.catchAllCause(() => Effect.void),\n          ),\n        ),\n      )\n    })\n\n    register(fieldPath, (state: any) =>\n      Effect.gen(function* () {\n        const { moduleId, instanceId } = getBoundScope(bound)\n        const replayModeOpt = yield* Effect.serviceOption(ReplayModeConfigTag)\n        const replayMode = Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : \"live\"\n        const replayLogOpt = yield* Effect.serviceOption(ReplayLog.ReplayLog)\n        const replayLog = Option.isSome(replayLogOpt) ? replayLogOpt.value : undefined\n        const force = yield* FiberRef.get(TaskRunner.forceSourceRefresh)\n\n        let key: unknown\n        try {\n          key = (entry.meta as any).key(state)\n        } catch {\n          key = undefined\n        }\n\n      // dev-mode\uFF1A\u4FA6\u6D4B keySelector \u7684\u5B9E\u9645\u8BFB\u53D6\u8DEF\u5F84\u4E0E\u58F0\u660E deps \u7684\u5DEE\u5F02\uFF08\u4EC5\u505A\u8BCA\u65AD\uFF0C\u4E0D\u5F71\u54CD\u6267\u884C\u8BED\u4E49\uFF09\u3002\n      const traceKey = `${instanceId ?? \"unknown\"}::source::${fieldPath}`\n      if (isDevEnv() && (yield* onceInRunSession(`deps_trace_settled:${traceKey}`))) {\n        try {\n          const traced = DepsTrace.trace((s) => (entry.meta as any).key(s), state)\n          const diff = DepsTrace.diffDeps(\n            ((entry.meta as any).deps ?? []) as ReadonlyArray<string>,\n            traced.reads,\n          )\n          if (diff) {\n            yield* emitDepsMismatch({\n              moduleId,\n              instanceId,\n              kind: \"source\",\n              fieldPath,\n              diff,\n            })\n          }\n        } catch {\n          // tracing failure should never break refresh flow\n        }\n      }\n\n      // key \u53D8\u7A7A\uFF1A\u540C\u6B65 idle \u6E05\u7A7A\uFF08\u5E76\u4E2D\u65AD in-flight\uFF09\u3002\n      if (key === undefined) {\n        if (inFlight) {\n          yield* Fiber.interruptFork(inFlight.fiber)\n          inFlight = undefined\n        }\n        trailing = undefined\n\n        const idleSnapshot = Snapshot.idle()\n        const wroteIdle = yield* setSnapshotInTxn(\n          bound,\n          fieldPath,\n          idleSnapshot,\n          \"source:idle\",\n          `source:${fieldPath}:idle`,\n          step.debugInfo?.graphNodeId,\n        )\n      if (wroteIdle) {\n        const event: ReplayLog.ReplayLogEvent = {\n          _tag: \"ResourceSnapshot\",\n          resourceId,\n          fieldPath,\n          keyHash: undefined,\n          concurrency: mode,\n          phase: \"idle\",\n          snapshot: idleSnapshot,\n          timestamp: Date.now(),\n          moduleId,\n          instanceId,\n          }\n          recordReplayEvent(bound, event)\n          yield* recordSnapshot(replayMode, replayLog, event)\n        }\n        return\n      }\n\n      const h = hashKey(key)\n\n      // \u9ED8\u8BA4\u8BED\u4E49\uFF1A\u540C\u4E00 keyHash \u5DF2\u6709\u975E idle \u5FEB\u7167\u65F6\uFF0Crefresh \u5C3D\u91CF no-op\uFF08\u907F\u514D\u91CD\u590D IO/\u5199\u56DE\uFF09\u3002\n      // \u663E\u5F0F refresh / invalidate \u53EF\u901A\u8FC7 force \u7ED5\u8FC7\u8BE5\u4F18\u5316\u3002\n      if (!force) {\n        if (inFlight && inFlight.keyHash === h) {\n          return\n        }\n\n        const currentSnapshot = RowId.getAtPath(state, fieldPath) as any\n        const currentKeyHash =\n          currentSnapshot && typeof currentSnapshot === \"object\"\n            ? (currentSnapshot as any).keyHash\n            : undefined\n        const currentStatus =\n          currentSnapshot && typeof currentSnapshot === \"object\"\n            ? (currentSnapshot as any).status\n            : undefined\n        if (currentStatus && currentStatus !== \"idle\" && currentKeyHash === h) {\n          return\n        }\n      }\n\n      if (mode === \"exhaust-trailing\" && inFlight) {\n        // \u5FD9\u788C\u65F6\uFF1A\u8BB0\u5F55 trailing\uFF0C\u5E76\u7ACB\u5373\u66F4\u65B0\u5230\u6700\u65B0 loading\uFF08\u65E7 in-flight \u5199\u56DE\u4F1A\u88AB keyHash gate \u62E6\u4F4F\uFF09\u3002\n        trailing = { key, keyHash: h }\n        const loadingSnapshot = Snapshot.loading({ keyHash: h })\n        const wroteLoading = yield* setSnapshotInTxn(\n          bound,\n          fieldPath,\n          loadingSnapshot,\n          \"source:loading\",\n          `source:${fieldPath}:loading`,\n          step.debugInfo?.graphNodeId,\n        )\n      if (wroteLoading) {\n        const event: ReplayLog.ReplayLogEvent = {\n          _tag: \"ResourceSnapshot\",\n          resourceId,\n          fieldPath,\n          keyHash: h,\n          concurrency: mode,\n          phase: \"loading\",\n          snapshot: loadingSnapshot,\n          timestamp: Date.now(),\n          moduleId,\n          instanceId,\n          }\n          recordReplayEvent(bound, event)\n          yield* recordSnapshot(replayMode, replayLog, event)\n        }\n        return\n      }\n\n      if (mode === \"switch\" && inFlight) {\n        yield* Fiber.interruptFork(inFlight.fiber)\n        inFlight = undefined\n        trailing = undefined\n      }\n\n      // start fetch (pending tx + fork IO)\n      yield* startFetch(key, h, replayMode, replayLog)\n    }),\n  )\n\n  return Effect.void\n}\n", "export interface DepsTraceResult<T> {\n  readonly value: T\n  readonly reads: ReadonlyArray<string>\n}\n\nexport interface DepsDiff {\n  readonly reads: ReadonlyArray<string>\n  readonly declared: ReadonlyArray<string>\n  readonly missing: ReadonlyArray<string>\n  readonly unused: ReadonlyArray<string>\n}\n\nconst isTraceableObject = (value: unknown): value is object => {\n  if (!value || typeof value !== \"object\") return false\n  if (Array.isArray(value)) return true\n  if (value instanceof Date) return false\n  if (value instanceof RegExp) return false\n  if (value instanceof Error) return false\n  if (value instanceof Map) return false\n  if (value instanceof Set) return false\n  if (value instanceof WeakMap) return false\n  if (value instanceof WeakSet) return false\n  return true\n}\n\nconst shouldIgnoreKey = (key: string): boolean =>\n  key === \"__proto__\" || key === \"prototype\" || key === \"constructor\"\n\nconst normalizeReads = (reads: ReadonlySet<string>): ReadonlyArray<string> => {\n  const all = Array.from(reads).filter((p) => typeof p === \"string\" && p.length > 0)\n  all.sort()\n\n  // \u53BB\u6389\u4E25\u683C\u524D\u7F00\u8DEF\u5F84\uFF08\u4F8B\u5982\u540C\u65F6\u8BFB\u4E86 profile \u4E0E profile.id \u65F6\uFF0C\u53EA\u4FDD\u7559\u66F4\u5177\u4F53\u7684 profile.id\uFF09\u3002\n  const isPrefix = (prefix: string, full: string): boolean =>\n    full !== prefix && full.startsWith(prefix + \".\")\n\n  const pruned: Array<string> = []\n  for (const p of all) {\n    let hasMoreSpecific = false\n    for (const other of all) {\n      if (isPrefix(p, other)) {\n        hasMoreSpecific = true\n        break\n      }\n    }\n    if (!hasMoreSpecific) {\n      pruned.push(p)\n    }\n  }\n\n  pruned.sort()\n  return pruned\n}\n\nconst covers = (declared: string, read: string): boolean =>\n  declared === read || read.startsWith(declared + \".\")\n\nexport const diffDeps = (\n  declared: ReadonlyArray<string>,\n  reads: ReadonlyArray<string>,\n): DepsDiff | undefined => {\n  const declaredList = Array.from(new Set(declared)).filter((p) => typeof p === \"string\" && p.length > 0)\n  declaredList.sort()\n  const readList = Array.from(new Set(reads)).filter((p) => typeof p === \"string\" && p.length > 0)\n  readList.sort()\n\n  const missing = readList.filter((r) => declaredList.every((d) => !covers(d, r)))\n  const unused = declaredList.filter((d) => readList.every((r) => !covers(d, r)))\n\n  if (missing.length === 0 && unused.length === 0) return undefined\n\n  return {\n    reads: readList,\n    declared: declaredList,\n    missing,\n    unused,\n  }\n}\n\nexport const trace = <T>(\n  fn: (state: any) => T,\n  state: unknown,\n): DepsTraceResult<T> => {\n  if (!isTraceableObject(state)) {\n    return { value: fn(state as any), reads: [] }\n  }\n\n  const reads = new Set<string>()\n\n  // per-trace caches to preserve reference identity within the traced call.\n  const proxyCache = new WeakMap<object, Map<string, any>>()\n  const proxyToTarget = new WeakMap<object, object>()\n\n  const wrap = (value: unknown, path: string): unknown => {\n    if (!isTraceableObject(value)) return value\n    return getProxy(value as any, path)\n  }\n\n  const unwrap = <V>(value: V): V => {\n    if (value && (typeof value === \"object\" || typeof value === \"function\")) {\n      const target = proxyToTarget.get(value as any)\n      if (target) return target as any as V\n    }\n    return value\n  }\n\n  const getProxy = (target: object, basePath: string): any => {\n    let byPath = proxyCache.get(target)\n    if (!byPath) {\n      byPath = new Map()\n      proxyCache.set(target, byPath)\n    }\n\n    const cached = byPath.get(basePath)\n    if (cached) return cached\n\n    const record = (path: string) => {\n      if (path) reads.add(path)\n    }\n\n    const proxy = new Proxy(target as any, {\n      get: (t, prop, receiver) => {\n        if (typeof prop === \"symbol\") {\n          return Reflect.get(t, prop, receiver)\n        }\n        const key = String(prop)\n        if (shouldIgnoreKey(key)) {\n          return Reflect.get(t, prop, receiver)\n        }\n\n        const nextPath = basePath ? `${basePath}.${key}` : key\n        record(nextPath)\n\n        const value = Reflect.get(t, prop, receiver) as unknown\n        return wrap(value, nextPath)\n      },\n      has: (t, prop) => {\n        if (typeof prop === \"symbol\") return Reflect.has(t, prop)\n        const key = String(prop)\n        if (!shouldIgnoreKey(key)) {\n          const nextPath = basePath ? `${basePath}.${key}` : key\n          record(nextPath)\n        }\n        return Reflect.has(t, prop)\n      },\n      ownKeys: (t) => {\n        if (basePath) record(basePath)\n        return Reflect.ownKeys(t)\n      },\n      getOwnPropertyDescriptor: (t, prop) => {\n        if (typeof prop === \"symbol\") {\n          return Reflect.getOwnPropertyDescriptor(t, prop)\n        }\n        const key = String(prop)\n        if (!shouldIgnoreKey(key)) {\n          const nextPath = basePath ? `${basePath}.${key}` : key\n          record(nextPath)\n        }\n        return Reflect.getOwnPropertyDescriptor(t, prop)\n      },\n      set: () => {\n        throw new Error(\n          \"[deps-trace] Attempted to mutate state during deps tracing (state is readonly in dev-mode diagnostics).\",\n        )\n      },\n      defineProperty: () => {\n        throw new Error(\n          \"[deps-trace] Attempted to define property on state during deps tracing (state is readonly in dev-mode diagnostics).\",\n        )\n      },\n      deleteProperty: () => {\n        throw new Error(\n          \"[deps-trace] Attempted to delete property on state during deps tracing (state is readonly in dev-mode diagnostics).\",\n        )\n      },\n    })\n\n    byPath.set(basePath, proxy)\n    proxyToTarget.set(proxy, target)\n    return proxy\n  }\n\n  const root = getProxy(state as any, \"\")\n  const value = unwrap(fn(root))\n\n  return {\n    value,\n    reads: normalizeReads(reads),\n  }\n}\n\n"],
  "mappings": "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",
  "names": ["value", "record", "keyHash", "key", "prev", "prevStatus", "concurrency", "mode", "inFlight", "trailing", "gen", "startFetch"]
}
