effect-inspect 0.1.0

package/dist/client/Tracer.js

@@ -0,0 +1,119 @@
+/**
+ * The tracer and logger that observe the host program.
+ *
+ * Both delegate rather than replace: the tracer wraps whatever tracer is
+ * already installed and the logger is merged into the existing set, so adding
+ * the inspect layer never removes behaviour the program already had. Every
+ * method here is called on the host program's own fibers, so none of them may
+ * fail, suspend, or do real work — they narrow a value to the protocol's domain
+ * and hand it to a queue.
+ */
+import { Cause, Clock, Effect, Logger, References, Tracer } from 'effect';
+import { toAttributes, toJson, toOutcome } from './Edge.js';
+const parentOf = (span) => {
+    const parent = span.parent;
+    if (parent._tag === 'None')
+        return undefined;
+    const value = parent.value;
+    return value._tag === 'Span'
+        ? { _tag: 'LocalParent', spanId: value.spanId }
+        : {
+            _tag: 'ExternalParent',
+            spanId: value.spanId,
+            traceId: value.traceId,
+            sampled: value.sampled,
+        };
+};
+/**
+ * Creates a tracer that mirrors every span to the client while delegating to
+ * the current tracer.
+ *
+ * `SpanStart` is sent once when the span opens and `SpanEnd` when it closes,
+ * carrying the end time, the flattened outcome, and the span's attributes for
+ * the collector to merge. See `span` for why the attributes are not a strict
+ * delta.
+ */
+export const make = (client) => Effect.map(Effect.tracer, (currentTracer) => Tracer.make({
+    span(options) {
+        const span = currentTracer.span(options);
+        // `SpanStart` goes out immediately, so a live trace shows the span as
+        // soon as it opens. Its attributes are usually empty at this instant:
+        // Effect applies the ones passed to `Effect.withSpan` through
+        // `span.attribute` *after* this method returns, and it does so in the
+        // same synchronous burst as any later annotation, so there is no timing
+        // signal that separates "initial" from "late".
+        //
+        // Rather than guess, `SpanEnd` carries the span's whole attribute map.
+        // The protocol has the collector merge those over what it already has,
+        // and merging is idempotent, so a resent attribute costs a few bytes
+        // and changes nothing — which is the cheaper error than dropping an
+        // attribute the user set.
+        const parent = parentOf(span);
+        client.sendUnsafe({
+            _tag: 'SpanStart',
+            sessionId: client.sessionId,
+            spanId: span.spanId,
+            traceId: span.traceId,
+            ...(parent === undefined ? {} : { parent }),
+            name: span.name,
+            kind: span.kind,
+            startTime: options.startTime,
+            attributes: toAttributes(span.attributes),
+            sampled: span.sampled,
+        });
+        const inheritedEvent = span.event.bind(span);
+        span.event = (name, startTime, attributes) => {
+            client.sendUnsafe({
+                _tag: 'SpanEvent',
+                sessionId: client.sessionId,
+                spanId: span.spanId,
+                name,
+                time: startTime,
+                attributes: toAttributes(attributes ?? {}),
+            });
+            return inheritedEvent(name, startTime, attributes);
+        };
+        const inheritedEnd = span.end.bind(span);
+        span.end = (endTime, exit) => {
+            inheritedEnd(endTime, exit);
+            client.sendUnsafe({
+                _tag: 'SpanEnd',
+                sessionId: client.sessionId,
+                spanId: span.spanId,
+                endTime,
+                outcome: toOutcome(exit),
+                attributes: toAttributes(span.attributes),
+            });
+        };
+        return span;
+    },
+    context: currentTracer.context,
+}));
+/**
+ * Creates a logger that mirrors every log record to the client, correlated with
+ * the span the logging fiber is inside.
+ *
+ * Effect's own tracer logger turns logs into span events, which loses logs
+ * emitted outside any span. These are sent as `Log` instead, so they keep their
+ * level and appear in the stream whether or not a span was active.
+ */
+export const makeLogger = (client) => Logger.make(({ cause, fiber, logLevel, message }) => {
+    const span = fiber.cache.span;
+    const annotations = {
+        ...toAttributes(fiber.getRef(References.CurrentLogAnnotations)),
+    };
+    if (cause.reasons.length > 0)
+        annotations['effect.cause'] = Cause.pretty(cause);
+    client.sendUnsafe({
+        _tag: 'Log',
+        sessionId: client.sessionId,
+        // The fiber's own clock, so log times share the span time base rather
+        // than mixing in a wall clock the webapp would have to re-anchor.
+        time: fiber.getRef(Clock.Clock).currentTimeNanosUnsafe(),
+        level: logLevel,
+        message: toJson(Array.isArray(message) && message.length === 1 ? message[0] : message),
+        ...(span === undefined || span._tag === 'ExternalSpan' ? {} : { spanId: span.spanId }),
+        fiberId: fiber.id,
+        annotations,
+    });
+});

