@logixjs/core 0.0.1 → 1.0.0

package/dist/Debug.cjs

@@ -23,10 +23,12 @@ __export(Debug_exports, {
   appendSinks: () => appendSinks,
   clearDevtoolsEvents: () => clearDevtoolsEvents2,
   devtoolsHubLayer: () => devtoolsHubLayer,
-  diagnosticsLevel: () => diagnosticsLevel,
+  diagnosticsLevel: () => diagnosticsLevel2,
+  diagnosticsMaterialization: () => diagnosticsMaterialization2,
   exportEvidencePackage: () => exportEvidencePackage2,
   getDevtoolsRunId: () => getDevtoolsRunId2,
   getDevtoolsSnapshot: () => getDevtoolsSnapshot2,
+  getDevtoolsSnapshotByRuntimeLabel: () => getDevtoolsSnapshotByRuntimeLabel2,
   getDevtoolsSnapshotToken: () => getDevtoolsSnapshotToken2,
   getInstanceLabel: () => getInstanceLabel2,
   getModuleFinalTraits: () => getModuleFinalTraits,
@@ -48,13 +50,14 @@ __export(Debug_exports, {
   subscribeDevtoolsSnapshot: () => subscribeDevtoolsSnapshot2,
   toRuntimeDebugEventRef: () => toRuntimeDebugEventRef2,
   traceLayer: () => traceLayer,
+  traceMode: () => traceMode2,
   traitConvergeDiagnosticsSampling: () => traitConvergeDiagnosticsSampling2,
   withPrettyLogger: () => withPrettyLogger
 });
 module.exports = __toCommonJS(Debug_exports);
-var import_effect7 = require("effect");
+var import_effect12 = 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 +149,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 +162,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;
 };
@@ -239,7 +243,7 @@ var getMessageFromUnknown = (cause) => {
     return cause.message;
   }
   try {
-    const pretty = import_effect.Cause.pretty(cause, { renderErrorCause: true });
+    const pretty = import_effect.Cause.pretty(cause);
     if (typeof pretty === "string" && pretty.length > 0) return pretty;
   } catch {
   }
@@ -293,21 +297,50 @@ var toSerializableErrorSummary = (cause, options) => {
 
 // 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 traitConvergeDiagnosticsSampling = (config) => import_effect3.Layer.fiberRefLocallyScopedWith(currentTraitConvergeDiagnosticsSampling, () => config);
+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 diagnosticsLevel = (level) => import_effect3.Layer.succeed(currentDiagnosticsLevel, level);
+var currentDiagnosticsMaterialization = import_effect3.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentDiagnosticsMaterialization",
+  {
+    defaultValue: () => "eager"
+  }
+);
+var diagnosticsMaterialization = (mode) => import_effect3.Layer.succeed(currentDiagnosticsMaterialization, mode);
+var currentTraceMode = import_effect3.ServiceMap.Reference("@logixjs/core/Debug.currentTraceMode", {
+  defaultValue: () => "on"
+});
+var traceMode = (mode) => import_effect3.Layer.succeed(currentTraceMode, mode);
+var currentTraitConvergeDiagnosticsSampling = import_effect3.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentTraitConvergeDiagnosticsSampling",
+  {
+    defaultValue: () => ({
+      sampleEveryN: 32,
+      topK: 3
+    })
+  }
+);
+var traitConvergeDiagnosticsSampling = (config) => import_effect3.Layer.succeed(currentTraitConvergeDiagnosticsSampling, config);
 var nextGlobalEventSeq = 0;
 var clearRuntimeDebugEventSeq = () => {
   nextGlobalEventSeq = 0;
@@ -322,8 +355,89 @@ var mergeDowngrade2 = (current, next) => {
   if (!next) return current;
   if (current === "non_serializable" || next === "non_serializable") return "non_serializable";
   if (current === "oversized" || next === "oversized") return "oversized";
+  if (current === "budget_exceeded" || next === "budget_exceeded") return "budget_exceeded";
   return "unknown";
 };
+var stripDirtyRootPaths = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const { rootPaths, ...rest } = value;
+  return rest;
+};
+var stripTraitConvergeLegacyFields = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const anyValue = value;
+  const { dirtyRoots, ...rest } = anyValue;
+  const dirty = rest.dirty;
+  if (!dirty || typeof dirty !== "object" || Array.isArray(dirty)) {
+    return rest;
+  }
+  return {
+    ...rest,
+    dirty: stripDirtyRootPaths(dirty)
+  };
+};
+var stripTraitConvergeLight = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const anyValue = value;
+  const dirty = anyValue.dirty;
+  const dirtySlim = dirty && typeof dirty === "object" && !Array.isArray(dirty) ? {
+    dirtyAll: dirty.dirtyAll,
+    ...typeof dirty.reason === "string" ? { reason: dirty.reason } : null,
+    ...Array.isArray(dirty.rootIds) ? { rootIds: dirty.rootIds } : null,
+    ...typeof dirty.rootIdsTruncated === "boolean" ? { rootIdsTruncated: dirty.rootIdsTruncated } : null
+  } : void 0;
+  const { top3, dirtyRoots, ...rest } = anyValue;
+  return dirtySlim ? { ...rest, dirty: dirtySlim } : rest;
+};
+var stripTraitConvergeSampled = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const anyValue = value;
+  const dirty = anyValue.dirty;
+  const dirtySlim = dirty && typeof dirty === "object" && !Array.isArray(dirty) ? {
+    dirtyAll: dirty.dirtyAll,
+    ...typeof dirty.reason === "string" ? { reason: dirty.reason } : null
+  } : void 0;
+  const { dirtyRoots, ...rest } = anyValue;
+  return dirtySlim ? { ...rest, dirty: dirtySlim } : rest;
+};
+var stripTraitCheckLight = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const anyValue = value;
+  const degraded = anyValue.degraded;
+  const degradedSlim = degraded && typeof degraded === "object" && !Array.isArray(degraded) ? { kind: degraded.kind } : void 0;
+  const summary = anyValue.summary;
+  let summarySlim;
+  if (summary && typeof summary === "object" && !Array.isArray(summary)) {
+    const candidate = {};
+    let hasSummaryField = false;
+    if (typeof summary.scannedRows === "number") {
+      candidate.scannedRows = summary.scannedRows;
+      hasSummaryField = true;
+    }
+    if (typeof summary.affectedRows === "number") {
+      candidate.affectedRows = summary.affectedRows;
+      hasSummaryField = true;
+    }
+    if (typeof summary.changedRows === "number") {
+      candidate.changedRows = summary.changedRows;
+      hasSummaryField = true;
+    }
+    if (hasSummaryField) {
+      summarySlim = candidate;
+    }
+  }
+  const slim = {};
+  if (typeof anyValue.ruleId === "string") slim.ruleId = anyValue.ruleId;
+  if (Array.isArray(anyValue.scopeFieldPath)) slim.scopeFieldPath = anyValue.scopeFieldPath;
+  if (typeof anyValue.mode === "string") slim.mode = anyValue.mode;
+  if (anyValue.trigger && typeof anyValue.trigger === "object" && !Array.isArray(anyValue.trigger)) {
+    slim.trigger = anyValue.trigger;
+  }
+  if (typeof anyValue.rowIdMode === "string") slim.rowIdMode = anyValue.rowIdMode;
+  if (summarySlim) slim.summary = summarySlim;
+  if (degradedSlim) slim.degraded = degradedSlim;
+  return slim;
+};
 var browserLifecycleSeen = /* @__PURE__ */ new Set();
 var browserDiagnosticSeen = /* @__PURE__ */ new Set();
 var lastTxnByInstance = /* @__PURE__ */ new Map();
