@logixjs/core 0.0.1 → 1.0.0

package/dist/TraitLifecycle.cjs

@@ -20,7 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/TraitLifecycle.ts
 var TraitLifecycle_exports = {};
 __export(TraitLifecycle_exports, {
-  Ref: () => Ref3,
+  Ref: () => Ref4,
   cleanup: () => cleanup2,
   install: () => install2,
   makeSourceWiring: () => makeSourceWiring2,
@@ -30,12 +30,12 @@ __export(TraitLifecycle_exports, {
 module.exports = __toCommonJS(TraitLifecycle_exports);
 
 // src/internal/trait-lifecycle/index.ts
-var import_effect7 = require("effect");
+var import_effect11 = require("effect");
 
 // src/internal/runtime/core/TaskRunner.ts
-var import_effect5 = require("effect");
+var import_effect9 = require("effect");
 
-// src/internal/runtime/core/DebugSink.ts
+// src/internal/runtime/core/DebugSink.record.ts
 var import_effect3 = require("effect");
 
 // src/internal/observability/jsonValue.ts
@@ -53,29 +53,53 @@ var import_effect = require("effect");
 
 // src/internal/runtime/core/EffectOpCore.ts
 var import_effect2 = require("effect");
-var currentLinkId = import_effect2.FiberRef.unsafeMake(void 0);
-var EffectOpMiddlewareTag = class extends import_effect2.Context.Tag("Logix/EffectOpMiddleware")() {
+var currentLinkId = import_effect2.ServiceMap.Reference("@logixjs/core/CurrentLinkId", {
+  defaultValue: () => void 0
+});
+var EffectOpMiddlewareTag = class extends import_effect2.ServiceMap.Service()("Logix/EffectOpMiddleware") {
 };
 
-// src/internal/runtime/core/DebugSink.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
+// src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentDebugSinks", {
+  defaultValue: () => []
+});
+var currentRuntimeLabel = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentRuntimeLabel", {
+  defaultValue: () => void 0
+});
+var currentTxnId = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentTxnId", {
+  defaultValue: () => void 0
+});
+var currentOpSeq = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentOpSeq", {
+  defaultValue: () => void 0
 });
