@logixjs/core 0.0.1 → 0.0.2

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,
@@ -106,21 +107,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 +140,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 +197,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 +207,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 +370,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 +415,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 : "");
@@ -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";
@@ -538,6 +646,32 @@ var fnv1a32 = (input) => {
 
 // src/internal/state-trait/build.ts
 var nowPerf = () => typeof globalThis.performance !== "undefined" && typeof globalThis.performance.now === "function" ? globalThis.performance.now() : Date.now();
+var collectMultipleWritersError = (entries) => {
+  const kindsByFieldPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.kind !== "computed" && entry.kind !== "link" && entry.kind !== "source" && entry.kind !== "externalStore") {
+      continue;
+    }
+    const set = kindsByFieldPath.get(entry.fieldPath) ?? /* @__PURE__ */ new Set();
+    set.add(entry.kind);
+    kindsByFieldPath.set(entry.fieldPath, set);
+  }
+  const conflicts = [];
+  for (const [fieldPath, kinds] of kindsByFieldPath.entries()) {
+    if (kinds.size <= 1) continue;
+    conflicts.push({ fieldPath, kinds: Array.from(kinds).sort() });
+  }
+  if (conflicts.length === 0) return void 0;
+  conflicts.sort((a, b) => a.fieldPath < b.fieldPath ? -1 : a.fieldPath > b.fieldPath ? 1 : 0);
+  const fields = conflicts.map((c) => c.fieldPath);
+  const primary = conflicts[0];
+  const kindSummary = primary.kinds.join(" + ");
+  return {
+    code: "MULTIPLE_WRITERS",
+    message: `[StateTrait.build] Multiple writers for field "${primary.fieldPath}" (${kindSummary}). Only one of computed/link/source/externalStore can write a fieldPath.`,
+    fields
+  };
+};
 var getConvergeWriterDeps = (entry) => {
   if (entry.kind === "computed") {
     return entry.meta?.deps ?? [];
@@ -666,6 +800,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 +812,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) => {
@@ -730,7 +865,7 @@ var buildConvergeIr = (stateSchema, entries) => {
     fieldPathsKey,
     fieldPaths,
     fieldPathIdRegistry,
-    ...topo.configError ? { configError: topo.configError } : null,
+    ...multipleWritersError ? { configError: multipleWritersError } : topo.configError ? { configError: topo.configError } : null,
     stepsById,
     stepOutFieldPathIdByStepId,
     stepDepsFieldPathIdsByStepId,
@@ -886,6 +1021,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 +1167,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,55 +1220,290 @@ var build = (stateSchema, spec) => {
 };
 
 // src/internal/state-trait/install.ts
-var import_effect11 = require("effect");
+var import_effect17 = require("effect");
 
 // src/internal/runtime/core/env.ts
-var import_effect = require("effect");
-var getNodeEnv = () => {
+var import_effect8 = 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 ReadQueryStrictGateConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
 };
-var ReplayModeConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+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 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}` };
+  }
+  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 internals;
+  return { kind: "module", moduleInstanceKey: `${moduleId}::${instanceId}` };
+};
+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 subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const set = existing ?? /* @__PURE__ */ new Set();
+    const alreadyHas = set.has(listener);
+    if (!alreadyHas) {
+      set.add(listener);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, set);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const current = listenersByTopic.get(topicKey);
+      if (!current) return;
+      const deleted = current.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 (current.size === 0) {
+        listenersByTopic.delete(topicKey);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.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);
+    }
+    const changedTopics = /* @__PURE__ */ new Map();
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners = Array.from(listenersByTopic.get(topicKey) ?? []);
+      if (listeners.length > 0) {
+        changedTopics.set(topicKey, { priority, listeners });
+      }
+    }
+    return { changedTopics };
+  };
+  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_effect6 = 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");
@@ -1157,140 +1533,13 @@ var runWithMiddleware = (op, stack) => {
   });
 };
 
-// src/internal/observability/runSession.ts
-var import_effect3 = require("effect");
-
-// src/internal/observability/jsonValue.ts
-var defaultOptions = {
-  maxDepth: 6,
-  maxObjectKeys: 32,
-  maxArrayLength: 32,
-  maxStringLength: 256,
-  maxJsonBytes: 4 * 1024,
-  oversizedPreviewBytes: 256
-};
-
-// src/internal/observability/runSession.ts
-var RunSessionTagImpl = class extends import_effect3.Context.Tag("@logixjs/core/RunSession")() {
-};
-var RunSessionTag = RunSessionTagImpl;
-
-// src/internal/effect-op.ts
-var nextGlobalOpSeq = 0;
-var nextOpSeq = () => {
-  nextGlobalOpSeq += 1;
-  return nextGlobalOpSeq;
-};
-var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
-var make = (params) => ({
-  ...params.id ? { id: params.id, meta: params.meta } : (() => {
-    const meta = params.meta ?? {};
-    const instanceId = meta.instanceId;
-    const opSeq = typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq();
-    return {
-      id: makeId(instanceId, opSeq),
-      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq }
-    };
-  })(),
-  kind: params.kind,
-  name: params.name,
-  payload: params.payload,
-  effect: params.effect
-});
-var run = (op, stack) => runWithMiddleware(op, stack);
-
-// src/internal/resource.ts
-var import_effect5 = require("effect");
-var stableStringify3 = (value) => {
-  const seen = /* @__PURE__ */ new WeakSet();
-  const encode = (input) => {
-    if (input === null) return null;
-    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
-      return input;
-    }
-    if (typeof input === "bigint") return input.toString();
-    if (typeof input === "undefined") return "__undefined__";
-    if (typeof input === "symbol") return `__symbol__:${String(input)}`;
-    if (typeof input === "function") return "__function__";
-    if (Array.isArray(input)) {
-      return input.map((v) => encode(v));
-    }
-    if (input instanceof Date) {
-      return `__date__:${input.toISOString()}`;
-    }
-    if (input instanceof Error) {
-      return {
-        _tag: "Error",
-        name: input.name,
-        message: input.message
-      };
-    }
-    if (input && typeof input === "object") {
-      const obj = input;
-      if (seen.has(obj)) return "__cycle__";
-      seen.add(obj);
-      const record2 = input;
-      const keys = Object.keys(record2).sort();
-      const out = {};
-      for (const k of keys) {
-        out[k] = encode(record2[k]);
-      }
-      return out;
-    }
-    return String(input);
-  };
-  try {
-    return JSON.stringify(encode(value));
-  } catch {
-    return String(value);
-  }
-};
-var keyHash = (key) => stableStringify3(key);
-var Snapshot = {
-  idle: () => ({
-    status: "idle",
-    keyHash: void 0,
-    data: void 0,
-    error: void 0
-  }),
-  loading: (params) => ({
-    status: "loading",
-    keyHash: params.keyHash,
-    data: void 0,
-    error: void 0
-  }),
-  success: (params) => ({
-    status: "success",
-    keyHash: params.keyHash,
-    data: params.data,
-    error: void 0
-  }),
-  error: (params) => ({
-    status: "error",
-    keyHash: params.keyHash,
-    data: void 0,
-    error: params.error
-  })
-};
-var ResourceRegistryTag = class extends import_effect5.Context.Tag("@logixjs/core/ResourceRegistry")() {
-};
-var internal = {
-  ResourceRegistryTag
-};
-
-// src/internal/runtime/core/DebugSink.ts
-var import_effect7 = require("effect");
-
-// src/internal/runtime/core/errorSummary.ts
-var import_effect6 = require("effect");
-
-// src/internal/runtime/core/DebugSink.ts
-var currentDebugSinks = import_effect7.FiberRef.unsafeMake([]);
-var currentRuntimeLabel = import_effect7.FiberRef.unsafeMake(void 0);
-var currentTxnId = import_effect7.FiberRef.unsafeMake(void 0);
-var currentOpSeq = import_effect7.FiberRef.unsafeMake(void 0);
-var currentDiagnosticsLevel = import_effect7.FiberRef.unsafeMake("off");
-var currentTraitConvergeDiagnosticsSampling = import_effect7.FiberRef.unsafeMake({
+// src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = import_effect3.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect3.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect3.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect3.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect3.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect3.FiberRef.unsafeMake({
   sampleEveryN: 32,
   topK: 3
 });
@@ -1300,7 +1549,7 @@ var lifecycleErrorLog = (event) => {
   const moduleId = event.moduleId ?? "unknown";
   const causePretty = (() => {
     try {
-      return import_effect7.Cause.pretty(event.cause, {
+      return import_effect3.Cause.pretty(event.cause, {
         renderErrorCause: true
       });
     } catch {
@@ -1313,8 +1562,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 +1577,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 +1590,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.locallyScoped(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.locallyScoped(currentDebugSinks, [errorOnlySink]);
 var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
 var consoleSink = {
-  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect7.Effect.logDebug({ debugEvent: event })
+  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.locallyScoped(currentDebugSinks, [consoleSink]);
 var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
 var renderBrowserConsoleEvent = (event) => {
   if (typeof event.type === "string" && event.type.startsWith("trace:")) {
     const moduleId = event.moduleId ?? "unknown";
     const type = event.type;
-    return import_effect7.Effect.sync(() => {
+    return import_effect3.Effect.sync(() => {
       console.groupCollapsed(
         "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
         "color:#6b7280;font-weight:bold",
@@ -1378,7 +1627,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, { renderErrorCause: true });
       } catch {
         try {
           return JSON.stringify(event.cause, null, 2);
@@ -1389,10 +1638,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 +1663,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,32 +1683,32 @@ 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.locallyScoped(currentDebugSinks, [browserConsoleSink]);
 var browserDiagnosticConsoleSink = {
   record: (event) => {
     if (!isBrowser) {
-      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect7.Effect.void;
+      return event.type === "lifecycle:error" ? 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.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect3.Logger.replace(
+  import_effect3.Logger.defaultLogger,
+  import_effect3.Logger.prettyLogger({ 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.FiberRef.get(currentDebugSinks);
   if (isErrorOnlyOnlySinks(sinks)) {
     if (event.type === "lifecycle:error") {
       yield* lifecycleErrorLog(event);
@@ -1469,11 +1718,11 @@ var record = (event) => import_effect7.Effect.gen(function* () {
       if (event.severity !== "info") {
         yield* diagnosticLog(event);
       } else {
-        yield* import_effect7.Effect.void;
+        yield* import_effect3.Effect.void;
       }
       return;
     }
-    yield* import_effect7.Effect.void;
+    yield* import_effect3.Effect.void;
     return;
   }
   if (sinks.length === 0) {
@@ -1482,73 +1731,420 @@ var record = (event) => import_effect7.Effect.gen(function* () {
         yield* renderBrowserConsoleEvent(event);
         return;
       }
-      yield* import_effect7.Effect.void;
+      yield* import_effect3.Effect.void;
       return;
     }
     if (event.type === "lifecycle:error") {
       yield* lifecycleErrorLog(event);
       return;
     }
-    if (event.type === "diagnostic") {
-      yield* diagnosticLog(event);
-      return;
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* import_effect3.Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel = yield* import_effect3.FiberRef.get(currentDiagnosticsLevel);
+  let now;
+  const getNow = () => {
+    if (now === void 0) now = Date.now();
+    return now;
+  };
+  if (enriched.timestamp === void 0 && (diagnosticsLevel !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
+    ;
+    enriched.timestamp = getNow();
+  }
+  if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel = yield* import_effect3.FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect3.FiberRef.get(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const linkId = yield* import_effect3.FiberRef.get(currentLinkId);
+    if (linkId) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  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/DevtoolsHub.ts
+var import_effect4 = require("effect");
+var lastRunTs = 0;
+var lastRunTsSeq = 0;
+var nextRunId = () => {
+  const ts = Date.now();
+  if (ts === lastRunTs) {
+    lastRunTsSeq += 1;
+  } else {
+    lastRunTs = ts;
+    lastRunTsSeq = 0;
+  }
+  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
+};
+var currentRunId = nextRunId();
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect5 = require("effect");
+var inSyncTransactionFiber = import_effect5.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect5.FiberRef.unsafeMake(false);
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect7 = 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_effect7.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_effect8.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var ReplayModeConfigTag = ReplayModeConfigTagImpl;
+var StateTransactionOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+var RuntimeStoreTag = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeStore")() {
+};
+var runtimeStoreLayer = import_effect8.Layer.scoped(
+  RuntimeStoreTag,
+  import_effect8.Effect.acquireRelease(
+    import_effect8.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect8.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect8.Context.Tag("@logixjs/core/HostScheduler")() {
+};
+var hostSchedulerLayer = import_effect8.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect8.Context.Tag("@logixjs/core/DeclarativeLinkRuntime")() {
+};
+var declarativeLinkRuntimeLayer = import_effect8.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect8.Context.Tag("@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_effect13 = require("effect");
+var import_mutative = require("mutative");
+
+// src/internal/effect-op.ts
+var import_effect10 = require("effect");
+
+// src/internal/observability/runSession.ts
+var import_effect9 = require("effect");
+var RunSessionTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/RunSession")() {
+};
+var RunSessionTag = RunSessionTagImpl;
+
+// src/internal/effect-op.ts
+var nextGlobalOpSeq = 0;
+var nextOpSeq = () => {
+  nextGlobalOpSeq += 1;
+  return nextGlobalOpSeq;
+};
+var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
+var make = (params) => ({
+  ...params.id ? { id: params.id, meta: params.meta } : (() => {
+    const meta = params.meta ?? {};
+    const instanceId = meta.instanceId;
+    const opSeq = typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq();
+    return {
+      id: makeId(instanceId, opSeq),
+      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq }
+    };
+  })(),
+  kind: params.kind,
+  name: params.name,
+  payload: params.payload,
+  effect: params.effect
+});
+var run = (op, stack) => runWithMiddleware(op, stack);
+
+// src/internal/resource.ts
+var import_effect11 = 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));
     }
-    yield* import_effect7.Effect.void;
-    return;
-  }
-  const enriched = event;
-  const diagnosticsLevel = yield* import_effect7.FiberRef.get(currentDiagnosticsLevel);
-  let now;
-  const getNow = () => {
-    if (now === void 0) now = Date.now();
-    return now;
-  };
-  if (enriched.timestamp === void 0 && (diagnosticsLevel !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
-    ;
-    enriched.timestamp = getNow();
-  }
-  if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
-    const runtimeLabel = yield* import_effect7.FiberRef.get(currentRuntimeLabel);
-    if (runtimeLabel) {
-      ;
-      enriched.runtimeLabel = runtimeLabel;
+    if (input instanceof Date) {
+      return `__date__:${input.toISOString()}`;
     }
-  }
-  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
-    const txnId = yield* import_effect7.FiberRef.get(currentTxnId);
-    if (txnId) {
-      ;
-      enriched.txnId = txnId;
+    if (input instanceof Error) {
+      return {
+        _tag: "Error",
+        name: input.name,
+        message: input.message
+      };
     }
-  }
-  if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
-    const linkId = yield* import_effect7.FiberRef.get(currentLinkId);
-    if (linkId) {
-      ;
-      enriched.linkId = linkId;
+    if (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_effect11.Context.Tag("@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_effect12 = require("effect");
+var ReplayLog = class extends import_effect12.Context.Tag("@logixjs/core/ReplayLog")() {
 };
-var snapshot = import_effect9.Effect.gen(function* () {
+var snapshot = import_effect12.Effect.gen(function* () {
   const log = yield* ReplayLog;
   return yield* log.snapshot;
 });
-var resetCursor = import_effect9.Effect.gen(function* () {
+var resetCursor = import_effect12.Effect.gen(function* () {
   const log = yield* ReplayLog;
   yield* log.resetCursor;
 });
@@ -1698,16 +2294,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_effect13.Effect.serviceOption(RunSessionTag).pipe(
+  import_effect13.Effect.map((maybe) => import_effect13.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_effect13.Effect.gen(function* () {
   const key = `${params.instanceId ?? "unknown"}::${params.kind}::${params.fieldPath}`;
   const shouldEmit = yield* onceInRunSession(`deps_mismatch:${key}`);
   if (!shouldEmit) return;
@@ -1722,8 +2318,8 @@ 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_effect13.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect13.Effect.map((maybe) => import_effect13.Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var recordTraitPatch = (bound, path, reason, from2, to, traitNodeId) => {
   const normalized = normalizeFieldPath(path) ?? [];
@@ -1748,7 +2344,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_effect13.Effect.gen(function* () {
   let wrote = false;
   yield* bound.state.mutate((draft) => {
     const prev = getAtPath(draft, fieldPath);
@@ -1759,7 +2355,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_effect13.Effect.gen(function* () {
   let wrote = false;
   yield* bound.state.mutate((draft) => {
     const current = getAtPath(draft, fieldPath);
@@ -1777,7 +2373,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_effect13.Effect.void;
   const fieldPath = step.targetFieldPath;
   const resourceId = step.resourceId ?? entry.meta.resource;
   const listItem = parseListItemFieldPath(fieldPath);
@@ -1785,12 +2381,12 @@ var installSourceRefresh = (bound, step, entry) => {
   try {
     internals = getBoundInternals(bound);
   } catch {
-    return import_effect10.Effect.void;
+    return import_effect13.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_effect13.Effect.void;
+    if (replayMode !== "live") return import_effect13.Effect.void;
     const event = input && typeof input === "object" && input._tag === "ResourceSnapshot" ? input : {
       _tag: "ResourceSnapshot",
       resourceId,
@@ -1808,12 +2404,12 @@ var installSourceRefresh = (bound, step, entry) => {
   if (listItem) {
     const store = internals.traits.rowIdStore;
     if (!store) {
-      return import_effect10.Effect.void;
+      return import_effect13.Effect.void;
     }
     const listPath = listItem.listPath;
     const itemPath = listItem.itemPath;
     if (!itemPath) {
-      return import_effect10.Effect.void;
+      return import_effect13.Effect.void;
     }
     const concurrency2 = entry.meta.concurrency;
     const mode2 = concurrency2 ?? "switch";
@@ -1824,7 +2420,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_effect13.Effect.gen(function* () {
       let wrotePath;
       yield* bound.state.mutate((draft) => {
         const index = store.getIndex(listPath, rowId);
@@ -1838,7 +2434,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_effect13.Effect.gen(function* () {
       let wrotePath;
       yield* bound.state.mutate((draft) => {
         const index = store.getIndex(listPath, rowId);
@@ -1870,7 +2466,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_effect13.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 +2504,17 @@ var installSourceRefresh = (bound, step, entry) => {
         recordReplayEvent(bound, event);
         yield* recordSnapshot(replayMode, replayLog, event);
       }
-      const io = import_effect10.Effect.gen(function* () {
+      const io = import_effect13.Effect.gen(function* () {
         if (replayMode === "replay" && replayLog) {
-          yield* import_effect10.Effect.yieldNow();
+          yield* import_effect13.Effect.yieldNow();
           const consumePath = wroteLoadingPath ?? logFieldPath;
-          if (!consumePath) return yield* import_effect10.Effect.void;
+          if (!consumePath) return yield* import_effect13.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_effect13.Effect.void;
           if (replayed.phase === "success") {
             yield* writebackIfCurrentKeyHashForRow(
               rowId,
@@ -1938,14 +2534,14 @@ var installSourceRefresh = (bound, step, entry) => {
               "error"
             );
           }
-          return yield* import_effect10.Effect.void;
+          return yield* import_effect13.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_effect13.Effect.serviceOption(internal.ResourceRegistryTag);
+        const registry = import_effect13.Option.isSome(registryOpt) ? registryOpt.value : void 0;
         const spec = registry?.specs.get(resourceId);
         if (!spec) {
-          return yield* import_effect10.Effect.void;
+          return yield* import_effect13.Effect.void;
         }
         const loadEffect = spec.load(key);
         const meta = {
@@ -1960,8 +2556,8 @@ 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_effect13.Effect.serviceOption(RunSessionTag);
+          if (import_effect13.Option.isSome(sessionOpt)) {
             const seqKey = instanceId ?? "global";
             meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", seqKey);
           }
@@ -1972,7 +2568,7 @@ var installSourceRefresh = (bound, step, entry) => {
           effect: loadEffect,
           meta
         });
-        const exit = yield* import_effect10.Effect.exit(run(op, stack));
+        const exit = yield* import_effect13.Effect.exit(run(op, stack));
         if (exit._tag === "Success") {
           const successSnapshot = Snapshot.success({ keyHash: keyHash2, data: exit.value });
           const wroteSuccessPath = yield* writebackIfCurrentKeyHashForRow(
@@ -2022,47 +2618,47 @@ 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_effect13.Effect.catchAllCause(() => import_effect13.Effect.void));
+      const fiber = yield* import_effect13.Effect.forkScoped(import_effect13.Effect.locally(inSyncTransactionFiber, false)(io));
       const myGen = gen2 += 1;
       inFlight2.set(rowId, { gen: myGen, fiber, keyHash: keyHash2 });
-      yield* import_effect10.Effect.forkScoped(
-        import_effect10.Effect.locally(
+      yield* import_effect13.Effect.forkScoped(
+        import_effect13.Effect.locally(
           inSyncTransactionFiber,
           false
         )(
-          import_effect10.Fiber.await(fiber).pipe(
-            import_effect10.Effect.zipRight(
-              import_effect10.Effect.sync(() => {
+          import_effect13.Fiber.await(fiber).pipe(
+            import_effect13.Effect.zipRight(
+              import_effect13.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* () {
+            import_effect13.Effect.zipRight(
+              mode2 === "exhaust-trailing" ? import_effect13.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_effect13.Effect.void
             ),
-            import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void)
+            import_effect13.Effect.catchAllCause(() => import_effect13.Effect.void)
           )
         )
       );
     });
     register(
       fieldPath,
-      (state) => import_effect10.Effect.gen(function* () {
+      (state) => import_effect13.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_effect13.Effect.serviceOption(ReplayModeConfigTag);
+        const replayMode = import_effect13.Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+        const replayLogOpt = yield* import_effect13.Effect.serviceOption(ReplayLog);
+        const replayLog = import_effect13.Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+        const force = yield* import_effect13.FiberRef.get(forceSourceRefresh);
         const listValue = getAtPath(state, listPath);
         const items = Array.isArray(listValue) ? listValue : [];
         const ids = store.ensureList(listPath, items);
@@ -2173,14 +2769,14 @@ var installSourceRefresh = (bound, step, entry) => {
         }
       })
     );
-    return import_effect10.Effect.void;
+    return import_effect13.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_effect13.Effect.gen(function* () {
     const { moduleId, instanceId } = getBoundScope(bound);
     let loadingSnapshot = Snapshot.loading({ keyHash: keyHash2 });
     if (replayMode === "replay" && replayLog) {
@@ -2218,15 +2814,15 @@ var installSourceRefresh = (bound, step, entry) => {
       recordReplayEvent(bound, event);
       yield* recordSnapshot(replayMode, replayLog, event);
     }
-    const io = import_effect10.Effect.gen(function* () {
+    const io = import_effect13.Effect.gen(function* () {
       if (replayMode === "replay" && replayLog) {
-        yield* import_effect10.Effect.yieldNow();
+        yield* import_effect13.Effect.yieldNow();
         const replayed = yield* replayLog.consumeNextResourceSnapshot({
           resourceId,
           fieldPath,
           keyHash: keyHash2
         });
-        if (!replayed) return yield* import_effect10.Effect.void;
+        if (!replayed) return yield* import_effect13.Effect.void;
         if (replayed.phase === "success") {
           const event = {
             _tag: "ResourceSnapshot",
@@ -2274,14 +2870,14 @@ var installSourceRefresh = (bound, step, entry) => {
             event
           );
         }
-        return yield* import_effect10.Effect.void;
+        return yield* import_effect13.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_effect13.Effect.serviceOption(internal.ResourceRegistryTag);
+      const registry = import_effect13.Option.isSome(registryOpt) ? registryOpt.value : void 0;
       const spec = registry?.specs.get(resourceId);
       if (!spec) {
-        return yield* import_effect10.Effect.void;
+        return yield* import_effect13.Effect.void;
       }
       const loadEffect = spec.load(key);
       const meta = {
@@ -2295,8 +2891,8 @@ 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_effect13.Effect.serviceOption(RunSessionTag);
+        if (import_effect13.Option.isSome(sessionOpt)) {
           const seqKey = instanceId ?? "global";
           meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", seqKey);
         }
@@ -2307,7 +2903,7 @@ var installSourceRefresh = (bound, step, entry) => {
         effect: loadEffect,
         meta
       });
-      const exit = yield* import_effect10.Effect.exit(run(op, stack));
+      const exit = yield* import_effect13.Effect.exit(run(op, stack));
       if (exit._tag === "Success") {
         const successSnapshot = Snapshot.success({ keyHash: keyHash2, data: exit.value });
         const event = {
@@ -2363,46 +2959,46 @@ 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_effect13.Effect.catchAllCause(() => import_effect13.Effect.void));
+    const fiber = yield* import_effect13.Effect.forkScoped(import_effect13.Effect.locally(inSyncTransactionFiber, false)(io));
     const myGen = gen += 1;
     inFlight = { gen: myGen, fiber, keyHash: keyHash2 };
-    yield* import_effect10.Effect.forkScoped(
-      import_effect10.Effect.locally(
+    yield* import_effect13.Effect.forkScoped(
+      import_effect13.Effect.locally(
         inSyncTransactionFiber,
         false
       )(
-        import_effect10.Fiber.await(fiber).pipe(
-          import_effect10.Effect.zipRight(
-            import_effect10.Effect.sync(() => {
+        import_effect13.Fiber.await(fiber).pipe(
+          import_effect13.Effect.zipRight(
+            import_effect13.Effect.sync(() => {
               if (inFlight && inFlight.gen === myGen) {
                 inFlight = void 0;
               }
             })
           ),
-          import_effect10.Effect.zipRight(
-            mode === "exhaust-trailing" ? import_effect10.Effect.gen(function* () {
+          import_effect13.Effect.zipRight(
+            mode === "exhaust-trailing" ? import_effect13.Effect.gen(function* () {
               const next = trailing;
               trailing = void 0;
               if (next) {
                 yield* startFetch(next.key, next.keyHash, replayMode, replayLog);
               }
-            }) : import_effect10.Effect.void
+            }) : import_effect13.Effect.void
           ),
-          import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void)
+          import_effect13.Effect.catchAllCause(() => import_effect13.Effect.void)
         )
       )
     );
   });
   register(
     fieldPath,
-    (state) => import_effect10.Effect.gen(function* () {
+    (state) => import_effect13.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_effect13.Effect.serviceOption(ReplayModeConfigTag);
+      const replayMode = import_effect13.Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
+      const replayLogOpt = yield* import_effect13.Effect.serviceOption(ReplayLog);
+      const replayLog = import_effect13.Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
+      const force = yield* import_effect13.FiberRef.get(forceSourceRefresh);
       let key;
       try {
         key = entry.meta.key(state);
@@ -2428,7 +3024,7 @@ var installSourceRefresh = (bound, step, entry) => {
       }
       if (key === void 0) {
         if (inFlight) {
-          yield* import_effect10.Fiber.interruptFork(inFlight.fiber);
+          yield* import_effect13.Fiber.interruptFork(inFlight.fiber);
           inFlight = void 0;
         }
         trailing = void 0;
@@ -2501,15 +3097,475 @@ var installSourceRefresh = (bound, step, entry) => {
         return;
       }
       if (mode === "switch" && inFlight) {
-        yield* import_effect10.Fiber.interruptFork(inFlight.fiber);
+        yield* import_effect13.Fiber.interruptFork(inFlight.fiber);
         inFlight = void 0;
         trailing = void 0;
       }
       yield* startFetch(key, h, replayMode, replayLog);
     })
   );
-  return import_effect10.Effect.void;
+  return import_effect13.Effect.void;
+};
+
+// src/internal/state-trait/external-store.ts
+var import_effect14 = 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 resolveStore = (entry) => import_effect14.Effect.gen(function* () {
+  const store = entry.meta?.store;
+  const descriptor = getExternalStoreDescriptor(store);
+  if (descriptor?.kind === "service") {
+    const service = yield* descriptor.tag;
+    return descriptor.map(service);
+  }
+  return store;
+});
+var installExternalStoreSync = (bound, step, entry) => import_effect14.Effect.gen(function* () {
+  const fieldPath = step.targetFieldPath;
+  if (!fieldPath) return;
+  const env = yield* import_effect14.Effect.context();
+  const hostSchedulerOpt = yield* import_effect14.Effect.serviceOption(HostSchedulerTag);
+  const hostScheduler = import_effect14.Option.isSome(hostSchedulerOpt) ? hostSchedulerOpt.value : getGlobalHostScheduler();
+  const microtask = import_effect14.Effect.async((resume2) => {
+    hostScheduler.scheduleMicrotask(() => resume2(import_effect14.Effect.void));
+  });
+  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);
+  if (rawDescriptor?.kind === "module") {
+    const linkRuntimeOpt = yield* import_effect14.Effect.serviceOption(DeclarativeLinkRuntimeTag);
+    if (import_effect14.Option.isNone(linkRuntimeOpt)) {
+      return yield* import_effect14.Effect.dieMessage("[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_effect14.Context.isTag(tag)) {
+          return internals.imports.get(tag);
+        }
+        if (import_effect14.Context.isTag(module2)) {
+          return internals.imports.get(module2);
+        }
+      }
+      return void 0;
+    })();
+    if (!sourceRuntime) {
+      return yield* import_effect14.Effect.dieMessage(
+        `[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_effect14.Effect.dieMessage(
+        `[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_effect14.Effect.dieMessage(
+        `[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 writeValue2 = (nextValue) => import_effect14.Effect.gen(function* () {
+      const inTxn = yield* import_effect14.FiberRef.get(inSyncTransactionFiber);
+      const body = import_effect14.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_effect14.Effect.asVoid)
+      );
+    }).pipe(import_effect14.Effect.provide(env));
+    const unregister = linkRuntimeOpt.value.registerModuleAsSourceLink({
+      id: `${internals.instanceId}::externalStore:${step.id}`,
+      sourceModuleInstanceKey: moduleInstanceKey,
+      readQuery: rawDescriptor.readQuery,
+      computeValue,
+      equalsValue: isEqual,
+      applyValue: writeValue2
+    });
+    yield* import_effect14.Effect.addFinalizer(
+      () => import_effect14.Effect.sync(() => {
+        unregister();
+      })
+    );
+    const initialState = yield* sourceRuntime.getState;
+    const initialSelected = rawDescriptor.readQuery.select(initialState);
+    yield* writeValue2(computeValue(initialSelected));
+    return;
+  }
+  const store = rawDescriptor?.kind === "service" ? yield* resolveStore(entry) : rawStore;
+  if (!store || typeof store !== "object") {
+    return yield* import_effect14.Effect.dieMessage(
+      `[StateTrait.externalStore] Invalid store for "${fieldPath}". Expected { getSnapshot, subscribe }.`
+    );
+  }
+  if (!isFn(store.getSnapshot) || !isFn(store.subscribe)) {
+    return yield* import_effect14.Effect.dieMessage(
+      `[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_effect14.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_effect14.Effect.void;
+    }
+    return import_effect14.Effect.async((resumeEffect, signal2) => {
+      let done = false;
+      const r = () => {
+        if (done) return;
+        done = true;
+        resume = void 0;
+        resumeEffect(import_effect14.Effect.void);
+      };
+      resume = r;
+      try {
+        signal2.addEventListener(
+          "abort",
+          () => {
+            if (resume === r) {
+              resume = void 0;
+            }
+          },
+          { once: true }
+        );
+      } catch {
+      }
+    });
+  };
+  const getSnapshotOrFuse = () => {
+    try {
+      return store.getSnapshot();
+    } catch (err) {
+      fused = true;
+      fuseCause = err;
+      return void 0;
+    }
+  };
+  const readSnapshotOrFuse = import_effect14.Effect.locally(inSyncTransactionFiber, false)(import_effect14.Effect.sync(getSnapshotOrFuse));
+  const before = yield* readSnapshotOrFuse;
+  if (fused) {
+    yield* recordFuseDiagnostic;
+    return;
+  }
+  const unsubscribe = store.subscribe(signal);
+  yield* import_effect14.Effect.addFinalizer(
+    () => import_effect14.Effect.sync(() => {
+      try {
+        unsubscribe?.();
+      } catch {
+      }
+    })
+  );
+  const after = yield* readSnapshotOrFuse;
+  if (fused) {
+    yield* recordFuseDiagnostic;
+    return;
+  }
+  const writeValue = (nextValue) => import_effect14.Effect.gen(function* () {
+    const inTxn = yield* import_effect14.FiberRef.get(inSyncTransactionFiber);
+    const body = import_effect14.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_effect14.Effect.asVoid)
+    );
+  });
+  yield* writeValue(computeValue(after));
+  if (!isEqual(before, after)) {
+    signal();
+  }
+  yield* import_effect14.Effect.forkScoped(
+    import_effect14.Effect.locally(inSyncTransactionFiber, false)(
+      import_effect14.Effect.gen(function* () {
+        while (true) {
+          yield* awaitSignal();
+          if (fused) return;
+          yield* microtask;
+          if (fused) return;
+          const snapshot2 = yield* readSnapshotOrFuse;
+          if (fused) {
+            yield* recordFuseDiagnostic;
+            return;
+          }
+          yield* writeValue(computeValue(snapshot2));
+        }
+      })
+    )
+  );
+});
+
+// src/internal/state-trait/meta-diagnostics.ts
+var import_effect16 = require("effect");
+
+// src/internal/state-trait/converge-diagnostics.ts
+var import_effect15 = require("effect");
+var SchemaAST2 = __toESM(require("effect/SchemaAST"), 1);
+var onceKeysFallback = /* @__PURE__ */ new Set();
+var onceInRunSession2 = (key) => import_effect15.Effect.serviceOption(RunSessionTag).pipe(
+  import_effect15.Effect.map((maybe) => {
+    if (import_effect15.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_effect16.Effect.gen(function* () {
+  if (!isDevEnv()) return;
+  const level = yield* import_effect16.FiberRef.get(currentDiagnosticsLevel);
+  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 +3578,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_effect17.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_effect17.Effect.void;
+      }
+      if (step.kind !== "source-refresh" && step.kind !== "external-store-sync") {
+        return import_effect17.Effect.void;
+      }
+      const candidates = entryIndex.get(step.targetFieldPath);
+      if (!candidates || candidates.length === 0) {
+        return import_effect17.Effect.void;
+      }
+      const entry = step.kind === "source-refresh" ? candidates.find((e) => e.kind === "source") : candidates.find((e) => e.kind === "externalStore");
+      if (!entry) {
+        return import_effect17.Effect.void;
+      }
+      return step.kind === "source-refresh" ? installSourceRefresh(bound, step, entry) : installExternalStoreSync(bound, step, entry);
+    };
+    yield* import_effect17.Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(import_effect17.Effect.asVoid);
+  }).pipe(import_effect17.Effect.asVoid);
 };
 
 // src/internal/state-trait/ir.ts
@@ -2569,6 +3634,8 @@ var toNodeKind = (step) => {
       return "link";
     case "source-refresh":
       return "source";
+    case "external-store-sync":
+      return "externalStore";
     case "check-validate":
       return "check";
   }
@@ -2593,6 +3660,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 +3710,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 +3808,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 +3831,7 @@ var exportStaticIr2 = (program, moduleId, options) => exportStaticIr({
   build,
   computed,
   exportStaticIr,
+  externalStore,
   from,
   install,
   link,