package/dist/collector/Config.d.ts

@@ -0,0 +1,8 @@
+import { Config } from 'effect';
+/** Port instrumented programs and the webapp both dial. */
+export declare const defaultPort = 34437;
+/** Shared settings for the standalone collector and the installed CLI. */
+export declare const collectorConfig: Config.Config<{
+    port: number;
+    capacity: number;
+}>;

package/dist/collector/Config.js

@@ -0,0 +1,9 @@
+import { Config } from 'effect';
+import { defaultCapacity } from './Store.js';
+/** Port instrumented programs and the webapp both dial. */
+export const defaultPort = 34437;
+/** Shared settings for the standalone collector and the installed CLI. */
+export const collectorConfig = Config.all({
+    port: Config.Port('EFFECT_INSPECT_PORT').pipe(Config.withDefault(defaultPort)),
+    capacity: Config.Int('EFFECT_INSPECT_CAPACITY').pipe(Config.withDefault(defaultCapacity)),
+});

package/dist/collector/Server.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The collector's WebSocket server.
+ *
+ * One `SocketServer` serves both sides on one port, routed by request path:
+ * `/webapp` is a webapp client, anything else is an instrumented program. The
+ * socket server forks and supervises each connection independently, so a
+ * program that crashes mid-message, or a webapp client that disappears, cannot
+ * take the collector down.
+ */
+import { Effect } from 'effect';
+import { HttpServer } from 'effect/unstable/http';
+import { Socket } from 'effect/unstable/socket';
+import { Store } from './Store.ts';
+/** Path a webapp client connects on; anything else is an instrumented program. */
+export declare const webappPath = "/webapp";
+/**
+ * Handles one accepted connection, routed by its request path.
+ *
+ * Scoped per connection: the writer and every fiber a handler forks are
+ * released when that one connection ends, and nothing outlives it.
+ */
+export declare const handleConnection: (socket: Socket.Socket, path: string) => Effect.Effect<void, never, Store>;
+/** Serves instrumented clients, webapp sockets, and the bundled web UI. */
+export declare const run: (fetch?: (request: Request) => Promise<Response>) => Effect.Effect<never, never, HttpServer.HttpServer | import("effect/Scope").Scope | Store>;

package/dist/collector/Server.js

