@logixjs/core 0.0.1

package/dist/Debug.cjs

@@ -0,0 +1,1821 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Debug.ts
+var Debug_exports = {};
+__export(Debug_exports, {
+  appendSinks: () => appendSinks,
+  clearDevtoolsEvents: () => clearDevtoolsEvents2,
+  devtoolsHubLayer: () => devtoolsHubLayer,
+  diagnosticsLevel: () => diagnosticsLevel,
+  exportEvidencePackage: () => exportEvidencePackage2,
+  getDevtoolsRunId: () => getDevtoolsRunId2,
+  getDevtoolsSnapshot: () => getDevtoolsSnapshot2,
+  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,
+  traitConvergeDiagnosticsSampling: () => traitConvergeDiagnosticsSampling2,
+  withPrettyLogger: () => withPrettyLogger
+});
+module.exports = __toCommonJS(Debug_exports);
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/DebugSink.ts
+var import_effect3 = require("effect");
+
+// src/internal/observability/jsonValue.ts
+var defaultOptions = {
+  maxDepth: 6,
+  maxObjectKeys: 32,
+  maxArrayLength: 32,
+  maxStringLength: 256,
+  maxJsonBytes: 4 * 1024,
+  oversizedPreviewBytes: 256
+};
+var truncateString = (value, maxLen, stats) => {
+  if (value.length <= maxLen) return value;
+  stats.oversized += 1;
+  return value.slice(0, maxLen);
+};
+var mergeDowngrade = (current, next) => {
+  if (!current) return next;
+  if (current === "non_serializable" || next === "non_serializable") return "non_serializable";
+  if (current === "oversized" || next === "oversized") return "oversized";
+  return "unknown";
+};
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var asNumber = (value, stats) => {
+  if (Number.isFinite(value)) return value;
+  stats.nonSerializable += 1;
+  return String(value);
+};
+var toJsonValueInternal = (input, options, stats, seen, depth) => {
+  if (input === null) return null;
+  switch (typeof input) {
+    case "string":
+      return truncateString(input, options.maxStringLength, stats);
+    case "number":
+      return asNumber(input, stats);
+    case "boolean":
+      return input;
+    case "bigint":
+      stats.nonSerializable += 1;
+      return truncateString(input.toString(), options.maxStringLength, stats);
+    case "symbol":
+      stats.nonSerializable += 1;
+      return truncateString(input.toString(), options.maxStringLength, stats);
+    case "function":
+      stats.nonSerializable += 1;
+      return "[Function]";
+    case "undefined":
+      stats.dropped += 1;
+      return null;
+  }
+  if (depth >= options.maxDepth) {
+    stats.oversized += 1;
+    return "[Truncated]";
+  }
+  if (input instanceof Date) {
+    return input.toISOString();
+  }
+  if (input instanceof Error) {
+    stats.nonSerializable += 1;
+    return {
+      name: truncateString(input.name, options.maxStringLength, stats),
+      message: truncateString(input.message, options.maxStringLength, stats)
+    };
+  }
+  if (typeof input === "object") {
+    if (seen.has(input)) {
+      stats.nonSerializable += 1;
+      return "[Circular]";
+    }
+    seen.add(input);
+  }
+  if (Array.isArray(input)) {
+    const out2 = [];
+    const limit2 = Math.min(input.length, options.maxArrayLength);
+    for (let i = 0; i < limit2; i++) {
+      out2.push(toJsonValueInternal(input[i], options, stats, seen, depth + 1));
+    }
+    if (input.length > limit2) {
+      stats.oversized += 1;
+      out2.push(`[...${input.length - limit2} more]`);
+    }
+    return out2;
+  }
+  if (!isPlainRecord(input)) {
+    stats.nonSerializable += 1;
+    return truncateString(String(input), options.maxStringLength, stats);
+  }
+  const entries = Object.entries(input);
+  const limit = Math.min(entries.length, options.maxObjectKeys);
+  const out = {};
+  for (let i = 0; i < limit; i++) {
+    const [rawKey, rawValue] = entries[i];
+    const key = truncateString(rawKey, options.maxStringLength, stats);
+    if (rawValue === void 0) {
+      stats.dropped += 1;
+      continue;
+    }
+    out[key] = toJsonValueInternal(rawValue, options, stats, seen, depth + 1);
+  }
+  if (entries.length > limit) {
+    stats.oversized += 1;
+    out.__truncatedKeys = entries.length - limit;
+  }
+  return out;
+};
+var projectJsonValue = (input, options) => {
+  const resolved = { ...defaultOptions, ...options ?? {} };
+  const stats = { dropped: 0, oversized: 0, nonSerializable: 0 };
+  const seen = /* @__PURE__ */ new WeakSet();
+  let downgrade;
+  const value = toJsonValueInternal(input, resolved, stats, seen, 0);
+  if (stats.nonSerializable > 0) {
+    downgrade = mergeDowngrade(downgrade, "non_serializable");
+  }
+  if (stats.oversized > 0) {
+    downgrade = mergeDowngrade(downgrade, "oversized");
+  }
+  try {
+    const json = JSON.stringify(value);
+    if (json.length > resolved.maxJsonBytes) {
+      downgrade = mergeDowngrade(downgrade, "oversized");
+      const preview = json.slice(0, Math.min(resolved.oversizedPreviewBytes, resolved.maxJsonBytes));
+      return {
+        value: {
+          _tag: "oversized",
+          bytes: json.length,
+          preview
+        },
+        stats: {
+          dropped: stats.dropped,
+          oversized: stats.oversized + 1,
+          nonSerializable: stats.nonSerializable
+        },
+        downgrade
+      };
+    }
+  } catch {
+    downgrade = mergeDowngrade(downgrade, "non_serializable");
+    return {
+      value: "[Unserializable]",
+      stats: {
+        dropped: stats.dropped,
+        oversized: stats.oversized,
+        nonSerializable: stats.nonSerializable + 1
+      },
+      downgrade
+    };
+  }
+  return {
+    value,
+    stats: {
+      dropped: stats.dropped,
+      oversized: stats.oversized,
+      nonSerializable: stats.nonSerializable
+    },
+    downgrade
+  };
+};
+
+// src/internal/runtime/core/errorSummary.ts
+var import_effect = require("effect");
+var truncate = (value, maxLen) => {
+  if (value.length <= maxLen) return { value, truncated: false };
+  return { value: value.slice(0, maxLen), truncated: true };
+};
+var safeStringify = (value) => {
+  try {
+    return { ok: true, json: JSON.stringify(value) };
+  } catch {
+    return { ok: false };
+  }
+};
+var getMessageFromUnknown = (cause) => {
+  if (typeof cause === "string") return cause;
+  if (typeof cause === "number" || typeof cause === "boolean" || typeof cause === "bigint") return String(cause);
+  if (cause instanceof Error) return cause.message || cause.name || "Error";
+  if (cause && typeof cause === "object" && "message" in cause && typeof cause.message === "string") {
+    return cause.message;
+  }
+  try {
+    const pretty = import_effect.Cause.pretty(cause, { renderErrorCause: true });
+    if (typeof pretty === "string" && pretty.length > 0) return pretty;
+  } catch {
+  }
+  return "Unknown error";
+};
+var toSerializableErrorSummary = (cause, options) => {
+  const maxMessageLength = options?.maxMessageLength ?? 256;
+  const messageRaw = getMessageFromUnknown(cause);
+  const { value: message, truncated } = truncate(messageRaw, maxMessageLength);
+  const summary = {
+    message
+  };
+  if (cause instanceof Error) {
+    if (cause.name && cause.name !== "Error") summary.name = cause.name;
+    const anyCause = cause;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    else if (typeof anyCause.code === "number" && Number.isFinite(anyCause.code)) summary.code = String(anyCause.code);
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+    return {
+      errorSummary: summary,
+      downgrade: truncated ? "oversized" : void 0
+    };
+  }
+  if (cause && typeof cause === "object") {
+    const anyCause = cause;
+    if (typeof anyCause.name === "string" && anyCause.name.length > 0) summary.name = anyCause.name;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+  }
+  const stringifyResult = safeStringify(cause);
+  if (!stringifyResult.ok) {
+    return {
+      errorSummary: summary,
+      downgrade: "non_serializable"
+    };
+  }
+  if (truncated) {
+    return {
+      errorSummary: summary,
+      downgrade: "oversized"
+    };
+  }
+  if (message === "Unknown error") {
+    return {
+      errorSummary: summary,
+      downgrade: "unknown"
+    };
+  }
+  return { errorSummary: summary };
+};
+
+// src/internal/runtime/core/EffectOpCore.ts
+var import_effect2 = require("effect");
+var currentLinkId = import_effect2.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect2.Context.Tag("Logix/EffectOpMiddleware")() {
+};
+
+// src/internal/runtime/core/DebugSink.ts
+var currentDebugSinks = import_effect3.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect3.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect3.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect3.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect3.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect3.FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var traitConvergeDiagnosticsSampling = (config) => import_effect3.Layer.fiberRefLocallyScopedWith(currentTraitConvergeDiagnosticsSampling, () => config);
+var nextGlobalEventSeq = 0;
+var clearRuntimeDebugEventSeq = () => {
+  nextGlobalEventSeq = 0;
+};
+var nextEventSeq = () => {
+  nextGlobalEventSeq += 1;
+  return nextGlobalEventSeq;
+};
+var makeEventId = (instanceId, eventSeq) => `${instanceId}::e${eventSeq}`;
+var mergeDowngrade2 = (current, next) => {
+  if (!current) return next;
+  if (!next) return current;
+  if (current === "non_serializable" || next === "non_serializable") return "non_serializable";
+  if (current === "oversized" || next === "oversized") return "oversized";
+  return "unknown";
+};
+var browserLifecycleSeen = /* @__PURE__ */ new Set();
+var browserDiagnosticSeen = /* @__PURE__ */ new Set();
+var lastTxnByInstance = /* @__PURE__ */ new Map();
+var pendingTxnAlignmentByInstance = /* @__PURE__ */ new Map();
+var enqueuePendingTxnAlignment = (instanceId, ref) => {
+  const list = pendingTxnAlignmentByInstance.get(instanceId);
+  if (!list) {
+    pendingTxnAlignmentByInstance.set(instanceId, [ref]);
+    return;
+  }
+  list.push(ref);
+  if (list.length > 64) {
+    list.shift();
+  }
+};
+var backfillPendingTxnAlignment = (instanceId, txn) => {
+  const pending = pendingTxnAlignmentByInstance.get(instanceId);
+  if (!pending || pending.length === 0) {
+    pendingTxnAlignmentByInstance.delete(instanceId);
+    return;
+  }
+  for (const ref of pending) {
+    const anyRef = ref;
+    if (anyRef.txnId == null) {
+      anyRef.txnId = txn.txnId;
+    }
+    if (typeof anyRef.txnSeq !== "number" || anyRef.txnSeq <= 0) {
+      anyRef.txnSeq = txn.txnSeq;
+    }
+  }
+  pendingTxnAlignmentByInstance.delete(instanceId);
+};
+var lifecycleErrorLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const causePretty = (() => {
+    try {
+      return import_effect3.Cause.pretty(event.cause, {
+        renderErrorCause: true
+      });
+    } catch {
+      try {
+        return JSON.stringify(event.cause, null, 2);
+      } catch {
+        return String(event.cause);
+      }
+    }
+  })();
+  const message = `[Logix][module=${moduleId}] lifecycle:error
+${causePretty}`;
+  return import_effect3.Effect.logError(message).pipe(
+    import_effect3.Effect.annotateLogs({
+      "logix.moduleId": moduleId,
+      "logix.event": "lifecycle:error",
+      "logix.cause": causePretty
+    })
+  );
+};
+var diagnosticLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`;
+  const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+  const msg = `${header}
+${detail}`;
+  const base = event.severity === "warning" ? import_effect3.Effect.logWarning(msg) : event.severity === "info" ? import_effect3.Effect.logInfo(msg) : import_effect3.Effect.logError(msg);
+  const annotations = {
+    "logix.moduleId": moduleId,
+    "logix.event": `diagnostic(${event.severity})`,
+    "logix.diagnostic.code": event.code,
+    "logix.diagnostic.message": event.message
+  };
+  if (event.hint) {
+    annotations["logix.diagnostic.hint"] = event.hint;
+  }
+  if (event.actionTag) {
+    annotations["logix.diagnostic.actionTag"] = event.actionTag;
+  }
+  return base.pipe(import_effect3.Effect.annotateLogs(annotations));
+};
+var noopLayer = import_effect3.Layer.locallyScoped(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 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 isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var renderBrowserConsoleEvent = (event) => {
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const moduleId = event.moduleId ?? "unknown";
+    const type = event.type;
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
+        "color:#6b7280;font-weight:bold",
+        // tag
+        "color:#3b82f6",
+        // label
+        "color:#9ca3af",
+        // module id
+        "color:#6b7280"
+        // type
+      );
+      console.log(event);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "lifecycle:error") {
+    const moduleId = event.moduleId ?? "unknown";
+    const causePretty = (() => {
+      try {
+        return import_effect3.Cause.pretty(event.cause, { renderErrorCause: true });
+      } catch {
+        try {
+          return JSON.stringify(event.cause, null, 2);
+        } catch {
+          return String(event.cause);
+        }
+      }
+    })();
+    const key = `${moduleId}|${causePretty}`;
+    if (browserLifecycleSeen.has(key)) {
+      return import_effect3.Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c lifecycle:error %c" + moduleId,
+        "color:#ef4444;font-weight:bold",
+        // tag
+        "color:#ef4444",
+        // label
+        "color:#9ca3af"
+        // module id
+      );
+      console.error(causePretty);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "diagnostic") {
+    const moduleId = event.moduleId ?? "unknown";
+    const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+    const color = event.severity === "warning" ? "color:#d97706" : event.severity === "info" ? "color:#3b82f6" : "color:#ef4444";
+    const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
+    const key = `${moduleId}|${event.code}|${event.message}`;
+    if (browserDiagnosticSeen.has(key)) {
+      return import_effect3.Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c " + label + "%c module=" + moduleId,
+        "color:#6b7280;font-weight:bold",
+        color,
+        "color:#9ca3af"
+      );
+      if (event.severity === "warning") {
+        console.warn(detail);
+      } else if (event.severity === "info") {
+        console.info(detail);
+      } else {
+        console.error(detail);
+      }
+      console.groupEnd();
+    });
+  }
+  return import_effect3.Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserDiagnosticConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void;
+    }
+    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 record = (event) => import_effect3.Effect.gen(function* () {
+  const sinks = yield* import_effect3.FiberRef.get(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;
+    }
+    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") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* import_effect3.Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel2 = yield* import_effect3.FiberRef.get(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")) {
+    ;
+    enriched.timestamp = getNow();
+  }
+  if (diagnosticsLevel2 !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel2 = yield* import_effect3.FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel2) {
+      ;
+      enriched.runtimeLabel = runtimeLabel2;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect3.FiberRef.get(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) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect3.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
+var toRuntimeDebugEventRef = (event, options) => {
+  const diagnosticsLevel2 = options?.diagnosticsLevel ?? "full";
+  if (diagnosticsLevel2 === "off") {
+    return void 0;
+  }
+  const isLightLike = diagnosticsLevel2 === "light" || diagnosticsLevel2 === "sampled";
+  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";
+  const instanceIdRaw = event.instanceId;
+  const instanceId = typeof instanceIdRaw === "string" && instanceIdRaw.length > 0 ? instanceIdRaw : "unknown";
+  const runtimeLabelRaw = event.runtimeLabel;
+  const runtimeLabel2 = typeof runtimeLabelRaw === "string" && runtimeLabelRaw.length > 0 ? runtimeLabelRaw : void 0;
+  const txnSeqRaw = event.txnSeq;
+  const txnSeq = typeof txnSeqRaw === "number" && Number.isFinite(txnSeqRaw) && txnSeqRaw >= 0 ? Math.floor(txnSeqRaw) : 0;
+  const txnIdRaw = event.txnId;
+  const txnId = typeof txnIdRaw === "string" && txnIdRaw.length > 0 ? txnIdRaw : txnSeq > 0 ? `${instanceId}::t${txnSeq}` : void 0;
+  const linkId = (() => {
+    const linkIdRaw = event.linkId;
+    if (typeof linkIdRaw === "string" && linkIdRaw.length > 0) return linkIdRaw;
+    if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
+      return void 0;
+    }
+    const data = event.data;
+    const meta = data?.meta;
+    const linkIdFromMeta = meta?.linkId;
+    if (typeof linkIdFromMeta === "string" && linkIdFromMeta.length > 0) return linkIdFromMeta;
+    return void 0;
+  })();
+  const eventSeqRaw = options?.eventSeq;
+  const eventSeq = typeof eventSeqRaw === "number" && Number.isFinite(eventSeqRaw) && eventSeqRaw > 0 ? Math.floor(eventSeqRaw) : nextEventSeq();
+  const eventId = makeEventId(instanceId, eventSeq);
+  const base = {
+    eventId,
+    eventSeq,
+    moduleId,
+    instanceId,
+    runtimeLabel: runtimeLabel2,
+    txnSeq,
+    txnId,
+    linkId,
+    timestamp
+  };
+  let downgrade;
+  const withDowngrade = (ref) => {
+    if (!downgrade) return ref;
+    return { ...ref, downgrade: { reason: downgrade } };
+  };
+  switch (event.type) {
+    case "module:init":
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: "module:init"
+      });
+    case "module:destroy":
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: "module:destroy"
+      });
+    case "lifecycle:phase": {
+      const e = event;
+      const metaInput = isLightLike ? { type: "lifecycle:phase", phase: e.phase, name: e.name } : { type: "lifecycle:phase", phase: e.phase, name: e.name, payload: e.payload };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: e.name,
+        meta: metaProjection.value
+      });
+    }
+    case "action:dispatch": {
+      const action = event.action;
+      const actionTagRaw = event.actionTag;
+      const tag = typeof actionTagRaw === "string" && actionTagRaw.length > 0 ? actionTagRaw : action?._tag ?? action?.type;
+      const label = String(tag ?? "action:dispatch");
+      const labelNormalized = label.length > 0 ? label : "unknown";
+      const unknownAction = event.unknownAction === true ? true : void 0;
+      const metaInput = isLightLike ? { actionTag: labelNormalized, ...unknownAction ? { unknownAction: true } : {} } : { action, ...unknownAction ? { unknownAction: true } : {} };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      if (unknownAction) {
+        downgrade = mergeDowngrade2(downgrade, "unknown");
+      }
+      return withDowngrade({
+        ...base,
+        kind: "action",
+        label: labelNormalized,
+        meta: metaProjection.value
+      });
+    }
+    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);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      if (txnId) {
+        lastTxnByInstance.set(instanceId, { txnId, txnSeq });
+        backfillPendingTxnAlignment(instanceId, { txnId, txnSeq });
+      }
+      return withDowngrade({
+        ...base,
+        kind: "state",
+        label: "state:update",
+        meta: metaProjection.value
+      });
+    }
+    case "process:start":
+    case "process:stop":
+    case "process:restart":
+    case "process:trigger":
+    case "process:dispatch":
+    case "process:error": {
+      const e = event;
+      const ts2 = typeof e.timestampMs === "number" && Number.isFinite(e.timestampMs) ? e.timestampMs : timestamp;
+      const metaInput = {
+        identity: e.identity,
+        severity: e.severity,
+        eventSeq: e.eventSeq,
+        timestampMs: e.timestampMs,
+        trigger: e.trigger,
+        dispatch: e.dispatch,
+        error: e.error
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      const errorSummary = e.type === "process:error" || e.type === "process:restart" ? e.error : void 0;
+      return withDowngrade({
+        ...base,
+        timestamp: ts2,
+        kind: "process",
+        label: e.type,
+        meta: metaProjection.value,
+        errorSummary
+      });
+    }
+    case "lifecycle:error": {
+      const e = event;
+      const summary = toSerializableErrorSummary(e.cause);
+      downgrade = mergeDowngrade2(downgrade, summary.downgrade);
+      const metaInput = isLightLike ? { type: "lifecycle:error", phase: e.phase, name: e.hook } : {
+        type: "lifecycle:error",
+        phase: e.phase,
+        name: e.hook,
+        hook: e.hook,
+        taskId: e.taskId,
+        origin: e.origin,
+        txnSeq: e.txnSeq,
+        opSeq: e.opSeq
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: "lifecycle:error",
+        meta: metaProjection.value,
+        errorSummary: summary.errorSummary
+      });
+    }
+    case "diagnostic": {
+      const e = event;
+      const metaInput = {
+        code: e.code,
+        severity: e.severity,
+        message: e.message,
+        hint: e.hint,
+        actionTag: e.actionTag,
+        kind: e.kind,
+        trigger: e.trigger
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.code,
+        meta: metaProjection.value
+      });
+    }
+    default: {
+      if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
+        return void 0;
+      }
+      if (event.type === "trace:txn-lane") {
+        const data = event.data;
+        const evidence = data?.evidence ?? data;
+        const metaProjection2 = projectJsonValue(evidence);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        const label = typeof evidence?.kind === "string" && evidence.kind.length > 0 ? String(evidence.kind) : "txn-lane";
+        return withDowngrade({
+          ...base,
+          kind: "txn-lane",
+          label,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:react-render" || event.type === "trace:react-selector") {
+        const data = event.data;
+        const metaProjection2 = projectJsonValue(
+          isLightLike ? {
+            componentLabel: data?.componentLabel,
+            selectorKey: data?.selectorKey,
+            fieldPaths: data?.fieldPaths,
+            selectorId: data?.selectorId,
+            lane: data?.lane,
+            producer: data?.producer,
+            fallbackReason: data?.fallbackReason,
+            readsDigest: data?.readsDigest,
+            equalsKind: data?.equalsKind,
+            strictModePhase: data?.strictModePhase
+          } : {
+            componentLabel: data?.componentLabel,
+            selectorKey: data?.selectorKey,
+            fieldPaths: data?.fieldPaths,
+            selectorId: data?.selectorId,
+            lane: data?.lane,
+            producer: data?.producer,
+            fallbackReason: data?.fallbackReason,
+            readsDigest: data?.readsDigest,
+            equalsKind: data?.equalsKind,
+            strictModePhase: data?.strictModePhase,
+            meta: data?.meta
+          }
+        );
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        const label = typeof data?.componentLabel === "string" && data.componentLabel.length > 0 ? data.componentLabel : event.type === "trace:react-selector" ? "react-selector" : "react-render";
+        const last = lastTxnByInstance.get(instanceId);
+        const txnSeqFromMeta = typeof data?.meta?.txnSeq === "number" && Number.isFinite(data.meta.txnSeq) && data.meta.txnSeq >= 0 ? Math.floor(data.meta.txnSeq) : void 0;
+        const txnIdFromMeta = typeof data?.meta?.txnId === "string" && data.meta.txnId.length > 0 ? data.meta.txnId : void 0;
+        const txnIdAligned = txnIdFromMeta ?? base.txnId ?? last?.txnId;
+        const txnSeqAligned = txnSeqFromMeta ?? (base.txnSeq > 0 ? base.txnSeq : last?.txnSeq ?? base.txnSeq);
+        const ref = withDowngrade({
+          ...base,
+          txnId: txnIdAligned,
+          txnSeq: txnSeqAligned,
+          kind: event.type === "trace:react-selector" ? "react-selector" : "react-render",
+          label,
+          meta: metaProjection2.value
+        });
+        if (instanceId !== "unknown" && (ref.txnId == null || ref.txnSeq <= 0)) {
+          enqueuePendingTxnAlignment(instanceId, ref);
+        }
+        return ref;
+      }
+      if (event.type === "trace:selector:eval") {
+        const data = event.data;
+        const metaInput = {
+          selectorId: data?.selectorId,
+          lane: data?.lane,
+          producer: data?.producer,
+          fallbackReason: data?.fallbackReason,
+          readsDigest: data?.readsDigest,
+          equalsKind: data?.equalsKind,
+          changed: data?.changed,
+          evalMs: data?.evalMs
+        };
+        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:exec-vm") {
+        const data = event.data;
+        const metaInput = {
+          version: data?.version,
+          stage: data?.stage,
+          hit: data?.hit,
+          reasonCode: data?.reasonCode ?? data?.reason,
+          reasonDetail: data?.reasonDetail,
+          execIrVersion: data?.execIrVersion,
+          execIrHash: data?.execIrHash,
+          serviceId: data?.serviceId,
+          implId: data?.implId
+        };
+        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: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 metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "trait:converge",
+          label: "trait:converge",
+          meta: metaProjection2.value
+        });
+      }
+      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 metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "trait:check",
+          label: "trait:check",
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:trait:validate") {
+        const data = event.data;
+        const metaProjection2 = projectJsonValue(data);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "trait:validate",
+          label: "trait:validate",
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:module:traits") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          digest: data?.digest,
+          count: data?.count
+        } : {
+          digest: data?.digest,
+          count: data?.count,
+          traits: data?.traits,
+          provenanceIndex: data?.provenanceIndex
+        };
+        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:module:traits:conflict") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          conflictCount: data?.conflictCount,
+          traitIds: data?.traitIds
+        } : {
+          conflictCount: data?.conflictCount,
+          conflicts: data?.conflicts
+        };
+        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:module:descriptor") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          id: data?.id,
+          traits: data?.traits,
+          source: data?.source
+        } : { 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:effectop") {
+        const data = event.data;
+        const opMeta = data?.meta;
+        const opKind = data?.kind ?? "service";
+        const label = typeof data?.name === "string" ? data.name : "effectop";
+        const moduleId2 = typeof opMeta?.moduleId === "string" ? opMeta.moduleId : moduleId;
+        const txnId2 = typeof opMeta?.txnId === "string" && opMeta.txnId.length > 0 ? opMeta.txnId : base.txnId;
+        const txnSeq2 = typeof opMeta?.txnSeq === "number" && Number.isFinite(opMeta.txnSeq) && opMeta.txnSeq >= 0 ? Math.floor(opMeta.txnSeq) : base.txnSeq;
+        const metaInput = isLightLike ? {
+          id: data?.id,
+          kind: data?.kind,
+          name: data?.name,
+          meta: opMeta
+        } : {
+          id: data?.id,
+          kind: data?.kind,
+          name: data?.name,
+          payload: data?.payload,
+          meta: opMeta
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          moduleId: moduleId2,
+          txnId: txnId2,
+          txnSeq: txnSeq2,
+          kind: opKind,
+          label,
+          meta: metaProjection2.value
+        });
+      }
+      const metaProjection = projectJsonValue(
+        isLightLike ? {
+          data: void 0
+        } : {
+          data: event.data
+        }
+      );
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "devtools",
+        label: event.type,
+        meta: metaProjection.value
+      });
+    }
+  }
+};
+
+// src/internal/runtime/core/DevtoolsHub.ts
+var import_effect4 = require("effect");
+
+// src/internal/observability/evidence.ts
+var OBSERVABILITY_PROTOCOL_VERSION = "v1";
+var exportEvidencePackage = (options) => {
+  const protocolVersion = options.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
+  return {
+    protocolVersion,
+    runId: options.runId,
+    createdAt: options.createdAt ?? Date.now(),
+    source: options.source,
+    events: options.events.slice().sort((a, b) => a.seq - b.seq),
+    summary: options.summary
+  };
+};
+
+// 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 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 snapshotToken = 0;
+var ensureRingBufferSize = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (ringBuffer.length <= bufferSize) return;
+  const excess = ringBuffer.length - bufferSize;
+  ringBuffer.splice(0, excess);
+  ringBufferSeq.splice(0, excess);
+};
+var trimRingBufferIfNeeded = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (bufferSize <= 64) {
+    ensureRingBufferSize();
+    return;
+  }
+  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);
+};
+var currentSnapshot = {
+  snapshotToken,
+  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 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;
+      ensureRingBufferSize();
+      markSnapshotChanged();
+    }
+  }
+};
+var isDevtoolsEnabled = () => devtoolsEnabled;
+var getDevtoolsSnapshot = () => currentSnapshot;
+var getDevtoolsSnapshotToken = () => snapshotToken;
+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();
+  nextSeq = 1;
+  clearRuntimeDebugEventSeq();
+  clearDevtoolsEvents();
+  return currentRunId;
+};
+var clearDevtoolsEvents = () => {
+  ringBuffer.length = 0;
+  ringBufferSeq.length = 0;
+  exportBudget.dropped = 0;
+  exportBudget.oversized = 0;
+  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 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) => import_effect4.Effect.gen(function* () {
+    const level = yield* import_effect4.FiberRef.get(currentDiagnosticsLevel);
+    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 = event.moduleId ?? "unknown";
+      const runtimeLabel2 = event.runtimeLabel ?? "unknown";
+      const instanceId = event.instanceId;
+      const key = `${runtimeLabel2}::${moduleId}`;
+      const prev = instances.get(key) ?? 0;
+      if (event.type === "module:init") {
+        instances.set(key, prev + 1);
+        changed = true;
+        if (instanceId) {
+          const instanceKey = `${runtimeLabel2}::${moduleId}::${instanceId}`;
+          liveInstanceKeys.add(instanceKey);
+          if (latestStates.delete(instanceKey)) changed = true;
+          if (latestTraitSummaries.delete(instanceKey)) changed = true;
+        }
+      } else {
+        const next = prev - 1;
+        if (next <= 0) {
+          if (instances.delete(key)) changed = true;
+        } else {
+          instances.set(key, next);
+          changed = true;
+        }
+        if (instanceId) {
+          const instanceKey = `${runtimeLabel2}::${moduleId}::${instanceId}`;
+          liveInstanceKeys.delete(instanceKey);
+          if (latestStates.delete(instanceKey)) changed = true;
+          if (latestTraitSummaries.delete(instanceKey)) changed = true;
+          if (instanceLabels.delete(instanceId)) changed = true;
+          changed = true;
+        }
+      }
+    }
+    let exportBudgetChanged = false;
+    const ref = toRuntimeDebugEventRef(event, {
+      diagnosticsLevel: level,
+      resolveConvergeStaticIr: (staticIrDigest) => convergeStaticIrByDigest.get(staticIrDigest),
+      onMetaProjection: ({ stats }) => {
+        if (stats.dropped !== 0 || stats.oversized !== 0) {
+          exportBudgetChanged = true;
+        }
+        exportBudget.dropped += stats.dropped;
+        exportBudget.oversized += stats.oversized;
+      }
+    });
+    if (exportBudgetChanged) {
+      changed = true;
+    }
+    if (!ref) {
+      if (changed) {
+        markSnapshotChanged();
+      }
+      return;
+    }
+    if (ref.kind === "state" && ref.label === "state:update") {
+      const runtimeLabel2 = ref.runtimeLabel ?? "unknown";
+      const key = `${runtimeLabel2}::${ref.moduleId}::${ref.instanceId}`;
+      if (liveInstanceKeys.has(key)) {
+        if (ref.meta && typeof ref.meta === "object" && !Array.isArray(ref.meta)) {
+          const anyMeta = ref.meta;
+          if ("state" in anyMeta) {
+            latestStates.set(key, anyMeta.state);
+            changed = true;
+          }
+          if ("traitSummary" in anyMeta && anyMeta.traitSummary !== void 0) {
+            latestTraitSummaries.set(key, anyMeta.traitSummary);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (bufferSize > 0) {
+      const seq = nextSeq++;
+      ringBuffer.push(ref);
+      ringBufferSeq.push(seq);
+      trimRingBufferIfNeeded();
+      changed = true;
+    }
+    if (changed) {
+      markSnapshotChanged();
+    }
+  })
+};
+
+// 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
+]);
+
+// src/internal/runtime/core/env.ts
+var import_effect6 = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/debug/ModuleTraitsRegistry.ts
+var programsByIdAndDigest = /* @__PURE__ */ new Map();
+var latestDigestById = /* @__PURE__ */ new Map();
+var getModuleProgramById = (moduleId) => {
+  const latestDigest = latestDigestById.get(moduleId);
+  if (!latestDigest) return void 0;
+  return programsByIdAndDigest.get(moduleId)?.get(latestDigest);
+};
+
+// src/internal/runtime/core/runtimeInternalsAccessor.ts
+var RUNTIME_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeInternals");
+var MODULE_TRAITS_PROGRAM = /* @__PURE__ */ Symbol.for("@logixjs/core/moduleTraitsProgram");
+var getModuleTraitsProgram = (module2) => {
+  if (!module2) return void 0;
+  if (typeof module2 !== "object" && typeof module2 !== "function") return void 0;
+  return module2[MODULE_TRAITS_PROGRAM];
+};
+var formatScope = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var getRuntimeInternals = (runtime) => {
+  const scope = runtime;
+  const internals = runtime[RUNTIME_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeInternals] Runtime internals not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make calls internalHooks.installInternalHooks (020 foundation).",
+      "- If you created a mock runtime for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Runtime internals not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== internals.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeInternals] Runtime internals instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `internals: ${formatScope(internals.moduleId, internals.instanceId)}`
+      ].join("\n") : "Runtime internals mismatch"
+    );
+  }
+  return internals;
+};
+
+// src/Debug.ts
+var toRuntimeDebugEventRef2 = toRuntimeDebugEventRef;
+var internal = {
+  currentDebugSinks,
+  currentRuntimeLabel,
+  currentDiagnosticsLevel,
+  currentTraitConvergeDiagnosticsSampling,
+  toRuntimeDebugEventRef
+};
+var getDevtoolsSnapshot2 = getDevtoolsSnapshot;
+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 diagnosticsLevel = (level) => import_effect7.Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
+var traitConvergeDiagnosticsSampling2 = (config) => traitConvergeDiagnosticsSampling(config);
+var isDevtoolsEnabled2 = isDevtoolsEnabled;
+var makeModuleRuntimeCounterSink = () => {
+  const counts = /* @__PURE__ */ new Map();
+  const sink = {
+    record: (event) => import_effect7.Effect.sync(() => {
+      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) => import_effect7.Effect.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);
+  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;
+      }
+    }
+  })();
+  return diagnostics ? import_effect7.Layer.mergeAll(sinks, diagnosticsLevel(diagnostics)) : sinks;
+};
+var withPrettyLogger = (base, options) => import_effect7.Layer.merge(
+  base,
+  import_effect7.Logger.replace(import_effect7.Logger.defaultLogger, import_effect7.Logger.prettyLogger(options))
+);
+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 hasBase = isLayerValue(baseOrOptions);
+  const base = hasBase ? baseOrOptions : import_effect7.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),
+    base
+  );
+}
+var runtimeLabel = (label) => import_effect7.Layer.fiberRefLocallyScopedWith(internal.currentRuntimeLabel, () => label);
+var getModuleTraits = (module2) => {
+  const moduleTag = module2.tag ? module2.tag : module2;
+  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 : import_effect7.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
+  };
+  const appendTrace = import_effect7.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (sinks) => [...sinks, traceSink]);
+  return import_effect7.Layer.provideMerge(appendTrace, base);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendSinks,
+  clearDevtoolsEvents,
+  devtoolsHubLayer,
+  diagnosticsLevel,
+  exportEvidencePackage,
+  getDevtoolsRunId,
+  getDevtoolsSnapshot,
+  getDevtoolsSnapshotToken,
+  getInstanceLabel,
+  getModuleFinalTraits,
+  getModuleTraits,
+  getModuleTraitsById,
+  getModuleTraitsSnapshot,
+  internal,
+  isDevtoolsEnabled,
+  layer,
+  makeModuleRuntimeCounterSink,
+  makeRingBufferSink,
+  noopLayer,
+  record,
+  replace,
+  runtimeLabel,
+  setDevtoolsRunId,
+  setInstanceLabel,
+  startDevtoolsRun,
+  subscribeDevtoolsSnapshot,
+  toRuntimeDebugEventRef,
+  traceLayer,
+  traitConvergeDiagnosticsSampling,
+  withPrettyLogger
+});
+//# sourceMappingURL=Debug.cjs.map