@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/{chunk-X72PZOFA.js → chunk-K2MQ66O7.js}

@@ -2,7 +2,7 @@
 
 import {
   record
-} from "./chunk-S4EXG3OS.js";
+} from "./chunk-RBB6SHW2.js";
 
 // ../logix-core/src/Middleware.ts
 import { Effect } from "../effect.js";

package/public/sandbox/chunks/chunk-KA7PZA6F.js

@@ -0,0 +1,464 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  getModuleProgramById
+} from "./chunk-ST353BOX.js";
+import {
+  appendConvergeStaticIrCollectors
+} from "./chunk-75DQFC5M.js";
+import {
+  getModuleTraitsProgram,
+  getRuntimeInternals
+} from "./chunk-6FKWRVP4.js";
+import {
+  getNodeEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  browserConsoleLayer,
+  clearRuntimeDebugEventSeq,
+  currentDebugSinks,
+  currentDiagnosticsLevel,
+  currentRuntimeLabel,
+  errorOnlyLayer,
+  noopLayer,
+  record,
+  toRuntimeDebugEventRef
+} from "./chunk-CVZPRIDB.js";
+import {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage
+} from "./chunk-Z5L7EZXS.js";
+
+// ../logix-core/src/Debug.ts
+import { Effect as Effect2, Layer, Logger } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/DevtoolsHub.ts
+import { Effect, FiberRef } from "../effect.js";
+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 exportBudget = {
+  dropped: 0,
+  oversized: 0
+};
+var lastRunTs = 0;
+var lastRunTsSeq = 0;
+var nextRunId = () => {
+  const ts = Date.now();
+  if (ts === lastRunTs) {
+    lastRunTsSeq += 1;
+  } else {
+    lastRunTs = ts;
+    lastRunTsSeq = 0;
+  }
+  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
+};
+var currentRunId = nextRunId();
+var nextSeq = 1;
+var bufferSize = 500;
+var ringBuffer = [];
+var ringBufferSeq = [];
+var currentSnapshot = {
+  instances,
+  events: ringBuffer,
+  latestStates,
+  latestTraitSummaries,
+  exportBudget
+};
+var listeners = /* @__PURE__ */ new Set();
+var notifyScheduled = false;
+var scheduleNotify = () => {
+  if (notifyScheduled) return;
+  notifyScheduled = true;
+  queueMicrotask(() => {
+    notifyScheduled = false;
+    for (const listener of listeners) {
+      listener();
+    }
+  });
+};
+var devtoolsEnabled = false;
+var configureDevtoolsHub = (options) => {
+  devtoolsEnabled = true;
+  if (typeof options?.bufferSize === "number" && Number.isFinite(options.bufferSize)) {
+    const next = Math.floor(options.bufferSize);
+    bufferSize = next > 0 ? next : bufferSize;
+    if (ringBuffer.length > bufferSize) {
+      const excess = ringBuffer.length - bufferSize;
+      ringBuffer.splice(0, excess);
+      ringBufferSeq.splice(0, excess);
+    }
+    scheduleNotify();
+  }
+};
+var isDevtoolsEnabled = () => devtoolsEnabled;
+var getDevtoolsSnapshot = () => currentSnapshot;
+var subscribeDevtoolsSnapshot = (listener) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+var getDevtoolsRunId = () => currentRunId;
+var setDevtoolsRunId = (runId) => {
+  if (typeof runId !== "string" || runId.length === 0) return;
+  currentRunId = 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;
+  scheduleNotify();
+};
+var setInstanceLabel = (instanceId, label) => {
+  instanceLabels.set(instanceId, label);
+  scheduleNotify();
+};
+var getInstanceLabel = (instanceId) => instanceLabels.get(instanceId);
+var registerConvergeStaticIr = (ir) => {
+  convergeStaticIrByDigest.set(ir.staticIrDigest, ir);
+};
+var devtoolsHubConvergeStaticIrCollector = {
+  register: registerConvergeStaticIr
+};
+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) => ({
+    protocolVersion,
+    runId,
+    seq: ringBufferSeq[i] ?? 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 dirty = meta.dirty;
+    if (isRecord(dirty) && typeof dirty.rootCount === "number") {
+      sawFullConverge = true;
+    }
+  }
+  let summary;
+  if (sawFullConverge && convergeDigests.size > 0) {
+    const staticIrByDigest = {};
+    for (const digest of convergeDigests) {
+      const ir = convergeStaticIrByDigest.get(digest);
+      if (ir) {
+        staticIrByDigest[digest] = ir;
+      }
+    }
+    if (Object.keys(staticIrByDigest).length > 0) {
+      summary = { converge: { staticIrByDigest } };
+    }
+  }
+  return exportEvidencePackage({
+    protocolVersion,
+    runId,
+    source,
+    events,
+    summary
+  });
+};
+var devtoolsHubSink = {
+  record: (event) => Effect.gen(function* () {
+    const level = yield* FiberRef.get(currentDiagnosticsLevel);
+    if (event.type === "trace:instanceLabel") {
+      const instanceId = event.instanceId;
+      const data = event.data;
+      const label = data && typeof data === "object" && "label" in data ? String(data.label) : void 0;
+      if (instanceId && label) {
+        instanceLabels.set(instanceId, label);
+      }
+    }
+    if (event.type === "module:init" || event.type === "module:destroy") {
+      const moduleId = event.moduleId ?? "unknown";
+      const runtimeLabel2 = event.runtimeLabel ?? "unknown";
+      const key = `${runtimeLabel2}::${moduleId}`;
+      const prev = instances.get(key) ?? 0;
+      if (event.type === "module:init") {
+        instances.set(key, prev + 1);
+      } else {
+        const next = prev - 1;
+        if (next <= 0) {
+          instances.delete(key);
+        } else {
+          instances.set(key, next);
+        }
+      }
+    }
+    const ref = toRuntimeDebugEventRef(event, {
+      diagnosticsLevel: level,
+      onMetaProjection: ({ stats }) => {
+        exportBudget.dropped += stats.dropped;
+        exportBudget.oversized += stats.oversized;
+      }
+    });
+    if (!ref) {
+      scheduleNotify();
+      return;
+    }
+    if (ref.kind === "state" && ref.label === "state:update") {
+      const runtimeLabel2 = ref.runtimeLabel ?? "unknown";
+      const key = `${runtimeLabel2}::${ref.moduleId}::${ref.instanceId}`;
+      if (ref.meta && typeof ref.meta === "object" && !Array.isArray(ref.meta)) {
+        const anyMeta = ref.meta;
+        if ("state" in anyMeta) {
+          latestStates.set(key, anyMeta.state);
+        }
+        if ("traitSummary" in anyMeta && anyMeta.traitSummary !== void 0) {
+          latestTraitSummaries.set(key, anyMeta.traitSummary);
+        }
+      }
+    }
+    if (event.type === "module:destroy") {
+      const instanceId = event.instanceId;
+      if (instanceId) {
+        instanceLabels.delete(instanceId);
+      }
+    }
+    if (bufferSize > 0) {
+      const seq = nextSeq++;
+      if (ringBuffer.length >= bufferSize) {
+        ringBuffer.shift();
+        ringBufferSeq.shift();
+      }
+      ringBuffer.push(ref);
+      ringBufferSeq.push(seq);
+    }
+    scheduleNotify();
+  })
+};
+
+// ../logix-core/src/Debug.ts
+var internal = {
+  currentDebugSinks,
+  currentRuntimeLabel,
+  currentDiagnosticsLevel,
+  toRuntimeDebugEventRef
+};
+var getDevtoolsSnapshot2 = getDevtoolsSnapshot;
+var subscribeDevtoolsSnapshot2 = subscribeDevtoolsSnapshot;
+var clearDevtoolsEvents2 = clearDevtoolsEvents;
+var getDevtoolsRunId2 = getDevtoolsRunId;
+var setDevtoolsRunId2 = setDevtoolsRunId;
+var startDevtoolsRun2 = startDevtoolsRun;
+var setInstanceLabel2 = setInstanceLabel;
+var getInstanceLabel2 = getInstanceLabel;
+var exportEvidencePackage2 = (options) => exportDevtoolsEvidencePackage(options);
+var diagnosticsLevel = (level) => Layer.fiberRefLocallyScopedWith(
+  currentDiagnosticsLevel,
+  () => level
+);
+var isDevtoolsEnabled2 = isDevtoolsEnabled;
+var makeModuleRuntimeCounterSink = () => {
+  const counts = /* @__PURE__ */ new Map();
+  const sink = {
+    record: (event) => Effect2.sync(() => {
+      if (event.type === "module:init") {
+        const moduleId = event.moduleId ?? "unknown";
+        const runtimeLabel2 = "runtimeLabel" in event && event.runtimeLabel ? event.runtimeLabel : "unknown";
+        const key = `${runtimeLabel2}::${moduleId}`;
+        const prev = counts.get(key) ?? 0;
+        counts.set(key, prev + 1);
+        return;
+      }
+      if (event.type === "module:destroy") {
+        const moduleId = event.moduleId ?? "unknown";
+        const runtimeLabel2 = "runtimeLabel" in event && event.runtimeLabel ? event.runtimeLabel : "unknown";
+        const key = `${runtimeLabel2}::${moduleId}`;
+        const prev = counts.get(key) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          counts.delete(key);
+        } else {
+          counts.set(key, next);
+        }
+      }
+    })
+  };
+  const getSnapshot = () => new Map(counts);
+  return { sink, getSnapshot };
+};
+var makeRingBufferSink = (capacity = 1e3) => {
+  const buffer = [];
+  const sink = {
+    record: (event) => Effect2.sync(() => {
+      if (capacity <= 0) {
+        return;
+      }
+      if (buffer.length >= capacity) {
+        buffer.shift();
+      }
+      buffer.push(event);
+    })
+  };
+  const getSnapshot = () => buffer.slice();
+  const clear = () => {
+    buffer.length = 0;
+  };
+  return { sink, getSnapshot, clear };
+};
+var record2 = record;
+var noopLayer2 = noopLayer;
+var resolveMode = (mode) => {
+  if (mode && mode !== "auto") {
+    return mode;
+  }
+  const env = getNodeEnv();
+  return env === "production" ? "prod" : "dev";
+};
+var layer = (options) => {
+  const mode = resolveMode(options?.mode);
+  switch (mode) {
+    case "off":
+      return noopLayer;
+    case "prod":
+      return errorOnlyLayer;
+    case "dev":
+    case "auto": {
+      return browserConsoleLayer;
+    }
+  }
+};
+var withPrettyLogger = (base, options) => Layer.merge(
+  base,
+  Logger.replace(
+    Logger.defaultLogger,
+    Logger.prettyLogger(options)
+  )
+);
+var replace = (sinks) => Layer.locallyScoped(
+  internal.currentDebugSinks,
+  sinks
+);
+var appendSinks = (sinks) => 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 : Layer.empty;
+  const options = hasBase ? maybeOptions : baseOrOptions;
+  configureDevtoolsHub(options);
+  const append = appendSinks([devtoolsHubSink]);
+  const appendConvergeStaticIr = appendConvergeStaticIrCollectors([
+    devtoolsHubConvergeStaticIrCollector
+  ]);
+  const enableExportableDiagnostics = diagnosticsLevel(options?.diagnosticsLevel ?? "light");
+  return Layer.provideMerge(
+    Layer.mergeAll(append, enableExportableDiagnostics, appendConvergeStaticIr),
+    base
+  );
+}
+var runtimeLabel = (label) => Layer.fiberRefLocallyScopedWith(
+  internal.currentRuntimeLabel,
+  () => label
+);
+var getModuleTraits = (module) => {
+  const moduleTag = module.tag ? module.tag : module;
+  const program = getModuleTraitsProgram(moduleTag);
+  if (!program) {
+    return {};
+  }
+  return {
+    program,
+    graph: program.graph,
+    plan: program.plan
+  };
+};
+var getModuleTraitsById = (moduleId) => {
+  const program = getModuleProgramById(moduleId);
+  if (!program) {
+    return void 0;
+  }
+  return {
+    program,
+    graph: program.graph,
+    plan: program.plan
+  };
+};
+var getModuleTraitsSnapshot = (runtime) => {
+  try {
+    const internals = getRuntimeInternals(runtime);
+    return internals.traits.getModuleTraitsSnapshot();
+  } catch {
+    return void 0;
+  }
+};
+var getModuleFinalTraits = (runtime) => {
+  const snapshot = getModuleTraitsSnapshot(runtime);
+  if (!snapshot) return [];
+  return snapshot.traits.map((t) => ({
+    traitId: t.traitId,
+    name: t.name,
+    description: t.description,
+    provenance: snapshot.provenanceIndex[t.traitId]
+  }));
+};
+var isLayer = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
+function traceLayer(baseOrHandler, maybeOnTrace) {
+  const hasBase = isLayer(baseOrHandler);
+  const base = hasBase ? baseOrHandler : Layer.empty;
+  const onTrace = hasBase ? maybeOnTrace : baseOrHandler;
+  const traceSink = {
+    record: (event) => typeof event.type === "string" && event.type.startsWith("trace:") ? onTrace ? onTrace(event) : Effect2.logDebug({ traceEvent: event }) : Effect2.void
+  };
+  const appendTrace = Layer.fiberRefLocallyScopedWith(
+    currentDebugSinks,
+    (sinks) => [...sinks, traceSink]
+  );
+  return Layer.provideMerge(appendTrace, base);
+}
+
+export {
+  internal,
+  getDevtoolsSnapshot2 as getDevtoolsSnapshot,
+  subscribeDevtoolsSnapshot2 as subscribeDevtoolsSnapshot,
+  clearDevtoolsEvents2 as clearDevtoolsEvents,
+  getDevtoolsRunId2 as getDevtoolsRunId,
+  setDevtoolsRunId2 as setDevtoolsRunId,
+  startDevtoolsRun2 as startDevtoolsRun,
+  setInstanceLabel2 as setInstanceLabel,
+  getInstanceLabel2 as getInstanceLabel,
+  exportEvidencePackage2 as exportEvidencePackage,
+  diagnosticsLevel,
+  isDevtoolsEnabled2 as isDevtoolsEnabled,
+  makeModuleRuntimeCounterSink,
+  makeRingBufferSink,
+  record2 as record,
+  noopLayer2 as noopLayer,
+  layer,
+  withPrettyLogger,
+  replace,
+  appendSinks,
+  devtoolsHubLayer,
+  runtimeLabel,
+  getModuleTraits,
+  getModuleTraitsById,
+  getModuleTraitsSnapshot,
+  getModuleFinalTraits,
+  traceLayer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Debug.ts", "../../../../logix-core/src/internal/runtime/core/DevtoolsHub.ts"],
  "sourcesContent": ["import { Effect, Layer, Logger } from \"effect\"\nimport type {\n  AnyModuleShape,\n  ModuleLike,\n  ModuleRuntime,\n  ModuleTag,\n} from \"./internal/module.js\"\nimport type {\n  StateTraitProgram,\n  StateTraitGraph,\n  StateTraitPlan,\n} from \"./state-trait.js\"\nimport * as Internal from \"./internal/runtime/core/DebugSink.js\"\nimport * as DevtoolsHub from \"./internal/runtime/core/DevtoolsHub.js\"\nimport * as ConvergeStaticIrCollector from \"./internal/runtime/core/ConvergeStaticIrCollector.js\"\nimport * as ModuleTraitsRegistry from \"./internal/debug/ModuleTraitsRegistry.js\"\nimport type * as ModuleTraits from \"./internal/runtime/core/ModuleTraits.js\"\nimport {\n  getModuleTraitsProgram,\n  getRuntimeInternals,\n} from \"./internal/runtime/core/runtimeInternalsAccessor.js\"\nimport { getNodeEnv } from \"./internal/runtime/core/env.js\"\nimport type { EvidencePackage, EvidencePackageSource } from \"./observability.js\"\n\n// Public Debug API\uFF1A\u4EE5\u547D\u540D\u7A7A\u95F4\u5F62\u5F0F\u6536\u53E3 Debug \u80FD\u529B\uFF0C\u4F9B\u4E1A\u52A1\u4E0E\u5E73\u53F0\u7EDF\u4E00\u4F7F\u7528\u3002\n// \u5B9E\u9645\u4E8B\u4EF6\u6A21\u578B\u4E0E Layer \u5B9A\u4E49\u96C6\u4E2D\u5728 internal/runtime/core/DebugSink.ts \u4E2D\uFF0C\n// \u8FD9\u91CC\u5728\u5176\u57FA\u7840\u4E0A\u63D0\u4F9B\u66F4\u6613\u7528\u7684\u7EC4\u5408\u5165\u53E3\u3002\n\nexport type Event = Internal.Event\nexport interface Sink extends Internal.Sink {}\nexport interface RuntimeDebugEventRef extends Internal.RuntimeDebugEventRef {}\nexport type DiagnosticsLevel = Internal.DiagnosticsLevel\n\nexport const internal = {\n  currentDebugSinks: Internal.currentDebugSinks,\n  currentRuntimeLabel: Internal.currentRuntimeLabel,\n  currentDiagnosticsLevel: Internal.currentDiagnosticsLevel,\n  toRuntimeDebugEventRef: Internal.toRuntimeDebugEventRef,\n}\n\nexport interface DevtoolsSnapshot extends DevtoolsHub.DevtoolsSnapshot {}\nexport interface DevtoolsHubOptions extends DevtoolsHub.DevtoolsHubOptions {\n  readonly diagnosticsLevel?: DiagnosticsLevel\n}\n\nexport const getDevtoolsSnapshot = DevtoolsHub.getDevtoolsSnapshot\nexport const subscribeDevtoolsSnapshot = DevtoolsHub.subscribeDevtoolsSnapshot\nexport const clearDevtoolsEvents = DevtoolsHub.clearDevtoolsEvents\nexport const getDevtoolsRunId = DevtoolsHub.getDevtoolsRunId\nexport const setDevtoolsRunId = DevtoolsHub.setDevtoolsRunId\nexport const startDevtoolsRun = DevtoolsHub.startDevtoolsRun\nexport const setInstanceLabel = DevtoolsHub.setInstanceLabel\nexport const getInstanceLabel = DevtoolsHub.getInstanceLabel\n\nexport const exportEvidencePackage = (options?: {\n  readonly runId?: string\n  readonly source?: EvidencePackageSource\n  readonly protocolVersion?: string\n}): EvidencePackage => DevtoolsHub.exportDevtoolsEvidencePackage(options)\n\n/**\n * diagnosticsLevel\uFF1A\n * - \u63A7\u5236\u201C\u53EF\u5BFC\u51FA\u4E8B\u4EF6\u201D\u7684\u751F\u6210\u4E0E\u88C1\u526A\u7B56\u7565\uFF1B\n * - \u4EC5\u5F71\u54CD DevtoolsHub\uFF08ring buffer / snapshot\uFF09\u7B49\u5BFC\u51FA\u9762\uFF0C\u4E0D\u6539\u53D8 Debug.record \u7684\u9519\u8BEF\u515C\u5E95\u8BED\u4E49\u3002\n */\nexport const diagnosticsLevel = (level: DiagnosticsLevel): Layer.Layer<any, never, never> =>\n  Layer.fiberRefLocallyScopedWith(\n    Internal.currentDiagnosticsLevel as any,\n    () => level,\n  ) as Layer.Layer<any, never, never>\n\n/**\n * isDevtoolsEnabled\uFF1A\n * - \u7528\u4E8E React/Devtools UI \u5728\u975E dev \u73AF\u5883\u4E0B\u5224\u65AD\u662F\u5426\u5E94\u542F\u7528\u989D\u5916\u89C2\u6D4B\uFF08\u5982 react-render \u4E8B\u4EF6\uFF09\u3002\n * - \u8BE5\u6807\u8BB0\u7531 devtoolsHubLayer \u6253\u5F00\uFF08\u663E\u5F0F override\uFF09\u3002\n */\nexport const isDevtoolsEnabled = DevtoolsHub.isDevtoolsEnabled\n\n/**\n * ModuleRuntimeCounter\uFF1A\n * - \u4EC5\u4F9D\u8D56 module:init / module:destroy \u4E8B\u4EF6\uFF0C\u6309 moduleId \u7EF4\u5EA6\u7EDF\u8BA1\u5F53\u524D\u6D3B\u8DC3\u5B9E\u4F8B\u6570\u91CF\uFF1B\n * - \u9002\u5408\u4F5C\u4E3A DevTools / Playground \u7684\u57FA\u7840\u6570\u636E\u6E90\uFF0C\u4E0D\u5173\u5FC3\u5177\u4F53 instanceId \u6216 React key\u3002\n */\nexport interface ModuleRuntimeCounter {\n  readonly sink: Sink\n  readonly getSnapshot: () => ReadonlyMap<string, number>\n}\n\n/**\n * RingBufferSink\uFF1A\n * - \u901A\u7528 DevTools \u8F85\u52A9\u5DE5\u5177\uFF0C\u7528\u4E8E\u5728\u5185\u5B58\u4E2D\u4FDD\u7559\u6700\u8FD1\u4E00\u6BB5 Debug \u4E8B\u4EF6\u7A97\u53E3\uFF08\u73AF\u5F62\u7F13\u51B2\u533A\uFF09\uFF1B\n * - \u4E0D\u505A\u4EFB\u4F55\u7B5B\u9009/\u5206\u7EC4\uFF0C\u8C03\u7528\u65B9\u53EF\u4EE5\u57FA\u4E8E snapshot \u518D\u6309 moduleId / type \u7B49\u7EF4\u5EA6\u52A0\u5DE5\u3002\n */\nexport interface RingBufferSink {\n  readonly sink: Sink\n  readonly getSnapshot: () => ReadonlyArray<Event>\n  readonly clear: () => void\n}\n\n/**\n * makeModuleRuntimeCounterSink\uFF1A\n * - \u6784\u9020\u4E00\u4E2A DebugSink\uFF0C\u7528\u4E8E\u5728\u5185\u5B58\u4E2D\u7D2F\u79EF\u300C\u6BCF\u4E2A moduleId \u5F53\u524D\u6709\u591A\u5C11\u6D3B\u8DC3\u5B9E\u4F8B\u300D\uFF1B\n * - Snapshot \u901A\u8FC7 getSnapshot() \u66B4\u9732\u7ED9 DevTools\uFF0C\u8C03\u7528\u65B9\u53EF\u81EA\u884C\u51B3\u5B9A\u5982\u4F55\u5BF9\u5916\u6865\u63A5\uFF08window/postMessage \u7B49\uFF09\u3002\n */\nexport const makeModuleRuntimeCounterSink = (): ModuleRuntimeCounter => {\n  const counts = new Map<string, number>()\n\n  const sink: Sink = {\n    record: (event: Event) =>\n      Effect.sync(() => {\n        if (event.type === \"module:init\") {\n          const moduleId = event.moduleId ?? \"unknown\"\n          const runtimeLabel =\n            \"runtimeLabel\" in event && event.runtimeLabel\n              ? event.runtimeLabel\n              : \"unknown\"\n          const key = `${runtimeLabel}::${moduleId}`\n          const prev = counts.get(key) ?? 0\n          counts.set(key, prev + 1)\n          return\n        }\n        if (event.type === \"module:destroy\") {\n          const moduleId = event.moduleId ?? \"unknown\"\n          const runtimeLabel =\n            \"runtimeLabel\" in event && event.runtimeLabel\n              ? event.runtimeLabel\n              : \"unknown\"\n          const key = `${runtimeLabel}::${moduleId}`\n          const prev = counts.get(key) ?? 0\n          const next = prev - 1\n          if (next <= 0) {\n            counts.delete(key)\n          } else {\n            counts.set(key, next)\n          }\n        }\n      }),\n  }\n\n  const getSnapshot = (): ReadonlyMap<string, number> =>\n    new Map(counts)\n\n  return { sink, getSnapshot }\n}\n\n/**\n * makeRingBufferSink\uFF1A\n * - \u521B\u5EFA\u4E00\u4E2A\u7B80\u5355\u7684\u73AF\u5F62\u7F13\u51B2\u533A DebugSink\uFF0C\u6309\u65F6\u95F4\u987A\u5E8F\u8BB0\u5F55\u6700\u8FD1 capacity \u6761\u4E8B\u4EF6\uFF1B\n * - \u9002\u5408\u4F5C\u4E3A DevTools / Playground \u7684\u201C\u4E8B\u4EF6\u65F6\u95F4\u7EBF\u201D\u57FA\u7840\u5B9E\u73B0\u3002\n */\nexport const makeRingBufferSink = (capacity = 1000): RingBufferSink => {\n  const buffer: Event[] = []\n\n  const sink: Sink = {\n    record: (event: Event) =>\n      Effect.sync(() => {\n        if (capacity <= 0) {\n          return\n        }\n        if (buffer.length >= capacity) {\n          buffer.shift()\n        }\n        buffer.push(event)\n      }),\n  }\n\n  const getSnapshot = (): ReadonlyArray<Event> => buffer.slice()\n  const clear = (): void => {\n    buffer.length = 0\n  }\n\n  return { sink, getSnapshot, clear }\n}\n\n/**\n * Debug.record\uFF1A\n * - \u5411\u5F53\u524D Fiber \u4E0A\u6302\u8F7D\u7684 Debug sinks \u53D1\u51FA\u4E00\u6761\u4E8B\u4EF6\uFF1B\n * - \u82E5\u5F53\u524D Fiber \u4E0A\u672A\u63D0\u4F9B\u4EFB\u4F55 sink\uFF0C\u5219\u6839\u636E\u8FD0\u884C\u73AF\u5883\u9009\u62E9\u515C\u5E95\u884C\u4E3A\n *   \uFF08\u6D4F\u89C8\u5668\u8D70\u5F69\u8272 console \u5206\u7EC4\uFF0CNode \u53EA\u4FDD\u8BC1\u9519\u8BEF\u7C7B\u4E8B\u4EF6\u4E0D\u4F1A\u5B8C\u5168\u4E22\u5931\uFF09\u3002\n */\nexport const record = Internal.record\n\n/**\n * noopLayer\uFF1A\n * - \u63D0\u4F9B\u4E00\u4E2A\u201C\u7A7A DebugSink \u96C6\u5408\u201D\uFF08\u5185\u90E8\u65E0\u4EFB\u4F55 Sink\uFF09\uFF0C\u76F4\u63A5\u4E22\u5F03\u6240\u6709 Debug \u4E8B\u4EF6\uFF1B\n * - \u4E3B\u8981\u7528\u4E8E\u6D4B\u8BD5\u573A\u666F\u6216\u663E\u5F0F\u5173\u95ED Debug \u80FD\u529B\u3002\n */\nexport const noopLayer = Internal.noopLayer as unknown as Layer.Layer<any, never, never>\n\n/**\n * DebugMode\uFF1A\n * - \"auto\"\uFF1A\u6839\u636E NODE_ENV \u81EA\u52A8\u9009\u62E9 dev / prod\uFF1B\n * - \"dev\"\uFF1A\u5F00\u53D1\u6A21\u5F0F\uFF0C\u8F93\u51FA\u5C3D\u91CF\u4E30\u5BCC\u7684\u8BCA\u65AD\u4FE1\u606F\uFF1B\n * - \"prod\"\uFF1A\u751F\u4EA7\u6A21\u5F0F\uFF0C\u53EA\u4FDD\u7559\u5173\u952E\u9519\u8BEF\u4E0E\u8BCA\u65AD\uFF1B\n * - \"off\"\uFF1A\u5B8C\u5168\u5173\u95ED DebugSink\uFF08\u901A\u5E38\u7528\u4E8E\u57FA\u51C6/\u7279\u6B8A\u6D4B\u8BD5\u573A\u666F\uFF09\u3002\n */\nexport type DebugMode = \"auto\" | \"dev\" | \"prod\" | \"off\"\n\nexport interface DebugLayerOptions {\n  readonly mode?: DebugMode\n  /**\n   * \u4E3A\u672A\u6765\u6269\u5C55\u9884\u7559\uFF1A\u5728 dev \u6A21\u5F0F\u4E0B\u662F\u5426\u6253\u5F00\u9AD8\u566A\u97F3\u7684 action/state \u7EA7\u522B\u65E5\u5FD7\u3002\n   * \u5F53\u524D\u5B9E\u73B0\u4E2D\u5C1A\u672A\u4F7F\u7528\u3002\n   */\n  readonly verboseActions?: boolean\n  /**\n   * \u4E3A\u672A\u6765\u6269\u5C55\u9884\u7559\uFF1A\u5728 prod \u6A21\u5F0F\u4E0B\u662F\u5426\u5C06\u5173\u952E\u4E8B\u4EF6\u6253\u5165 metrics\u3002\n   * \u5F53\u524D\u5B9E\u73B0\u4E2D\u5C1A\u672A\u4F7F\u7528\u3002\n   */\n  readonly enableMetrics?: boolean\n}\n\nconst resolveMode = (mode: DebugMode | undefined): DebugMode => {\n  if (mode && mode !== \"auto\") {\n    return mode\n  }\n\n  const env = getNodeEnv()\n  return env === \"production\" ? \"prod\" : \"dev\"\n}\n\n/**\n * Debug.layer\uFF1A\n * - \u5BF9\u5916\u7EDF\u4E00\u5165\u53E3\uFF0C\u6839\u636E\u5F53\u524D\u73AF\u5883\u6216\u663E\u5F0F\u4F20\u5165\u7684 mode \u7EC4\u5408\u4E00\u5957 Debug \u80FD\u529B\uFF1B\n * - \u9ED8\u8BA4 `mode: \"auto\"`\uFF1A\u975E production \u89C6\u4E3A dev\uFF0Cproduction \u89C6\u4E3A prod\u3002\n *\n * \u5178\u578B\u7528\u6CD5\uFF1A\n *\n *   const runtime = Runtime.make(AppImpl, {\n *     layer: Layer.mergeAll(\n *       Debug.layer(),\n *       businessLayer,\n *     ),\n *   })\n */\nexport const layer = (options?: DebugLayerOptions): Layer.Layer<any, never, never> => {\n  const mode = resolveMode(options?.mode)\n\n  switch (mode) {\n    case \"off\":\n      return Internal.noopLayer as unknown as Layer.Layer<any, never, never>\n    case \"prod\":\n      // \u751F\u4EA7\u73AF\u5883\uFF1A\u4EC5\u4FDD\u7559\u5173\u952E\u9519\u8BEF\u4E0E\u9AD8\u4EF7\u503C\u8BCA\u65AD\uFF0C\u907F\u514D\u9AD8\u566A\u97F3\u65E5\u5FD7\u3002\n      return Internal.errorOnlyLayer as unknown as Layer.Layer<any, never, never>\n    case \"dev\":\n    case \"auto\": {\n      // \u5F00\u53D1\u73AF\u5883\uFF1A\u9ED8\u8BA4\u4EC5\u542F\u7528 Debug Sink \u7684\u6D4F\u89C8\u5668\u53CB\u597D\u8F93\u51FA\uFF0C\n      // Logger.pretty \u7531\u8C03\u7528\u65B9\u81EA\u884C\u9009\u62E9\u662F\u5426\u53E0\u52A0\uFF0C\u907F\u514D\u9690\u5F0F\u6539\u5199 logger\u3002\n      return Internal.browserConsoleLayer as unknown as Layer.Layer<any, never, never>\n    }\n  }\n}\n\n/**\n * PrettyLoggerOptions\uFF1A\u76F4\u63A5\u590D\u7528 Effect.Logger.prettyLogger \u7684\u53C2\u6570\u5F62\u72B6\u3002\n */\nexport type PrettyLoggerOptions = Parameters<typeof Logger.prettyLogger>[0]\n\n/**\n * withPrettyLogger\uFF1A\n * - \u5728\u7ED9\u5B9A Layer \u57FA\u7840\u4E0A\uFF0C\u66FF\u6362 Effect \u9ED8\u8BA4 logger \u4E3A pretty logger\uFF1B\n * - \u7B49\u4EF7\u4E8E Logger.replace(Logger.defaultLogger, Logger.prettyLogger(options))\uFF0C\n *   \u4EE5 Layer \u5F62\u5F0F\u66B4\u9732\uFF0C\u4FBF\u4E8E\u4E0E Debug.layer / \u4E1A\u52A1 Layer \u7EC4\u5408\u3002\n */\nexport const withPrettyLogger = (\n  base: Layer.Layer<any, any, any>,\n  options?: PrettyLoggerOptions\n): Layer.Layer<any, any, any> =>\n  Layer.merge(\n    base,\n    Logger.replace(\n      Logger.defaultLogger,\n      Logger.prettyLogger(options)\n    ) as unknown as Layer.Layer<any, any, any>\n  )\n\n/**\n * replace\uFF1A\n * - \u9AD8\u7EA7\u7528\u6CD5\uFF1A\u5B8C\u5168\u4F7F\u7528\u8C03\u7528\u65B9\u63D0\u4F9B\u7684 Sink Layer \u63A5\u7BA1 Debug \u80FD\u529B\uFF1B\n * - \u901A\u5E38\u914D\u5408 Debug.makeSink / \u81EA\u5B9A\u4E49 Sink \u4F7F\u7528\uFF1B\n * - \u4E0E Debug.layer \u4E92\u65A5\uFF1A\u540C\u4E00\u4F5C\u7528\u57DF\u5185\u5EFA\u8BAE\u4E8C\u9009\u4E00\u3002\n */\nexport const replace = (sinks: ReadonlyArray<Sink>): Layer.Layer<any, never, never> =>\n  Layer.locallyScoped(\n    internal.currentDebugSinks,\n    sinks as ReadonlyArray<Internal.Sink>,\n  ) as Layer.Layer<any, never, never>\n\n/**\n * appendSinks\uFF1A\n * - \u5728\u5F53\u524D Fiber \u7684 Debug sinks \u96C6\u5408\u57FA\u7840\u4E0A\u201C\u8FFD\u52A0\u201D sinks\uFF08\u4E0D\u8986\u76D6\u8C03\u7528\u65B9\u5DF2\u6709 sinks\uFF09\uFF1B\n * - \u5178\u578B\u7528\u4E8E devtoolsHubLayer / traceLayer \u7B49\u88C5\u9970\u5668\u573A\u666F\u3002\n */\nexport const appendSinks = (sinks: ReadonlyArray<Sink>): Layer.Layer<any, never, never> =>\n  Layer.fiberRefLocallyScopedWith(\n    Internal.currentDebugSinks,\n    (current) => [...current, ...(sinks as ReadonlyArray<Internal.Sink>)],\n  ) as Layer.Layer<any, never, never>\n\n/**\n * devtoolsHubLayer\uFF1A\n * - \u8FFD\u52A0 DevtoolsHub Sink\uFF0C\u7528\u4E8E\u5728\u8FDB\u7A0B/\u9875\u9762\u5185\u805A\u5408 Debug \u4E8B\u4EF6\u5FEB\u7167\uFF08DevtoolsSnapshot\uFF09\uFF1B\n * - \u4EE5\u201C\u8FFD\u52A0 sinks\u201D\u7684\u65B9\u5F0F\u5DE5\u4F5C\uFF0C\u4E0D\u4F1A\u8986\u76D6 Debug.layer / Debug.replace / \u81EA\u5B9A\u4E49 sinks\u3002\n */\nexport function devtoolsHubLayer(options?: DevtoolsHubOptions): Layer.Layer<any, never, never>\nexport function devtoolsHubLayer(\n  base: Layer.Layer<any, any, any>,\n  options?: DevtoolsHubOptions,\n): Layer.Layer<any, never, any>\nexport function devtoolsHubLayer(\n  baseOrOptions?: Layer.Layer<any, any, any> | DevtoolsHubOptions,\n  maybeOptions?: DevtoolsHubOptions,\n): Layer.Layer<any, never, any> {\n  // Layer \u5728 effect v3 \u8FD0\u884C\u65F6\u662F\u4E00\u4E2A\u5E26 `_op_layer` \u6807\u8BB0\u7684\u5BF9\u8C61\u3002\n  const isLayerValue = (value: unknown): value is Layer.Layer<any, any, any> =>\n    typeof value === \"object\" && value !== null && \"_op_layer\" in (value as Record<string, unknown>)\n\n  const hasBase = isLayerValue(baseOrOptions)\n  const base = hasBase\n    ? (baseOrOptions as Layer.Layer<any, any, any>)\n    : (Layer.empty as unknown as Layer.Layer<any, any, any>)\n  const options = hasBase\n    ? maybeOptions\n    : (baseOrOptions as DevtoolsHubOptions | undefined)\n\n  DevtoolsHub.configureDevtoolsHub(options)\n  const append = appendSinks([DevtoolsHub.devtoolsHubSink])\n  const appendConvergeStaticIr =\n    ConvergeStaticIrCollector.appendConvergeStaticIrCollectors([\n      DevtoolsHub.devtoolsHubConvergeStaticIrCollector,\n    ])\n  const enableExportableDiagnostics = diagnosticsLevel(options?.diagnosticsLevel ?? \"light\")\n\n  // FiberRef \u5C42\u9700\u8981\u4FDD\u8BC1 base \u5148\u5EFA\u7ACB sinks\uFF0C\u518D\u7531 append \u8FFD\u52A0\uFF1BprovideMerge(append, base)\n  // \u4F1A\u5148\u6784\u5EFA base\uFF0C\u518D\u5E94\u7528 append \u7684 FiberRefs patch\uFF0C\u907F\u514D\u88AB\u8986\u76D6\u3002\n  return Layer.provideMerge(\n    Layer.mergeAll(append, enableExportableDiagnostics, appendConvergeStaticIr) as Layer.Layer<\n      any,\n      never,\n      any\n    >,\n    base,\n  ) as Layer.Layer<any, never, any>\n}\n\n/**\n * runtimeLabel\uFF1A\n * - \u5728\u5F53\u524D Fiber \u4F5C\u7528\u57DF\u5185\u4E3A Debug \u4E8B\u4EF6\u9644\u52A0\u4E00\u4E2A\u903B\u8F91 Runtime \u6807\u8BC6\uFF08\u5982 App \u540D\u79F0 / \u573A\u666F\u6807\u7B7E\uFF09\uFF1B\n * - DevTools \u53EF\u4EE5\u636E\u6B64\u5C06 Debug \u4E8B\u4EF6\u6309 Runtime \u5206\u7EC4\u5C55\u793A\u3002\n */\nexport const runtimeLabel = (label: string): Layer.Layer<any, never, never> =>\n  Layer.fiberRefLocallyScopedWith(\n    internal.currentRuntimeLabel as any,\n    () => label,\n  ) as Layer.Layer<any, never, never>\n\n/**\n * ModuleTraitsDebug\uFF1A\n * - Devtools / \u811A\u672C\u4F7F\u7528\u7684 StateTrait \u8C03\u8BD5\u89C6\u56FE\uFF1B\n * - program \u662F\u5B8C\u6574 Program\uFF0Cgraph / plan \u4E3A\u5176\u4E2D\u7684\u7ED3\u6784\u5316\u5B50\u96C6\u3002\n */\nexport interface ModuleTraitsDebug {\n  readonly program?: StateTraitProgram<any>\n  readonly graph?: StateTraitGraph\n  readonly plan?: StateTraitPlan\n}\n\n/**\n * ModuleTraitsFinalItem\uFF1A\n * - 023\uFF1A\u7528\u4E8E\u6D4B\u8BD5/\u8BCA\u65AD\u679A\u4E3E\u201C\u6700\u7EC8 traits \u6E05\u5355\u201D\uFF08\u6765\u81EA runtime \u521D\u59CB\u5316\u9636\u6BB5\u7684 finalize snapshot\uFF09\u3002\n */\nexport interface ModuleTraitsFinalItem {\n  readonly traitId: string\n  readonly name: string\n  readonly description?: string\n  readonly provenance: ModuleTraits.TraitProvenance\n}\n\n/**\n * getModuleTraits\uFF1A\n * - \u4ECE Module \u5B9A\u4E49\u5BF9\u8C61\u4E2D\u8BFB\u53D6 StateTraitProgram\uFF08\u82E5\u5B58\u5728\uFF09\uFF0C\u5E76\u8FD4\u56DE\u8C03\u8BD5\u89C6\u56FE\uFF1B\n * - \u82E5\u6A21\u5757\u672A\u4F7F\u7528 traits \u69FD\u4F4D\uFF0C\u5219\u8FD4\u56DE\u7A7A\u5BF9\u8C61\u3002\n */\nexport const getModuleTraits = (\n  module:\n    | ModuleTag<string, AnyModuleShape>\n    | ModuleLike<string, AnyModuleShape, any>,\n): ModuleTraitsDebug => {\n  const moduleTag = (module as any).tag ? (module as any).tag : module\n\n  const program = getModuleTraitsProgram(moduleTag as any) as\n    | StateTraitProgram<any>\n    | undefined\n\n  if (!program) {\n    return {}\n  }\n\n  return {\n    program,\n    graph: program.graph,\n    plan: program.plan,\n  }\n}\n\n/**\n * getModuleTraitsById\uFF1A\n * - \u6309 moduleId \u67E5\u8BE2 StateTraitProgram\uFF08\u82E5\u5DF2\u5728 Module.make \u9636\u6BB5\u6CE8\u518C\uFF09\uFF0C\u5E76\u8FD4\u56DE\u8C03\u8BD5\u89C6\u56FE\uFF1B\n * - \u7528\u4E8E Devtools \u7B49\u57FA\u4E8E Debug \u4E8B\u4EF6\uFF08\u53EA\u6709 moduleId \u5B57\u7B26\u4E32\uFF09\u7684\u573A\u666F\u3002\n */\nexport const getModuleTraitsById = (\n  moduleId: string,\n): ModuleTraitsDebug | undefined => {\n  const program = ModuleTraitsRegistry.getModuleProgramById(moduleId)\n  if (!program) {\n    return undefined\n  }\n  return {\n    program,\n    graph: program.graph,\n    plan: program.plan,\n  }\n}\n\n/**\n * getModuleTraitsSnapshot\uFF1A\n * - \u4ECE ModuleRuntime \u5B9E\u4F8B\u4E2D\u8BFB\u53D6 023 \u7684\u6700\u7EC8 traits \u5FEB\u7167\uFF08\u82E5\u5C1A\u672A finalize \u5219\u4E3A undefined\uFF09\u3002\n */\nexport const getModuleTraitsSnapshot = (\n  runtime: ModuleRuntime<any, any>,\n): ModuleTraits.ModuleTraitsSnapshot | undefined => {\n  try {\n    const internals = getRuntimeInternals(runtime as any)\n    return internals.traits.getModuleTraitsSnapshot()\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * getModuleFinalTraits\uFF1A\n * - \u4ECE 023 \u7684\u6700\u7EC8 traits \u5FEB\u7167\u5BFC\u51FA\u201C\u6700\u5C0F\u53EF\u679A\u4E3E\u6E05\u5355\u201D\uFF0C\u7528\u4E8E\u6D4B\u8BD5\u4E0E\u8BCA\u65AD\u5C55\u793A\uFF1B\n * - \u8F93\u51FA\u987A\u5E8F\u4E0E snapshot \u4E00\u81F4\uFF08\u786E\u5B9A\u6027\uFF09\u3002\n */\nexport const getModuleFinalTraits = (\n  runtime: ModuleRuntime<any, any>,\n): ReadonlyArray<ModuleTraitsFinalItem> => {\n  const snapshot = getModuleTraitsSnapshot(runtime)\n  if (!snapshot) return []\n\n  return snapshot.traits.map((t) => ({\n    traitId: t.traitId,\n    name: t.name,\n    description: t.description,\n    provenance: snapshot.provenanceIndex[t.traitId]!,\n  }))\n}\n\n/**\n * traceLayer\uFF1A\n * - \u4F5C\u4E3A\u88C5\u9970\u5668\u5728\u5F53\u524D Fiber \u7684 Debug sinks \u96C6\u5408\u57FA\u7840\u4E0A\u8FFD\u52A0\u4E00\u4E2A\u4EC5\u5904\u7406 `trace:*` \u7684 Sink\uFF1B\n * - \u9ED8\u8BA4\u884C\u4E3A\u662F\u5C06 trace \u4E8B\u4EF6\u4EE5 Debug \u65E5\u5FD7\u8F93\u51FA\uFF08logDebug\uFF09\uFF0C\n *   \u8C03\u7528\u65B9\u53EF\u4EE5\u901A\u8FC7\u4F20\u5165\u81EA\u5B9A\u4E49 handler \u5C06 trace \u4E8B\u4EF6\u5199\u5165 ring buffer / DevToolsBridge \u7B49\uFF1B\n * - \u6B63\u786E\u7528\u6CD5\u793A\u4F8B\uFF1A\n *\n *   const layer = Debug.traceLayer(\n *     Debug.layer({ mode: \"dev\" }),\n *     (event) => Effect.logInfo({ traceEvent: event }),\n *   )\n */\nconst isLayer = (value: unknown): value is Layer.Layer<any, any, any> =>\n  typeof value === \"object\" && value !== null && \"_op_layer\" in (value as Record<string, unknown>)\n\nexport function traceLayer(\n  onTrace?: (event: Event) => Effect.Effect<void>,\n): Layer.Layer<any, never, never>\nexport function traceLayer(\n  base: Layer.Layer<any, any, any>,\n  onTrace?: (event: Event) => Effect.Effect<void>,\n): Layer.Layer<any, never, any>\nexport function traceLayer(\n  baseOrHandler?: Layer.Layer<any, any, any> | ((event: Event) => Effect.Effect<void>),\n  maybeOnTrace?: (event: Event) => Effect.Effect<void>,\n): Layer.Layer<any, never, any> {\n  const hasBase = isLayer(baseOrHandler)\n  const base = hasBase\n    ? (baseOrHandler as Layer.Layer<any, any, any>)\n    : (Layer.empty as unknown as Layer.Layer<any, any, any>)\n  const onTrace = hasBase ? maybeOnTrace : (baseOrHandler as ((event: Event) => Effect.Effect<void>) | undefined)\n\n  const traceSink: Sink = {\n    record: (event: Event) =>\n      typeof event.type === \"string\" && event.type.startsWith(\"trace:\")\n        ? (onTrace ? onTrace(event) : Effect.logDebug({ traceEvent: event }))\n        : Effect.void,\n  }\n\n  // \u901A\u8FC7 FiberRef \u8FFD\u52A0 trace sink\uFF1A\u5728\u5F53\u524D Fiber \u7684 sinks \u96C6\u5408\u57FA\u7840\u4E0A\u8FFD\u52A0\uFF0C\n  // \u4E0D\u518D\u4F9D\u8D56\u4EFB\u4F55 DebugHub / Tag\uFF0C\u53EA\u4F7F\u7528 FiberRef.currentDebugSinks \u4F5C\u4E3A\u5355\u4E00\u771F\u76F8\u3002\n  const appendTrace = Layer.fiberRefLocallyScopedWith(\n    Internal.currentDebugSinks,\n    (sinks) => [...sinks, traceSink],\n  )\n\n  // \u540C devtoolsHubLayer\uFF1A\u5148\u6784\u5EFA base\uFF0C\u518D\u7531 appendTrace \u8FFD\u52A0 FiberRef sinks\u3002\n  return Layer.provideMerge(appendTrace, base as Layer.Layer<any, any, any>) as Layer.Layer<any, never, any>\n}\n", "import { Effect, FiberRef } from \"effect\"\nimport type { JsonValue } from \"../../observability/jsonValue.js\"\nimport type { EvidencePackage, EvidencePackageSource } from \"../../observability/evidence.js\"\nimport { exportEvidencePackage, OBSERVABILITY_PROTOCOL_VERSION } from \"../../observability/evidence.js\"\nimport type { ConvergeStaticIrExport } from \"../../state-trait/converge-ir.js\"\nimport type { ConvergeStaticIrCollector } from \"./ConvergeStaticIrCollector.js\"\nimport {\n  currentDiagnosticsLevel,\n  clearRuntimeDebugEventSeq,\n  toRuntimeDebugEventRef,\n  type Event,\n  type RuntimeDebugEventRef,\n  type Sink,\n} from \"./DebugSink.js\"\n\n/**\n * DevtoolsHub\uFF1A\n * - \u8FDB\u7A0B/\u9875\u9762\u7EA7\u7684 Debug \u4E8B\u4EF6\u805A\u5408\u5668\uFF08\u5168\u5C40\u5355\u4F8B\uFF09\u3002\n *\n * \u6CE8\u610F\uFF1A\u8BE5 Hub \u4EC5\u5728\u663E\u5F0F\u542F\u7528 devtoolsHubLayer \u65F6\u624D\u4F1A\u88AB\u6302\u5165 Debug sinks\uFF0C\n * \u4F46 Snapshot API \u672C\u8EAB\u59CB\u7EC8\u53EF\u7528\uFF08\u672A\u542F\u7528\u65F6\u8FD4\u56DE\u7A7A\u5FEB\u7167\uFF09\u3002\n *\n * \u6027\u80FD\u8BF4\u660E\uFF1A\n * - Devtools \u7684 Debug \u4E8B\u4EF6\u5728\u9AD8\u9891\u573A\u666F\u4F1A\u975E\u5E38\u5BC6\u96C6\uFF08EffectOp / Trait / StateTxn \u7B49\uFF09\uFF1B\n * - \u65E7\u5B9E\u73B0\u4F1A\u5728\u6BCF\u6761\u4E8B\u4EF6\u5230\u6765\u65F6\u590D\u5236 ringBuffer \u4E0E Map \u6765\u6784\u9020\u201C\u4E0D\u53EF\u53D8\u5FEB\u7167\u201D\uFF0C\u6210\u672C\u4E3A O(bufferSize)\uFF1B\n * - \u5F53\u524D\u5B9E\u73B0\u6539\u4E3A\uFF1ASnapshot \u76F4\u63A5\u5F15\u7528\u5185\u90E8\u7684 Map/Array\uFF08\u53EA\u8BFB\u7EA6\u5B9A\uFF09\uFF0C\u5E76\u5728\u5FAE\u4EFB\u52A1\u4E2D\u6279\u91CF\u901A\u77E5\u8BA2\u9605\u8005\uFF1B\n *   \u8FD9\u6837\u907F\u514D per-event \u62F7\u8D1D\uFF0C\u663E\u8457\u964D\u4F4E\u5BF9\u4E1A\u52A1\u6E32\u67D3/\u8F93\u5165\u7684\u4E3B\u7EBF\u7A0B\u5E72\u6270\u3002\n */\n\nexport interface DevtoolsSnapshot {\n  readonly instances: ReadonlyMap<string, number>\n  readonly events: ReadonlyArray<RuntimeDebugEventRef>\n  readonly latestStates: ReadonlyMap<string, JsonValue>\n  readonly latestTraitSummaries: ReadonlyMap<string, JsonValue>\n  /**\n   * exportBudget\uFF1A\n   * - \u8BB0\u5F55\u5BFC\u51FA\u8FB9\u754C\uFF08JsonValue \u6295\u5F71/\u88C1\u526A\uFF09\u5E26\u6765\u7684\u201C\u964D\u7EA7\u8BA1\u6570\u201D\uFF0C\u7528\u4E8E\u89E3\u91CA\u9884\u7B97\u5F71\u54CD\uFF1B\n   * - \u8BA1\u6570\u4E3A\u7D2F\u8BA1\u503C\uFF08\u4E0E ring buffer \u7684\u7A97\u53E3\u53EF\u80FD\u4E0D\u4E00\u81F4\uFF09\uFF1B\u8C03\u7528 clearDevtoolsEvents \u4F1A\u6E05\u96F6\u3002\n   */\n  readonly exportBudget: {\n    readonly dropped: number\n    readonly oversized: number\n  }\n}\n\nexport interface DevtoolsHubOptions {\n  readonly bufferSize?: number\n}\n\n// ---- Global mutable state (singleton) ----\n\nconst instances = new Map<string, number>()\nconst latestStates = new Map<string, JsonValue>()\nconst latestTraitSummaries = new Map<string, JsonValue>()\nconst instanceLabels = new Map<string, string>()\nconst convergeStaticIrByDigest = new Map<string, ConvergeStaticIrExport>()\n\nconst exportBudget = {\n  dropped: 0,\n  oversized: 0,\n}\n\nlet lastRunTs = 0\nlet lastRunTsSeq = 0\n\nconst nextRunId = (): string => {\n  const ts = Date.now()\n  if (ts === lastRunTs) {\n    lastRunTsSeq += 1\n  } else {\n    lastRunTs = ts\n    lastRunTsSeq = 0\n  }\n\n  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`\n}\n\nlet currentRunId = nextRunId()\nlet nextSeq = 1\n\nlet bufferSize = 500\nconst ringBuffer: RuntimeDebugEventRef[] = []\nconst ringBufferSeq: number[] = []\n\n// Snapshot \u76F4\u63A5\u5F15\u7528\u5185\u90E8\u7ED3\u6784\uFF08\u53EA\u8BFB\u7EA6\u5B9A\uFF09\uFF0C\u907F\u514D\u9AD8\u9891\u573A\u666F\u4E0B\u7684\u62F7\u8D1D\u6210\u672C\u3002\nconst currentSnapshot: DevtoolsSnapshot = {\n  instances,\n  events: ringBuffer,\n  latestStates,\n  latestTraitSummaries,\n  exportBudget,\n}\n\nconst listeners = new Set<() => void>()\n\nlet notifyScheduled = false\nconst scheduleNotify = () => {\n  if (notifyScheduled) return\n  notifyScheduled = true\n  queueMicrotask(() => {\n    notifyScheduled = false\n    for (const listener of listeners) {\n      listener()\n    }\n  })\n}\n\nlet devtoolsEnabled = false\n\nexport const configureDevtoolsHub = (options?: DevtoolsHubOptions) => {\n  devtoolsEnabled = true\n  if (typeof options?.bufferSize === \"number\" && Number.isFinite(options.bufferSize)) {\n    const next = Math.floor(options.bufferSize)\n    bufferSize = next > 0 ? next : bufferSize\n    // \u82E5\u7F29\u5C0F bufferSize\uFF0C\u88C1\u526A\u65E7\u4E8B\u4EF6\u7A97\u53E3\u3002\n    if (ringBuffer.length > bufferSize) {\n      const excess = ringBuffer.length - bufferSize\n      ringBuffer.splice(0, excess)\n      ringBufferSeq.splice(0, excess)\n    }\n    scheduleNotify()\n  }\n}\n\nexport const isDevtoolsEnabled = (): boolean => devtoolsEnabled\n\n// ---- Snapshot public helpers ----\n\nexport const getDevtoolsSnapshot = (): DevtoolsSnapshot => currentSnapshot\n\nexport const subscribeDevtoolsSnapshot = (listener: () => void): (() => void) => {\n  listeners.add(listener)\n  return () => {\n    listeners.delete(listener)\n  }\n}\n\nexport const getDevtoolsRunId = (): string => currentRunId\n\nexport const setDevtoolsRunId = (runId: string): void => {\n  if (typeof runId !== \"string\" || runId.length === 0) return\n  currentRunId = runId\n}\n\nexport const startDevtoolsRun = (runId?: string): string => {\n  currentRunId = typeof runId === \"string\" && runId.length > 0 ? runId : nextRunId()\n  nextSeq = 1\n  clearRuntimeDebugEventSeq()\n  clearDevtoolsEvents()\n  return currentRunId\n}\n\nexport const clearDevtoolsEvents = (): void => {\n  ringBuffer.length = 0\n  ringBufferSeq.length = 0\n  exportBudget.dropped = 0\n  exportBudget.oversized = 0\n  scheduleNotify()\n}\n\nexport const setInstanceLabel = (instanceId: string, label: string): void => {\n  instanceLabels.set(instanceId, label)\n  scheduleNotify()\n}\n\nexport const getInstanceLabel = (instanceId: string): string | undefined =>\n  instanceLabels.get(instanceId)\n\nconst registerConvergeStaticIr = (ir: ConvergeStaticIrExport): void => {\n  convergeStaticIrByDigest.set(ir.staticIrDigest, ir)\n}\n\nexport const devtoolsHubConvergeStaticIrCollector: ConvergeStaticIrCollector = {\n  register: registerConvergeStaticIr,\n}\n\nexport const exportDevtoolsEvidencePackage = (options?: {\n  readonly runId?: string\n  readonly source?: EvidencePackageSource\n  readonly protocolVersion?: string\n}): EvidencePackage => {\n  const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION\n  const runId = options?.runId ?? currentRunId\n  const source = options?.source ?? { host: \"unknown\" }\n\n  const events = ringBuffer.map((payload, i) => ({\n    protocolVersion,\n    runId,\n    seq: ringBufferSeq[i] ?? i + 1,\n    timestamp: payload.timestamp,\n    type: \"debug:event\",\n    payload: payload as unknown as JsonValue,\n  }))\n\n  const isRecord = (value: unknown): value is Record<string, unknown> =>\n    typeof value === \"object\" && value !== null && !Array.isArray(value)\n\n  // Full \u8BCA\u65AD\u4E0B\uFF1A\u6309 staticIrDigest \u53BB\u91CD\u5BFC\u51FA\u5BF9\u5E94\u7684 ConvergeStaticIR\uFF08\u4F9B\u79BB\u7EBF\u89E3\u91CA/\u56DE\u653E\uFF09\u3002\n  const convergeDigests = new Set<string>()\n  let sawFullConverge = false\n\n  for (const ref of ringBuffer) {\n    if (ref.kind !== \"trait:converge\") continue\n    const meta = ref.meta\n    if (!isRecord(meta)) continue\n\n    const digest = meta.staticIrDigest\n    if (typeof digest === \"string\" && digest.length > 0) {\n      convergeDigests.add(digest)\n    }\n\n    const dirty = meta.dirty\n    if (isRecord(dirty) && typeof dirty.rootCount === \"number\") {\n      sawFullConverge = true\n    }\n  }\n\n  let summary: JsonValue | undefined\n  if (sawFullConverge && convergeDigests.size > 0) {\n    const staticIrByDigest: Record<string, JsonValue> = {}\n    for (const digest of convergeDigests) {\n      const ir = convergeStaticIrByDigest.get(digest)\n      if (ir) {\n        staticIrByDigest[digest] = ir as unknown as JsonValue\n      }\n    }\n    if (Object.keys(staticIrByDigest).length > 0) {\n      summary = { converge: { staticIrByDigest } } as unknown as JsonValue\n    }\n  }\n\n  return exportEvidencePackage({\n    protocolVersion,\n    runId,\n    source,\n    events,\n    summary,\n  })\n}\n\n// ---- Hub Sink ----\n\nexport const devtoolsHubSink: Sink = {\n  record: (event: Event) =>\n    Effect.gen(function* () {\n      // NOTE: Hub \u662F\u5168\u5C40\u5355\u4F8B\uFF0C\u4F46\u4E8B\u4EF6\u7684\u201C\u662F\u5426\u53EF\u5BFC\u51FA/\u662F\u5426\u5199\u5165 buffer\u201D\u7531 FiberRef \u63A7\u5236\uFF0C\n      // \u4EE5\u652F\u6301\u540C\u8FDB\u7A0B\u5185\u4E0D\u540C scope \u7684\u6027\u80FD\u57FA\u7EBF/\u8BCA\u65AD\u5206\u6863\u3002\n      const level = yield* FiberRef.get(currentDiagnosticsLevel)\n\n      // trace:instanceLabel\uFF1A\u4E3A runtime \u5B9E\u4F8B\u8BBE\u7F6E\u6613\u8BFB\u540D\u79F0\u3002\n      if (event.type === \"trace:instanceLabel\") {\n        const instanceId = (event as any).instanceId as string | undefined\n        const data = (event as any).data\n        const label =\n          data && typeof data === \"object\" && \"label\" in data ? String((data as any).label) : undefined\n        if (instanceId && label) {\n          instanceLabels.set(instanceId, label)\n        }\n      }\n\n      // \u5B9E\u4F8B\u8BA1\u6570\uFF1A\u6309 runtimeLabel::moduleId \u7EF4\u5EA6\u7EF4\u62A4\u6D3B\u8DC3\u5B9E\u4F8B\u6570\u91CF\u3002\n      if (event.type === \"module:init\" || event.type === \"module:destroy\") {\n        const moduleId = (event as any).moduleId ?? \"unknown\"\n        const runtimeLabel = (event as any).runtimeLabel ?? \"unknown\"\n        const key = `${runtimeLabel}::${moduleId}`\n        const prev = instances.get(key) ?? 0\n        if (event.type === \"module:init\") {\n          instances.set(key, prev + 1)\n        } else {\n          const next = prev - 1\n          if (next <= 0) {\n            instances.delete(key)\n          } else {\n            instances.set(key, next)\n          }\n        }\n      }\n\n      const ref = toRuntimeDebugEventRef(event, {\n        diagnosticsLevel: level,\n        onMetaProjection: ({ stats }) => {\n          exportBudget.dropped += stats.dropped\n          exportBudget.oversized += stats.oversized\n        },\n      })\n      if (!ref) {\n        // off \u6863\u4F4D\uFF1A\u4E0D\u5199\u5165 ring buffer / latestStates\uFF0C\u4F46\u5141\u8BB8\u7EF4\u62A4\u6700\u5C0F\u8BA1\u6570\u4E0E\u6807\u7B7E\u3002\n        scheduleNotify()\n        return\n      }\n\n      // latestStates / latestTraitSummaries\uFF1A\u6309 runtimeLabel::moduleId::instanceId \u8BB0\u5F55\u6700\u65B0\u5FEB\u7167\u3002\n      if (ref.kind === \"state\" && ref.label === \"state:update\") {\n        const runtimeLabel = ref.runtimeLabel ?? \"unknown\"\n        const key = `${runtimeLabel}::${ref.moduleId}::${ref.instanceId}`\n\n        if (ref.meta && typeof ref.meta === \"object\" && !Array.isArray(ref.meta)) {\n          const anyMeta = ref.meta as any\n          if (\"state\" in anyMeta) {\n            latestStates.set(key, anyMeta.state as JsonValue)\n          }\n          if (\"traitSummary\" in anyMeta && anyMeta.traitSummary !== undefined) {\n            latestTraitSummaries.set(key, anyMeta.traitSummary as JsonValue)\n          }\n        }\n      }\n\n      // module:destroy \u65F6\u6E05\u7406\u5B9E\u4F8B\u6807\u7B7E\u3002\n      if (event.type === \"module:destroy\") {\n        const instanceId = (event as any).instanceId as string | undefined\n        if (instanceId) {\n          instanceLabels.delete(instanceId)\n        }\n      }\n\n      // ring buffer\uFF1A\u4FDD\u7559\u6700\u8FD1 bufferSize \u6761 RuntimeDebugEventRef\u3002\n      if (bufferSize > 0) {\n        const seq = nextSeq++\n        if (ringBuffer.length >= bufferSize) {\n          ringBuffer.shift()\n          ringBufferSeq.shift()\n        }\n        ringBuffer.push(ref)\n        ringBufferSeq.push(seq)\n      }\n\n      scheduleNotify()\n    }),\n}\n"],
  "mappings": "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",
  "names": ["Effect", "runtimeLabel", "getDevtoolsSnapshot", "subscribeDevtoolsSnapshot", "clearDevtoolsEvents", "getDevtoolsRunId", "setDevtoolsRunId", "startDevtoolsRun", "setInstanceLabel", "getInstanceLabel", "exportEvidencePackage", "isDevtoolsEnabled", "Effect", "runtimeLabel", "record", "noopLayer"]
}
