@logixjs/core 0.0.1 → 1.0.0

package/dist/Process.cjs

@@ -34,15 +34,17 @@ __export(Process_exports, {
   getDefinition: () => getDefinition2,
   getMeta: () => getMeta2,
   link: () => link,
-  make: () => make7
+  linkDeclarative: () => linkDeclarative,
+  make: () => make9
 });
 module.exports = __toCommonJS(Process_exports);
+var import_effect56 = require("effect");
 
 // src/internal/runtime/ModuleFactory.ts
-var import_effect48 = require("effect");
+var import_effect55 = require("effect");
 
-// src/internal/runtime/core/ModuleRuntime.ts
-var import_effect42 = require("effect");
+// src/internal/runtime/core/ModuleRuntime.impl.ts
+var import_effect49 = require("effect");
 
 // src/internal/runtime/core/Lifecycle.ts
 var import_effect4 = require("effect");
@@ -50,7 +52,7 @@ var import_effect4 = require("effect");
 // src/internal/runtime/core/errorSummary.ts
 var import_effect = 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
@@ -65,29 +67,53 @@ var defaultOptions = {
 
 // 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")() {
-};
-
-// 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
+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.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);
@@ -128,15 +154,16 @@ ${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 isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === 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:")) {
@@ -162,7 +189,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);
@@ -228,7 +255,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) {
@@ -237,114 +264,765 @@ 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 }))
+    );
+  })
 );
