@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,1991 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  ReplayLog,
+  getAtPath,
+  parseListItemFieldPath,
+  setAtPathMutating,
+  toListItemValuePath
+} from "./chunk-C2MYMMO4.js";
+import {
+  Snapshot,
+  internal,
+  keyHash
+} from "./chunk-EZTMVCJF.js";
+import {
+  create
+} from "./chunk-KE2H62D6.js";
+import {
+  mergeCanonical,
+  sanitize
+} from "./chunk-X2Z5VYG3.js";
+import {
+  compareFieldPath,
+  getFieldPathId,
+  makeFieldPathIdRegistry,
+  normalizeFieldPath
+} from "./chunk-ASVMK364.js";
+import {
+  getBoundInternals
+} from "./chunk-7GPAF2UK.js";
+import {
+  ReplayModeConfigTag,
+  forceSourceRefresh,
+  inSyncTransactionFiber,
+  isDevEnv
+} from "./chunk-YMVMZA3U.js";
+import {
+  RunSessionTag,
+  make,
+  run
+} from "./chunk-W365QUZ5.js";
+import {
+  currentDiagnosticsLevel,
+  record
+} from "./chunk-SH7TP5CJ.js";
+import {
+  EffectOpMiddlewareTag
+} from "./chunk-SI5OKFFY.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-DT7YIIWE.js";
+
+// ../logix-core/src/internal/state-trait/build.ts
+import * as SchemaAST from "../effect/SchemaAST.js";
+
+// ../logix-core/src/internal/state-trait/model.ts
+var normalizeSpec = (spec) => {
+  const entries = [];
+  const isNode = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitNode";
+  const isList = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitList";
+  const joinPath = (prefix, suffix) => {
+    if (!prefix) return suffix;
+    if (!suffix) return prefix;
+    return `${prefix}.${suffix}`;
+  };
+  const prefixDeps = (deps, prefix) => {
+    if (!deps || deps.length === 0) return [];
+    return deps.map((d) => prefix ? joinPath(prefix, d) : d);
+  };
+  const normalizeEntry = (entry, fieldPath, depPrefix) => {
+    if (entry.kind === "computed") {
+      const meta = entry.meta;
+      const rawDeps = meta.deps;
+      const deps = rawDeps !== void 0 ? prefixDeps(rawDeps, depPrefix) : void 0;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, deps }
+      };
+    }
+    if (entry.kind === "source") {
+      const meta = entry.meta;
+      const rawDeps = meta.deps;
+      const deps = rawDeps !== void 0 ? prefixDeps(rawDeps, depPrefix) : void 0;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, deps, _fieldPath: fieldPath }
+      };
+    }
+    if (entry.kind === "externalStore") {
+      const meta = entry.meta;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, _fieldPath: fieldPath }
+      };
+    }
+    if (entry.kind === "link") {
+      const meta = entry.meta;
+      const from = prefixDeps([meta.from], depPrefix)[0] ?? meta.from;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, from }
+      };
+    }
+    return {
+      ...entry,
+      fieldPath
+    };
+  };
+  const expandNode = (scopeId, joinPrefix, node, options) => {
+    const addEntry = (relativeTarget, raw) => {
+      const rel = raw.fieldPath ?? relativeTarget;
+      const fieldPath = joinPrefix ? joinPath(joinPrefix, String(rel)) : String(rel);
+      entries.push(normalizeEntry(raw, fieldPath, joinPrefix));
+    };
+    const expandMaybeRecord = (value) => {
+      if (!value) return;
+      if (typeof value.kind === "string") {
+        addEntry("", value);
+        return;
+      }
+      const record2 = value;
+      for (const key in record2) {
+        if (!Object.prototype.hasOwnProperty.call(record2, key)) continue;
+        const entry = record2[key];
+        if (!entry) continue;
+        addEntry(key, entry);
+      }
+    };
+    expandMaybeRecord(node.computed);
+    expandMaybeRecord(node.source);
+    expandMaybeRecord(node.link);
+    expandMaybeRecord(node.externalStore);
+    if (node.check) {
+      const rules = {};
+      const checkDepsPrefix = options?.checkDepsPrefix ?? (joinPrefix.endsWith("[]") ? joinPrefix : "");
+      const prefixCheckDeps = (deps) => {
+        if (!deps || deps.length === 0) return [];
+        return deps.map((d) => d === "" ? scopeId : checkDepsPrefix ? joinPath(checkDepsPrefix, d) : d);
+      };
+      for (const name of Object.keys(node.check)) {
+        const rule = node.check[name];
+        if (typeof rule === "function") {
+          rules[name] = rule;
+          continue;
+        }
+        if (rule && typeof rule === "object") {
+          const meta = sanitize(rule.meta);
+          rules[name] = {
+            ...rule,
+            deps: prefixCheckDeps(rule.deps),
+            meta
+          };
+          continue;
+        }
+      }
+      entries.push({
+        fieldPath: scopeId,
+        kind: "check",
+        meta: {
+          rules,
+          writeback: { kind: "errors" }
+        }
+      });
+    }
+  };
+  for (const key in spec) {
+    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue;
+    const raw = spec[key];
+    if (!raw) continue;
+    if (isList(raw)) {
+      const listPath = key;
+      if (raw.item) {
+        expandNode(`${listPath}[]`, `${listPath}[]`, raw.item);
+      }
+      if (raw.list) {
+        expandNode(listPath, listPath, raw.list, {
+          checkDepsPrefix: `${listPath}[]`
+        });
+      }
+      continue;
+    }
+    if (isNode(raw)) {
+      if (key === "$root") {
+        expandNode("$root", "", raw);
+      } else {
+        expandNode(key, key, raw);
+      }
+      continue;
+    }
+    const entry = raw;
+    const fieldPath = entry.fieldPath ?? key;
+    entries.push(normalizeEntry(entry, String(fieldPath), ""));
+  }
+  return entries;
+};
+var collectNodeMeta = (spec) => {
+  const out = /* @__PURE__ */ new Map();
+  const isNode = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitNode";
+  const isList = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitList";
+  const add = (scopeId, node) => {
+    const meta = sanitize(node.meta);
+    if (meta) out.set(scopeId, meta);
+  };
+  for (const key in spec) {
+    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue;
+    const raw = spec[key];
+    if (!raw) continue;
+    if (isList(raw)) {
+      const listPath = key;
+      if (raw.item) add(`${listPath}[]`, raw.item);
+      if (raw.list) add(listPath, raw.list);
+      continue;
+    }
+    if (isNode(raw)) {
+      if (key === "$root") add("$root", raw);
+      else add(key, raw);
+      continue;
+    }
+  }
+  return out;
+};
+
+// ../logix-core/src/internal/state-trait/build.ts
+var nowPerf = () => typeof globalThis.performance !== "undefined" && typeof globalThis.performance.now === "function" ? globalThis.performance.now() : Date.now();
+var collectMultipleWritersError = (entries) => {
+  const kindsByFieldPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.kind !== "computed" && entry.kind !== "link" && entry.kind !== "source" && entry.kind !== "externalStore") {
+      continue;
+    }
+    const set = kindsByFieldPath.get(entry.fieldPath) ?? /* @__PURE__ */ new Set();
+    set.add(entry.kind);
+    kindsByFieldPath.set(entry.fieldPath, set);
+  }
+  const conflicts = [];
+  for (const [fieldPath, kinds] of kindsByFieldPath.entries()) {
+    if (kinds.size <= 1) continue;
+    conflicts.push({ fieldPath, kinds: Array.from(kinds).sort() });
+  }
+  if (conflicts.length === 0) return void 0;
+  conflicts.sort((a, b) => a.fieldPath < b.fieldPath ? -1 : a.fieldPath > b.fieldPath ? 1 : 0);
+  const fields = conflicts.map((c) => c.fieldPath);
+  const primary = conflicts[0];
+  const kindSummary = primary.kinds.join(" + ");
+  return {
+    code: "MULTIPLE_WRITERS",
+    message: `[StateTrait.build] Multiple writers for field "${primary.fieldPath}" (${kindSummary}). Only one of computed/link/source/externalStore can write a fieldPath.`,
+    fields
+  };
+};
+var getConvergeWriterDeps = (entry) => {
+  if (entry.kind === "computed") {
+    return entry.meta?.deps ?? [];
+  }
+  return [entry.meta.from];
+};
+var computeConvergeTopoOrder = (writers) => {
+  const writerByPath = /* @__PURE__ */ new Map();
+  for (const entry of writers) {
+    const existing = writerByPath.get(entry.fieldPath);
+    if (existing) {
+      return {
+        order: [],
+        configError: {
+          code: "MULTIPLE_WRITERS",
+          message: `[StateTrait.converge] Multiple writers for field "${entry.fieldPath}" (${existing.kind} + ${entry.kind}).`,
+          fields: [entry.fieldPath]
+        }
+      };
+    }
+    writerByPath.set(entry.fieldPath, entry);
+  }
+  const nodes = /* @__PURE__ */ new Set();
+  for (const entry of writers) {
+    nodes.add(entry.fieldPath);
+  }
+  const indegree = /* @__PURE__ */ new Map();
+  const forward = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    indegree.set(node, 0);
+    forward.set(node, []);
+  }
+  for (const entry of writers) {
+    const to = entry.fieldPath;
+    const deps = getConvergeWriterDeps(entry);
+    for (const dep of deps) {
+      if (!nodes.has(dep)) continue;
+      forward.get(dep).push(to);
+      indegree.set(to, (indegree.get(to) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const [node, deg] of indegree.entries()) {
+    if (deg === 0) queue.push(node);
+  }
+  const order = [];
+  while (queue.length) {
+    const n = queue.shift();
+    order.push(n);
+    const outs = forward.get(n);
+    for (const to of outs) {
+      const next = (indegree.get(to) ?? 0) - 1;
+      indegree.set(to, next);
+      if (next === 0) queue.push(to);
+    }
+  }
+  if (order.length !== nodes.size) {
+    const remaining = Array.from(nodes).filter((n) => !order.includes(n));
+    return {
+      order: [],
+      configError: {
+        code: "CYCLE_DETECTED",
+        message: `[StateTrait.converge] Cycle detected in computed/link graph: ${remaining.join(", ")}`,
+        fields: remaining
+      }
+    };
+  }
+  return { order };
+};
+var collectSchemaFieldPaths = (schema) => {
+  const byKey = /* @__PURE__ */ new Map();
+  const add = (path) => {
+    const normalized = normalizeFieldPath(path);
+    if (!normalized) return;
+    byKey.set(JSON.stringify(normalized), normalized);
+  };
+  const visit = (ast, prefix, seen) => {
+    let current = ast;
+    while (true) {
+      if (SchemaAST.isSuspend(current)) {
+        if (seen.has(current)) return;
+        seen.add(current);
+        current = current.f();
+        continue;
+      }
+      if (SchemaAST.isRefinement(current)) {
+        current = current.from;
+        continue;
+      }
+      break;
+    }
+    if (SchemaAST.isTransformation(current)) {
+      visit(current.to, prefix, seen);
+      visit(current.from, prefix, seen);
+      return;
+    }
+    if (SchemaAST.isUnion(current)) {
+      for (const t of current.types) {
+        visit(t, prefix, seen);
+      }
+      return;
+    }
+    if (SchemaAST.isTupleType(current)) {
+      for (const e of current.elements) {
+        visit(e.type, prefix, seen);
+      }
+      for (const r of current.rest) {
+        visit(r.type, prefix, seen);
+      }
+      return;
+    }
+    if (SchemaAST.isTypeLiteral(current)) {
+      for (const ps of current.propertySignatures) {
+        const seg = String(ps.name);
+        if (!seg) continue;
+        const next = [...prefix, seg];
+        add(next);
+        visit(ps.type, next, seen);
+      }
+      return;
+    }
+  };
+  visit(schema.ast, [], /* @__PURE__ */ new Set());
+  return Array.from(byKey.values()).sort(compareFieldPath);
+};
+var buildConvergeIr = (stateSchema, entries) => {
+  const startedAt = nowPerf();
+  const generation = 0;
+  const multipleWritersError = collectMultipleWritersError(entries);
+  const writers = entries.filter((e) => e.kind === "computed" || e.kind === "link");
+  const writersKey = writers.map((entry) => `${entry.kind}:${entry.fieldPath}`).sort().join("|");
+  const depsKey = writers.map((entry) => {
+    const deps = getConvergeWriterDeps(entry).slice().sort().join(",");
+    const scheduling = entry.meta?.scheduling === "deferred" ? "d" : "i";
+    return `${entry.kind}:${entry.fieldPath}@${scheduling}=>${deps}`;
+  }).sort().join("|");
+  const writerByPath = /* @__PURE__ */ new Map();
+  for (const entry of writers) {
+    writerByPath.set(entry.fieldPath, entry);
+  }
+  const topo = multipleWritersError ? { order: [] } : writers.length > 0 ? computeConvergeTopoOrder(writers) : { order: [] };
+  const stepsById = topo.configError ? [] : topo.order.map((path) => writerByPath.get(path));
+  const fieldPathTable = /* @__PURE__ */ new Map();
+  const addPath = (path) => {
+    for (let i = 1; i <= path.length; i++) {
+      const prefix = path.slice(0, i);
+      const key = JSON.stringify(prefix);
+      if (!fieldPathTable.has(key)) fieldPathTable.set(key, prefix);
+    }
+  };
+  for (const schemaPath of collectSchemaFieldPaths(stateSchema)) {
+    addPath(schemaPath);
+  }
+  for (const entry of writers) {
+    const out = normalizeFieldPath(entry.fieldPath);
+    if (out) addPath(out);
+    for (const dep of getConvergeWriterDeps(entry)) {
+      const depPath = normalizeFieldPath(dep);
+      if (depPath) addPath(depPath);
+    }
+  }
+  const fieldPaths = Array.from(fieldPathTable.values()).sort(compareFieldPath);
+  const fieldPathIdRegistry = makeFieldPathIdRegistry(fieldPaths);
+  const fieldPathsKey = fnv1a32(stableStringify(fieldPaths));
+  const stepOutFieldPathIdByStepId = [];
+  const stepDepsFieldPathIdsByStepId = [];
+  const stepSchedulingByStepId = [];
+  for (const entry of stepsById) {
+    const out = normalizeFieldPath(entry.fieldPath);
+    const outId = out != null ? getFieldPathId(fieldPathIdRegistry, out) : void 0;
+    if (outId == null) {
+      throw new Error(`[StateTrait.build] Failed to map converge output fieldPath "${entry.fieldPath}" to FieldPathId.`);
+    }
+    const depIds = [];
+    for (const dep of getConvergeWriterDeps(entry)) {
+      const depPath = normalizeFieldPath(dep);
+      if (!depPath) continue;
+      const depId = getFieldPathId(fieldPathIdRegistry, depPath);
+      if (depId != null) depIds.push(depId);
+    }
+    stepOutFieldPathIdByStepId.push(outId);
+    stepDepsFieldPathIdsByStepId.push(depIds);
+    stepSchedulingByStepId.push(entry.meta?.scheduling === "deferred" ? "deferred" : "immediate");
+  }
+  const topoOrder = stepsById.map((_, i) => i);
+  const buildDurationMs = Math.max(0, nowPerf() - startedAt);
+  return {
+    generation,
+    writersKey,
+    depsKey,
+    fieldPathsKey,
+    fieldPaths,
+    fieldPathIdRegistry,
+    ...multipleWritersError ? { configError: multipleWritersError } : topo.configError ? { configError: topo.configError } : null,
+    stepsById,
+    stepOutFieldPathIdByStepId,
+    stepDepsFieldPathIdsByStepId,
+    stepSchedulingByStepId,
+    topoOrder,
+    buildDurationMs
+  };
+};
+var toFieldTrait = (entry) => {
+  const deps = [];
+  if (entry.kind === "computed") {
+    const meta = entry.meta;
+    const list = meta.deps;
+    if (list) deps.push(...list);
+  } else if (entry.kind === "source") {
+    const meta = entry.meta;
+    const list = meta.deps;
+    if (list) deps.push(...list);
+  } else if (entry.kind === "link") {
+    deps.push(entry.meta.from);
+  } else if (entry.kind === "check") {
+    const meta = entry.meta;
+    const rules = meta?.rules ?? {};
+    for (const name of Object.keys(rules)) {
+      const rule = rules[name];
+      if (rule && typeof rule === "object") {
+        const list = rule.deps;
+        if (list) deps.push(...list);
+      }
+    }
+  }
+  return {
+    fieldId: entry.fieldPath,
+    kind: entry.kind,
+    // Keep meta identical to Entry.meta at runtime so install can reuse it directly.
+    meta: entry.meta,
+    deps
+  };
+};
+var buildGraph = (entries, nodeMetaByFieldPath) => {
+  const fieldMap = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const edges = [];
+  const resourcesById = /* @__PURE__ */ new Map();
+  const planSteps = [];
+  const ensureField = (fieldPath) => {
+    let field = fieldMap.get(fieldPath);
+    if (!field) {
+      field = {
+        id: fieldPath,
+        path: fieldPath,
+        traits: []
+      };
+      fieldMap.set(fieldPath, field);
+    }
+    return field;
+  };
+  for (const entry of entries) {
+    const fieldPath = entry.fieldPath;
+    const field = ensureField(fieldPath);
+    const trait = toFieldTrait(entry);
+    field.traits.push(trait);
+    if (entry.kind === "computed") {
+      const stepId = `computed:${fieldPath}`;
+      planSteps.push({
+        id: stepId,
+        kind: "computed-update",
+        targetFieldPath: fieldPath
+        // Note: the current version does not statically analyze computed dependencies; sourceFieldPaths remains empty.
+      });
+      const deps = entry.meta.deps;
+      if (deps) {
+        for (const dep of deps) {
+          ensureField(dep);
+          edges.push({
+            id: `computed:${dep}->${fieldPath}`,
+            from: dep,
+            to: fieldPath,
+            kind: "computed"
+          });
+        }
+      }
+    } else if (entry.kind === "link") {
+      const from = entry.meta.from;
+      ensureField(from);
+      const edgeId = `link:${from}->${fieldPath}`;
+      edges.push({
+        id: edgeId,
+        from,
+        to: fieldPath,
+        kind: "link"
+      });
+      planSteps.push({
+        id: `link:${fieldPath}`,
+        kind: "link-propagate",
+        targetFieldPath: fieldPath,
+        sourceFieldPaths: [from],
+        debugInfo: {
+          graphEdgeId: edgeId
+        }
+      });
+    } else if (entry.kind === "source") {
+      const resourceId = entry.meta.resource;
+      const resourceMeta = sanitize(entry.meta.meta);
+      const existing = resourcesById.get(resourceId);
+      if (existing) {
+        const ownerFields = [...existing.ownerFields, fieldPath];
+        let meta = existing.meta;
+        let metaOrigin = existing.metaOrigin;
+        let metaConflicts = existing.metaConflicts;
+        if (resourceMeta) {
+          const merged = mergeCanonical(
+            { meta, origin: metaOrigin, conflicts: metaConflicts },
+            { origin: fieldPath, meta: resourceMeta }
+          );
+          meta = merged.meta;
+          metaOrigin = merged.origin;
+          metaConflicts = merged.conflicts;
+        }
+        resourcesById.set(resourceId, {
+          ...existing,
+          ownerFields,
+          meta,
+          metaOrigin,
+          metaConflicts
+        });
+      } else {
+        resourcesById.set(resourceId, {
+          resourceId,
+          // Use a simple identifier string for now; may evolve into a structured form based on key rules.
+          keySelector: `StateTrait.source@${fieldPath}`,
+          ownerFields: [fieldPath],
+          meta: resourceMeta,
+          metaOrigin: resourceMeta ? fieldPath : void 0
+        });
+      }
+      planSteps.push({
+        id: `source:${fieldPath}`,
+        kind: "source-refresh",
+        targetFieldPath: fieldPath,
+        resourceId,
+        keySelectorId: `StateTrait.source@${fieldPath}`
+      });
+      const deps = entry.meta.deps;
+      if (deps) {
+        for (const dep of deps) {
+          ensureField(dep);
+          edges.push({
+            id: `source-dep:${dep}->${fieldPath}`,
+            from: dep,
+            to: fieldPath,
+            kind: "source-dep"
+          });
+        }
+      }
+    } else if (entry.kind === "externalStore") {
+      planSteps.push({
+        id: `external-store:${fieldPath}`,
+        kind: "external-store-sync",
+        targetFieldPath: fieldPath
+      });
+    } else if (entry.kind === "check") {
+      planSteps.push({
+        id: `check:${fieldPath}`,
+        kind: "check-validate",
+        targetFieldPath: fieldPath
+      });
+      if (trait.deps.length > 0) {
+        for (const dep of trait.deps) {
+          ensureField(dep);
+          edges.push({
+            id: `check-dep:${dep}->${fieldPath}`,
+            from: dep,
+            to: fieldPath,
+            kind: "check-dep"
+          });
+        }
+      }
+    }
+  }
+  for (const field of fieldMap.values()) {
+    nodes.push({
+      id: field.id,
+      field,
+      traits: field.traits,
+      meta: nodeMetaByFieldPath.get(field.id)
+    });
+  }
+  const graph = {
+    _tag: "StateTraitGraph",
+    nodes,
+    edges,
+    resources: Array.from(resourcesById.values())
+  };
+  const plan = {
+    _tag: "StateTraitPlan",
+    steps: planSteps
+  };
+  return { graph, plan };
+};
+var assertNoLinkCycles = (edges) => {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (edge.kind !== "link") continue;
+    const list = adjacency.get(edge.from) ?? [];
+    list.push(edge.to);
+    adjacency.set(edge.from, list);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const dfs = (node) => {
+    if (stack.has(node)) {
+      throw new Error(
+        `[StateTrait.build] link cycle detected at field "${node}". Please check link traits for circular dependencies.`
+      );
+    }
+    if (visited.has(node)) return;
+    visited.add(node);
+    stack.add(node);
+    const nexts = adjacency.get(node);
+    if (nexts) {
+      for (const to of nexts) {
+        dfs(to);
+      }
+    }
+    stack.delete(node);
+  };
+  for (const node of adjacency.keys()) {
+    if (!visited.has(node)) {
+      dfs(node);
+    }
+  }
+};
+var collectSchemaPaths = (entries) => {
+  const byKey = /* @__PURE__ */ new Map();
+  const add = (ref) => {
+    if (!ref.path) return;
+    const k = `${ref.kind}|${ref.entryKind}|${ref.entryFieldPath}|${ref.ruleName ?? ""}|${ref.path}`;
+    byKey.set(k, ref);
+  };
+  const getCheckWritebackPath = (entry) => {
+    const wb = entry.meta?.writeback;
+    const p = wb && typeof wb === "object" ? wb.path : void 0;
+    const writebackPath = typeof p === "string" && p.startsWith("errors.") ? p : void 0;
+    if (writebackPath) return writebackPath;
+    const fieldPath = entry.fieldPath;
+    if (fieldPath.endsWith("[]")) {
+      return `errors.${fieldPath.slice(0, -2)}`;
+    }
+    return `errors.${fieldPath}`;
+  };
+  for (const entry of entries) {
+    add({
+      kind: "fieldPath",
+      entryKind: entry.kind,
+      entryFieldPath: entry.fieldPath,
+      path: entry.fieldPath
+    });
+    if (entry.kind === "computed" || entry.kind === "source") {
+      const deps = entry.meta?.deps ?? [];
+      for (const dep of deps) {
+        add({
+          kind: "dep",
+          entryKind: entry.kind,
+          entryFieldPath: entry.fieldPath,
+          path: dep
+        });
+      }
+    }
+    if (entry.kind === "link") {
+      add({
+        kind: "link_from",
+        entryKind: "link",
+        entryFieldPath: entry.fieldPath,
+        path: entry.meta.from
+      });
+    }
+    if (entry.kind === "check") {
+      add({
+        kind: "check_writeback",
+        entryKind: "check",
+        entryFieldPath: entry.fieldPath,
+        path: getCheckWritebackPath(entry)
+      });
+      const rules = entry.meta?.rules ?? {};
+      for (const name of Object.keys(rules)) {
+        const rule = rules[name];
+        if (!rule || typeof rule !== "object") continue;
+        const deps = rule.deps ?? [];
+        for (const dep of deps) {
+          add({
+            kind: "dep",
+            entryKind: "check",
+            entryFieldPath: entry.fieldPath,
+            ruleName: name,
+            path: dep
+          });
+        }
+      }
+    }
+  }
+  return Array.from(byKey.entries()).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map(([, v]) => v);
+};
+var build = (stateSchema, spec) => {
+  const entries = normalizeSpec(spec);
+  const nodeMetaByFieldPath = collectNodeMeta(spec);
+  for (const entry of entries) {
+    if (entry.kind === "computed") {
+      const deps = entry.meta.deps;
+      if (deps === void 0) {
+        throw new Error(
+          `[StateTrait.build] Missing explicit deps for computed "${entry.fieldPath}". Please use StateTrait.computed({ deps: [...], get: ... }).`
+        );
+      }
+    }
+    if (entry.kind === "source") {
+      const deps = entry.meta.deps;
+      if (deps === void 0) {
+        throw new Error(
+          `[StateTrait.build] Missing explicit deps for source "${entry.fieldPath}". Please provide meta.deps for StateTrait.source({ deps: [...], ... }).`
+        );
+      }
+    }
+    if (entry.kind === "check") {
+      const rules = entry.meta?.rules ?? {};
+      for (const name of Object.keys(rules)) {
+        const rule = rules[name];
+        if (typeof rule === "function" || !rule || typeof rule !== "object") {
+          throw new Error(
+            `[StateTrait.build] Missing explicit deps for check "${entry.fieldPath}" rule "${name}". Please use { deps: [...], validate: ... } form.`
+          );
+        }
+        if (rule.deps === void 0) {
+          throw new Error(
+            `[StateTrait.build] Missing explicit deps for check "${entry.fieldPath}" rule "${name}". Please provide deps: [...].`
+          );
+        }
+      }
+    }
+  }
+  const { graph, plan } = buildGraph(entries, nodeMetaByFieldPath);
+  assertNoLinkCycles(graph.edges);
+  return {
+    stateSchema,
+    spec,
+    entries,
+    graph,
+    plan,
+    convergeIr: buildConvergeIr(stateSchema, entries),
+    schemaPaths: collectSchemaPaths(entries)
+  };
+};
+
+// ../logix-core/src/internal/state-trait/source.impl.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.impl.ts
+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, path, reason, from, to, traitNodeId) => {
+  const normalized = normalizeFieldPath(path) ?? [];
+  try {
+    const internals = getBoundInternals(bound);
+    internals.txn.recordStatePatch(normalized, reason, from, to, traitNodeId);
+  } 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, fieldPath, reason, prev, next, 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, fieldPath, reason, prev, next, 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-refresh";
+  const nextDraft = create(draft, (next) => {
+    for (const u of updates) {
+      setAtPathMutating(next, u.fieldPath, Snapshot.idle());
+    }
+  });
+  ctx.setDraft(nextDraft);
+  for (const u of updates) {
+    const normalized = normalizeFieldPath(u.fieldPath) ?? [];
+    ctx.recordPatch(normalized, reason, u.prev, Snapshot.idle(), `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, concretePath, reason, prev, next, 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, concretePath, reason, prev, next, 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-refresh",
+        `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-refresh",
+              `source:${fieldPath}:${rowId}:success`,
+              "success"
+            );
+          } else if (replayed.phase === "error") {
+            yield* writebackIfCurrentKeyHashForRow(
+              rowId,
+              keyHash2,
+              replayed.snapshot,
+              "source-refresh",
+              `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-refresh",
+            `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-refresh",
+            `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-refresh",
+              `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-refresh",
+              `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-refresh",
+      `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-refresh",
+            `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-refresh",
+            `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-refresh",
+          `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-refresh",
+          `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-refresh",
+          `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-refresh",
+          `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;
+};
+
+// ../logix-core/src/internal/state-trait/converge-diagnostics.ts
+import { Effect as Effect2, FiberRef as FiberRef2, Option as Option2 } from "../effect.js";
+import * as SchemaAST2 from "../effect/SchemaAST.js";
+var onceKeysFallback = /* @__PURE__ */ new Set();
+var onceInRunSession2 = (key) => Effect2.serviceOption(RunSessionTag).pipe(
+  Effect2.map((maybe) => {
+    if (Option2.isSome(maybe)) {
+      return maybe.value.local.once(key);
+    }
+    if (onceKeysFallback.has(key)) return false;
+    onceKeysFallback.add(key);
+    return true;
+  })
+);
+var formatList2 = (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 emitDepsMismatch2 = (params) => {
+  return Effect2.gen(function* () {
+    const key = `${params.moduleId ?? "unknown"}::${params.instanceId ?? "unknown"}::${params.kind}::${params.fieldPath}`;
+    const shouldEmit = yield* onceInRunSession2(`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=[${formatList2(params.diff.declared)}] reads=[${formatList2(params.diff.reads)}] missing=[${formatList2(params.diff.missing)}] unused=[${formatList2(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 schemaHasPath = (ast, segments, seen = /* @__PURE__ */ new Set()) => {
+  if (segments.length === 0) return true;
+  let current = ast;
+  while (true) {
+    if (SchemaAST2.isSuspend(current)) {
+      if (seen.has(current)) {
+        return true;
+      }
+      seen.add(current);
+      current = current.f();
+      continue;
+    }
+    if (SchemaAST2.isRefinement(current)) {
+      current = current.from;
+      continue;
+    }
+    break;
+  }
+  if (SchemaAST2.isTransformation(current)) {
+    return schemaHasPath(current.to, segments, seen) || schemaHasPath(current.from, segments, seen);
+  }
+  if (SchemaAST2.isUnion(current)) {
+    return current.types.some((t) => schemaHasPath(t, segments, seen));
+  }
+  if (SchemaAST2.isTupleType(current)) {
+    const candidates = [];
+    for (const e of current.elements) candidates.push(e.type);
+    for (const r of current.rest) candidates.push(r.type);
+    if (candidates.length === 0) return true;
+    return candidates.some((t) => schemaHasPath(t, segments, seen));
+  }
+  if (SchemaAST2.isTypeLiteral(current)) {
+    const [head, ...tail] = segments;
+    for (const ps of current.propertySignatures) {
+      if (String(ps.name) !== head) continue;
+      return schemaHasPath(ps.type, tail, seen);
+    }
+    for (const sig of current.indexSignatures) {
+      let param = sig.parameter;
+      while (SchemaAST2.isRefinement(param)) {
+        param = param.from;
+      }
+      const tag2 = param?._tag;
+      if (tag2 === "StringKeyword" || tag2 === "TemplateLiteral") {
+        return schemaHasPath(sig.type, tail, seen);
+      }
+    }
+    return false;
+  }
+  const tag = current?._tag;
+  if (tag === "AnyKeyword" || tag === "UnknownKeyword" || tag === "ObjectKeyword" || tag === "Declaration") {
+    return true;
+  }
+  return false;
+};
+var schemaHasFieldPath = (stateSchemaAst, path) => {
+  if (!path) return true;
+  if (path === "$root") return true;
+  const normalized = normalizeFieldPath(path);
+  if (!normalized) return false;
+  const segs = normalized[0] === "$root" ? normalized.slice(1) : normalized;
+  return schemaHasPath(stateSchemaAst, segs);
+};
+var formatSchemaMismatchLine = (ref) => {
+  if (ref.kind === "fieldPath") {
+    return `- ${ref.entryKind} "${ref.entryFieldPath}" fieldPath="${ref.path}"`;
+  }
+  if (ref.kind === "dep") {
+    const rule = ref.ruleName ? ` rule="${ref.ruleName}"` : "";
+    return `- ${ref.entryKind} "${ref.entryFieldPath}" deps="${ref.path}"${rule}`;
+  }
+  if (ref.kind === "link_from") {
+    return `- link "${ref.entryFieldPath}" from="${ref.path}"`;
+  }
+  if (ref.kind === "check_writeback") {
+    return `- check "${ref.entryFieldPath}" writeback="${ref.path}"`;
+  }
+  return `- ${ref.entryKind} "${ref.entryFieldPath}" path="${ref.path}"`;
+};
+var emitSchemaMismatch = (program, ctx) => Effect2.gen(function* () {
+  if (!isDevEnv()) return;
+  const level = yield* FiberRef2.get(currentDiagnosticsLevel);
+  if (level === "off") return;
+  const key = `${ctx.moduleId ?? "unknown"}::${ctx.instanceId}`;
+  const shouldEmit = yield* onceInRunSession2(`schema_mismatch:${key}`);
+  if (!shouldEmit) return;
+  const refs = program.schemaPaths ?? [];
+  if (refs.length === 0) return;
+  const stateSchemaAst = program.stateSchema.ast;
+  const mismatches = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    if (schemaHasFieldPath(stateSchemaAst, ref.path)) continue;
+    const k = `${ref.kind}|${ref.entryKind}|${ref.entryFieldPath}|${ref.ruleName ?? ""}|${ref.path}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    mismatches.push(ref);
+  }
+  if (mismatches.length === 0) return;
+  const limit = level === "light" ? 8 : 24;
+  const lines = mismatches.slice(0, limit).map(formatSchemaMismatchLine);
+  if (mismatches.length > limit) {
+    lines.push(`- \u2026(+${mismatches.length - limit})`);
+  }
+  yield* record({
+    type: "diagnostic",
+    moduleId: ctx.moduleId,
+    instanceId: ctx.instanceId,
+    code: "state_trait::schema_mismatch",
+    severity: "warning",
+    message: `[schema] The following paths are not declared in stateSchema (total ${mismatches.length}):
+${lines.join("\n")}`,
+    hint: "StateTrait writeback will create missing objects/fields. Declare all fieldPath/deps/link.from and errors.* writeback paths in stateSchema, or fix typos in trait paths.",
+    kind: "schema_mismatch"
+  });
+});
+
+export {
+  onceInRunSession2 as onceInRunSession,
+  emitDepsMismatch2 as emitDepsMismatch,
+  emitSchemaMismatch,
+  diffDeps,
+  trace,
+  syncIdleInTransaction,
+  installSourceRefresh,
+  build
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/build.ts", "../../../../logix-core/src/internal/state-trait/model.ts", "../../../../logix-core/src/internal/state-trait/source.impl.ts", "../../../../logix-core/src/internal/state-trait/deps-trace.ts", "../../../../logix-core/src/internal/state-trait/converge-diagnostics.ts"],
  "sourcesContent": ["import type { Schema } from 'effect'\nimport * as SchemaAST from 'effect/SchemaAST'\nimport {\n  type StateTraitProgram,\n  type StateTraitSpec,\n  type StateTraitEntry,\n  type StateTraitGraph,\n  type StateTraitGraphEdge,\n  type StateTraitGraphNode,\n  type StateTraitField,\n  type StateTraitFieldTrait,\n  type StateTraitKind,\n  type StateTraitPlan,\n  type StateTraitPlanStep,\n  type StateTraitResource,\n  type StateTraitSchemaPathRef,\n  collectNodeMeta,\n  normalizeSpec,\n} from './model.js'\nimport * as Meta from './meta.js'\nimport {\n  compareFieldPath,\n  getFieldPathId,\n  makeFieldPathIdRegistry,\n  normalizeFieldPath,\n  type FieldPath,\n  type FieldPathId,\n} from '../field-path.js'\nimport { fnv1a32, stableStringify } from '../digest.js'\nimport type { ConvergeStaticIrRegistry } from './converge-ir.js'\n\nconst nowPerf = (): number =>\n  typeof globalThis.performance !== 'undefined' && typeof globalThis.performance.now === 'function'\n    ? globalThis.performance.now()\n    : Date.now()\n\ntype ConvergeWriter = Extract<StateTraitEntry<any, string>, { readonly kind: 'computed' | 'link' }>\n\nconst collectMultipleWritersError = (\n  entries: ReadonlyArray<StateTraitEntry<any, string>>,\n): ConvergeStaticIrRegistry['configError'] | undefined => {\n  const kindsByFieldPath = new Map<string, Set<StateTraitKind>>()\n\n  for (const entry of entries) {\n    if (entry.kind !== 'computed' && entry.kind !== 'link' && entry.kind !== 'source' && entry.kind !== 'externalStore') {\n      continue\n    }\n    const set = kindsByFieldPath.get(entry.fieldPath) ?? new Set<StateTraitKind>()\n    set.add(entry.kind)\n    kindsByFieldPath.set(entry.fieldPath, set)\n  }\n\n  const conflicts: Array<{ readonly fieldPath: string; readonly kinds: ReadonlyArray<StateTraitKind> }> = []\n  for (const [fieldPath, kinds] of kindsByFieldPath.entries()) {\n    if (kinds.size <= 1) continue\n    conflicts.push({ fieldPath, kinds: Array.from(kinds).sort() })\n  }\n\n  if (conflicts.length === 0) return undefined\n\n  conflicts.sort((a, b) => (a.fieldPath < b.fieldPath ? -1 : a.fieldPath > b.fieldPath ? 1 : 0))\n  const fields = conflicts.map((c) => c.fieldPath)\n  const primary = conflicts[0]!\n  const kindSummary = primary.kinds.join(' + ')\n\n  return {\n    code: 'MULTIPLE_WRITERS',\n    message:\n      `[StateTrait.build] Multiple writers for field \"${primary.fieldPath}\" (${kindSummary}). ` +\n      'Only one of computed/link/source/externalStore can write a fieldPath.',\n    fields,\n  }\n}\n\nconst getConvergeWriterDeps = (entry: ConvergeWriter): ReadonlyArray<string> => {\n  if (entry.kind === 'computed') {\n    return ((entry.meta as any)?.deps ?? []) as ReadonlyArray<string>\n  }\n  return [entry.meta.from as string]\n}\n\nconst computeConvergeTopoOrder = (\n  writers: ReadonlyArray<ConvergeWriter>,\n): { readonly order: ReadonlyArray<string>; readonly configError?: ConvergeStaticIrRegistry['configError'] } => {\n  const writerByPath = new Map<string, ConvergeWriter>()\n  for (const entry of writers) {\n    const existing = writerByPath.get(entry.fieldPath)\n    if (existing) {\n      return {\n        order: [],\n        configError: {\n          code: 'MULTIPLE_WRITERS',\n          message: `[StateTrait.converge] Multiple writers for field \"${entry.fieldPath}\" (${existing.kind} + ${entry.kind}).`,\n          fields: [entry.fieldPath],\n        },\n      }\n    }\n    writerByPath.set(entry.fieldPath, entry)\n  }\n\n  const nodes = new Set<string>()\n  for (const entry of writers) {\n    nodes.add(entry.fieldPath)\n  }\n\n  const indegree = new Map<string, number>()\n  const forward = new Map<string, Array<string>>()\n\n  for (const node of nodes) {\n    indegree.set(node, 0)\n    forward.set(node, [])\n  }\n\n  for (const entry of writers) {\n    const to = entry.fieldPath\n    const deps = getConvergeWriterDeps(entry)\n    for (const dep of deps) {\n      if (!nodes.has(dep)) continue\n      forward.get(dep)!.push(to)\n      indegree.set(to, (indegree.get(to) ?? 0) + 1)\n    }\n  }\n\n  const queue: Array<string> = []\n  for (const [node, deg] of indegree.entries()) {\n    if (deg === 0) queue.push(node)\n  }\n\n  const order: Array<string> = []\n  while (queue.length) {\n    const n = queue.shift()!\n    order.push(n)\n    const outs = forward.get(n)!\n    for (const to of outs) {\n      const next = (indegree.get(to) ?? 0) - 1\n      indegree.set(to, next)\n      if (next === 0) queue.push(to)\n    }\n  }\n\n  if (order.length !== nodes.size) {\n    const remaining = Array.from(nodes).filter((n) => !order.includes(n))\n    return {\n      order: [],\n      configError: {\n        code: 'CYCLE_DETECTED',\n        message: `[StateTrait.converge] Cycle detected in computed/link graph: ${remaining.join(', ')}`,\n        fields: remaining,\n      },\n    }\n  }\n\n  return { order }\n}\n\nconst collectSchemaFieldPaths = (schema: Schema.Schema<any, any>): ReadonlyArray<FieldPath> => {\n  const byKey = new Map<string, FieldPath>()\n\n  const add = (path: FieldPath): void => {\n    const normalized = normalizeFieldPath(path)\n    if (!normalized) return\n    byKey.set(JSON.stringify(normalized), normalized)\n  }\n\n  const visit = (ast: SchemaAST.AST, prefix: ReadonlyArray<string>, seen: Set<SchemaAST.AST>): void => {\n    let current: SchemaAST.AST = ast\n\n    // Unwrap Suspend/Refinement (recursive schema / branded schema).\n    while (true) {\n      if (SchemaAST.isSuspend(current)) {\n        if (seen.has(current)) return\n        seen.add(current)\n        current = current.f()\n        continue\n      }\n      if (SchemaAST.isRefinement(current)) {\n        current = current.from\n        continue\n      }\n      break\n    }\n\n    if (SchemaAST.isTransformation(current)) {\n      visit(current.to, prefix, seen)\n      visit(current.from, prefix, seen)\n      return\n    }\n\n    if (SchemaAST.isUnion(current)) {\n      for (const t of current.types) {\n        visit(t, prefix, seen)\n      }\n      return\n    }\n\n    // Array / Tuple: indices do not enter the FieldPathId space; recurse into element types to support `items[0].name -> items.name`.\n    if (SchemaAST.isTupleType(current)) {\n      for (const e of current.elements) {\n        visit(e.type, prefix, seen)\n      }\n      for (const r of current.rest) {\n        visit(r.type, prefix, seen)\n      }\n      return\n    }\n\n    if (SchemaAST.isTypeLiteral(current)) {\n      for (const ps of current.propertySignatures) {\n        const seg = String(ps.name)\n        if (!seg) continue\n        const next = [...prefix, seg]\n        add(next)\n        visit(ps.type, next, seen)\n      }\n      // Index signature (Record<string, T>) can't be enumerated statically: avoid generating misaligned dynamic key paths.\n      return\n    }\n\n    // Any / Unknown / Object / Declaration (open types): cannot enumerate nested paths; stop conservatively.\n  }\n\n  visit(schema.ast as unknown as SchemaAST.AST, [], new Set())\n  return Array.from(byKey.values()).sort(compareFieldPath)\n}\n\nconst buildConvergeIr = (\n  stateSchema: Schema.Schema<any, any>,\n  entries: ReadonlyArray<StateTraitEntry<any, string>>,\n): ConvergeStaticIrRegistry => {\n  const startedAt = nowPerf()\n  const generation = 0\n\n  const multipleWritersError = collectMultipleWritersError(entries)\n\n  const writers = entries.filter((e): e is ConvergeWriter => e.kind === 'computed' || e.kind === 'link')\n\n  const writersKey = writers\n    .map((entry) => `${entry.kind}:${entry.fieldPath}`)\n    .sort()\n    .join('|')\n\n  const depsKey = writers\n    .map((entry) => {\n      const deps = getConvergeWriterDeps(entry).slice().sort().join(',')\n      const scheduling = (entry.meta as any)?.scheduling === 'deferred' ? 'd' : 'i'\n      return `${entry.kind}:${entry.fieldPath}@${scheduling}=>${deps}`\n    })\n    .sort()\n    .join('|')\n\n  const writerByPath = new Map<string, ConvergeWriter>()\n  for (const entry of writers) {\n    writerByPath.set(entry.fieldPath, entry)\n  }\n\n  const topo = multipleWritersError\n    ? { order: [] as ReadonlyArray<string> }\n    : writers.length > 0\n      ? computeConvergeTopoOrder(writers)\n      : { order: [] as ReadonlyArray<string> }\n  const stepsById: Array<ConvergeWriter> = topo.configError ? [] : topo.order.map((path) => writerByPath.get(path)!)\n\n  const fieldPathTable = new Map<string, FieldPath>()\n  const addPath = (path: FieldPath): void => {\n    for (let i = 1; i <= path.length; i++) {\n      const prefix = path.slice(0, i)\n      const key = JSON.stringify(prefix)\n      if (!fieldPathTable.has(key)) fieldPathTable.set(key, prefix)\n    }\n  }\n\n  // 065: FieldPathId semantics must cover all enumerable field paths of stateSchema; otherwise reducer patchPaths can't map and will fall back to dirtyAll.\n  for (const schemaPath of collectSchemaFieldPaths(stateSchema)) {\n    addPath(schemaPath)\n  }\n\n  for (const entry of writers) {\n    const out = normalizeFieldPath(entry.fieldPath)\n    if (out) addPath(out)\n    for (const dep of getConvergeWriterDeps(entry)) {\n      const depPath = normalizeFieldPath(dep)\n      if (depPath) addPath(depPath)\n    }\n  }\n\n  const fieldPaths = Array.from(fieldPathTable.values()).sort(compareFieldPath)\n  const fieldPathIdRegistry = makeFieldPathIdRegistry(fieldPaths)\n  const fieldPathsKey = fnv1a32(stableStringify(fieldPaths))\n\n  const stepOutFieldPathIdByStepId: Array<FieldPathId> = []\n  const stepDepsFieldPathIdsByStepId: Array<ReadonlyArray<FieldPathId>> = []\n  const stepSchedulingByStepId: Array<'immediate' | 'deferred'> = []\n\n  for (const entry of stepsById) {\n    const out = normalizeFieldPath(entry.fieldPath)\n    const outId = out != null ? getFieldPathId(fieldPathIdRegistry, out) : undefined\n    if (outId == null) {\n      throw new Error(`[StateTrait.build] Failed to map converge output fieldPath \"${entry.fieldPath}\" to FieldPathId.`)\n    }\n\n    const depIds: Array<FieldPathId> = []\n    for (const dep of getConvergeWriterDeps(entry)) {\n      const depPath = normalizeFieldPath(dep)\n      if (!depPath) continue\n      const depId = getFieldPathId(fieldPathIdRegistry, depPath)\n      if (depId != null) depIds.push(depId)\n    }\n\n    stepOutFieldPathIdByStepId.push(outId)\n    stepDepsFieldPathIdsByStepId.push(depIds)\n    stepSchedulingByStepId.push((entry.meta as any)?.scheduling === 'deferred' ? 'deferred' : 'immediate')\n  }\n\n  const topoOrder = stepsById.map((_, i) => i)\n  const buildDurationMs = Math.max(0, nowPerf() - startedAt)\n\n  return {\n    generation,\n    writersKey,\n    depsKey,\n    fieldPathsKey,\n    fieldPaths,\n    fieldPathIdRegistry,\n    ...(multipleWritersError ? { configError: multipleWritersError } : topo.configError ? { configError: topo.configError } : null),\n    stepsById,\n    stepOutFieldPathIdByStepId,\n    stepDepsFieldPathIdsByStepId,\n    stepSchedulingByStepId,\n    topoOrder,\n    buildDurationMs,\n  }\n}\n\n/**\n * Builds a normalized FieldTrait from a StateTraitEntry.\n *\n * - Currently uses explicit deps for computed/source and link edges; deeper dependency analysis is intentionally not performed.\n * - If we evolve explicit dependency declarations further, extend here.\n */\nconst toFieldTrait = (entry: StateTraitEntry<any, string>): StateTraitFieldTrait => {\n  const deps: Array<string> = []\n\n  if (entry.kind === 'computed') {\n    const meta = entry.meta as any\n    const list = meta.deps as ReadonlyArray<string> | undefined\n    if (list) deps.push(...list)\n  } else if (entry.kind === 'source') {\n    const meta = entry.meta as any\n    const list = meta.deps as ReadonlyArray<string> | undefined\n    if (list) deps.push(...list)\n  } else if (entry.kind === 'link') {\n    deps.push(entry.meta.from as string)\n  } else if (entry.kind === 'check') {\n    const meta = entry.meta as any\n    const rules = (meta?.rules ?? {}) as Record<string, any>\n    for (const name of Object.keys(rules)) {\n      const rule = rules[name]\n      if (rule && typeof rule === 'object') {\n        const list = rule.deps as ReadonlyArray<string> | undefined\n        if (list) deps.push(...list)\n      }\n    }\n  }\n\n  return {\n    fieldId: entry.fieldPath,\n    kind: entry.kind,\n    // Keep meta identical to Entry.meta at runtime so install can reuse it directly.\n    meta: entry.meta as any,\n    deps,\n  }\n}\n\n/**\n * Builds Field / Node / Edge / Resource sets from normalized entries.\n */\nconst buildGraph = (\n  entries: ReadonlyArray<StateTraitEntry<any, string>>,\n  nodeMetaByFieldPath: ReadonlyMap<string, Meta.TraitMeta>,\n): {\n  readonly graph: StateTraitGraph\n  readonly plan: StateTraitPlan\n} => {\n  const fieldMap = new Map<string, StateTraitField>()\n  const nodes: Array<StateTraitGraphNode> = []\n  const edges: Array<StateTraitGraphEdge> = []\n  const resourcesById = new Map<string, StateTraitResource>()\n  const planSteps: Array<StateTraitPlanStep> = []\n\n  const ensureField = (fieldPath: string): StateTraitField => {\n    let field = fieldMap.get(fieldPath)\n    if (!field) {\n      field = {\n        id: fieldPath,\n        path: fieldPath,\n        traits: [],\n      }\n      fieldMap.set(fieldPath, field)\n    }\n    return field\n  }\n\n  for (const entry of entries) {\n    const fieldPath = entry.fieldPath\n    const field = ensureField(fieldPath)\n    const trait = toFieldTrait(entry)\n\n    ;(field.traits as Array<StateTraitFieldTrait>).push(trait)\n\n    // Build Graph edges and Plan steps by kind.\n    if (entry.kind === 'computed') {\n      const stepId = `computed:${fieldPath}`\n      planSteps.push({\n        id: stepId,\n        kind: 'computed-update',\n        targetFieldPath: fieldPath,\n        // Note: the current version does not statically analyze computed dependencies; sourceFieldPaths remains empty.\n      })\n      // If deps is explicitly declared, add Graph edges (for diagnostics / reverse-closure computation).\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps) {\n        for (const dep of deps) {\n          ensureField(dep)\n          edges.push({\n            id: `computed:${dep}->${fieldPath}`,\n            from: dep,\n            to: fieldPath,\n            kind: 'computed',\n          })\n        }\n      }\n    } else if (entry.kind === 'link') {\n      const from = entry.meta.from as string\n      ensureField(from)\n\n      const edgeId = `link:${from}->${fieldPath}`\n      edges.push({\n        id: edgeId,\n        from,\n        to: fieldPath,\n        kind: 'link',\n      })\n\n      planSteps.push({\n        id: `link:${fieldPath}`,\n        kind: 'link-propagate',\n        targetFieldPath: fieldPath,\n        sourceFieldPaths: [from],\n        debugInfo: {\n          graphEdgeId: edgeId,\n        },\n      })\n    } else if (entry.kind === 'source') {\n      const resourceId = entry.meta.resource\n      const resourceMeta = Meta.sanitize((entry.meta as any).meta)\n\n      const existing = resourcesById.get(resourceId)\n      if (existing) {\n        const ownerFields = [...existing.ownerFields, fieldPath]\n        let meta = existing.meta\n        let metaOrigin = existing.metaOrigin\n        let metaConflicts = existing.metaConflicts\n\n        if (resourceMeta) {\n          const merged = Meta.mergeCanonical(\n            { meta, origin: metaOrigin, conflicts: metaConflicts },\n            { origin: fieldPath, meta: resourceMeta },\n          )\n          meta = merged.meta\n          metaOrigin = merged.origin\n          metaConflicts = merged.conflicts\n        }\n\n        resourcesById.set(resourceId, {\n          ...existing,\n          ownerFields,\n          meta,\n          metaOrigin,\n          metaConflicts,\n        })\n      } else {\n        resourcesById.set(resourceId, {\n          resourceId,\n          // Use a simple identifier string for now; may evolve into a structured form based on key rules.\n          keySelector: `StateTrait.source@${fieldPath}`,\n          ownerFields: [fieldPath],\n          meta: resourceMeta,\n          metaOrigin: resourceMeta ? fieldPath : undefined,\n        })\n      }\n\n      planSteps.push({\n        id: `source:${fieldPath}`,\n        kind: 'source-refresh',\n        targetFieldPath: fieldPath,\n        resourceId,\n        keySelectorId: `StateTrait.source@${fieldPath}`,\n      })\n\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps) {\n        for (const dep of deps) {\n          ensureField(dep)\n          edges.push({\n            id: `source-dep:${dep}->${fieldPath}`,\n            from: dep,\n            to: fieldPath,\n            kind: 'source-dep',\n          })\n        }\n      }\n    } else if (entry.kind === 'externalStore') {\n      planSteps.push({\n        id: `external-store:${fieldPath}`,\n        kind: 'external-store-sync',\n        targetFieldPath: fieldPath,\n      })\n    } else if (entry.kind === 'check') {\n      planSteps.push({\n        id: `check:${fieldPath}`,\n        kind: 'check-validate',\n        targetFieldPath: fieldPath,\n      })\n\n      // If the rule explicitly declares deps, add Graph edges (for ReverseClosure scoped validate).\n      if (trait.deps.length > 0) {\n        for (const dep of trait.deps) {\n          ensureField(dep)\n          edges.push({\n            id: `check-dep:${dep}->${fieldPath}`,\n            from: dep,\n            to: fieldPath,\n            kind: 'check-dep',\n          })\n        }\n      }\n    }\n  }\n\n  for (const field of fieldMap.values()) {\n    nodes.push({\n      id: field.id,\n      field,\n      traits: field.traits,\n      meta: nodeMetaByFieldPath.get(field.id),\n    })\n  }\n\n  const graph: StateTraitGraph = {\n    _tag: 'StateTraitGraph',\n    nodes,\n    edges,\n    resources: Array.from(resourcesById.values()),\n  }\n\n  const plan: StateTraitPlan = {\n    _tag: 'StateTraitPlan',\n    steps: planSteps,\n  }\n\n  return { graph, plan }\n}\n\n/**\n * Performs a simple cycle detection for link edges.\n *\n * - Only considers edges with kind = 'link'; computed/source do not participate in the first version.\n * - On cycle detection, throws an error with path context to avoid infinite updates at runtime.\n */\nconst assertNoLinkCycles = (edges: ReadonlyArray<StateTraitGraphEdge>): void => {\n  const adjacency = new Map<string, string[]>()\n\n  for (const edge of edges) {\n    if (edge.kind !== 'link') continue\n    const list = adjacency.get(edge.from) ?? []\n    list.push(edge.to)\n    adjacency.set(edge.from, list)\n  }\n\n  const visited = new Set<string>()\n  const stack = new Set<string>()\n\n  const dfs = (node: string): void => {\n    if (stack.has(node)) {\n      throw new Error(\n        `[StateTrait.build] link cycle detected at field \"${node}\". ` +\n          'Please check link traits for circular dependencies.',\n      )\n    }\n    if (visited.has(node)) return\n    visited.add(node)\n    stack.add(node)\n\n    const nexts = adjacency.get(node)\n    if (nexts) {\n      for (const to of nexts) {\n        dfs(to)\n      }\n    }\n\n    stack.delete(node)\n  }\n\n  for (const node of adjacency.keys()) {\n    if (!visited.has(node)) {\n      dfs(node)\n    }\n  }\n}\n\nconst collectSchemaPaths = (\n  entries: ReadonlyArray<StateTraitEntry<any, string>>,\n): ReadonlyArray<StateTraitSchemaPathRef> => {\n  const byKey = new Map<string, StateTraitSchemaPathRef>()\n\n  const add = (ref: StateTraitSchemaPathRef): void => {\n    if (!ref.path) return\n    const k = `${ref.kind}|${ref.entryKind}|${ref.entryFieldPath}|${ref.ruleName ?? ''}|${ref.path}`\n    byKey.set(k, ref)\n  }\n\n  const getCheckWritebackPath = (entry: Extract<StateTraitEntry<any, string>, { readonly kind: 'check' }>): string => {\n    const wb = (entry.meta as any)?.writeback\n    const p = wb && typeof wb === 'object' ? (wb as any).path : undefined\n    const writebackPath = typeof p === 'string' && p.startsWith('errors.') ? p : undefined\n\n    if (writebackPath) return writebackPath\n\n    const fieldPath = entry.fieldPath\n    if (fieldPath.endsWith('[]')) {\n      return `errors.${fieldPath.slice(0, -2)}`\n    }\n    return `errors.${fieldPath}`\n  }\n\n  for (const entry of entries) {\n    add({\n      kind: 'fieldPath',\n      entryKind: entry.kind,\n      entryFieldPath: entry.fieldPath,\n      path: entry.fieldPath,\n    })\n\n    if (entry.kind === 'computed' || entry.kind === 'source') {\n      const deps = ((entry.meta as any)?.deps ?? []) as ReadonlyArray<string>\n      for (const dep of deps) {\n        add({\n          kind: 'dep',\n          entryKind: entry.kind,\n          entryFieldPath: entry.fieldPath,\n          path: dep,\n        })\n      }\n    }\n\n    if (entry.kind === 'link') {\n      add({\n        kind: 'link_from',\n        entryKind: 'link',\n        entryFieldPath: entry.fieldPath,\n        path: entry.meta.from as string,\n      })\n    }\n\n    if (entry.kind === 'check') {\n      add({\n        kind: 'check_writeback',\n        entryKind: 'check',\n        entryFieldPath: entry.fieldPath,\n        path: getCheckWritebackPath(entry),\n      })\n\n      const rules = ((entry.meta as any)?.rules ?? {}) as Record<string, any>\n      for (const name of Object.keys(rules)) {\n        const rule = rules[name]\n        if (!rule || typeof rule !== 'object') continue\n        const deps = (rule.deps ?? []) as ReadonlyArray<string>\n        for (const dep of deps) {\n          add({\n            kind: 'dep',\n            entryKind: 'check',\n            entryFieldPath: entry.fieldPath,\n            ruleName: name,\n            path: dep,\n          })\n        }\n      }\n    }\n  }\n\n  return Array.from(byKey.entries())\n    .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))\n    .map(([, v]) => v)\n}\n\n/**\n * Builds a StateTraitProgram from the given stateSchema and trait spec.\n *\n * - Pure function: does not depend on external Env / global state.\n * - Current implementation focuses on:\n *   - Normalizing Spec into entries.\n *   - Building a lightweight Graph / Plan from entries.\n *   - Running basic cycle detection for link edges.\n *\n * If we later need finer-grained dependency analysis (e.g. static analysis for computed/key),\n * evolve it inside this module without changing the public API surface.\n */\nexport const build = <S extends object>(\n  stateSchema: Schema.Schema<S, any>,\n  spec: StateTraitSpec<S>,\n): StateTraitProgram<S> => {\n  const entries = normalizeSpec(spec) as ReadonlyArray<StateTraitEntry<S, string>>\n  const nodeMetaByFieldPath = collectNodeMeta(spec)\n\n  // Phase 4 (US2): require explicit deps (Graph/diagnostics/replay treat deps as the single dependency source of truth).\n  for (const entry of entries) {\n    if (entry.kind === 'computed') {\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps === undefined) {\n        throw new Error(\n          `[StateTrait.build] Missing explicit deps for computed \"${entry.fieldPath}\". ` +\n            'Please use StateTrait.computed({ deps: [...], get: ... }).',\n        )\n      }\n    }\n    if (entry.kind === 'source') {\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps === undefined) {\n        throw new Error(\n          `[StateTrait.build] Missing explicit deps for source \"${entry.fieldPath}\". ` +\n            'Please provide meta.deps for StateTrait.source({ deps: [...], ... }).',\n        )\n      }\n    }\n    if (entry.kind === 'check') {\n      const rules = ((entry.meta as any)?.rules ?? {}) as Record<string, any>\n      for (const name of Object.keys(rules)) {\n        const rule = rules[name]\n        if (typeof rule === 'function' || !rule || typeof rule !== 'object') {\n          throw new Error(\n            `[StateTrait.build] Missing explicit deps for check \"${entry.fieldPath}\" rule \"${name}\". ` +\n              'Please use { deps: [...], validate: ... } form.',\n          )\n        }\n        if ((rule as any).deps === undefined) {\n          throw new Error(\n            `[StateTrait.build] Missing explicit deps for check \"${entry.fieldPath}\" rule \"${name}\". ` +\n              'Please provide deps: [...].',\n          )\n        }\n      }\n    }\n  }\n\n  const { graph, plan } = buildGraph(entries, nodeMetaByFieldPath)\n\n  // Run a cycle check for link edges to avoid obvious configuration errors.\n  assertNoLinkCycles(graph.edges)\n\n  return {\n    stateSchema,\n    spec,\n    entries: entries as ReadonlyArray<StateTraitEntry<any, string>>,\n    graph,\n    plan,\n    convergeIr: buildConvergeIr(stateSchema as any, entries as ReadonlyArray<StateTraitEntry<any, string>>),\n    schemaPaths: collectSchemaPaths(entries as ReadonlyArray<StateTraitEntry<any, string>>),\n  }\n}\n", "import type { Schema } from 'effect'\nimport type { StateAtPath, StateFieldPath } from './field-path.js'\nimport type { DirtyAllReason } from '../field-path.js'\nimport * as Meta from './meta.js'\nimport type { ConvergeStaticIrRegistry } from './converge-ir.js'\nimport type { ConvergeExecIr } from './converge-exec-ir.js'\n\n// StateTrait core model.\n// Keep the field semantics aligned with data-model.md / references/state-trait-core.md.\n\n/**\n * StateTraitSpec<S>\uFF1A\n * - The standard shape for the `traits` slot in a Module blueprint.\n * - Keys are constrained by StateFieldPath<S>; values are declarations for the corresponding scope (Entry / Node / List).\n */\nexport type StateTraitSpec<S> = S extends object\n  ? {\n      [Path in StateFieldPath<S> | '$root']?: StateTraitSpecValue<S, Path>\n    }\n  : never\n\nexport type StateTraitKind = 'computed' | 'source' | 'link' | 'externalStore' | 'check'\n\nexport type TraitLane = 'urgent' | 'nonUrgent'\n\n/**\n * TraitConvergeScheduling\uFF1A\n * - Scheduling semantics for converge/dirty-check (043): decides whether a step must converge within each transaction window.\n * - Default `immediate` (keeps legacy behavior); `deferred` takes effect only with explicit declaration + time-slicing enabled.\n */\nexport type TraitConvergeScheduling = 'immediate' | 'deferred'\n\nexport interface ComputedMeta<S, P> {\n  /**\n   * Explicit dependency field paths (required):\n   *\n   * - deps is the single source of truth for dependencies: Graph/ReverseClosure/incremental scheduling/perf optimizations rely on deps only.\n   * - In the DSL, `StateTrait.computed({ deps, get })` uses deps-as-args; it does not expose `(state) => ...`.\n   * - During build, `get(...depsValues)` is lowered into `derive(state)` for runtime execution, but the dependency read-set remains deps-based.\n   * - In dev-mode, if actual reads in `derive(state)` disagree with deps, a `deps_mismatch` diagnostic warning is emitted.\n   *\n   * - For root scope: deps are StateFieldPath<State>.\n   * - For list.item scope: deps are StateFieldPath<Item> (relative paths; build will prefix them).\n   */\n  readonly deps: ReadonlyArray<StateFieldPath<S>>\n  readonly derive: (state: Readonly<S>) => StateAtPath<S, P>\n  /**\n   * Optional: equality predicate (used to skip no-op writebacks).\n   */\n  readonly equals?: (prev: StateAtPath<S, P>, next: StateAtPath<S, P>) => boolean\n  /**\n   * Converge scheduling (043): defaults to immediate.\n   */\n  readonly scheduling?: TraitConvergeScheduling\n}\n\nexport interface SourceMeta<S, P> {\n  readonly deps: ReadonlyArray<StateFieldPath<S>>\n  /**\n   * Logical resource identifier (e.g. \"user/profile\").\n   *\n   * - In the StateTrait.source DSL, `resource` is stored here during build.\n   * - data-model.md calls it resourceId; we keep the DSL naming here to avoid confusion.\n   */\n  readonly resource: string\n  /**\n   * Rule for computing the key required to access the resource.\n   *\n   * - deps is the single source of truth for dependencies: Graph/ReverseClosure/incremental scheduling/perf optimizations rely on deps only.\n   * - In the DSL, `StateTrait.source({ deps, key })` uses deps-as-args; it does not expose `(state) => ...`.\n   * - During build, `key(...depsValues)` is lowered into `key(state)` for runtime execution, but the dependency read-set remains deps-based.\n   *\n   * - Returning undefined means the resource is inactive under the current state (should be recycled to idle).\n   */\n  readonly key: (state: Readonly<S>) => unknown\n  readonly triggers?: ReadonlyArray<'onMount' | 'onKeyChange' | 'manual'>\n  readonly debounceMs?: number\n  readonly concurrency?: 'switch' | 'exhaust-trailing'\n  /**\n   * Serializable metadata for devtools/docs (whitelisted fields).\n   */\n  readonly meta?: Meta.TraitMeta\n  /**\n   * Reserved: build may populate the field path this trait is attached to, for easier debugging.\n   */\n  readonly _fieldPath?: P\n}\n\nexport interface LinkMeta<S> {\n  /**\n   * Source field path (also constrained by StateFieldPath<S>).\n   */\n  readonly from: StateFieldPath<S>\n  /**\n   * Converge scheduling (043): defaults to immediate.\n   */\n  readonly scheduling?: TraitConvergeScheduling\n}\n\nexport interface ExternalStoreLike<T> {\n  readonly getSnapshot: () => T\n  readonly getServerSnapshot?: () => T\n  readonly subscribe: (listener: () => void) => () => void\n}\n\nexport interface ExternalStoreMeta<S, P, T = unknown> {\n  readonly store: ExternalStoreLike<T>\n  readonly select?: (snapshot: T) => StateAtPath<S, P>\n  readonly equals?: (prev: StateAtPath<S, P>, next: StateAtPath<S, P>) => boolean\n  readonly coalesceWindowMs?: number\n  readonly priority?: TraitLane\n  readonly meta?: Meta.TraitMeta\n  readonly _fieldPath?: P\n}\n\nexport type CheckRule<Input = unknown, Ctx = unknown> = {\n  readonly deps: ReadonlyArray<string>\n  /**\n   * validateOn\uFF1A\n   * - Affects only auto validation phases (onChange/onBlur); submit/manual always run.\n   * - Empty array disables auto validation (only submit/manual run).\n   */\n  readonly validateOn?: ReadonlyArray<'onChange' | 'onBlur'>\n  readonly validate: (input: Input, ctx: Ctx) => unknown\n  readonly meta?: Meta.TraitMeta\n}\n\nexport interface CheckMeta<Input = unknown, Ctx = unknown> {\n  /**\n   * Named rule set (used for deterministic merge and diagnostics display).\n   */\n  readonly rules: Readonly<Record<string, CheckRule<Input, Ctx>>>\n  /**\n   * Error-tree writeback (Phase 2: structure only; concrete writeback semantics land in later phases).\n   */\n  readonly writeback?: {\n    readonly kind: 'errors'\n    readonly path?: string\n  }\n}\n\n/**\n * StateTraitEntry<S, P>\uFF1A\n * - A single Trait configuration attached to a field path P.\n * - kind and meta always come together and are used to dispatch behavior during build/install.\n */\nexport type StateTraitEntry<S = unknown, P extends string = StateFieldPath<S>> =\n  | {\n      readonly fieldPath: P\n      readonly kind: 'computed'\n      readonly meta: ComputedMeta<S, P>\n    }\n  | {\n      readonly fieldPath: P\n      readonly kind: 'source'\n      readonly meta: SourceMeta<S, P>\n    }\n  | {\n      readonly fieldPath: P\n      readonly kind: 'link'\n      readonly meta: LinkMeta<S>\n    }\n  | {\n      readonly fieldPath: P\n      readonly kind: 'externalStore'\n      readonly meta: ExternalStoreMeta<S, P>\n    }\n  | {\n      readonly fieldPath: P\n      readonly kind: 'check'\n      readonly meta: CheckMeta<unknown, unknown>\n    }\n\nexport interface StateTraitNode<Input = unknown, Ctx = unknown> {\n  readonly _tag: 'StateTraitNode'\n  readonly computed?: StateTraitEntry<Input, any> | Readonly<Record<string, StateTraitEntry<Input, any>>>\n  readonly source?: StateTraitEntry<Input, any> | Readonly<Record<string, StateTraitEntry<Input, any>>>\n  readonly link?: StateTraitEntry<Input, any> | Readonly<Record<string, StateTraitEntry<Input, any>>>\n  readonly externalStore?: StateTraitEntry<Input, any> | Readonly<Record<string, StateTraitEntry<Input, any>>>\n  readonly check?: Readonly<Record<string, CheckRule<Input, Ctx>>>\n  readonly meta?: Meta.TraitMeta\n}\n\nexport interface StateTraitList<Item = unknown> {\n  readonly _tag: 'StateTraitList'\n  readonly item?: StateTraitNode<Item, any>\n  readonly list?: StateTraitNode<ReadonlyArray<Item>, any>\n  readonly identityHint?: {\n    readonly trackBy?: string\n  }\n}\n\nexport type StateTraitSpecValue<S, P extends string> =\n  | StateTraitEntry<S, P>\n  | StateTraitNode<any, any>\n  | StateTraitList<any>\n\n/**\n * StateTraitField\uFF1A\n * - Represents a field node in State (whether or not traits are attached).\n * - Normalized from StateTraitSpec during build.\n */\nexport interface StateTraitField {\n  readonly id: string\n  readonly path: string\n  readonly displayName?: string\n  readonly valueType?: string\n  readonly traits: ReadonlyArray<StateTraitFieldTrait>\n}\n\n/**\n * StateTraitFieldTrait\uFF1A\n * - A structured description of a field trait (computed / source / link).\n * - meta matches StateTraitEntry.meta; deps is the set of field paths this trait depends on.\n */\nexport interface StateTraitFieldTrait {\n  readonly fieldId: string\n  readonly kind: StateTraitKind\n  readonly meta:\n    | ComputedMeta<unknown, string>\n    | SourceMeta<unknown, string>\n    | LinkMeta<unknown>\n    | ExternalStoreMeta<unknown, string>\n    | CheckMeta<unknown, unknown>\n  readonly deps: ReadonlyArray<string>\n}\n\n/**\n * StateTraitResource\uFF1A\n * - Describes the logical resource metadata that a source trait depends on.\n * - Concrete ResourceSpec implementation lives in the Resource namespace; this keeps only trait-perspective dependency info.\n */\nexport interface StateTraitResource {\n  readonly resourceId: string\n  readonly keySelector: string\n  readonly keyExample?: unknown\n  readonly ownerFields: ReadonlyArray<string>\n  readonly meta?: Meta.TraitMeta\n  readonly metaOrigin?: string\n  readonly metaConflicts?: ReadonlyArray<Meta.TraitMetaConflict>\n}\n\n/**\n * Graph Node / Edge\uFF1A\n * - Nodes typically correspond to fields.\n * - Edges represent dependencies between fields, or between fields and resources.\n */\nexport interface StateTraitGraphNode {\n  readonly id: string\n  readonly field: StateTraitField\n  readonly traits: ReadonlyArray<StateTraitFieldTrait>\n  readonly meta?: Meta.TraitMeta\n}\n\nexport interface StateTraitGraphEdge {\n  readonly id: string\n  readonly from: string\n  readonly to: string\n  readonly kind: 'computed' | 'link' | 'source-dep' | 'check-dep'\n}\n\n/**\n * StateTraitGraph\uFF1A\n * - Structural view of the StateTrait engine: a graph of nodes and dependency edges.\n * - Used by Devtools / Studio / Runtime for structural analysis and visualization.\n */\nexport interface StateTraitGraph {\n  readonly _tag: 'StateTraitGraph'\n  readonly nodes: ReadonlyArray<StateTraitGraphNode>\n  readonly edges: ReadonlyArray<StateTraitGraphEdge>\n  readonly resources: ReadonlyArray<StateTraitResource>\n  readonly meta?: {\n    readonly moduleId?: string\n    readonly version?: string\n  }\n}\n\n/**\n * StateTraitPlanStep\uFF1A\n * - The smallest instruction unit used by StateTrait.install / Runtime execution.\n * - Derived from the graph; used at runtime to install watchers or trigger external calls.\n */\nexport interface StateTraitPlanStep {\n  readonly id: string\n  readonly kind: 'computed-update' | 'link-propagate' | 'source-refresh' | 'external-store-sync' | 'check-validate'\n  readonly targetFieldPath?: string\n  readonly sourceFieldPaths?: ReadonlyArray<string>\n  readonly resourceId?: string\n  readonly keySelectorId?: string\n  readonly debugInfo?: {\n    readonly graphNodeId?: string\n    readonly graphEdgeId?: string\n  }\n}\n\n/**\n * StateTraitPlan\uFF1A\n * - Execution plan summarizing all trait behaviors for a module.\n * - install mounts behaviors onto Bound API / EffectOp pipelines according to the plan.\n */\nexport interface StateTraitPlan {\n  readonly _tag: 'StateTraitPlan'\n  readonly moduleId?: string\n  readonly steps: ReadonlyArray<StateTraitPlanStep>\n  readonly meta?: Record<string, unknown>\n}\n\nexport type StateTraitSchemaPathKind = 'fieldPath' | 'dep' | 'link_from' | 'check_writeback'\n\nexport interface StateTraitSchemaPathRef {\n  readonly kind: StateTraitSchemaPathKind\n  readonly entryKind: StateTraitKind\n  readonly entryFieldPath: string\n  readonly path: string\n  readonly ruleName?: string\n}\n\n/**\n * StateTraitProgram<S>\uFF1A\n * - Program output of the StateTrait engine; the unified entrypoint for Runtime / Devtools.\n * - stateSchema and spec preserve original inputs; graph/plan are internal IR.\n */\nexport interface StateTraitProgram<S> {\n  readonly stateSchema: Schema.Schema<S, any>\n  readonly spec: StateTraitSpec<S>\n  /**\n   * Program.entries\uFF1A\n   * - Minimal rule set normalized from spec (including node/list/$root) during build.\n   * - Phase 2 focuses on a readable/diagnosable structure; later phases add execution and converge semantics.\n   */\n  readonly entries: ReadonlyArray<StateTraitEntry<any, string>>\n  readonly graph: StateTraitGraph\n  readonly plan: StateTraitPlan\n  readonly convergeIr?: ConvergeStaticIrRegistry\n  readonly convergeExecIr?: ConvergeExecIr\n  /**\n   * schemaPaths\uFF1A\n   * - Path references that must exist in stateSchema, collected from entries during build; dev-only diagnostics (e.g. schema_mismatch).\n   * - When diagnostics=off, validation can be skipped entirely to keep near-zero cost.\n   */\n  readonly schemaPaths?: ReadonlyArray<StateTraitSchemaPathRef>\n}\n\n/**\n * Build a normalized entry list from StateTraitSpec.\n *\n * - Phase 2: supports structural expansion of node/list/$root and fills/prefixes fieldPath/deps when necessary.\n * - Later phases may extend validation here (e.g. detecting duplicates, override rules, etc.).\n */\nexport const normalizeSpec = <S>(spec: StateTraitSpec<S>): ReadonlyArray<StateTraitEntry<any, string>> => {\n  const entries: Array<StateTraitEntry<any, string>> = []\n\n  const isNode = (value: unknown): value is StateTraitNode<any, any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitNode'\n\n  const isList = (value: unknown): value is StateTraitList<any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitList'\n\n  const joinPath = (prefix: string, suffix: string): string => {\n    if (!prefix) return suffix\n    if (!suffix) return prefix\n    return `${prefix}.${suffix}`\n  }\n\n  const prefixDeps = (deps: ReadonlyArray<string> | undefined, prefix: string): ReadonlyArray<string> => {\n    if (!deps || deps.length === 0) return []\n    return deps.map((d) => (prefix ? joinPath(prefix, d) : d))\n  }\n\n  const normalizeEntry = (\n    entry: StateTraitEntry<any, string>,\n    fieldPath: string,\n    depPrefix: string,\n  ): StateTraitEntry<any, string> => {\n    if (entry.kind === 'computed') {\n      const meta = entry.meta as any\n      const rawDeps = meta.deps as ReadonlyArray<string> | undefined\n      const deps = rawDeps !== undefined ? prefixDeps(rawDeps, depPrefix) : undefined\n      return {\n        ...(entry as any),\n        fieldPath,\n        meta: { ...meta, deps },\n      }\n    }\n    if (entry.kind === 'source') {\n      const meta = entry.meta as any\n      const rawDeps = meta.deps as ReadonlyArray<string> | undefined\n      const deps = rawDeps !== undefined ? prefixDeps(rawDeps, depPrefix) : undefined\n      return {\n        ...(entry as any),\n        fieldPath,\n        meta: { ...meta, deps, _fieldPath: fieldPath },\n      }\n    }\n    if (entry.kind === 'externalStore') {\n      const meta = entry.meta as any\n      return {\n        ...(entry as any),\n        fieldPath,\n        meta: { ...meta, _fieldPath: fieldPath },\n      }\n    }\n    if (entry.kind === 'link') {\n      const meta = entry.meta as any\n      const from = prefixDeps([meta.from as string], depPrefix)[0] ?? meta.from\n      return {\n        ...(entry as any),\n        fieldPath,\n        meta: { ...meta, from },\n      }\n    }\n    // check: Phase 2 adjusts fieldPath only; deps are still collected from meta.rules during build.\n    return {\n      ...(entry as any),\n      fieldPath,\n    }\n  }\n\n  const expandNode = (\n    scopeId: string,\n    joinPrefix: string,\n    node: StateTraitNode<any, any>,\n    options?: {\n      /**\n       * Prefix for check deps: default semantics for list-scope checks (deps are relative to a row item rather than the list root).\n       *\n       * - item scope: depsPrefix = `${listPath}[]` (matches joinPrefix).\n       * - list scope: fieldPath = `${listPath}`, but depsPrefix should be `${listPath}[]`.\n       */\n      readonly checkDepsPrefix?: string\n    },\n  ): void => {\n    const addEntry = (relativeTarget: string, raw: StateTraitEntry<any, string>): void => {\n      const rel = (raw as any).fieldPath ?? relativeTarget\n      const fieldPath = joinPrefix ? joinPath(joinPrefix, String(rel)) : String(rel)\n      entries.push(normalizeEntry(raw, fieldPath, joinPrefix))\n    }\n\n    const expandMaybeRecord = (\n      value: StateTraitEntry<any, any> | Readonly<Record<string, StateTraitEntry<any, any>>> | undefined,\n    ): void => {\n      if (!value) return\n      if (typeof (value as any).kind === 'string') {\n        addEntry('', value as any)\n        return\n      }\n      const record = value as Readonly<Record<string, StateTraitEntry<any, any>>>\n      for (const key in record) {\n        if (!Object.prototype.hasOwnProperty.call(record, key)) continue\n        const entry = record[key]\n        if (!entry) continue\n        addEntry(key, entry as any)\n      }\n    }\n\n    expandMaybeRecord(node.computed)\n    expandMaybeRecord(node.source)\n    expandMaybeRecord(node.link)\n    expandMaybeRecord(node.externalStore)\n\n    if (node.check) {\n      const rules: Record<string, CheckRule<any, any>> = {}\n      const checkDepsPrefix = options?.checkDepsPrefix ?? (joinPrefix.endsWith('[]') ? joinPrefix : '')\n\n      const prefixCheckDeps = (deps: ReadonlyArray<string> | undefined): ReadonlyArray<string> => {\n        if (!deps || deps.length === 0) return []\n        return deps.map((d) => (d === '' ? scopeId : checkDepsPrefix ? joinPath(checkDepsPrefix, d) : d))\n      }\n      for (const name of Object.keys(node.check)) {\n        const rule = (node.check as any)[name] as CheckRule<any, any>\n        if (typeof rule === 'function') {\n          rules[name] = rule\n          continue\n        }\n        if (rule && typeof rule === 'object') {\n          const meta = Meta.sanitize((rule as any).meta)\n          rules[name] = {\n            ...rule,\n            deps: prefixCheckDeps(rule.deps),\n            meta,\n          }\n          continue\n        }\n        // Invalid input: ignore (later phases may promote this into a build-time config error).\n      }\n\n      entries.push({\n        fieldPath: scopeId,\n        kind: 'check',\n        meta: {\n          rules,\n          writeback: { kind: 'errors' },\n        },\n      } as StateTraitEntry<any, any>)\n    }\n  }\n\n  for (const key in spec) {\n    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue\n    const raw = spec[key as keyof typeof spec] as StateTraitSpecValue<S, any> | undefined\n    if (!raw) continue\n\n    if (isList(raw)) {\n      const listPath = key\n      if (raw.item) {\n        expandNode(`${listPath}[]`, `${listPath}[]`, raw.item)\n      }\n      if (raw.list) {\n        expandNode(listPath, listPath, raw.list, {\n          checkDepsPrefix: `${listPath}[]`,\n        })\n      }\n      continue\n    }\n\n    if (isNode(raw)) {\n      if (key === '$root') {\n        expandNode('$root', '', raw)\n      } else {\n        expandNode(key, key, raw)\n      }\n      continue\n    }\n\n    const entry = raw as any as StateTraitEntry<any, string>\n    const fieldPath = (entry as any).fieldPath ?? key\n    entries.push(normalizeEntry(entry, String(fieldPath), ''))\n  }\n\n  return entries\n}\n\n/**\n * collectNodeMeta\uFF1A\n * - Extract StateTraitNode.meta (whitelisted fields) from StateTraitSpec for devtools structural display.\n * - meta is for diagnostics/display only and does not participate in runtime semantics.\n */\nexport const collectNodeMeta = <S>(spec: StateTraitSpec<S>): ReadonlyMap<string, Meta.TraitMeta> => {\n  const out = new Map<string, Meta.TraitMeta>()\n\n  const isNode = (value: unknown): value is StateTraitNode<any, any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitNode'\n\n  const isList = (value: unknown): value is StateTraitList<any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitList'\n\n  const add = (scopeId: string, node: StateTraitNode<any, any>): void => {\n    const meta = Meta.sanitize(node.meta)\n    if (meta) out.set(scopeId, meta)\n  }\n\n  for (const key in spec) {\n    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue\n    const raw = spec[key as keyof typeof spec] as StateTraitSpecValue<S, any> | undefined\n    if (!raw) continue\n\n    if (isList(raw)) {\n      const listPath = key\n      if (raw.item) add(`${listPath}[]`, raw.item)\n      if (raw.list) add(listPath, raw.list)\n      continue\n    }\n\n    if (isNode(raw)) {\n      if (key === '$root') add('$root', raw)\n      else add(key, raw)\n      continue\n    }\n  }\n\n  return out\n}\n\n// ---- Converge (013) evidence model ----\n\nexport type TraitConvergeRequestedMode = 'auto' | 'full' | 'dirty'\nexport type TraitConvergeExecutedMode = 'full' | 'dirty'\nexport type TraitConvergeOutcome = 'Converged' | 'Noop' | 'Degraded'\n\nexport type TraitConvergeConfigScope = 'provider' | 'runtime_module' | 'runtime_default' | 'builtin'\n\nexport type TraitConvergeReason =\n  | 'cold_start'\n  | 'cache_hit'\n  | 'cache_miss'\n  | 'budget_cutoff'\n  | 'near_full'\n  | 'unknown_write'\n  | 'dirty_all'\n  | 'generation_bumped'\n  | 'low_hit_rate_protection'\n  | 'module_override'\n  | 'time_slicing_immediate'\n  | 'time_slicing_deferred'\n\nexport interface TraitConvergeStepStats {\n  readonly totalSteps: number\n  readonly executedSteps: number\n  readonly skippedSteps: number\n  readonly changedSteps: number\n  readonly affectedSteps?: number\n}\n\nexport interface TraitConvergeDirtySummary {\n  readonly dirtyAll: boolean\n  readonly reason?: DirtyAllReason\n  readonly rootCount?: number\n  readonly rootIds?: ReadonlyArray<number>\n  readonly rootIdsTruncated?: boolean\n}\n\nexport interface TraitConvergePlanCacheEvidence {\n  readonly capacity: number\n  readonly size: number\n  readonly hits: number\n  readonly misses: number\n  readonly evicts: number\n  readonly hit: boolean\n  readonly keySize?: number\n  readonly missReason?: 'cold_start' | 'generation_bumped' | 'not_cached' | 'unknown'\n  readonly disabled?: boolean\n  readonly disableReason?: 'low_hit_rate' | 'generation_thrash' | 'manual_override' | 'unknown'\n}\n\nexport type TraitConvergeGenerationBumpReason =\n  | 'writers_changed'\n  | 'deps_changed'\n  | 'logic_installed'\n  | 'logic_uninstalled'\n  | 'imports_changed'\n  | 'unknown'\n\nexport interface TraitConvergeGenerationEvidence {\n  readonly generation: number\n  readonly generationBumpCount?: number\n  readonly lastBumpReason?: TraitConvergeGenerationBumpReason\n}\n\nexport interface TraitConvergeStaticIrEvidence {\n  readonly fieldPathCount: number\n  readonly stepCount: number\n  readonly buildDurationMs?: number\n}\n\nexport interface TraitConvergeHotspot {\n  readonly kind?: string\n  readonly stepId: number\n  readonly outFieldPathId?: number\n  readonly durationMs: number\n  readonly changed: boolean\n}\n\nexport interface TraitConvergeTimeSlicingSummary {\n  readonly scope: 'all' | 'immediate' | 'deferred'\n  readonly immediateStepCount: number\n  readonly deferredStepCount: number\n}\n\nexport interface TraitConvergeDiagnosticsSamplingSummary {\n  /**\n   * Deterministic sampling: use stable txnSeq as an anchor and sample every N transactions.\n   * - sampled=true means this invocation captured per-step timings and produced hotspots.\n   */\n  readonly strategy: 'txnSeq_interval'\n  readonly sampleEveryN: number\n  readonly topK: number\n  readonly sampled: boolean\n}\n\nexport interface TraitConvergeDecisionSummary {\n  readonly requestedMode: TraitConvergeRequestedMode\n  readonly executedMode: TraitConvergeExecutedMode\n  readonly outcome: TraitConvergeOutcome\n  readonly configScope: TraitConvergeConfigScope\n  readonly staticIrDigest: string\n  readonly executionBudgetMs: number\n  readonly executionDurationMs: number\n  readonly decisionBudgetMs?: number\n  readonly decisionDurationMs?: number\n  readonly reasons: ReadonlyArray<TraitConvergeReason>\n  readonly stepStats: TraitConvergeStepStats\n  readonly dirty?: TraitConvergeDirtySummary\n  readonly cache?: TraitConvergePlanCacheEvidence\n  readonly generation?: TraitConvergeGenerationEvidence\n  readonly staticIr?: TraitConvergeStaticIrEvidence\n  readonly timeSlicing?: TraitConvergeTimeSlicingSummary\n  readonly thresholds?: { readonly floorRatio?: number }\n  readonly diagnosticsSampling?: TraitConvergeDiagnosticsSamplingSummary\n  readonly top3?: ReadonlyArray<TraitConvergeHotspot>\n}\n", "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 } from '../runtime/core/StateTransaction.js'\nimport type { FieldPath, FieldPathId } from '../field-path.js'\nimport { normalizeFieldPath } from '../field-path.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 { StateTraitEntry, StateTraitPlanStep, StateTraitProgram } 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: (\n    path: string | FieldPath | FieldPathId | undefined,\n    reason: PatchReason,\n    from?: unknown,\n    to?: unknown,\n    traitNodeId?: string,\n    stepId?: number,\n  ) => void\n}\n\nconst onceInRunSession = (key: string): Effect.Effect<boolean, never, any> =>\n  Effect.serviceOption(RunSessionTag).pipe(\n    Effect.map((maybe) => (Option.isSome(maybe) ? maybe.value.local.once(key) : true)),\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 = (params: {\n  readonly moduleId?: string\n  readonly instanceId?: string\n  readonly kind: 'computed' | 'source'\n  readonly fieldPath: string\n  readonly diff: DepsTrace.DepsDiff\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<EffectOp.MiddlewareStack, never, any> =>\n  Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag).pipe(\n    Effect.map((maybe) => (Option.isSome(maybe) ? maybe.value.stack : [])),\n  )\n\nconst recordTraitPatch = (\n  bound: BoundApi<any, any>,\n  path: string,\n  reason: PatchReason,\n  from?: unknown,\n  to?: unknown,\n  traitNodeId?: string,\n): void => {\n  const normalized = normalizeFieldPath(path) ?? []\n  try {\n    const internals = getBoundInternals(bound as any)\n    internals.txn.recordStatePatch(normalized, reason, from, to, traitNodeId)\n  } catch {\n    // no-op for legacy/mocked bound\n  }\n}\n\nconst recordReplayEvent = (bound: BoundApi<any, any>, event: ReplayLog.ReplayLogEvent): 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 = (bound: BoundApi<any, any>): { 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) => {\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, fieldPath, reason, prev, next, traitNodeId)\n    })\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) => {\n      const current = RowId.getAtPath(draft, fieldPath)\n      const currentKeyHash = 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, fieldPath, reason, prev, next, traitNodeId)\n    })\n    return wrote\n  })\n\n/**\n * syncIdleInTransaction\uFF1A\n * - Synchronously evaluate all source.key(state) within the transaction window.\n * - If a key becomes empty (undefined), synchronously reset the field to an idle snapshot (avoid tearing).\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: evaluate key per row by index, and synchronously write back idle for inactive rows.\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(listItem.listPath, index, listItem.itemPath)\n          const prev = RowId.getAtPath(draft, concretePath)\n          const prevStatus = 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 = prev && typeof prev === 'object' ? (prev as any).status : undefined\n      if (prevStatus === 'idle') {\n        // Still ensure data/error are cleared.\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-refresh'\n\n    const nextDraft = create(draft, (next) => {\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      const normalized = normalizeFieldPath(u.fieldPath) ?? []\n      ctx.recordPatch(normalized, reason, u.prev, Snapshot.idle(), `source:${u.fieldPath}:idle`)\n    }\n  })\n\n/**\n * installSourceRefresh\uFF1A\n * - Register the refresh implementation for a single source field (ResourceSnapshot + keyHash gate + concurrency).\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: in-flight gating by RowID (avoid writing to the wrong row under insert/remove/reorder).\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      // Never write the snapshot back to the whole item (it would overwrite business values).\n      return Effect.void\n    }\n\n    const concurrency = (entry.meta as any).concurrency as 'switch' | 'exhaust-trailing' | 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    // When a row is removed: clear trailing/inFlight references to avoid wrong attribution or memory leaks.\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) => {\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, concretePath, reason, prev, next, step.debugInfo?.graphNodeId)\n        })\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) => {\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 = 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, concretePath, reason, prev, next, step.debugInfo?.graphNodeId)\n        })\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 ? undefined : 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-refresh',\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            // Let loading commit become visible first, then replay the settled phase (preserve the async-resource timeline shape).\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-refresh',\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-refresh',\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-refresh',\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-refresh',\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: IO fibers must detach from the sync-transaction FiberRef; otherwise they'd be misclassified as \"in txn window\"\n        // and block subsequent writeback entrypoints.\n        const fiber = yield* Effect.forkScoped(Effect.locally(TaskRunner.inSyncTransactionFiber, false)(io))\n        const myGen = (gen += 1)\n        inFlight.set(rowId, { gen: myGen, fiber, keyHash })\n\n        yield* Effect.forkScoped(\n          Effect.locally(\n            TaskRunner.inSyncTransactionFiber,\n            false,\n          )(\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(rowId, next.key, next.keyHash, replayMode, replayLog)\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: trace deps once for the first row (diagnostics only; does not affect execution semantics).\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) => (r ? `${listPath}[].${r}` : `${listPath}[]`))\n              const diff = DepsTrace.diffDeps(((entry.meta as any).deps ?? []) as ReadonlyArray<string>, prefixedReads)\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            // If it's already clean idle, avoid redundant writeback (prevents meaningless patches and UI jitter).\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-refresh',\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 unchanged: avoid redundant refresh while keeping in-flight.\n          if (!force && current && current.keyHash === h) {\n            continue\n          }\n\n          // Not in-flight: if snapshot.keyHash already matches, treat it as already up-to-date (avoid full refresh and row jitter).\n          const prevKeyHash =\n            prevSnapshot && typeof prevSnapshot === 'object' ? (prevSnapshot as any).keyHash : 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-refresh',\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            // Do not rely on cancellation correctness: stale writebacks are dropped by the keyHash gate.\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 'switch' | 'exhaust-trailing' | 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: synchronously write a loading snapshot (within the current transaction window).\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-refresh',\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: run in a background fiber (avoid blocking the current transaction).\n      const io = Effect.gen(function* () {\n        if (replayMode === 'replay' && replayLog) {\n          // Let loading commit become visible first, then replay the settled phase (preserve the async-resource timeline shape).\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-refresh',\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-refresh',\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(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          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: use a keyHash gate to prevent stale results from writing back onto a new key.\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-refresh',\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-refresh',\n            `source:${fieldPath}:error`,\n            step.debugInfo?.graphNodeId,\n            event,\n          )\n          if (wroteError) {\n            yield* recordSnapshot(replayMode, replayLog, event)\n          }\n        }\n      }).pipe(Effect.catchAllCause(() => Effect.void))\n\n      // Do not wait for IO completion: forkScoped into the runtime scope so unmount will interrupt automatically.\n      const fiber = yield* Effect.forkScoped(Effect.locally(TaskRunner.inSyncTransactionFiber, false)(io))\n      const myGen = (gen += 1)\n      inFlight = { gen: myGen, fiber, keyHash }\n\n      // After in-flight completes, clean up; in exhaust-trailing mode, run one trailing fetch if present.\n      yield* Effect.forkScoped(\n        Effect.locally(\n          TaskRunner.inSyncTransactionFiber,\n          false,\n        )(\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(next.key, next.keyHash, replayMode, replayLog)\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: detect mismatch between actual reads in keySelector and declared deps (diagnostics only; does not affect execution semantics).\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(((entry.meta as any).deps ?? []) as ReadonlyArray<string>, traced.reads)\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 becomes empty: synchronously clear to idle (and interrupt in-flight).\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-refresh',\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      // Default semantics: when a non-idle snapshot already exists for the same keyHash, refresh should be a no-op when possible\n      // (avoid duplicate IO/writeback). Explicit refresh/invalidate can bypass via force.\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' ? (currentSnapshot as any).keyHash : undefined\n        const currentStatus =\n          currentSnapshot && typeof currentSnapshot === 'object' ? (currentSnapshot as any).status : undefined\n        if (currentStatus && currentStatus !== 'idle' && currentKeyHash === h) {\n          return\n        }\n      }\n\n      if (mode === 'exhaust-trailing' && inFlight) {\n        // Busy: record trailing and update loading immediately; stale in-flight writebacks will be blocked by the keyHash gate.\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-refresh',\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 => 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  // Drop strict prefix paths (e.g. if both profile and profile.id are read, keep only the more specific profile.id).\n  const isPrefix = (prefix: string, full: string): boolean => 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 => declared === read || read.startsWith(declared + '.')\n\nexport const diffDeps = (declared: ReadonlyArray<string>, reads: ReadonlyArray<string>): 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>(fn: (state: any) => T, state: unknown): 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", "import { Effect, FiberRef, Option } from 'effect'\nimport * as SchemaAST from 'effect/SchemaAST'\nimport * as Debug from '../runtime/core/DebugSink.js'\nimport { isDevEnv } from '../runtime/core/env.js'\nimport { RunSessionTag } from '../observability/runSession.js'\nimport { normalizeFieldPath } from '../field-path.js'\nimport * as DepsTrace from './deps-trace.js'\nimport type { ConvergeContext } from './converge.types.js'\nimport type { StateTraitProgram, StateTraitSchemaPathRef } from './model.js'\n\nconst onceKeysFallback = new Set<string>()\n\nexport const onceInRunSession = (key: string): Effect.Effect<boolean> =>\n  Effect.serviceOption(RunSessionTag).pipe(\n    Effect.map((maybe) => {\n      if (Option.isSome(maybe)) {\n        return maybe.value.local.once(key)\n      }\n      if (onceKeysFallback.has(key)) return false\n      onceKeysFallback.add(key)\n      return 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\nexport const emitDepsMismatch = (params: {\n  readonly moduleId?: string\n  readonly instanceId?: string\n  readonly kind: 'computed' | 'source'\n  readonly fieldPath: string\n  readonly diff: DepsTrace.DepsDiff\n}): Effect.Effect<void> => {\n  return Effect.gen(function* () {\n    const key = `${params.moduleId ?? 'unknown'}::${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}\n\nconst schemaHasPath = (\n  ast: SchemaAST.AST,\n  segments: ReadonlyArray<string>,\n  seen: Set<SchemaAST.AST> = new Set(),\n): boolean => {\n  if (segments.length === 0) return true\n\n  let current = ast\n\n  // unwrap Suspend/Refinement (common for recursive schemas and branded schemas)\n  while (true) {\n    if (SchemaAST.isSuspend(current)) {\n      if (seen.has(current)) {\n        // Recursion: if we can't statically decide further, allow conservatively to avoid false positives.\n        return true\n      }\n      seen.add(current)\n      current = current.f()\n      continue\n    }\n    if (SchemaAST.isRefinement(current)) {\n      current = current.from\n      continue\n    }\n    break\n  }\n\n  // Transformation: prefer `to` (decoded shape), but also allow `from` to reduce false positives.\n  if (SchemaAST.isTransformation(current)) {\n    return schemaHasPath(current.to, segments, seen) || schemaHasPath(current.from, segments, seen)\n  }\n\n  if (SchemaAST.isUnion(current)) {\n    return current.types.some((t) => schemaHasPath(t, segments, seen))\n  }\n\n  if (SchemaAST.isTupleType(current)) {\n    const candidates: Array<SchemaAST.AST> = []\n    for (const e of current.elements) candidates.push(e.type)\n    for (const r of current.rest) candidates.push(r.type)\n    if (candidates.length === 0) return true\n    return candidates.some((t) => schemaHasPath(t, segments, seen))\n  }\n\n  if (SchemaAST.isTypeLiteral(current)) {\n    const [head, ...tail] = segments\n\n    for (const ps of current.propertySignatures) {\n      if (String(ps.name) !== head) continue\n      return schemaHasPath(ps.type, tail, seen)\n    }\n\n    // index signature: open objects like Record<string, T> allow any key\n    for (const sig of current.indexSignatures) {\n      let param: SchemaAST.AST = sig.parameter as unknown as SchemaAST.AST\n      while (SchemaAST.isRefinement(param)) {\n        param = param.from\n      }\n      const tag = (param as any)?._tag\n      if (tag === 'StringKeyword' || tag === 'TemplateLiteral') {\n        return schemaHasPath(sig.type, tail, seen)\n      }\n    }\n\n    return false\n  }\n\n  const tag = (current as any)?._tag\n  if (tag === 'AnyKeyword' || tag === 'UnknownKeyword' || tag === 'ObjectKeyword' || tag === 'Declaration') {\n    return true\n  }\n\n  return false\n}\n\nconst schemaHasFieldPath = (stateSchemaAst: SchemaAST.AST, path: string): boolean => {\n  if (!path) return true\n  if (path === '$root') return true\n\n  const normalized = normalizeFieldPath(path)\n  if (!normalized) return false\n\n  const segs = normalized[0] === '$root' ? normalized.slice(1) : normalized\n  return schemaHasPath(stateSchemaAst, segs)\n}\n\nconst formatSchemaMismatchLine = (ref: StateTraitSchemaPathRef): string => {\n  if (ref.kind === 'fieldPath') {\n    return `- ${ref.entryKind} \"${ref.entryFieldPath}\" fieldPath=\"${ref.path}\"`\n  }\n  if (ref.kind === 'dep') {\n    const rule = ref.ruleName ? ` rule=\"${ref.ruleName}\"` : ''\n    return `- ${ref.entryKind} \"${ref.entryFieldPath}\" deps=\"${ref.path}\"${rule}`\n  }\n  if (ref.kind === 'link_from') {\n    return `- link \"${ref.entryFieldPath}\" from=\"${ref.path}\"`\n  }\n  if (ref.kind === 'check_writeback') {\n    return `- check \"${ref.entryFieldPath}\" writeback=\"${ref.path}\"`\n  }\n  return `- ${ref.entryKind} \"${ref.entryFieldPath}\" path=\"${ref.path}\"`\n}\n\nexport const emitSchemaMismatch = <S extends object>(\n  program: StateTraitProgram<S>,\n  ctx: Pick<ConvergeContext<S>, 'moduleId' | 'instanceId'>,\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    if (!isDevEnv()) return\n\n    const level = yield* FiberRef.get(Debug.currentDiagnosticsLevel)\n    if (level === 'off') return\n\n    const key = `${ctx.moduleId ?? 'unknown'}::${ctx.instanceId}`\n    const shouldEmit = yield* onceInRunSession(`schema_mismatch:${key}`)\n    if (!shouldEmit) return\n\n    const refs = (program.schemaPaths ?? []) as ReadonlyArray<StateTraitSchemaPathRef>\n    if (refs.length === 0) return\n\n    const stateSchemaAst = program.stateSchema.ast as unknown as SchemaAST.AST\n\n    const mismatches: Array<StateTraitSchemaPathRef> = []\n    const seen = new Set<string>()\n\n    for (const ref of refs) {\n      if (schemaHasFieldPath(stateSchemaAst, ref.path)) continue\n      const k = `${ref.kind}|${ref.entryKind}|${ref.entryFieldPath}|${ref.ruleName ?? ''}|${ref.path}`\n      if (seen.has(k)) continue\n      seen.add(k)\n      mismatches.push(ref)\n    }\n\n    if (mismatches.length === 0) return\n\n    const limit = level === 'light' ? 8 : 24\n    const lines = mismatches.slice(0, limit).map(formatSchemaMismatchLine)\n    if (mismatches.length > limit) {\n      lines.push(`- \u2026(+${mismatches.length - limit})`)\n    }\n\n    yield* Debug.record({\n      type: 'diagnostic',\n      moduleId: ctx.moduleId,\n      instanceId: ctx.instanceId,\n      code: 'state_trait::schema_mismatch',\n      severity: 'warning',\n      message: `[schema] The following paths are not declared in stateSchema (total ${mismatches.length}):\\n${lines.join('\\n')}`,\n      hint: 'StateTrait writeback will create missing objects/fields. Declare all fieldPath/deps/link.from and errors.* writeback paths in stateSchema, or fix typos in trait paths.',\n      kind: 'schema_mismatch',\n    })\n  })\n"],
  "mappings": "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",
  "names": ["record", "value", "record", "keyHash", "key", "prev", "prevStatus", "concurrency", "mode", "inFlight", "trailing", "gen", "startFetch", "Effect", "FiberRef", "Option", "SchemaAST", "onceInRunSession", "Effect", "Option", "formatList", "emitDepsMismatch", "tag", "FiberRef"]
}