+var currentDiagnosticsLevel = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentDiagnosticsLevel", {
+  defaultValue: () => "off"
+});
+var currentDiagnosticsMaterialization = import_effect3.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentDiagnosticsMaterialization",
+  {
+    defaultValue: () => "eager"
+  }
+);
+var currentTraceMode = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentTraceMode", {
+  defaultValue: () => "on"
+});
+var currentTraitConvergeDiagnosticsSampling = import_effect3.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentTraitConvergeDiagnosticsSampling",
+  {
+    defaultValue: () => ({
+      sampleEveryN: 32,
+      topK: 3
+    })
+  }
+);
 var browserLifecycleSeen = /* @__PURE__ */ new Set();
 var browserDiagnosticSeen = /* @__PURE__ */ new Set();
 var lifecycleErrorLog = (event) => {
   const moduleId = event.moduleId ?? "unknown";
   const causePretty = (() => {
     try {
-      return import_effect3.Cause.pretty(event.cause, {
-        renderErrorCause: true
-      });
+      return import_effect3.Cause.pretty(event.cause);
     } catch {
       try {
         return JSON.stringify(event.cause, null, 2);
@@ -116,15 +140,15 @@ ${detail}`;
   }
   return base.pipe(import_effect3.Effect.annotateLogs(annotations));
 };
-var noopLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, []);
+var noopLayer = import_effect3.Layer.succeed(currentDebugSinks, []);
 var errorOnlySink = {
   record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void
 };
-var errorOnlyLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var errorOnlyLayer = import_effect3.Layer.succeed(currentDebugSinks, [errorOnlySink]);
 var consoleSink = {
   record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event })
 };
-var consoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var consoleLayer = import_effect3.Layer.succeed(currentDebugSinks, [consoleSink]);
 var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
 var renderBrowserConsoleEvent = (event) => {
   if (typeof event.type === "string" && event.type.startsWith("trace:")) {
@@ -150,7 +174,7 @@ var renderBrowserConsoleEvent = (event) => {
     const moduleId = event.moduleId ?? "unknown";
     const causePretty = (() => {
       try {
-        return import_effect3.Cause.pretty(event.cause, { renderErrorCause: true });
+        return import_effect3.Cause.pretty(event.cause);
       } catch {
         try {
           return JSON.stringify(event.cause, null, 2);
@@ -216,7 +240,7 @@ var browserConsoleSink = {
     return renderBrowserConsoleEvent(event);
   }
 };
-var browserConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserConsoleLayer = import_effect3.Layer.succeed(currentDebugSinks, [browserConsoleSink]);
 var browserDiagnosticConsoleSink = {
   record: (event) => {
     if (!isBrowser) {
@@ -225,14 +249,520 @@ var browserDiagnosticConsoleSink = {
     return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect3.Effect.void;
   }
 };
-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 browserDiagnosticConsoleLayer = import_effect3.Layer.succeed(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect3.Layer.effect(
+  import_effect3.Logger.CurrentLoggers,
+  import_effect3.Effect.gen(function* () {
+    const current = yield* import_effect3.Effect.service(import_effect3.Logger.CurrentLoggers);
+    return new Set(
+      [...current].filter((logger) => logger !== import_effect3.Logger.defaultLogger).concat(import_effect3.Logger.consolePretty({ mode: "browser", colors: true }))
+    );
+  })
 );
 
 // src/internal/runtime/core/env.ts
+var import_effect6 = 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 {
+    Promise.resolve().then(cb);
+  } catch {
+    setTimeout(cb, 0);
+  }
+};
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
+};
+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 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 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 globalHostScheduler;
+var getGlobalHostScheduler = () => {
+  globalHostScheduler ?? (globalHostScheduler = makeDefaultHostScheduler());
+  return globalHostScheduler;
+};
+
+// 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 { kind: "module", moduleInstanceKey: `${moduleId}::${instanceId}` };
+};
+var EMPTY_LISTENER_SNAPSHOT = [];
+var NO_CHANGED_TOPIC_LISTENERS = [];
+var makeRuntimeStore = () => {
+  let tickSeq = 0;
+  const moduleStates = /* @__PURE__ */ new Map();
+  const topicVersions = /* @__PURE__ */ new Map();
+  const topicPriorities = /* @__PURE__ */ new Map();
+  const listenersByTopic = /* @__PURE__ */ new Map();
+  const subscriberCountByModule = /* @__PURE__ */ new Map();
+  const getTopicVersion = (topicKey) => topicVersions.get(topicKey) ?? 0;
+  const getTopicPriority = (topicKey) => topicPriorities.get(topicKey) ?? "normal";
+  const commitTopicBump = (topicKey, priority) => {
+    const prev = topicVersions.get(topicKey) ?? 0;
+    topicVersions.set(topicKey, prev + 1);
+    topicPriorities.set(topicKey, priority);
+  };
+  const refreshTopicSnapshot = (state) => {
+    state.snapshot = Array.from(state.listeners);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const state = existing ?? { listeners: /* @__PURE__ */ new Set(), snapshot: EMPTY_LISTENER_SNAPSHOT };
+    const alreadyHas = state.listeners.has(listener);
+    if (!alreadyHas) {
+      state.listeners.add(listener);
+      refreshTopicSnapshot(state);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, state);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const currentState = listenersByTopic.get(topicKey);
+      if (!currentState) return;
+      const deleted = currentState.listeners.delete(listener);
+      if (deleted && info) {
+        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          subscriberCountByModule.delete(info.moduleInstanceKey);
+        } else {
+          subscriberCountByModule.set(info.moduleInstanceKey, next);
+        }
+      }
+      if (currentState.listeners.size === 0) {
+        listenersByTopic.delete(topicKey);
+      } else if (deleted) {
+        refreshTopicSnapshot(currentState);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.listeners.size ?? 0;
+  const getModuleSubscriberCount = (moduleInstanceKey) => subscriberCountByModule.get(moduleInstanceKey) ?? 0;
+  const registerModuleInstance = (args) => {
+    moduleStates.set(args.moduleInstanceKey, args.initialState);
+    if (!topicVersions.has(args.moduleInstanceKey)) {
+      topicVersions.set(args.moduleInstanceKey, 0);
+      topicPriorities.set(args.moduleInstanceKey, "normal");
+    }
+  };
+  const unregisterModuleInstance = (moduleInstanceKey) => {
+    moduleStates.delete(moduleInstanceKey);
+  };
+  const commitTick = (args) => {
+    tickSeq = args.tickSeq;
+    for (const [key, commit] of args.accepted.modules) {
+      moduleStates.set(key, commit.state);
+    }
+    if (args.accepted.dirtyTopics.size === 0) {
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    if (args.onListener) {
+      let firstTopicListeners;
+      let secondTopicListeners;
+      let restTopicListeners;
+      for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+        commitTopicBump(topicKey, priority);
+        const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+        if (listeners.length === 0) {
+          continue;
+        }
+        if (!firstTopicListeners) {
+          firstTopicListeners = listeners;
+          continue;
+        }
+        if (!secondTopicListeners) {
+          secondTopicListeners = listeners;
+          continue;
+        }
+        if (!restTopicListeners) {
+          restTopicListeners = [];
+        }
+        restTopicListeners.push(listeners);
+      }
+      if (firstTopicListeners) {
+        for (const listener of firstTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (secondTopicListeners) {
+        for (const listener of secondTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (restTopicListeners) {
+        for (const listeners of restTopicListeners) {
+          for (const listener of listeners) {
+            try {
+              args.onListener(listener);
+            } catch {
+            }
+          }
+        }
+      }
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    let singleTopicListeners;
+    let flattenedTopicListeners;
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+      if (listeners.length === 0) {
+        continue;
+      }
+      if (flattenedTopicListeners) {
+        for (const listener of listeners) {
+          flattenedTopicListeners.push(listener);
+        }
+        continue;
+      }
+      if (!singleTopicListeners) {
+        singleTopicListeners = listeners;
+        continue;
+      }
+      flattenedTopicListeners = Array.from(singleTopicListeners);
+      for (const listener of listeners) {
+        flattenedTopicListeners.push(listener);
+      }
+    }
+    return {
+      changedTopicListeners: flattenedTopicListeners ?? singleTopicListeners ?? NO_CHANGED_TOPIC_LISTENERS
+    };
+  };
+  const getModuleState = (moduleInstanceKey) => moduleStates.get(moduleInstanceKey);
+  const dispose = () => {
+    moduleStates.clear();
+    topicVersions.clear();
+    topicPriorities.clear();
+    listenersByTopic.clear();
+    subscriberCountByModule.clear();
+  };
+  return {
+    getTickSeq: () => tickSeq,
+    getModuleState,
+    getTopicVersion,
+    getTopicPriority,
+    subscribeTopic,
+    getTopicSubscriberCount,
+    getModuleSubscriberCount,
+    registerModuleInstance,
+    unregisterModuleInstance,
+    commitTick,
+    dispose
+  };
+};
+
+// src/internal/runtime/core/TickScheduler.ts
 var import_effect4 = require("effect");
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect5 = 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 = (link) => {
+    const stored = {
+      ...link,
+      hasValue: false,
+      lastValue: void 0
+    };
+    moduleAsSourceById.set(link.id, stored);
+    const set = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey) ?? /* @__PURE__ */ new Set();
+    set.add(link.id);
+    moduleAsSourceIdsBySource.set(link.sourceModuleInstanceKey, set);
+    return () => {
+      moduleAsSourceById.delete(link.id);
+      const current = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey);
+      if (!current) return;
+      current.delete(link.id);
+      if (current.size === 0) {
+        moduleAsSourceIdsBySource.delete(link.sourceModuleInstanceKey);
+      }
+    };
+  };
+  const registerDeclarativeLink = (link) => {
+    const readNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.readNodes) {
+      readNodeById.set(n.nodeId, n);
+    }
+    const dispatchNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.dispatchNodes) {
+      dispatchNodeById.set(n.nodeId, n);
+    }
+    const incomingByDispatch = /* @__PURE__ */ new Map();
+    for (const e of link.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=${link.linkId}, nodeId=${to}).`
+        );
+      }
+    }
+    const dispatchTargetsByReadNode = /* @__PURE__ */ new Map();
+    for (const e of link.ir.edges) {
+      const from = e.from;
+      const to = e.to;
+      if (!readNodeById.has(from)) continue;
+      if (!dispatchNodeById.has(to)) continue;
+      const list = dispatchTargetsByReadNode.get(from) ?? [];
+      list.push(to);
+      dispatchTargetsByReadNode.set(from, list);
+    }
+    const stored = {
+      ...link,
+      readNodeById,
+      dispatchNodeById,
+      dispatchTargetsByReadNode,
+      readNodeState: /* @__PURE__ */ new Map()
+    };
+    declarativeById.set(link.linkId, stored);
+    for (const n of link.readNodes) {
+      const list = declarativeReadNodesBySource.get(n.moduleInstanceKey) ?? [];
+      list.push({ linkId: link.linkId, nodeId: n.nodeId });
+      declarativeReadNodesBySource.set(n.moduleInstanceKey, list);
+    }
+    return () => {
+      declarativeById.delete(link.linkId);
+      for (const n of link.readNodes) {
+        const list = declarativeReadNodesBySource.get(n.moduleInstanceKey);
+        if (!list) continue;
+        const next = list.filter((x) => !(x.linkId === link.linkId && x.nodeId === n.nodeId));
+        if (next.length === 0) {
+          declarativeReadNodesBySource.delete(n.moduleInstanceKey);
+        } else {
+          declarativeReadNodesBySource.set(n.moduleInstanceKey, next);
+        }
+      }
+    };
+  };
+  const applyForSources = (args) => import_effect5.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 link = moduleAsSourceById.get(id);
+        if (!link) continue;
+        let selected;
+        try {
+          selected = link.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const nextValue = link.computeValue(selected);
+        if (link.hasValue && link.equalsValue(link.lastValue, nextValue)) {
+          continue;
+        }
+        link.hasValue = true;
+        link.lastValue = nextValue;
+        scheduled = true;
+        yield* link.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 link = declarativeById.get(ref.linkId);
+        if (!link) continue;
+        const readNode = link.readNodeById.get(ref.nodeId);
+        if (!readNode) continue;
+        let value;
+        try {
+          value = readNode.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const state = link.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;
+        link.readNodeState.set(ref.nodeId, state);
+        const targets = link.dispatchTargetsByReadNode.get(ref.nodeId) ?? [];
+        for (const dispatchNodeId of targets) {
+          const node = link.dispatchNodeById.get(dispatchNodeId);
+          if (!node) continue;
+          scheduled = true;
+          yield* node.dispatch(value);
+        }
+      }
+    }
+    return { scheduled };
+  });
+  return {
+    registerModuleAsSourceLink,
+    registerDeclarativeLink,
+    applyForSources
+  };
+};
+
+// src/internal/runtime/core/env.ts
 var getNodeEnv = () => {
   try {
     const env = globalThis?.process?.env;
@@ -242,32 +772,65 @@ var getNodeEnv = () => {
   }
 };
 var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+var StateTransactionConfigTagImpl = class extends import_effect6.ServiceMap.Service()("@logixjs/core/StateTransactionRuntimeConfig") {
 };
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect6.ServiceMap.Service()("@logixjs/core/ReadQueryStrictGateRuntimeConfig") {
 };
-var ReplayModeConfigTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var ReplayModeConfigTagImpl = class extends import_effect6.ServiceMap.Service()("@logixjs/core/ReplayModeConfig") {
 };
-var StateTransactionOverridesTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var StateTransactionOverridesTagImpl = class extends import_effect6.ServiceMap.Service()("@logixjs/core/StateTransactionOverrides") {
+};
+var SchedulingPolicySurfaceTagImpl = class extends import_effect6.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurface") {
+};
+var SchedulingPolicySurfaceOverridesTagImpl = class extends import_effect6.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurfaceOverrides") {
+};
+var RuntimeStoreTag = class extends import_effect6.ServiceMap.Service()("@logixjs/core/RuntimeStore") {
+};
+var runtimeStoreLayer = import_effect6.Layer.effect(
+  RuntimeStoreTag,
+  import_effect6.Effect.acquireRelease(
+    import_effect6.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect6.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect6.ServiceMap.Service()("@logixjs/core/HostScheduler") {
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var hostSchedulerLayer = import_effect6.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect6.ServiceMap.Service()("@logixjs/core/DeclarativeLinkRuntime") {
 };
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var declarativeLinkRuntimeLayer = import_effect6.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect6.ServiceMap.Service()("@logixjs/core/TickScheduler") {
 };
 
+// src/internal/runtime/core/ModeRunner.ts
+var import_effect8 = require("effect");
+
+// src/internal/runtime/core/LatestFiberSlot.ts
+var import_effect7 = require("effect");
+
 // src/internal/runtime/core/TaskRunner.ts
-var inSyncTransactionFiber = import_effect5.FiberRef.unsafeMake(false);
-var forceSourceRefresh = import_effect5.FiberRef.unsafeMake(false);
+var inSyncTransactionFiber = import_effect9.ServiceMap.Reference("@logixjs/core/TaskRunner.inSyncTransactionFiber", {
+  defaultValue: () => false
+});
+var forceSourceRefresh = import_effect9.ServiceMap.Reference("@logixjs/core/TaskRunner.forceSourceRefresh", {
+  defaultValue: () => false
+});
 
 // src/internal/runtime/core/ReplayLog.ts
-var import_effect6 = require("effect");
-var ReplayLog = class extends import_effect6.Context.Tag("@logixjs/core/ReplayLog")() {
+var import_effect10 = require("effect");
+var ReplayLog = class extends import_effect10.ServiceMap.Service()("@logixjs/core/ReplayLog") {
 };
-var snapshot = import_effect6.Effect.gen(function* () {
+var snapshot = import_effect10.Effect.gen(function* () {
   const log = yield* ReplayLog;
   return yield* log.snapshot;
 });
-var resetCursor = import_effect6.Effect.gen(function* () {
+var resetCursor = import_effect10.Effect.gen(function* () {
   const log = yield* ReplayLog;
   yield* log.resetCursor;
 });
@@ -292,7 +855,7 @@ var unsetAtPathMutating = (draft, path) => {
   }
   const last = segments[segments.length - 1];
   if (Array.isArray(current) && typeof last === "number") {
-    current[last] = void 0;
+    delete current[last];
     return;
   }
   if (current && typeof current === "object") {
@@ -323,7 +886,7 @@ var getBoundInternals = (bound) => {
 };
 
 // src/internal/trait-lifecycle/index.ts
-var Ref2 = {
+var Ref3 = {
   field: (path) => ({ kind: "field", path }),
   list: (path, listIndexPath) => ({
     kind: "list",
@@ -351,9 +914,9 @@ var Ref2 = {
    */
   fromValuePath: (valuePath) => {
     const raw = typeof valuePath === "string" ? valuePath.trim() : "";
-    if (!raw || raw === "$root") return Ref2.root();
+    if (!raw || raw === "$root") return Ref3.root();
     const segments = raw.split(".").filter(Boolean);
-    if (segments.length === 0) return Ref2.root();
+    if (segments.length === 0) return Ref3.root();
     const isIndex = (seg) => /^[0-9]+$/.test(seg);
     const stripPattern = (seg) => seg.endsWith("[]") ? seg.slice(0, -2) : seg;
     const indexPositions = [];
@@ -361,16 +924,16 @@ var Ref2 = {
       const seg = segments[i];
       if (!isIndex(seg)) continue;
       const index = Number(seg);
-      if (!Number.isFinite(index) || index < 0) return Ref2.field(raw);
+      if (!Number.isFinite(index) || index < 0) return Ref3.field(raw);
       indexPositions.push({ pos: i, index });
     }
     if (indexPositions.length > 0) {
       const last = indexPositions[indexPositions.length - 1];
       const listIndexPath = indexPositions.slice(0, -1).map((p) => p.index);
       const listPath = segments.slice(0, last.pos).filter((seg) => !isIndex(seg)).map(stripPattern).join(".");
-      if (!listPath) return Ref2.field(raw);
+      if (!listPath) return Ref3.field(raw);
       const fieldRest = segments.slice(last.pos + 1).map(stripPattern).join(".");
-      return Ref2.item(listPath, last.index, {
+      return Ref3.item(listPath, last.index, {
         listIndexPath: listIndexPath.length > 0 ? listIndexPath : void 0,
         field: fieldRest ? fieldRest : void 0
       });
@@ -378,14 +941,14 @@ var Ref2 = {
     if (segments.some((s) => s.includes("[]"))) {
       const last = segments[segments.length - 1];
       if (last.endsWith("[]")) {
-        return Ref2.list(segments.map(stripPattern).join("."));
+        return Ref3.list(segments.map(stripPattern).join("."));
       }
     }
-    return Ref2.field(raw);
+    return Ref3.field(raw);
   },
   root: () => ({ kind: "root" })
 };
-var scopedValidate = (bound, request) => import_effect7.Effect.gen(function* () {
+var scopedValidate = (bound, request) => import_effect11.Effect.gen(function* () {
   let internals;
   try {
     internals = getBoundInternals(bound);
@@ -416,19 +979,19 @@ var scopedValidate = (bound, request) => import_effect7.Effect.gen(function* ()
     mode: request.mode,
     target: toTarget(request.target)
   };
-  const inTxn = yield* import_effect7.FiberRef.get(inSyncTransactionFiber);
+  const inTxn = yield* import_effect11.Effect.service(inSyncTransactionFiber).pipe(import_effect11.Effect.orDie);
   if (inTxn) {
     enqueue(internal);
     return;
   }
   yield* internals.txn.runWithStateTransaction(
     { kind: "trait", name: "scopedValidate", details: request },
-    () => import_effect7.Effect.sync(() => {
+    () => import_effect11.Effect.sync(() => {
       enqueue(internal);
     })
   );
-});
-var scopedExecute = (bound, request) => import_effect7.Effect.gen(function* () {
+}).pipe(import_effect11.Effect.catchCause(() => import_effect11.Effect.void));
+var scopedExecute = (bound, request) => import_effect11.Effect.gen(function* () {
   if (request.kind === "source:refresh") {
     const toFieldPath = (ref) => {
       if (ref.kind === "root") return void 0;
@@ -446,8 +1009,8 @@ var scopedExecute = (bound, request) => import_effect7.Effect.gen(function* () {
   if (request.kind !== "query:invalidate") {
     return;
   }
-  const replayLogOpt = yield* import_effect7.Effect.serviceOption(ReplayLog);
-  if (import_effect7.Option.isNone(replayLogOpt)) {
+  const replayLogOpt = yield* import_effect11.Effect.serviceOption(ReplayLog);
+  if (import_effect11.Option.isNone(replayLogOpt)) {
     return;
   }
   let moduleId;
@@ -470,7 +1033,7 @@ var scopedExecute = (bound, request) => import_effect7.Effect.gen(function* () {
     meta: request.request
   });
 });
-var cleanup = (bound, request) => import_effect7.Effect.gen(function* () {
+var cleanup = (bound, request) => import_effect11.Effect.gen(function* () {
   const apply = () => bound.state.mutate((draft) => {
     const clearAt = (root, path) => {
       if (!path) return;
@@ -496,7 +1059,7 @@ var cleanup = (bound, request) => import_effect7.Effect.gen(function* () {
       return;
     }
   });
-  const inTxn = yield* import_effect7.FiberRef.get(inSyncTransactionFiber);
+  const inTxn = yield* import_effect11.Effect.service(inSyncTransactionFiber).pipe(import_effect11.Effect.orDie);
   if (inTxn) {
     return yield* apply();
   }
@@ -511,7 +1074,7 @@ var cleanup = (bound, request) => import_effect7.Effect.gen(function* () {
     return yield* apply();
   }
   return yield* runWithTxn({ kind: "trait", name: "cleanup", details: request }, apply);
-});
+}).pipe(import_effect11.Effect.catchCause(() => import_effect11.Effect.void));
 var isAuxRootPath = (path) => path === "errors" || path === "ui" || path.startsWith("errors.") || path.startsWith("ui.");
 var toPatternPath = (path) => {
   if (!path) return path;
@@ -535,35 +1098,35 @@ var makeSourceWiring = (bound, module2) => {
   const sourceOnKeyChange = sources.filter(
     (e) => Array.isArray(e?.meta?.triggers) ? e.meta.triggers.includes("onKeyChange") : false
   );
-  const setup = import_effect7.Effect.sync(() => {
+  const setup = import_effect11.Effect.sync(() => {
     if (sourceOnMount.length === 0) return;
     bound.lifecycle.onStart(
-      import_effect7.Effect.forEach(sourceOnMount, (entry) => bound.traits.source.refresh(entry.fieldPath), {
+      import_effect11.Effect.forEach(sourceOnMount, (entry) => bound.traits.source.refresh(entry.fieldPath), {
         concurrency: "unbounded"
-      }).pipe(import_effect7.Effect.asVoid)
+      }).pipe(import_effect11.Effect.asVoid)
     );
   });
-  const refreshOnKeyChange = (changedPath) => import_effect7.Effect.gen(function* () {
+  const refreshOnKeyChange = (changedPath) => import_effect11.Effect.gen(function* () {
     if (!changedPath || isAuxRootPath(changedPath)) return;
     if (sourceOnKeyChange.length === 0) return;
     const changedPattern = toPatternPath(changedPath);
-    yield* import_effect7.Effect.forEach(
+    yield* import_effect11.Effect.forEach(
       sourceOnKeyChange,
       (entry) => {
         const deps = entry?.meta?.deps ?? [];
         const affected = deps.some((dep) => isDepAffectedByChange(dep, changedPattern));
-        if (!affected) return import_effect7.Effect.void;
+        if (!affected) return import_effect11.Effect.void;
         return bound.traits.source.refresh(entry.fieldPath);
       },
       { concurrency: "unbounded" }
     );
-  }).pipe(import_effect7.Effect.asVoid);
+  }).pipe(import_effect11.Effect.asVoid);
   return { setup, refreshOnKeyChange };
 };
-var install = (_bound) => import_effect7.Effect.void;
+var install = (_bound) => import_effect11.Effect.void;
 
 // src/TraitLifecycle.ts
-var Ref3 = Ref2;
+var Ref4 = Ref3;
 var scopedValidate2 = (bound, request) => scopedValidate(bound, request);
 var scopedExecute2 = (bound, request) => scopedExecute(bound, request);
 var cleanup2 = (bound, request) => cleanup(bound, request);