inspeffct 0.1.1 → 1.0.1

package/dist/bootloader.cjs

@@ -57,6 +57,41 @@
 
   // src/Encoder.ts
   var constFailure2 = { _tag: "Failure" };
+  var formatBestEffort = (value) => {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const go = (input) => {
+      if (input === null) return "null";
+      switch (typeof input) {
+        case "string":
+          return JSON.stringify(input);
+        case "number":
+        case "boolean":
+        case "bigint":
+          return String(input);
+        case "undefined":
+          return "undefined";
+        case "symbol":
+          return String(input);
+        case "function":
+          return `[Function: ${input.name || "anonymous"}]`;
+        case "object": {
+          if (seen.has(input)) return "[Circular]";
+          seen.add(input);
+          if (Array.isArray(input)) {
+            return `[${input.map(go).join(", ")}]`;
+          }
+          if (input instanceof Error) {
+            return `${input.name}: ${input.message}`;
+          }
+          const entries = Object.keys(input).map((key) => `${key}: ${go(input[key])}`);
+          return `{ ${entries.join(", ")} }`;
+        }
+        default:
+          return String(input);
+      }
+    };
+    return go(value);
+  };
   var literal2 = (value) => (givenValue) => givenValue === value ? { _tag: "Success", value } : constFailure2;
   var string2 = (value) => typeof value === "string" ? { _tag: "Success", value } : constFailure2;
   var boolean = (value) => typeof value === "boolean" ? { _tag: "Success", value } : constFailure2;
@@ -105,6 +140,13 @@
     return { _tag: "Success", value: result };
   };
   var unknown = (value) => ({ _tag: "Success", value });
+  var bestEffortAny = (value) => {
+    try {
+      return { _tag: "Success", value: JSON.parse(JSON.stringify(value)) };
+    } catch {
+      return { _tag: "Success", value: formatBestEffort(value) };
+    }
+  };
   var lazy = (thunk) => (value) => thunk()(value);
 
   // src/ProtocolEncoder.generated.ts
@@ -113,23 +155,23 @@
   var InitNotification = struct2({ _tag: literal2("InitNotification"), protocolVersion: ProtocolVersion2, instrumentationId: InstrumentationId2, inspectorURL: union2(string2, literal2(null)), waitingForDebugger: boolean });
   var PingNotification = struct2({ _tag: literal2("PingNotification"), protocolVersion: ProtocolVersion2, instrumentationId: InstrumentationId2 });
   var SpanAttributes = array2(tuple(string2, unknown));
-  var BigInt = bigint;
-  var SpanStatusStarted = struct2({ _tag: literal2("Started"), startTime: BigInt });
+  var SpanStatusStarted = struct2({ _tag: literal2("Started"), startTime: bigint });
+  var BestEffortAny = bestEffortAny;
   var FiberIdNoneEncoded = struct2({ _tag: literal2("None") });
   var Int = number;
   var FiberIdRuntimeEncoded = struct2({ _tag: literal2("Runtime"), id: Int, startTimeMillis: Int });
   var FiberIdCompositeEncoded = struct2({ _tag: literal2("Composite"), left: lazy(() => FiberIdEncoded), right: lazy(() => FiberIdEncoded) });
   var FiberIdEncoded = union2(FiberIdNoneEncoded, FiberIdRuntimeEncoded, FiberIdCompositeEncoded);
