@logixjs/core 0.0.1 → 1.0.0

package/dist/chunk-GNEN7NKO.js

@@ -0,0 +1,908 @@
+import {
+  getModuleProgramById
+} from "./chunk-EB46EYI7.js";
+import {
+  appendConvergeStaticIrCollectors
+} from "./chunk-RHJIGDUE.js";
+import {
+  getModuleTraitsProgram,
+  getRuntimeInternals
+} from "./chunk-63ZQ5RIN.js";
+import {
+  getNodeEnv
+} from "./chunk-S4S5N4BJ.js";
+import {
+  getGlobalHostScheduler
+} from "./chunk-MYKNINNN.js";
+import {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage
+} from "./chunk-R4LFQGP3.js";
+import {
+  browserConsoleLayer,
+  browserDiagnosticConsoleLayer,
+  clearRuntimeDebugEventSeq,
+  currentDebugSinks,
+  currentDiagnosticsLevel,
+  currentDiagnosticsMaterialization,
+  currentRuntimeLabel,
+  currentTraceMode,
+  currentTraitConvergeDiagnosticsSampling,
+  diagnosticsLevel,
+  diagnosticsMaterialization,
+  errorOnlyLayer,
+  noopLayer,
+  record,
+  toRuntimeDebugEventRef,
+  traceMode,
+  traitConvergeDiagnosticsSampling
+} from "./chunk-V2SBGVDO.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/Debug.ts
+var Debug_exports = {};
+__export(Debug_exports, {
+  appendSinks: () => appendSinks,
+  clearDevtoolsEvents: () => clearDevtoolsEvents2,
+  devtoolsHubLayer: () => devtoolsHubLayer,
+  diagnosticsLevel: () => diagnosticsLevel2,
+  diagnosticsMaterialization: () => diagnosticsMaterialization2,
+  exportEvidencePackage: () => exportEvidencePackage2,
+  getDevtoolsRunId: () => getDevtoolsRunId2,
+  getDevtoolsSnapshot: () => getDevtoolsSnapshot2,
+  getDevtoolsSnapshotByRuntimeLabel: () => getDevtoolsSnapshotByRuntimeLabel2,
+  getDevtoolsSnapshotToken: () => getDevtoolsSnapshotToken2,
+  getInstanceLabel: () => getInstanceLabel2,
+  getModuleFinalTraits: () => getModuleFinalTraits,
+  getModuleTraits: () => getModuleTraits,
+  getModuleTraitsById: () => getModuleTraitsById,
+  getModuleTraitsSnapshot: () => getModuleTraitsSnapshot,
+  internal: () => internal,
+  isDevtoolsEnabled: () => isDevtoolsEnabled2,
+  layer: () => layer,
+  makeModuleRuntimeCounterSink: () => makeModuleRuntimeCounterSink,
+  makeRingBufferSink: () => makeRingBufferSink,
+  noopLayer: () => noopLayer2,
+  record: () => record2,
+  replace: () => replace,
+  runtimeLabel: () => runtimeLabel,
+  setDevtoolsRunId: () => setDevtoolsRunId2,
+  setInstanceLabel: () => setInstanceLabel2,
+  startDevtoolsRun: () => startDevtoolsRun2,
+  subscribeDevtoolsSnapshot: () => subscribeDevtoolsSnapshot2,
+  toRuntimeDebugEventRef: () => toRuntimeDebugEventRef2,
+  traceLayer: () => traceLayer,
+  traceMode: () => traceMode2,
+  traitConvergeDiagnosticsSampling: () => traitConvergeDiagnosticsSampling2,
+  withPrettyLogger: () => withPrettyLogger
+});
+import { Effect as Effect2, Layer, Logger } from "effect";
+
+// src/internal/runtime/core/DevtoolsHub.ts
+import { Effect } from "effect";
+var instances = /* @__PURE__ */ new Map();
+var instanceLabels = /* @__PURE__ */ new Map();
+var convergeStaticIrByDigest = /* @__PURE__ */ new Map();
+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 = () => {
+  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 bufferSize = 500;
+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) {
+    ringTrimMode = "disabled";
+    ringTrimThreshold = 0;
+    return prevMode !== ringTrimMode || prevThreshold !== ringTrimThreshold;
+  }
+  ringTrimMode = "strict";
+  ringTrimThreshold = bufferSize;
+  return prevMode !== ringTrimMode || prevThreshold !== ringTrimThreshold;
+};
+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 (bucket.exportBudget.dropped !== 0 || bucket.exportBudget.oversized !== 0) {
+    bucket.exportBudget.dropped = 0;
+    bucket.exportBudget.oversized = 0;
+    changed = true;
+  }
+  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: globalRing.view,
+  latestStates,
+  latestTraitSummaries,
+  exportBudget
+};
+var listeners = /* @__PURE__ */ new Set();
+var notifyScheduled = false;
+var scheduleNotify = () => {
+  if (listeners.size === 0) return;
+  if (notifyScheduled) return;
+  notifyScheduled = true;
+  getGlobalHostScheduler().scheduleMicrotask(() => {
+    notifyScheduled = false;
+    for (const listener of listeners) {
+      listener();
+    }
+  });
+};
+var devtoolsEnabled = false;
+var bumpSnapshotToken = () => {
+  snapshotToken += 1;
+  currentSnapshot.snapshotToken = snapshotToken;
+};
+var markSnapshotChanged = () => {
+  bumpSnapshotToken();
+  scheduleNotify();
+};
+var configureDevtoolsHub = (options) => {
+  devtoolsEnabled = true;
+  if (typeof options?.bufferSize === "number" && Number.isFinite(options.bufferSize)) {
+    const next = Math.floor(options.bufferSize);
+    const nextBufferSize = next >= 0 ? next : 0;
+    if (nextBufferSize !== bufferSize) {
+      bufferSize = nextBufferSize;
+      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 = () => {
+  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 () => {
+    listeners.delete(listener);
+  };
+};
+var getDevtoolsRunId = () => currentRunId;
+var setDevtoolsRunId = (runId) => {
+  if (typeof runId !== "string" || runId.length === 0) return;
+  if (runId !== currentRunId) {
+    currentRunId = runId;
+    markSnapshotChanged();
+  }
+};
+var startDevtoolsRun = (runId) => {
+  currentRunId = typeof runId === "string" && runId.length > 0 ? runId : nextRunId();
+  clearRuntimeDebugEventSeq();
+  clearDevtoolsEvents();
+  return currentRunId;
+};
+var clearDevtoolsEvents = (runtimeLabel2) => {
+  if (runtimeLabel2 !== void 0) {
+    if (clearRuntimeBucketEvents(normalizeRuntimeLabel(runtimeLabel2))) {
+      markSnapshotChanged();
+    }
+    return;
+  }
+  clearAllRuntimeBucketEvents();
+  markSnapshotChanged();
+};
+var setInstanceLabel = (instanceId, label) => {
+  instanceLabels.set(instanceId, label);
+  markSnapshotChanged();
+};
+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 refs = getEventRingView(globalRing);
+  const events = refs.map((payload, i) => ({
+    protocolVersion,
+    runId,
+    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();
+  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;
+    }
+    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 (convergeDigests.size > 0) {
+    const staticIrByDigest = {};
+    for (const digest of convergeDigests) {
+      const ir = convergeStaticIrByDigest.get(digest);
+      if (ir) {
+        staticIrByDigest[digest] = sawFullByDigest.has(digest) ? ir : { fieldPaths: ir.fieldPaths };
+      }
+    }
+    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* Effect.service(currentDiagnosticsLevel).pipe(Effect.orDie);
+    const materialization = yield* Effect.service(currentDiagnosticsMaterialization).pipe(Effect.orDie);
+    const eventRuntimeLabel = normalizeRuntimeLabel(event.runtimeLabel);
+    let changed = false;
+    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);
+        changed = true;
+      }
+    }
+    if (event.type === "module:init" || event.type === "module:destroy") {
+      const moduleId = normalizeKeyPart(event.moduleId);
+      const runtimeLabel2 = eventRuntimeLabel;
+      const runtimeBucket2 = getOrCreateRuntimeBucket(runtimeLabel2);
+      const instanceId = event.instanceId;
+      if (event.type === "module:init") {
+        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 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(moduleKey)) changed = true;
+        } else {
+          instances.set(moduleKey, next);
+          changed = true;
+        }
+        if (instanceId) {
+          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 projectedDropped = 0;
+    let projectedOversized = 0;
+    const ref = toRuntimeDebugEventRef(event, {
+      diagnosticsLevel: level,
+      materialization,
+      onMetaProjection: ({ stats }) => {
+        projectedDropped += stats.dropped;
+        projectedOversized += stats.oversized;
+      }
+    });
+    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) {
+      if (changed) {
+        markSnapshotChanged();
+      }
+      return;
+    }
+    const refRuntimeLabel = normalizeRuntimeLabel(ref.runtimeLabel);
+    const runtimeBucket = getOrCreateRuntimeBucket(refRuntimeLabel);
+    if (ref.kind === "state" && ref.label === "state:update") {
+      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(instanceKey, anyMeta.state);
+            runtimeBucket.latestStates.set(instanceKey, anyMeta.state);
+            changed = true;
+          }
+          if ("traitSummary" in anyMeta && anyMeta.traitSummary !== void 0) {
+            latestTraitSummaries.set(instanceKey, anyMeta.traitSummary);
+            runtimeBucket.latestTraitSummaries.set(instanceKey, anyMeta.traitSummary);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (bufferSize > 0) {
+      appendRuntimeRef(refRuntimeLabel, ref);
+      changed = true;
+    }
+    if (changed) {
+      markSnapshotChanged();
+    }
+  })
+};
+
+// src/Debug.ts
+var toRuntimeDebugEventRef2 = toRuntimeDebugEventRef;
+var internal = {
+  currentDebugSinks,
+  currentRuntimeLabel,
+  currentDiagnosticsLevel,
+  currentDiagnosticsMaterialization,
+  currentTraceMode,
+  currentTraitConvergeDiagnosticsSampling,
+  toRuntimeDebugEventRef
+};
+var getDevtoolsSnapshot2 = getDevtoolsSnapshot;
+var getDevtoolsSnapshotByRuntimeLabel2 = getDevtoolsSnapshotByRuntimeLabel;
+var getDevtoolsSnapshotToken2 = getDevtoolsSnapshotToken;
+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 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) => 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 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) => Effect2.sync(() => {
+      if (capacity <= 0) {
+        return;
+      }
+      if (!isBounded) {
+        unboundedBuffer.push(event);
+        return;
+      }
+      const writeIndex = (head + size) % boundedCapacity;
+      boundedBuffer[writeIndex] = event;
+      if (size < boundedCapacity) {
+        size += 1;
+        return;
+      }
+      head = (head + 1) % boundedCapacity;
+    })
+  };
+  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 = () => {
+    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 };
+};
+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);
+  const diagnostics = options?.diagnosticsLevel;
+  const sinks = (() => {
+    switch (mode) {
+      case "off":
+        return noopLayer;
+      case "prod":
+        return errorOnlyLayer;
+      case "dev":
+      case "auto": {
+        return options?.devConsole === "diagnostic" ? browserDiagnosticConsoleLayer : browserConsoleLayer;
+      }
+    }
+  })();
+  const trace = mode === "dev" ? traceMode2("on") : traceMode2("off");
+  const base = Layer.mergeAll(sinks, trace);
+  return diagnostics ? Layer.mergeAll(base, diagnosticsLevel2(diagnostics)) : base;
+};
+var withPrettyLogger = (base, options) => Layer.merge(
+  base,
+  Layer.effect(
+    Logger.CurrentLoggers,
+    Effect2.gen(function* () {
+      const current = yield* Effect2.service(Logger.CurrentLoggers);
+      return new Set([...current].filter((logger) => logger !== Logger.defaultLogger).concat(Logger.consolePretty(options)));
+    })
+  )
+);
+var replace = (sinks) => Layer.succeed(internal.currentDebugSinks, sinks);
+var appendSinks = (sinks) => Layer.effect(
+  internal.currentDebugSinks,
+  Effect2.gen(function* () {
+    const current = yield* internal.currentDebugSinks;
+    return [...current, ...sinks];
+  })
+);
+function devtoolsHubLayer(baseOrOptions, maybeOptions) {
+  const isLayerValue = (value) => Layer.isLayer(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 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) : Layer.empty;
+  return Layer.provideMerge(
+    Layer.mergeAll(
+      append,
+      enableExportableDiagnostics,
+      enableMaterialization,
+      enableTraceMode,
+      convergeSamplingLayer,
+      appendConvergeStaticIr
+    ),
+    base
+  );
+}
+var runtimeLabel = (label) => Layer.succeed(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 && "build" 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.effect(
+    currentDebugSinks,
+    Effect2.gen(function* () {
+      const sinks = yield* currentDebugSinks;
+      return [...sinks, traceSink];
+    })
+  );
+  return Layer.provideMerge(appendTrace, base);
+}
+
+export {
+  toRuntimeDebugEventRef2 as toRuntimeDebugEventRef,
+  internal,
+  getDevtoolsSnapshot2 as getDevtoolsSnapshot,
+  getDevtoolsSnapshotByRuntimeLabel2 as getDevtoolsSnapshotByRuntimeLabel,
+  getDevtoolsSnapshotToken2 as getDevtoolsSnapshotToken,
+  subscribeDevtoolsSnapshot2 as subscribeDevtoolsSnapshot,
+  clearDevtoolsEvents2 as clearDevtoolsEvents,
+  getDevtoolsRunId2 as getDevtoolsRunId,
+  setDevtoolsRunId2 as setDevtoolsRunId,
+  startDevtoolsRun2 as startDevtoolsRun,
+  setInstanceLabel2 as setInstanceLabel,
+  getInstanceLabel2 as getInstanceLabel,
+  exportEvidencePackage2 as exportEvidencePackage,
+  diagnosticsLevel2 as diagnosticsLevel,
+  diagnosticsMaterialization2 as diagnosticsMaterialization,
+  traceMode2 as traceMode,
+  traitConvergeDiagnosticsSampling2 as traitConvergeDiagnosticsSampling,
+  isDevtoolsEnabled2 as isDevtoolsEnabled,
+  makeModuleRuntimeCounterSink,
+  makeRingBufferSink,
+  record2 as record,
+  noopLayer2 as noopLayer,
+  layer,
+  withPrettyLogger,
+  replace,
+  appendSinks,
+  devtoolsHubLayer,
+  runtimeLabel,
+  getModuleTraits,
+  getModuleTraitsById,
+  getModuleTraitsSnapshot,
+  getModuleFinalTraits,
+  traceLayer,
+  Debug_exports
+};
+//# sourceMappingURL=chunk-GNEN7NKO.js.map