@@ -0,0 +1,172 @@
+/**
+ * The collector's WebSocket server.
+ *
+ * One `SocketServer` serves both sides on one port, routed by request path:
+ * `/webapp` is a webapp client, anything else is an instrumented program. The
+ * socket server forks and supervises each connection independently, so a
+ * program that crashes mid-message, or a webapp client that disappears, cannot
+ * take the collector down.
+ */
+import { Effect, Fiber, PubSub, Result } from 'effect';
+import { HttpServer, HttpServerRequest, HttpServerResponse } from 'effect/unstable/http';
+import { Socket } from 'effect/unstable/socket';
+import { clientCodec, collectorCodec, webappCodec, webappRequestCodec } from '../protocol/Codec.js';
+import { Store } from './Store.js';
+/** Path a webapp client connects on; anything else is an instrumented program. */
+export const webappPath = '/webapp';
+/**
+ * Splits a stream of arbitrary chunks into `\n`-terminated lines.
+ *
+ * A WebSocket frame is usually exactly one line, but nothing guarantees it, so
+ * an unterminated remainder is carried across pulls.
+ */
+const lineSplitter = () => {
+    let rest = '';
+    return {
+        push: (chunk) => {
+            const parts = (rest + chunk).split('\n');
+            rest = parts.pop() ?? '';
+            return parts;
+        },
+        /** Trailing unterminated text, once the peer has stopped sending. */
+        flush: () => {
+            const last = rest;
+            rest = '';
+            return last;
+        },
+    };
+};
+/**
+ * Reads NDJSON lines off a socket, skipping any line that will not decode.
+ *
+ * This is the line-level recovery the codec deliberately does not do:
+ * `Codec.decodeAll` fails a whole chunk on one bad line, which would cost a
+ * session every message that shared a frame with it. Here a bad line is counted
+ * and dropped and the connection carries on — one malformed line must never
+ * drop a session or kill the collector.
+ *
+ * Returns when the peer disconnects. A socket error ends the loop the same way
+ * a clean close does: there is nothing left to read either way.
+ */
+const readLines = (pull, decode, onMessage, onSkipped) => Effect.suspend(() => {
+    const splitter = lineSplitter();
+    const handle = (line) => line.trim() === ''
+        ? Effect.void
+        : Result.match(decode(line), { onSuccess: onMessage, onFailure: () => onSkipped(line) });
+    return Effect.forever(Effect.flatMap(pull, (chunk) => Effect.forEach(chunk.flatMap(splitter.push), handle, { discard: true }))).pipe(Effect.catchTag('SocketError', () => Effect.void), Effect.ensuring(Effect.suspend(() => handle(splitter.flush()))));
+});
+/**
+ * Acquires a socket's line reader for the current scope.
+ *
+ * The reader must be acquired before anything writes: a `Socket` writer blocks
+ * until the reader has latched onto the underlying WebSocket, so a handler that
+ * sends first and reads later would deadlock.
+ */
+const readerFor = (socket) => Socket.readerString(socket).pipe(
+// An already-dead socket is a disconnect, not a collector error: hand back
+// a pull that reports the close so the read loop exits immediately.
+Effect.catchTag('SocketError', (error) => Effect.succeed(Effect.fail(error))));
+/** Handles one instrumented program's connection for its lifetime. */
+const handleClient = Effect.fnUntraced(function* (socket) {
+    const store = yield* Store;
+    const pull = yield* readerFor(socket);
+    const writer = yield* socket.writer;
+    /** The session this connection belongs to, learned from its `Hello`. */
+    let sessionId;
+    const onMessage = (message) => Effect.gen(function* () {
+        sessionId = message.sessionId;
+        switch (message._tag) {
+            case 'Hello':
+                yield* store.hello(message);
+                return;
+            case 'Ping':
+                // A failed write means the client is gone; the read loop notices.
+                yield* Effect.ignore(writer.write(collectorCodec.encode({ _tag: 'Pong', sessionId: message.sessionId })));
+                return;
+            default:
+                yield* store.append(message);
+        }
+    });
+    yield* readLines(pull, clientCodec.decode, onMessage, () => Effect.suspend(() => store.skipLine(sessionId))).pipe(
+    // However the connection ends — clean close, crash, kill -9 — the session
+    // is marked ended. A reconnect with the same id resumes it.
+    Effect.ensuring(Effect.suspend(() => (sessionId === undefined ? Effect.void : store.end(sessionId)))));
+});
+/** Handles one webapp client's connection for its lifetime. */
+const handleWebapp = Effect.fnUntraced(function* (socket) {
+    const store = yield* Store;
+    const pull = yield* readerFor(socket);
+    const writer = yield* socket.writer;
+    const send = (message) => Effect.ignore(writer.write(webappCodec.encode(message)));
+    const sendSessionList = Effect.flatMap(store.sessions, (sessions) => send({ _tag: 'SessionList', sessions }));
+    /** One live-tail fiber per subscribed session, so `Unsubscribe` interrupts. */
+    const tails = new Map();
+    const unsubscribe = (sessionId) => Effect.suspend(() => {
+        const fiber = tails.get(sessionId);
+        if (fiber === undefined)
+            return Effect.void;
+        tails.delete(sessionId);
+        return Effect.asVoid(Fiber.interrupt(fiber));
+    });
+    const subscribe = (sessionId) => Effect.gen(function* () {
+        if (tails.has(sessionId))
+            return;
+        const fiber = yield* Effect.forkScoped(Effect.scoped(Effect.gen(function* () {
+            // Subscribe before snapshotting: an overlap is deduplicated by span
+            // id downstream, a gap is a span the webapp never sees.
+            const pubsub = yield* store.live(sessionId);
+            if (pubsub === undefined)
+                return;
+            const live = yield* PubSub.subscribe(pubsub);
+            const snapshot = yield* store.snapshot(sessionId);
+            yield* send({
+                _tag: 'Backlog',
+                sessionId,
+                messages: snapshot?.messages ?? [],
+                complete: true,
+            });
+            return yield* Effect.forever(Effect.flatMap(PubSub.take(live), (message) => send({ _tag: 'Live', message })));
+        })));
+        tails.set(sessionId, fiber);
+    });
+    yield* sendSessionList;
+    // Re-send the list whenever a session opens, resumes or ends.
+    yield* Effect.forkScoped(Effect.scoped(Effect.gen(function* () {
+        const subscription = yield* PubSub.subscribe(store.changes);
+        return yield* Effect.forever(Effect.flatMap(PubSub.take(subscription), () => sendSessionList));
+    })));
+    yield* readLines(pull, webappRequestCodec.decode, (request) => request._tag === 'Subscribe' ? subscribe(request.sessionId) : unsubscribe(request.sessionId), 
+    // A webapp sending garbage is a webapp bug: drop the line, keep the socket.
+    () => Effect.void);
+});
+/**
+ * Handles one accepted connection, routed by its request path.
+ *
+ * Scoped per connection: the writer and every fiber a handler forks are
+ * released when that one connection ends, and nothing outlives it.
+ */
+export const handleConnection = (socket, path) => Effect.scoped(path === webappPath ? handleWebapp(socket) : handleClient(socket));
+/** Serves instrumented clients, webapp sockets, and the bundled web UI. */
+export const run = (fetch) => Effect.gen(function* () {
+    const server = yield* HttpServer.HttpServer;
+    yield* server.serve(Effect.gen(function* () {
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        const path = new URL(request.url, 'http://localhost').pathname;
+        if (request.headers.upgrade?.toLowerCase() === 'websocket') {
+            const socket = yield* request.upgrade;
+            yield* handleConnection(socket, path);
+            return HttpServerResponse.empty();
+        }
+        if (fetch === undefined) {
+            return HttpServerResponse.text('effect-inspect collector: websocket only', {
+                status: 426,
+            });
+        }
+        const response = yield* Effect.promise(() => fetch(new Request(new URL(request.url, 'http://localhost').href, {
+            method: request.method,
+            headers: request.headers,
+        })));
+        return HttpServerResponse.fromWeb(response);
+    }));
+    return yield* Effect.never;
+});

