@logixjs/core 0.0.1

package/dist/StateTrait.cjs

@@ -0,0 +1,2737 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/StateTrait.ts
+var StateTrait_exports = {};
+__export(StateTrait_exports, {
+  $root: () => $root,
+  build: () => build2,
+  computed: () => computed,
+  exportStaticIr: () => exportStaticIr2,
+  from: () => from,
+  install: () => install2,
+  link: () => link,
+  list: () => list,
+  node: () => node,
+  source: () => source
+});
+module.exports = __toCommonJS(StateTrait_exports);
+
+// src/internal/state-trait/rowid.ts
+var parseSegments = (path) => {
+  if (!path) return [];
+  return path.split(".").map((seg) => /^[0-9]+$/.test(seg) ? Number(seg) : seg);
+};
+var getAtPath = (state, path) => {
+  if (!path || state == null) return state;
+  const segments = parseSegments(path);
+  let current = state;
+  for (const seg of segments) {
+    if (current == null) return void 0;
+    if (typeof seg === "number") {
+      current = Array.isArray(current) ? current[seg] : current[String(seg)];
+      continue;
+    }
+    current = current[seg];
+  }
+  return current;
+};
+var setAtPathMutating = (draft, path, value) => {
+  if (!path) return;
+  const segments = parseSegments(path);
+  if (segments.length === 0) return;
+  let current = draft;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const key = segments[i];
+    const nextKey = segments[i + 1];
+    const next = current?.[key];
+    if (next == null || typeof next !== "object") {
+      current[key] = typeof nextKey === "number" ? [] : {};
+    }
+    current = current[key];
+  }
+  const last = segments[segments.length - 1];
+  current[last] = value;
+};
+var parseListItemFieldPath = (fieldPath) => {
+  const raw = typeof fieldPath === "string" ? fieldPath.trim() : "";
+  if (!raw) return void 0;
+  const segments = raw.split(".").filter(Boolean);
+  let lastListSeg = -1;
+  for (let i = 0; i < segments.length; i++) {
+    if (segments[i].endsWith("[]")) lastListSeg = i;
+  }
+  if (lastListSeg < 0) return void 0;
+  const strip = (seg) => seg.endsWith("[]") ? seg.slice(0, -2) : seg;
+  const listPath = segments.slice(0, lastListSeg + 1).map(strip).join(".");
+  const itemPath = segments.slice(lastListSeg + 1).map(strip).join(".");
+  return { listPath, itemPath };
+};
+var toListItemValuePath = (listPath, index, itemPath) => itemPath ? `${listPath}.${index}.${itemPath}` : `${listPath}.${index}`;
+
+// src/internal/state-trait/build.ts
+var SchemaAST = __toESM(require("effect/SchemaAST"), 1);
+
+// src/internal/state-trait/meta.ts
+var uniqSortedStrings = (input) => {
+  const set = /* @__PURE__ */ new Set();
+  for (const item of input) {
+    const v = item.trim();
+    if (!v) continue;
+    set.add(v);
+  }
+  return Array.from(set).sort((a, b) => a.localeCompare(b));
+};
+var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sanitizeJsonValue = (input, depth) => {
+  if (input === null) return null;
+  if (typeof input === "string") return input;
+  if (typeof input === "boolean") return input;
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : void 0;
+  }
+  if (depth >= 6) return void 0;
+  if (Array.isArray(input)) {
+    const out = [];
+    for (const item of input) {
+      const v = sanitizeJsonValue(item, depth + 1);
+      if (v !== void 0) out.push(v);
+    }
+    return out;
+  }
+  if (isPlainRecord(input)) {
+    const keys = Object.keys(input).sort();
+    const out = {};
+    for (const key of keys) {
+      const v = sanitizeJsonValue(input[key], depth + 1);
+      if (v !== void 0) out[key] = v;
+    }
+    return out;
+  }
+  return void 0;
+};
+var sanitize = (input) => {
+  if (input === null || input === void 0) return void 0;
+  if (typeof input !== "object" || Array.isArray(input)) return void 0;
+  const record2 = input;
+  const out = {};
+  const pickString = (key) => {
+    const value = record2[key];
+    if (typeof value !== "string") return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    out[key] = trimmed;
+  };
+  pickString("label");
+  pickString("description");
+  pickString("group");
+  pickString("docsUrl");
+  pickString("cacheGroup");
+  const canonical = record2.canonical;
+  if (typeof canonical === "boolean") {
+    out.canonical = canonical;
+  }
+  const tagsRaw = record2.tags;
+  if (typeof tagsRaw === "string") {
+    const tags = uniqSortedStrings([tagsRaw]);
+    if (tags.length > 0) out.tags = tags;
+  } else if (Array.isArray(tagsRaw)) {
+    const tags = uniqSortedStrings(tagsRaw.filter((x) => typeof x === "string"));
+    if (tags.length > 0) out.tags = tags;
+  }
+  const annotations = {};
+  const annotationKeys = Object.keys(record2).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
+  for (const key of annotationKeys) {
+    const v = sanitizeJsonValue(record2[key], 0);
+    if (v !== void 0) annotations[key] = v;
+  }
+  const annotationsRaw = record2.annotations;
+  if (isPlainRecord(annotationsRaw)) {
+    const keys = Object.keys(annotationsRaw).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+      const v = sanitizeJsonValue(annotationsRaw[key], 0);
+      if (v !== void 0) annotations[key] = v;
+    }
+  }
+  if (Object.keys(annotations).length > 0) out.annotations = annotations;
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var stableStringify = (meta) => {
+  const out = {};
+  const keys = Object.keys(meta).sort();
+  for (const k of keys) {
+    out[k] = meta[k];
+  }
+  return JSON.stringify(out);
+};
+var equals = (a, b) => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return stableStringify(a) === stableStringify(b);
+};
+var mergeCanonical = (current, incoming) => {
+  const existing = current.meta;
+  if (!existing) {
+    return {
+      meta: incoming.meta,
+      origin: incoming.origin,
+      conflicts: current.conflicts
+    };
+  }
+  if (equals(existing, incoming.meta)) {
+    return current;
+  }
+  const conflicts = [...current.conflicts ?? []];
+  const push = (conflict) => {
+    const exists = conflicts.some((c) => c.origin === conflict.origin && equals(c.meta, conflict.meta));
+    if (!exists) conflicts.push(conflict);
+  };
+  const existingCanonical = existing.canonical === true;
+  const incomingCanonical = incoming.meta.canonical === true;
+  if (!existingCanonical && incomingCanonical) {
+    push({
+      origin: current.origin ?? "unknown",
+      meta: existing
+    });
+    return {
+      meta: incoming.meta,
+      origin: incoming.origin,
+      conflicts
+    };
+  }
+  push({
+    origin: incoming.origin,
+    meta: incoming.meta
+  });
+  return {
+    meta: existing,
+    origin: current.origin ?? incoming.origin,
+    conflicts
+  };
+};
+
+// 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 === "link") {
+      const meta = entry.meta;
+      const from2 = prefixDeps([meta.from], depPrefix)[0] ?? meta.from;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, from: from2 }
+      };
+    }
+    return {
+      ...entry,
+      fieldPath
+    };
+  };
+  const expandNode = (scopeId, joinPrefix, node2, 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(node2.computed);
+    expandMaybeRecord(node2.source);
+    expandMaybeRecord(node2.link);
+    if (node2.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(node2.check)) {
+        const rule = node2.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, node2) => {
+    const meta = sanitize(node2.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;
+};
+
+// src/internal/field-path.ts
+var isFieldPathSegment = (seg) => {
+  if (!seg) return false;
+  if (seg === "*") return false;
+  if (/^\d+$/.test(seg)) return false;
+  if (seg.includes("[") || seg.includes("]")) return false;
+  return true;
+};
+var normalizeFieldPath = (input) => {
+  if (typeof input === "string") {
+    const segs = splitSegments(input);
+    if (!segs || segs.length === 0) return void 0;
+    const normalized2 = segs.filter(isFieldPathSegment);
+    return normalized2.length > 0 ? normalized2 : void 0;
+  }
+  if (input.length === 0) return void 0;
+  let needsFilter = false;
+  for (const seg of input) {
+    if (!isFieldPathSegment(seg)) {
+      needsFilter = true;
+      break;
+    }
+  }
+  if (!needsFilter) return input;
+  const normalized = input.filter(isFieldPathSegment);
+  return normalized.length > 0 ? normalized : void 0;
+};
+var compareFieldPath = (a, b) => {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const as = a[i];
+    const bs = b[i];
+    if (as === bs) continue;
+    return as < bs ? -1 : 1;
+  }
+  return a.length - b.length;
+};
+var makeFieldPathIdRegistry = (fieldPaths) => {
+  const root = { children: /* @__PURE__ */ new Map() };
+  const pathStringToId = /* @__PURE__ */ new Map();
+  const ambiguousPathStrings = /* @__PURE__ */ new Set();
+  for (let id = 0; id < fieldPaths.length; id++) {
+    const path = fieldPaths[id];
+    let node2 = root;
+    for (const seg of path) {
+      const children = node2.children;
+      let next = children.get(seg);
+      if (!next) {
+        next = { children: /* @__PURE__ */ new Map() };
+        children.set(seg, next);
+      }
+      node2 = next;
+    }
+    node2.id = id;
+    if (path.length > 0 && path.some((seg) => seg.includes("."))) {
+      const key = path.join(".");
+      ambiguousPathStrings.add(key);
+      pathStringToId.delete(key);
+    }
+    if (path.length > 0 && path.every((seg) => !seg.includes(".") && !seg.includes("[") && !seg.includes("]"))) {
+      const key = path.join(".");
+      if (ambiguousPathStrings.has(key)) continue;
+      if (pathStringToId.has(key)) {
+        ambiguousPathStrings.add(key);
+        pathStringToId.delete(key);
+        continue;
+      }
+      pathStringToId.set(key, id);
+    }
+  }
+  return { fieldPaths, root, pathStringToId };
+};
+var getFieldPathId = (registry, path) => {
+  let node2 = registry.root;
+  for (const seg of path) {
+    const next = node2.children.get(seg);
+    if (!next) return void 0;
+    node2 = next;
+  }
+  return node2.id;
+};
+var splitSegments = (path) => {
+  if (!path) return void 0;
+  if (path === "*") return void 0;
+  const parts = path.split(".").filter((p) => p.length > 0);
+  const segs = [];
+  for (const part of parts) {
+    if (!part) continue;
+    if (part === "*") {
+      return void 0;
+    }
+    if (part.endsWith("[]")) {
+      const base = part.slice(0, -2);
+      if (base) segs.push(base);
+      continue;
+    }
+    const bracket = /^(.+)\[(\d+)\]$/.exec(part);
+    if (bracket) {
+      segs.push(bracket[1]);
+      continue;
+    }
+    if (/^\d+$/.test(part)) {
+      continue;
+    }
+    if (part.includes("[") || part.includes("]")) {
+      return void 0;
+    }
+    segs.push(part);
+  }
+  return segs;
+};
+
+// src/internal/digest.ts
+var stableStringify2 = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify2).join(",")}]`;
+  }
+  if (t === "object") {
+    const record2 = value;
+    const keys = Object.keys(record2).sort((a, b) => a.localeCompare(b));
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify2(record2[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
+
+// src/internal/state-trait/build.ts
+var nowPerf = () => typeof globalThis.performance !== "undefined" && typeof globalThis.performance.now === "function" ? globalThis.performance.now() : Date.now();
+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 node2 of nodes) {
+    indegree.set(node2, 0);
+    forward.set(node2, []);
+  }
+  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 [node2, deg] of indegree.entries()) {
+    if (deg === 0) queue.push(node2);
+  }
+  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 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 = 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(stableStringify2(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,
+    ...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 list2 = meta.deps;
+    if (list2) deps.push(...list2);
+  } else if (entry.kind === "source") {
+    const meta = entry.meta;
+    const list2 = meta.deps;
+    if (list2) deps.push(...list2);
+  } 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 list2 = rule.deps;
+        if (list2) deps.push(...list2);
+      }
+    }
+  }
+  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 from2 = entry.meta.from;
+      ensureField(from2);
+      const edgeId = `link:${from2}->${fieldPath}`;
+      edges.push({
+        id: edgeId,
+        from: from2,
+        to: fieldPath,
+        kind: "link"
+      });
+      planSteps.push({
+        id: `link:${fieldPath}`,
+        kind: "link-propagate",
+        targetFieldPath: fieldPath,
+        sourceFieldPaths: [from2],
+        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 === "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 list2 = adjacency.get(edge.from) ?? [];
+    list2.push(edge.to);
+    adjacency.set(edge.from, list2);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const dfs = (node2) => {
+    if (stack.has(node2)) {
+      throw new Error(
+        `[StateTrait.build] link cycle detected at field "${node2}". Please check link traits for circular dependencies.`
+      );
+    }
+    if (visited.has(node2)) return;
+    visited.add(node2);
+    stack.add(node2);
+    const nexts = adjacency.get(node2);
+    if (nexts) {
+      for (const to of nexts) {
+        dfs(to);
+      }
+    }
+    stack.delete(node2);
+  };
+  for (const node2 of adjacency.keys()) {
+    if (!visited.has(node2)) {
+      dfs(node2);
+    }
+  }
+};
+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].localeCompare(b[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)
+  };
+};
+
+// src/internal/state-trait/install.ts
+var import_effect11 = require("effect");
+
+// src/internal/runtime/core/env.ts
+var import_effect = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var ReplayModeConfigTag = ReplayModeConfigTagImpl;
+var StateTransactionOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/runtime/core/runtimeInternalsAccessor.ts
+var BOUND_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/boundInternals");
+var getBoundInternals = (bound) => {
+  const internals = bound[BOUND_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingBoundInternals] Bound internals not installed on Bound API instance.",
+      "fix:",
+      "- Ensure BoundApiRuntime attaches internals (020 foundation).",
+      "- If you created a mock bound for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Bound internals not installed";
+    throw new Error(msg);
+  }
+  return internals;
+};
+
+// src/internal/state-trait/source.ts
+var import_effect10 = require("effect");
+var import_mutative = require("mutative");
+
+// src/internal/effect-op.ts
+var import_effect4 = require("effect");
+
+// src/internal/runtime/core/EffectOpCore.ts
+var import_effect2 = require("effect");
+var currentLinkId = import_effect2.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect2.Context.Tag("Logix/EffectOpMiddleware")() {
+};
+var composeMiddleware = (stack) => {
+  return (op) => stack.reduceRight(
+    (eff, mw) => mw({ ...op, effect: eff }),
+    op.effect
+  );
+};
+var runWithMiddleware = (op, stack) => {
+  return import_effect2.Effect.gen(function* () {
+    const existing = yield* import_effect2.FiberRef.get(currentLinkId);
+    const metaLinkId = op.meta?.linkId;
+    const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
+    const nextOp = {
+      ...op,
+      meta: {
+        ...op.meta ?? {},
+        linkId
+      }
+    };
+    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
+    return yield* import_effect2.Effect.locally(currentLinkId, linkId)(program);
+  });
+};
+
+// src/internal/observability/runSession.ts
+var import_effect3 = require("effect");
+
+// src/internal/observability/jsonValue.ts
+var defaultOptions = {
+  maxDepth: 6,
+  maxObjectKeys: 32,
+  maxArrayLength: 32,
+  maxStringLength: 256,
+  maxJsonBytes: 4 * 1024,
+  oversizedPreviewBytes: 256
+};
+
+// src/internal/observability/runSession.ts
+var RunSessionTagImpl = class extends import_effect3.Context.Tag("@logixjs/core/RunSession")() {
+};
+var RunSessionTag = RunSessionTagImpl;
+
+// src/internal/effect-op.ts
+var nextGlobalOpSeq = 0;
+var nextOpSeq = () => {
+  nextGlobalOpSeq += 1;
+  return nextGlobalOpSeq;
+};
+var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
+var make = (params) => ({
+  ...params.id ? { id: params.id, meta: params.meta } : (() => {
+    const meta = params.meta ?? {};
+    const instanceId = meta.instanceId;
+    const opSeq = typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq();
+    return {
+      id: makeId(instanceId, opSeq),
+      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq }
+    };
+  })(),
+  kind: params.kind,
+  name: params.name,
+  payload: params.payload,
+  effect: params.effect
+});
+var run = (op, stack) => runWithMiddleware(op, stack);
+
+// src/internal/resource.ts
+var import_effect5 = require("effect");
+var stableStringify3 = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const encode = (input) => {
+    if (input === null) return null;
+    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+      return input;
+    }
+    if (typeof input === "bigint") return input.toString();
+    if (typeof input === "undefined") return "__undefined__";
+    if (typeof input === "symbol") return `__symbol__:${String(input)}`;
+    if (typeof input === "function") return "__function__";
+    if (Array.isArray(input)) {
+      return input.map((v) => encode(v));
+    }
+    if (input instanceof Date) {
+      return `__date__:${input.toISOString()}`;
+    }
+    if (input instanceof Error) {
+      return {
+        _tag: "Error",
+        name: input.name,
+        message: input.message
+      };
+    }
+    if (input && typeof input === "object") {
+      const obj = input;
+      if (seen.has(obj)) return "__cycle__";
+      seen.add(obj);
+      const record2 = input;
+      const keys = Object.keys(record2).sort();
+      const out = {};
+      for (const k of keys) {
+        out[k] = encode(record2[k]);
+      }
+      return out;
+    }
+    return String(input);
+  };
+  try {
+    return JSON.stringify(encode(value));
+  } catch {
+    return String(value);
+  }
+};
+var keyHash = (key) => stableStringify3(key);
+var Snapshot = {
+  idle: () => ({
+    status: "idle",
+    keyHash: void 0,
+    data: void 0,
+    error: void 0
+  }),
+  loading: (params) => ({
+    status: "loading",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: void 0
+  }),
+  success: (params) => ({
+    status: "success",
+    keyHash: params.keyHash,
+    data: params.data,
+    error: void 0
+  }),
+  error: (params) => ({
+    status: "error",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: params.error
+  })
+};
+var ResourceRegistryTag = class extends import_effect5.Context.Tag("@logixjs/core/ResourceRegistry")() {
+};
+var internal = {
+  ResourceRegistryTag
+};
+
+// src/internal/runtime/core/DebugSink.ts
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/errorSummary.ts
+var import_effect6 = require("effect");
+
+// src/internal/runtime/core/DebugSink.ts
+var currentDebugSinks = import_effect7.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect7.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect7.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect7.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect7.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect7.FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var browserLifecycleSeen = /* @__PURE__ */ new Set();
+var browserDiagnosticSeen = /* @__PURE__ */ new Set();
+var lifecycleErrorLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const causePretty = (() => {
+    try {
+      return import_effect7.Cause.pretty(event.cause, {
+        renderErrorCause: true
+      });
+    } catch {
+      try {
+        return JSON.stringify(event.cause, null, 2);
+      } catch {
+        return String(event.cause);
+      }
+    }
+  })();
+  const message = `[Logix][module=${moduleId}] lifecycle:error
+${causePretty}`;
+  return import_effect7.Effect.logError(message).pipe(
+    import_effect7.Effect.annotateLogs({
+      "logix.moduleId": moduleId,
+      "logix.event": "lifecycle:error",
+      "logix.cause": causePretty
+    })
+  );
+};
+var diagnosticLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`;
+  const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+  const msg = `${header}
+${detail}`;
+  const base = event.severity === "warning" ? import_effect7.Effect.logWarning(msg) : event.severity === "info" ? import_effect7.Effect.logInfo(msg) : import_effect7.Effect.logError(msg);
+  const annotations = {
+    "logix.moduleId": moduleId,
+    "logix.event": `diagnostic(${event.severity})`,
+    "logix.diagnostic.code": event.code,
+    "logix.diagnostic.message": event.message
+  };
+  if (event.hint) {
+    annotations["logix.diagnostic.hint"] = event.hint;
+  }
+  if (event.actionTag) {
+    annotations["logix.diagnostic.actionTag"] = event.actionTag;
+  }
+  return base.pipe(import_effect7.Effect.annotateLogs(annotations));
+};
+var noopLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, []);
+var errorOnlySink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect7.Effect.void
+};
+var errorOnlyLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
+var consoleSink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect7.Effect.logDebug({ debugEvent: event })
+};
+var consoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var renderBrowserConsoleEvent = (event) => {
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const moduleId = event.moduleId ?? "unknown";
+    const type = event.type;
+    return import_effect7.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
+        "color:#6b7280;font-weight:bold",
+        // tag
+        "color:#3b82f6",
+        // label
+        "color:#9ca3af",
+        // module id
+        "color:#6b7280"
+        // type
+      );
+      console.log(event);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "lifecycle:error") {
+    const moduleId = event.moduleId ?? "unknown";
+    const causePretty = (() => {
+      try {
+        return import_effect7.Cause.pretty(event.cause, { renderErrorCause: true });
+      } catch {
+        try {
+          return JSON.stringify(event.cause, null, 2);
+        } catch {
+          return String(event.cause);
+        }
+      }
+    })();
+    const key = `${moduleId}|${causePretty}`;
+    if (browserLifecycleSeen.has(key)) {
+      return import_effect7.Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return import_effect7.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c lifecycle:error %c" + moduleId,
+        "color:#ef4444;font-weight:bold",
+        // tag
+        "color:#ef4444",
+        // label
+        "color:#9ca3af"
+        // module id
+      );
+      console.error(causePretty);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "diagnostic") {
+    const moduleId = event.moduleId ?? "unknown";
+    const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+    const color = event.severity === "warning" ? "color:#d97706" : event.severity === "info" ? "color:#3b82f6" : "color:#ef4444";
+    const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
+    const key = `${moduleId}|${event.code}|${event.message}`;
+    if (browserDiagnosticSeen.has(key)) {
+      return import_effect7.Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return import_effect7.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c " + label + "%c module=" + moduleId,
+        "color:#6b7280;font-weight:bold",
+        color,
+        "color:#9ca3af"
+      );
+      if (event.severity === "warning") {
+        console.warn(detail);
+      } else if (event.severity === "info") {
+        console.info(detail);
+      } else {
+        console.error(detail);
+      }
+      console.groupEnd();
+    });
+  }
+  return import_effect7.Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect7.Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserDiagnosticConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect7.Effect.void;
+    }
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect7.Effect.void;
+  }
+};
+var browserDiagnosticConsoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect7.Logger.replace(
+  import_effect7.Logger.defaultLogger,
+  import_effect7.Logger.prettyLogger({ mode: "browser", colors: true })
+);
+var record = (event) => import_effect7.Effect.gen(function* () {
+  const sinks = yield* import_effect7.FiberRef.get(currentDebugSinks);
+  if (isErrorOnlyOnlySinks(sinks)) {
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      if (event.severity !== "info") {
+        yield* diagnosticLog(event);
+      } else {
+        yield* import_effect7.Effect.void;
+      }
+      return;
+    }
+    yield* import_effect7.Effect.void;
+    return;
+  }
+  if (sinks.length === 0) {
+    if (isBrowser) {
+      if (event.type === "lifecycle:error" || event.type === "diagnostic") {
+        yield* renderBrowserConsoleEvent(event);
+        return;
+      }
+      yield* import_effect7.Effect.void;
+      return;
+    }
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* import_effect7.Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel = yield* import_effect7.FiberRef.get(currentDiagnosticsLevel);
+  let now;
+  const getNow = () => {
+    if (now === void 0) now = Date.now();
+    return now;
+  };
+  if (enriched.timestamp === void 0 && (diagnosticsLevel !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
+    ;
+    enriched.timestamp = getNow();
+  }
+  if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel = yield* import_effect7.FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect7.FiberRef.get(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const linkId = yield* import_effect7.FiberRef.get(currentLinkId);
+    if (linkId) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect7.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect8 = require("effect");
+var inSyncTransactionFiber = import_effect8.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect8.FiberRef.unsafeMake(false);
+
+// src/internal/runtime/core/ReplayLog.ts
+var import_effect9 = require("effect");
+var ReplayLog = class extends import_effect9.Context.Tag("@logixjs/core/ReplayLog")() {
+};
+var snapshot = import_effect9.Effect.gen(function* () {
+  const log = yield* ReplayLog;
+  return yield* log.snapshot;
+});
+var resetCursor = import_effect9.Effect.gen(function* () {
+  const log = yield* ReplayLog;
+  yield* log.resetCursor;
+});
+
+// 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)
+  };
+};
+
+// src/internal/state-trait/source.ts
+var onceInRunSession = (key) => import_effect10.Effect.serviceOption(RunSessionTag).pipe(
+  import_effect10.Effect.map((maybe) => import_effect10.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) => import_effect10.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 = () => import_effect10.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect10.Effect.map((maybe) => import_effect10.Option.isSome(maybe) ? maybe.value.stack : [])
+);
+var recordTraitPatch = (bound, path, reason, from2, to, traitNodeId) => {
+  const normalized = normalizeFieldPath(path) ?? [];
+  try {
+    const internals = getBoundInternals(bound);
+    internals.txn.recordStatePatch(normalized, reason, from2, 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) => import_effect10.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) => import_effect10.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 installSourceRefresh = (bound, step, entry) => {
+  if (!step.targetFieldPath) return import_effect10.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 import_effect10.Effect.void;
+  }
+  const register = internals.traits.registerSourceRefresh;
+  const recordSnapshot = (replayMode, replayLog, input) => {
+    if (!replayLog) return import_effect10.Effect.void;
+    if (replayMode !== "live") return import_effect10.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 import_effect10.Effect.void;
+    }
+    const listPath = listItem.listPath;
+    const itemPath = listItem.itemPath;
+    if (!itemPath) {
+      return import_effect10.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) => import_effect10.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) => import_effect10.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) => import_effect10.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 = import_effect10.Effect.gen(function* () {
+        if (replayMode === "replay" && replayLog) {
+          yield* import_effect10.Effect.yieldNow();
+          const consumePath = wroteLoadingPath ?? logFieldPath;
+          if (!consumePath) return yield* import_effect10.Effect.void;
+          const replayed = yield* replayLog.consumeNextResourceSnapshot({
+            resourceId,
+            fieldPath: consumePath,
+            keyHash: keyHash2
+          });
+          if (!replayed) return yield* import_effect10.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* import_effect10.Effect.void;
+        }
+        const stack = yield* getMiddlewareStack();
+        const registryOpt = yield* import_effect10.Effect.serviceOption(internal.ResourceRegistryTag);
+        const registry = import_effect10.Option.isSome(registryOpt) ? registryOpt.value : void 0;
+        const spec = registry?.specs.get(resourceId);
+        if (!spec) {
+          return yield* import_effect10.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* import_effect10.Effect.serviceOption(RunSessionTag);
+          if (import_effect10.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* import_effect10.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(import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void));
+      const fiber = yield* import_effect10.Effect.forkScoped(import_effect10.Effect.locally(inSyncTransactionFiber, false)(io));
+      const myGen = gen2 += 1;
+      inFlight2.set(rowId, { gen: myGen, fiber, keyHash: keyHash2 });
+      yield* import_effect10.Effect.forkScoped(
+        import_effect10.Effect.locally(
+          inSyncTransactionFiber,
+          false
+        )(
+          import_effect10.Fiber.await(fiber).pipe(
+            import_effect10.Effect.zipRight(
+              import_effect10.Effect.sync(() => {
+                const current = inFlight2.get(rowId);
+                if (current && current.gen === myGen) {
+                  inFlight2.delete(rowId);
+                }
+              })
+            ),
+            import_effect10.Effect.zipRight(
+              mode2 === "exhaust-trailing" ? import_effect10.Effect.gen(function* () {
+                const next = trailing2.get(rowId);
+                trailing2.delete(rowId);
+                if (next) {
+                  yield* startFetch2(rowId, next.key, next.keyHash, replayMode, replayLog);
+                }
+              }) : import_effect10.Effect.void
+            ),
+            import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void)
+          )
+        )
+      );
+    });
+    register(
+      fieldPath,
+      (state) => import_effect10.Effect.gen(function* () {
+        const { moduleId, instanceId } = getBoundScope(bound);
+        const replayModeOpt = yield* import_effect10.Effect.serviceOption(ReplayModeConfigTag);
+        const replayMode = import_effect10.Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+        const replayLogOpt = yield* import_effect10.Effect.serviceOption(ReplayLog);
+        const replayLog = import_effect10.Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+        const force = yield* import_effect10.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 import_effect10.Effect.void;
+  }
+  let inFlight;
+  let gen = 0;
+  let trailing;
+  const concurrency = entry.meta.concurrency;
+  const mode = concurrency ?? "switch";
+  const startFetch = (key, keyHash2, replayMode, replayLog) => import_effect10.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 = import_effect10.Effect.gen(function* () {
+      if (replayMode === "replay" && replayLog) {
+        yield* import_effect10.Effect.yieldNow();
+        const replayed = yield* replayLog.consumeNextResourceSnapshot({
+          resourceId,
+          fieldPath,
+          keyHash: keyHash2
+        });
+        if (!replayed) return yield* import_effect10.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* import_effect10.Effect.void;
+      }
+      const stack = yield* getMiddlewareStack();
+      const registryOpt = yield* import_effect10.Effect.serviceOption(internal.ResourceRegistryTag);
+      const registry = import_effect10.Option.isSome(registryOpt) ? registryOpt.value : void 0;
+      const spec = registry?.specs.get(resourceId);
+      if (!spec) {
+        return yield* import_effect10.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* import_effect10.Effect.serviceOption(RunSessionTag);
+        if (import_effect10.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* import_effect10.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(import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void));
+    const fiber = yield* import_effect10.Effect.forkScoped(import_effect10.Effect.locally(inSyncTransactionFiber, false)(io));
+    const myGen = gen += 1;
+    inFlight = { gen: myGen, fiber, keyHash: keyHash2 };
+    yield* import_effect10.Effect.forkScoped(
+      import_effect10.Effect.locally(
+        inSyncTransactionFiber,
+        false
+      )(
+        import_effect10.Fiber.await(fiber).pipe(
+          import_effect10.Effect.zipRight(
+            import_effect10.Effect.sync(() => {
+              if (inFlight && inFlight.gen === myGen) {
+                inFlight = void 0;
+              }
+            })
+          ),
+          import_effect10.Effect.zipRight(
+            mode === "exhaust-trailing" ? import_effect10.Effect.gen(function* () {
+              const next = trailing;
+              trailing = void 0;
+              if (next) {
+                yield* startFetch(next.key, next.keyHash, replayMode, replayLog);
+              }
+            }) : import_effect10.Effect.void
+          ),
+          import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void)
+        )
+      )
+    );
+  });
+  register(
+    fieldPath,
+    (state) => import_effect10.Effect.gen(function* () {
+      const { moduleId, instanceId } = getBoundScope(bound);
+      const replayModeOpt = yield* import_effect10.Effect.serviceOption(ReplayModeConfigTag);
+      const replayMode = import_effect10.Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+      const replayLogOpt = yield* import_effect10.Effect.serviceOption(ReplayLog);
+      const replayLog = import_effect10.Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+      const force = yield* import_effect10.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* import_effect10.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* import_effect10.Fiber.interruptFork(inFlight.fiber);
+        inFlight = void 0;
+        trailing = void 0;
+      }
+      yield* startFetch(key, h, replayMode, replayLog);
+    })
+  );
+  return import_effect10.Effect.void;
+};
+
+// src/internal/state-trait/install.ts
+var buildEntryIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list2 = index.get(entry.fieldPath) ?? [];
+    list2.push(entry);
+    index.set(entry.fieldPath, list2);
+  }
+  return index;
+};
+var install = (bound, program) => {
+  try {
+    const internals = getBoundInternals(bound);
+    internals.traits.registerStateTraitProgram(program, {
+      bumpReason: "logic_installed"
+    });
+  } catch {
+  }
+  const entryIndex = buildEntryIndex(program.entries);
+  const installStep = (step) => {
+    if (!step.targetFieldPath) {
+      return import_effect11.Effect.void;
+    }
+    if (step.kind !== "source-refresh") {
+      return import_effect11.Effect.void;
+    }
+    const candidates = entryIndex.get(step.targetFieldPath);
+    if (!candidates || candidates.length === 0) {
+      return import_effect11.Effect.void;
+    }
+    const entry = candidates.find((e) => e.kind === "source");
+    if (!entry) {
+      return import_effect11.Effect.void;
+    }
+    return installSourceRefresh(bound, step, entry);
+  };
+  return import_effect11.Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(import_effect11.Effect.asVoid);
+};
+
+// src/internal/state-trait/ir.ts
+var normalizeFieldPaths = (paths) => {
+  if (!paths || paths.length === 0) return [];
+  const out = [];
+  for (const path of paths) {
+    const normalized = normalizeFieldPath(path);
+    if (normalized) out.push(normalized);
+  }
+  return out;
+};
+var normalizeFieldPath2 = (path) => path ? normalizeFieldPath(path) : void 0;
+var toNodeKind = (step) => {
+  switch (step.kind) {
+    case "computed-update":
+      return "computed";
+    case "link-propagate":
+      return "link";
+    case "source-refresh":
+      return "source";
+    case "check-validate":
+      return "check";
+  }
+};
+var findEntryForStep = (program, step) => {
+  const fieldPath = step.targetFieldPath;
+  if (!fieldPath) return void 0;
+  const kind = toNodeKind(step);
+  return program.entries.find(
+    (e) => e.fieldPath === fieldPath && (e.kind === kind || kind === "check" && e.kind === "check" || kind === "source" && e.kind === "source" || kind === "link" && e.kind === "link" || kind === "computed" && e.kind === "computed")
+  );
+};
+var getReadsForEntry = (entry) => {
+  if (!entry) return void 0;
+  if (entry.kind === "computed") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "source") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "link") {
+    const from2 = entry.meta.from;
+    return from2 ? [from2] : [];
+  }
+  if (entry.kind === "check") {
+    const rules = entry.meta?.rules ?? {};
+    const out = [];
+    for (const name of Object.keys(rules)) {
+      const rule = rules[name];
+      const deps = rule?.deps;
+      if (deps) out.push(...deps);
+    }
+    return out;
+  }
+  return void 0;
+};
+var exportStaticIr = (params) => {
+  const moduleId = params.moduleId;
+  const version = params.version ?? "009";
+  const metaByField = /* @__PURE__ */ new Map();
+  for (const node2 of params.program.graph.nodes) {
+    const meta = node2.meta;
+    if (!meta || typeof meta !== "object") continue;
+    const label = typeof meta.label === "string" ? meta.label : void 0;
+    const description = typeof meta.description === "string" ? meta.description : void 0;
+    const tags = Array.isArray(meta.tags) && meta.tags.every((t) => typeof t === "string") ? meta.tags : void 0;
+    const group = typeof meta.group === "string" ? meta.group : void 0;
+    const docsUrl = typeof meta.docsUrl === "string" ? meta.docsUrl : void 0;
+    const cacheGroup = typeof meta.cacheGroup === "string" ? meta.cacheGroup : void 0;
+    const annotationsRaw = meta.annotations;
+    const annotations = annotationsRaw && typeof annotationsRaw === "object" && !Array.isArray(annotationsRaw) ? annotationsRaw : void 0;
+    if (label || description || tags || group || docsUrl || cacheGroup || annotations) {
+      metaByField.set(node2.id, {
+        label,
+        description,
+        tags,
+        group,
+        docsUrl,
+        cacheGroup,
+        annotations
+      });
+    }
+  }
+  const nodes = params.program.plan.steps.map((step) => {
+    const kind = toNodeKind(step);
+    const entry = findEntryForStep(params.program, step);
+    const reads = normalizeFieldPaths(getReadsForEntry(entry));
+    const target = step.targetFieldPath;
+    const write = normalizeFieldPath2(target);
+    const writes = write ? [write] : [];
+    const meta = target ? metaByField.get(target) : void 0;
+    const base2 = {
+      nodeId: step.id,
+      kind,
+      reads,
+      writes: kind === "check" ? [] : writes,
+      meta
+    };
+    if (kind !== "check" && target && !write) {
+      return { ...base2, writesUnknown: true };
+    }
+    return base2;
+  });
+  const edges = params.program.graph.edges.map((edge) => ({
+    edgeId: edge.id,
+    from: edge.from,
+    to: edge.to,
+    kind: edge.kind
+  }));
+  const base = {
+    version,
+    moduleId,
+    nodes,
+    edges
+  };
+  const digest = `stir:${version}:${fnv1a32(stableStringify2(base))}`;
+  return {
+    ...base,
+    digest
+  };
+};
+
+// src/StateTrait.ts
+var $root = "$root";
+var from = (_schema) => (spec) => spec;
+var node = (spec) => ({
+  _tag: "StateTraitNode",
+  ...spec
+});
+var list = (spec) => ({
+  _tag: "StateTraitList",
+  ...spec
+});
+var computed = (input) => {
+  const derive = (state) => {
+    const args = input.deps.map((dep) => getAtPath(state, dep));
+    return input.get(...args);
+  };
+  return {
+    fieldPath: void 0,
+    kind: "computed",
+    meta: {
+      deps: input.deps,
+      derive,
+      equals: input.equals,
+      ...input.scheduling ? { scheduling: input.scheduling } : {}
+    }
+  };
+};
+var source = (input) => {
+  const key = (state) => {
+    const args = input.deps.map((dep) => getAtPath(state, dep));
+    return input.key(...args);
+  };
+  return {
+    fieldPath: void 0,
+    kind: "source",
+    meta: { ...input, key }
+  };
+};
+var link = (meta) => ({
+  fieldPath: void 0,
+  kind: "link",
+  meta: { ...meta, ...meta.scheduling ? { scheduling: meta.scheduling } : {} }
+});
+var build2 = (stateSchema, spec) => build(stateSchema, spec);
+var install2 = (bound, program) => install(bound, program);
+var exportStaticIr2 = (program, moduleId, options) => exportStaticIr({
+  program,
+  moduleId,
+  version: options?.version
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $root,
+  build,
+  computed,
+  exportStaticIr,
+  from,
+  install,
+  link,
+  list,
+  node,
+  source
+});
+//# sourceMappingURL=StateTrait.cjs.map