@logixjs/core 0.0.1 → 1.0.0

package/dist/StateTrait.cjs

@@ -34,6 +34,7 @@ __export(StateTrait_exports, {
   build: () => build2,
   computed: () => computed,
   exportStaticIr: () => exportStaticIr2,
+  externalStore: () => externalStore,
   from: () => from,
   install: () => install2,
   link: () => link,
@@ -43,6 +44,118 @@ __export(StateTrait_exports, {
 });
 module.exports = __toCommonJS(StateTrait_exports);
 
+// 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/state-trait/rowid.ts
 var parseSegments = (path) => {
   if (!path) return [];
@@ -106,21 +219,31 @@ var uniqSortedStrings = (input) => {
     if (!v) continue;
     set.add(v);
   }
-  return Array.from(set).sort((a, b) => a.localeCompare(b));
+  return Array.from(set).sort();
 };
 var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var sanitizeJsonValue = (input, depth) => {
+var sanitizeJsonValue = (input, depth, stats) => {
   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 (!Number.isFinite(input)) {
+      stats.dropped += 1;
+      stats.nonSerializable += 1;
+      stats.nonFiniteNumber += 1;
+      return void 0;
+    }
+    return input;
+  }
+  if (depth >= 6) {
+    stats.dropped += 1;
+    stats.depthExceeded += 1;
+    return 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);
+      const v = sanitizeJsonValue(item, depth + 1, stats);
       if (v !== void 0) out.push(v);
     }
     return out;
@@ -129,18 +252,50 @@ var sanitizeJsonValue = (input, depth) => {
     const keys = Object.keys(input).sort();
     const out = {};
     for (const key of keys) {
-      const v = sanitizeJsonValue(input[key], depth + 1);
+      const v = sanitizeJsonValue(input[key], depth + 1, stats);
       if (v !== void 0) out[key] = v;
     }
     return out;
   }
+  stats.dropped += 1;
+  stats.nonSerializable += 1;
   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;
+var pushSample = (target, value, limit) => {
+  if (target.length >= limit) return;
+  target.push(value);
+};
+var sanitizeWithReport = (input) => {
+  if (input === null || input === void 0) return {};
+  if (typeof input !== "object" || Array.isArray(input)) {
+    return { report: { invalidInput: true } };
+  }
   const record2 = input;
   const out = {};
+  const reportUnknownKeys = [];
+  let unknownKeyCount = 0;
+  const reportDroppedKeys = [];
+  let droppedTagItems = 0;
+  const reportIgnoredAnnotationKeys = [];
+  let ignoredAnnotationKeyCount = 0;
+  const reportDroppedAnnotationKeys = [];
+  let droppedAnnotationKeyCount = 0;
+  const stats = { dropped: 0, nonSerializable: 0, depthExceeded: 0, nonFiniteNumber: 0 };
+  const allowed = /* @__PURE__ */ new Set([
+    "label",
+    "description",
+    "group",
+    "docsUrl",
+    "cacheGroup",
+    "canonical",
+    "tags",
+    "annotations"
+  ]);
+  for (const key of Object.keys(record2)) {
+    if (allowed.has(key) || key.startsWith("x-")) continue;
+    unknownKeyCount += 1;
+    pushSample(reportUnknownKeys, key, 8);
+  }
   const pickString = (key) => {
     const value = record2[key];
     if (typeof value !== "string") return;
@@ -154,7 +309,9 @@ var sanitize = (input) => {
   pickString("docsUrl");
   pickString("cacheGroup");
   const canonical = record2.canonical;
-  if (typeof canonical === "boolean") {
+  if (canonical !== void 0 && canonical !== null && typeof canonical !== "boolean") {
+    pushSample(reportDroppedKeys, "canonical", 8);
+  } else if (typeof canonical === "boolean") {
     out.canonical = canonical;
   }
   const tagsRaw = record2.tags;
@@ -162,26 +319,80 @@ var sanitize = (input) => {
     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"));
+    const raw = tagsRaw.filter((x) => typeof x === "string");
+    droppedTagItems += tagsRaw.length - raw.length;
+    const tags = uniqSortedStrings(raw);
     if (tags.length > 0) out.tags = tags;
+    droppedTagItems += raw.length - tags.length;
+  } else if (tagsRaw !== void 0 && tagsRaw !== null) {
+    pushSample(reportDroppedKeys, "tags", 8);
   }
   const annotations = {};
-  const annotationKeys = Object.keys(record2).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
+  const annotationKeys = Object.keys(record2).filter((k) => k.startsWith("x-")).sort();
   for (const key of annotationKeys) {
-    const v = sanitizeJsonValue(record2[key], 0);
-    if (v !== void 0) annotations[key] = v;
+    const v = sanitizeJsonValue(record2[key], 0, stats);
+    if (v !== void 0) {
+      annotations[key] = v;
+    } else {
+      droppedAnnotationKeyCount += 1;
+      pushSample(reportDroppedAnnotationKeys, key, 8);
+    }
   }
   const annotationsRaw = record2.annotations;
-  if (isPlainRecord(annotationsRaw)) {
-    const keys = Object.keys(annotationsRaw).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
+  if (annotationsRaw !== void 0 && annotationsRaw !== null && !isPlainRecord(annotationsRaw)) {
+    pushSample(reportDroppedKeys, "annotations", 8);
+  } else if (isPlainRecord(annotationsRaw)) {
+    const keys = Object.keys(annotationsRaw).sort();
     for (const key of keys) {
-      const v = sanitizeJsonValue(annotationsRaw[key], 0);
-      if (v !== void 0) annotations[key] = v;
+      if (!key.startsWith("x-")) {
+        ignoredAnnotationKeyCount += 1;
+        pushSample(reportIgnoredAnnotationKeys, key, 8);
+        continue;
+      }
+      const v = sanitizeJsonValue(annotationsRaw[key], 0, stats);
+      if (v !== void 0) {
+        annotations[key] = v;
+      } else {
+        droppedAnnotationKeyCount += 1;
+        pushSample(reportDroppedAnnotationKeys, key, 8);
+      }
     }
   }
   if (Object.keys(annotations).length > 0) out.annotations = annotations;
-  return Object.keys(out).length > 0 ? out : void 0;
+  for (const key of ["label", "description", "group", "docsUrl", "cacheGroup"]) {
+    const value = record2[key];
+    if (value !== void 0 && value !== null && typeof value !== "string") {
+      pushSample(reportDroppedKeys, key, 8);
+    }
+  }
+  const meta = Object.keys(out).length > 0 ? out : void 0;
+  const report = (() => {
+    const hasUnknownKeys = unknownKeyCount > 0;
+    const hasDroppedKeys = reportDroppedKeys.length > 0;
+    const hasDroppedTagItems = droppedTagItems > 0;
+    const hasIgnoredAnnotationKeys = ignoredAnnotationKeyCount > 0;
+    const hasDroppedAnnotations = droppedAnnotationKeyCount > 0 || stats.dropped > 0;
+    if (!hasUnknownKeys && !hasDroppedKeys && !hasDroppedTagItems && !hasIgnoredAnnotationKeys && !hasDroppedAnnotations) {
+      return void 0;
+    }
+    return {
+      ...hasUnknownKeys ? { unknownKeys: reportUnknownKeys, unknownKeyCount } : {},
+      ...hasDroppedKeys ? { droppedKeys: uniqSortedStrings(reportDroppedKeys) } : {},
+      ...hasDroppedTagItems ? { droppedTagItems } : {},
+      ...hasIgnoredAnnotationKeys ? { ignoredAnnotationKeys: uniqSortedStrings(reportIgnoredAnnotationKeys), ignoredAnnotationKeyCount } : {},
+      ...hasDroppedAnnotations ? {
+        droppedAnnotationKeys: uniqSortedStrings(reportDroppedAnnotationKeys),
+        droppedAnnotationKeyCount,
+        droppedAnnotationValues: stats.dropped,
+        droppedAnnotationNonSerializable: stats.nonSerializable,
+        droppedAnnotationDepthExceeded: stats.depthExceeded,
+        droppedAnnotationNonFiniteNumber: stats.nonFiniteNumber
+      } : {}
+    };
+  })();
+  return report ? { meta, report } : { meta };
 };
+var sanitize = (input) => sanitizeWithReport(input).meta;
 var stableStringify = (meta) => {
   const out = {};
   const keys = Object.keys(meta).sort();
@@ -271,6 +482,14 @@ var normalizeSpec = (spec) => {
         meta: { ...meta, deps, _fieldPath: fieldPath }
       };
     }
+    if (entry.kind === "externalStore") {
+      const meta = entry.meta;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, _fieldPath: fieldPath }
+      };
+    }
     if (entry.kind === "link") {
       const meta = entry.meta;
       const from2 = prefixDeps([meta.from], depPrefix)[0] ?? meta.from;
@@ -308,6 +527,7 @@ var normalizeSpec = (spec) => {
     expandMaybeRecord(node2.computed);
     expandMaybeRecord(node2.source);
     expandMaybeRecord(node2.link);
+    expandMaybeRecord(node2.externalStore);
     if (node2.check) {
       const rules = {};
       const checkDepsPrefix = options?.checkDepsPrefix ?? (joinPrefix.endsWith("[]") ? joinPrefix : "");
@@ -398,118 +618,6 @@ var collectNodeMeta = (spec) => {
   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";
@@ -522,7 +630,7 @@ var stableStringify2 = (value) => {
   }
   if (t === "object") {
     const record2 = value;
-    const keys = Object.keys(record2).sort((a, b) => a.localeCompare(b));
+    const keys = Object.keys(record2).sort();
     return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify2(record2[k])}`).join(",")}}`;
   }
   return "null";
@@ -536,10 +644,47 @@ var fnv1a32 = (input) => {
   return hash.toString(16).padStart(8, "0");
 };
 
+// src/internal/state-trait/converge-ir.ts
+var getConvergeStaticIrDigest = (ir) => {
+  if (typeof ir.staticIrDigest === "string" && ir.staticIrDigest.length > 0) {
+    return ir.staticIrDigest;
+  }
+  const hash = fnv1a32(
+    stableStringify2({ writersKey: ir.writersKey, depsKey: ir.depsKey, fieldPathsKey: ir.fieldPathsKey })
+  );
+  return `converge_ir_v2:${hash}`;
+};
+
 // 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") {
+var collectMultipleWritersError = (entries) => {
+  const kindsByFieldPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.kind !== "computed" && entry.kind !== "link" && entry.kind !== "source" && entry.kind !== "externalStore") {
+      continue;
+    }
+    const set = kindsByFieldPath.get(entry.fieldPath) ?? /* @__PURE__ */ new Set();
+    set.add(entry.kind);
+    kindsByFieldPath.set(entry.fieldPath, set);
+  }
+  const conflicts = [];
+  for (const [fieldPath, kinds] of kindsByFieldPath.entries()) {
+    if (kinds.size <= 1) continue;
+    conflicts.push({ fieldPath, kinds: Array.from(kinds).sort() });
+  }
+  if (conflicts.length === 0) return void 0;
+  conflicts.sort((a, b) => a.fieldPath < b.fieldPath ? -1 : a.fieldPath > b.fieldPath ? 1 : 0);
+  const fields = conflicts.map((c) => c.fieldPath);
+  const primary = conflicts[0];
+  const kindSummary = primary.kinds.join(" + ");
+  return {
+    code: "MULTIPLE_WRITERS",
+    message: `[StateTrait.build] Multiple writers for field "${primary.fieldPath}" (${kindSummary}). Only one of computed/link/source/externalStore can write a fieldPath.`,
+    fields
+  };
+};
+var getConvergeWriterDeps = (entry) => {
+  if (entry.kind === "computed") {
     return entry.meta?.deps ?? [];
   }
   return [entry.meta.from];
@@ -615,24 +760,11 @@ var collectSchemaFieldPaths = (schema) => {
     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;
+    let current = SchemaAST.toType(ast);
+    while (SchemaAST.isSuspend(current)) {
+      if (seen.has(current)) return;
+      seen.add(current);
+      current = SchemaAST.toType(current.thunk());
     }
     if (SchemaAST.isUnion(current)) {
       for (const t of current.types) {
@@ -640,16 +772,16 @@ var collectSchemaFieldPaths = (schema) => {
       }
       return;
     }
-    if (SchemaAST.isTupleType(current)) {
+    if (SchemaAST.isArrays(current)) {
       for (const e of current.elements) {
-        visit(e.type, prefix, seen);
+        visit(e, prefix, seen);
       }
       for (const r of current.rest) {
-        visit(r.type, prefix, seen);
+        visit(r, prefix, seen);
       }
       return;
     }
-    if (SchemaAST.isTypeLiteral(current)) {
+    if (SchemaAST.isObjects(current)) {
       for (const ps of current.propertySignatures) {
         const seg = String(ps.name);
         if (!seg) continue;
@@ -666,6 +798,7 @@ var collectSchemaFieldPaths = (schema) => {
 var buildConvergeIr = (stateSchema, entries) => {
   const startedAt = nowPerf();
   const generation = 0;
+  const multipleWritersError = collectMultipleWritersError(entries);
   const writers = entries.filter((e) => e.kind === "computed" || e.kind === "link");
   const writersKey = writers.map((entry) => `${entry.kind}:${entry.fieldPath}`).sort().join("|");
   const depsKey = writers.map((entry) => {
@@ -677,7 +810,7 @@ var buildConvergeIr = (stateSchema, entries) => {
   for (const entry of writers) {
     writerByPath.set(entry.fieldPath, entry);
   }
-  const topo = writers.length > 0 ? computeConvergeTopoOrder(writers) : { order: [] };
+  const topo = multipleWritersError ? { order: [] } : writers.length > 0 ? computeConvergeTopoOrder(writers) : { order: [] };
   const stepsById = topo.configError ? [] : topo.order.map((path) => writerByPath.get(path));
   const fieldPathTable = /* @__PURE__ */ new Map();
   const addPath = (path) => {
@@ -701,6 +834,11 @@ var buildConvergeIr = (stateSchema, entries) => {
   const fieldPaths = Array.from(fieldPathTable.values()).sort(compareFieldPath);
   const fieldPathIdRegistry = makeFieldPathIdRegistry(fieldPaths);
   const fieldPathsKey = fnv1a32(stableStringify2(fieldPaths));
+  const staticIrDigest = getConvergeStaticIrDigest({
+    writersKey,
+    depsKey,
+    fieldPathsKey
+  });
   const stepOutFieldPathIdByStepId = [];
   const stepDepsFieldPathIdsByStepId = [];
   const stepSchedulingByStepId = [];
@@ -728,9 +866,10 @@ var buildConvergeIr = (stateSchema, entries) => {
     writersKey,
     depsKey,
     fieldPathsKey,
+    staticIrDigest,
     fieldPaths,
     fieldPathIdRegistry,
-    ...topo.configError ? { configError: topo.configError } : null,
+    ...multipleWritersError ? { configError: multipleWritersError } : topo.configError ? { configError: topo.configError } : null,
     stepsById,
     stepOutFieldPathIdByStepId,
     stepDepsFieldPathIdsByStepId,
@@ -886,6 +1025,12 @@ var buildGraph = (entries, nodeMetaByFieldPath) => {
           });
         }
       }
+    } else if (entry.kind === "externalStore") {
+      planSteps.push({
+        id: `external-store:${fieldPath}`,
+        kind: "external-store-sync",
+        targetFieldPath: fieldPath
+      });
     } else if (entry.kind === "check") {
       planSteps.push({
         id: `check:${fieldPath}`,
@@ -1026,7 +1171,7 @@ var collectSchemaPaths = (entries) => {
       }
     }
   }
-  return Array.from(byKey.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, v]) => v);
+  return Array.from(byKey.entries()).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map(([, v]) => v);
 };
 var build = (stateSchema, spec) => {
   const entries = normalizeSpec(spec);
@@ -1079,70 +1224,397 @@ var build = (stateSchema, spec) => {
 };
 
 // src/internal/state-trait/install.ts
-var import_effect11 = require("effect");
+var import_effect18 = require("effect");
 
 // src/internal/runtime/core/env.ts
-var import_effect = require("effect");
-var getNodeEnv = () => {
+var import_effect9 = require("effect");
+
+// src/internal/runtime/core/HostScheduler.ts
+var noopCancel = () => {
+};
+var safeNowMs = () => {
+  const perf = globalThis.performance;
+  if (perf && typeof perf.now === "function") {
+    try {
+      const v = perf.now();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+    } catch {
+    }
+  }
+  return Date.now();
+};
+var safeQueueMicrotask = (cb) => {
+  const qm = globalThis.queueMicrotask;
+  if (typeof qm === "function") {
+    try {
+      qm(cb);
+      return;
+    } catch {
+    }
+  }
   try {
-    const env = globalThis?.process?.env;
-    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+    Promise.resolve().then(cb);
   } catch {
-    return void 0;
+    setTimeout(cb, 0);
   }
 };
-var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
 };
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var makeMessageChannelMacrotask = () => {
+  const MC = globalThis.MessageChannel;
+  if (typeof MC !== "function") return void 0;
+  let channel;
+  try {
+    channel = new MC();
+  } catch {
+    return void 0;
+  }
+  const queue = [];
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    const tasks = queue.splice(0, queue.length);
+    for (const t of tasks) {
+      if (t.canceled) continue;
+      try {
+        t.cb();
+      } catch {
+      }
+    }
+  };
+  try {
+    channel.port1.onmessage = flush;
+  } catch {
+    return void 0;
+  }
+  const schedule = (cb) => {
+    const task = { canceled: false, cb };
+    queue.push(task);
+    if (!scheduled) {
+      scheduled = true;
+      try {
+        channel.port2.postMessage(void 0);
+      } catch {
+        scheduled = false;
+        return safeSetTimeout(0, cb);
+      }
+    }
+    return () => {
+      task.canceled = true;
+    };
+  };
+  return schedule;
 };
-var ReplayModeConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var makeSetImmediateMacrotask = () => {
+  const si = globalThis.setImmediate;
+  const ci = globalThis.clearImmediate;
+  if (typeof si !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = si(cb);
+    } catch {
+      return safeSetTimeout(0, cb);
+    }
+    return () => {
+      if (typeof ci !== "function") return;
+      try {
+        ci(id);
+      } catch {
+      }
+    };
+  };
 };
-var ReplayModeConfigTag = ReplayModeConfigTagImpl;
-var StateTransactionOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var makeRaf = () => {
+  const raf = globalThis.requestAnimationFrame;
+  const cancel = globalThis.cancelAnimationFrame;
+  if (typeof raf !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = raf(cb);
+    } catch {
+      return noopCancel;
+    }
+    return () => {
+      if (typeof cancel !== "function") return;
+      try {
+        cancel(id);
+      } catch {
+      }
+    };
+  };
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var makeDefaultHostScheduler = () => {
+  const macrotask = makeSetImmediateMacrotask() ?? makeMessageChannelMacrotask() ?? ((cb) => safeSetTimeout(0, cb));
+  const raf = makeRaf();
+  return {
+    nowMs: safeNowMs,
+    scheduleMicrotask: safeQueueMicrotask,
+    scheduleMacrotask: macrotask,
+    scheduleAnimationFrame: (cb) => raf?.(cb) ?? macrotask(cb),
+    scheduleTimeout: safeSetTimeout
+  };
 };
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var globalHostScheduler;
+var getGlobalHostScheduler = () => {
+  globalHostScheduler ?? (globalHostScheduler = makeDefaultHostScheduler());
+  return globalHostScheduler;
 };
 
-// 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);
+// src/internal/runtime/core/RuntimeStore.ts
+var parseTopicKey = (topicKey) => {
+  const idx = topicKey.indexOf("::");
+  if (idx <= 0) return void 0;
+  const moduleId = topicKey.slice(0, idx);
+  const rest = topicKey.slice(idx + 2);
+  if (rest.length === 0) return void 0;
+  const idx2 = rest.indexOf("::");
+  if (idx2 < 0) {
+    return { kind: "module", moduleInstanceKey: `${moduleId}::${rest}` };
   }
-  return internals;
+  const instanceId = rest.slice(0, idx2);
+  const suffix = rest.slice(idx2 + 2);
+  if (suffix.startsWith("rq:")) {
+    const selectorId = suffix.slice("rq:".length);
+    if (selectorId.length === 0) return void 0;
+    return {
+      kind: "readQuery",
+      moduleInstanceKey: `${moduleId}::${instanceId}`,
+      selectorId
+    };
+  }
+  return { kind: "module", moduleInstanceKey: `${moduleId}::${instanceId}` };
+};
+var EMPTY_LISTENER_SNAPSHOT = [];
+var NO_CHANGED_TOPIC_LISTENERS = [];
+var makeRuntimeStore = () => {
+  let tickSeq = 0;
+  const moduleStates = /* @__PURE__ */ new Map();
+  const topicVersions = /* @__PURE__ */ new Map();
+  const topicPriorities = /* @__PURE__ */ new Map();
+  const listenersByTopic = /* @__PURE__ */ new Map();
+  const subscriberCountByModule = /* @__PURE__ */ new Map();
+  const getTopicVersion = (topicKey) => topicVersions.get(topicKey) ?? 0;
+  const getTopicPriority = (topicKey) => topicPriorities.get(topicKey) ?? "normal";
+  const commitTopicBump = (topicKey, priority) => {
+    const prev = topicVersions.get(topicKey) ?? 0;
+    topicVersions.set(topicKey, prev + 1);
+    topicPriorities.set(topicKey, priority);
+  };
+  const refreshTopicSnapshot = (state) => {
+    state.snapshot = Array.from(state.listeners);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const state = existing ?? { listeners: /* @__PURE__ */ new Set(), snapshot: EMPTY_LISTENER_SNAPSHOT };
+    const alreadyHas = state.listeners.has(listener);
+    if (!alreadyHas) {
+      state.listeners.add(listener);
+      refreshTopicSnapshot(state);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, state);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const currentState = listenersByTopic.get(topicKey);
+      if (!currentState) return;
+      const deleted = currentState.listeners.delete(listener);
+      if (deleted && info) {
+        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          subscriberCountByModule.delete(info.moduleInstanceKey);
+        } else {
+          subscriberCountByModule.set(info.moduleInstanceKey, next);
+        }
+      }
+      if (currentState.listeners.size === 0) {
+        listenersByTopic.delete(topicKey);
+      } else if (deleted) {
+        refreshTopicSnapshot(currentState);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.listeners.size ?? 0;
+  const getModuleSubscriberCount = (moduleInstanceKey) => subscriberCountByModule.get(moduleInstanceKey) ?? 0;
+  const registerModuleInstance = (args) => {
+    moduleStates.set(args.moduleInstanceKey, args.initialState);
+    if (!topicVersions.has(args.moduleInstanceKey)) {
+      topicVersions.set(args.moduleInstanceKey, 0);
+      topicPriorities.set(args.moduleInstanceKey, "normal");
+    }
+  };
+  const unregisterModuleInstance = (moduleInstanceKey) => {
+    moduleStates.delete(moduleInstanceKey);
+  };
+  const commitTick = (args) => {
+    tickSeq = args.tickSeq;
+    for (const [key, commit] of args.accepted.modules) {
+      moduleStates.set(key, commit.state);
+    }
+    if (args.accepted.dirtyTopics.size === 0) {
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    if (args.onListener) {
+      let firstTopicListeners;
+      let secondTopicListeners;
+      let restTopicListeners;
+      for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+        commitTopicBump(topicKey, priority);
+        const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+        if (listeners.length === 0) {
+          continue;
+        }
+        if (!firstTopicListeners) {
+          firstTopicListeners = listeners;
+          continue;
+        }
+        if (!secondTopicListeners) {
+          secondTopicListeners = listeners;
+          continue;
+        }
+        if (!restTopicListeners) {
+          restTopicListeners = [];
+        }
+        restTopicListeners.push(listeners);
+      }
+      if (firstTopicListeners) {
+        for (const listener of firstTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (secondTopicListeners) {
+        for (const listener of secondTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (restTopicListeners) {
+        for (const listeners of restTopicListeners) {
+          for (const listener of listeners) {
+            try {
+              args.onListener(listener);
+            } catch {
+            }
+          }
+        }
+      }
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    let singleTopicListeners;
+    let flattenedTopicListeners;
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+      if (listeners.length === 0) {
+        continue;
+      }
+      if (flattenedTopicListeners) {
+        for (const listener of listeners) {
+          flattenedTopicListeners.push(listener);
+        }
+        continue;
+      }
+      if (!singleTopicListeners) {
+        singleTopicListeners = listeners;
+        continue;
+      }
+      flattenedTopicListeners = Array.from(singleTopicListeners);
+      for (const listener of listeners) {
+        flattenedTopicListeners.push(listener);
+      }
+    }
+    return {
+      changedTopicListeners: flattenedTopicListeners ?? singleTopicListeners ?? NO_CHANGED_TOPIC_LISTENERS
+    };
+  };
+  const getModuleState = (moduleInstanceKey) => moduleStates.get(moduleInstanceKey);
+  const dispose = () => {
+    moduleStates.clear();
+    topicVersions.clear();
+    topicPriorities.clear();
+    listenersByTopic.clear();
+    subscriberCountByModule.clear();
+  };
+  return {
+    getTickSeq: () => tickSeq,
+    getModuleState,
+    getTopicVersion,
+    getTopicPriority,
+    subscribeTopic,
+    getTopicSubscriberCount,
+    getModuleSubscriberCount,
+    registerModuleInstance,
+    unregisterModuleInstance,
+    commitTick,
+    dispose
+  };
 };
 
-// src/internal/state-trait/source.ts
-var import_effect10 = require("effect");
-var import_mutative = require("mutative");
+// src/internal/runtime/core/TickScheduler.ts
+var import_effect7 = require("effect");
 
-// src/internal/effect-op.ts
-var import_effect4 = require("effect");
+// src/internal/runtime/core/DebugSink.record.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/runtime/core/errorSummary.ts
+var import_effect = 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 currentLinkId = import_effect2.ServiceMap.Reference("@logixjs/core/CurrentLinkId", {
+  defaultValue: () => void 0
+});
+var composeMiddlewareCache = /* @__PURE__ */ new WeakMap();
+var EffectOpMiddlewareTag = class extends import_effect2.ServiceMap.Service()("Logix/EffectOpMiddleware") {
 };
 var composeMiddleware = (stack) => {
-  return (op) => stack.reduceRight(
+  const cached = composeMiddlewareCache.get(stack);
+  if (cached) {
+    return cached;
+  }
+  const composed = (op) => stack.reduceRight(
     (eff, mw) => mw({ ...op, effect: eff }),
     op.effect
   );
+  composeMiddlewareCache.set(stack, composed);
+  return composed;
 };
 var runWithMiddleware = (op, stack) => {
   return import_effect2.Effect.gen(function* () {
-    const existing = yield* import_effect2.FiberRef.get(currentLinkId);
+    const existing = yield* import_effect2.Effect.service(currentLinkId);
     const metaLinkId = op.meta?.linkId;
     const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
     const nextOp = {
@@ -1153,156 +1625,51 @@ var runWithMiddleware = (op, stack) => {
       }
     };
     const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
-    return yield* import_effect2.Effect.locally(currentLinkId, linkId)(program);
+    return yield* import_effect2.Effect.provideService(program, currentLinkId, linkId);
   });
 };
 
-// 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
+// src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentDebugSinks", {
+  defaultValue: () => []
 });
-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 currentRuntimeLabel = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentRuntimeLabel", {
+  defaultValue: () => void 0
+});
+var currentTxnId = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentTxnId", {
+  defaultValue: () => void 0
+});
+var currentOpSeq = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentOpSeq", {
+  defaultValue: () => void 0
+});
+var currentDiagnosticsLevel = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentDiagnosticsLevel", {
+  defaultValue: () => "off"
+});
+var currentDiagnosticsMaterialization = import_effect3.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentDiagnosticsMaterialization",
+  {
+    defaultValue: () => "eager"
   }
-};
-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 currentTraceMode = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentTraceMode", {
+  defaultValue: () => "on"
 });
+var currentTraitConvergeDiagnosticsSampling = import_effect3.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentTraitConvergeDiagnosticsSampling",
+  {
+    defaultValue: () => ({
+      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
-      });
+      return import_effect3.Cause.pretty(event.cause);
     } catch {
       try {
         return JSON.stringify(event.cause, null, 2);
@@ -1313,8 +1680,8 @@ var lifecycleErrorLog = (event) => {
   })();
   const message = `[Logix][module=${moduleId}] lifecycle:error
 ${causePretty}`;
-  return import_effect7.Effect.logError(message).pipe(
-    import_effect7.Effect.annotateLogs({
+  return import_effect3.Effect.logError(message).pipe(
+    import_effect3.Effect.annotateLogs({
       "logix.moduleId": moduleId,
       "logix.event": "lifecycle:error",
       "logix.cause": causePretty
@@ -1328,7 +1695,7 @@ var diagnosticLog = (event) => {
 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 base = event.severity === "warning" ? import_effect3.Effect.logWarning(msg) : event.severity === "info" ? import_effect3.Effect.logInfo(msg) : import_effect3.Effect.logError(msg);
   const annotations = {
     "logix.moduleId": moduleId,
     "logix.event": `diagnostic(${event.severity})`,
@@ -1341,24 +1708,24 @@ ${detail}`;
   if (event.actionTag) {
     annotations["logix.diagnostic.actionTag"] = event.actionTag;
   }
-  return base.pipe(import_effect7.Effect.annotateLogs(annotations));
+  return base.pipe(import_effect3.Effect.annotateLogs(annotations));
 };
-var noopLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, []);
+var noopLayer = import_effect3.Layer.succeed(currentDebugSinks, []);
 var errorOnlySink = {
-  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect7.Effect.void
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void
 };
-var errorOnlyLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var errorOnlyLayer = import_effect3.Layer.succeed(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 })
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event })
 };
-var consoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var consoleLayer = import_effect3.Layer.succeed(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(() => {
+    return import_effect3.Effect.sync(() => {
       console.groupCollapsed(
         "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
         "color:#6b7280;font-weight:bold",
@@ -1378,7 +1745,7 @@ var renderBrowserConsoleEvent = (event) => {
     const moduleId = event.moduleId ?? "unknown";
     const causePretty = (() => {
       try {
-        return import_effect7.Cause.pretty(event.cause, { renderErrorCause: true });
+        return import_effect3.Cause.pretty(event.cause);
       } catch {
         try {
           return JSON.stringify(event.cause, null, 2);
@@ -1389,10 +1756,10 @@ var renderBrowserConsoleEvent = (event) => {
     })();
     const key = `${moduleId}|${causePretty}`;
     if (browserLifecycleSeen.has(key)) {
-      return import_effect7.Effect.void;
+      return import_effect3.Effect.void;
     }
     browserLifecycleSeen.add(key);
-    return import_effect7.Effect.sync(() => {
+    return import_effect3.Effect.sync(() => {
       console.groupCollapsed(
         "%c[Logix]%c lifecycle:error %c" + moduleId,
         "color:#ef4444;font-weight:bold",
@@ -1414,10 +1781,10 @@ hint: ${event.hint}` : ""}`;
     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;
+      return import_effect3.Effect.void;
     }
     browserDiagnosticSeen.add(key);
-    return import_effect7.Effect.sync(() => {
+    return import_effect3.Effect.sync(() => {
       console.groupCollapsed(
         "%c[Logix]%c " + label + "%c module=" + moduleId,
         "color:#6b7280;font-weight:bold",
@@ -1434,55 +1801,52 @@ hint: ${event.hint}` : ""}`;
       console.groupEnd();
     });
   }
-  return import_effect7.Effect.void;
+  return import_effect3.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 event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event });
     }
     return renderBrowserConsoleEvent(event);
   }
 };
-var browserConsoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserConsoleLayer = import_effect3.Layer.succeed(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" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void;
     }
-    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect7.Effect.void;
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect3.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 browserDiagnosticConsoleLayer = import_effect3.Layer.succeed(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect3.Layer.effect(
+  import_effect3.Logger.CurrentLoggers,
+  import_effect3.Effect.gen(function* () {
+    const current = yield* import_effect3.Effect.service(import_effect3.Logger.CurrentLoggers);
+    return new Set(
+      [...current].filter((logger) => logger !== import_effect3.Logger.defaultLogger).concat(import_effect3.Logger.consolePretty({ mode: "browser", colors: true }))
+    );
+  })
 );
-var record = (event) => import_effect7.Effect.gen(function* () {
-  const sinks = yield* import_effect7.FiberRef.get(currentDebugSinks);
+var record = (event) => import_effect3.Effect.gen(function* () {
+  const sinks = yield* import_effect3.Effect.service(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;
+    if (event.type === "diagnostic" && event.severity !== "info") {
+      yield* diagnosticLog(event);
     }
-    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") {
@@ -1491,13 +1855,15 @@ var record = (event) => import_effect7.Effect.gen(function* () {
     }
     if (event.type === "diagnostic") {
       yield* diagnosticLog(event);
-      return;
     }
-    yield* import_effect7.Effect.void;
     return;
   }
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const mode = yield* import_effect3.Effect.service(currentTraceMode);
+    if (mode === "off") return;
+  }
   const enriched = event;
-  const diagnosticsLevel = yield* import_effect7.FiberRef.get(currentDiagnosticsLevel);
+  const diagnosticsLevel = yield* import_effect3.Effect.service(currentDiagnosticsLevel);
   let now;
   const getNow = () => {
     if (now === void 0) now = Date.now();
@@ -1508,47 +1874,390 @@ var record = (event) => import_effect7.Effect.gen(function* () {
     enriched.timestamp = getNow();
   }
   if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
-    const runtimeLabel = yield* import_effect7.FiberRef.get(currentRuntimeLabel);
+    const runtimeLabel = yield* import_effect3.Effect.service(currentRuntimeLabel);
     if (runtimeLabel) {
       ;
       enriched.runtimeLabel = runtimeLabel;
     }
   }
   if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
-    const txnId = yield* import_effect7.FiberRef.get(currentTxnId);
+    const txnId = yield* import_effect3.Effect.service(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) {
+    const maybeLinkId = yield* import_effect3.Effect.serviceOption(currentLinkId);
+    if (import_effect3.Option.isSome(maybeLinkId) && maybeLinkId.value) {
       ;
-      enriched.linkId = linkId;
+      enriched.linkId = maybeLinkId.value;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect3.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect6 = require("effect");
+
+// src/internal/runtime/core/ModeRunner.ts
+var import_effect5 = require("effect");
+
+// src/internal/runtime/core/LatestFiberSlot.ts
+var import_effect4 = require("effect");
+
+// src/internal/runtime/core/TaskRunner.ts
+var inSyncTransactionFiber = import_effect6.ServiceMap.Reference("@logixjs/core/TaskRunner.inSyncTransactionFiber", {
+  defaultValue: () => false
+});
+var forceSourceRefresh = import_effect6.ServiceMap.Reference("@logixjs/core/TaskRunner.forceSourceRefresh", {
+  defaultValue: () => false
+});
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect8 = require("effect");
+var makeDeclarativeLinkRuntime = () => {
+  const moduleAsSourceById = /* @__PURE__ */ new Map();
+  const moduleAsSourceIdsBySource = /* @__PURE__ */ new Map();
+  const declarativeById = /* @__PURE__ */ new Map();
+  const declarativeReadNodesBySource = /* @__PURE__ */ new Map();
+  const registerModuleAsSourceLink = (link2) => {
+    const stored = {
+      ...link2,
+      hasValue: false,
+      lastValue: void 0
+    };
+    moduleAsSourceById.set(link2.id, stored);
+    const set = moduleAsSourceIdsBySource.get(link2.sourceModuleInstanceKey) ?? /* @__PURE__ */ new Set();
+    set.add(link2.id);
+    moduleAsSourceIdsBySource.set(link2.sourceModuleInstanceKey, set);
+    return () => {
+      moduleAsSourceById.delete(link2.id);
+      const current = moduleAsSourceIdsBySource.get(link2.sourceModuleInstanceKey);
+      if (!current) return;
+      current.delete(link2.id);
+      if (current.size === 0) {
+        moduleAsSourceIdsBySource.delete(link2.sourceModuleInstanceKey);
+      }
+    };
+  };
+  const registerDeclarativeLink = (link2) => {
+    const readNodeById = /* @__PURE__ */ new Map();
+    for (const n of link2.readNodes) {
+      readNodeById.set(n.nodeId, n);
+    }
+    const dispatchNodeById = /* @__PURE__ */ new Map();
+    for (const n of link2.dispatchNodes) {
+      dispatchNodeById.set(n.nodeId, n);
+    }
+    const incomingByDispatch = /* @__PURE__ */ new Map();
+    for (const e of link2.ir.edges) {
+      const to = e.to;
+      const isDispatch = dispatchNodeById.has(to);
+      if (!isDispatch) continue;
+      incomingByDispatch.set(to, (incomingByDispatch.get(to) ?? 0) + 1);
+      const count = incomingByDispatch.get(to) ?? 0;
+      if (count > 1) {
+        throw new Error(
+          `[DeclarativeLinkRuntime] Invalid DeclarativeLinkIR: dispatch node has multiple incoming edges (linkId=${link2.linkId}, nodeId=${to}).`
+        );
+      }
+    }
+    const dispatchTargetsByReadNode = /* @__PURE__ */ new Map();
+    for (const e of link2.ir.edges) {
+      const from2 = e.from;
+      const to = e.to;
+      if (!readNodeById.has(from2)) continue;
+      if (!dispatchNodeById.has(to)) continue;
+      const list2 = dispatchTargetsByReadNode.get(from2) ?? [];
+      list2.push(to);
+      dispatchTargetsByReadNode.set(from2, list2);
+    }
+    const stored = {
+      ...link2,
+      readNodeById,
+      dispatchNodeById,
+      dispatchTargetsByReadNode,
+      readNodeState: /* @__PURE__ */ new Map()
+    };
+    declarativeById.set(link2.linkId, stored);
+    for (const n of link2.readNodes) {
+      const list2 = declarativeReadNodesBySource.get(n.moduleInstanceKey) ?? [];
+      list2.push({ linkId: link2.linkId, nodeId: n.nodeId });
+      declarativeReadNodesBySource.set(n.moduleInstanceKey, list2);
+    }
+    return () => {
+      declarativeById.delete(link2.linkId);
+      for (const n of link2.readNodes) {
+        const list2 = declarativeReadNodesBySource.get(n.moduleInstanceKey);
+        if (!list2) continue;
+        const next = list2.filter((x) => !(x.linkId === link2.linkId && x.nodeId === n.nodeId));
+        if (next.length === 0) {
+          declarativeReadNodesBySource.delete(n.moduleInstanceKey);
+        } else {
+          declarativeReadNodesBySource.set(n.moduleInstanceKey, next);
+        }
+      }
+    };
+  };
+  const applyForSources = (args) => import_effect8.Effect.gen(function* () {
+    let scheduled = false;
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const ids = moduleAsSourceIdsBySource.get(sourceKey);
+      if (!ids || ids.size === 0) continue;
+      const commit = args.acceptedModules.get(sourceKey);
+      if (!commit) continue;
+      for (const id of ids) {
+        const link2 = moduleAsSourceById.get(id);
+        if (!link2) continue;
+        let selected;
+        try {
+          selected = link2.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const nextValue = link2.computeValue(selected);
+        if (link2.hasValue && link2.equalsValue(link2.lastValue, nextValue)) {
+          continue;
+        }
+        link2.hasValue = true;
+        link2.lastValue = nextValue;
+        scheduled = true;
+        yield* link2.applyValue(nextValue);
+      }
+    }
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const refs = declarativeReadNodesBySource.get(sourceKey);
+      if (!refs || refs.length === 0) continue;
+      const commit = args.acceptedModules.get(sourceKey);
+      if (!commit) continue;
+      for (const ref of refs) {
+        const link2 = declarativeById.get(ref.linkId);
+        if (!link2) continue;
+        const readNode = link2.readNodeById.get(ref.nodeId);
+        if (!readNode) continue;
+        let value;
+        try {
+          value = readNode.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const state = link2.readNodeState.get(ref.nodeId) ?? { hasValue: false, lastValue: void 0 };
+        const changed = !state.hasValue || !Object.is(state.lastValue, value);
+        if (!changed) continue;
+        state.hasValue = true;
+        state.lastValue = value;
+        link2.readNodeState.set(ref.nodeId, state);
+        const targets = link2.dispatchTargetsByReadNode.get(ref.nodeId) ?? [];
+        for (const dispatchNodeId of targets) {
+          const node2 = link2.dispatchNodeById.get(dispatchNodeId);
+          if (!node2) continue;
+          scheduled = true;
+          yield* node2.dispatch(value);
+        }
+      }
+    }
+    return { scheduled };
+  });
+  return {
+    registerModuleAsSourceLink,
+    registerDeclarativeLink,
+    applyForSources
+  };
+};
+
+// src/internal/runtime/core/env.ts
+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_effect9.ServiceMap.Service()("@logixjs/core/StateTransactionRuntimeConfig") {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect9.ServiceMap.Service()("@logixjs/core/ReadQueryStrictGateRuntimeConfig") {
+};
+var ReplayModeConfigTagImpl = class extends import_effect9.ServiceMap.Service()("@logixjs/core/ReplayModeConfig") {
+};
+var ReplayModeConfigTag = ReplayModeConfigTagImpl;
+var StateTransactionOverridesTagImpl = class extends import_effect9.ServiceMap.Service()("@logixjs/core/StateTransactionOverrides") {
+};
+var SchedulingPolicySurfaceTagImpl = class extends import_effect9.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurface") {
+};
+var SchedulingPolicySurfaceOverridesTagImpl = class extends import_effect9.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurfaceOverrides") {
+};
+var RuntimeStoreTag = class extends import_effect9.ServiceMap.Service()("@logixjs/core/RuntimeStore") {
+};
+var runtimeStoreLayer = import_effect9.Layer.effect(
+  RuntimeStoreTag,
+  import_effect9.Effect.acquireRelease(
+    import_effect9.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect9.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect9.ServiceMap.Service()("@logixjs/core/HostScheduler") {
+};
+var hostSchedulerLayer = import_effect9.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect9.ServiceMap.Service()("@logixjs/core/DeclarativeLinkRuntime") {
+};
+var declarativeLinkRuntimeLayer = import_effect9.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect9.ServiceMap.Service()("@logixjs/core/TickScheduler") {
+};
+
+// 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.impl.ts
+var import_effect14 = require("effect");
+var import_mutative = require("mutative");
+
+// src/internal/effect-op.ts
+var import_effect11 = require("effect");
+
+// src/internal/observability/runSession.ts
+var import_effect10 = require("effect");
+var RunSessionTagImpl = class extends import_effect10.ServiceMap.Service()("@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 make2 = (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_effect12 = 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);
   }
-  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);
+};
+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_effect12.ServiceMap.Service()("@logixjs/core/ResourceRegistry") {
+};
+var internal = {
+  ResourceRegistryTag
+};
 
 // src/internal/runtime/core/ReplayLog.ts
-var import_effect9 = require("effect");
-var ReplayLog = class extends import_effect9.Context.Tag("@logixjs/core/ReplayLog")() {
+var import_effect13 = require("effect");
+var ReplayLog = class extends import_effect13.ServiceMap.Service()("@logixjs/core/ReplayLog") {
 };
-var snapshot = import_effect9.Effect.gen(function* () {
+var snapshot = import_effect13.Effect.gen(function* () {
   const log = yield* ReplayLog;
   return yield* log.snapshot;
 });
-var resetCursor = import_effect9.Effect.gen(function* () {
+var resetCursor = import_effect13.Effect.gen(function* () {
   const log = yield* ReplayLog;
   yield* log.resetCursor;
 });
@@ -1698,16 +2407,16 @@ var trace = (fn, state) => {
   };
 };
 
-// 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)
+// src/internal/state-trait/source.impl.ts
+var onceInRunSession = (key) => import_effect14.Effect.serviceOption(RunSessionTag).pipe(
+  import_effect14.Effect.map((maybe) => import_effect14.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* () {
+var emitDepsMismatch = (params) => import_effect14.Effect.gen(function* () {
   const key = `${params.instanceId ?? "unknown"}::${params.kind}::${params.fieldPath}`;
   const shouldEmit = yield* onceInRunSession(`deps_mismatch:${key}`);
   if (!shouldEmit) return;
@@ -1722,8 +2431,10 @@ var emitDepsMismatch = (params) => import_effect10.Effect.gen(function* () {
     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 getMiddlewareStack = () => import_effect14.Effect.serviceOption(
+  EffectOpMiddlewareTag
+).pipe(
+  import_effect14.Effect.map((maybe) => import_effect14.Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var recordTraitPatch = (bound, path, reason, from2, to, traitNodeId) => {
   const normalized = normalizeFieldPath(path) ?? [];
@@ -1748,7 +2459,7 @@ var getBoundScope = (bound) => {
     return { moduleId: void 0, instanceId: void 0 };
   }
 };
-var setSnapshotInTxn = (bound, fieldPath, next, reason, stepId, traitNodeId) => import_effect10.Effect.gen(function* () {
+var setSnapshotInTxn = (bound, fieldPath, next, reason, stepId, traitNodeId) => import_effect14.Effect.gen(function* () {
   let wrote = false;
   yield* bound.state.mutate((draft) => {
     const prev = getAtPath(draft, fieldPath);
@@ -1759,7 +2470,7 @@ var setSnapshotInTxn = (bound, fieldPath, next, reason, stepId, traitNodeId) =>
   });
   return wrote;
 });
-var writebackIfCurrentKeyHash = (bound, fieldPath, keyHash2, next, reason, stepId, traitNodeId, replayEvent) => import_effect10.Effect.gen(function* () {
+var writebackIfCurrentKeyHash = (bound, fieldPath, keyHash2, next, reason, stepId, traitNodeId, replayEvent) => import_effect14.Effect.gen(function* () {
   let wrote = false;
   yield* bound.state.mutate((draft) => {
     const current = getAtPath(draft, fieldPath);
@@ -1777,7 +2488,7 @@ var writebackIfCurrentKeyHash = (bound, fieldPath, keyHash2, next, reason, stepI
   return wrote;
 });
 var installSourceRefresh = (bound, step, entry) => {
-  if (!step.targetFieldPath) return import_effect10.Effect.void;
+  if (!step.targetFieldPath) return import_effect14.Effect.void;
   const fieldPath = step.targetFieldPath;
   const resourceId = step.resourceId ?? entry.meta.resource;
   const listItem = parseListItemFieldPath(fieldPath);
@@ -1785,12 +2496,12 @@ var installSourceRefresh = (bound, step, entry) => {
   try {
     internals = getBoundInternals(bound);
   } catch {
-    return import_effect10.Effect.void;
+    return import_effect14.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;
+    if (!replayLog) return import_effect14.Effect.void;
+    if (replayMode !== "live") return import_effect14.Effect.void;
     const event = input && typeof input === "object" && input._tag === "ResourceSnapshot" ? input : {
       _tag: "ResourceSnapshot",
       resourceId,
@@ -1808,12 +2519,12 @@ var installSourceRefresh = (bound, step, entry) => {
   if (listItem) {
     const store = internals.traits.rowIdStore;
     if (!store) {
-      return import_effect10.Effect.void;
+      return import_effect14.Effect.void;
     }
     const listPath = listItem.listPath;
     const itemPath = listItem.itemPath;
     if (!itemPath) {
-      return import_effect10.Effect.void;
+      return import_effect14.Effect.void;
     }
     const concurrency2 = entry.meta.concurrency;
     const mode2 = concurrency2 ?? "switch";
@@ -1824,7 +2535,7 @@ var installSourceRefresh = (bound, step, entry) => {
       trailing2.delete(rowId);
       inFlight2.delete(rowId);
     });
-    const setSnapshotForRowInTxn = (rowId, next, reason, stepId) => import_effect10.Effect.gen(function* () {
+    const setSnapshotForRowInTxn = (rowId, next, reason, stepId) => import_effect14.Effect.gen(function* () {
       let wrotePath;
       yield* bound.state.mutate((draft) => {
         const index = store.getIndex(listPath, rowId);
@@ -1838,7 +2549,7 @@ var installSourceRefresh = (bound, step, entry) => {
       });
       return wrotePath;
     });
-    const writebackIfCurrentKeyHashForRow = (rowId, keyHash2, next, reason, stepId, phase) => import_effect10.Effect.gen(function* () {
+    const writebackIfCurrentKeyHashForRow = (rowId, keyHash2, next, reason, stepId, phase) => import_effect14.Effect.gen(function* () {
       let wrotePath;
       yield* bound.state.mutate((draft) => {
         const index = store.getIndex(listPath, rowId);
@@ -1870,7 +2581,7 @@ var installSourceRefresh = (bound, step, entry) => {
       });
       return wrotePath;
     });
-    const startFetch2 = (rowId, key, keyHash2, replayMode, replayLog) => import_effect10.Effect.gen(function* () {
+    const startFetch2 = (rowId, key, keyHash2, replayMode, replayLog) => import_effect14.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);
@@ -1908,17 +2619,17 @@ var installSourceRefresh = (bound, step, entry) => {
         recordReplayEvent(bound, event);
         yield* recordSnapshot(replayMode, replayLog, event);
       }
-      const io = import_effect10.Effect.gen(function* () {
+      const io = import_effect14.Effect.gen(function* () {
         if (replayMode === "replay" && replayLog) {
-          yield* import_effect10.Effect.yieldNow();
+          yield* import_effect14.Effect.yieldNow;
           const consumePath = wroteLoadingPath ?? logFieldPath;
-          if (!consumePath) return yield* import_effect10.Effect.void;
+          if (!consumePath) return yield* import_effect14.Effect.void;
           const replayed = yield* replayLog.consumeNextResourceSnapshot({
             resourceId,
             fieldPath: consumePath,
             keyHash: keyHash2
           });
-          if (!replayed) return yield* import_effect10.Effect.void;
+          if (!replayed) return yield* import_effect14.Effect.void;
           if (replayed.phase === "success") {
             yield* writebackIfCurrentKeyHashForRow(
               rowId,
@@ -1938,14 +2649,16 @@ var installSourceRefresh = (bound, step, entry) => {
               "error"
             );
           }
-          return yield* import_effect10.Effect.void;
+          return yield* import_effect14.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 registryOpt = yield* import_effect14.Effect.serviceOption(
+          internal.ResourceRegistryTag
+        );
+        const registry = import_effect14.Option.isSome(registryOpt) ? registryOpt.value : void 0;
         const spec = registry?.specs.get(resourceId);
         if (!spec) {
-          return yield* import_effect10.Effect.void;
+          return yield* import_effect14.Effect.void;
         }
         const loadEffect = spec.load(key);
         const meta = {
@@ -1960,19 +2673,19 @@ var installSourceRefresh = (bound, step, entry) => {
           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 sessionOpt = yield* import_effect14.Effect.serviceOption(RunSessionTag);
+          if (import_effect14.Option.isSome(sessionOpt)) {
             const seqKey = instanceId ?? "global";
             meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", seqKey);
           }
         }
-        const op = make({
+        const op = make2({
           kind: "service",
           name: resourceId,
           effect: loadEffect,
           meta
         });
-        const exit = yield* import_effect10.Effect.exit(run(op, stack));
+        const exit = yield* import_effect14.Effect.exit(run(op, stack));
         if (exit._tag === "Success") {
           const successSnapshot = Snapshot.success({ keyHash: keyHash2, data: exit.value });
           const wroteSuccessPath = yield* writebackIfCurrentKeyHashForRow(
@@ -2022,47 +2735,40 @@ var installSourceRefresh = (bound, step, entry) => {
             });
           }
         }
-      }).pipe(import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void));
-      const fiber = yield* import_effect10.Effect.forkScoped(import_effect10.Effect.locally(inSyncTransactionFiber, false)(io));
+      }).pipe(import_effect14.Effect.catchCause(() => import_effect14.Effect.void));
+      const fiber = yield* import_effect14.Effect.forkScoped(import_effect14.Effect.provideService(io, inSyncTransactionFiber, false));
       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)
-          )
-        )
+      yield* import_effect14.Effect.forkScoped(
+        import_effect14.Effect.provideService(import_effect14.Fiber.await(fiber).pipe(
+          import_effect14.Effect.flatMap(() => import_effect14.Effect.sync(() => {
+            const current = inFlight2.get(rowId);
+            if (current && current.gen === myGen) {
+              inFlight2.delete(rowId);
+            }
+          })),
+          import_effect14.Effect.flatMap(() => mode2 === "exhaust-trailing" ? import_effect14.Effect.gen(function* () {
+            const next = trailing2.get(rowId);
+            trailing2.delete(rowId);
+            if (next) {
+              yield* startFetch2(rowId, next.key, next.keyHash, replayMode, replayLog);
+            }
+          }) : import_effect14.Effect.void),
+          import_effect14.Effect.catchCause(() => import_effect14.Effect.void)
+        ), inSyncTransactionFiber, false)
       );
     });
     register(
       fieldPath,
-      (state) => import_effect10.Effect.gen(function* () {
+      (state) => import_effect14.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 replayModeOpt = yield* import_effect14.Effect.serviceOption(
+          ReplayModeConfigTag
+        );
+        const replayMode = import_effect14.Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+        const replayLogOpt = yield* import_effect14.Effect.serviceOption(ReplayLog);
+        const replayLog = import_effect14.Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+        const force = yield* import_effect14.Effect.service(forceSourceRefresh).pipe(import_effect14.Effect.orDie);
         const listValue = getAtPath(state, listPath);
         const items = Array.isArray(listValue) ? listValue : [];
         const ids = store.ensureList(listPath, items);
@@ -2173,14 +2879,14 @@ var installSourceRefresh = (bound, step, entry) => {
         }
       })
     );
-    return import_effect10.Effect.void;
+    return import_effect14.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 startFetch = (key, keyHash2, replayMode, replayLog) => import_effect14.Effect.gen(function* () {
     const { moduleId, instanceId } = getBoundScope(bound);
     let loadingSnapshot = Snapshot.loading({ keyHash: keyHash2 });
     if (replayMode === "replay" && replayLog) {
@@ -2218,15 +2924,15 @@ var installSourceRefresh = (bound, step, entry) => {
       recordReplayEvent(bound, event);
       yield* recordSnapshot(replayMode, replayLog, event);
     }
-    const io = import_effect10.Effect.gen(function* () {
+    const io = import_effect14.Effect.gen(function* () {
       if (replayMode === "replay" && replayLog) {
-        yield* import_effect10.Effect.yieldNow();
+        yield* import_effect14.Effect.yieldNow;
         const replayed = yield* replayLog.consumeNextResourceSnapshot({
           resourceId,
           fieldPath,
           keyHash: keyHash2
         });
-        if (!replayed) return yield* import_effect10.Effect.void;
+        if (!replayed) return yield* import_effect14.Effect.void;
         if (replayed.phase === "success") {
           const event = {
             _tag: "ResourceSnapshot",
@@ -2274,14 +2980,14 @@ var installSourceRefresh = (bound, step, entry) => {
             event
           );
         }
-        return yield* import_effect10.Effect.void;
+        return yield* import_effect14.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 registryOpt = yield* import_effect14.Effect.serviceOption(internal.ResourceRegistryTag);
+      const registry = import_effect14.Option.isSome(registryOpt) ? registryOpt.value : void 0;
       const spec = registry?.specs.get(resourceId);
       if (!spec) {
-        return yield* import_effect10.Effect.void;
+        return yield* import_effect14.Effect.void;
       }
       const loadEffect = spec.load(key);
       const meta = {
@@ -2295,19 +3001,19 @@ var installSourceRefresh = (bound, step, entry) => {
         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 sessionOpt = yield* import_effect14.Effect.serviceOption(RunSessionTag);
+        if (import_effect14.Option.isSome(sessionOpt)) {
           const seqKey = instanceId ?? "global";
           meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", seqKey);
         }
       }
-      const op = make({
+      const op = make2({
         kind: "trait-source",
         name: resourceId,
         effect: loadEffect,
         meta
       });
-      const exit = yield* import_effect10.Effect.exit(run(op, stack));
+      const exit = yield* import_effect14.Effect.exit(run(op, stack));
       if (exit._tag === "Success") {
         const successSnapshot = Snapshot.success({ keyHash: keyHash2, data: exit.value });
         const event = {
@@ -2363,46 +3069,39 @@ var installSourceRefresh = (bound, step, entry) => {
           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));
+    }).pipe(import_effect14.Effect.catchCause(() => import_effect14.Effect.void));
+    const fiber = yield* import_effect14.Effect.forkScoped(import_effect14.Effect.provideService(io, inSyncTransactionFiber, false));
     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)
-        )
-      )
+    yield* import_effect14.Effect.forkScoped(
+      import_effect14.Effect.provideService(import_effect14.Fiber.await(fiber).pipe(
+        import_effect14.Effect.flatMap(() => import_effect14.Effect.sync(() => {
+          if (inFlight && inFlight.gen === myGen) {
+            inFlight = void 0;
+          }
+        })),
+        import_effect14.Effect.flatMap(() => mode === "exhaust-trailing" ? import_effect14.Effect.gen(function* () {
+          const next = trailing;
+          trailing = void 0;
+          if (next) {
+            yield* startFetch(next.key, next.keyHash, replayMode, replayLog);
+          }
+        }) : import_effect14.Effect.void),
+        import_effect14.Effect.catchCause(() => import_effect14.Effect.void)
+      ), inSyncTransactionFiber, false)
     );
   });
   register(
     fieldPath,
-    (state) => import_effect10.Effect.gen(function* () {
+    (state) => import_effect14.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 replayModeOpt = yield* import_effect14.Effect.serviceOption(
+        ReplayModeConfigTag
+      );
+      const replayMode = import_effect14.Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+      const replayLogOpt = yield* import_effect14.Effect.serviceOption(ReplayLog);
+      const replayLog = import_effect14.Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+      const force = yield* import_effect14.Effect.service(forceSourceRefresh).pipe(import_effect14.Effect.orDie);
       let key;
       try {
         key = entry.meta.key(state);
@@ -2428,7 +3127,7 @@ var installSourceRefresh = (bound, step, entry) => {
       }
       if (key === void 0) {
         if (inFlight) {
-          yield* import_effect10.Fiber.interruptFork(inFlight.fiber);
+          yield* import_effect14.Fiber.interrupt(inFlight.fiber);
           inFlight = void 0;
         }
         trailing = void 0;
@@ -2501,15 +3200,629 @@ var installSourceRefresh = (bound, step, entry) => {
         return;
       }
       if (mode === "switch" && inFlight) {
-        yield* import_effect10.Fiber.interruptFork(inFlight.fiber);
+        yield* import_effect14.Fiber.interrupt(inFlight.fiber);
         inFlight = void 0;
         trailing = void 0;
       }
       yield* startFetch(key, h, replayMode, replayLog);
     })
   );
-  return import_effect10.Effect.void;
+  return import_effect14.Effect.void;
+};
+
+// src/internal/state-trait/external-store.ts
+var import_effect15 = require("effect");
+var import_mutative2 = require("mutative");
+
+// src/internal/external-store-descriptor.ts
+var EXTERNAL_STORE_DESCRIPTOR = /* @__PURE__ */ Symbol.for("@logixjs/core/externalStoreDescriptor");
+var getExternalStoreDescriptor = (store) => {
+  if (!store || typeof store !== "object" && typeof store !== "function") return void 0;
+  return store[EXTERNAL_STORE_DESCRIPTOR];
+};
+
+// src/internal/state-trait/external-store.ts
+var isFn = (value) => typeof value === "function";
+var writebackCoordinatorByInternals = /* @__PURE__ */ new WeakMap();
+var getOrCreateExternalStoreWritebackCoordinator = (args) => import_effect15.Effect.gen(function* () {
+  const cached = writebackCoordinatorByInternals.get(args.internals);
+  if (cached) return cached;
+  let closed = false;
+  let inFlight = false;
+  let pendingWrites = /* @__PURE__ */ new Map();
+  const drainPendingWrites = () => {
+    if (pendingWrites.size === 0) return [];
+    const drained = pendingWrites;
+    pendingWrites = /* @__PURE__ */ new Map();
+    return Array.from(drained.values());
+  };
+  const applyWritebackBatch = (batch) => import_effect15.Effect.gen(function* () {
+    if (batch.length === 0) return;
+    if (batch.length === 1) {
+      const req = batch[0];
+      const prevState2 = yield* args.bound.state.read;
+      const prevValue = getAtPath(prevState2, req.fieldPath);
+      if (req.isEqual(prevValue, req.nextValue)) return;
+      const nextDraft2 = (0, import_mutative2.create)(prevState2, (draft) => {
+        setAtPathMutating(draft, req.fieldPath, req.nextValue);
+      });
+      args.internals.txn.recordStatePatch(
+        req.normalizedPatchPath,
+        "trait-external-store",
+        prevValue,
+        req.nextValue,
+        req.traitNodeId
+      );
+      args.internals.txn.updateDraft(nextDraft2);
+      return;
+    }
+    const prevState = yield* args.bound.state.read;
+    const changes = [];
+    for (let i = 0; i < batch.length; i++) {
+      const req = batch[i];
+      const prevValue = getAtPath(prevState, req.fieldPath);
+      if (req.isEqual(prevValue, req.nextValue)) continue;
+      changes.push({ request: req, prevValue });
+    }
+    if (changes.length === 0) return;
+    const nextDraft = (0, import_mutative2.create)(prevState, (draft) => {
+      for (let i = 0; i < changes.length; i++) {
+        const { request } = changes[i];
+        setAtPathMutating(draft, request.fieldPath, request.nextValue);
+      }
+    });
+    for (let i = 0; i < changes.length; i++) {
+      const { request, prevValue } = changes[i];
+      args.internals.txn.recordStatePatch(
+        request.normalizedPatchPath,
+        "trait-external-store",
+        prevValue,
+        request.nextValue,
+        request.traitNodeId
+      );
+    }
+    args.internals.txn.updateDraft(nextDraft);
+  });
+  const coordinator = {
+    enqueue: (request) => import_effect15.Effect.gen(function* () {
+      if (closed) return;
+      pendingWrites.set(request.fieldPath, request);
+      if (inFlight) return;
+      inFlight = true;
+      try {
+        while (true) {
+          const batch = drainPendingWrites();
+          if (batch.length === 0) return;
+          const commitPriority = batch.some((x) => x.commitPriority === "normal") ? "normal" : "low";
+          const originName = batch.length === 1 ? batch[0].fieldPath : "externalStore:batched";
+          yield* args.internals.txn.runWithStateTransaction(
+            {
+              kind: "trait-external-store",
+              name: originName,
+              details: {
+                stateCommit: {
+                  priority: commitPriority
+                }
+              }
+            },
+            () => applyWritebackBatch(batch).pipe(import_effect15.Effect.asVoid)
+          ).pipe(import_effect15.Effect.provide(args.env));
+        }
+      } finally {
+        inFlight = false;
+      }
+    })
+  };
+  writebackCoordinatorByInternals.set(args.internals, coordinator);
+  yield* import_effect15.Effect.addFinalizer(
+    () => import_effect15.Effect.sync(() => {
+      closed = true;
+      pendingWrites.clear();
+    })
+  );
+  return coordinator;
+});
+var resolveStore = (entry) => import_effect15.Effect.gen(function* () {
+  const store = entry.meta?.store;
+  const descriptor = getExternalStoreDescriptor(store);
+  if (descriptor?.kind === "service") {
+    const service = yield* import_effect15.Effect.service(descriptor.tag).pipe(import_effect15.Effect.orDie);
+    return descriptor.map(service);
+  }
+  return store;
+});
+var installExternalStoreSync = (bound, step, entry) => import_effect15.Effect.gen(function* () {
+  const fieldPath = step.targetFieldPath;
+  if (!fieldPath) return;
+  const env = yield* import_effect15.Effect.services();
+  let internals;
+  try {
+    internals = getBoundInternals(bound);
+  } catch {
+    return;
+  }
+  const select = entry.meta?.select;
+  const equals2 = entry.meta?.equals;
+  const computeValue = (snapshot2) => isFn(select) ? select(snapshot2) : snapshot2;
+  const isEqual = (a, b) => isFn(equals2) ? equals2(a, b) : Object.is(a, b);
+  const traitLane = entry.meta?.priority;
+  const rawStore = entry.meta?.store;
+  const rawDescriptor = getExternalStoreDescriptor(rawStore);
+  const makeScopedDescriptorStore = () => import_effect15.Effect.gen(function* () {
+    if (rawDescriptor?.kind === "subscriptionRef") {
+      let current = yield* import_effect15.Effect.provideService(rawDescriptor.ref.get, inSyncTransactionFiber, false);
+      const listeners = /* @__PURE__ */ new Set();
+      const notify = () => {
+        for (const listener of listeners) {
+          listener();
+        }
+      };
+      const fiber2 = yield* import_effect15.Effect.forkDetach(
+        import_effect15.Effect.provideService(import_effect15.Stream.runForEach(
+          rawDescriptor.ref.changes,
+          (value) => import_effect15.Effect.sync(() => {
+            current = value;
+            notify();
+          })
+        ).pipe(import_effect15.Effect.catchCause(() => import_effect15.Effect.void)), inSyncTransactionFiber, false),
+        { startImmediately: true }
+      );
+      internals.lifecycle.registerDestroy(import_effect15.Fiber.interrupt(fiber2).pipe(import_effect15.Effect.asVoid), { name: `externalStore:${fieldPath}:subscriptionRef` });
+      return {
+        getSnapshot: () => current,
+        subscribe: (listener) => {
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        }
+      };
+    }
+    if (rawDescriptor?.kind === "stream") {
+      let current = rawDescriptor.initial;
+      const listeners = /* @__PURE__ */ new Set();
+      const notify = () => {
+        for (const listener of listeners) {
+          listener();
+        }
+      };
+      const fiber2 = yield* import_effect15.Effect.forkDetach(
+        import_effect15.Effect.provideService(import_effect15.Stream.runForEach(
+          rawDescriptor.stream,
+          (value) => import_effect15.Effect.sync(() => {
+            current = value;
+            notify();
+          })
+        ).pipe(import_effect15.Effect.catchCause(() => import_effect15.Effect.void)), inSyncTransactionFiber, false),
+        { startImmediately: true }
+      );
+      internals.lifecycle.registerDestroy(import_effect15.Fiber.interrupt(fiber2).pipe(import_effect15.Effect.asVoid), { name: `externalStore:${fieldPath}:stream` });
+      return {
+        getSnapshot: () => current,
+        subscribe: (listener) => {
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        }
+      };
+    }
+    return void 0;
+  });
+  if (rawDescriptor?.kind === "module") {
+    const linkRuntimeOpt = yield* import_effect15.Effect.serviceOption(
+      DeclarativeLinkRuntimeTag
+    );
+    if (import_effect15.Option.isNone(linkRuntimeOpt)) {
+      return yield* import_effect15.Effect.die(new Error("[StateTrait.externalStore] Missing DeclarativeLinkRuntime service (073)."));
+    }
+    const module2 = rawDescriptor.module;
+    const sourceRuntime = (() => {
+      if (module2 && typeof module2 === "object") {
+        const moduleId = module2.moduleId;
+        const instanceId = module2.instanceId;
+        const getState = module2.getState;
+        if (typeof moduleId === "string" && moduleId.length > 0 && typeof instanceId === "string" && instanceId.length > 0 && getState) {
+          return module2;
+        }
+        const tag = module2.tag;
+        if (tag && import_effect15.ServiceMap.isKey(tag)) {
+          return internals.imports.get(tag);
+        }
+        if (import_effect15.ServiceMap.isKey(module2)) {
+          return internals.imports.get(module2);
+        }
+      }
+      return void 0;
+    })();
+    if (!sourceRuntime) {
+      return yield* import_effect15.Effect.die(new Error(`[StateTrait.externalStore] Module-as-Source store is unresolved for "${fieldPath}". Fix: include the source ModuleTag in module imports (moduleId=${rawDescriptor.moduleId}).`));
+    }
+    if (rawDescriptor.instanceId && rawDescriptor.instanceId !== sourceRuntime.instanceId) {
+      return yield* import_effect15.Effect.die(new Error(`[StateTrait.externalStore] Module-as-Source instanceId mismatch for "${fieldPath}". descriptor.instanceId=${rawDescriptor.instanceId}, resolved.instanceId=${sourceRuntime.instanceId}`));
+    }
+    if (sourceRuntime.moduleId !== rawDescriptor.moduleId) {
+      return yield* import_effect15.Effect.die(new Error(`[StateTrait.externalStore] Module-as-Source moduleId mismatch for "${fieldPath}". descriptor.moduleId=${rawDescriptor.moduleId}, resolved.moduleId=${sourceRuntime.moduleId}`));
+    }
+    const staticIr = rawDescriptor.readQuery.staticIr;
+    const isRecognizableStatic = staticIr.lane === "static" && staticIr.readsDigest != null && staticIr.fallbackReason == null;
+    if (!isRecognizableStatic) {
+      yield* record({
+        type: "diagnostic",
+        moduleId: internals.moduleId,
+        instanceId: internals.instanceId,
+        code: "external_store::module_source_degraded",
+        severity: "warning",
+        message: "[StateTrait.externalStore] Module-as-Source selector is not fully IR-recognizable; falling back to module-topic edge (may reduce perf).",
+        hint: "Fix: provide a static ReadQuery (ReadQuery.make) or annotate selector.fieldPaths to get a stable readsDigest; avoid dynamic lane.",
+        kind: "module_as_source_degraded",
+        trigger: {
+          kind: "trait",
+          name: "externalStore.moduleSource",
+          details: {
+            sourceModuleId: rawDescriptor.moduleId,
+            selectorId: staticIr.selectorId,
+            lane: staticIr.lane,
+            fallbackReason: staticIr.fallbackReason,
+            readsDigest: staticIr.readsDigest
+          }
+        }
+      });
+    }
+    const moduleInstanceKey = `${sourceRuntime.moduleId}::${sourceRuntime.instanceId}`;
+    const writeValue = (nextValue) => import_effect15.Effect.gen(function* () {
+      const inTxn = yield* import_effect15.Effect.service(inSyncTransactionFiber).pipe(import_effect15.Effect.orDie);
+      const body = import_effect15.Effect.gen(function* () {
+        const prevState = yield* bound.state.read;
+        const prevValue = getAtPath(prevState, fieldPath);
+        if (isEqual(prevValue, nextValue)) {
+          return;
+        }
+        const nextDraft = (0, import_mutative2.create)(prevState, (draft) => {
+          setAtPathMutating(draft, fieldPath, nextValue);
+        });
+        const normalized = normalizeFieldPath(fieldPath) ?? [];
+        internals.txn.recordStatePatch(normalized, "trait-external-store", prevValue, nextValue, step.id);
+        internals.txn.updateDraft(nextDraft);
+      });
+      if (inTxn) {
+        return yield* body;
+      }
+      const stateCommitPriority = traitLane === "nonUrgent" ? "low" : "normal";
+      return yield* internals.txn.runWithStateTransaction(
+        {
+          kind: "trait-external-store",
+          name: fieldPath,
+          details: {
+            stateCommit: {
+              priority: stateCommitPriority
+            }
+          }
+        },
+        () => body.pipe(import_effect15.Effect.asVoid)
+      );
+    }).pipe(import_effect15.Effect.provideServices(env));
+    const unregister = linkRuntimeOpt.value.registerModuleAsSourceLink({
+      id: `${internals.instanceId}::externalStore:${step.id}`,
+      sourceModuleInstanceKey: moduleInstanceKey,
+      readQuery: rawDescriptor.readQuery,
+      computeValue,
+      equalsValue: isEqual,
+      applyValue: writeValue
+    });
+    yield* import_effect15.Effect.addFinalizer(
+      () => import_effect15.Effect.sync(() => {
+        unregister();
+      })
+    );
+    const initialState = yield* sourceRuntime.getState;
+    const initialSelected = rawDescriptor.readQuery.select(initialState);
+    yield* writeValue(computeValue(initialSelected));
+    return;
+  }
+  const scopedDescriptorStore = yield* makeScopedDescriptorStore();
+  const store = scopedDescriptorStore ?? (rawDescriptor?.kind === "service" ? yield* resolveStore(entry) : rawStore);
+  if (!store || typeof store !== "object") {
+    return yield* import_effect15.Effect.die(new Error(`[StateTrait.externalStore] Invalid store for "${fieldPath}". Expected { getSnapshot, subscribe }.`));
+  }
+  if (!isFn(store.getSnapshot) || !isFn(store.subscribe)) {
+    return yield* import_effect15.Effect.die(new Error(`[StateTrait.externalStore] Invalid store for "${fieldPath}". Expected { getSnapshot, subscribe }.`));
+  }
+  let fused = false;
+  let fuseCause;
+  let fuseRecorded = false;
+  let pending = false;
+  let resume;
+  const recordFuseDiagnostic = import_effect15.Effect.gen(function* () {
+    if (fuseRecorded) return;
+    fuseRecorded = true;
+    const errorMessage = (() => {
+      if (fuseCause instanceof Error) return fuseCause.message;
+      if (typeof fuseCause === "string") return fuseCause;
+      return "unknown";
+    })();
+    yield* record({
+      type: "diagnostic",
+      moduleId: internals.moduleId,
+      instanceId: internals.instanceId,
+      code: "external_store::snapshot_threw",
+      severity: "warning",
+      message: `[StateTrait.externalStore] store.getSnapshot() threw; trait is fused and will stop syncing for "${fieldPath}".`,
+      hint: "Fix: ensure getSnapshot is synchronous and non-throwing; async resources should use StateTrait.source or ExternalStore.fromStream({ current/initial }).",
+      kind: "external_store_fused:get_snapshot",
+      trigger: {
+        kind: "trait",
+        name: "externalStore.getSnapshot",
+        details: {
+          fieldPath,
+          traitId: step.id,
+          storeKind: rawDescriptor?.kind ?? "raw",
+          error: errorMessage
+        }
+      }
+    });
+  });
+  const signal = () => {
+    if (fused) return;
+    if (resume) {
+      const r = resume;
+      pending = false;
+      r();
+      return;
+    }
+    pending = true;
+  };
+  const awaitSignal = () => {
+    if (pending) {
+      pending = false;
+      return import_effect15.Effect.void;
+    }
+    return import_effect15.Effect.promise(
+      (signal2) => new Promise((resolve) => {
+        let done = false;
+        const r = () => {
+          if (done) return;
+          done = true;
+          resume = void 0;
+          resolve();
+        };
+        resume = r;
+        signal2.addEventListener(
+          "abort",
+          () => {
+            if (resume === r) {
+              resume = void 0;
+            }
+          },
+          { once: true }
+        );
+      })
+    );
+  };
+  const getSnapshotOrFuse = () => {
+    try {
+      return store.getSnapshot();
+    } catch (err) {
+      fused = true;
+      fuseCause = err;
+      return void 0;
+    }
+  };
+  const readSnapshotOrFuse = import_effect15.Effect.provideService(import_effect15.Effect.sync(getSnapshotOrFuse), inSyncTransactionFiber, false);
+  const before = yield* readSnapshotOrFuse;
+  if (fused) {
+    yield* recordFuseDiagnostic;
+    return;
+  }
+  const unsubscribe = store.subscribe(signal);
+  yield* import_effect15.Effect.addFinalizer(
+    () => import_effect15.Effect.sync(() => {
+      try {
+        unsubscribe?.();
+      } catch {
+      }
+    })
+  );
+  const after = yield* readSnapshotOrFuse;
+  if (fused) {
+    yield* recordFuseDiagnostic;
+    return;
+  }
+  const coordinator = yield* getOrCreateExternalStoreWritebackCoordinator({ internals, bound, env });
+  const normalizedPatchPath = normalizeFieldPath(fieldPath) ?? [];
+  const commitPriority = traitLane === "nonUrgent" ? "low" : "normal";
+  const writeValueSync = (nextValue) => import_effect15.Effect.gen(function* () {
+    const inTxn = yield* import_effect15.Effect.service(inSyncTransactionFiber).pipe(import_effect15.Effect.orDie);
+    const body = import_effect15.Effect.gen(function* () {
+      const prevState = yield* bound.state.read;
+      const prevValue = getAtPath(prevState, fieldPath);
+      if (isEqual(prevValue, nextValue)) {
+        return;
+      }
+      const nextDraft = (0, import_mutative2.create)(prevState, (draft) => {
+        setAtPathMutating(draft, fieldPath, nextValue);
+      });
+      internals.txn.recordStatePatch(normalizedPatchPath, "trait-external-store", prevValue, nextValue, step.id);
+      internals.txn.updateDraft(nextDraft);
+    });
+    if (inTxn) {
+      return yield* body;
+    }
+    return yield* internals.txn.runWithStateTransaction(
+      {
+        kind: "trait-external-store",
+        name: fieldPath,
+        details: {
+          stateCommit: {
+            priority: commitPriority
+          }
+        }
+      },
+      () => body.pipe(import_effect15.Effect.asVoid)
+    );
+  }).pipe(import_effect15.Effect.provideServices(env));
+  const enqueueWriteValue = (nextValue) => coordinator.enqueue({
+    fieldPath,
+    traitNodeId: step.id,
+    normalizedPatchPath,
+    nextValue,
+    isEqual,
+    commitPriority
+  });
+  yield* writeValueSync(computeValue(after));
+  if (!isEqual(before, after)) {
+    signal();
+  }
+  const fiber = yield* import_effect15.Effect.forkDetach(
+    import_effect15.Effect.provideService(import_effect15.Effect.gen(function* () {
+      while (true) {
+        yield* awaitSignal();
+        if (fused) return;
+        const snapshot2 = yield* readSnapshotOrFuse;
+        if (fused) {
+          yield* recordFuseDiagnostic;
+          return;
+        }
+        yield* enqueueWriteValue(computeValue(snapshot2));
+      }
+    }), inSyncTransactionFiber, false),
+    { startImmediately: true }
+  );
+  internals.lifecycle.registerDestroy(import_effect15.Fiber.interrupt(fiber).pipe(import_effect15.Effect.asVoid), { name: `externalStore:${fieldPath}:writeback` });
+});
+
+// src/internal/state-trait/meta-diagnostics.ts
+var import_effect17 = require("effect");
+
+// src/internal/state-trait/converge-diagnostics.ts
+var import_effect16 = require("effect");
+var SchemaAST2 = __toESM(require("effect/SchemaAST"), 1);
+var onceKeysFallback = /* @__PURE__ */ new Set();
+var onceInRunSession2 = (key) => import_effect16.Effect.serviceOption(RunSessionTag).pipe(
+  import_effect16.Effect.map((maybe) => {
+    if (import_effect16.Option.isSome(maybe)) {
+      return maybe.value.local.once(key);
+    }
+    if (onceKeysFallback.has(key)) return false;
+    onceKeysFallback.add(key);
+    return true;
+  })
+);
+
+// src/internal/state-trait/meta-diagnostics.ts
+var formatList2 = (items, limit = 6) => {
+  if (!items || items.length === 0) return void 0;
+  if (items.length <= limit) return items.join(", ");
+  return `${items.slice(0, limit).join(", ")}, \u2026(+${items.length - limit})`;
+};
+var formatPart = (label, value) => {
+  if (value === void 0) return void 0;
+  return `${label}=${value}`;
+};
+var formatIssue = (issue) => {
+  const r = issue.report;
+  const parts = [];
+  if (r.invalidInput) parts.push("invalidInput=true");
+  const unknownKeys = formatList2(r.unknownKeys, 6);
+  if (unknownKeys) {
+    parts.push(
+      `unknownKeys=[${unknownKeys}]${typeof r.unknownKeyCount === "number" && r.unknownKeyCount > r.unknownKeys.length ? ` total=${r.unknownKeyCount}` : ""}`
+    );
+  }
+  const droppedKeys = formatList2(r.droppedKeys, 6);
+  if (droppedKeys) parts.push(`droppedKeys=[${droppedKeys}]`);
+  if (typeof r.droppedTagItems === "number" && r.droppedTagItems > 0) {
+    parts.push(`droppedTagItems=${r.droppedTagItems}`);
+  }
+  const ignoredAnnotationKeys = formatList2(r.ignoredAnnotationKeys, 6);
+  if (ignoredAnnotationKeys) {
+    parts.push(
+      `ignoredAnnotationKeys=[${ignoredAnnotationKeys}]${typeof r.ignoredAnnotationKeyCount === "number" && r.ignoredAnnotationKeyCount > r.ignoredAnnotationKeys.length ? ` total=${r.ignoredAnnotationKeyCount}` : ""}`
+    );
+  }
+  const droppedAnnotationKeys = formatList2(r.droppedAnnotationKeys, 6);
+  if (droppedAnnotationKeys) {
+    parts.push(
+      `droppedAnnotationKeys=[${droppedAnnotationKeys}]${typeof r.droppedAnnotationKeyCount === "number" && r.droppedAnnotationKeyCount > r.droppedAnnotationKeys.length ? ` total=${r.droppedAnnotationKeyCount}` : ""}`
+    );
+  }
+  const droppedValues = formatPart("droppedAnnotationValues", r.droppedAnnotationValues);
+  if (droppedValues) parts.push(droppedValues);
+  const nonSerializable = formatPart("nonSerializable", r.droppedAnnotationNonSerializable);
+  const depthExceeded = formatPart("depthExceeded", r.droppedAnnotationDepthExceeded);
+  const nonFiniteNumber = formatPart("nonFiniteNumber", r.droppedAnnotationNonFiniteNumber);
+  const reasons = [nonSerializable, depthExceeded, nonFiniteNumber].filter((x) => x !== void 0);
+  if (reasons.length > 0) parts.push(`reasons={${reasons.join(", ")}}`);
+  return `[${issue.origin}] ${parts.join(" ")}`;
+};
+var collectNodeMetaIssues = (program) => {
+  const spec = program.spec;
+  if (!spec || typeof spec !== "object") return [];
+  const isNode = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitNode";
+  const isList = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitList";
+  const issues = [];
+  const add = (origin, meta) => {
+    const { report } = sanitizeWithReport(meta);
+    if (report) issues.push({ origin, report });
+  };
+  for (const key of Object.keys(spec)) {
+    const raw = spec[key];
+    if (!raw) continue;
+    if (isList(raw)) {
+      if (raw.item && isNode(raw.item) && raw.item.meta !== void 0) {
+        add(`node:${key}[]`, raw.item.meta);
+      }
+      if (raw.list && isNode(raw.list) && raw.list.meta !== void 0) {
+        add(`node:${key}`, raw.list.meta);
+      }
+      continue;
+    }
+    if (isNode(raw)) {
+      if (raw.meta === void 0) continue;
+      add(`node:${key === "$root" ? "$root" : key}`, raw.meta);
+      continue;
+    }
+  }
+  return issues;
 };
+var collectEntryMetaIssues = (program) => {
+  const issues = [];
+  for (const entry of program.entries) {
+    if (entry.kind !== "source" && entry.kind !== "externalStore") continue;
+    const rawMeta = entry.meta?.meta;
+    if (rawMeta === void 0) continue;
+    const origin = entry.kind === "source" ? `source:${entry.fieldPath}` : `externalStore:${entry.fieldPath}`;
+    const { report } = sanitizeWithReport(rawMeta);
+    if (report) issues.push({ origin, report });
+  }
+  return issues;
+};
+var emitMetaSanitizeDiagnostics = (program, ctx) => import_effect17.Effect.gen(function* () {
+  if (!isDevEnv()) return;
+  const level = yield* import_effect17.Effect.service(currentDiagnosticsLevel).pipe(import_effect17.Effect.orDie);
+  if (level === "off") return;
+  const moduleId = ctx.moduleId ?? "unknown";
+  const shouldEmit = yield* onceInRunSession2(`meta_sanitize:${moduleId}`);
+  if (!shouldEmit) return;
+  const issues = [...collectNodeMetaIssues(program), ...collectEntryMetaIssues(program)];
+  if (issues.length === 0) return;
+  const limit = level === "light" || level === "sampled" ? 8 : 24;
+  const lines = issues.slice(0, limit).map(formatIssue);
+  if (issues.length > limit) {
+    lines.push(`\u2026(+${issues.length - limit})`);
+  }
+  yield* record({
+    type: "diagnostic",
+    moduleId: ctx.moduleId,
+    instanceId: ctx.instanceId,
+    code: "state_trait::meta_sanitized",
+    severity: "warning",
+    message: `[meta] TraitMeta contains non-exportable fields/values and will be sanitized (total ${issues.length}):
+${lines.join("\n")}`,
+    hint: "TraitMeta is export-only (Devtools/Static IR) and MUST be JsonValue. Use `annotations` with `x-*` keys for extension hints; avoid closures/functions/Effect/Fiber/Tag/DOM/BigInt/circular refs. See specs/016 and docs/ssot/platform/contracts/03-control-surface-manifest.md.",
+    kind: "meta_sanitized"
+  });
+});
 
 // src/internal/state-trait/install.ts
 var buildEntryIndex = (entries) => {
@@ -2522,32 +3835,41 @@ var buildEntryIndex = (entries) => {
   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;
+  return import_effect18.Effect.gen(function* () {
+    let internals;
+    try {
+      internals = getBoundInternals(bound);
+      internals.traits.registerStateTraitProgram(program, {
+        bumpReason: "logic_installed"
+      });
+    } catch {
     }
-    const entry = candidates.find((e) => e.kind === "source");
-    if (!entry) {
-      return import_effect11.Effect.void;
+    if (internals) {
+      yield* emitMetaSanitizeDiagnostics(program, {
+        moduleId: internals.moduleId,
+        instanceId: internals.instanceId
+      });
     }
-    return installSourceRefresh(bound, step, entry);
-  };
-  return import_effect11.Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(import_effect11.Effect.asVoid);
+    const entryIndex = buildEntryIndex(program.entries);
+    const installStep = (step) => {
+      if (!step.targetFieldPath) {
+        return import_effect18.Effect.void;
+      }
+      if (step.kind !== "source-refresh" && step.kind !== "external-store-sync") {
+        return import_effect18.Effect.void;
+      }
+      const candidates = entryIndex.get(step.targetFieldPath);
+      if (!candidates || candidates.length === 0) {
+        return import_effect18.Effect.void;
+      }
+      const entry = step.kind === "source-refresh" ? candidates.find((e) => e.kind === "source") : candidates.find((e) => e.kind === "externalStore");
+      if (!entry) {
+        return import_effect18.Effect.void;
+      }
+      return step.kind === "source-refresh" ? installSourceRefresh(bound, step, entry) : installExternalStoreSync(bound, step, entry);
+    };
+    yield* import_effect18.Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(import_effect18.Effect.asVoid);
+  }).pipe(import_effect18.Effect.asVoid);
 };
 
 // src/internal/state-trait/ir.ts
@@ -2569,6 +3891,8 @@ var toNodeKind = (step) => {
       return "link";
     case "source-refresh":
       return "source";
+    case "external-store-sync":
+      return "externalStore";
     case "check-validate":
       return "check";
   }
@@ -2593,6 +3917,9 @@ var getReadsForEntry = (entry) => {
     const from2 = entry.meta.from;
     return from2 ? [from2] : [];
   }
+  if (entry.kind === "externalStore") {
+    return [];
+  }
   if (entry.kind === "check") {
     const rules = entry.meta?.rules ?? {};
     const out = [];
@@ -2640,11 +3967,40 @@ var exportStaticIr = (params) => {
     const write = normalizeFieldPath2(target);
     const writes = write ? [write] : [];
     const meta = target ? metaByField.get(target) : void 0;
+    const externalStorePolicy = () => {
+      if (kind !== "externalStore") return void 0;
+      if (!entry || entry.kind !== "externalStore") return void 0;
+      const descriptor = getExternalStoreDescriptor(entry.meta.store);
+      const storeId = descriptor?.storeId;
+      const priorityRaw = entry.meta?.priority;
+      const lane = priorityRaw === "nonUrgent" ? "nonUrgent" : "urgent";
+      const meta2 = sanitize(entry.meta.meta);
+      const source2 = descriptor?.kind === "module" ? {
+        kind: "module",
+        storeId,
+        moduleId: descriptor.moduleId,
+        ...descriptor.instanceId ? { instanceKey: descriptor.instanceId } : {},
+        selectorId: descriptor.readQuery.staticIr.selectorId,
+        readsDigest: descriptor.readQuery.staticIr.readsDigest,
+        fallbackReason: descriptor.readQuery.staticIr.fallbackReason
+      } : descriptor ? { kind: "external", storeId } : { kind: "external", storeId: "unknown" };
+      const coalesceWindowMs = entry.meta?.coalesceWindowMs;
+      return {
+        traitId: step.id,
+        storeId: storeId ?? "unknown",
+        source: source2,
+        ownership: "external-owned",
+        lane,
+        ...typeof coalesceWindowMs === "number" && Number.isFinite(coalesceWindowMs) && coalesceWindowMs > 0 ? { coalesceWindowMs } : {},
+        ...meta2 ? { meta: meta2 } : {}
+      };
+    };
     const base2 = {
       nodeId: step.id,
       kind,
       reads,
       writes: kind === "check" ? [] : writes,
+      ...kind === "externalStore" ? { policy: externalStorePolicy() } : {},
       meta
     };
     if (kind !== "check" && target && !write) {
@@ -2709,6 +4065,11 @@ var source = (input) => {
     meta: { ...input, key }
   };
 };
+var externalStore = (input) => ({
+  fieldPath: void 0,
+  kind: "externalStore",
+  meta: input
+});
 var link = (meta) => ({
   fieldPath: void 0,
   kind: "link",
@@ -2727,6 +4088,7 @@ var exportStaticIr2 = (program, moduleId, options) => exportStaticIr({
   build,
   computed,
   exportStaticIr,
+  externalStore,
   from,
   install,
   link,