@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,1109 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  currentLinkId,
+  projectJsonValue
+} from "./chunk-SI5OKFFY.js";
+
+// ../logix-core/src/internal/runtime/core/DebugSink.record.ts
+import { Cause as Cause2, Effect, FiberRef, Layer, Logger } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/errorSummary.ts
+import { Cause } from "../effect.js";
+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 = 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 };
+};
+
+// ../logix-core/src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = FiberRef.unsafeMake([]);
+var currentRuntimeLabel = FiberRef.unsafeMake(void 0);
+var currentTxnId = FiberRef.unsafeMake(void 0);
+var currentOpSeq = FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = FiberRef.unsafeMake("off");
+var diagnosticsLevel = (level) => Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
+var currentTraitConvergeDiagnosticsSampling = FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var traitConvergeDiagnosticsSampling = (config) => Layer.fiberRefLocallyScopedWith(currentTraitConvergeDiagnosticsSampling, () => config);
+var appendSinks = (sinks) => Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [...current, ...sinks]);
+var nextGlobalEventSeq = 0;
+var clearRuntimeDebugEventSeq = () => {
+  nextGlobalEventSeq = 0;
+};
+var nextEventSeq = () => {
+  nextGlobalEventSeq += 1;
+  return nextGlobalEventSeq;
+};
+var makeEventId = (instanceId, eventSeq) => `${instanceId}::e${eventSeq}`;
+var mergeDowngrade = (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 Cause2.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 Effect.logError(message).pipe(
+    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" ? Effect.logWarning(msg) : event.severity === "info" ? Effect.logInfo(msg) : 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(Effect.annotateLogs(annotations));
+};
+var noopLayer = Layer.locallyScoped(currentDebugSinks, []);
+var errorOnlySink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : Effect.void
+};
+var errorOnlyLayer = 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) : Effect.logDebug({ debugEvent: event })
+};
+var consoleLayer = 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 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 Cause2.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 Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return 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 Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return 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 Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = 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) : Effect.void;
+    }
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : Effect.void;
+  }
+};
+var browserDiagnosticConsoleLayer = Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = Logger.replace(
+  Logger.defaultLogger,
+  Logger.prettyLogger({ mode: "browser", colors: true })
+);
+var record = (event) => Effect.gen(function* () {
+  const sinks = yield* 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* Effect.void;
+      }
+      return;
+    }
+    yield* Effect.void;
+    return;
+  }
+  if (sinks.length === 0) {
+    if (isBrowser) {
+      if (event.type === "lifecycle:error" || event.type === "diagnostic") {
+        yield* renderBrowserConsoleEvent(event);
+        return;
+      }
+      yield* Effect.void;
+      return;
+    }
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel2 = yield* 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 runtimeLabel = yield* FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* FiberRef.get(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel2 !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const linkId = yield* FiberRef.get(currentLinkId);
+    if (linkId) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* 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 runtimeLabel = 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,
+    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 = mergeDowngrade(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 = mergeDowngrade(downgrade, metaProjection.downgrade);
+      if (unknownAction) {
+        downgrade = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.code,
+        meta: metaProjection.value
+      });
+    }
+    case "warn:priority-inversion": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      } : {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
+    case "warn:microtask-starvation": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      } : {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
+    default: {
+      if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
+        return void 0;
+      }
+      if (event.type === "trace:tick") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          tickSeq: data?.tickSeq,
+          phase: data?.phase,
+          schedule: data?.schedule,
+          triggerSummary: data?.triggerSummary,
+          anchors: data?.anchors,
+          budget: data?.budget,
+          backlog: data?.backlog,
+          result: data?.result
+        } : {
+          data
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:txn-lane") {
+        const data = event.data;
+        const evidence = data?.evidence ?? data;
+        const metaProjection2 = projectJsonValue(evidence);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(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 = mergeDowngrade(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "devtools",
+        label: event.type,
+        meta: metaProjection.value
+      });
+    }
+  }
+};
+
+export {
+  toSerializableErrorSummary,
+  currentDebugSinks,
+  currentRuntimeLabel,
+  currentTxnId,
+  currentOpSeq,
+  currentDiagnosticsLevel,
+  diagnosticsLevel,
+  currentTraitConvergeDiagnosticsSampling,
+  traitConvergeDiagnosticsSampling,
+  appendSinks,
+  clearRuntimeDebugEventSeq,
+  noopLayer,
+  errorOnlyLayer,
+  isErrorOnlyOnlySinks,
+  browserConsoleLayer,
+  browserDiagnosticConsoleLayer,
+  record,
+  toRuntimeDebugEventRef
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/DebugSink.record.ts", "../../../../logix-core/src/internal/runtime/core/errorSummary.ts"],
  "sourcesContent": ["import { Cause, Effect, FiberRef, Layer, Logger } from 'effect'\nimport {\n  projectJsonValue,\n  type DowngradeReason as JsonDowngradeReason,\n  type JsonValue,\n  type JsonValueProjectionStats,\n} from '../../observability/jsonValue.js'\nimport type * as ReplayLog from './ReplayLog.js'\nimport {\n  toSerializableErrorSummary,\n  type DowngradeReason as ErrorDowngradeReason,\n  type SerializableErrorSummary,\n} from './errorSummary.js'\nimport * as EffectOpCore from './EffectOpCore.js'\nimport type * as ProcessProtocol from './process/protocol.js'\nimport type { ConvergeStaticIrExport } from '../../state-trait/converge-ir.js'\n\nexport interface TriggerRef {\n  readonly kind: string\n  readonly name?: string\n  readonly details?: unknown\n}\n\ntype TraceEventType = `trace:${string}`\ntype GenericTraceEventType = Exclude<\n  TraceEventType,\n  'trace:trait:converge' | 'trace:trait:check' | 'trace:trait:validate'\n>\n\n/**\n * ReplayEventRef\uFF1A\n * - Replay event structure referenced from Debug events.\n * - Based on ReplayLog.Event, enriched with txn/trigger association fields for Devtools aggregation and explanation.\n */\nexport type ReplayEventRef = ReplayLog.ReplayLogEvent & {\n  readonly txnId?: string\n  readonly trigger?: TriggerRef\n}\n\nexport type Event =\n  | {\n      readonly type: 'module:init'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'module:destroy'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'lifecycle:phase'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly phase: 'init' | 'run' | 'destroy' | 'platform'\n      readonly name: string\n      readonly payload?: unknown\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'action:dispatch'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly action: unknown\n      readonly actionTag?: string\n      readonly unknownAction?: boolean\n      readonly txnSeq?: number\n      readonly txnId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'state:update'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly state: unknown\n      readonly txnSeq?: number\n      readonly txnId?: string\n      /**\n       * Optional: Static IR digest aligned with FieldPathId/StepId (for consumer-side reverse-mapping & alignment).\n       * - When missing or mismatched, consumers must not attempt to reverse-map rootIds -> rootPaths (avoid wrong UI).\n       * - Allowed to be omitted on near-zero-cost diagnostics=off paths.\n       */\n      readonly staticIrDigest?: string\n      /**\n       * Optional: the affected scope aggregated by this commit (field-level dirty-set).\n       * - Populated by Runtime at commit time;\n       * - Must stay slim and serializable;\n       * - Devtools can use it to explain \"why converge/validate ran / why it degraded to full\".\n       */\n      readonly dirtySet?: unknown\n      /**\n       * Optional: patch count aggregated by this commit (from StateTransaction).\n       * - Populated by Runtime only on transaction paths.\n       * - Devtools can use it as a lightweight transaction summary metric.\n       */\n      readonly patchCount?: number\n      /**\n       * Optional: whether patch records were truncated (bounded) under full instrumentation.\n       */\n      readonly patchesTruncated?: boolean\n      /**\n       * Optional: truncation reason code (stable enum).\n       */\n      readonly patchesTruncatedReason?: 'max_patches'\n      /**\n       * Optional: commit mode (normal/batched/low-priority, etc).\n       * - Populated by Runtime;\n       * - Default is chosen by the caller (typically \"normal\").\n       */\n      readonly commitMode?: string\n      /**\n       * Optional: external visibility priority (normal/low).\n       * - Populated by Runtime.\n       * - Mainly used by React external subscription scheduling (avoid unnecessary renders).\n       */\n      readonly priority?: string\n      /**\n       * Optional: transaction origin kind (origin.kind) that triggered this state commit:\n       * - e.g. \"action\" / \"source-refresh\" / \"service-callback\" / \"devtools\".\n       * - Populated by Runtime only on StateTransaction-based paths.\n       * - Devtools can distinguish app transactions vs devtools time-travel operations.\n       */\n      readonly originKind?: string\n      /**\n       * Optional: transaction origin name (origin.name) that triggered this state commit:\n       * - e.g. action dispatch / fieldPath / task:success/task:failure, etc.\n       * - Populated by Runtime only on StateTransaction-based paths.\n       */\n      readonly originName?: string\n      /**\n       * Reserved: Trait converge summary (for Devtools window-level stats / TopN costs / degrade reasons, etc.).\n       * - Phase 2: field slot only; structure is not fixed.\n       * - Later phases will align with the Trait/Replay event model into an explainable structure.\n       */\n      readonly traitSummary?: unknown\n      /**\n       * Reserved: replay event associated with this transaction (re-emit source of truth from ReplayLog).\n       * - Phase 2: field slot only.\n       * - Later phases will align with ReplayLog.Event structure.\n       */\n      readonly replayEvent?: ReplayEventRef\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type:\n        | 'process:start'\n        | 'process:stop'\n        | 'process:restart'\n        | 'process:trigger'\n        | 'process:dispatch'\n        | 'process:error'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly identity: ProcessProtocol.ProcessInstanceIdentity\n      readonly severity: 'info' | 'warning' | 'error'\n      readonly eventSeq: number\n      readonly timestampMs: number\n      readonly trigger?: ProcessProtocol.ProcessTrigger\n      readonly dispatch?: {\n        readonly moduleId: string\n        readonly instanceId: string\n        readonly actionId: string\n      }\n      readonly error?: ProcessProtocol.SerializableErrorSummary\n      readonly txnSeq?: number\n      readonly txnId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'lifecycle:error'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly cause: unknown\n      readonly phase?: 'init' | 'run' | 'destroy' | 'platform'\n      readonly hook?: 'initRequired' | 'start' | 'destroy' | 'suspend' | 'resume' | 'reset' | 'unknown'\n      readonly taskId?: string\n      readonly opSeq?: number\n      readonly origin?: string\n      readonly txnSeq?: number\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'diagnostic'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly code: string\n      readonly severity: 'error' | 'warning' | 'info'\n      readonly message: string\n      readonly hint?: string\n      readonly actionTag?: string\n      readonly kind?: string\n      readonly txnSeq?: number\n      readonly txnId?: string\n      readonly trigger?: TriggerRef\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'warn:priority-inversion'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly tickSeq: number\n      readonly reason: 'deferredBacklog' | 'subscribedNonUrgent'\n      readonly selectorId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'warn:microtask-starvation'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly tickSeq: number\n      readonly microtaskChainDepth?: number\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  /**\n   * trace:* events:\n   * - Extension hook for runtime tracing / Playground / Alignment Lab.\n   * - Only the type prefix and moduleId are standardized; payload shape is defined by higher layers (e.g. spanId/attributes in data).\n   */\n  | {\n      readonly type: 'trace:trait:converge'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly data: JsonValue\n      readonly txnSeq?: number\n      readonly txnId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'trace:trait:check'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly data: JsonValue\n      readonly txnSeq?: number\n      readonly txnId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: 'trace:trait:validate'\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly data: JsonValue\n      readonly txnSeq?: number\n      readonly txnId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n  | {\n      readonly type: GenericTraceEventType\n      readonly moduleId?: string\n      readonly instanceId?: string\n      readonly data?: unknown\n      readonly txnSeq?: number\n      readonly txnId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n\nexport interface Sink {\n  readonly record: (event: Event) => Effect.Effect<void>\n}\nexport const currentDebugSinks = FiberRef.unsafeMake<ReadonlyArray<Sink>>([])\nexport const currentRuntimeLabel = FiberRef.unsafeMake<string | undefined>(undefined)\nexport const currentTxnId = FiberRef.unsafeMake<string | undefined>(undefined)\nexport const currentOpSeq = FiberRef.unsafeMake<number | undefined>(undefined)\nexport type DiagnosticsLevel = 'off' | 'light' | 'sampled' | 'full'\nexport const currentDiagnosticsLevel = FiberRef.unsafeMake<DiagnosticsLevel>('off')\n\nexport const diagnosticsLevel = (level: DiagnosticsLevel): Layer.Layer<any, never, never> =>\n  Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel as any, () => level) as Layer.Layer<any, never, never>\n\nexport interface TraitConvergeDiagnosticsSamplingConfig {\n  /**\n   * Sample once every N txns (deterministic, based on stable txnSeq).\n   * - 1: sample every txn (timing granularity similar to full, while keeping payload slim)\n   */\n  readonly sampleEveryN: number\n  /**\n   * Max number of TopK hotspots to output (recommended \u2264 3).\n   */\n  readonly topK: number\n}\n\nexport const currentTraitConvergeDiagnosticsSampling = FiberRef.unsafeMake<TraitConvergeDiagnosticsSamplingConfig>({\n  sampleEveryN: 32,\n  topK: 3,\n})\n\nexport const traitConvergeDiagnosticsSampling = (\n  config: TraitConvergeDiagnosticsSamplingConfig,\n): Layer.Layer<any, never, never> =>\n  Layer.fiberRefLocallyScopedWith(currentTraitConvergeDiagnosticsSampling as any, () => config) as Layer.Layer<\n    any,\n    never,\n    never\n  >\n\nexport const appendSinks = (sinks: ReadonlyArray<Sink>): Layer.Layer<any, never, never> =>\n  Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [...current, ...sinks]) as Layer.Layer<\n    any,\n    never,\n    never\n  >\n\nexport type RuntimeDebugEventKind =\n  | 'action'\n  | 'state'\n  | 'service'\n  | 'process'\n  | 'trait-computed'\n  | 'trait-link'\n  | 'trait-source'\n  | 'lifecycle'\n  | 'react-render'\n  | 'devtools'\n  | 'diagnostic'\n  | (string & {})\n\nexport interface RuntimeDebugEventRef {\n  readonly eventId: string\n  readonly eventSeq: number\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly runtimeLabel?: string\n  readonly txnSeq: number\n  readonly txnId?: string\n  /**\n   * linkId\uFF1A\n   * - Current operation chain id (shared by boundary ops in the same chain).\n   * - Created by Runtime at the boundary root and propagated via FiberRef across nested/cross-module chains.\n   */\n  readonly linkId?: string\n  readonly timestamp: number\n  readonly kind: RuntimeDebugEventKind\n  readonly label: string\n  readonly meta?: JsonValue\n  readonly errorSummary?: SerializableErrorSummary\n  readonly downgrade?: {\n    readonly reason?: 'non_serializable' | 'oversized' | 'unknown'\n  }\n}\n\nexport type TxnLaneEvidenceReason =\n  | 'disabled'\n  | 'forced_off'\n  | 'forced_sync'\n  | 'queued_non_urgent'\n  | 'preempted_by_urgent'\n  | 'budget_yield'\n  | 'coalesced'\n  | 'canceled'\n  | 'max_lag_forced'\n  | 'starvation_protection'\n\nexport type TxnLaneNonUrgentYieldReason = 'none' | 'input_pending' | 'budget_exceeded' | 'forced_frame_yield'\n\nexport type TxnLaneEvidence = {\n  readonly anchor: {\n    readonly moduleId: string\n    readonly instanceId: string\n    readonly txnSeq: number\n    readonly opSeq?: number\n  }\n  readonly lane: 'urgent' | 'nonUrgent'\n  readonly kind: string\n  readonly policy: {\n    readonly enabled: boolean\n    readonly overrideMode?: 'forced_off' | 'forced_sync'\n    readonly configScope: 'provider' | 'runtime_module' | 'runtime_default' | 'builtin'\n    readonly budgetMs: number\n    readonly debounceMs: number\n    readonly maxLagMs: number\n    readonly allowCoalesce: boolean\n    readonly yieldStrategy?: 'baseline' | 'inputPending'\n    readonly queueMode?: 'fifo' | 'lanes'\n  }\n  readonly backlog: {\n    readonly pendingCount: number\n    readonly ageMs?: number\n    readonly coalescedCount?: number\n    readonly canceledCount?: number\n  }\n  readonly budget?: {\n    readonly budgetMs?: number\n    readonly sliceDurationMs?: number\n    readonly yieldCount?: number\n    readonly yielded?: boolean\n    readonly yieldReason?: TxnLaneNonUrgentYieldReason\n  }\n  readonly starvation?: {\n    readonly triggered?: boolean\n    readonly reason?: string\n  }\n  readonly reasons: ReadonlyArray<TxnLaneEvidenceReason>\n}\n\nlet nextGlobalEventSeq = 0\n\nexport const clearRuntimeDebugEventSeq = (): void => {\n  nextGlobalEventSeq = 0\n}\n\nconst nextEventSeq = (): number => {\n  nextGlobalEventSeq += 1\n  return nextGlobalEventSeq\n}\n\nconst makeEventId = (instanceId: string, eventSeq: number): string => `${instanceId}::e${eventSeq}`\n\ntype DowngradeReason = JsonDowngradeReason | ErrorDowngradeReason\n\nconst mergeDowngrade = (\n  current: DowngradeReason | undefined,\n  next: DowngradeReason | undefined,\n): DowngradeReason | undefined => {\n  if (!current) return next\n  if (!next) return current\n  if (current === 'non_serializable' || next === 'non_serializable') return 'non_serializable'\n  if (current === 'oversized' || next === 'oversized') return 'oversized'\n  return 'unknown'\n}\n\n// In browsers, to reduce duplicated noise caused by React StrictMode, etc.,\n// de-duplicate lifecycle:error and diagnostic events: print the same moduleId+payload only once.\nconst browserLifecycleSeen = new Set<string>()\nconst browserDiagnosticSeen = new Set<string>()\n\n// Align trace:react-render events with the most recent state:update txn (UI-only association).\nconst lastTxnByInstance = new Map<string, { readonly txnId: string; readonly txnSeq: number }>()\n\n// trace:react-render / trace:react-selector may enter the sink before state:update (reordering due to concurrency/scheduling).\n// To provide usable txn anchors in Devtools/UI, we allow a one-time backfill for refs missing txn fields.\nconst pendingTxnAlignmentByInstance = new Map<string, Array<RuntimeDebugEventRef>>()\n\nconst enqueuePendingTxnAlignment = (instanceId: string, ref: RuntimeDebugEventRef): void => {\n  const list = pendingTxnAlignmentByInstance.get(instanceId)\n  if (!list) {\n    pendingTxnAlignmentByInstance.set(instanceId, [ref])\n    return\n  }\n  list.push(ref)\n  if (list.length > 64) {\n    list.shift()\n  }\n}\n\nconst backfillPendingTxnAlignment = (\n  instanceId: string,\n  txn: { readonly txnId: string; readonly txnSeq: number },\n): void => {\n  const pending = pendingTxnAlignmentByInstance.get(instanceId)\n  if (!pending || pending.length === 0) {\n    pendingTxnAlignmentByInstance.delete(instanceId)\n    return\n  }\n\n  for (const ref of pending) {\n    const anyRef: any = ref as any\n    if (anyRef.txnId == null) {\n      anyRef.txnId = txn.txnId\n    }\n    if (typeof anyRef.txnSeq !== 'number' || anyRef.txnSeq <= 0) {\n      anyRef.txnSeq = txn.txnSeq\n    }\n  }\n\n  pendingTxnAlignmentByInstance.delete(instanceId)\n}\n\nconst lifecycleErrorLog = (event: Extract<Event, { readonly type: 'lifecycle:error' }>) => {\n  const moduleId = event.moduleId ?? 'unknown'\n  const causePretty = (() => {\n    try {\n      return Cause.pretty(event.cause as Cause.Cause<unknown>, {\n        renderErrorCause: true,\n      })\n    } catch {\n      try {\n        return JSON.stringify(event.cause, null, 2)\n      } catch {\n        return String(event.cause)\n      }\n    }\n  })()\n\n  const message = `[Logix][module=${moduleId}] lifecycle:error\\n${causePretty}`\n\n  return Effect.logError(message).pipe(\n    Effect.annotateLogs({\n      'logix.moduleId': moduleId,\n      'logix.event': 'lifecycle:error',\n      'logix.cause': causePretty,\n    }),\n  )\n}\n\nconst diagnosticLog = (event: Extract<Event, { readonly type: 'diagnostic' }>) => {\n  const moduleId = event.moduleId ?? 'unknown'\n  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`\n  const detail = `code=${event.code} message=${event.message}${\n    event.actionTag ? ` action=${event.actionTag}` : ''\n  }${event.hint ? `\\nhint: ${event.hint}` : ''}`\n  const msg = `${header}\\n${detail}`\n\n  const base =\n    event.severity === 'warning'\n      ? Effect.logWarning(msg)\n      : event.severity === 'info'\n        ? Effect.logInfo(msg)\n        : Effect.logError(msg)\n\n  const annotations: Record<string, unknown> = {\n    'logix.moduleId': moduleId,\n    'logix.event': `diagnostic(${event.severity})`,\n    'logix.diagnostic.code': event.code,\n    'logix.diagnostic.message': event.message,\n  }\n  if (event.hint) {\n    annotations['logix.diagnostic.hint'] = event.hint\n  }\n  if (event.actionTag) {\n    annotations['logix.diagnostic.actionTag'] = event.actionTag\n  }\n\n  return base.pipe(Effect.annotateLogs(annotations))\n}\n\n/**\n * Default Layer composition based on FiberRef.currentDebugSinks:\n * - Uses Layer.locallyScoped to inject Debug sinks via FiberRef state.\n * - Avoids misusing FiberRef as a Context.Tag.\n */\nexport const noopLayer = Layer.locallyScoped(currentDebugSinks, [])\n\n/**\n * errorOnlyLayer\uFF1A\n * - Default DebugSink implementation that only cares about lifecycle:error events.\n * - Suitable as a \"minimum observability\" layer so fatal errors don't silently disappear.\n * - Other events (module:init/destroy, action:dispatch, state:update) are not recorded by default.\n */\nconst errorOnlySink: Sink = {\n  record: (event: Event) =>\n    event.type === 'lifecycle:error'\n      ? lifecycleErrorLog(event)\n      : event.type === 'diagnostic' && event.severity !== 'info'\n        ? diagnosticLog(event)\n        : Effect.void,\n}\n\nexport const errorOnlyLayer = Layer.locallyScoped(currentDebugSinks, [errorOnlySink])\n\nexport const isErrorOnlyOnlySinks = (sinks: ReadonlyArray<Sink>): boolean => sinks.length === 1 && sinks[0] === errorOnlySink\n\n/**\n * consoleLayer\uFF1A\n * - Full debug layer that logs all Debug events via Effect logs (logfmt / structured).\n * - Suitable as an observability layer for general environments (Node / tests).\n */\nconst consoleSink: Sink = {\n  record: (event: Event) =>\n    event.type === 'lifecycle:error'\n      ? lifecycleErrorLog(event)\n      : event.type === 'diagnostic'\n        ? diagnosticLog(event)\n        : Effect.logDebug({ debugEvent: event }),\n}\n\nexport const consoleLayer = Layer.locallyScoped(currentDebugSinks, [consoleSink])\n\nconst isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined'\n\n// Shared browser console rendering logic used by the default DebugSink and browserConsoleLayer.\nconst renderBrowserConsoleEvent = (event: Event): Effect.Effect<void> => {\n  // trace:* events: shown as separate groups in browsers for Playground / DevTools observation.\n  if (typeof (event as any).type === 'string' && (event as any).type.startsWith('trace:')) {\n    const moduleId = (event as any).moduleId ?? 'unknown'\n    const type = (event as any).type\n\n    return Effect.sync(() => {\n      // eslint-disable-next-line no-console\n      console.groupCollapsed(\n        '%c[Logix]%c trace %c' + moduleId + '%c ' + String(type),\n        'color:#6b7280;font-weight:bold', // tag\n        'color:#3b82f6', // label\n        'color:#9ca3af', // module id\n        'color:#6b7280', // type\n      )\n      // eslint-disable-next-line no-console\n      console.log(event)\n      // eslint-disable-next-line no-console\n      console.groupEnd()\n    })\n  }\n\n  if (event.type === 'lifecycle:error') {\n    const moduleId = event.moduleId ?? 'unknown'\n    const causePretty = (() => {\n      try {\n        return Cause.pretty(event.cause as Cause.Cause<unknown>, { renderErrorCause: true })\n      } catch {\n        try {\n          return JSON.stringify(event.cause, null, 2)\n        } catch {\n          return String(event.cause)\n        }\n      }\n    })()\n\n    const key = `${moduleId}|${causePretty}`\n    if (browserLifecycleSeen.has(key)) {\n      return Effect.void\n    }\n    browserLifecycleSeen.add(key)\n\n    return Effect.sync(() => {\n      // eslint-disable-next-line no-console\n      console.groupCollapsed(\n        '%c[Logix]%c lifecycle:error %c' + moduleId,\n        'color:#ef4444;font-weight:bold', // tag\n        'color:#ef4444', // label\n        'color:#9ca3af', // module id\n      )\n      // eslint-disable-next-line no-console\n      console.error(causePretty)\n      // eslint-disable-next-line no-console\n      console.groupEnd()\n    })\n  }\n\n  if (event.type === 'diagnostic') {\n    const moduleId = event.moduleId ?? 'unknown'\n    const detail = `code=${event.code} message=${event.message}${\n      event.actionTag ? ` action=${event.actionTag}` : ''\n    }${event.hint ? `\\nhint: ${event.hint}` : ''}`\n\n    const color =\n      event.severity === 'warning' ? 'color:#d97706' : event.severity === 'info' ? 'color:#3b82f6' : 'color:#ef4444'\n\n    const label =\n      event.severity === 'warning'\n        ? 'diagnostic(warning)'\n        : event.severity === 'info'\n          ? 'diagnostic(info)'\n          : 'diagnostic(error)'\n\n    const key = `${moduleId}|${event.code}|${event.message}`\n    if (browserDiagnosticSeen.has(key)) {\n      return Effect.void\n    }\n    browserDiagnosticSeen.add(key)\n\n    return Effect.sync(() => {\n      // eslint-disable-next-line no-console\n      console.groupCollapsed(\n        '%c[Logix]%c ' + label + '%c module=' + moduleId,\n        'color:#6b7280;font-weight:bold',\n        color,\n        'color:#9ca3af',\n      )\n      if (event.severity === 'warning') {\n        // eslint-disable-next-line no-console\n        console.warn(detail)\n      } else if (event.severity === 'info') {\n        // eslint-disable-next-line no-console\n        console.info(detail)\n      } else {\n        // eslint-disable-next-line no-console\n        console.error(detail)\n      }\n      // eslint-disable-next-line no-console\n      console.groupEnd()\n    })\n  }\n\n  // Other events are not printed to the browser console by default to avoid being too noisy during development.\n  // For internal debug events, use a custom Debug sink or use consoleLayer in Node.\n  return Effect.void\n}\n\n/**\n * Browser console debug layer:\n * - In browsers, uses console.groupCollapsed + colored labels to simulate pretty logger grouping.\n * - In non-browser environments, falls back to consoleLayer's Effect logging implementation.\n */\nconst browserConsoleSink: Sink = {\n  record: (event: Event) => {\n    if (!isBrowser) {\n      // Non-browser: fall back to consoleLayer behavior (Effect.log*).\n      return event.type === 'lifecycle:error'\n        ? lifecycleErrorLog(event)\n        : event.type === 'diagnostic'\n          ? diagnosticLog(event)\n          : Effect.logDebug({ debugEvent: event })\n    }\n\n    return renderBrowserConsoleEvent(event)\n  },\n}\n\nexport const browserConsoleLayer = Layer.locallyScoped(currentDebugSinks, [browserConsoleSink])\n\n/**\n * Browser diagnostic-only debug layer:\n * - In browsers, prints only lifecycle:error + diagnostic(warning/error) via console.groupCollapsed.\n * - Drops trace:* and other high-frequency events from the browser console (use DevtoolsHub instead).\n * - In non-browser environments, behaves like errorOnlySink (Effect.log*).\n */\nconst browserDiagnosticConsoleSink: Sink = {\n  record: (event: Event) => {\n    if (!isBrowser) {\n      return event.type === 'lifecycle:error'\n        ? lifecycleErrorLog(event)\n        : event.type === 'diagnostic' && event.severity !== 'info'\n          ? diagnosticLog(event)\n          : Effect.void\n    }\n\n    return event.type === 'lifecycle:error' || (event.type === 'diagnostic' && event.severity !== 'info')\n      ? renderBrowserConsoleEvent(event)\n      : Effect.void\n  },\n}\n\nexport const browserDiagnosticConsoleLayer = Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink])\n\n/**\n * Browser-friendly Logger layer: replaces the default logger with Effect's pretty logger (browser mode).\n * - Avoids hand-written console styles; reuses Effect's colored/grouped formatting.\n * - Safely degrades to the default logger in server environments.\n */\nexport const browserPrettyLoggerLayer = Logger.replace(\n  Logger.defaultLogger,\n  Logger.prettyLogger({ mode: 'browser', colors: true }),\n)\n\n/**\n * defaultLayer\uFF1A\n * - Public default layer; currently equivalent to errorOnlyLayer.\n * - Records lifecycle:error only, avoiding a large volume of action/state logs by default.\n */\nexport const defaultLayer = errorOnlyLayer\n\nexport const record = (event: Event) =>\n  Effect.gen(function* () {\n    const sinks = yield* FiberRef.get(currentDebugSinks)\n\n    // Fast path: production default installs errorOnlyLayer (sinks=1).\n    // Avoid paying diagnostics FiberRef + enrichment costs for high-frequency events that are always dropped by errorOnly.\n    if (isErrorOnlyOnlySinks(sinks)) {\n      if (event.type === 'lifecycle:error') {\n        yield* lifecycleErrorLog(event)\n        return\n      }\n      if (event.type === 'diagnostic') {\n        if (event.severity !== 'info') {\n          yield* diagnosticLog(event)\n        } else {\n          yield* Effect.void\n        }\n        return\n      }\n      yield* Effect.void\n      return\n    }\n\n    // Fast path: when no sinks are installed, only a small subset of events are ever surfaced.\n    // Avoid paying per-event FiberRef + enrichment costs for high-frequency events like state:update.\n    if (sinks.length === 0) {\n      if (isBrowser) {\n        if (event.type === 'lifecycle:error' || event.type === 'diagnostic') {\n          yield* renderBrowserConsoleEvent(event)\n          return\n        }\n        yield* Effect.void\n        return\n      }\n\n      if (event.type === 'lifecycle:error') {\n        yield* lifecycleErrorLog(event)\n        return\n      }\n      if (event.type === 'diagnostic') {\n        yield* diagnosticLog(event)\n        return\n      }\n      yield* Effect.void\n      return\n    }\n\n    const enriched = event as Event\n\n    const diagnosticsLevel = yield* FiberRef.get(currentDiagnosticsLevel)\n\n    // Enrich Debug.Event with basic fields (enabled only when diagnosticsLevel!=off):\n    // - timestamp: for Devtools/Timeline/Overview time aggregation; avoids UI-side \"first observed time\" distortion.\n    // - runtimeLabel: from FiberRef for grouping by runtime (injected only when not already provided by the event).\n    let now: number | undefined\n    const getNow = (): number => {\n      if (now === undefined) now = Date.now()\n      return now\n    }\n\n    // diagnostics=off: keep near-zero cost; do not add timestamp for high-frequency events (avoid extra Date.now()).\n    // Low-frequency events (lifecycle:error/diagnostic) may still get timestamp for easier debugging.\n    if (\n      enriched.timestamp === undefined &&\n      (diagnosticsLevel !== 'off' || enriched.type === 'lifecycle:error' || enriched.type === 'diagnostic')\n    ) {\n      ;(enriched as any).timestamp = getNow()\n    }\n    if (diagnosticsLevel !== 'off' && enriched.runtimeLabel === undefined) {\n      const runtimeLabel = yield* FiberRef.get(currentRuntimeLabel)\n      if (runtimeLabel) {\n        ;(enriched as any).runtimeLabel = runtimeLabel\n      }\n    }\n\n    if (enriched.type === 'diagnostic' && (enriched as any).txnId === undefined) {\n      const txnId = yield* FiberRef.get(currentTxnId)\n      if (txnId) {\n        ;(enriched as any).txnId = txnId\n      }\n    }\n    // linkId is meaningful only for EffectOp events: avoid extra FiberRef reads on high-frequency events (state:update, etc.).\n    if (\n      diagnosticsLevel !== 'off' &&\n      (enriched as any).type === 'trace:effectop' &&\n      (enriched as any).linkId === undefined\n    ) {\n      const linkId = yield* FiberRef.get(EffectOpCore.currentLinkId)\n      if (linkId) {\n        ;(enriched as any).linkId = linkId\n      }\n    }\n\n    if (sinks.length === 1) {\n      yield* sinks[0]!.record(enriched)\n      return\n    }\n\n    yield* Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true })\n  })\n\n/**\n * Normalizes internal Debug.Event into RuntimeDebugEventRef:\n * - Allows Devtools / Runtime to consume Debug events uniformly.\n * - Does not change DebugSink behavior; provides a structured view only.\n */\nexport const toRuntimeDebugEventRef = (\n  event: Event,\n  options?: {\n    readonly diagnosticsLevel?: DiagnosticsLevel\n    readonly eventSeq?: number\n    readonly resolveConvergeStaticIr?: (staticIrDigest: string) => ConvergeStaticIrExport | undefined\n    readonly onMetaProjection?: (projection: {\n      readonly stats: JsonValueProjectionStats\n      readonly downgrade?: JsonDowngradeReason\n    }) => void\n  },\n): RuntimeDebugEventRef | undefined => {\n  const diagnosticsLevel = options?.diagnosticsLevel ?? 'full'\n  if (diagnosticsLevel === 'off') {\n    return undefined\n  }\n\n  const isLightLike = diagnosticsLevel === 'light' || diagnosticsLevel === 'sampled'\n\n  const timestamp =\n    typeof event.timestamp === 'number' && Number.isFinite(event.timestamp) ? event.timestamp : Date.now()\n\n  const moduleIdRaw = (event as any).moduleId\n  const moduleId = typeof moduleIdRaw === 'string' && moduleIdRaw.length > 0 ? moduleIdRaw : 'unknown'\n\n  const instanceIdRaw = (event as any).instanceId\n  const instanceId = typeof instanceIdRaw === 'string' && instanceIdRaw.length > 0 ? instanceIdRaw : 'unknown'\n\n  const runtimeLabelRaw = (event as any).runtimeLabel\n  const runtimeLabel = typeof runtimeLabelRaw === 'string' && runtimeLabelRaw.length > 0 ? runtimeLabelRaw : undefined\n\n  const txnSeqRaw = (event as any).txnSeq\n  const txnSeq =\n    typeof txnSeqRaw === 'number' && Number.isFinite(txnSeqRaw) && txnSeqRaw >= 0 ? Math.floor(txnSeqRaw) : 0\n\n  const txnIdRaw = (event as any).txnId\n  const txnId =\n    typeof txnIdRaw === 'string' && txnIdRaw.length > 0\n      ? txnIdRaw\n      : txnSeq > 0\n        ? `${instanceId}::t${txnSeq}`\n        : undefined\n\n  const linkId = (() => {\n    const linkIdRaw = (event as any).linkId\n    if (typeof linkIdRaw === 'string' && linkIdRaw.length > 0) return linkIdRaw\n\n    // trace:*: allow fallback extraction from data.meta.linkId (avoid UI diving into deep meta).\n    if (typeof (event as any).type !== 'string' || !(event as any).type.startsWith('trace:')) {\n      return undefined\n    }\n\n    const data: any = (event as any).data\n    const meta: any = data?.meta\n    const linkIdFromMeta = meta?.linkId\n    if (typeof linkIdFromMeta === 'string' && linkIdFromMeta.length > 0) return linkIdFromMeta\n\n    return undefined\n  })()\n\n  const eventSeqRaw = options?.eventSeq\n  const eventSeq =\n    typeof eventSeqRaw === 'number' && Number.isFinite(eventSeqRaw) && eventSeqRaw > 0\n      ? Math.floor(eventSeqRaw)\n      : nextEventSeq()\n  const eventId = makeEventId(instanceId, eventSeq)\n\n  const base = {\n    eventId,\n    eventSeq,\n    moduleId,\n    instanceId,\n    runtimeLabel,\n    txnSeq,\n    txnId,\n    linkId,\n    timestamp,\n  } as const\n\n  let downgrade: DowngradeReason | undefined\n\n  const withDowngrade = (ref: Omit<RuntimeDebugEventRef, 'downgrade'>): RuntimeDebugEventRef => {\n    if (!downgrade) return ref\n    return { ...ref, downgrade: { reason: downgrade } }\n  }\n\n  switch (event.type) {\n    case 'module:init':\n      return withDowngrade({\n        ...base,\n        kind: 'lifecycle',\n        label: 'module:init',\n      })\n    case 'module:destroy':\n      return withDowngrade({\n        ...base,\n        kind: 'lifecycle',\n        label: 'module:destroy',\n      })\n    case 'lifecycle:phase': {\n      const e = event as Extract<Event, { readonly type: 'lifecycle:phase' }>\n      const metaInput = isLightLike\n        ? { type: 'lifecycle:phase', phase: e.phase, name: e.name }\n        : { type: 'lifecycle:phase', phase: e.phase, name: e.name, payload: e.payload }\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n      return withDowngrade({\n        ...base,\n        kind: 'lifecycle',\n        label: e.name,\n        meta: metaProjection.value,\n      })\n    }\n    case 'action:dispatch': {\n      const action: any = (event as any).action\n      const actionTagRaw = (event as any).actionTag\n      const tag = typeof actionTagRaw === 'string' && actionTagRaw.length > 0 ? actionTagRaw : (action?._tag ?? action?.type)\n      const label = String(tag ?? 'action:dispatch')\n      const labelNormalized = label.length > 0 ? label : 'unknown'\n      const unknownAction = (event as any).unknownAction === true ? true : undefined\n      const metaInput = isLightLike\n        ? { actionTag: labelNormalized, ...(unknownAction ? { unknownAction: true } : {}) }\n        : { action, ...(unknownAction ? { unknownAction: true } : {}) }\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n      if (unknownAction) {\n        downgrade = mergeDowngrade(downgrade, 'unknown')\n      }\n      return withDowngrade({\n        ...base,\n        kind: 'action',\n        label: labelNormalized,\n        meta: metaProjection.value,\n      })\n    }\n    case 'state:update': {\n      const e = event as Extract<Event, { readonly type: 'state:update' }>\n\n      const resolveDirtySetRootPaths = (): ReadonlyArray<JsonValue> | undefined => {\n        const resolve = options?.resolveConvergeStaticIr\n        if (!resolve) return undefined\n\n        const digest = e.staticIrDigest\n        if (typeof digest !== 'string' || digest.length === 0) return undefined\n\n        const dirtySet = e.dirtySet as any\n        if (!dirtySet || typeof dirtySet !== 'object' || Array.isArray(dirtySet)) return undefined\n\n        const rootIds = dirtySet.rootIds\n        if (!Array.isArray(rootIds) || rootIds.length === 0) return undefined\n\n        const ir = resolve(digest) as ConvergeStaticIrExport | undefined\n        const fieldPaths = (ir as any)?.fieldPaths as unknown\n        if (!Array.isArray(fieldPaths) || fieldPaths.length === 0) return undefined\n\n        const out: Array<JsonValue> = []\n        for (const rawId of rootIds) {\n          if (typeof rawId !== 'number' || !Number.isFinite(rawId)) continue\n          const id = Math.floor(rawId)\n          if (id < 0) continue\n          const path = (fieldPaths as any)[id] as unknown\n          if (!Array.isArray(path) || path.length === 0) continue\n          if (!path.every((seg) => typeof seg === 'string' && seg.length > 0)) continue\n          out.push(path as any)\n        }\n\n        return out.length > 0 ? out : undefined\n      }\n\n      const dirtySetWithRootPaths = (() => {\n        const rootPaths = resolveDirtySetRootPaths()\n        if (!rootPaths) return e.dirtySet\n        const dirtySet = e.dirtySet as any\n        if (!dirtySet || typeof dirtySet !== 'object' || Array.isArray(dirtySet)) return e.dirtySet\n        return { ...dirtySet, rootPaths }\n      })()\n\n      const metaInput = isLightLike\n        ? {\n            state: e.state,\n            dirtySet: dirtySetWithRootPaths,\n            patchCount: e.patchCount,\n            patchesTruncated: e.patchesTruncated,\n            patchesTruncatedReason: e.patchesTruncatedReason,\n            staticIrDigest: e.staticIrDigest,\n            commitMode: e.commitMode,\n            priority: e.priority,\n            originKind: e.originKind,\n            originName: e.originName,\n          }\n        : {\n            state: e.state,\n            dirtySet: dirtySetWithRootPaths,\n            patchCount: e.patchCount,\n            patchesTruncated: e.patchesTruncated,\n            patchesTruncatedReason: e.patchesTruncatedReason,\n            staticIrDigest: e.staticIrDigest,\n            commitMode: e.commitMode,\n            priority: e.priority,\n            originKind: e.originKind,\n            originName: e.originName,\n            traitSummary: e.traitSummary,\n            replayEvent: e.replayEvent,\n          }\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n      if (txnId) {\n        lastTxnByInstance.set(instanceId, { txnId, txnSeq })\n        backfillPendingTxnAlignment(instanceId, { txnId, txnSeq })\n      }\n      return withDowngrade({\n        ...base,\n        kind: 'state',\n        label: 'state:update',\n        meta: metaProjection.value,\n      })\n    }\n    case 'process:start':\n    case 'process:stop':\n    case 'process:restart':\n    case 'process:trigger':\n    case 'process:dispatch':\n    case 'process:error': {\n      const e = event as Extract<\n        Event,\n        {\n          readonly type:\n            | 'process:start'\n            | 'process:stop'\n            | 'process:restart'\n            | 'process:trigger'\n            | 'process:dispatch'\n            | 'process:error'\n        }\n      >\n\n      const ts2 = typeof e.timestampMs === 'number' && Number.isFinite(e.timestampMs) ? e.timestampMs : timestamp\n\n      const metaInput = {\n        identity: e.identity,\n        severity: e.severity,\n        eventSeq: e.eventSeq,\n        timestampMs: e.timestampMs,\n        trigger: e.trigger,\n        dispatch: e.dispatch,\n        error: e.error,\n      }\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n      const errorSummary =\n        e.type === 'process:error' || e.type === 'process:restart'\n          ? (e.error as any as SerializableErrorSummary | undefined)\n          : undefined\n\n      return withDowngrade({\n        ...base,\n        timestamp: ts2,\n        kind: 'process',\n        label: e.type,\n        meta: metaProjection.value,\n        errorSummary,\n      })\n    }\n    case 'lifecycle:error': {\n      const e = event as Extract<Event, { readonly type: 'lifecycle:error' }>\n      const summary = toSerializableErrorSummary(e.cause)\n      downgrade = mergeDowngrade(downgrade, summary.downgrade)\n      const metaInput = isLightLike\n        ? { type: 'lifecycle:error', phase: e.phase, name: e.hook }\n        : {\n            type: 'lifecycle:error',\n            phase: e.phase,\n            name: e.hook,\n            hook: e.hook,\n            taskId: e.taskId,\n            origin: e.origin,\n            txnSeq: e.txnSeq,\n            opSeq: e.opSeq,\n          }\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n      return withDowngrade({\n        ...base,\n        kind: 'lifecycle',\n        label: 'lifecycle:error',\n        meta: metaProjection.value,\n        errorSummary: summary.errorSummary,\n      })\n    }\n    case 'diagnostic': {\n      const e = event as Extract<Event, { readonly type: 'diagnostic' }>\n      const metaInput = {\n        code: e.code,\n        severity: e.severity,\n        message: e.message,\n        hint: e.hint,\n        actionTag: e.actionTag,\n        kind: e.kind,\n        trigger: e.trigger,\n      }\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n      return withDowngrade({\n        ...base,\n        kind: 'diagnostic',\n        label: e.code,\n        meta: metaProjection.value,\n      })\n    }\n    case 'warn:priority-inversion': {\n      const e = event as Extract<Event, { readonly type: 'warn:priority-inversion' }>\n      const metaInput = isLightLike\n        ? {\n            tickSeq: e.tickSeq,\n            reason: e.reason,\n            selectorId: e.selectorId,\n          }\n        : {\n            tickSeq: e.tickSeq,\n            reason: e.reason,\n            selectorId: e.selectorId,\n          }\n\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n      return withDowngrade({\n        ...base,\n        kind: 'diagnostic',\n        label: e.type,\n        meta: metaProjection.value,\n      })\n    }\n    case 'warn:microtask-starvation': {\n      const e = event as Extract<Event, { readonly type: 'warn:microtask-starvation' }>\n      const metaInput = isLightLike\n        ? {\n            tickSeq: e.tickSeq,\n            microtaskChainDepth: e.microtaskChainDepth,\n          }\n        : {\n            tickSeq: e.tickSeq,\n            microtaskChainDepth: e.microtaskChainDepth,\n          }\n\n      const metaProjection = projectJsonValue(metaInput)\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n      return withDowngrade({\n        ...base,\n        kind: 'diagnostic',\n        label: e.type,\n        meta: metaProjection.value,\n      })\n    }\n    default: {\n      if (typeof event.type !== 'string' || !event.type.startsWith('trace:')) {\n        return undefined\n      }\n\n      // trace:tick: runtime tick evidence; keep Slim payload even in light tier.\n      if (event.type === 'trace:tick') {\n        const data: any = (event as any).data\n        const metaInput = isLightLike\n          ? {\n              tickSeq: data?.tickSeq,\n              phase: data?.phase,\n              schedule: data?.schedule,\n              triggerSummary: data?.triggerSummary,\n              anchors: data?.anchors,\n              budget: data?.budget,\n              backlog: data?.backlog,\n              result: data?.result,\n            }\n          : {\n              data,\n            }\n\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'devtools',\n          label: event.type,\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:txn-lane: slim evidence for Txn Lanes (lane/backlog/reasons), used for Devtools summary and offline export.\n      if (event.type === 'trace:txn-lane') {\n        const data: any = (event as any).data\n        const evidence = data?.evidence ?? data\n\n        const metaProjection = projectJsonValue(evidence)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        const label =\n          typeof evidence?.kind === 'string' && evidence.kind.length > 0 ? String(evidence.kind) : 'txn-lane'\n\n        return withDowngrade({\n          ...base,\n          kind: 'txn-lane',\n          label,\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:react-render / trace:react-selector: keep slim meta only (field trimming is handled by JsonValue projection).\n      if (event.type === 'trace:react-render' || event.type === 'trace:react-selector') {\n        const data: any = (event as any).data\n        const metaProjection = projectJsonValue(\n          isLightLike\n            ? {\n                componentLabel: data?.componentLabel,\n                selectorKey: data?.selectorKey,\n                fieldPaths: data?.fieldPaths,\n                selectorId: data?.selectorId,\n                lane: data?.lane,\n                producer: data?.producer,\n                fallbackReason: data?.fallbackReason,\n                readsDigest: data?.readsDigest,\n                equalsKind: data?.equalsKind,\n                strictModePhase: data?.strictModePhase,\n              }\n            : {\n                componentLabel: data?.componentLabel,\n                selectorKey: data?.selectorKey,\n                fieldPaths: data?.fieldPaths,\n                selectorId: data?.selectorId,\n                lane: data?.lane,\n                producer: data?.producer,\n                fallbackReason: data?.fallbackReason,\n                readsDigest: data?.readsDigest,\n                equalsKind: data?.equalsKind,\n                strictModePhase: data?.strictModePhase,\n                meta: data?.meta,\n              },\n        )\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n        const label =\n          typeof data?.componentLabel === 'string' && data.componentLabel.length > 0\n            ? data.componentLabel\n            : event.type === 'trace:react-selector'\n              ? 'react-selector'\n              : 'react-render'\n        const last = lastTxnByInstance.get(instanceId)\n        const txnSeqFromMeta =\n          typeof data?.meta?.txnSeq === 'number' && Number.isFinite(data.meta.txnSeq) && data.meta.txnSeq >= 0\n            ? Math.floor(data.meta.txnSeq)\n            : undefined\n        const txnIdFromMeta =\n          typeof data?.meta?.txnId === 'string' && data.meta.txnId.length > 0 ? data.meta.txnId : undefined\n        const txnIdAligned = txnIdFromMeta ?? base.txnId ?? last?.txnId\n        const txnSeqAligned = txnSeqFromMeta ?? (base.txnSeq > 0 ? base.txnSeq : (last?.txnSeq ?? base.txnSeq))\n        const ref = withDowngrade({\n          ...base,\n          txnId: txnIdAligned,\n          txnSeq: txnSeqAligned,\n          kind: event.type === 'trace:react-selector' ? 'react-selector' : 'react-render',\n          label,\n          meta: metaProjection.value,\n        })\n\n        if (instanceId !== 'unknown' && (ref.txnId == null || ref.txnSeq <= 0)) {\n          enqueuePendingTxnAlignment(instanceId, ref)\n        }\n\n        return ref\n      }\n\n      // trace:selector:eval: SelectorGraph evaluation evidence within commit (used for txn\u2192selector\u2192render causal chain).\n      if (event.type === 'trace:selector:eval') {\n        const data: any = (event as any).data\n        const metaInput = {\n          selectorId: data?.selectorId,\n          lane: data?.lane,\n          producer: data?.producer,\n          fallbackReason: data?.fallbackReason,\n          readsDigest: data?.readsDigest,\n          equalsKind: data?.equalsKind,\n          changed: data?.changed,\n          evalMs: data?.evalMs,\n        }\n\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'devtools',\n          label: event.type,\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:exec-vm: Exec VM hit/miss evidence (049). In light tier we keep minimal summary fields.\n      if (event.type === 'trace:exec-vm') {\n        const data: any = (event as any).data\n        const metaInput = {\n          version: data?.version,\n          stage: data?.stage,\n          hit: data?.hit,\n          reasonCode: data?.reasonCode ?? data?.reason,\n          reasonDetail: data?.reasonDetail,\n          execIrVersion: data?.execIrVersion,\n          execIrHash: data?.execIrHash,\n          serviceId: data?.serviceId,\n          implId: data?.implId,\n        }\n\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'devtools',\n          label: event.type,\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:trait:converge: converge evidence must be exportable (JsonValue hard gate) and trims heavy fields in light tier.\n      if (event.type === 'trace:trait:converge') {\n        const resolveDirtyRootPaths = (args: {\n          readonly staticIrDigest: unknown\n          readonly rootIds: unknown\n        }): ReadonlyArray<JsonValue> | undefined => {\n          const resolve = options?.resolveConvergeStaticIr\n          if (!resolve) return undefined\n          const digest = args.staticIrDigest\n          if (typeof digest !== 'string' || digest.length === 0) return undefined\n\n          const rootIds = args.rootIds\n          if (!Array.isArray(rootIds) || rootIds.length === 0) return undefined\n\n          const ir = resolve(digest) as ConvergeStaticIrExport | undefined\n          const fieldPaths = (ir as any)?.fieldPaths as unknown\n          if (!Array.isArray(fieldPaths) || fieldPaths.length === 0) return undefined\n\n          const out: Array<JsonValue> = []\n          for (const id of rootIds) {\n            if (typeof id !== 'number' || !Number.isFinite(id)) continue\n            const idx = Math.floor(id)\n            if (idx < 0 || idx >= fieldPaths.length) continue\n            const path = fieldPaths[idx]\n            if (Array.isArray(path)) {\n              out.push(path as any)\n            }\n          }\n\n          return out.length > 0 ? out : undefined\n        }\n\n        const enrichDirtyRootPaths = (value: JsonValue): JsonValue => {\n          if (!value || typeof value !== 'object' || Array.isArray(value)) return value\n\n          const anyValue = value as any\n          const dirty = anyValue.dirty\n          if (!dirty || typeof dirty !== 'object' || Array.isArray(dirty)) return value\n\n          const dirtyRootPaths = resolveDirtyRootPaths({\n            staticIrDigest: anyValue.staticIrDigest,\n            rootIds: dirty?.rootIds,\n          })\n          if (!dirtyRootPaths) return value\n\n          return {\n            ...anyValue,\n            dirty: {\n              ...(dirty as any),\n              rootPaths: dirtyRootPaths,\n            },\n          } as JsonValue\n        }\n\n        const stripHeavyLight = (value: JsonValue): JsonValue => {\n          if (!value || typeof value !== 'object' || Array.isArray(value)) return value\n\n          const anyValue = value as any\n          const dirty = anyValue.dirty\n          const dirtyRootPaths = resolveDirtyRootPaths({\n            staticIrDigest: anyValue.staticIrDigest,\n            rootIds: dirty?.rootIds,\n          })\n          const dirtySlim =\n            dirty && typeof dirty === 'object' && !Array.isArray(dirty)\n              ? {\n                  dirtyAll: (dirty as any).dirtyAll,\n                  ...(typeof (dirty as any).reason === 'string' ? { reason: (dirty as any).reason } : null),\n                  ...(Array.isArray((dirty as any).rootIds) ? { rootIds: (dirty as any).rootIds } : null),\n                  ...(typeof (dirty as any).rootIdsTruncated === 'boolean'\n                    ? { rootIdsTruncated: (dirty as any).rootIdsTruncated }\n                    : null),\n                  ...(dirtyRootPaths ? { rootPaths: dirtyRootPaths } : null),\n                }\n              : undefined\n\n          const { top3, dirtyRoots, ...rest } = anyValue\n          return (dirtySlim ? { ...rest, dirty: dirtySlim } : rest) as JsonValue\n        }\n\n        const stripHeavySampled = (value: JsonValue): JsonValue => {\n          if (!value || typeof value !== 'object' || Array.isArray(value)) return value\n\n          const anyValue = value as any\n          const dirty = anyValue.dirty\n          const dirtySlim =\n            dirty && typeof dirty === 'object' && !Array.isArray(dirty)\n              ? {\n                  dirtyAll: (dirty as any).dirtyAll,\n                  ...(typeof (dirty as any).reason === 'string' ? { reason: (dirty as any).reason } : null),\n                }\n              : undefined\n\n          const { dirtyRoots, ...rest } = anyValue\n          return (dirtySlim ? { ...rest, dirty: dirtySlim } : rest) as JsonValue\n        }\n\n        const data = (event as Extract<Event, { readonly type: 'trace:trait:converge' }>).data\n        const metaInput =\n          diagnosticsLevel === 'light'\n            ? stripHeavyLight(data)\n            : diagnosticsLevel === 'sampled'\n              ? stripHeavySampled(data)\n              : enrichDirtyRootPaths(data)\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'trait:converge',\n          label: 'trait:converge',\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:trait:check: validation diagnostics must be exportable and stay slim in light tier (keep key fields).\n      if (event.type === 'trace:trait:check') {\n        const stripHeavy = (value: JsonValue): JsonValue => {\n          if (!value || typeof value !== 'object' || Array.isArray(value)) return value\n          const anyValue = value as any\n          const degraded = anyValue.degraded\n          const degradedSlim =\n            degraded && typeof degraded === 'object' && !Array.isArray(degraded)\n              ? { kind: (degraded as any).kind }\n              : undefined\n\n          const { degraded: _degraded, ...rest } = anyValue\n          return (degradedSlim ? { ...rest, degraded: degradedSlim } : rest) as JsonValue\n        }\n\n        const data = (event as Extract<Event, { readonly type: 'trace:trait:check' }>).data\n        const metaInput = isLightLike ? stripHeavy(data) : data\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'trait:check',\n          label: 'trait:check',\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:trait:validate: validation decision summary must be exportable and slim in light tier (no heavy fields by default).\n      if (event.type === 'trace:trait:validate') {\n        const data = (event as Extract<Event, { readonly type: 'trace:trait:validate' }>).data\n        const metaProjection = projectJsonValue(data)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'trait:validate',\n          label: 'trait:validate',\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:module:traits: final traits snapshot must be exportable and slim in light tier (digest/count).\n      if (event.type === 'trace:module:traits') {\n        const data: any = (event as any).data\n        const metaInput = isLightLike\n          ? {\n              digest: data?.digest,\n              count: data?.count,\n            }\n          : {\n              digest: data?.digest,\n              count: data?.count,\n              traits: data?.traits,\n              provenanceIndex: data?.provenanceIndex,\n            }\n\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'devtools',\n          label: event.type,\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:module:traits:conflict: conflict details must be exportable; avoid relying on truncated lifecycle:error messages.\n      if (event.type === 'trace:module:traits:conflict') {\n        const data: any = (event as any).data\n        const metaInput = isLightLike\n          ? {\n              conflictCount: data?.conflictCount,\n              traitIds: data?.traitIds,\n            }\n          : {\n              conflictCount: data?.conflictCount,\n              conflicts: data?.conflicts,\n            }\n\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'devtools',\n          label: event.type,\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:module:descriptor: keep key anchors even in light tier (avoid data being fully trimmed).\n      if (event.type === 'trace:module:descriptor') {\n        const data: any = (event as any).data\n        const metaInput = isLightLike\n          ? {\n              id: data?.id,\n              traits: data?.traits,\n              source: data?.source,\n            }\n          : { data }\n\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          kind: 'devtools',\n          label: event.type,\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:effectop: keep slim op meta and prefer EffectOp.meta.moduleId when present.\n      if (event.type === 'trace:effectop') {\n        const data: any = (event as any).data\n        const opMeta: any = data?.meta\n        const opKind = (data?.kind ?? 'service') as RuntimeDebugEventKind\n        const label = typeof data?.name === 'string' ? data.name : 'effectop'\n        const moduleId2 = typeof opMeta?.moduleId === 'string' ? opMeta.moduleId : moduleId\n        const txnId2 = typeof opMeta?.txnId === 'string' && opMeta.txnId.length > 0 ? opMeta.txnId : base.txnId\n        const txnSeq2 =\n          typeof opMeta?.txnSeq === 'number' && Number.isFinite(opMeta.txnSeq) && opMeta.txnSeq >= 0\n            ? Math.floor(opMeta.txnSeq)\n            : base.txnSeq\n\n        const metaInput = isLightLike\n          ? {\n              id: data?.id,\n              kind: data?.kind,\n              name: data?.name,\n              meta: opMeta,\n            }\n          : {\n              id: data?.id,\n              kind: data?.kind,\n              name: data?.name,\n              payload: data?.payload,\n              meta: opMeta,\n            }\n\n        const metaProjection = projectJsonValue(metaInput)\n        options?.onMetaProjection?.({\n          stats: metaProjection.stats,\n          downgrade: metaProjection.downgrade,\n        })\n        downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n\n        return withDowngrade({\n          ...base,\n          moduleId: moduleId2,\n          txnId: txnId2,\n          txnSeq: txnSeq2,\n          kind: opKind,\n          label,\n          meta: metaProjection.value,\n        })\n      }\n\n      // Other trace:* events: categorize as devtools and trim meta by tier.\n      const metaProjection = projectJsonValue(\n        isLightLike\n          ? {\n              data: undefined,\n            }\n          : {\n              data: (event as any).data,\n            },\n      )\n      options?.onMetaProjection?.({\n        stats: metaProjection.stats,\n        downgrade: metaProjection.downgrade,\n      })\n      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade)\n      return withDowngrade({\n        ...base,\n        kind: 'devtools',\n        label: event.type,\n        meta: metaProjection.value,\n      })\n    }\n  }\n}\n", "import { Cause } from 'effect'\n\nexport type DowngradeReason = 'non_serializable' | 'oversized' | 'unknown'\n\nexport interface SerializableErrorSummary {\n  readonly message: string\n  readonly name?: string\n  readonly code?: string\n  readonly hint?: string\n}\n\nexport interface ErrorSummaryResult {\n  readonly errorSummary: SerializableErrorSummary\n  readonly downgrade?: DowngradeReason\n}\n\nconst truncate = (value: string, maxLen: number): { readonly value: string; readonly truncated: boolean } => {\n  if (value.length <= maxLen) return { value, truncated: false }\n  return { value: value.slice(0, maxLen), truncated: true }\n}\n\nconst safeStringify = (value: unknown): { readonly ok: true; readonly json: string } | { readonly ok: false } => {\n  try {\n    return { ok: true, json: JSON.stringify(value) }\n  } catch {\n    return { ok: false }\n  }\n}\n\nconst getMessageFromUnknown = (cause: unknown): string => {\n  if (typeof cause === 'string') return cause\n  if (typeof cause === 'number' || typeof cause === 'boolean' || typeof cause === 'bigint') return String(cause)\n  if (cause instanceof Error) return cause.message || cause.name || 'Error'\n  if (cause && typeof cause === 'object' && 'message' in (cause as any) && typeof (cause as any).message === 'string') {\n    return (cause as any).message as string\n  }\n\n  // Try Effect Cause pretty (best-effort). This may include more details than needed,\n  // so callers MUST still treat it as an untrusted/oversized string and truncate.\n  try {\n    const pretty = Cause.pretty(cause as Cause.Cause<unknown>, { renderErrorCause: true })\n    if (typeof pretty === 'string' && pretty.length > 0) return pretty\n  } catch {\n    // ignore\n  }\n\n  return 'Unknown error'\n}\n\nexport const toSerializableErrorSummary = (\n  cause: unknown,\n  options?: {\n    readonly maxMessageLength?: number\n  },\n): ErrorSummaryResult => {\n  const maxMessageLength = options?.maxMessageLength ?? 256\n\n  const messageRaw = getMessageFromUnknown(cause)\n  const { value: message, truncated } = truncate(messageRaw, maxMessageLength)\n\n  const summary: { message: string; name?: string; code?: string; hint?: string } = {\n    message,\n  }\n\n  if (cause instanceof Error) {\n    if (cause.name && cause.name !== 'Error') summary.name = cause.name\n    const anyCause = cause as any\n    if (typeof anyCause.code === 'string' && anyCause.code.length > 0) summary.code = anyCause.code\n    else if (typeof anyCause.code === 'number' && Number.isFinite(anyCause.code)) summary.code = String(anyCause.code)\n    if (typeof anyCause.hint === 'string' && anyCause.hint.length > 0) summary.hint = anyCause.hint\n    return {\n      errorSummary: summary,\n      downgrade: truncated ? 'oversized' : undefined,\n    }\n  }\n\n  if (cause && typeof cause === 'object') {\n    const anyCause = cause as any\n    if (typeof anyCause.name === 'string' && anyCause.name.length > 0) summary.name = anyCause.name\n    if (typeof anyCause.code === 'string' && anyCause.code.length > 0) summary.code = anyCause.code\n    if (typeof anyCause.hint === 'string' && anyCause.hint.length > 0) summary.hint = anyCause.hint\n  }\n\n  // If the original cause isn't JSON-serializable, mark it explicitly.\n  const stringifyResult = safeStringify(cause)\n  if (!stringifyResult.ok) {\n    return {\n      errorSummary: summary,\n      downgrade: 'non_serializable',\n    }\n  }\n\n  if (truncated) {\n    return {\n      errorSummary: summary,\n      downgrade: 'oversized',\n    }\n  }\n\n  if (message === 'Unknown error') {\n    return {\n      errorSummary: summary,\n      downgrade: 'unknown',\n    }\n  }\n\n  return { errorSummary: summary }\n}\n"],
  "mappings": "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",
  "names": ["Cause", "Cause", "diagnosticsLevel", "metaProjection"]
}
