@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,706 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  projectJsonValue
+} from "./chunk-RYSSJBGX.js";
+
+// ../logix-core/src/internal/runtime/core/DebugSink.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.ts
+var currentDebugSinks = FiberRef.unsafeMake([]);
+var currentRuntimeLabel = FiberRef.unsafeMake(void 0);
+var currentTxnId = FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = FiberRef.unsafeMake("off");
+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 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 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"
+      );
+      console.log(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 browserPrettyLoggerLayer = Logger.replace(
+  Logger.defaultLogger,
+  Logger.prettyLogger({ mode: "browser", colors: true })
+);
+var record = (event) => Effect.gen(function* () {
+  const sinks = yield* FiberRef.get(currentDebugSinks);
+  const runtimeLabel = yield* FiberRef.get(currentRuntimeLabel);
+  const txnId = yield* FiberRef.get(currentTxnId);
+  const now = Date.now();
+  const enriched = event;
+  if (enriched.timestamp === void 0) {
+    ;
+    enriched.timestamp = now;
+  }
+  if (runtimeLabel && enriched.runtimeLabel === void 0) {
+    ;
+    enriched.runtimeLabel = runtimeLabel;
+  }
+  if (txnId && enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    ;
+    enriched.txnId = txnId;
+  }
+  if (sinks.length > 0) {
+    yield* Effect.forEach(
+      sinks,
+      (sink) => sink.record(enriched),
+      {
+        discard: true
+      }
+    );
+    return;
+  }
+  if (isBrowser) {
+    yield* renderBrowserConsoleEvent(enriched);
+    return;
+  }
+  if (enriched.type === "lifecycle:error") {
+    yield* lifecycleErrorLog(enriched);
+    return;
+  }
+  if (enriched.type === "diagnostic") {
+    yield* diagnosticLog(enriched);
+    return;
+  }
+  yield* Effect.void;
+});
+var toRuntimeDebugEventRef = (event, options) => {
+  const diagnosticsLevel = options?.diagnosticsLevel ?? "full";
+  if (diagnosticsLevel === "off") {
+    return void 0;
+  }
+  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 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,
+    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 = diagnosticsLevel === "light" ? { 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 tag = action?._tag ?? action?.type ?? "action:dispatch";
+      const label = String(tag);
+      const metaInput = diagnosticsLevel === "light" ? { actionTag: label } : { action };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "action",
+        label,
+        meta: metaProjection.value
+      });
+    }
+    case "state:update": {
+      const e = event;
+      const metaInput = diagnosticsLevel === "light" ? {
+        state: e.state,
+        dirtySet: e.dirtySet,
+        patchCount: e.patchCount,
+        commitMode: e.commitMode,
+        priority: e.priority,
+        originKind: e.originKind,
+        originName: e.originName
+      } : {
+        state: e.state,
+        dirtySet: e.dirtySet,
+        patchCount: e.patchCount,
+        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 });
+      }
+      return withDowngrade({
+        ...base,
+        kind: "state",
+        label: "state:update",
+        meta: metaProjection.value
+      });
+    }
+    case "lifecycle:error": {
+      const e = event;
+      const summary = toSerializableErrorSummary(e.cause);
+      downgrade = mergeDowngrade(downgrade, summary.downgrade);
+      const metaInput = diagnosticsLevel === "light" ? { 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
+      });
+    }
+    default: {
+      if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
+        return void 0;
+      }
+      if (event.type === "trace:react-render" || event.type === "trace:react-selector") {
+        const data = event.data;
+        const metaProjection2 = projectJsonValue(
+          diagnosticsLevel === "light" ? {
+            componentLabel: data?.componentLabel,
+            selectorKey: data?.selectorKey,
+            fieldPaths: data?.fieldPaths,
+            strictModePhase: data?.strictModePhase
+          } : {
+            componentLabel: data?.componentLabel,
+            selectorKey: data?.selectorKey,
+            fieldPaths: data?.fieldPaths,
+            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 = event.type === "trace:react-render" ? lastTxnByInstance.get(instanceId) : void 0;
+        const txnIdAligned = base.txnId ?? last?.txnId;
+        const txnSeqAligned = base.txnSeq > 0 ? base.txnSeq : last?.txnSeq ?? base.txnSeq;
+        return withDowngrade({
+          ...base,
+          txnId: txnIdAligned,
+          txnSeq: txnSeqAligned,
+          kind: event.type === "trace:react-selector" ? "react-selector" : "react-render",
+          label,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:trait:converge") {
+        const stripHeavy = (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 { top3, dirtyRoots, ...rest } = anyValue;
+          return dirtySlim ? { ...rest, dirty: dirtySlim } : rest;
+        };
+        const data = event.data;
+        const metaInput = diagnosticsLevel === "light" ? 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: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 = diagnosticsLevel === "light" ? 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 = diagnosticsLevel === "light" ? {
+          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 = diagnosticsLevel === "light" ? {
+          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 = diagnosticsLevel === "light" ? {
+          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 = diagnosticsLevel === "light" ? {
+          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(
+        diagnosticsLevel === "light" ? {
+          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,
+  currentDiagnosticsLevel,
+  clearRuntimeDebugEventSeq,
+  noopLayer,
+  errorOnlyLayer,
+  browserConsoleLayer,
+  record,
+  toRuntimeDebugEventRef
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/DebugSink.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\"\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 * - Debug \u4E8B\u4EF6\u4FA7\u5F15\u7528\u7684\u201C\u56DE\u653E\u4E8B\u4EF6\u201D\u7ED3\u6784\uFF1B\n * - \u57FA\u4E8E ReplayLog.Event\uFF0C\u5E76\u8865\u9F50 txn/trigger \u7B49\u5173\u8054\u5B57\u6BB5\u4EE5\u4FBF\u4E8E\u5728 Devtools \u4E2D\u505A\u805A\u5408\u4E0E\u89E3\u91CA\u3002\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 txnSeq?: number\n      readonly txnId?: string\n      readonly runtimeLabel?: string\n      readonly timestamp?: number\n    }\n\t  | {\n\t      readonly type: \"state:update\"\n\t      readonly moduleId?: string\n\t      readonly instanceId?: string\n\t      readonly state: unknown\n      readonly txnSeq?: number\n      readonly txnId?: string\n      /**\n       * \u53EF\u9009\uFF1A\u672C\u6B21\u63D0\u4EA4\u805A\u5408\u7684\u5F71\u54CD\u57DF\uFF08\u5B57\u6BB5\u7EA7 dirty-set\uFF09\u3002\n       * - \u7531 Runtime \u5728 commit \u70B9\u586B\u5145\uFF1B\n       * - \u5FC5\u987B\u4FDD\u6301 Slim \u4E14\u53EF\u5E8F\u5217\u5316\uFF1B\n       * - \u53EF\u88AB Devtools \u7528\u4E8E explain \u201C\u4E3A\u4F55\u89E6\u53D1 converge/validate/\u4E3A\u4F55\u9000\u5316 full\u201D\u3002\n       */\n      readonly dirtySet?: unknown\n      /**\n       * \u53EF\u9009\uFF1A\u672C\u6B21\u63D0\u4EA4\u805A\u5408\u7684 Patch \u6570\u91CF\uFF08\u6765\u81EA StateTransaction\uFF09\uFF1B\n       * - \u4EC5\u5728\u4E8B\u52A1\u8DEF\u5F84\u4E0B\u7531 Runtime \u586B\u5145\uFF1B\n       * - Devtools \u53EF\u7528\u4F5C\u4E8B\u52A1\u6982\u8981\u4FE1\u606F\u7684\u8F7B\u91CF\u6307\u6807\u3002\n       */\n      readonly patchCount?: number\n      /**\n       * \u53EF\u9009\uFF1A\u63D0\u4EA4\u6A21\u5F0F\uFF08\u666E\u901A/\u6279\u5904\u7406/\u4F4E\u4F18\u5148\u7EA7\u7B49\uFF09\u3002\n       * - \u7531 Runtime \u586B\u5145\uFF1B\n       * - \u9ED8\u8BA4\u503C\u7531\u8C03\u7528\u65B9\u51B3\u5B9A\uFF08\u901A\u5E38\u4E3A \"normal\"\uFF09\u3002\n       */\n      readonly commitMode?: string\n      /**\n       * \u53EF\u9009\uFF1A\u5BF9\u5916\u53EF\u89C1\u6027\u4F18\u5148\u7EA7\uFF08normal/low\uFF09\u3002\n       * - \u7531 Runtime \u586B\u5145\uFF1B\n       * - \u4E3B\u8981\u7528\u4E8E React \u5916\u90E8\u8BA2\u9605\u8C03\u5EA6\uFF08\u907F\u514D\u975E\u5FC5\u8981 render\uFF09\u3002\n       */\n      readonly priority?: string\n      /**\n       * \u53EF\u9009\uFF1A\u89E6\u53D1\u672C\u6B21\u72B6\u6001\u63D0\u4EA4\u7684\u4E8B\u52A1\u6765\u6E90\u79CD\u7C7B\uFF08origin.kind\uFF09\uFF1A\n       * - \u4F8B\u5982 \"action\" / \"source-refresh\" / \"service-callback\" / \"devtools\"\uFF1B\n       * - \u4EC5\u5728\u57FA\u4E8E StateTransaction \u7684\u8DEF\u5F84\u4E0B\u7531 Runtime \u586B\u5145\uFF1B\n       * - Devtools \u53EF\u636E\u6B64\u533A\u5206\u4E1A\u52A1\u4E8B\u52A1\u4E0E Devtools time-travel \u64CD\u4F5C\u3002\n       */\n      readonly originKind?: string\n      /**\n       * \u53EF\u9009\uFF1A\u89E6\u53D1\u672C\u6B21\u72B6\u6001\u63D0\u4EA4\u7684\u4E8B\u52A1\u6765\u6E90\u540D\u79F0\uFF08origin.name\uFF09\uFF1A\n       * - \u4F8B\u5982 action dispatch / fieldPath / task:success/task:failure \u7B49\uFF1B\n       * - \u4EC5\u5728\u57FA\u4E8E StateTransaction \u7684\u8DEF\u5F84\u4E0B\u7531 Runtime \u586B\u5145\u3002\n       */\n      readonly originName?: string\n      /**\n       * \u9884\u7559\uFF1ATrait \u6536\u655B\u6458\u8981\uFF08\u7528\u4E8E Devtools \u5C55\u793A\u7A97\u53E3\u7EA7\u7EDF\u8BA1/TopN \u6210\u672C/\u964D\u7EA7\u539F\u56E0\u7B49\uFF09\u3002\n       * - Phase 2\uFF1A\u4EC5\u56FA\u5316\u5B57\u6BB5\u4F4D\uFF0C\u4E0D\u9501\u6B7B\u7ED3\u6784\uFF1B\n       * - \u540E\u7EED Phase \u4F1A\u4E0E Trait/Replay \u4E8B\u4EF6\u6A21\u578B\u5BF9\u9F50\u4E3A\u53EF\u89E3\u91CA\u7ED3\u6784\u3002\n       */\n      readonly traitSummary?: unknown\n      /**\n\t       * \u9884\u7559\uFF1A\u672C\u6B21\u4E8B\u52A1\u5173\u8054\u7684\u56DE\u653E\u4E8B\u4EF6\uFF08ReplayLog \u4FA7\u7684 re-emit \u4E8B\u5B9E\u6E90\uFF09\u3002\n\t       * - Phase 2\uFF1A\u4EC5\u56FA\u5316\u5B57\u6BB5\u4F4D\uFF1B\n\t       * - \u540E\u7EED Phase \u4F1A\u4E0E ReplayLog.Event \u7ED3\u6784\u5BF9\u9F50\u3002\n\t       */\n\t      readonly replayEvent?: ReplayEventRef\n\t      readonly runtimeLabel?: string\n\t      readonly timestamp?: number\n\t    }\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?:\n        | \"initRequired\"\n        | \"start\"\n        | \"destroy\"\n        | \"suspend\"\n        | \"resume\"\n        | \"reset\"\n        | \"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\t  | {\n\t      readonly type: \"diagnostic\"\n\t      readonly moduleId?: string\n\t      readonly instanceId?: string\n\t      readonly code: string\n\t      readonly severity: \"error\" | \"warning\" | \"info\"\n\t      readonly message: string\n\t      readonly hint?: string\n\t      readonly actionTag?: string\n\t      readonly kind?: string\n\t      readonly txnSeq?: number\n\t      readonly txnId?: string\n\t      readonly trigger?: TriggerRef\n\t      readonly runtimeLabel?: string\n\t      readonly timestamp?: number\n\t    }\n  /**\n   * trace:* \u4E8B\u4EF6\uFF1A\n   * - \u4F5C\u4E3A\u8FD0\u884C\u65F6 trace / Playground / Alignment Lab \u7684\u6269\u5C55\u94A9\u5B50\uFF1B\n   * - \u5F53\u524D\u53EA\u7EA6\u5B9A type \u524D\u7F00\u4E0E moduleId\uFF0C\u5177\u4F53 payload \u7ED3\u6784\u7531\u4E0A\u5C42\u7EA6\u5B9A\uFF08\u4F8B\u5982 data \u5185\u6302 spanId/attributes \u7B49\uFF09\u3002\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 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 type DiagnosticsLevel = \"off\" | \"light\" | \"full\"\nexport const currentDiagnosticsLevel = FiberRef.unsafeMake<DiagnosticsLevel>(\"off\")\n\nexport type RuntimeDebugEventKind =\n  | \"action\"\n  | \"state\"\n  | \"service\"\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  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\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// \u6D4F\u89C8\u5668\u73AF\u5883\u4E0B\uFF0C\u4E3A\u4E86\u51CF\u5C11 React StrictMode \u7B49\u5BFC\u81F4\u7684\u91CD\u590D\u65E5\u5FD7\u566A\u97F3\uFF0C\n// \u5BF9 lifecycle:error \u4E0E diagnostic \u4E8B\u4EF6\u505A\u4E00\u6B21\u7B80\u5355\u53BB\u91CD\uFF1A\u540C\u4E00 moduleId+payload \u53EA\u6253\u5370\u4E00\u6B21\u3002\nconst browserLifecycleSeen = new Set<string>()\nconst browserDiagnosticSeen = new Set<string>()\n\n// \u7528\u4E8E\u5C06 trace:react-render \u4E8B\u4EF6\u4E0E\u6700\u8FD1\u4E00\u6B21 state:update \u4E8B\u52A1\u5BF9\u9F50\uFF08\u4EC5\u4F5C\u4E3A UI \u8F85\u52A9\u5173\u8054\uFF09\u3002\nconst lastTxnByInstance = new Map<string, { readonly txnId: string; readonly txnSeq: number }>()\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 * \u57FA\u4E8E FiberRef.currentDebugSinks \u7684\u9ED8\u8BA4 Layer \u7EC4\u5408\uFF1A\n * - \u4F7F\u7528 Layer.locallyScoped \u786E\u4FDD Debug sinks \u4F5C\u4E3A FiberRef \u72B6\u6001\u6CE8\u5165\uFF0C\n * - \u4E0D\u518D\u5C06 FiberRef \u8BEF\u7528\u4E3A Context.Tag\u3002\n */\nexport const noopLayer = Layer.locallyScoped(currentDebugSinks, [])\n\n/**\n * errorOnlyLayer\uFF1A\n * - \u9ED8\u8BA4\u7684 DebugSink \u5B9E\u73B0\uFF0C\u4EC5\u5173\u5FC3 lifecycle:error \u4E8B\u4EF6\uFF1B\n * - \u9002\u5408\u4F5C\u4E3A Runtime \u7684\u201C\u6700\u4F4E\u9650\u5EA6\u89C2\u6D4B\u201D\u5C42\uFF0C\u4FDD\u8BC1\u81F4\u547D\u9519\u8BEF\u4E0D\u4F1A\u6084\u7136\u6D88\u5931\uFF1B\n * - \u5176\u4ED6\u4E8B\u4EF6\uFF08module:init/destroy\u3001action:dispatch\u3001state:update\uFF09\u9ED8\u8BA4\u4E0D\u8BB0\u5F55\u3002\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\n/**\n * consoleLayer\uFF1A\n * - \u5168\u91CF\u8C03\u8BD5\u5C42\uFF0C\u5C06\u6240\u6709 Debug \u4E8B\u4EF6\u4EE5 Effect \u65E5\u5FD7\u5F62\u5F0F\u8F93\u51FA\uFF08logfmt / structured\uFF09\uFF0C\n * - \u9002\u5408\u4F5C\u4E3A\u901A\u7528\u73AF\u5883\uFF08Node / \u6D4B\u8BD5\u73AF\u5883\uFF09\u7684\u89C2\u6D4B\u5C42\u3002\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// \u6D4F\u89C8\u5668\u73AF\u5883\u4E0B\u7EDF\u4E00\u7684 Console \u6E32\u67D3\u903B\u8F91\uFF0C\u7528\u4E8E DebugSink \u7F3A\u7701\u5B9E\u73B0\u4E0E browserConsoleLayer\u3002\nconst renderBrowserConsoleEvent = (event: Event): Effect.Effect<void> => {\n  // trace:* \u4E8B\u4EF6\uFF1A\u5728\u6D4F\u89C8\u5668\u4E2D\u4EE5\u72EC\u7ACB\u5206\u7EC4\u5C55\u793A\uFF0C\u4FBF\u4E8E Playground / DevTools \u89C2\u6D4B\u3002\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\"\n        ? \"color:#d97706\"\n        : event.severity === \"info\"\n          ? \"color:#3b82f6\"\n          : \"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      // eslint-disable-next-line no-console\n      console.log(detail)\n      // eslint-disable-next-line no-console\n      console.groupEnd()\n    })\n  }\n\n  // \u5176\u4ED6\u4E8B\u4EF6\uFF1A\u9ED8\u8BA4\u4E0D\u5728\u6D4F\u89C8\u5668\u63A7\u5236\u53F0\u8F93\u51FA\uFF0C\u4EE5\u514D\u5728\u4E1A\u52A1\u5F00\u53D1\u573A\u666F\u4E2D\u8FC7\u4E8E\u5435\u95F9\uFF1B\n  // \u5982\u9700\u67E5\u770B\u5185\u90E8\u8C03\u8BD5\u4E8B\u4EF6\uFF0C\u53EF\u901A\u8FC7\u81EA\u5B9A\u4E49 Debug Sink \u6216\u5728 Node \u73AF\u5883\u4E0B\u4F7F\u7528 consoleLayer\u3002\n  return Effect.void\n}\n\n/**\n * \u6D4F\u89C8\u5668 Console \u8C03\u8BD5\u5C42\uFF1A\n * - \u5728\u6D4F\u89C8\u5668\u73AF\u5883\u4E0B\u4F7F\u7528 console.groupCollapsed + \u5F69\u8272 label \u6A21\u62DF pretty logger \u7684\u5206\u7EC4\u6548\u679C\uFF1B\n * - \u5728\u975E\u6D4F\u89C8\u5668\u73AF\u5883\u4E0B\u56DE\u9000\u5230 consoleLayer \u7684 Effect \u65E5\u5FD7\u5B9E\u73B0\u3002\n */\nconst browserConsoleSink: Sink = {\n  record: (event: Event) => {\n    if (!isBrowser) {\n      // \u975E\u6D4F\u89C8\u5668\u73AF\u5883\uFF1A\u9000\u56DE\u5230 Effect.log* \u7684 consoleLayer \u884C\u4E3A\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 * \u6D4F\u89C8\u5668\u53CB\u597D\u7684 Logger \u5C42\uFF1A\u4F7F\u7528 Effect \u5B98\u65B9\u7684 pretty logger\uFF08browser \u6A21\u5F0F\uFF09\u66FF\u6362\u9ED8\u8BA4 logger\u3002\n * - \u4E0D\u518D\u624B\u5199 console \u6837\u5F0F\uFF0C\u76F4\u63A5\u590D\u7528 Effect \u7684\u5F69\u8272/\u5206\u7EC4\u683C\u5F0F\uFF1B\n * - \u5728\u670D\u52A1\u7AEF\u73AF\u5883\u4E0B\u4E5F\u80FD\u5B89\u5168\u9000\u5316\u4E3A\u9ED8\u8BA4 logger\u3002\n */\nexport const browserPrettyLoggerLayer = Logger.replace(\n  Logger.defaultLogger,\n  Logger.prettyLogger({ mode: \"browser\", colors: true })\n)\n\n/**\n * defaultLayer\uFF1A\n * - \u516C\u5171\u9ED8\u8BA4\u5C42\uFF0C\u5F53\u524D\u7B49\u540C\u4E8E errorOnlyLayer\uFF1B\n * - \u4EC5\u8BB0\u5F55 lifecycle:error\uFF0C\u907F\u514D\u5728\u9ED8\u8BA4\u60C5\u51B5\u4E0B\u5BF9 action/state \u6253\u5370\u5927\u91CF\u65E5\u5FD7\u3002\n */\nexport const defaultLayer = errorOnlyLayer\n\nexport const record = (event: Event) =>\n  Effect.gen(function* () {\n    const sinks = yield* FiberRef.get(currentDebugSinks)\n    const runtimeLabel = yield* FiberRef.get(currentRuntimeLabel)\n    const txnId = yield* FiberRef.get(currentTxnId)\n\n    // \u4E3A Debug.Event \u8865\u5168\u57FA\u7840\u5B57\u6BB5\uFF1A\n    // - timestamp\uFF1A\u7528\u4E8E Devtools/Timeline/Overview \u505A\u65F6\u95F4\u805A\u5408\uFF0C\u907F\u514D UI \u4FA7\u7528 Date.now()\u201C\u9996\u6B21\u89C2\u5BDF\u65F6\u95F4\u201D\u5BFC\u81F4\u5931\u771F\uFF1B\n    // - runtimeLabel\uFF1A\u6765\u81EA FiberRef\uFF0C\u4FBF\u4E8E\u6309 runtime \u7EF4\u5EA6\u5206\u7EC4\uFF08\u4EC5\u5728\u4E8B\u4EF6\u672A\u663E\u5F0F\u63D0\u4F9B\u65F6\u6CE8\u5165\uFF09\u3002\n    const now = Date.now()\n    const enriched = event as Event\n    if (enriched.timestamp === undefined) {\n      ;(enriched as any).timestamp = now\n    }\n\tif (runtimeLabel && enriched.runtimeLabel === undefined) {\n\t  ;(enriched as any).runtimeLabel = runtimeLabel\n\t}\n\tif (txnId && enriched.type === \"diagnostic\" && (enriched as any).txnId === undefined) {\n\t  ;(enriched as any).txnId = txnId\n\t}\n\n    if (sinks.length > 0) {\n      yield* Effect.forEach(\n        sinks,\n        (sink) => sink.record(enriched),\n        {\n          discard: true,\n        },\n      )\n      return\n    }\n\n    if (isBrowser) {\n      yield* renderBrowserConsoleEvent(enriched)\n      return\n    }\n    if (enriched.type === \"lifecycle:error\") {\n      yield* lifecycleErrorLog(enriched)\n      return\n    }\n    if (enriched.type === \"diagnostic\") {\n      yield* diagnosticLog(enriched)\n      return\n    }\n    yield* Effect.void\n  })\n\n/**\n * \u5C06\u5185\u90E8 Debug.Event \u5F52\u4E00\u5316\u4E3A RuntimeDebugEventRef\uFF1A\n * - \u4FBF\u4E8E Devtools / Runtime \u7EDF\u4E00\u6D88\u8D39 Debug \u4E8B\u4EF6\uFF1B\n * - \u4E0D\u6539\u53D8\u539F\u6709 DebugSink \u884C\u4E3A\uFF0C\u4EC5\u63D0\u4F9B\u7ED3\u6784\u5316\u89C6\u56FE\u3002\n */\nexport const toRuntimeDebugEventRef = (\n  event: Event,\n  options?: {\n    readonly diagnosticsLevel?: DiagnosticsLevel\n    readonly eventSeq?: number\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 timestamp =\n    typeof event.timestamp === \"number\" && Number.isFinite(event.timestamp)\n      ? event.timestamp\n      : Date.now()\n\n  const moduleIdRaw = (event as any).moduleId\n  const moduleId =\n    typeof moduleIdRaw === \"string\" && moduleIdRaw.length > 0 ? moduleIdRaw : \"unknown\"\n\n  const instanceIdRaw = (event as any).instanceId\n  const instanceId =\n    typeof instanceIdRaw === \"string\" && instanceIdRaw.length > 0\n      ? instanceIdRaw\n      : \"unknown\"\n\n  const runtimeLabelRaw = (event as any).runtimeLabel\n  const runtimeLabel =\n    typeof runtimeLabelRaw === \"string\" && runtimeLabelRaw.length > 0\n      ? runtimeLabelRaw\n      : undefined\n\n  const txnSeqRaw = (event as any).txnSeq\n  const txnSeq =\n    typeof txnSeqRaw === \"number\" && Number.isFinite(txnSeqRaw) && txnSeqRaw >= 0\n      ? Math.floor(txnSeqRaw)\n      : 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 eventSeqRaw = options?.eventSeq\n  const eventSeq =\n    typeof eventSeqRaw === \"number\" &&\n    Number.isFinite(eventSeqRaw) &&\n    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    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 =\n        diagnosticsLevel === \"light\"\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 tag = action?._tag ?? action?.type ?? \"action:dispatch\"\n      const label = String(tag)\n      const metaInput = diagnosticsLevel === \"light\" ? { actionTag: label } : { action }\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: \"action\",\n        label,\n        meta: metaProjection.value,\n      })\n    }\n    case \"state:update\": {\n      const e = event as Extract<Event, { readonly type: \"state:update\" }>\n      const metaInput =\n        diagnosticsLevel === \"light\"\n          ? {\n              state: e.state,\n              dirtySet: e.dirtySet,\n              patchCount: e.patchCount,\n              commitMode: e.commitMode,\n              priority: e.priority,\n              originKind: e.originKind,\n              originName: e.originName,\n            }\n          : {\n              state: e.state,\n              dirtySet: e.dirtySet,\n              patchCount: e.patchCount,\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      }\n      return withDowngrade({\n        ...base,\n        kind: \"state\",\n        label: \"state:update\",\n        meta: metaProjection.value,\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 =\n        diagnosticsLevel === \"light\"\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    default: {\n      if (typeof event.type !== \"string\" || !event.type.startsWith(\"trace:\")) {\n        return undefined\n      }\n\n      // trace:react-render / trace:react-selector\uFF1A\u53EA\u4FDD\u7559 Slim meta\uFF08\u5B57\u6BB5\u88C1\u526A\u7531 JsonValue \u6295\u5F71\u627F\u62C5\uFF09\u3002\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          diagnosticsLevel === \"light\"\n            ? {\n                componentLabel: data?.componentLabel,\n                selectorKey: data?.selectorKey,\n                fieldPaths: data?.fieldPaths,\n                strictModePhase: data?.strictModePhase,\n              }\n            : {\n                componentLabel: data?.componentLabel,\n                selectorKey: data?.selectorKey,\n                fieldPaths: data?.fieldPaths,\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 =\n          event.type === \"trace:react-render\" ? lastTxnByInstance.get(instanceId) : undefined\n        const txnIdAligned = base.txnId ?? last?.txnId\n        const txnSeqAligned = base.txnSeq > 0 ? base.txnSeq : (last?.txnSeq ?? base.txnSeq)\n        return 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\n      // trace:trait:converge\uFF1A\u6536\u655B\u8BC1\u636E\u5FC5\u987B\u53EF\u5BFC\u51FA\uFF08JsonValue \u786C\u95E8\uFF09\uFF0C\u5E76\u5728 light \u6863\u4F4D\u88C1\u526A\u91CD\u5B57\u6BB5\u3002\n      if (event.type === \"trace:trait:converge\") {\n        const stripHeavy = (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\"\n                    ? { reason: (dirty as any).reason }\n                    : null),\n                }\n              : undefined\n\n          const { top3, 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 = diagnosticsLevel === \"light\" ? 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:converge\",\n          label: \"trait:converge\",\n          meta: metaProjection.value,\n        })\n      }\n\n      // trace:trait:check\uFF1A\u6821\u9A8C\u8BCA\u65AD\u5FC5\u987B\u53EF\u5BFC\u51FA\uFF0C\u5E76\u5728 light \u6863\u4F4D\u4FDD\u6301 Slim\uFF08\u4E0D\u4E22\u5173\u952E\u5B57\u6BB5\uFF09\u3002\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 = diagnosticsLevel === \"light\" ? 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\uFF1A\u6821\u9A8C\u51B3\u7B56\u6458\u8981\u5FC5\u987B\u53EF\u5BFC\u51FA\uFF0C\u4E14\u5728 light \u6863\u4F4D\u4FDD\u6301 Slim\uFF08\u9ED8\u8BA4\u4E0D\u643A\u5E26\u91CD\u5B57\u6BB5\uFF09\u3002\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\uFF1Atraits \u6700\u7EC8\u5FEB\u7167\u5FC5\u987B\u53EF\u5BFC\u51FA\uFF0C\u5E76\u5728 light \u6863\u4F4D\u4FDD\u6301 Slim\uFF08digest/count\uFF09\u3002\n      if (event.type === \"trace:module:traits\") {\n        const data: any = (event as any).data\n        const metaInput =\n          diagnosticsLevel === \"light\"\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\uFF1A\u51B2\u7A81\u7EC6\u8282\u5FC5\u987B\u53EF\u5BFC\u51FA\uFF0C\u907F\u514D\u4F9D\u8D56 lifecycle:error \u7684\u622A\u65AD message\u3002\n      if (event.type === \"trace:module:traits:conflict\") {\n        const data: any = (event as any).data\n        const metaInput =\n          diagnosticsLevel === \"light\"\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\uFF1A\u5728 light \u6863\u4F4D\u4E5F\u4FDD\u7559\u5173\u952E\u951A\u70B9\uFF08\u907F\u514D data \u88AB\u5B8C\u5168\u88C1\u526A\uFF09\u3002\n      if (event.type === \"trace:module:descriptor\") {\n        const data: any = (event as any).data\n        const metaInput =\n          diagnosticsLevel === \"light\"\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\uFF1A\u4FDD\u7559 Slim op meta\uFF0C\u5E76\u4F18\u5148\u4F7F\u7528 EffectOp.meta.moduleId\uFF08\u82E5\u5B58\u5728\uFF09\u3002\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 =\n          diagnosticsLevel === \"light\"\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      // \u5176\u4ED6 trace:*\uFF1A\u7EDF\u4E00\u5F52\u7C7B\u4E3A devtools\uFF0C\u5E76\u6309\u6863\u4F4D\u88C1\u526A meta\u3002\n      const metaProjection = projectJsonValue(\n        diagnosticsLevel === \"light\"\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", "metaProjection"]
}