package/dist/collector/Store.d.ts

@@ -0,0 +1,86 @@
+/**
+ * In-memory, bounded store of every session the collector has seen.
+ *
+ * Each session keeps its telemetry in a bounded ring (oldest dropped first,
+ * drops counted) plus a sliding `PubSub` that webapp clients subscribe to for
+ * the live tail. Nothing is persisted: M1 is live-only.
+ *
+ * Ingest never blocks on a consumer. The ring drops its oldest message when
+ * full and the live `PubSub` is sliding, so neither a long-running program nor
+ * a stalled webapp client can apply backpressure to the instrumented program.
+ */
+import { Context, Effect, Layer, PubSub } from 'effect';
+import * as Protocol from '../protocol/Schema.ts';
+/** Messages a single session retains before dropping its oldest. */
+export declare const defaultCapacity = 200000;
+/** A session's retained telemetry plus the counters describing what was lost. */
+export interface SessionSnapshot {
+    readonly session: Protocol.Session;
+    readonly messages: ReadonlyArray<Protocol.ClientMessage>;
+    /** Messages evicted by the capacity bound. */
+    readonly droppedMessages: number;
+    /** Lines received for this session that could not be decoded. */
+    readonly skippedLines: number;
+}
+declare const Store_base: Context.ServiceClass<Store, "effect-inspect/collector/Store", {
+    /** Opens a session, or resumes the existing one when a program reconnects. */
+    readonly hello: (message: Protocol.Hello) => Effect.Effect<void>;
+    /** Records one decoded message and fans it out to live subscribers. */
+    readonly append: (message: Protocol.ClientMessage) => Effect.Effect<void>;
+    /** Counts one line that could not be decoded. */
+    readonly skipLine: (sessionId: Protocol.SessionId | undefined) => Effect.Effect<void>;
+    /** Marks a session ended because its program disconnected. */
+    readonly end: (sessionId: Protocol.SessionId) => Effect.Effect<void>;
+    /** Every known session, in the order they first said `Hello`. */
+    readonly sessions: Effect.Effect<ReadonlyArray<Protocol.Session>>;
+    /** One session's retained messages and loss counters. */
+    readonly snapshot: (sessionId: Protocol.SessionId) => Effect.Effect<SessionSnapshot | undefined>;
+    /**
+     * A session's live-tail `PubSub`, or `undefined` when it is unknown.
+     *
+     * Subscribe to it before reading the snapshot: an overlapping message is
+     * deduplicated downstream by span id, a missed one is a hole in the trace.
+     */
+    readonly live: (sessionId: Protocol.SessionId) => Effect.Effect<PubSub.PubSub<Protocol.ClientMessage> | undefined>;
+    /** Published whenever the session list changes, so clients can re-send it. */
+    readonly changes: PubSub.PubSub<void>;
+}>;
+/**
+ * The collector's session store.
+ *
+ * @see {@link layer} for the live implementation and {@link make} to build one
+ * with a smaller capacity in tests.
+ */
+export declare class Store extends Store_base {
+}
+/** Builds a `Store`, retaining `capacity` messages per session. */
+export declare const make: (options?: {
+    readonly capacity?: number;
+} | undefined) => Effect.Effect<{
+    /** Opens a session, or resumes the existing one when a program reconnects. */
+    readonly hello: (message: Protocol.Hello) => Effect.Effect<void>;
+    /** Records one decoded message and fans it out to live subscribers. */
+    readonly append: (message: Protocol.ClientMessage) => Effect.Effect<void>;
+    /** Counts one line that could not be decoded. */
+    readonly skipLine: (sessionId: Protocol.SessionId | undefined) => Effect.Effect<void>;
+    /** Marks a session ended because its program disconnected. */
+    readonly end: (sessionId: Protocol.SessionId) => Effect.Effect<void>;
+    /** Every known session, in the order they first said `Hello`. */
+    readonly sessions: Effect.Effect<ReadonlyArray<Protocol.Session>>;
+    /** One session's retained messages and loss counters. */
+    readonly snapshot: (sessionId: Protocol.SessionId) => Effect.Effect<SessionSnapshot | undefined>;
+    /**
+     * A session's live-tail `PubSub`, or `undefined` when it is unknown.
+     *
+     * Subscribe to it before reading the snapshot: an overlapping message is
+     * deduplicated downstream by span id, a missed one is a hole in the trace.
+     */
+    readonly live: (sessionId: Protocol.SessionId) => Effect.Effect<PubSub.PubSub<Protocol.ClientMessage> | undefined>;
+    /** Published whenever the session list changes, so clients can re-send it. */
+    readonly changes: PubSub.PubSub<void>;
+}, never, never>;
+/** The live `Store`, retaining {@link defaultCapacity} messages per session. */
+export declare const layer: (options?: {
+    readonly capacity?: number;
+}) => Layer.Layer<Store>;
+export {};