-  var CauseEncoded3 = union2(struct2({ _tag: literal2("Empty") }), struct2({ _tag: literal2("Fail"), error: unknown }), struct2({ _tag: literal2("Die"), defect: unknown }), struct2({ _tag: literal2("Interrupt"), fiberId: FiberIdEncoded }), struct2({ _tag: literal2("Sequential"), left: lazy(() => CauseEncoded3), right: lazy(() => CauseEncoded3) }), struct2({ _tag: literal2("Parallel"), left: lazy(() => CauseEncoded3), right: lazy(() => CauseEncoded3) }));
-  var SpanExit = union2(struct2({ _tag: literal2("Failure"), cause: CauseEncoded3 }), struct2({ _tag: literal2("Success"), value: unknown }));
-  var SpanStatusEnded = struct2({ _tag: literal2("Ended"), startTime: BigInt, endTime: BigInt, exit: SpanExit });
+  var CauseEncoded3 = union2(struct2({ _tag: literal2("Empty") }), struct2({ _tag: literal2("Fail"), error: BestEffortAny }), struct2({ _tag: literal2("Die"), defect: BestEffortAny }), struct2({ _tag: literal2("Interrupt"), fiberId: FiberIdEncoded }), struct2({ _tag: literal2("Sequential"), left: lazy(() => CauseEncoded3), right: lazy(() => CauseEncoded3) }), struct2({ _tag: literal2("Parallel"), left: lazy(() => CauseEncoded3), right: lazy(() => CauseEncoded3) }));
+  var SpanExit = union2(struct2({ _tag: literal2("Failure"), cause: CauseEncoded3 }), struct2({ _tag: literal2("Success"), value: BestEffortAny }));
+  var SpanStatusEnded = struct2({ _tag: literal2("Ended"), startTime: bigint, endTime: bigint, exit: SpanExit });
   var SpanStatus = union2(SpanStatusStarted, SpanStatusEnded);
   var SpanAndTraceId = struct2({ traceId: string2, spanId: string2 });
   var Span = struct2({ _tag: literal2("Span"), spanId: string2, traceId: string2, name: string2, sampled: boolean, attributes: SpanAttributes, status: SpanStatus, parent: union2(SpanAndTraceId, literal2(null)) });
   var ExternalSpan = struct2({ _tag: literal2("ExternalSpan"), spanId: string2, traceId: string2, sampled: boolean });
   var AnySpan = union2(Span, ExternalSpan);
   var TracerSpanNotification = struct2({ _tag: literal2("TracerSpanNotification"), protocolVersion: ProtocolVersion2, instrumentationId: InstrumentationId2, span: AnySpan });
-  var SpanEvent = struct2({ spanId: string2, traceId: string2, name: string2, time: BigInt, attributes: SpanAttributes });
+  var SpanEvent = struct2({ spanId: string2, traceId: string2, name: string2, time: bigint, attributes: SpanAttributes });
   var TracerSpanEventNotification = struct2({ _tag: literal2("TracerSpanEventNotification"), protocolVersion: ProtocolVersion2, instrumentationId: InstrumentationId2, event: SpanEvent });
   var SpanLink = struct2({ spanId: string2, traceId: string2, linkedSpanId: string2, linkedTraceId: string2, attributes: SpanAttributes });
   var TracerSpanLinkNotification = struct2({ _tag: literal2("TracerSpanLinkNotification"), protocolVersion: ProtocolVersion2, instrumentationId: InstrumentationId2, link: SpanLink });
