@logixjs/core 0.0.1

package/dist/chunk-DMBALCE2.js

@@ -0,0 +1,1034 @@
+import {
+  currentLinkId,
+  projectJsonValue
+} from "./chunk-JWOYLO27.js";
+
+// src/internal/runtime/core/DebugSink.ts
+import { Cause as Cause2, Effect, FiberRef, Layer, Logger } from "effect";
+
+// src/internal/runtime/core/errorSummary.ts
+import { Cause } from "effect";
+var truncate = (value, maxLen) => {
+  if (value.length <= maxLen) return { value, truncated: false };
+  return { value: value.slice(0, maxLen), truncated: true };
+};
+var safeStringify = (value) => {
+  try {
+    return { ok: true, json: JSON.stringify(value) };
+  } catch {
+    return { ok: false };
+  }
+};
+var getMessageFromUnknown = (cause) => {
+  if (typeof cause === "string") return cause;
+  if (typeof cause === "number" || typeof cause === "boolean" || typeof cause === "bigint") return String(cause);
+  if (cause instanceof Error) return cause.message || cause.name || "Error";
+  if (cause && typeof cause === "object" && "message" in cause && typeof cause.message === "string") {
+    return cause.message;
+  }
+  try {
+    const pretty = Cause.pretty(cause, { renderErrorCause: true });
+    if (typeof pretty === "string" && pretty.length > 0) return pretty;
+  } catch {
+  }
+  return "Unknown error";
+};
+var toSerializableErrorSummary = (cause, options) => {
+  const maxMessageLength = options?.maxMessageLength ?? 256;
+  const messageRaw = getMessageFromUnknown(cause);
+  const { value: message, truncated } = truncate(messageRaw, maxMessageLength);
+  const summary = {
+    message
+  };
+  if (cause instanceof Error) {
+    if (cause.name && cause.name !== "Error") summary.name = cause.name;
+    const anyCause = cause;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    else if (typeof anyCause.code === "number" && Number.isFinite(anyCause.code)) summary.code = String(anyCause.code);
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+    return {
+      errorSummary: summary,
+      downgrade: truncated ? "oversized" : void 0
+    };
+  }
+  if (cause && typeof cause === "object") {
+    const anyCause = cause;
+    if (typeof anyCause.name === "string" && anyCause.name.length > 0) summary.name = anyCause.name;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+  }
+  const stringifyResult = safeStringify(cause);
+  if (!stringifyResult.ok) {
+    return {
+      errorSummary: summary,
+      downgrade: "non_serializable"
+    };
+  }
+  if (truncated) {
+    return {
+      errorSummary: summary,
+      downgrade: "oversized"
+    };
+  }
+  if (message === "Unknown error") {
+    return {
+      errorSummary: summary,
+      downgrade: "unknown"
+    };
+  }
+  return { errorSummary: summary };
+};
+
+// src/internal/runtime/core/DebugSink.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
+      });
+    }
+    default: {
+      if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
+        return void 0;
+      }
+      if (event.type === "trace:txn-lane") {
+        const data = event.data;
+        const evidence = data?.evidence ?? data;
+        const metaProjection2 = projectJsonValue(evidence);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = 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=chunk-DMBALCE2.js.map