package/dist/collector/Store.js

@@ -0,0 +1,119 @@
+/**
+ * In-memory, bounded store of every session the collector has seen.
+ *
+ * Each session keeps its telemetry in a bounded ring (oldest dropped first,
+ * drops counted) plus a sliding `PubSub` that webapp clients subscribe to for
+ * the live tail. Nothing is persisted: M1 is live-only.
+ *
+ * Ingest never blocks on a consumer. The ring drops its oldest message when
+ * full and the live `PubSub` is sliding, so neither a long-running program nor
+ * a stalled webapp client can apply backpressure to the instrumented program.
+ */
+import { Clock, Context, Effect, Layer, PubSub } from 'effect';
+import * as Protocol from '../protocol/Schema.js';
+/** Messages a single session retains before dropping its oldest. */
+export const defaultCapacity = 200_000;
+/** Live messages buffered per webapp subscriber before the oldest is dropped. */
+const liveBufferSize = 4096;
+/**
+ * The collector's session store.
+ *
+ * @see {@link layer} for the live implementation and {@link make} to build one
+ * with a smaller capacity in tests.
+ */
+export class Store extends Context.Service()('effect-inspect/collector/Store') {
+}
+/** Builds a `Store`, retaining `capacity` messages per session. */
+export const make = Effect.fnUntraced(function* (options) {
+    const capacity = options?.capacity ?? defaultCapacity;
+    const sessions = new Map();
+    const changes = yield* PubSub.sliding(1);
+    const notify = PubSub.publish(changes, undefined).pipe(Effect.asVoid);
+    const hello = (message) => Effect.gen(function* () {
+        const existing = sessions.get(message.sessionId);
+        if (existing !== undefined) {
+            // A reconnect resumes the session rather than starting a new one, so a
+            // program that is killed and restarted keeps one continuous trace.
+            existing.session = { ...existing.session, active: true };
+            delete existing.session.endedAtEpochMillis;
+            yield* notify;
+            return;
+        }
+        sessions.set(message.sessionId, {
+            session: {
+                sessionId: message.sessionId,
+                program: message.program,
+                pid: message.pid,
+                runtime: message.runtime,
+                clock: message.clock,
+                active: true,
+            },
+            ring: [],
+            head: 0,
+            droppedMessages: 0,
+            skippedLines: 0,
+            live: yield* PubSub.sliding(liveBufferSize),
+        });
+        yield* notify;
+    });
+    const append = (message) => Effect.suspend(() => {
+        const state = sessions.get(message.sessionId);
+        // A message for a session that never said Hello has nowhere to go. It is
+        // a client bug, not a reason to drop the connection.
+        if (state === undefined)
+            return Effect.void;
+        if (state.ring.length < capacity) {
+            state.ring.push(message);
+        }
+        else {
+            state.ring[state.head] = message;
+            state.head = (state.head + 1) % capacity;
+            state.droppedMessages += 1;
+        }
+        return PubSub.publish(state.live, message).pipe(Effect.asVoid);
+    });
+    // A line from a connection that never sent a usable `Hello` has no session
+    // to count it against, so it is skipped without a counter.
+    const skipLine = (sessionId) => Effect.sync(() => {
+        const state = sessionId === undefined ? undefined : sessions.get(sessionId);
+        if (state !== undefined)
+            state.skippedLines += 1;
+    });
+    const end = (sessionId) => Effect.flatMap(Clock.currentTimeMillis, (now) => {
+        const state = sessions.get(sessionId);
+        if (state === undefined || !state.session.active)
+            return Effect.void;
+        state.session = {
+            ...state.session,
+            active: false,
+            endedAtEpochMillis: now,
+        };
+        return notify;
+    });
+    const snapshot = (sessionId) => Effect.sync(() => {
+        const state = sessions.get(sessionId);
+        if (state === undefined)
+            return undefined;
+        return {
+            session: state.session,
+            messages: state.head === 0
+                ? state.ring.slice()
+                : state.ring.slice(state.head).concat(state.ring.slice(0, state.head)),
+            droppedMessages: state.droppedMessages,
+            skippedLines: state.skippedLines,
+        };
+    });
+    const live = (sessionId) => Effect.sync(() => sessions.get(sessionId)?.live);
+    return Store.of({
+        hello,
+        append,
+        skipLine,
+        end,
+        sessions: Effect.sync(() => Array.from(sessions.values(), (state) => state.session)),
+        snapshot,
+        live,
+        changes,
+    });
+});
+/** The live `Store`, retaining {@link defaultCapacity} messages per session. */
+export const layer = (options) => Layer.effect(Store)(make(options));