@@ -360,9 +474,7 @@ 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);
@@ -403,16 +515,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:")) {
@@ -438,7 +550,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);
@@ -504,7 +616,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) {
@@ -513,36 +625,33 @@ 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.FiberRef.get(currentDebugSinks);
+  const sinks = yield* import_effect3.Effect.service(currentDebugSinks);
   if (isErrorOnlyOnlySinks(sinks)) {
     if (event.type === "lifecycle:error") {
       yield* lifecycleErrorLog(event);
       return;
     }
-    if (event.type === "diagnostic") {
-      if (event.severity !== "info") {
-        yield* diagnosticLog(event);
-      } else {
-        yield* import_effect3.Effect.void;
-      }
-      return;
+    if (event.type === "diagnostic" && event.severity !== "info") {
+      yield* diagnosticLog(event);
     }
-    yield* import_effect3.Effect.void;
     return;
   }
   if (sinks.length === 0) {
     if (isBrowser) {
       if (event.type === "lifecycle:error" || event.type === "diagnostic") {
         yield* renderBrowserConsoleEvent(event);
-        return;
       }
-      yield* import_effect3.Effect.void;
       return;
     }
     if (event.type === "lifecycle:error") {
@@ -551,41 +660,43 @@ var record = (event) => import_effect3.Effect.gen(function* () {
     }
     if (event.type === "diagnostic") {
       yield* diagnosticLog(event);
-      return;
     }
-    yield* import_effect3.Effect.void;
     return;
   }
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const mode = yield* import_effect3.Effect.service(currentTraceMode);
+    if (mode === "off") return;
+  }
   const enriched = event;
-  const diagnosticsLevel2 = yield* import_effect3.FiberRef.get(currentDiagnosticsLevel);
+  const diagnosticsLevel3 = yield* import_effect3.Effect.service(currentDiagnosticsLevel);
   let now;
   const getNow = () => {
     if (now === void 0) now = Date.now();
     return now;
   };
-  if (enriched.timestamp === void 0 && (diagnosticsLevel2 !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
+  if (enriched.timestamp === void 0 && (diagnosticsLevel3 !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
     ;
     enriched.timestamp = getNow();
   }
-  if (diagnosticsLevel2 !== "off" && enriched.runtimeLabel === void 0) {
-    const runtimeLabel2 = yield* import_effect3.FiberRef.get(currentRuntimeLabel);
+  if (diagnosticsLevel3 !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel2 = yield* import_effect3.Effect.service(currentRuntimeLabel);
     if (runtimeLabel2) {
       ;
       enriched.runtimeLabel = runtimeLabel2;
     }
   }
   if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
-    const txnId = yield* import_effect3.FiberRef.get(currentTxnId);
+    const txnId = yield* import_effect3.Effect.service(currentTxnId);
     if (txnId) {
       ;
       enriched.txnId = txnId;
     }
   }
-  if (diagnosticsLevel2 !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
-    const linkId = yield* import_effect3.FiberRef.get(currentLinkId);
-    if (linkId) {
+  if (diagnosticsLevel3 !== "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 = linkId;
+      enriched.linkId = maybeLinkId.value;
     }
   }
   if (sinks.length === 1) {
@@ -595,11 +706,13 @@ var record = (event) => import_effect3.Effect.gen(function* () {
   yield* import_effect3.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
 });
 var toRuntimeDebugEventRef = (event, options) => {
-  const diagnosticsLevel2 = options?.diagnosticsLevel ?? "full";
-  if (diagnosticsLevel2 === "off") {
+  const diagnosticsLevel3 = options?.diagnosticsLevel ?? "full";
+  if (diagnosticsLevel3 === "off") {
     return void 0;
   }
-  const isLightLike = diagnosticsLevel2 === "light" || diagnosticsLevel2 === "sampled";
+  const isLightLike = diagnosticsLevel3 === "light" || diagnosticsLevel3 === "sampled";
+  const materialization = options?.materialization ?? "eager";
+  const isLazyMaterialization = materialization === "lazy";
   const timestamp = typeof event.timestamp === "number" && Number.isFinite(event.timestamp) ? event.timestamp : Date.now();
   const moduleIdRaw = event.moduleId;
   const moduleId = typeof moduleIdRaw === "string" && moduleIdRaw.length > 0 ? moduleIdRaw : "unknown";
@@ -697,63 +810,23 @@ var toRuntimeDebugEventRef = (event, options) => {
     }
     case "state:update": {
       const e = event;
-      const resolveDirtySetRootPaths = () => {
-        const resolve = options?.resolveConvergeStaticIr;
-        if (!resolve) return void 0;
-        const digest = e.staticIrDigest;
-        if (typeof digest !== "string" || digest.length === 0) return void 0;
-        const dirtySet = e.dirtySet;
-        if (!dirtySet || typeof dirtySet !== "object" || Array.isArray(dirtySet)) return void 0;
-        const rootIds = dirtySet.rootIds;
-        if (!Array.isArray(rootIds) || rootIds.length === 0) return void 0;
-        const ir = resolve(digest);
-        const fieldPaths = ir?.fieldPaths;
-        if (!Array.isArray(fieldPaths) || fieldPaths.length === 0) return void 0;
-        const out = [];
-        for (const rawId of rootIds) {
-          if (typeof rawId !== "number" || !Number.isFinite(rawId)) continue;
-          const id = Math.floor(rawId);
-          if (id < 0) continue;
-          const path = fieldPaths[id];
-          if (!Array.isArray(path) || path.length === 0) continue;
-          if (!path.every((seg) => typeof seg === "string" && seg.length > 0)) continue;
-          out.push(path);
-        }
-        return out.length > 0 ? out : void 0;
-      };
-      const dirtySetWithRootPaths = (() => {
-        const rootPaths = resolveDirtySetRootPaths();
-        if (!rootPaths) return e.dirtySet;
-        const dirtySet = e.dirtySet;
-        if (!dirtySet || typeof dirtySet !== "object" || Array.isArray(dirtySet)) return e.dirtySet;
-        return { ...dirtySet, rootPaths };
-      })();
-      const metaInput = isLightLike ? {
-        state: e.state,
-        dirtySet: dirtySetWithRootPaths,
-        patchCount: e.patchCount,
-        patchesTruncated: e.patchesTruncated,
-        patchesTruncatedReason: e.patchesTruncatedReason,
-        staticIrDigest: e.staticIrDigest,
-        commitMode: e.commitMode,
-        priority: e.priority,
-        originKind: e.originKind,
-        originName: e.originName
-      } : {
-        state: e.state,
-        dirtySet: dirtySetWithRootPaths,
-        patchCount: e.patchCount,
-        patchesTruncated: e.patchesTruncated,
-        patchesTruncatedReason: e.patchesTruncatedReason,
-        staticIrDigest: e.staticIrDigest,
-        commitMode: e.commitMode,
-        priority: e.priority,
-        originKind: e.originKind,
-        originName: e.originName,
-        traitSummary: e.traitSummary,
-        replayEvent: e.replayEvent
-      };
-      const metaProjection = projectJsonValue(metaInput);
+      const dirtySetCanonical = stripDirtyRootPaths(e.dirtySet);
+      const slimMetaInput = {};
+      if (dirtySetCanonical !== void 0) slimMetaInput.dirtySet = dirtySetCanonical;
+      if (e.patchCount !== void 0) slimMetaInput.patchCount = e.patchCount;
+      if (e.patchesTruncated !== void 0) slimMetaInput.patchesTruncated = e.patchesTruncated;
+      if (e.patchesTruncatedReason !== void 0) slimMetaInput.patchesTruncatedReason = e.patchesTruncatedReason;
+      if (e.staticIrDigest !== void 0) slimMetaInput.staticIrDigest = e.staticIrDigest;
+      if (e.commitMode !== void 0) slimMetaInput.commitMode = e.commitMode;
+      if (e.priority !== void 0) slimMetaInput.priority = e.priority;
+      if (e.originKind !== void 0) slimMetaInput.originKind = e.originKind;
+      if (e.originName !== void 0) slimMetaInput.originName = e.originName;
+      const metaInput = isLightLike ? isLazyMaterialization ? slimMetaInput : { state: e.state, ...slimMetaInput } : isLazyMaterialization ? slimMetaInput : { state: e.state, ...slimMetaInput, traitSummary: e.traitSummary, replayEvent: e.replayEvent };
+      const metaProjection = isLazyMaterialization ? {
+        value: metaInput,
+        stats: { dropped: 0, oversized: 0, nonSerializable: 0 },
+        downgrade: void 0
+      } : projectJsonValue(metaInput);
       options?.onMetaProjection?.({
         stats: metaProjection.stats,
         downgrade: metaProjection.downgrade
@@ -785,7 +858,9 @@ var toRuntimeDebugEventRef = (event, options) => {
         timestampMs: e.timestampMs,
         trigger: e.trigger,
         dispatch: e.dispatch,
-        error: e.error
+        error: e.error,
+        budgetEnvelope: e.budgetEnvelope,
+        degrade: e.degrade
       };
       const metaProjection = projectJsonValue(metaInput);
       options?.onMetaProjection?.({
@@ -793,6 +868,17 @@ var toRuntimeDebugEventRef = (event, options) => {
         downgrade: metaProjection.downgrade
       });
       downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      const processDegradeReason = (() => {
+        const marker = e.degrade;
+        if (!marker || typeof marker !== "object" || Array.isArray(marker)) return void 0;
+        if (marker.degraded !== true) return void 0;
+        const reason = marker.reason;
+        if (reason === "budget_exceeded") return "budget_exceeded";
+        if (reason === "payload_oversized") return "oversized";
+        if (reason === "payload_non_serializable") return "non_serializable";
+        return "unknown";
+      })();
+      downgrade = mergeDowngrade2(downgrade, processDegradeReason);
       const errorSummary = e.type === "process:error" || e.type === "process:restart" ? e.error : void 0;
       return withDowngrade({
         ...base,
@@ -840,6 +926,7 @@ var toRuntimeDebugEventRef = (event, options) => {
         hint: e.hint,
         actionTag: e.actionTag,
         kind: e.kind,
+        opSeq: e.opSeq,
         trigger: e.trigger
       };
       const metaProjection = projectJsonValue(metaInput);
@@ -855,10 +942,103 @@ 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:devtools:ring-trim-policy") {
+        const data = event.data;
+        const metaInput = {
+          mode: data?.mode,
+          threshold: data?.threshold,
+          bufferSize: data?.bufferSize
+        };
+        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: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;
@@ -876,6 +1056,55 @@ var toRuntimeDebugEventRef = (event, options) => {
           meta: metaProjection2.value
         });
       }
+      if (event.type === "trace:txn-phase") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          kind: data?.kind,
+          originKind: data?.originKind,
+          originName: data?.originName,
+          commitMode: data?.commitMode,
+          priority: data?.priority,
+          txnPreludeMs: data?.txnPreludeMs,
+          queue: data?.queue ? {
+            lane: data.queue.lane,
+            contextLookupMs: data.queue.contextLookupMs,
+            resolvePolicyMs: data.queue.resolvePolicyMs,
+            backpressureMs: data.queue.backpressureMs,
+            enqueueBookkeepingMs: data.queue.enqueueBookkeepingMs,
+            queueWaitMs: data.queue.queueWaitMs,
+            startHandoffMs: data.queue.startHandoffMs,
+            startMode: data.queue.startMode
+          } : void 0,
+          dispatchActionRecordMs: data?.dispatchActionRecordMs,
+          dispatchActionCommitHubMs: data?.dispatchActionCommitHubMs,
+          dispatchActionCount: data?.dispatchActionCount,
+          bodyShellMs: data?.bodyShellMs,
+          asyncEscapeGuardMs: data?.asyncEscapeGuardMs,
+          traitConvergeMs: data?.traitConvergeMs,
+          scopedValidateMs: data?.scopedValidateMs,
+          sourceSyncMs: data?.sourceSyncMs,
+          commit: data?.commit ? {
+            totalMs: data.commit.totalMs,
+            rowIdSyncMs: data.commit.rowIdSyncMs,
+            publishCommitMs: data.commit.publishCommitMs,
+            stateUpdateDebugRecordMs: data.commit.stateUpdateDebugRecordMs,
+            onCommitBeforeStateUpdateMs: data.commit.onCommitBeforeStateUpdateMs,
+            onCommitAfterStateUpdateMs: data.commit.onCommitAfterStateUpdateMs
+          } : void 0
+        } : 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:react-render" || event.type === "trace:react-selector") {
         const data = event.data;
         const metaProjection2 = projectJsonValue(
@@ -980,77 +1209,8 @@ var toRuntimeDebugEventRef = (event, options) => {
         });
       }
       if (event.type === "trace:trait:converge") {
-        const resolveDirtyRootPaths = (args) => {
-          const resolve = options?.resolveConvergeStaticIr;
-          if (!resolve) return void 0;
-          const digest = args.staticIrDigest;
-          if (typeof digest !== "string" || digest.length === 0) return void 0;
-          const rootIds = args.rootIds;
-          if (!Array.isArray(rootIds) || rootIds.length === 0) return void 0;
-          const ir = resolve(digest);
-          const fieldPaths = ir?.fieldPaths;
-          if (!Array.isArray(fieldPaths) || fieldPaths.length === 0) return void 0;
-          const out = [];
-          for (const id of rootIds) {
-            if (typeof id !== "number" || !Number.isFinite(id)) continue;
-            const idx = Math.floor(id);
-            if (idx < 0 || idx >= fieldPaths.length) continue;
-            const path = fieldPaths[idx];
-            if (Array.isArray(path)) {
-              out.push(path);
-            }
-          }
-          return out.length > 0 ? out : void 0;
-        };
-        const enrichDirtyRootPaths = (value) => {
-          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-          const anyValue = value;
-          const dirty = anyValue.dirty;
-          if (!dirty || typeof dirty !== "object" || Array.isArray(dirty)) return value;
-          const dirtyRootPaths = resolveDirtyRootPaths({
-            staticIrDigest: anyValue.staticIrDigest,
-            rootIds: dirty?.rootIds
-          });
-          if (!dirtyRootPaths) return value;
-          return {
-            ...anyValue,
-            dirty: {
-              ...dirty,
-              rootPaths: dirtyRootPaths
-            }
-          };
-        };
-        const stripHeavyLight = (value) => {
-          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-          const anyValue = value;
-          const dirty = anyValue.dirty;
-          const dirtyRootPaths = resolveDirtyRootPaths({
-            staticIrDigest: anyValue.staticIrDigest,
-            rootIds: dirty?.rootIds
-          });
-          const dirtySlim = dirty && typeof dirty === "object" && !Array.isArray(dirty) ? {
-            dirtyAll: dirty.dirtyAll,
-            ...typeof dirty.reason === "string" ? { reason: dirty.reason } : null,
-            ...Array.isArray(dirty.rootIds) ? { rootIds: dirty.rootIds } : null,
-            ...typeof dirty.rootIdsTruncated === "boolean" ? { rootIdsTruncated: dirty.rootIdsTruncated } : null,
-            ...dirtyRootPaths ? { rootPaths: dirtyRootPaths } : null
-          } : void 0;
-          const { top3, dirtyRoots, ...rest } = anyValue;
-          return dirtySlim ? { ...rest, dirty: dirtySlim } : rest;
-        };
-        const stripHeavySampled = (value) => {
-          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-          const anyValue = value;
-          const dirty = anyValue.dirty;
-          const dirtySlim = dirty && typeof dirty === "object" && !Array.isArray(dirty) ? {
-            dirtyAll: dirty.dirtyAll,
-            ...typeof dirty.reason === "string" ? { reason: dirty.reason } : null
-          } : void 0;
-          const { dirtyRoots, ...rest } = anyValue;
-          return dirtySlim ? { ...rest, dirty: dirtySlim } : rest;
-        };
         const data = event.data;
-        const metaInput = diagnosticsLevel2 === "light" ? stripHeavyLight(data) : diagnosticsLevel2 === "sampled" ? stripHeavySampled(data) : enrichDirtyRootPaths(data);
+        const metaInput = diagnosticsLevel3 === "light" ? stripTraitConvergeLight(data) : diagnosticsLevel3 === "sampled" ? stripTraitConvergeSampled(data) : stripTraitConvergeLegacyFields(data);
         const metaProjection2 = projectJsonValue(metaInput);
         options?.onMetaProjection?.({
           stats: metaProjection2.stats,
@@ -1065,16 +1225,8 @@ var toRuntimeDebugEventRef = (event, options) => {
         });
       }
       if (event.type === "trace:trait:check") {
-        const stripHeavy = (value) => {
-          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-          const anyValue = value;
-          const degraded = anyValue.degraded;
-          const degradedSlim = degraded && typeof degraded === "object" && !Array.isArray(degraded) ? { kind: degraded.kind } : void 0;
-          const { degraded: _degraded, ...rest } = anyValue;
-          return degradedSlim ? { ...rest, degraded: degradedSlim } : rest;
-        };
         const data = event.data;
-        const metaInput = isLightLike ? stripHeavy(data) : data;
+        const metaInput = isLightLike ? stripTraitCheckLight(data) : data;
         const metaProjection2 = projectJsonValue(metaInput);
         options?.onMetaProjection?.({
           stats: metaProjection2.stats,
@@ -1244,17 +1396,294 @@ 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();
-var latestTraitSummaries = /* @__PURE__ */ new Map();
 var instanceLabels = /* @__PURE__ */ new Map();
 var convergeStaticIrByDigest = /* @__PURE__ */ new Map();
-var liveInstanceKeys = /* @__PURE__ */ new Set();
+var toCapacity = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  const n = Math.floor(value);
+  return n > 0 ? n : 0;
+};
+var makeEventRing = (capacity) => {
+  const cap = toCapacity(capacity);
+  return {
+    capacity: cap,
+    start: 0,
+    size: 0,
+    data: cap > 0 ? new Array(cap) : [],
+    view: [],
+    dirty: true
+  };
+};
+var clearEventRing = (ring) => {
+  ring.start = 0;
+  ring.size = 0;
+  ring.data = ring.capacity > 0 ? new Array(ring.capacity) : [];
+  ring.view.length = 0;
+  ring.dirty = true;
+};
+var pushEventRing = (ring, ref) => {
+  const cap = ring.capacity;
+  if (cap <= 0) return;
+  if (ring.size < cap) {
+    ring.data[(ring.start + ring.size) % cap] = ref;
+    ring.size += 1;
+  } else {
+    ring.data[ring.start] = ref;
+    ring.start = (ring.start + 1) % cap;
+  }
+  ring.dirty = true;
+};
+var getEventRingView = (ring) => {
+  if (!ring.dirty) return ring.view;
+  const cap = ring.capacity;
+  const size = ring.size;
+  const out = ring.view;
+  out.length = size;
+  if (cap <= 0 || size === 0) {
+    ring.dirty = false;
+    return out;
+  }
+  const start = ring.start;
+  const data = ring.data;
+  for (let i = 0; i < size; i++) {
+    out[i] = data[(start + i) % cap];
+  }
+  ring.dirty = false;
+  return out;
+};
+var resizeEventRing = (ring, capacity) => {
+  const cap = toCapacity(capacity);
+  if (cap === ring.capacity) return;
+  const snapshot = getEventRingView(ring);
+  const keepStart = cap <= 0 ? snapshot.length : Math.max(0, snapshot.length - cap);
+  const keep = [];
+  for (let i = keepStart; i < snapshot.length; i++) {
+    keep.push(snapshot[i]);
+  }
+  ring.capacity = cap;
+  ring.start = 0;
+  ring.size = 0;
+  ring.data = cap > 0 ? new Array(cap) : [];
+  ring.view.length = 0;
+  ring.dirty = true;
+  for (let i = 0; i < keep.length; i++) {
+    pushEventRing(ring, keep[i]);
+  }
+};
+var rebuildEventRingFromOrdered = (ring, ordered) => {
+  clearEventRing(ring);
+  for (let i = 0; i < ordered.length; i++) {
+    pushEventRing(ring, ordered[i]);
+  }
+};
+var runtimeBuckets = /* @__PURE__ */ new Map();
+var getRuntimeBucket = (runtimeLabel2) => runtimeBuckets.get(runtimeLabel2);
+var getOrCreateRuntimeBucket = (runtimeLabel2) => {
+  const existing = runtimeBuckets.get(runtimeLabel2);
+  if (existing) return existing;
+  const created = {
+    runtimeLabel: runtimeLabel2,
+    ring: makeEventRing(bufferSize),
+    latestStates: /* @__PURE__ */ new Map(),
+    latestTraitSummaries: /* @__PURE__ */ new Map(),
+    exportBudget: {
+      dropped: 0,
+      oversized: 0
+    }
+  };
+  runtimeBuckets.set(runtimeLabel2, created);
+  return created;
+};
+var latestStates = /* @__PURE__ */ new Map();
+var latestTraitSummaries = /* @__PURE__ */ new Map();
+var runtimeModules = /* @__PURE__ */ new Map();
+var normalizeKeyPart = (value) => value === void 0 || value === null ? "unknown" : String(value);
+var getRuntimeModuleEntry = (runtimeLabel2, moduleId) => runtimeModules.get(runtimeLabel2)?.get(moduleId);
+var getOrCreateRuntimeModuleEntry = (runtimeLabel2, moduleId) => {
+  let modulesById = runtimeModules.get(runtimeLabel2);
+  if (!modulesById) {
+    modulesById = /* @__PURE__ */ new Map();
+    runtimeModules.set(runtimeLabel2, modulesById);
+  }
+  let moduleEntry = modulesById.get(moduleId);
+  if (!moduleEntry) {
+    moduleEntry = {
+      moduleKey: `${runtimeLabel2}::${moduleId}`,
+      instanceKeyById: /* @__PURE__ */ new Map()
+    };
+    modulesById.set(moduleId, moduleEntry);
+  }
+  return moduleEntry;
+};
+var cleanupRuntimeModuleEntryIfUnused = (runtimeLabel2, moduleId, moduleKey) => {
+  const modulesById = runtimeModules.get(runtimeLabel2);
+  if (!modulesById) return;
+  const moduleEntry = modulesById.get(moduleId);
+  if (!moduleEntry) return;
+  if (moduleEntry.instanceKeyById.size > 0) return;
+  if ((instances.get(moduleKey) ?? 0) > 0) return;
+  modulesById.delete(moduleId);
+  if (modulesById.size === 0) {
+    runtimeModules.delete(runtimeLabel2);
+  }
+};
+var resolveLiveInstanceKey = (runtimeLabel2, moduleId, instanceId) => runtimeModules.get(runtimeLabel2)?.get(moduleId)?.instanceKeyById.get(instanceId);
 var exportBudget = {
   dropped: 0,
   oversized: 0
 };
+var recalculateGlobalExportBudget = () => {
+  let dropped = 0;
+  let oversized = 0;
+  for (const bucket of runtimeBuckets.values()) {
+    dropped += bucket.exportBudget.dropped;
+    oversized += bucket.exportBudget.oversized;
+  }
+  exportBudget.dropped = dropped;
+  exportBudget.oversized = oversized;
+};
 var lastRunTs = 0;
 var lastRunTsSeq = 0;
 var nextRunId = () => {
@@ -1268,43 +1697,99 @@ var nextRunId = () => {
   return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
 };
 var currentRunId = nextRunId();
-var nextSeq = 1;
 var bufferSize = 500;
-var ringBuffer = [];
-var ringBufferSeq = [];
-var snapshotToken = 0;
-var ensureRingBufferSize = () => {
+var globalRing = makeEventRing(bufferSize);
+var ringTrimMode = "strict";
+var ringTrimThreshold = bufferSize;
+var RING_TRIM_POLICY_EVENT_LABEL = "trace:devtools:ring-trim-policy";
+var RING_TRIM_POLICY_MODULE_ID = "devtools:hub";
+var RING_TRIM_POLICY_INSTANCE_ID = "devtools:hub";
+var RING_TRIM_POLICY_RUNTIME_LABEL = "DevtoolsHub";
+var normalizeRuntimeLabel = (runtimeLabel2) => normalizeKeyPart(runtimeLabel2);
+var getRingTrimPolicySnapshot = () => ({
+  mode: ringTrimMode,
+  threshold: ringTrimThreshold,
+  bufferSize
+});
+var refreshRingTrimPolicy = () => {
+  const prevMode = ringTrimMode;
+  const prevThreshold = ringTrimThreshold;
   if (bufferSize <= 0) {
-    ringBuffer.length = 0;
-    ringBufferSeq.length = 0;
-    return;
+    ringTrimMode = "disabled";
+    ringTrimThreshold = 0;
+    return prevMode !== ringTrimMode || prevThreshold !== ringTrimThreshold;
   }
-  if (ringBuffer.length <= bufferSize) return;
-  const excess = ringBuffer.length - bufferSize;
-  ringBuffer.splice(0, excess);
-  ringBufferSeq.splice(0, excess);
+  ringTrimMode = "strict";
+  ringTrimThreshold = bufferSize;
+  return prevMode !== ringTrimMode || prevThreshold !== ringTrimThreshold;
 };
-var trimRingBufferIfNeeded = () => {
-  if (bufferSize <= 0) {
-    ringBuffer.length = 0;
-    ringBufferSeq.length = 0;
-    return;
+refreshRingTrimPolicy();
+var snapshotToken = 0;
+var parseDiagnosticsLevel = (value) => value === "off" || value === "light" || value === "sampled" || value === "full" ? value : "light";
+var appendRuntimeRef = (runtimeLabel2, ref) => {
+  const bucket = getOrCreateRuntimeBucket(runtimeLabel2);
+  pushEventRing(bucket.ring, ref);
+  pushEventRing(globalRing, ref);
+};
+var clearRuntimeBucketEvents = (runtimeLabel2) => {
+  const bucket = getRuntimeBucket(runtimeLabel2);
+  if (!bucket) return false;
+  let changed = false;
+  if (bucket.ring.size > 0) {
+    clearEventRing(bucket.ring);
+    changed = true;
   }
-  if (bufferSize <= 64) {
-    ensureRingBufferSize();
-    return;
+  if (bucket.exportBudget.dropped !== 0 || bucket.exportBudget.oversized !== 0) {
+    bucket.exportBudget.dropped = 0;
+    bucket.exportBudget.oversized = 0;
+    changed = true;
   }
-  const slack = Math.min(1024, Math.floor(bufferSize / 2));
-  const threshold = bufferSize + Math.max(1, slack);
-  if (ringBuffer.length <= threshold) return;
-  const excess = ringBuffer.length - bufferSize;
-  ringBuffer.splice(0, excess);
-  ringBufferSeq.splice(0, excess);
+  if (!changed) return false;
+  const kept = getEventRingView(globalRing).filter((event) => normalizeRuntimeLabel(event.runtimeLabel) !== runtimeLabel2);
+  rebuildEventRingFromOrdered(globalRing, kept);
+  recalculateGlobalExportBudget();
+  return true;
+};
+var clearAllRuntimeBucketEvents = () => {
+  let changed = false;
+  for (const bucket of runtimeBuckets.values()) {
+    if (bucket.ring.size > 0) {
+      clearEventRing(bucket.ring);
+      changed = true;
+    }
+    if (bucket.exportBudget.dropped !== 0 || bucket.exportBudget.oversized !== 0) {
+      bucket.exportBudget.dropped = 0;
+      bucket.exportBudget.oversized = 0;
+      changed = true;
+    }
+  }
+  if (globalRing.size > 0) {
+    clearEventRing(globalRing);
+    changed = true;
+  }
+  recalculateGlobalExportBudget();
+  return changed;
+};
+var emitRingTrimPolicyEvent = (diagnosticsLevel3) => {
+  if (diagnosticsLevel3 === "off") return;
+  if (bufferSize <= 0) return;
+  const ref = toRuntimeDebugEventRef(
+    {
+      type: RING_TRIM_POLICY_EVENT_LABEL,
+      moduleId: RING_TRIM_POLICY_MODULE_ID,
+      instanceId: RING_TRIM_POLICY_INSTANCE_ID,
+      runtimeLabel: RING_TRIM_POLICY_RUNTIME_LABEL,
+      data: getRingTrimPolicySnapshot()
+    },
+    { diagnosticsLevel: diagnosticsLevel3 }
+  );
+  if (!ref) return;
+  appendRuntimeRef(RING_TRIM_POLICY_RUNTIME_LABEL, ref);
 };
 var currentSnapshot = {
   snapshotToken,
   instances,
-  events: ringBuffer,
+  events: globalRing.view,
   latestStates,
   latestTraitSummaries,
   exportBudget
@@ -1312,9 +1797,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();
@@ -1337,14 +1823,43 @@ var configureDevtoolsHub = (options) => {
     const nextBufferSize = next >= 0 ? next : 0;
     if (nextBufferSize !== bufferSize) {
       bufferSize = nextBufferSize;
-      ensureRingBufferSize();
+      const policyChanged = refreshRingTrimPolicy();
+      resizeEventRing(globalRing, bufferSize);
+      for (const bucket of runtimeBuckets.values()) {
+        resizeEventRing(bucket.ring, bufferSize);
+      }
+      if (policyChanged && options?.diagnosticsLevel !== void 0) {
+        emitRingTrimPolicyEvent(parseDiagnosticsLevel(options.diagnosticsLevel));
+      }
       markSnapshotChanged();
     }
   }
 };
 var isDevtoolsEnabled = () => devtoolsEnabled;
-var getDevtoolsSnapshot = () => currentSnapshot;
+var getDevtoolsSnapshot = () => {
+  getEventRingView(globalRing);
+  return currentSnapshot;
+};
 var getDevtoolsSnapshotToken = () => snapshotToken;
+var getDevtoolsSnapshotByRuntimeLabel = (runtimeLabel2) => {
+  const normalizedRuntimeLabel = normalizeRuntimeLabel(runtimeLabel2);
+  const bucket = getRuntimeBucket(normalizedRuntimeLabel);
+  const runtimeInstances = /* @__PURE__ */ new Map();
+  const runtimePrefix = `${normalizedRuntimeLabel}::`;
+  for (const [moduleKey, count] of instances.entries()) {
+    if (moduleKey.startsWith(runtimePrefix)) {
+      runtimeInstances.set(moduleKey, count);
+    }
+  }
+  return {
+    snapshotToken,
+    instances: runtimeInstances,
+    events: bucket ? getEventRingView(bucket.ring) : [],
+    latestStates: bucket?.latestStates ?? /* @__PURE__ */ new Map(),
+    latestTraitSummaries: bucket?.latestTraitSummaries ?? /* @__PURE__ */ new Map(),
+    exportBudget: bucket?.exportBudget ?? { dropped: 0, oversized: 0 }
+  };
+};
 var subscribeDevtoolsSnapshot = (listener) => {
   listeners.add(listener);
   return () => {
@@ -1361,16 +1876,18 @@ var setDevtoolsRunId = (runId) => {
 };
 var startDevtoolsRun = (runId) => {
   currentRunId = typeof runId === "string" && runId.length > 0 ? runId : nextRunId();
-  nextSeq = 1;
   clearRuntimeDebugEventSeq();
   clearDevtoolsEvents();
   return currentRunId;
 };
-var clearDevtoolsEvents = () => {
-  ringBuffer.length = 0;
-  ringBufferSeq.length = 0;
-  exportBudget.dropped = 0;
-  exportBudget.oversized = 0;
+var clearDevtoolsEvents = (runtimeLabel2) => {
+  if (runtimeLabel2 !== void 0) {
+    if (clearRuntimeBucketEvents(normalizeRuntimeLabel(runtimeLabel2))) {
+      markSnapshotChanged();
+    }
+    return;
+  }
+  clearAllRuntimeBucketEvents();
   markSnapshotChanged();
 };
 var setInstanceLabel = (instanceId, label) => {
@@ -1388,37 +1905,46 @@ var exportDevtoolsEvidencePackage = (options) => {
   const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
   const runId = options?.runId ?? currentRunId;
   const source = options?.source ?? { host: "unknown" };
-  const events = ringBuffer.map((payload, i) => ({
+  const refs = getEventRingView(globalRing);
+  const events = refs.map((payload, i) => ({
     protocolVersion,
     runId,
-    seq: ringBufferSeq[i] ?? i + 1,
+    seq: typeof payload.eventSeq === "number" && Number.isFinite(payload.eventSeq) && payload.eventSeq > 0 ? Math.floor(payload.eventSeq) : i + 1,
     timestamp: payload.timestamp,
     type: "debug:event",
     payload
   }));
   const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
   const convergeDigests = /* @__PURE__ */ new Set();
-  let sawFullConverge = false;
-  for (const ref of ringBuffer) {
-    if (ref.kind !== "trait:converge") continue;
-    const meta = ref.meta;
-    if (!isRecord(meta)) continue;
-    const digest = meta.staticIrDigest;
-    if (typeof digest === "string" && digest.length > 0) {
-      convergeDigests.add(digest);
+  const sawFullByDigest = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    const meta = isRecord(ref.meta) ? ref.meta : void 0;
+    if (!meta) continue;
+    if (ref.kind === "trait:converge") {
+      const digest = meta.staticIrDigest;
+      if (typeof digest === "string" && digest.length > 0) {
+        convergeDigests.add(digest);
+        const dirty = meta.dirty;
+        if (isRecord(dirty) && typeof dirty.rootCount === "number") {
+          sawFullByDigest.add(digest);
+        }
+      }
+      continue;
     }
-    const dirty = meta.dirty;
-    if (isRecord(dirty) && typeof dirty.rootCount === "number") {
-      sawFullConverge = true;
+    if (ref.kind === "state" && ref.label === "state:update") {
+      const digest = meta.staticIrDigest;
+      if (typeof digest === "string" && digest.length > 0) {
+        convergeDigests.add(digest);
+      }
     }
   }
   let summary;
-  if (sawFullConverge && convergeDigests.size > 0) {
+  if (convergeDigests.size > 0) {
     const staticIrByDigest = {};
     for (const digest of convergeDigests) {
       const ir = convergeStaticIrByDigest.get(digest);
       if (ir) {
-        staticIrByDigest[digest] = ir;
+        staticIrByDigest[digest] = sawFullByDigest.has(digest) ? ir : { fieldPaths: ir.fieldPaths };
       }
     }
     if (Object.keys(staticIrByDigest).length > 0) {
@@ -1435,7 +1961,9 @@ var exportDevtoolsEvidencePackage = (options) => {
 };
 var devtoolsHubSink = {
   record: (event) => import_effect4.Effect.gen(function* () {
-    const level = yield* import_effect4.FiberRef.get(currentDiagnosticsLevel);
+    const level = yield* import_effect4.Effect.service(currentDiagnosticsLevel).pipe(import_effect4.Effect.orDie);
+    const materialization = yield* import_effect4.Effect.service(currentDiagnosticsMaterialization).pipe(import_effect4.Effect.orDie);
+    const eventRuntimeLabel = normalizeRuntimeLabel(event.runtimeLabel);
     let changed = false;
     if (event.type === "trace:instanceLabel") {
       const instanceId = event.instanceId;
@@ -1447,51 +1975,74 @@ var devtoolsHubSink = {
       }
     }
     if (event.type === "module:init" || event.type === "module:destroy") {
-      const moduleId = event.moduleId ?? "unknown";
-      const runtimeLabel2 = event.runtimeLabel ?? "unknown";
+      const moduleId = normalizeKeyPart(event.moduleId);
+      const runtimeLabel2 = eventRuntimeLabel;
+      const runtimeBucket2 = getOrCreateRuntimeBucket(runtimeLabel2);
       const instanceId = event.instanceId;
-      const key = `${runtimeLabel2}::${moduleId}`;
-      const prev = instances.get(key) ?? 0;
       if (event.type === "module:init") {
-        instances.set(key, prev + 1);
+        const moduleEntry = getOrCreateRuntimeModuleEntry(runtimeLabel2, moduleId);
+        const moduleKey = moduleEntry.moduleKey;
+        const prev = instances.get(moduleKey) ?? 0;
+        instances.set(moduleKey, prev + 1);
         changed = true;
         if (instanceId) {
-          const instanceKey = `${runtimeLabel2}::${moduleId}::${instanceId}`;
-          liveInstanceKeys.add(instanceKey);
+          const cachedInstanceKey = moduleEntry.instanceKeyById.get(instanceId);
+          const instanceKey = cachedInstanceKey ?? `${moduleKey}::${instanceId}`;
+          if (cachedInstanceKey === void 0) {
+            moduleEntry.instanceKeyById.set(instanceId, instanceKey);
+          }
           if (latestStates.delete(instanceKey)) changed = true;
           if (latestTraitSummaries.delete(instanceKey)) changed = true;
+          if (runtimeBucket2.latestStates.delete(instanceKey)) changed = true;
+          if (runtimeBucket2.latestTraitSummaries.delete(instanceKey)) changed = true;
         }
       } else {
+        const moduleEntry = getRuntimeModuleEntry(runtimeLabel2, moduleId);
+        const moduleKey = moduleEntry?.moduleKey ?? `${runtimeLabel2}::${moduleId}`;
+        const prev = instances.get(moduleKey) ?? 0;
         const next = prev - 1;
         if (next <= 0) {
-          if (instances.delete(key)) changed = true;
+          if (instances.delete(moduleKey)) changed = true;
         } else {
-          instances.set(key, next);
+          instances.set(moduleKey, next);
           changed = true;
         }
         if (instanceId) {
-          const instanceKey = `${runtimeLabel2}::${moduleId}::${instanceId}`;
-          liveInstanceKeys.delete(instanceKey);
+          const instanceKey = moduleEntry?.instanceKeyById.get(instanceId) ?? `${moduleKey}::${instanceId}`;
+          moduleEntry?.instanceKeyById.delete(instanceId);
           if (latestStates.delete(instanceKey)) changed = true;
           if (latestTraitSummaries.delete(instanceKey)) changed = true;
+          if (runtimeBucket2.latestStates.delete(instanceKey)) changed = true;
+          if (runtimeBucket2.latestTraitSummaries.delete(instanceKey)) changed = true;
           if (instanceLabels.delete(instanceId)) changed = true;
           changed = true;
         }
+        cleanupRuntimeModuleEntryIfUnused(runtimeLabel2, moduleId, moduleKey);
+      }
+    }
+    if (level === "off") {
+      if (changed) {
+        markSnapshotChanged();
       }
+      return;
     }
-    let exportBudgetChanged = false;
+    let projectedDropped = 0;
+    let projectedOversized = 0;
     const ref = toRuntimeDebugEventRef(event, {
       diagnosticsLevel: level,
-      resolveConvergeStaticIr: (staticIrDigest) => convergeStaticIrByDigest.get(staticIrDigest),
+      materialization,
       onMetaProjection: ({ stats }) => {
-        if (stats.dropped !== 0 || stats.oversized !== 0) {
-          exportBudgetChanged = true;
-        }
-        exportBudget.dropped += stats.dropped;
-        exportBudget.oversized += stats.oversized;
+        projectedDropped += stats.dropped;
+        projectedOversized += stats.oversized;
       }
     });
-    if (exportBudgetChanged) {
+    if (projectedDropped !== 0 || projectedOversized !== 0) {
+      const budgetRuntimeLabel = normalizeRuntimeLabel(ref?.runtimeLabel ?? eventRuntimeLabel);
+      const runtimeBucket2 = getOrCreateRuntimeBucket(budgetRuntimeLabel);
+      runtimeBucket2.exportBudget.dropped += projectedDropped;
+      runtimeBucket2.exportBudget.oversized += projectedOversized;
+      exportBudget.dropped += projectedDropped;
+      exportBudget.oversized += projectedOversized;
       changed = true;
     }
     if (!ref) {
@@ -1500,28 +2051,28 @@ var devtoolsHubSink = {
       }
       return;
     }
+    const refRuntimeLabel = normalizeRuntimeLabel(ref.runtimeLabel);
+    const runtimeBucket = getOrCreateRuntimeBucket(refRuntimeLabel);
     if (ref.kind === "state" && ref.label === "state:update") {
-      const runtimeLabel2 = ref.runtimeLabel ?? "unknown";
-      const key = `${runtimeLabel2}::${ref.moduleId}::${ref.instanceId}`;
-      if (liveInstanceKeys.has(key)) {
+      const instanceKey = resolveLiveInstanceKey(refRuntimeLabel, ref.moduleId, ref.instanceId);
+      if (instanceKey) {
         if (ref.meta && typeof ref.meta === "object" && !Array.isArray(ref.meta)) {
           const anyMeta = ref.meta;
           if ("state" in anyMeta) {
-            latestStates.set(key, anyMeta.state);
+            latestStates.set(instanceKey, anyMeta.state);
+            runtimeBucket.latestStates.set(instanceKey, anyMeta.state);
             changed = true;
           }
           if ("traitSummary" in anyMeta && anyMeta.traitSummary !== void 0) {
-            latestTraitSummaries.set(key, anyMeta.traitSummary);
+            latestTraitSummaries.set(instanceKey, anyMeta.traitSummary);
+            runtimeBucket.latestTraitSummaries.set(instanceKey, anyMeta.traitSummary);
             changed = true;
           }
         }
       }
     }
     if (bufferSize > 0) {
-      const seq = nextSeq++;
-      ringBuffer.push(ref);
-      ringBufferSeq.push(seq);
-      trimRingBufferIfNeeded();
+      appendRuntimeRef(refRuntimeLabel, ref);
       changed = true;
     }
     if (changed) {
@@ -1532,14 +2083,400 @@ var devtoolsHubSink = {
 
 // src/internal/runtime/core/ConvergeStaticIrCollector.ts
 var import_effect5 = require("effect");
-var currentConvergeStaticIrCollectors = import_effect5.FiberRef.unsafeMake([]);
-var appendConvergeStaticIrCollectors = (collectors) => import_effect5.Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [
-  ...current,
-  ...collectors
-]);
+var currentConvergeStaticIrCollectors = import_effect5.ServiceMap.Reference(
+  "@logixjs/core/ConvergeStaticIrCollectors",
+  {
+    defaultValue: () => []
+  }
+);
+var appendConvergeStaticIrCollectors = (collectors) => import_effect5.Layer.effect(
+  currentConvergeStaticIrCollectors,
+  import_effect5.Effect.gen(function* () {
+    const current = yield* import_effect5.Effect.service(currentConvergeStaticIrCollectors);
+    return [...current, ...collectors];
+  })
+);
 
 // src/internal/runtime/core/env.ts
+var import_effect11 = 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 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 listeners2 = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+        if (listeners2.length === 0) {
+          continue;
+        }
+        if (!firstTopicListeners) {
+          firstTopicListeners = listeners2;
+          continue;
+        }
+        if (!secondTopicListeners) {
+          secondTopicListeners = listeners2;
+          continue;
+        }
+        if (!restTopicListeners) {
+          restTopicListeners = [];
+        }
+        restTopicListeners.push(listeners2);
+      }
+      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 listeners2 of restTopicListeners) {
+          for (const listener of listeners2) {
+            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 listeners2 = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+      if (listeners2.length === 0) {
+        continue;
+      }
+      if (flattenedTopicListeners) {
+        for (const listener of listeners2) {
+          flattenedTopicListeners.push(listener);
+        }
+        continue;
+      }
+      if (!singleTopicListeners) {
+        singleTopicListeners = listeners2;
+        continue;
+      }
+      flattenedTopicListeners = Array.from(singleTopicListeners);
+      for (const listener of listeners2) {
+        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_effect9 = require("effect");
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect8 = require("effect");
+
+// src/internal/runtime/core/ModeRunner.ts
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/LatestFiberSlot.ts
 var import_effect6 = require("effect");
+
+// src/internal/runtime/core/TaskRunner.ts
+var inSyncTransactionFiber = import_effect8.ServiceMap.Reference("@logixjs/core/TaskRunner.inSyncTransactionFiber", {
+  defaultValue: () => false
+});
+var forceSourceRefresh = import_effect8.ServiceMap.Reference("@logixjs/core/TaskRunner.forceSourceRefresh", {
+  defaultValue: () => false
+});
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect10 = 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_effect10.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 +2486,40 @@ var getNodeEnv = () => {
   }
 };
 var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+var StateTransactionConfigTagImpl = class extends import_effect11.ServiceMap.Service()("@logixjs/core/StateTransactionRuntimeConfig") {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect11.ServiceMap.Service()("@logixjs/core/ReadQueryStrictGateRuntimeConfig") {
+};
+var ReplayModeConfigTagImpl = class extends import_effect11.ServiceMap.Service()("@logixjs/core/ReplayModeConfig") {
 };
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var StateTransactionOverridesTagImpl = class extends import_effect11.ServiceMap.Service()("@logixjs/core/StateTransactionOverrides") {
 };
-var ReplayModeConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var SchedulingPolicySurfaceTagImpl = class extends import_effect11.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurface") {
 };
-var StateTransactionOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var SchedulingPolicySurfaceOverridesTagImpl = class extends import_effect11.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurfaceOverrides") {
+};
+var RuntimeStoreTag = class extends import_effect11.ServiceMap.Service()("@logixjs/core/RuntimeStore") {
+};
+var runtimeStoreLayer = import_effect11.Layer.effect(
+  RuntimeStoreTag,
+  import_effect11.Effect.acquireRelease(
+    import_effect11.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect11.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect11.ServiceMap.Service()("@logixjs/core/HostScheduler") {
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var hostSchedulerLayer = import_effect11.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect11.ServiceMap.Service()("@logixjs/core/DeclarativeLinkRuntime") {
 };
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var declarativeLinkRuntimeLayer = import_effect11.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect11.ServiceMap.Service()("@logixjs/core/TickScheduler") {
 };
 
 // src/internal/debug/ModuleTraitsRegistry.ts
@@ -1616,10 +2576,13 @@ var internal = {
   currentDebugSinks,
   currentRuntimeLabel,
   currentDiagnosticsLevel,
+  currentDiagnosticsMaterialization,
+  currentTraceMode,
   currentTraitConvergeDiagnosticsSampling,
   toRuntimeDebugEventRef
 };
 var getDevtoolsSnapshot2 = getDevtoolsSnapshot;
+var getDevtoolsSnapshotByRuntimeLabel2 = getDevtoolsSnapshotByRuntimeLabel;
 var getDevtoolsSnapshotToken2 = getDevtoolsSnapshotToken;
 var subscribeDevtoolsSnapshot2 = subscribeDevtoolsSnapshot;
 var clearDevtoolsEvents2 = clearDevtoolsEvents;
@@ -1629,13 +2592,15 @@ var startDevtoolsRun2 = startDevtoolsRun;
 var setInstanceLabel2 = setInstanceLabel;
 var getInstanceLabel2 = getInstanceLabel;
 var exportEvidencePackage2 = (options) => exportDevtoolsEvidencePackage(options);
-var diagnosticsLevel = (level) => import_effect7.Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
+var diagnosticsLevel2 = (level) => diagnosticsLevel(level);
+var diagnosticsMaterialization2 = (mode) => diagnosticsMaterialization(mode);
+var traceMode2 = (mode) => traceMode(mode);
 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_effect12.Effect.sync(() => {
       if (event.type === "module:init") {
         const moduleId = event.moduleId ?? "unknown";
         const runtimeLabel2 = "runtimeLabel" in event && event.runtimeLabel ? event.runtimeLabel : "unknown";
@@ -1662,21 +2627,53 @@ var makeModuleRuntimeCounterSink = () => {
   return { sink, getSnapshot };
 };
 var makeRingBufferSink = (capacity = 1e3) => {
-  const buffer = [];
+  const boundedCapacity = Number.isFinite(capacity) ? Math.ceil(capacity) : 0;
+  const isBounded = boundedCapacity > 0;
+  const boundedBuffer = isBounded ? new Array(boundedCapacity) : [];
+  const unboundedBuffer = isBounded ? [] : [];
+  let head = 0;
+  let size = 0;
   const sink = {
-    record: (event) => import_effect7.Effect.sync(() => {
+    record: (event) => import_effect12.Effect.sync(() => {
       if (capacity <= 0) {
         return;
       }
-      if (buffer.length >= capacity) {
-        buffer.shift();
+      if (!isBounded) {
+        unboundedBuffer.push(event);
+        return;
+      }
+      const writeIndex = (head + size) % boundedCapacity;
+      boundedBuffer[writeIndex] = event;
+      if (size < boundedCapacity) {
+        size += 1;
+        return;
       }
-      buffer.push(event);
+      head = (head + 1) % boundedCapacity;
     })
   };
-  const getSnapshot = () => buffer.slice();
+  const getSnapshot = () => {
+    if (!isBounded) {
+      return unboundedBuffer.slice();
+    }
+    if (size === 0) {
+      return [];
+    }
+    const snapshot = new Array(size);
+    for (let i = 0; i < size; i++) {
+      snapshot[i] = boundedBuffer[(head + i) % boundedCapacity];
+    }
+    return snapshot;
+  };
   const clear = () => {
-    buffer.length = 0;
+    if (!isBounded) {
+      unboundedBuffer.length = 0;
+      return;
+    }
+    for (let i = 0; i < size; i++) {
+      boundedBuffer[(head + i) % boundedCapacity] = void 0;
+    }
+    head = 0;
+    size = 0;
   };
   return { sink, getSnapshot, clear };
 };
@@ -1704,35 +2701,59 @@ var layer = (options) => {
       }
     }
   })();
-  return diagnostics ? import_effect7.Layer.mergeAll(sinks, diagnosticsLevel(diagnostics)) : sinks;
+  const trace = mode === "dev" ? traceMode2("on") : traceMode2("off");
+  const base = import_effect12.Layer.mergeAll(sinks, trace);
+  return diagnostics ? import_effect12.Layer.mergeAll(base, diagnosticsLevel2(diagnostics)) : base;
 };
-var withPrettyLogger = (base, options) => import_effect7.Layer.merge(
+var withPrettyLogger = (base, options) => import_effect12.Layer.merge(
   base,
-  import_effect7.Logger.replace(import_effect7.Logger.defaultLogger, import_effect7.Logger.prettyLogger(options))
+  import_effect12.Layer.effect(
+    import_effect12.Logger.CurrentLoggers,
+    import_effect12.Effect.gen(function* () {
+      const current = yield* import_effect12.Effect.service(import_effect12.Logger.CurrentLoggers);
+      return new Set([...current].filter((logger) => logger !== import_effect12.Logger.defaultLogger).concat(import_effect12.Logger.consolePretty(options)));
+    })
+  )
+);
+var replace = (sinks) => import_effect12.Layer.succeed(internal.currentDebugSinks, sinks);
+var appendSinks = (sinks) => import_effect12.Layer.effect(
+  internal.currentDebugSinks,
+  import_effect12.Effect.gen(function* () {
+    const current = yield* internal.currentDebugSinks;
+    return [...current, ...sinks];
+  })
 );
-var replace = (sinks) => import_effect7.Layer.locallyScoped(internal.currentDebugSinks, sinks);
-var appendSinks = (sinks) => import_effect7.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [
-  ...current,
-  ...sinks
-]);
 function devtoolsHubLayer(baseOrOptions, maybeOptions) {
-  const isLayerValue = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
+  const isLayerValue = (value) => import_effect12.Layer.isLayer(value);
   const hasBase = isLayerValue(baseOrOptions);
-  const base = hasBase ? baseOrOptions : import_effect7.Layer.empty;
+  const base = hasBase ? baseOrOptions : import_effect12.Layer.empty;
   const options = hasBase ? maybeOptions : baseOrOptions;
   configureDevtoolsHub(options);
   const append = appendSinks([devtoolsHubSink]);
   const appendConvergeStaticIr = appendConvergeStaticIrCollectors([
     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 resolvedDiagnosticsLevel = options?.diagnosticsLevel ?? "light";
+  const resolvedTraceMode = options?.traceMode ?? (resolvedDiagnosticsLevel === "off" ? "off" : getNodeEnv() === "production" ? "off" : "on");
+  const enableExportableDiagnostics = diagnosticsLevel2(resolvedDiagnosticsLevel);
+  const enableMaterialization = diagnosticsMaterialization2(
+    options?.materialization ?? (resolvedDiagnosticsLevel === "full" && getNodeEnv() === "production" ? "lazy" : "eager")
+  );
+  const enableTraceMode = traceMode2(resolvedTraceMode);
+  const convergeSamplingLayer = options?.traitConvergeDiagnosticsSampling ? traitConvergeDiagnosticsSampling2(options.traitConvergeDiagnosticsSampling) : import_effect12.Layer.empty;
+  return import_effect12.Layer.provideMerge(
+    import_effect12.Layer.mergeAll(
+      append,
+      enableExportableDiagnostics,
+      enableMaterialization,
+      enableTraceMode,
+      convergeSamplingLayer,
+      appendConvergeStaticIr
+    ),
     base
   );
 }
-var runtimeLabel = (label) => import_effect7.Layer.fiberRefLocallyScopedWith(internal.currentRuntimeLabel, () => label);
+var runtimeLabel = (label) => import_effect12.Layer.succeed(internal.currentRuntimeLabel, label);
 var getModuleTraits = (module2) => {
   const moduleTag = module2.tag ? module2.tag : module2;
   const program = getModuleTraitsProgram(moduleTag);
@@ -1774,16 +2795,22 @@ var getModuleFinalTraits = (runtime) => {
     provenance: snapshot.provenanceIndex[t.traitId]
   }));
 };
-var isLayer = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
+var isLayer = (value) => typeof value === "object" && value !== null && "build" in value;
 function traceLayer(baseOrHandler, maybeOnTrace) {
   const hasBase = isLayer(baseOrHandler);
-  const base = hasBase ? baseOrHandler : import_effect7.Layer.empty;
+  const base = hasBase ? baseOrHandler : import_effect12.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_effect12.Effect.logDebug({ traceEvent: event }) : import_effect12.Effect.void
   };
-  const appendTrace = import_effect7.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (sinks) => [...sinks, traceSink]);
-  return import_effect7.Layer.provideMerge(appendTrace, base);
+  const appendTrace = import_effect12.Layer.effect(
+    currentDebugSinks,
+    import_effect12.Effect.gen(function* () {
+      const sinks = yield* currentDebugSinks;
+      return [...sinks, traceSink];
+    })
+  );
+  return import_effect12.Layer.provideMerge(appendTrace, base);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1791,9 +2818,11 @@ function traceLayer(baseOrHandler, maybeOnTrace) {
   clearDevtoolsEvents,
   devtoolsHubLayer,
   diagnosticsLevel,
+  diagnosticsMaterialization,
   exportEvidencePackage,
   getDevtoolsRunId,
   getDevtoolsSnapshot,
+  getDevtoolsSnapshotByRuntimeLabel,
   getDevtoolsSnapshotToken,
   getInstanceLabel,
   getModuleFinalTraits,
@@ -1815,6 +2844,7 @@ function traceLayer(baseOrHandler, maybeOnTrace) {
   subscribeDevtoolsSnapshot,
   toRuntimeDebugEventRef,
   traceLayer,
+  traceMode,
   traitConvergeDiagnosticsSampling,
   withPrettyLogger
 });