@logixjs/core 0.0.1 → 0.0.2

package/dist/Debug.cjs

@@ -52,9 +52,9 @@ __export(Debug_exports, {
   withPrettyLogger: () => withPrettyLogger
 });
 module.exports = __toCommonJS(Debug_exports);
-var import_effect7 = require("effect");
+var import_effect10 = 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
@@ -146,11 +146,12 @@ var toJsonValueInternal = (input, options, stats, seen, depth) => {
     stats.nonSerializable += 1;
     return truncateString(String(input), options.maxStringLength, stats);
   }
-  const entries = Object.entries(input);
-  const limit = Math.min(entries.length, options.maxObjectKeys);
+  const keys = Object.keys(input).sort();
+  const limit = Math.min(keys.length, options.maxObjectKeys);
   const out = {};
   for (let i = 0; i < limit; i++) {
-    const [rawKey, rawValue] = entries[i];
+    const rawKey = keys[i];
+    const rawValue = input[rawKey];
     const key = truncateString(rawKey, options.maxStringLength, stats);
     if (rawValue === void 0) {
       stats.dropped += 1;
@@ -158,9 +159,9 @@ var toJsonValueInternal = (input, options, stats, seen, depth) => {
     }
     out[key] = toJsonValueInternal(rawValue, options, stats, seen, depth + 1);
   }
-  if (entries.length > limit) {
+  if (keys.length > limit) {
     stats.oversized += 1;
-    out.__truncatedKeys = entries.length - limit;
+    out.__truncatedKeys = keys.length - limit;
   }
   return out;
 };
@@ -297,7 +298,7 @@ var currentLinkId = import_effect2.FiberRef.unsafeMake(void 0);
 var EffectOpMiddlewareTag = class extends import_effect2.Context.Tag("Logix/EffectOpMiddleware")() {
 };
 
-// src/internal/runtime/core/DebugSink.ts
+// src/internal/runtime/core/DebugSink.record.ts
 var currentDebugSinks = import_effect3.FiberRef.unsafeMake([]);
 var currentRuntimeLabel = import_effect3.FiberRef.unsafeMake(void 0);
 var currentTxnId = import_effect3.FiberRef.unsafeMake(void 0);
@@ -855,10 +856,83 @@ var toRuntimeDebugEventRef = (event, options) => {
         meta: metaProjection.value
       });
     }