package/dist/collector/WebApp.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from 'effect';
+/** Serves the built TanStack Start app from paths relative to this package. */
+export declare const loadWebApp: Effect.Effect<(request: Request) => Promise<Response>, never, never>;

package/dist/collector/WebApp.js

@@ -0,0 +1,36 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { Effect } from 'effect';
+// Reading packaged assets is a Node runtime boundary; the app itself returns Web Responses.
+// oxlint-disable-next-line effecttsgo/node-builtin-import
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+/** Serves the built TanStack Start app from paths relative to this package. */
+export const loadWebApp = Effect.gen(function* () {
+    const serverEntry = new URL('../../app/dist/server/server.js', import.meta.url);
+    const clientRoot = new URL('../../app/dist/client/', import.meta.url);
+    const app = (yield* Effect.promise(() => import(__rewriteRelativeImportExtension(serverEntry.href))));
+    return (request) => {
+        const path = new URL(request.url).pathname;
+        if (path.startsWith('/assets/')) {
+            const name = path.slice('/assets/'.length);
+            if (!/^[\w.-]+$/.test(name))
+                return Promise.resolve(new Response('Not found', { status: 404 }));
+            const file = fileURLToPath(new URL(`assets/${name}`, clientRoot));
+            return readFile(file).then((bytes) => new Response(bytes, {
+                headers: { 'content-type': name.endsWith('.css') ? 'text/css' : 'text/javascript' },
+            }), (error) => {
+                if (error.code === 'ENOENT')
+                    return new Response('Not found', { status: 404 });
+                throw error;
+            });
+        }
+        return app.default.fetch(request);
+    };
+});

package/dist/collector/main.d.ts

@@ -0,0 +1 @@
+export { defaultPort } from './Config.ts';

package/dist/collector/main.js

@@ -0,0 +1,22 @@
+/**
+ * Collector entry point — `bun run collector`.
+ *
+ * Long-lived: it outlives the programs it collects from, so an instrumented
+ * program can be killed and restarted without losing its trace.
+ */
+import { Effect, Layer } from 'effect';
+import * as NodeHttpServer from '@effect/platform-node/NodeHttpServer';
+import * as NodeRuntime from '@effect/platform-node/NodeRuntime';
+// NodeHttpServer needs a native server constructor to own the HTTP and upgrade listeners.
+// oxlint-disable-next-line effecttsgo/node-builtin-import
+import { createServer } from 'node:http';
+import { run } from './Server.js';
+import { layer as storeLayer } from './Store.js';
+import { collectorConfig } from './Config.js';
+export { defaultPort } from './Config.js';
+const main = Effect.gen(function* () {
+    const { capacity, port } = yield* collectorConfig;
+    yield* Effect.logInfo(`effect-inspect collector listening on ws://localhost:${port}`);
+    return yield* Effect.provide(run(), Layer.mergeAll(storeLayer({ capacity }), NodeHttpServer.layer(createServer, { port })));
+});
+NodeRuntime.runMain(Effect.scoped(main));

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * as Codec from './protocol/Codec.ts';
+export * as Inspect from './client/Inspect.ts';
+export * as Protocol from './protocol/Schema.ts';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * as Codec from './protocol/Codec.js';
+export * as Inspect from './client/Inspect.js';
+export * as Protocol from './protocol/Schema.js';