+var record = (event) => import_effect3.Effect.gen(function* () {
+  const sinks = yield* import_effect3.Effect.service(currentDebugSinks);
+  if (isErrorOnlyOnlySinks(sinks)) {
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic" && event.severity !== "info") {
+      yield* diagnosticLog(event);
+    }
+    return;
+  }
+  if (sinks.length === 0) {
+    if (isBrowser) {
+      if (event.type === "lifecycle:error" || event.type === "diagnostic") {
+        yield* renderBrowserConsoleEvent(event);
+      }
+      return;
+    }
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+    }
+    return;
+  }
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const mode = yield* import_effect3.Effect.service(currentTraceMode);
+    if (mode === "off") return;
+  }
+  const enriched = event;
+  const diagnosticsLevel = yield* import_effect3.Effect.service(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.Effect.service(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect3.Effect.service(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const maybeLinkId = yield* import_effect3.Effect.serviceOption(currentLinkId);
+    if (import_effect3.Option.isSome(maybeLinkId) && maybeLinkId.value) {
+      ;
+      enriched.linkId = maybeLinkId.value;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect3.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
 
 // src/internal/runtime/core/Lifecycle.ts
-var LifecycleContext = import_effect4.Context.GenericTag("@logixjs/LifecycleManager");
+var LifecycleContext = class extends import_effect4.ServiceMap.Service()("@logixjs/LifecycleManager") {
+};
 
 // src/internal/runtime/core/ConvergeStaticIrCollector.ts
 var import_effect5 = require("effect");
-var currentConvergeStaticIrCollectors = import_effect5.FiberRef.unsafeMake([]);
+var currentConvergeStaticIrCollectors = import_effect5.ServiceMap.Reference(
+  "@logixjs/core/ConvergeStaticIrCollectors",
+  {
+    defaultValue: () => []
+  }
+);
 
 // src/internal/runtime/core/StateTransaction.ts
 var import_effect6 = require("effect");
 
 // src/internal/runtime/core/RuntimeKernel.ts
-var import_effect8 = require("effect");
+var import_effect13 = require("effect");
 
 // src/internal/runtime/core/env.ts
+var import_effect12 = 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_effect10 = require("effect");
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect9 = require("effect");
+
+// src/internal/runtime/core/ModeRunner.ts
+var import_effect8 = require("effect");
+
+// src/internal/runtime/core/LatestFiberSlot.ts
 var import_effect7 = require("effect");
-var StateTransactionConfigTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+
+// src/internal/runtime/core/TaskRunner.ts
+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/DeclarativeLinkRuntime.ts
+var import_effect11 = 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 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 = {
+      ...link2,
+      readNodeById,
+      dispatchNodeById,
+      dispatchTargetsByReadNode,
+      readNodeState: /* @__PURE__ */ new Map()
+    };
+    declarativeById.set(link2.linkId, stored);
+    for (const n of link2.readNodes) {
+      const list = declarativeReadNodesBySource.get(n.moduleInstanceKey) ?? [];
+      list.push({ linkId: link2.linkId, nodeId: n.nodeId });
+      declarativeReadNodesBySource.set(n.moduleInstanceKey, list);
+    }
+    return () => {
+      declarativeById.delete(link2.linkId);
+      for (const n of link2.readNodes) {
+        const list = declarativeReadNodesBySource.get(n.moduleInstanceKey);
+        if (!list) continue;
+        const next = list.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_effect11.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 node = link2.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 StateTransactionConfigTagImpl = class extends import_effect12.ServiceMap.Service()("@logixjs/core/StateTransactionRuntimeConfig") {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect12.ServiceMap.Service()("@logixjs/core/ReadQueryStrictGateRuntimeConfig") {
 };
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var ReplayModeConfigTagImpl = class extends import_effect12.ServiceMap.Service()("@logixjs/core/ReplayModeConfig") {
 };
-var ReplayModeConfigTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var StateTransactionOverridesTagImpl = class extends import_effect12.ServiceMap.Service()("@logixjs/core/StateTransactionOverrides") {
 };
-var StateTransactionOverridesTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var SchedulingPolicySurfaceTagImpl = class extends import_effect12.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurface") {
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var SchedulingPolicySurfaceOverridesTagImpl = class extends import_effect12.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurfaceOverrides") {
 };
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var RuntimeStoreTag = class extends import_effect12.ServiceMap.Service()("@logixjs/core/RuntimeStore") {
+};
+var runtimeStoreLayer = import_effect12.Layer.effect(
+  RuntimeStoreTag,
+  import_effect12.Effect.acquireRelease(
+    import_effect12.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect12.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect12.ServiceMap.Service()("@logixjs/core/HostScheduler") {
+};
+var hostSchedulerLayer = import_effect12.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect12.ServiceMap.Service()("@logixjs/core/DeclarativeLinkRuntime") {
+};
+var declarativeLinkRuntimeLayer = import_effect12.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect12.ServiceMap.Service()("@logixjs/core/TickScheduler") {
 };
 
 // src/internal/runtime/core/RuntimeKernel.ts
-var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeServicesRuntimeConfig")() {
+var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect13.ServiceMap.Service()("@logixjs/core/RuntimeServicesRuntimeConfig") {
 };
-var RuntimeServicesProviderOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeServicesProviderOverrides")() {
+var RuntimeServicesProviderOverridesTagImpl = class extends import_effect13.ServiceMap.Service()("@logixjs/core/RuntimeServicesProviderOverrides") {
 };
-var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeServicesInstanceOverrides")() {
+var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect13.ServiceMap.Service()("@logixjs/core/RuntimeServicesInstanceOverrides") {
 };
-var FullCutoverGateModeTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/FullCutoverGateMode")() {
+var FullCutoverGateModeTagImpl = class extends import_effect13.ServiceMap.Service()("@logixjs/core/FullCutoverGateMode") {
 };
-var RuntimeServicesRegistryTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeServicesRegistry")() {
+var RuntimeServicesRegistryTagImpl = class extends import_effect13.ServiceMap.Service()("@logixjs/core/RuntimeServicesRegistry") {
 };
 
 // src/internal/runtime/core/KernelRef.ts
-var import_effect9 = require("effect");
-var KernelImplementationRefTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/KernelImplementationRef")() {
+var import_effect14 = require("effect");
+var KernelImplementationRefTagImpl = class extends import_effect14.ServiceMap.Service()("@logixjs/core/KernelImplementationRef") {
 };
 
 // src/internal/runtime/core/RuntimeServiceBuiltins.ts
-var import_effect10 = require("effect");
-var RuntimeServiceBuiltinsTag = class extends import_effect10.Context.Tag("@logixjs/core/RuntimeServiceBuiltins")() {
+var import_effect15 = require("effect");
+var RuntimeServiceBuiltinsTag = class extends import_effect15.ServiceMap.Service()("@logixjs/core/RuntimeServiceBuiltins") {
 };
 
 // src/internal/observability/evidenceCollector.ts
-var import_effect12 = require("effect");
+var import_effect17 = require("effect");
 
 // src/internal/observability/runSession.ts
-var import_effect11 = require("effect");
-var RunSessionTagImpl = class extends import_effect11.Context.Tag("@logixjs/core/RunSession")() {
+var import_effect16 = require("effect");
+var RunSessionTagImpl = class extends import_effect16.ServiceMap.Service()("@logixjs/core/RunSession") {
 };
 
 // src/internal/observability/evidenceCollector.ts
-var EvidenceCollectorTagImpl = class extends import_effect12.Context.Tag("@logixjs/core/EvidenceCollector")() {
+var EvidenceCollectorTagImpl = class extends import_effect17.ServiceMap.Service()("@logixjs/core/EvidenceCollector") {
 };
 
 // src/internal/runtime/core/ModuleRuntime.operation.ts
-var import_effect14 = require("effect");
+var import_effect19 = require("effect");
 
 // src/internal/effect-op.ts
-var import_effect13 = require("effect");
+var import_effect18 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.dispatch.ts
-var import_effect16 = require("effect");
+var import_effect21 = require("effect");
 
 // src/internal/runtime/core/ReducerDiagnostics.ts
-var import_effect15 = require("effect");
+var import_effect20 = require("effect");
+
+// src/internal/runtime/core/mutativePatches.ts
+var import_mutative = require("mutative");
 
 // src/internal/runtime/core/ModuleRuntime.effects.ts
-var import_effect17 = require("effect");
+var import_effect22 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.transaction.ts
-var import_effect27 = require("effect");
+var import_effect33 = require("effect");
 
-// src/internal/runtime/core/TaskRunner.ts
-var import_effect18 = require("effect");
-var inSyncTransactionFiber = import_effect18.FiberRef.unsafeMake(false);
-var forceSourceRefresh = import_effect18.FiberRef.unsafeMake(false);
+// src/internal/state-trait/converge-in-transaction.impl.ts
+var import_effect26 = require("effect");
 
-// src/internal/state-trait/converge-in-transaction.ts
-var import_effect22 = require("effect");
+// src/internal/digest.ts
+var stableStringify = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const record2 = value;
+    const keys = Object.keys(record2).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record2[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
 
 // src/internal/state-trait/converge-diagnostics.ts
-var import_effect19 = require("effect");
+var import_effect23 = require("effect");
 var SchemaAST = __toESM(require("effect/SchemaAST"), 1);
 
 // src/internal/state-trait/exec-vm-mode.ts
-var import_effect20 = require("effect");
-var currentExecVmMode = import_effect20.FiberRef.unsafeMake(false);
+var import_effect24 = require("effect");
+var currentExecVmMode = import_effect24.ServiceMap.Reference("@logixjs/core/ExecVmMode", {
+  defaultValue: () => false
+});
 
 // src/internal/state-trait/converge-step.ts
-var import_effect21 = require("effect");
+var import_effect25 = require("effect");
 
-// src/internal/state-trait/validate.ts
-var import_effect23 = require("effect");
-var import_mutative = require("mutative");
+// src/internal/state-trait/converge-in-transaction.impl.ts
+var EMPTY_INT32 = new Int32Array(0);
+
+// src/internal/state-trait/validate.impl.ts
+var import_effect27 = require("effect");
+var import_mutative2 = require("mutative");
 var nowMs = (() => {
   const perf = globalThis.performance;
   if (perf && typeof perf.now === "function") {
@@ -353,53 +1031,65 @@ var nowMs = (() => {
   return () => Date.now();
 })();
 
-// src/internal/state-trait/source.ts
-var import_effect26 = require("effect");
-var import_mutative2 = require("mutative");
+// src/internal/state-trait/source.impl.ts
+var import_effect30 = require("effect");
+var import_mutative3 = require("mutative");
 
 // src/internal/resource.ts
-var import_effect24 = require("effect");
-var ResourceRegistryTag = class extends import_effect24.Context.Tag("@logixjs/core/ResourceRegistry")() {
+var import_effect28 = require("effect");
+var ResourceRegistryTag = class extends import_effect28.ServiceMap.Service()("@logixjs/core/ResourceRegistry") {
 };
 
 // src/internal/runtime/core/ReplayLog.ts
-var import_effect25 = require("effect");
-var ReplayLog = class extends import_effect25.Context.Tag("@logixjs/core/ReplayLog")() {
+var import_effect29 = require("effect");
+var ReplayLog = class extends import_effect29.ServiceMap.Service()("@logixjs/core/ReplayLog") {
 };
-var snapshot = import_effect25.Effect.gen(function* () {
+var snapshot = import_effect29.Effect.gen(function* () {
   const log = yield* ReplayLog;
   return yield* log.snapshot;
 });
-var resetCursor = import_effect25.Effect.gen(function* () {
+var resetCursor = import_effect29.Effect.gen(function* () {
   const log = yield* ReplayLog;
   yield* log.resetCursor;
 });
 
+// src/internal/runtime/core/ModuleRuntime.txnQueue.ts
+var import_effect31 = require("effect");
+var currentTxnQueuePhaseTiming = import_effect31.ServiceMap.Reference(
+  "@logixjs/core/TxnQueue.currentTxnQueuePhaseTiming",
+  {
+    defaultValue: () => void 0
+  }
+);
+
+// src/internal/runtime/core/runner/SyncEffectRunner.ts
+var import_effect32 = require("effect");
+
 // src/internal/runtime/core/ModuleRuntime.concurrencyPolicy.ts
-var import_effect28 = require("effect");
+var import_effect34 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.txnLanePolicy.ts
-var import_effect29 = require("effect");
+var import_effect35 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.traitConvergeConfig.ts
-var import_effect30 = require("effect");
+var import_effect36 = require("effect");
 
 // src/internal/state-trait/build.ts
 var SchemaAST2 = __toESM(require("effect/SchemaAST"), 1);
 
 // src/internal/runtime/core/ModuleRuntime.internalHooks.ts
-var import_effect31 = require("effect");
+var import_effect37 = require("effect");
 
 // src/internal/runtime/core/RootContext.ts
-var import_effect32 = require("effect");
-var RootContextTagImpl = class extends import_effect32.Context.Tag("@logixjs/core/RootContext")() {
+var import_effect38 = require("effect");
+var RootContextTagImpl = class extends import_effect38.ServiceMap.Service()("@logixjs/core/RootContext") {
 };
 
-// src/internal/runtime/core/process/ProcessRuntime.ts
-var import_effect34 = require("effect");
+// src/internal/runtime/core/process/ProcessRuntime.make.ts
+var import_effect42 = require("effect");
 
 // src/internal/runtime/core/process/concurrency.ts
-var import_effect33 = require("effect");
+var import_effect39 = require("effect");
 
 // src/internal/runtime/core/process/events.ts
 var PROCESS_EVENT_MAX_BYTES = 4 * 1024;
@@ -424,66 +1114,384 @@ var attachMeta = (effect, meta) => {
 // src/internal/runtime/core/process/selectorSchema.ts
 var SchemaAST3 = __toESM(require("effect/SchemaAST"), 1);
 
-// src/internal/runtime/core/process/ProcessRuntime.ts
-var ProcessRuntimeTag = class extends import_effect34.Context.Tag("@logixjs/core/ProcessRuntime")() {
+// src/internal/runtime/core/process/triggerStreams.ts
+var import_effect40 = require("effect");
+
+// src/internal/runtime/core/ReadQuery.ts
+function isReadQuery(input) {
+  if (!input || typeof input !== "object" && typeof input !== "function") return false;
+  const maybe = input;
+  return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads);
+}
+var normalizeReads = (reads) => {
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of reads) {
+    const key = typeof r === "number" ? `n:${r}` : `s:${r}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(r);
+  }
+  return unique.slice().sort();
+};
+var toHash32Number = (hex) => Number.parseInt(hex, 16);
+var makeReadsDigest = (reads) => {
+  const normalized = normalizeReads(reads);
+  return {
+    count: normalized.length,
+    hash: toHash32Number(fnv1a32(stableStringify(normalized)))
+  };
+};
+var computeSelectorId = (value) => `rq_${fnv1a32(stableStringify(value))}`;
+var nextUnstableSelectorSeq = 0;
+var unstableSelectorIdByFn = /* @__PURE__ */ new WeakMap();
+var computeUnstableSelectorId = (selector) => {
+  const existing = unstableSelectorIdByFn.get(selector);
+  if (existing) return existing;
+  nextUnstableSelectorSeq += 1;
+  const selectorId = `rq_u${nextUnstableSelectorSeq}`;
+  unstableSelectorIdByFn.set(selector, selectorId);
+  return selectorId;
+};
+var unwrapParens = (input) => {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner.startsWith("(") || !inner.endsWith(")")) {
+      return inner;
+    }
+  }
+  return trimmed;
+};
+var extractArrow = (source) => {
+  const idx = source.indexOf("=>");
+  if (idx < 0) return void 0;
+  const left = source.slice(0, idx).trim();
+  const right = source.slice(idx + 2).trim();
+  const paramRaw = unwrapParens(left);
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(paramRaw)) return void 0;
+  if (right.startsWith("{")) {
+    const m = right.match(/^\{\s*return\s+(.+?);?\s*\}\s*$/s);
+    if (!m) return void 0;
+    return { param: paramRaw, body: m[1]?.trim() ?? "" };
+  }
+  return { param: paramRaw, body: right };
+};
+var extractFunctionReturn = (source) => {
+  const trimmed = source.trim();
+  const m = trimmed.match(
+    /^function\s*(?:[A-Za-z_$][A-Za-z0-9_$]*\s*)?\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\)\s*\{\s*return\s+(.+?);?\s*\}\s*$/s
+  );
+  if (!m) return void 0;
+  const param = m[1]?.trim() ?? "";
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(param)) return void 0;
+  const body = m[2]?.trim() ?? "";
+  if (body.length === 0) return void 0;
+  return { param, body };
+};
+var tryParseSelectorSource = (source) => {
+  const arrowOrFn = extractArrow(source) ?? extractFunctionReturn(source);
+  if (!arrowOrFn) return void 0;
+  const expr = unwrapParens(arrowOrFn.body).trim().replace(/;$/, "").trim();
+  {
+    const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+    const m = expr.match(re);
+    if (m) {
+      return { kind: "path", path: m[1] };
+    }
+  }
+  if (expr.startsWith("{") && expr.endsWith("}")) {
+    const inner = expr.slice(1, -1).trim();
+    if (inner.length === 0) return { kind: "struct", entries: [] };
+    const parts = inner.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    const entries = [];
+    for (const part of parts) {
+      const idx = part.indexOf(":");
+      if (idx < 0) return void 0;
+      const key = part.slice(0, idx).trim();
+      const value = part.slice(idx + 1).trim();
+      if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) return void 0;
+      const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+      const m = value.match(re);
+      if (!m) return void 0;
+      entries.push([key, m[1]]);
+    }
+    entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    return { kind: "struct", entries };
+  }
+  return void 0;
+};
+var READ_QUERY_TEMPLATE_CACHE_MAX = 2048;
+var readQueryTemplateByFn = /* @__PURE__ */ new WeakMap();
+var readQueryTemplateBySource = /* @__PURE__ */ new Map();
+var lruGet = (map, key) => {
+  const value = map.get(key);
+  if (value === void 0) return void 0;
+  map.delete(key);
+  map.set(key, value);
+  return value;
+};
+var lruSet = (map, key, value, maxSize) => {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  if (map.size <= maxSize) return;
+  const oldestKey = map.keys().next().value;
+  if (oldestKey !== void 0) {
+    map.delete(oldestKey);
+  }
+};
+var safeToString = (fn) => {
+  try {
+    return fn.toString();
+  } catch {
+    return "";
+  }
+};
+var compile = (input) => {
+  if (isReadQuery(input)) {
+    const reads = normalizeReads(input.reads);
+    const readsDigest = reads.length > 0 ? makeReadsDigest(reads) : void 0;
+    const equalsKind = input.equalsKind;
+    const staticIr2 = {
+      selectorId: input.selectorId,
+      debugKey: input.debugKey,
+      lane: "static",
+      producer: "manual",
+      reads,
+      readsDigest,
+      equalsKind
+    };
+    return {
+      ...input,
+      reads,
+      lane: "static",
+      producer: "manual",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const selector = input;
+  const debugKey = (typeof selector?.debugKey === "string" && selector.debugKey.length > 0 ? selector.debugKey : void 0) ?? (typeof selector.name === "string" && selector.name.length > 0 ? selector.name : void 0);
+  const declaredReads = Array.isArray(selector?.fieldPaths) ? selector.fieldPaths.filter((x) => typeof x === "string") : void 0;
+  if (declaredReads && declaredReads.length > 0) {
+    const reads = normalizeReads(declaredReads);
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "reads", reads });
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const cachedByFn = readQueryTemplateByFn.get(selector);
+  if (cachedByFn) {
+    const staticIr2 = {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedByFn.reads,
+      readsDigest: cachedByFn.readsDigest,
+      equalsKind: cachedByFn.equalsKind
+    };
+    return {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      reads: cachedByFn.reads,
+      select: selector,
+      equalsKind: cachedByFn.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedByFn.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const srcTrimmed = safeToString(selector).trim();
+  const cachedBySource = srcTrimmed.length > 0 ? lruGet(readQueryTemplateBySource, srcTrimmed) : void 0;
+  if (cachedBySource) {
+    readQueryTemplateByFn.set(selector, cachedBySource);
+    const staticIr2 = {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedBySource.reads,
+      readsDigest: cachedBySource.readsDigest,
+      equalsKind: cachedBySource.equalsKind
+    };
+    return {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      reads: cachedBySource.reads,
+      select: selector,
+      equalsKind: cachedBySource.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedBySource.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const parsed = srcTrimmed.length > 0 ? tryParseSelectorSource(srcTrimmed) : void 0;
+  if (parsed?.kind === "path") {
+    const reads = [parsed.path];
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "path", path: parsed.path });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "objectIs" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  if (parsed?.kind === "struct") {
+    const reads = normalizeReads(parsed.entries.map(([, path]) => path));
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "struct", entries: parsed.entries });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "shallowStruct" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "shallowStruct"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "shallowStruct",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const baseFallbackReason = srcTrimmed.includes("=>") || srcTrimmed.startsWith("function") ? "unsupportedSyntax" : "missingDeps";
+  const lowDiscriminabilitySource = srcTrimmed.length === 0 || srcTrimmed.includes("[native code]");
+  const fallbackReason = !debugKey || lowDiscriminabilitySource ? "unstableSelectorId" : baseFallbackReason;
+  const selectorId = fallbackReason === "unstableSelectorId" ? computeUnstableSelectorId(selector) : computeSelectorId({ kind: "dynamic", debugKey, src: srcTrimmed });
+  const staticIr = {
+    selectorId,
+    debugKey,
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    equalsKind: "objectIs"
+  };
+  return {
+    selectorId,
+    debugKey,
+    reads: [],
+    select: selector,
+    equalsKind: "objectIs",
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    staticIr
+  };
+};
+
+// src/internal/serviceId.ts
+var import_effect41 = require("effect");
+
+// src/internal/runtime/core/process/ProcessRuntime.make.ts
+var ProcessRuntimeTag = class extends import_effect42.ServiceMap.Service()("@logixjs/core/ProcessRuntime") {
 };
-var currentProcessTrigger = import_effect34.FiberRef.unsafeMake(void 0);
-var currentProcessEventBudget = import_effect34.FiberRef.unsafeMake(
-  void 0
+var currentProcessTrigger = import_effect42.ServiceMap.Reference("@logixjs/core/ProcessRuntime.currentTrigger", {
+  defaultValue: () => void 0
+});
+var currentProcessEventBudget = import_effect42.ServiceMap.Reference(
+  "@logixjs/core/ProcessRuntime.currentEventBudget",
+  {
+    defaultValue: () => void 0
+  }
 );
 
 // src/internal/runtime/core/SelectorGraph.ts
-var import_effect35 = require("effect");
-
-// src/internal/runtime/core/ModuleRuntime.txnQueue.ts
-var import_effect36 = require("effect");
+var import_effect43 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.logics.ts
-var import_effect40 = require("effect");
+var import_effect47 = require("effect");
 
 // src/internal/runtime/core/LifecycleDiagnostics.ts
-var import_effect37 = require("effect");
+var import_effect44 = require("effect");
 
 // src/internal/runtime/core/LogicDiagnostics.ts
-var import_effect38 = require("effect");
-var LogicPhaseServiceTag = import_effect38.Context.GenericTag("@logixjs/LogicPhaseService");
-var LogicUnitServiceTag = class extends import_effect38.Context.Tag("@logixjs/LogicUnitService")() {
+var import_effect45 = require("effect");
+var LogicPhaseServiceTag = class extends import_effect45.ServiceMap.Service()("@logixjs/LogicPhaseService") {
+};
+var LogicUnitServiceTag = class extends import_effect45.ServiceMap.Service()("@logixjs/LogicUnitService") {
 };
 
 // src/internal/runtime/core/Platform.ts
-var import_effect39 = require("effect");
-var Tag = import_effect39.Context.GenericTag("@logixjs/Platform");
+var import_effect46 = require("effect");
+var Tag = class extends import_effect46.ServiceMap.Service()("@logixjs/Platform") {
+};
 
 // src/internal/runtime/core/ConcurrencyDiagnostics.ts
-var import_effect41 = require("effect");
-var nowMs2 = import_effect41.Effect.clockWith((clock) => clock.currentTimeMillis);
+var import_effect48 = require("effect");
+var nowMs2 = import_effect48.Effect.clockWith((clock) => clock.currentTimeMillis);
 
 // src/internal/runtime/core/BoundApiRuntime.ts
-var import_effect47 = require("effect");
+var import_effect54 = require("effect");
 
 // src/internal/action.ts
-var import_effect43 = require("effect");
-
-// src/internal/runtime/core/mutativePatches.ts
-var import_mutative3 = require("mutative");
+var import_effect50 = require("effect");
 
 // src/internal/runtime/core/FlowRuntime.ts
-var import_effect44 = require("effect");
+var import_effect51 = require("effect");
 
 // src/internal/runtime/core/MatchBuilder.ts
-var import_effect45 = require("effect");
+var import_effect52 = require("effect");
 
 // src/internal/root.ts
-var import_effect46 = require("effect");
+var import_effect53 = require("effect");
 
 // src/internal/runtime/ModuleFactory.ts
 function Link(modules, logic) {
-  return import_effect48.Effect.gen(function* () {
+  return import_effect55.Effect.gen(function* () {
     const handles = {};
     for (const [key, module2] of Object.entries(modules)) {
-      const runtime = yield* module2;
+      const runtime = yield* import_effect55.Effect.service(module2).pipe(import_effect55.Effect.orDie);
       handles[key] = {
-        read: (selector) => import_effect48.Effect.map(runtime.getState, selector),
+        read: (selector) => import_effect55.Effect.map(runtime.getState, selector),
         changes: runtime.changes,
         dispatch: runtime.dispatch,
         actions$: runtime.actions$,
@@ -501,6 +1509,19 @@ function Link(modules, logic) {
   });
 }
 
+// src/internal/runtime/core/DeclarativeLinkIR.ts
+var getDeclarativeLinkIrDigest = (ir) => `dlink_ir_v1:${fnv1a32(stableStringify(ir))}`;
+var exportDeclarativeLinkIr = (args) => ({
+  staticIrDigest: getDeclarativeLinkIrDigest(args.ir),
+  moduleId: `link:${args.linkId}`,
+  instanceId: "runtime",
+  kind: "declarativeLinkIr",
+  ir: args.ir
+});
+
+// src/ReadQuery.ts
+var compile2 = compile;
+
 // src/Process.ts
 var DEFAULT_TRIGGERS = [{ kind: "platformEvent", platformEvent: "runtime:boot" }];
 var normalizeDefinition = (input) => {
@@ -524,7 +1545,7 @@ var normalizeDefinition = (input) => {
     diagnosticsLevel
   };
 };
-var make7 = (definition, effect) => attachMeta(effect, {
+var make9 = (definition, effect) => attachMeta(effect, {
   definition: normalizeDefinition(definition),
   kind: "process"
 });
@@ -551,6 +1572,21 @@ function link(config, logic) {
     modulesRecord,
     logic
   );
+  const wrapped = import_effect56.Effect.gen(function* () {
+    const level = yield* import_effect56.Effect.service(currentDiagnosticsLevel).pipe(import_effect56.Effect.orDie);
+    if (level !== "off") {
+      yield* record({
+        type: "diagnostic",
+        moduleId: `link:${linkId}`,
+        code: "process_link::blackbox_best_effort",
+        severity: "info",
+        message: "[Process.link] Blackbox link is best-effort and is NOT stabilized within the same tick. Strong consistency applies only to declarative IR.",
+        hint: "If you need same-tick strong consistency, migrate to Process.linkDeclarative(...) (073).",
+        kind: "blackbox_link_boundary"
+      });
+    }
+    return yield* effect;
+  });
   const definition = {
     processId: linkId,
     requires: Array.from(requires),
@@ -559,17 +1595,149 @@ function link(config, logic) {
     errorPolicy: { mode: "failStop" },
     diagnosticsLevel: "off"
   };
-  return attachMeta(effect, {
+  return attachMeta(wrapped, {
     definition,
     kind: "link"
   });
 }
+function linkDeclarative(config, build2) {
+  const linkId = config.id ?? [...config.modules].map((m) => m.id).sort().join("~");
+  const modulesRecord = /* @__PURE__ */ Object.create(null);
+  const requires = /* @__PURE__ */ new Set();
+  for (const module2 of config.modules) {
+    const tag = unwrapModuleTag(module2);
+    requires.add(String(tag.id));
+    modulesRecord[tag.id] = tag;
+  }
+  const handles = /* @__PURE__ */ Object.create(null);
+  for (const id of Object.keys(modulesRecord)) {
+    const tag = modulesRecord[id];
+    handles[id] = {
+      read: (selector) => {
+        const compiled = compile2(selector);
+        const staticIr = compiled.staticIr;
+        const ok = staticIr.lane === "static" && staticIr.readsDigest != null && staticIr.fallbackReason == null;
+        if (!ok) {
+          throw new Error(
+            `[Process.linkDeclarative] ReadQuery must be static with readsDigest (moduleId=${id}, selectorId=${staticIr.selectorId}, lane=${staticIr.lane}, fallbackReason=${staticIr.fallbackReason}). Fix: use ReadQuery.make(...) or annotate selector.fieldPaths.`
+          );
+        }
+        return { _tag: "readNode", moduleId: id, tag, readQuery: compiled };
+      },
+      dispatch: (actionTag) => {
+        if (typeof actionTag !== "string" || actionTag.length === 0) {
+          throw new Error("[Process.linkDeclarative] actionTag must be a non-empty string");
+        }
+        return { _tag: "dispatchNode", moduleId: id, tag, actionTag };
+      }
+    };
+  }
+  const edges = build2(handles);
+  if (!Array.isArray(edges)) {
+    throw new Error("[Process.linkDeclarative] build(...) must return an array of edges");
+  }
+  const normalized = edges.filter((e) => Boolean(e && e.from && e.to)).map((e) => {
+    if (e.from._tag !== "readNode" || e.to._tag !== "dispatchNode") {
+      throw new Error("[Process.linkDeclarative] Invalid edge spec returned from build(...)");
+    }
+    return e;
+  }).slice().sort((a, b) => {
+    const ak = `${a.from.moduleId}:${a.from.readQuery.staticIr.selectorId}->${a.to.moduleId}:${a.to.actionTag}`;
+    const bk = `${b.from.moduleId}:${b.from.readQuery.staticIr.selectorId}->${b.to.moduleId}:${b.to.actionTag}`;
+    return ak < bk ? -1 : ak > bk ? 1 : 0;
+  });
+  const program = import_effect56.Effect.gen(function* () {
+    const runtime = yield* import_effect56.Effect.service(DeclarativeLinkRuntimeTag).pipe(import_effect56.Effect.orDie);
+    const collectors = yield* import_effect56.Effect.service(currentConvergeStaticIrCollectors).pipe(import_effect56.Effect.orDie);
+    const runtimeByTag = /* @__PURE__ */ new Map();
+    const resolveRuntime = (tag) => import_effect56.Effect.suspend(() => {
+      const cached = runtimeByTag.get(tag);
+      if (cached) return import_effect56.Effect.succeed(cached);
+      return import_effect56.Effect.service(tag).pipe(
+        import_effect56.Effect.tap(
+          (rt) => import_effect56.Effect.sync(() => {
+            runtimeByTag.set(tag, rt);
+          })
+        )
+      );
+    });
+    const nodes = [];
+    const irEdges = [];
+    const readNodes = [];
+    const dispatchNodes = [];
+    for (let i = 0; i < normalized.length; i += 1) {
+      const edge = normalized[i];
+      const fromRuntime = yield* resolveRuntime(edge.from.tag);
+      const toRuntime = yield* resolveRuntime(edge.to.tag);
+      const fromKey = `${fromRuntime.moduleId}::${fromRuntime.instanceId}`;
+      const readNodeId = `r${i}`;
+      const dispatchNodeId = `d${i}`;
+      nodes.push({
+        id: readNodeId,
+        kind: "readQuery",
+        moduleId: fromRuntime.moduleId,
+        instanceKey: fromRuntime.instanceId,
+        readQuery: edge.from.readQuery.staticIr
+      });
+      nodes.push({
+        id: dispatchNodeId,
+        kind: "dispatch",
+        moduleId: toRuntime.moduleId,
+        instanceKey: toRuntime.instanceId,
+        actionTag: edge.to.actionTag
+      });
+      irEdges.push({ from: readNodeId, to: dispatchNodeId });
+      readNodes.push({ nodeId: readNodeId, moduleInstanceKey: fromKey, readQuery: edge.from.readQuery });
+      dispatchNodes.push({
+        nodeId: dispatchNodeId,
+        dispatch: (payload) => toRuntime.dispatch({ _tag: edge.to.actionTag, payload }).pipe(import_effect56.Effect.asVoid)
+      });
+    }
+    const ir = {
+      version: 1,
+      nodes,
+      edges: irEdges
+    };
+    const registration = {
+      linkId,
+      ir,
+      readNodes,
+      dispatchNodes
+    };
+    const unregister = runtime.registerDeclarativeLink(registration);
+    if (collectors.length > 0) {
+      const exported = exportDeclarativeLinkIr({ linkId, ir });
+      for (const collector of collectors) {
+        collector.register(exported);
+      }
+    }
+    yield* import_effect56.Effect.addFinalizer(
+      () => import_effect56.Effect.sync(() => {
+        unregister();
+      })
+    );
+    yield* import_effect56.Effect.never;
+  });
+  const definition = {
+    processId: `dlink:${linkId}`,
+    requires: Array.from(requires),
+    triggers: DEFAULT_TRIGGERS,
+    concurrency: { mode: "latest" },
+    errorPolicy: { mode: "failStop" },
+    diagnosticsLevel: "off"
+  };
+  return attachMeta(program, {
+    definition,
+    kind: "declarativeLink"
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   attachMeta,
   getDefinition,
   getMeta,
   link,
+  linkDeclarative,
   make
 });
 //# sourceMappingURL=Process.cjs.map