@@ -269,28 +311,28 @@
     }
   }
   function serializeCause(cause) {
-    switch (cause._tag) {
-      case "Empty":
-        return { _tag: "Empty" };
-      case "Fail":
-        return { _tag: "Fail", error: serializeToJson(cause.error) };
-      case "Die":
-        return { _tag: "Die", defect: serializeToJson(cause.defect) };
-      case "Interrupt":
-        return { _tag: "Interrupt", fiberId: serializeFiberId(cause.fiberId) };
-      case "Sequential":
-        return {
-          _tag: "Sequential",
-          left: cause.left ? serializeCause(cause.left) : { _tag: "Empty" },
-          right: cause.right ? serializeCause(cause.right) : { _tag: "Empty" }
-        };
-      case "Parallel":
-        return {
-          _tag: "Parallel",
-          left: cause.left ? serializeCause(cause.left) : { _tag: "Empty" },
-          right: cause.right ? serializeCause(cause.right) : { _tag: "Empty" }
-        };
+    const serializedReasons = cause.reasons.map((reason) => {
+      switch (reason._tag) {
+        case "Fail":
+          return { _tag: "Fail", error: serializeToJson(reason.error) };
+        case "Die":
+          return { _tag: "Die", defect: serializeToJson(reason.defect) };
+        case "Interrupt":
+          return { _tag: "Interrupt", fiberId: serializeFiberId(reason.fiberId) };
+      }
+    });
+    if (serializedReasons.length === 0) {
+      return { _tag: "Empty" };
+    }
+    let current = serializedReasons[0];
+    for (let i = 1; i < serializedReasons.length; i++) {
+      current = {
+        _tag: "Sequential",
+        left: current,
+        right: serializedReasons[i]
+      };
     }
+    return current;
   }
   function serializeExit(exit) {
     if (exit._tag === "Success") {
@@ -371,6 +413,8 @@ c.on("connect", () => {
       return false;
     }
   }
+  var CURRENT_FIBER_KEY = "~effect/Fiber/currentFiber";
+  var TRACER_KEY = "effect/Tracer";
   var _globalThis = globalThis;
   function getIpcSocketPath() {
     if (typeof process !== "undefined" && process.env) {
@@ -380,9 +424,9 @@ c.on("connect", () => {
   }
   function shouldWaitForDebugger() {
     if (typeof process !== "undefined" && process.env) {
-      return process.env.INSPEFFCT_NO_WAIT !== "1";
+      return process.env.INSPEFFCT_WAIT === "1";
     }
-    return true;
+    return false;
   }
   function waitForDebuggerNow() {
     try {
@@ -435,10 +479,11 @@ c.on("connect", () => {
     const ipcSocketPath = getIpcSocketPath();
     const inspectorInfo = getInspectorInfo();
     const bridgeAlreadyExists = typeof _globalThis.__inspeffct_bridge__ === "function";
-    const shouldWait = shouldWaitForDebugger() && inspectorInfo.weOpenedInspector && !bridgeAlreadyExists;
+    const shouldWait = (shouldWaitForDebugger() || inspectorInfo.weOpenedInspector) && !bridgeAlreadyExists;
     const instrumentation = createInstrumentation({ inspectorURL: inspectorInfo.inspectorURL }, shouldWait, (message) => {
       _globalThis["__inspeffct__"]?.onmessage(message);
     });
+    instrumentation.installEffectModulePatch();
     _globalThis["__inspeffct__"] = {
       send: instrumentation.handleMessage,
       onmessage: (message) => {
@@ -456,11 +501,11 @@ c.on("connect", () => {
         console.log("[inspeffct] No transport available, message:", message);
       }
     };
-    addSetInterceptor(_globalThis, "effect/FiberCurrent", (newFiber) => {
+    addSetInterceptor(_globalThis, CURRENT_FIBER_KEY, (newFiber) => {
       if (newFiber) instrumentation.ensureFiberIsTracked(newFiber);
     });
-    if (_globalThis["effect/FiberCurrent"]) {
-      instrumentation.ensureFiberIsTracked(_globalThis["effect/FiberCurrent"]);
+    if (_globalThis[CURRENT_FIBER_KEY]) {
+      instrumentation.ensureFiberIsTracked(_globalThis[CURRENT_FIBER_KEY]);
     }
     instrumentation.sendInitNotification();
     if (shouldWait && inspectorInfo.inspectorURL) {
@@ -479,6 +524,7 @@ c.on("connect", () => {
     parts.push(Math.random().toString(36).slice(2, 8));
     const instrumentationId = parts.join("-");
     const protocolVersion = 1;
+    const NATIVE_SPAN_PATCHED = "__inspeffct_native_span_patched__";
     function sendBack(event) {
       try {
         const encodedEvent = OutMessage(event);
@@ -510,12 +556,61 @@ c.on("connect", () => {
       }
     }
     const fibers = [];
+    const patchedFibers = /* @__PURE__ */ new WeakSet();
+    const patchedSpans = /* @__PURE__ */ new WeakSet();
+    function getFiberTracer(fiber) {
+      return fiber.context.mapUnsafe.get(TRACER_KEY);
+    }
+    function ensureSpanIsTracked(span) {
+      if (!span || span._tag !== "Span") {
+        return;
+      }
+      if (patchedSpans.has(span)) {
+        return;
+      }
+      patchedSpans.add(span);
+      sendTracerSpanNotification(span);
+      for (const link of span.links) {
+        sendTracerSpanLinkNotification(span, link);
+      }
+      const originalEnd = span.end;
+      span.end = function(...endArgs) {
+        originalEnd.apply(this, endArgs);
+        sendTracerSpanNotification(span);
+      };
+      const originalEvent = span.event;
+      span.event = function(name, time, attributes) {
+        originalEvent.apply(this, arguments);
+        sendTracerSpanEventNotification(span, name, time, attributes);
+      };
+      const originalAddLinks = span.addLinks;
+      span.addLinks = function(links) {
+        originalAddLinks.apply(this, arguments);
+        for (const link of links) {
+          sendTracerSpanLinkNotification(span, link);
+        }
+      };
+    }
+    function patchFiberContextTracking(fiber) {
+      if (patchedFibers.has(fiber)) {
+        return;
+      }
+      patchedFibers.add(fiber);
+      ensureSpanIsTracked(fiber.currentSpan);
+      const originalSetContext = fiber.setContext;
+      fiber.setContext = function(context) {
+        originalSetContext.call(this, context);
+        ensureSpanIsTracked(this.currentSpan);
+      };
+    }
     function ensureFiberIsTracked(fiber) {
       if (!fiber) return;
       if (fibers.indexOf(fiber) !== -1) return;
       fibers.push(fiber);
-      ensureTracerIsTracked(fiber.currentTracer);
-      if (fiber._children !== null) {
+      patchFiberContextTracking(fiber);
+      const tracer = getFiberTracer(fiber);
+      if (tracer) ensureTracerIsTracked(tracer);
+      if (fiber._children !== void 0) {
         fiber._children.forEach(ensureFiberIsTracked);
       }
       fiber.addObserver(() => {
@@ -531,36 +626,19 @@ c.on("connect", () => {
       const originalSpan = tracer.span;
       tracer.span = function(...args) {
         const span = originalSpan.apply(this, args);
-        sendTracerSpanNotification(span);
-        for (const link of span.links) {
-          sendTracerSpanLinkNotification(span, link);
-        }
-        const originalEnd = span.end;
-        span.end = function(...endArgs) {
-          originalEnd.apply(this, endArgs);
-          sendTracerSpanNotification(span);
-        };
-        const originalEvent = span.event;
-        span.event = function(name, time, attributes) {
-          originalEvent.apply(this, arguments);
-          sendTracerSpanEventNotification(span, name, time, attributes);
-        };
-        const originalAddLinks = span.addLinks;
-        span.addLinks = function(links) {
-          originalAddLinks.apply(this, arguments);
-          for (const link of links) {
-            sendTracerSpanLinkNotification(span, link);
-          }
-        };
+        ensureSpanIsTracked(span);
         return span;
       };
       const originalContext = tracer.context;
-      tracer.context = function(f, fiber) {
-        const context = originalContext.apply(this, arguments);
-        ensureFiberIsTracked(fiber);
-        ensureTracerIsTracked(fiber.currentTracer);
-        return context;
-      };
+      if (originalContext) {
+        tracer.context = function(f, fiber) {
+          const context = originalContext.apply(this, arguments);
+          ensureFiberIsTracked(fiber);
+          const tracer2 = getFiberTracer(fiber);
+          if (tracer2) ensureTracerIsTracked(tracer2);
+          return context;
+        };
+      }
     }
     function sendTracerSpanNotification(span) {
       if (span._tag === "ExternalSpan") {
@@ -627,6 +705,48 @@ c.on("connect", () => {
         }
       });
     }
+    function patchNativeSpanPrototype(NativeSpan) {
+      if (!NativeSpan?.prototype || NativeSpan.prototype[NATIVE_SPAN_PATCHED]) {
+        return;
+      }
+      NativeSpan.prototype[NATIVE_SPAN_PATCHED] = true;
+      const originalEnd = NativeSpan.prototype.end;
+      NativeSpan.prototype.end = function(endTime, exit) {
+        originalEnd.call(this, endTime, exit);
+        sendTracerSpanNotification(this);
+      };
+      const originalEvent = NativeSpan.prototype.event;
+      NativeSpan.prototype.event = function(name, startTime, attributes) {
+        originalEvent.call(this, name, startTime, attributes);
+        sendTracerSpanEventNotification(this, name, startTime, attributes);
+      };
+      const originalAddLinks = NativeSpan.prototype.addLinks;
+      NativeSpan.prototype.addLinks = function(links) {
+        originalAddLinks.call(this, links);
+        for (const link of links) {
+          sendTracerSpanLinkNotification(this, link);
+        }
+      };
+    }
+    function installEffectModulePatch() {
+      try {
+        const Module = __require("module");
+        const originalLoad = Module._load;
+        if (!originalLoad || originalLoad.__inspeffct_patched__) {
+          return;
+        }
+        const patchedLoad = function(request, parent, isMain) {
+          const exports$1 = originalLoad.call(this, request, parent, isMain);
+          if (request === "effect") {
+            patchNativeSpanPrototype(exports$1?.Tracer?.NativeSpan);
+          }
+          return exports$1;
+        };
+        patchedLoad.__inspeffct_patched__ = true;
+        Module._load = patchedLoad;
+      } catch {
+      }
+    }
     const resources = /* @__PURE__ */ new Map();
     function handleVariableReferenceInfoRequest(req) {
       if (req.variableReferenceId.instrumentationId !== instrumentationId) return;
@@ -686,8 +806,8 @@ c.on("connect", () => {
         requestId: req.requestId,
         fibers: fibers.map((fiber) => ({
           _tag: "FiberInfo",
-          id: globalThis.String(fiber.id().id),
-          isCurrent: _globalThis["effect/FiberCurrent"] === fiber,
+          id: globalThis.String(fiber.id),
+          isCurrent: _globalThis[CURRENT_FIBER_KEY] === fiber,
           currentSpan: null
           // TODO: capture current span
         }))
@@ -713,6 +833,7 @@ c.on("connect", () => {
       ensureFiberIsTracked,
       ensureTracerIsTracked,
       handleMessage,
+      installEffectModulePatch,
       sendInitNotification,
       sendPingNotification,
       instrumentationId

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inspeffct",
-  "version": "0.1.1",
+  "version": "1.0.1",
   "type": "module",
   "description": "A CLI to help agents and humans inspect Effect applications",
   "license": "MIT",
@@ -16,15 +16,11 @@
     "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@effect/cli": "^0.73.0",
-    "@effect/platform": "^0.94.1",
-    "@effect/platform-node": "^0.104.0",
-    "@effect/printer-ansi": "^0.44.14",
-    "@effect/sql": "^0.49.0",
-    "@effect/sql-sqlite-node": "^0.50.0",
-    "@effect/vitest": "^0.27.0",
+    "@effect/platform-node": "4.0.0-beta.70",
+    "@effect/sql-sqlite-node": "4.0.0-beta.70",
+    "@effect/vitest": "4.0.0-beta.70",
     "@types/ws": "^8.18.1",
-    "effect": "^3.19.14",
+    "effect": "4.0.0-beta.70",
     "tsup": "^8.5.1"
   },
   "scripts": {