+    case "warn:priority-inversion": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      } : {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
+    case "warn:microtask-starvation": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      } : {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
     default: {
       if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
         return void 0;
       }
+      if (event.type === "trace:tick") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          tickSeq: data?.tickSeq,
+          phase: data?.phase,
+          schedule: data?.schedule,
+          triggerSummary: data?.triggerSummary,
+          anchors: data?.anchors,
+          budget: data?.budget,
+          backlog: data?.backlog,
+          result: data?.result
+        } : {
+          data
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
       if (event.type === "trace:txn-lane") {
         const data = event.data;
         const evidence = data?.evidence ?? data;
@@ -1244,6 +1318,146 @@ var exportEvidencePackage = (options) => {
   };
 };
 
+// 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/DevtoolsHub.ts
 var instances = /* @__PURE__ */ new Map();
 var latestStates = /* @__PURE__ */ new Map();
@@ -1312,9 +1526,10 @@ var currentSnapshot = {
 var listeners = /* @__PURE__ */ new Set();
 var notifyScheduled = false;
 var scheduleNotify = () => {
+  if (listeners.size === 0) return;
   if (notifyScheduled) return;
   notifyScheduled = true;
-  queueMicrotask(() => {
+  getGlobalHostScheduler().scheduleMicrotask(() => {
     notifyScheduled = false;
     for (const listener of listeners) {
       listener();
@@ -1539,7 +1754,290 @@ var appendConvergeStaticIrCollectors = (collectors) => import_effect5.Layer.fibe
 ]);
 
 // src/internal/runtime/core/env.ts
+var import_effect9 = require("effect");
+
+// 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 makeRuntimeStore = () => {
+  let tickSeq = 0;
+  const moduleStates = /* @__PURE__ */ new Map();
+  const topicVersions = /* @__PURE__ */ new Map();
+  const topicPriorities = /* @__PURE__ */ new Map();
+  const listenersByTopic = /* @__PURE__ */ new Map();
+  const subscriberCountByModule = /* @__PURE__ */ new Map();
+  const getTopicVersion = (topicKey) => topicVersions.get(topicKey) ?? 0;
+  const getTopicPriority = (topicKey) => topicPriorities.get(topicKey) ?? "normal";
+  const commitTopicBump = (topicKey, priority) => {
+    const prev = topicVersions.get(topicKey) ?? 0;
+    topicVersions.set(topicKey, prev + 1);
+    topicPriorities.set(topicKey, priority);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const set = existing ?? /* @__PURE__ */ new Set();
+    const alreadyHas = set.has(listener);
+    if (!alreadyHas) {
+      set.add(listener);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, set);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const current = listenersByTopic.get(topicKey);
+      if (!current) return;
+      const deleted = current.delete(listener);
+      if (deleted && info) {
+        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          subscriberCountByModule.delete(info.moduleInstanceKey);
+        } else {
+          subscriberCountByModule.set(info.moduleInstanceKey, next);
+        }
+      }
+      if (current.size === 0) {
+        listenersByTopic.delete(topicKey);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.size ?? 0;
+  const getModuleSubscriberCount = (moduleInstanceKey) => subscriberCountByModule.get(moduleInstanceKey) ?? 0;
+  const registerModuleInstance = (args) => {
+    moduleStates.set(args.moduleInstanceKey, args.initialState);
+    if (!topicVersions.has(args.moduleInstanceKey)) {
+      topicVersions.set(args.moduleInstanceKey, 0);
+      topicPriorities.set(args.moduleInstanceKey, "normal");
+    }
+  };
+  const unregisterModuleInstance = (moduleInstanceKey) => {
+    moduleStates.delete(moduleInstanceKey);
+  };
+  const commitTick = (args) => {
+    tickSeq = args.tickSeq;
+    for (const [key, commit] of args.accepted.modules) {
+      moduleStates.set(key, commit.state);
+    }
+    const changedTopics = /* @__PURE__ */ new Map();
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners2 = Array.from(listenersByTopic.get(topicKey) ?? []);
+      if (listeners2.length > 0) {
+        changedTopics.set(topicKey, { priority, listeners: listeners2 });
+      }
+    }
+    return { changedTopics };
+  };
+  const getModuleState = (moduleInstanceKey) => moduleStates.get(moduleInstanceKey);
+  const dispose = () => {
+    moduleStates.clear();
+    topicVersions.clear();
+    topicPriorities.clear();
+    listenersByTopic.clear();
+    subscriberCountByModule.clear();
+  };
+  return {
+    getTickSeq: () => tickSeq,
+    getModuleState,
+    getTopicVersion,
+    getTopicPriority,
+    subscribeTopic,
+    getTopicSubscriberCount,
+    getModuleSubscriberCount,
+    registerModuleInstance,
+    unregisterModuleInstance,
+    commitTick,
+    dispose
+  };
+};
+
+// src/internal/runtime/core/TickScheduler.ts
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/TaskRunner.ts
 var import_effect6 = require("effect");
+var inSyncTransactionFiber = import_effect6.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect6.FiberRef.unsafeMake(false);
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect8 = require("effect");
+var makeDeclarativeLinkRuntime = () => {
+  const moduleAsSourceById = /* @__PURE__ */ new Map();
+  const moduleAsSourceIdsBySource = /* @__PURE__ */ new Map();
+  const declarativeById = /* @__PURE__ */ new Map();
+  const declarativeReadNodesBySource = /* @__PURE__ */ new Map();
+  const registerModuleAsSourceLink = (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_effect8.Effect.gen(function* () {
+    let scheduled = false;
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const ids = moduleAsSourceIdsBySource.get(sourceKey);
+      if (!ids || ids.size === 0) continue;
+      const commit = args.acceptedModules.get(sourceKey);
+      if (!commit) continue;
+      for (const id of ids) {
+        const 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;
@@ -1549,17 +2047,40 @@ var getNodeEnv = () => {
   }
 };
 var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+var StateTransactionConfigTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/ReplayModeConfig")() {
 };
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var StateTransactionOverridesTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
 };
-var ReplayModeConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var ConcurrencyPolicyTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
 };
-var StateTransactionOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var RuntimeStoreTag = class extends import_effect9.Context.Tag("@logixjs/core/RuntimeStore")() {
 };
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var runtimeStoreLayer = import_effect9.Layer.scoped(
+  RuntimeStoreTag,
+  import_effect9.Effect.acquireRelease(
+    import_effect9.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect9.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect9.Context.Tag("@logixjs/core/HostScheduler")() {
+};
+var hostSchedulerLayer = import_effect9.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect9.Context.Tag("@logixjs/core/DeclarativeLinkRuntime")() {
+};
+var declarativeLinkRuntimeLayer = import_effect9.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect9.Context.Tag("@logixjs/core/TickScheduler")() {
 };
 
 // src/internal/debug/ModuleTraitsRegistry.ts
@@ -1629,13 +2150,13 @@ var startDevtoolsRun2 = startDevtoolsRun;
 var setInstanceLabel2 = setInstanceLabel;
 var getInstanceLabel2 = getInstanceLabel;
 var exportEvidencePackage2 = (options) => exportDevtoolsEvidencePackage(options);
-var diagnosticsLevel = (level) => import_effect7.Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
+var diagnosticsLevel = (level) => import_effect10.Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
 var traitConvergeDiagnosticsSampling2 = (config) => traitConvergeDiagnosticsSampling(config);
 var isDevtoolsEnabled2 = isDevtoolsEnabled;
 var makeModuleRuntimeCounterSink = () => {
   const counts = /* @__PURE__ */ new Map();
   const sink = {
-    record: (event) => import_effect7.Effect.sync(() => {
+    record: (event) => import_effect10.Effect.sync(() => {
       if (event.type === "module:init") {
         const moduleId = event.moduleId ?? "unknown";
         const runtimeLabel2 = "runtimeLabel" in event && event.runtimeLabel ? event.runtimeLabel : "unknown";
@@ -1664,7 +2185,7 @@ var makeModuleRuntimeCounterSink = () => {
 var makeRingBufferSink = (capacity = 1e3) => {
   const buffer = [];
   const sink = {
-    record: (event) => import_effect7.Effect.sync(() => {
+    record: (event) => import_effect10.Effect.sync(() => {
       if (capacity <= 0) {
         return;
       }
@@ -1704,21 +2225,21 @@ var layer = (options) => {
       }
     }
   })();
-  return diagnostics ? import_effect7.Layer.mergeAll(sinks, diagnosticsLevel(diagnostics)) : sinks;
+  return diagnostics ? import_effect10.Layer.mergeAll(sinks, diagnosticsLevel(diagnostics)) : sinks;
 };
-var withPrettyLogger = (base, options) => import_effect7.Layer.merge(
+var withPrettyLogger = (base, options) => import_effect10.Layer.merge(
   base,
-  import_effect7.Logger.replace(import_effect7.Logger.defaultLogger, import_effect7.Logger.prettyLogger(options))
+  import_effect10.Logger.replace(import_effect10.Logger.defaultLogger, import_effect10.Logger.prettyLogger(options))
 );
-var replace = (sinks) => import_effect7.Layer.locallyScoped(internal.currentDebugSinks, sinks);
-var appendSinks = (sinks) => import_effect7.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [
+var replace = (sinks) => import_effect10.Layer.locallyScoped(internal.currentDebugSinks, sinks);
+var appendSinks = (sinks) => import_effect10.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [
   ...current,
   ...sinks
 ]);
 function devtoolsHubLayer(baseOrOptions, maybeOptions) {
   const isLayerValue = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
   const hasBase = isLayerValue(baseOrOptions);
-  const base = hasBase ? baseOrOptions : import_effect7.Layer.empty;
+  const base = hasBase ? baseOrOptions : import_effect10.Layer.empty;
   const options = hasBase ? maybeOptions : baseOrOptions;
   configureDevtoolsHub(options);
   const append = appendSinks([devtoolsHubSink]);
@@ -1726,13 +2247,13 @@ function devtoolsHubLayer(baseOrOptions, maybeOptions) {
     devtoolsHubConvergeStaticIrCollector
   ]);
   const enableExportableDiagnostics = diagnosticsLevel(options?.diagnosticsLevel ?? "light");
-  const convergeSamplingLayer = options?.traitConvergeDiagnosticsSampling ? traitConvergeDiagnosticsSampling2(options.traitConvergeDiagnosticsSampling) : import_effect7.Layer.empty;
-  return import_effect7.Layer.provideMerge(
-    import_effect7.Layer.mergeAll(append, enableExportableDiagnostics, convergeSamplingLayer, appendConvergeStaticIr),
+  const convergeSamplingLayer = options?.traitConvergeDiagnosticsSampling ? traitConvergeDiagnosticsSampling2(options.traitConvergeDiagnosticsSampling) : import_effect10.Layer.empty;
+  return import_effect10.Layer.provideMerge(
+    import_effect10.Layer.mergeAll(append, enableExportableDiagnostics, convergeSamplingLayer, appendConvergeStaticIr),
     base
   );
 }
-var runtimeLabel = (label) => import_effect7.Layer.fiberRefLocallyScopedWith(internal.currentRuntimeLabel, () => label);
+var runtimeLabel = (label) => import_effect10.Layer.fiberRefLocallyScopedWith(internal.currentRuntimeLabel, () => label);
 var getModuleTraits = (module2) => {
   const moduleTag = module2.tag ? module2.tag : module2;
   const program = getModuleTraitsProgram(moduleTag);
@@ -1777,13 +2298,13 @@ var getModuleFinalTraits = (runtime) => {
 var isLayer = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
 function traceLayer(baseOrHandler, maybeOnTrace) {
   const hasBase = isLayer(baseOrHandler);
-  const base = hasBase ? baseOrHandler : import_effect7.Layer.empty;
+  const base = hasBase ? baseOrHandler : import_effect10.Layer.empty;
   const onTrace = hasBase ? maybeOnTrace : baseOrHandler;
   const traceSink = {
-    record: (event) => typeof event.type === "string" && event.type.startsWith("trace:") ? onTrace ? onTrace(event) : import_effect7.Effect.logDebug({ traceEvent: event }) : import_effect7.Effect.void
+    record: (event) => typeof event.type === "string" && event.type.startsWith("trace:") ? onTrace ? onTrace(event) : import_effect10.Effect.logDebug({ traceEvent: event }) : import_effect10.Effect.void
   };
-  const appendTrace = import_effect7.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (sinks) => [...sinks, traceSink]);
-  return import_effect7.Layer.provideMerge(appendTrace, base);
+  const appendTrace = import_effect10.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (sinks) => [...sinks, traceSink]);
+  return import_effect10.Layer.provideMerge(appendTrace, base);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {