@m4trix/core 0.15.0 → 0.15.2

package/dist/matrix/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var effect = require('effect');
 var crypto$1 = require('crypto');
+var effect = require('effect');
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -21,56 +21,114 @@ var __privateSet = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-var ChannelName = effect.Brand.refined(
-  (s) => typeof s === "string" && KEBAB_CASE_REGEX.test(s),
-  (s) => effect.Brand.error(`Expected kebab-case (e.g. my-channel-name), got: ${s}`)
-);
-
-// src/matrix/agent-network/channel.ts
-var Sink = {
-  kafka(config) {
-    return { _tag: "SinkDef", type: "kafka", config };
-  },
-  httpStream() {
-    return { _tag: "SinkDef", type: "http-stream", config: {} };
+var _params, _logic, _id, _listensTo;
+var Agent = class {
+  constructor(logic, params, listensTo) {
+    __privateAdd(this, _params, void 0);
+    __privateAdd(this, _logic, void 0);
+    __privateAdd(this, _id, void 0);
+    __privateAdd(this, _listensTo, void 0);
+    __privateSet(this, _logic, logic);
+    __privateSet(this, _params, params);
+    __privateSet(this, _id, `agent-${crypto$1.randomUUID()}`);
+    __privateSet(this, _listensTo, listensTo ?? []);
+  }
+  getListensTo() {
+    return __privateGet(this, _listensTo);
+  }
+  async invoke(options) {
+    const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
+    const emitFn = emit ?? ((_event) => {
+    });
+    await __privateGet(this, _logic).call(this, {
+      params: __privateGet(this, _params),
+      triggerEvent: triggerEvent ?? void 0,
+      emit: emitFn,
+      runEvents: runEvents ?? [],
+      contextEvents: contextEvents ?? {
+        all: [],
+        byRun: () => [],
+        map: /* @__PURE__ */ new Map()
+      }
+    });
+  }
+  getId() {
+    return __privateGet(this, _id);
   }
 };
-function isHttpStreamSink(sink) {
-  return sink.type === "http-stream";
-}
-var ConfiguredChannel = class {
-  constructor(name) {
-    this._tag = "ConfiguredChannel";
-    this._events = [];
-    this._sinks = [];
-    this.name = name;
+_params = new WeakMap();
+_logic = new WeakMap();
+_id = new WeakMap();
+_listensTo = new WeakMap();
+
+// src/matrix/agent-factory.ts
+var AgentFactory = class _AgentFactory {
+  constructor({
+    logic,
+    paramsSchema,
+    listensTo = [],
+    emits = []
+  }) {
+    this._logic = logic;
+    this._paramsSchema = paramsSchema;
+    this._listensTo = listensTo;
+    this._emits = emits;
   }
-  events(events) {
-    this._events = [...events];
-    return this;
+  getConstructorState() {
+    return {
+      logic: this._logic,
+      paramsSchema: this._paramsSchema,
+      listensTo: this._listensTo,
+      emits: this._emits
+    };
   }
-  sink(sink) {
-    this._sinks = [...this._sinks, sink];
-    return this;
+  /** Union of all event definitions this agent listens to */
+  getListensTo() {
+    return this._listensTo;
   }
-  sinks(sinks) {
-    this._sinks = [...sinks];
-    return this;
+  /** Union of all event definitions this agent can emit */
+  getEmits() {
+    return this._emits;
   }
-  getEvents() {
-    return this._events;
+  getLogic() {
+    return this._logic;
   }
-  getSinks() {
-    return this._sinks;
+  static run() {
+    return new _AgentFactory({});
   }
-};
-var Channel = {
-  of(name) {
-    return {
-      _tag: "ChannelDef",
-      name
-    };
+  params(params) {
+    const { logic, ...rest } = this.getConstructorState();
+    return new _AgentFactory({
+      ...rest,
+      logic,
+      paramsSchema: params
+    });
+  }
+  listensTo(events) {
+    return new _AgentFactory({
+      ...this.getConstructorState(),
+      listensTo: [...this._listensTo, ...events]
+    });
+  }
+  emits(events) {
+    return new _AgentFactory({
+      ...this.getConstructorState(),
+      emits: [...this._emits, ...events]
+    });
+  }
+  logic(fn) {
+    return new _AgentFactory({
+      ...this.getConstructorState(),
+      logic: fn
+    });
+  }
+  produce(params) {
+    const listensTo = this._listensTo.map((e) => e.name);
+    return new Agent(
+      this._logic,
+      params,
+      listensTo
+    );
   }
 };
 
@@ -226,10 +284,7 @@ var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue, channelName)
     if (listensTo.length > 0 && !listensTo.includes(envelope.name)) {
       return;
     }
-    const runEvents = plane.getRunEvents(
-      envelope.meta.runId,
-      envelope.meta.contextId
-    );
+    const runEvents = plane.getRunEvents(envelope.meta.runId, envelope.meta.contextId);
     const contextEvents = plane.getContextEvents(envelope.meta.contextId);
     yield* effect.Effect.withSpan("agent.listen", {
       attributes: {
@@ -264,9 +319,7 @@ var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue, channelName)
                 ).catch(() => {
                 });
               } else {
-                effect.Effect.runFork(
-                  plane.publishToChannels(publishesTo, fullEnvelope)
-                );
+                effect.Effect.runFork(plane.publishToChannels(publishesTo, fullEnvelope));
               }
             },
             runEvents,
@@ -292,18 +345,65 @@ var run = (network, plane, options) => effect.Effect.gen(function* () {
   for (const reg of registrations.values()) {
     for (const channel of reg.subscribedTo) {
       const dequeue = yield* plane.subscribe(channel.name);
-      yield* runSubscriber(
-        reg.agent,
-        reg.publishesTo,
-        dequeue,
-        plane,
-        emitQueue,
-        channel.name
-      );
+      yield* runSubscriber(reg.agent, reg.publishesTo, dequeue, plane, emitQueue, channel.name);
     }
   }
   yield* effect.Effect.never;
 });
+var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var ChannelName = effect.Brand.refined(
+  (s) => typeof s === "string" && KEBAB_CASE_REGEX.test(s),
+  (s) => effect.Brand.error(`Expected kebab-case (e.g. my-channel-name), got: ${s}`)
+);
+
+// src/matrix/agent-network/channel.ts
+var Sink = {
+  kafka(config) {
+    return { _tag: "SinkDef", type: "kafka", config };
+  },
+  httpStream() {
+    return { _tag: "SinkDef", type: "http-stream", config: {} };
+  }
+};
+function isHttpStreamSink(sink) {
+  return sink.type === "http-stream";
+}
+var ConfiguredChannel = class {
+  constructor(name) {
+    this._tag = "ConfiguredChannel";
+    this._events = [];
+    this._sinks = [];
+    this.name = name;
+  }
+  events(events) {
+    this._events = [...events];
+    return this;
+  }
+  sink(sink) {
+    this._sinks = [...this._sinks, sink];
+    return this;
+  }
+  sinks(sinks) {
+    this._sinks = [...sinks];
+    return this;
+  }
+  getEvents() {
+    return this._events;
+  }
+  getSinks() {
+    return this._sinks;
+  }
+};
+var Channel = {
+  of(name) {
+    return {
+      _tag: "ChannelDef",
+      name
+    };
+  }
+};
+
+// src/matrix/io/expose.ts
 async function extractPayload(req) {
   const webRequest = req.request;
   if (webRequest?.method === "POST") {
@@ -367,14 +467,7 @@ function streamFromDequeue(take, signal, eventFilter) {
   };
 }
 function expose(network, options) {
-  const {
-    auth,
-    select,
-    plane: providedPlane,
-    onRequest,
-    triggerEvents,
-    tracingLayer
-  } = options;
+  const { auth, select, plane: providedPlane, onRequest, triggerEvents, tracingLayer } = options;
   const triggerEventDef = triggerEvents?.[0];
   const triggerEventName = triggerEventDef?.name ?? "request";
   const channels = resolveChannels(network, select);
@@ -421,10 +514,8 @@ function expose(network, options) {
           meta,
           payload: opts.event.payload
         };
-        effect.Effect.runPromise(plane.publish(targetChannel, envelope)).catch(
-          () => {
-          }
-        );
+        effect.Effect.runPromise(plane.publish(targetChannel, envelope)).catch(() => {
+        });
       };
       const dequeue = yield* plane.subscribe(channels[0]);
       if (onRequest) {
@@ -464,10 +555,7 @@ function expose(network, options) {
       if (auth) {
         const result = await auth(req);
         if (!result.allowed) {
-          throw new ExposeAuthError(
-            result.message ?? "Unauthorized",
-            result.status ?? 401
-          );
+          throw new ExposeAuthError(result.message ?? "Unauthorized", result.status ?? 401);
         }
       }
       return consumer ? createStream(req, consumer) : createStream(req);
@@ -644,7 +732,9 @@ var AgentNetworkEvent = {
     const makeBound = (meta, payload2) => effect.Effect.runSync(
       decodeEnvelope({ name, meta, payload: payload2 })
     );
-    const makeEffect = (payload2) => decodePayload(payload2).pipe(effect.Effect.map((p) => ({ name, payload: p })));
+    const makeEffect = (payload2) => decodePayload(payload2).pipe(
+      effect.Effect.map((p) => ({ name, payload: p }))
+    );
     const makeBoundEffect = (meta, payload2) => decodeEnvelope({ name, meta, payload: payload2 });
     const is = effect.Schema.is(envelopeSchema);
     return {
@@ -696,27 +786,27 @@ var EventAggregator = class _EventAggregator {
     });
   }
 };
-var _id, _listensTo, _emitWhen, _mapToEmit;
+var _id2, _listensTo2, _emitWhen, _mapToEmit;
 var EventAggregatorInstance = class {
   constructor({
     listensTo,
     emitWhen,
     mapToEmit
   }) {
-    __privateAdd(this, _id, void 0);
-    __privateAdd(this, _listensTo, void 0);
+    __privateAdd(this, _id2, void 0);
+    __privateAdd(this, _listensTo2, void 0);
     __privateAdd(this, _emitWhen, void 0);
     __privateAdd(this, _mapToEmit, void 0);
-    __privateSet(this, _id, `event-aggregator-${crypto$1.randomUUID()}`);
-    __privateSet(this, _listensTo, listensTo);
+    __privateSet(this, _id2, `event-aggregator-${crypto$1.randomUUID()}`);
+    __privateSet(this, _listensTo2, listensTo);
     __privateSet(this, _emitWhen, emitWhen);
     __privateSet(this, _mapToEmit, mapToEmit);
   }
   getId() {
-    return __privateGet(this, _id);
+    return __privateGet(this, _id2);
   }
   getListensTo() {
-    return __privateGet(this, _listensTo);
+    return __privateGet(this, _listensTo2);
   }
   async invoke(options) {
     const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
@@ -747,118 +837,205 @@ var EventAggregatorInstance = class {
     });
   }
 };
-_id = new WeakMap();
-_listensTo = new WeakMap();
+_id2 = new WeakMap();
+_listensTo2 = new WeakMap();
 _emitWhen = new WeakMap();
 _mapToEmit = new WeakMap();
-var _params, _logic, _id2, _listensTo2;
-var Agent = class {
-  constructor(logic, params, listensTo) {
-    __privateAdd(this, _params, void 0);
-    __privateAdd(this, _logic, void 0);
-    __privateAdd(this, _id2, void 0);
-    __privateAdd(this, _listensTo2, void 0);
-    __privateSet(this, _logic, logic);
-    __privateSet(this, _params, params);
-    __privateSet(this, _id2, `agent-${crypto$1.randomUUID()}`);
-    __privateSet(this, _listensTo2, listensTo ?? []);
-  }
-  getListensTo() {
-    return __privateGet(this, _listensTo2);
-  }
-  async invoke(options) {
-    const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
-    const emitFn = emit ?? ((_event) => {
-    });
-    await __privateGet(this, _logic).call(this, {
-      params: __privateGet(this, _params),
-      triggerEvent: triggerEvent ?? void 0,
-      emit: emitFn,
-      runEvents: runEvents ?? [],
-      contextEvents: contextEvents ?? {
-        all: [],
-        byRun: () => [],
-        map: /* @__PURE__ */ new Map()
-      }
-    });
-  }
-  getId() {
-    return __privateGet(this, _id2);
+var randomHexString = (length) => {
+  const chars = "abcdef0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
   }
+  return result;
 };
-_params = new WeakMap();
-_logic = new WeakMap();
-_id2 = new WeakMap();
-_listensTo2 = new WeakMap();
-
-// src/matrix/agent-factory.ts
-var AgentFactory = class _AgentFactory {
-  constructor({
-    logic,
-    paramsSchema,
-    listensTo = [],
-    emits = []
-  }) {
-    this._logic = logic;
-    this._paramsSchema = paramsSchema;
-    this._listensTo = listensTo;
-    this._emits = emits;
-  }
-  getConstructorState() {
-    return {
-      logic: this._logic,
-      paramsSchema: this._paramsSchema,
-      listensTo: this._listensTo,
-      emits: this._emits
-    };
-  }
-  /** Union of all event definitions this agent listens to */
-  getListensTo() {
-    return this._listensTo;
-  }
-  /** Union of all event definitions this agent can emit */
-  getEmits() {
-    return this._emits;
-  }
-  getLogic() {
-    return this._logic;
+var ConsoleSpan = class {
+  constructor(name, parent, context, links, startTime, kind, depth) {
+    this.name = name;
+    this.parent = parent;
+    this.context = context;
+    this.startTime = startTime;
+    this.kind = kind;
+    this.depth = depth;
+    this._tag = "Span";
+    this.sampled = true;
+    this.attributes = /* @__PURE__ */ new Map();
+    this.links = [];
+    this.traceId = parent._tag === "Some" ? parent.value.traceId : randomHexString(32);
+    this.spanId = randomHexString(16);
+    this.links = Array.from(links);
+    this.status = { _tag: "Started", startTime };
   }
-  static run() {
-    return new _AgentFactory({});
+  end(endTime, exit) {
+    if (this.status._tag === "Ended")
+      return;
+    const startTime = this.status.startTime;
+    const durationNs = endTime - startTime;
+    const durationMs = Number(durationNs) / 1e6;
+    const indent = "  ".repeat(this.depth);
+    const attrs = Object.fromEntries(this.attributes);
+    const status = effect.Exit.isSuccess(exit) ? "ok" : "error";
+    console.log(
+      `${indent}[trace] ${this.name} ${durationMs.toFixed(2)}ms (${status})`,
+      Object.keys(attrs).length > 0 ? attrs : ""
+    );
+    this.status = { _tag: "Ended", startTime, endTime, exit };
   }
-  params(params) {
-    const { logic, ...rest } = this.getConstructorState();
-    return new _AgentFactory({
-      ...rest,
-      logic,
-      paramsSchema: params
-    });
+  attribute(key, value) {
+    this.attributes.set(key, value);
   }
-  listensTo(events) {
-    return new _AgentFactory({
-      ...this.getConstructorState(),
-      listensTo: [...this._listensTo, ...events]
-    });
+  event(_name, _startTime, _attributes) {
   }
-  emits(events) {
-    return new _AgentFactory({
-      ...this.getConstructorState(),
-      emits: [...this._emits, ...events]
-    });
+  addLinks(links) {
+    this.links.push(...links);
   }
-  logic(fn) {
-    return new _AgentFactory({
-      ...this.getConstructorState(),
-      logic: fn
-    });
+};
+function getDepth(parent) {
+  if (parent._tag === "None")
+    return 0;
+  const p = parent.value;
+  if (p._tag === "ExternalSpan")
+    return 0;
+  return 1 + getDepth(p.parent);
+}
+var consoleTracer = effect.Tracer.make({
+  span: (name, parent, context, links, startTime, kind) => new ConsoleSpan(name, parent, context, links, startTime, kind, getDepth(parent)),
+  context: (f) => f()
+});
+var consoleTracerLayer = effect.Layer.setTracer(consoleTracer);
+
+// src/matrix/io/protocols/sse.ts
+function formatSSE(envelope) {
+  const data = JSON.stringify(envelope);
+  return `event: ${envelope.name}
+data: ${data}
+
+`;
+}
+function toSSEStream(source, signal) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      const onAbort = () => controller.close();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        for await (const envelope of source) {
+          if (signal?.aborted)
+            break;
+          controller.enqueue(encoder.encode(formatSSE(envelope)));
+        }
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+        controller.close();
+      }
+    }
+  });
+}
+
+// src/matrix/io/adapters/next-endpoint.ts
+var NextEndpoint = {
+  from(api, options) {
+    if (api.protocol !== "sse") {
+      throw new Error(`NextEndpoint: unsupported protocol "${api.protocol}"`);
+    }
+    const { requestToContextId, requestToRunId } = options;
+    return {
+      handler() {
+        return async (request) => {
+          const req = {
+            request,
+            contextId: requestToContextId(request),
+            runId: requestToRunId(request)
+          };
+          try {
+            const encoder = new TextEncoder();
+            const { readable, writable } = new TransformStream();
+            let consumerStarted;
+            const started = new Promise((resolve) => {
+              consumerStarted = resolve;
+            });
+            const streamDone = api.createStream(req, async (stream) => {
+              consumerStarted();
+              const writer = writable.getWriter();
+              try {
+                for await (const envelope of stream) {
+                  if (request.signal?.aborted)
+                    break;
+                  await writer.write(encoder.encode(formatSSE(envelope)));
+                }
+              } finally {
+                await writer.close();
+              }
+            });
+            await Promise.race([started, streamDone]);
+            streamDone.catch(() => {
+            });
+            return new Response(readable, {
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive"
+              }
+            });
+          } catch (e) {
+            if (e instanceof ExposeAuthError) {
+              return new Response(e.message, { status: e.status });
+            }
+            throw e;
+          }
+        };
+      }
+    };
   }
-  produce(params) {
-    const listensTo = this._listensTo.map((e) => e.name);
-    return new Agent(
-      this._logic,
-      params,
-      listensTo
-    );
+};
+
+// src/matrix/io/adapters/express-endpoint.ts
+var ExpressEndpoint = {
+  from(api, options) {
+    if (api.protocol !== "sse") {
+      throw new Error(`ExpressEndpoint: unsupported protocol "${api.protocol}"`);
+    }
+    const { requestToContextId, requestToRunId } = options;
+    return {
+      handler() {
+        return async (req, res) => {
+          const controller = new AbortController();
+          req.on("close", () => controller.abort());
+          const exposeReq = {
+            request: { signal: controller.signal },
+            req,
+            res,
+            contextId: requestToContextId(req),
+            runId: requestToRunId(req)
+          };
+          try {
+            const encoder = new TextEncoder();
+            await api.createStream(exposeReq, async (stream) => {
+              res.setHeader("Content-Type", "text/event-stream");
+              res.setHeader("Cache-Control", "no-cache");
+              res.setHeader("Connection", "keep-alive");
+              res.flushHeaders?.();
+              try {
+                for await (const envelope of stream) {
+                  if (controller.signal.aborted)
+                    break;
+                  res.write(encoder.encode(formatSSE(envelope)));
+                  res.flush?.();
+                }
+              } finally {
+                res.end();
+              }
+            });
+          } catch (e) {
+            if (e instanceof ExposeAuthError) {
+              res.status(e.status).send(e.message);
+              return;
+            }
+            throw e;
+          }
+        };
+      }
+    };
   }
 };
 var CAMEL_CASE_REGEX = /^[a-z][a-zA-Z0-9]*$/;
@@ -974,9 +1151,7 @@ var Skill = class _Skill {
       const layersObj = runtime?.layers ?? {};
       const chunks = [];
       const emit = (chunk) => {
-        const decoded = effect.Effect.runSync(
-          decodeChunk(chunk)
-        );
+        const decoded = effect.Effect.runSync(decodeChunk(chunk));
         chunks.push(decoded);
       };
       const done = await defineFn({
@@ -984,9 +1159,7 @@ var Skill = class _Skill {
         emit,
         layers: layersObj
       });
-      const decodedDone = effect.Effect.runSync(
-        decodeDone(done)
-      );
+      const decodedDone = effect.Effect.runSync(decodeDone(done));
       return { chunks, done: decodedDone };
     };
     return {
@@ -997,9 +1170,7 @@ var Skill = class _Skill {
         const layersObj = runtime?.layers ?? {};
         const chunks = [];
         const emit = (chunk) => {
-          const decoded = effect.Effect.runSync(
-            decodeChunk(chunk)
-          );
+          const decoded = effect.Effect.runSync(decodeChunk(chunk));
           chunks.push(decoded);
         };
         const done = await defineFn({
@@ -1007,9 +1178,7 @@ var Skill = class _Skill {
           emit,
           layers: layersObj
         });
-        const decodedDone = effect.Effect.runSync(
-          decodeDone(done)
-        );
+        const decodedDone = effect.Effect.runSync(decodeDone(done));
         for (const c of chunks) {
           yield c;
         }
@@ -1025,215 +1194,6 @@ var Skill = class _Skill {
   }
 };
 
-// src/matrix/io/protocols/sse.ts
-function formatSSE(envelope) {
-  const data = JSON.stringify(envelope);
-  return `event: ${envelope.name}
-data: ${data}
-
-`;
-}
-function toSSEStream(source, signal) {
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    async start(controller) {
-      const onAbort = () => controller.close();
-      signal?.addEventListener("abort", onAbort, { once: true });
-      try {
-        for await (const envelope of source) {
-          if (signal?.aborted)
-            break;
-          controller.enqueue(encoder.encode(formatSSE(envelope)));
-        }
-      } finally {
-        signal?.removeEventListener("abort", onAbort);
-        controller.close();
-      }
-    }
-  });
-}
-
-// src/matrix/io/adapters/next-endpoint.ts
-var NextEndpoint = {
-  from(api, options) {
-    if (api.protocol !== "sse") {
-      throw new Error(`NextEndpoint: unsupported protocol "${api.protocol}"`);
-    }
-    const { requestToContextId, requestToRunId } = options;
-    return {
-      handler() {
-        return async (request) => {
-          const req = {
-            request,
-            contextId: requestToContextId(request),
-            runId: requestToRunId(request)
-          };
-          try {
-            const encoder = new TextEncoder();
-            const { readable, writable } = new TransformStream();
-            let consumerStarted;
-            const started = new Promise((resolve) => {
-              consumerStarted = resolve;
-            });
-            const streamDone = api.createStream(req, async (stream) => {
-              consumerStarted();
-              const writer = writable.getWriter();
-              try {
-                for await (const envelope of stream) {
-                  if (request.signal?.aborted)
-                    break;
-                  await writer.write(encoder.encode(formatSSE(envelope)));
-                }
-              } finally {
-                await writer.close();
-              }
-            });
-            await Promise.race([started, streamDone]);
-            streamDone.catch(() => {
-            });
-            return new Response(readable, {
-              headers: {
-                "Content-Type": "text/event-stream",
-                "Cache-Control": "no-cache",
-                Connection: "keep-alive"
-              }
-            });
-          } catch (e) {
-            if (e instanceof ExposeAuthError) {
-              return new Response(e.message, { status: e.status });
-            }
-            throw e;
-          }
-        };
-      }
-    };
-  }
-};
-
-// src/matrix/io/adapters/express-endpoint.ts
-var ExpressEndpoint = {
-  from(api, options) {
-    if (api.protocol !== "sse") {
-      throw new Error(
-        `ExpressEndpoint: unsupported protocol "${api.protocol}"`
-      );
-    }
-    const { requestToContextId, requestToRunId } = options;
-    return {
-      handler() {
-        return async (req, res) => {
-          const controller = new AbortController();
-          req.on("close", () => controller.abort());
-          const exposeReq = {
-            request: { signal: controller.signal },
-            req,
-            res,
-            contextId: requestToContextId(req),
-            runId: requestToRunId(req)
-          };
-          try {
-            const encoder = new TextEncoder();
-            await api.createStream(exposeReq, async (stream) => {
-              res.setHeader("Content-Type", "text/event-stream");
-              res.setHeader("Cache-Control", "no-cache");
-              res.setHeader("Connection", "keep-alive");
-              res.flushHeaders?.();
-              try {
-                for await (const envelope of stream) {
-                  if (controller.signal.aborted)
-                    break;
-                  res.write(encoder.encode(formatSSE(envelope)));
-                  res.flush?.();
-                }
-              } finally {
-                res.end();
-              }
-            });
-          } catch (e) {
-            if (e instanceof ExposeAuthError) {
-              res.status(e.status).send(e.message);
-              return;
-            }
-            throw e;
-          }
-        };
-      }
-    };
-  }
-};
-var randomHexString = (length) => {
-  const chars = "abcdef0123456789";
-  let result = "";
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-};
-var ConsoleSpan = class {
-  constructor(name, parent, context, links, startTime, kind, depth) {
-    this.name = name;
-    this.parent = parent;
-    this.context = context;
-    this.startTime = startTime;
-    this.kind = kind;
-    this.depth = depth;
-    this._tag = "Span";
-    this.sampled = true;
-    this.attributes = /* @__PURE__ */ new Map();
-    this.links = [];
-    this.traceId = parent._tag === "Some" ? parent.value.traceId : randomHexString(32);
-    this.spanId = randomHexString(16);
-    this.links = Array.from(links);
-    this.status = { _tag: "Started", startTime };
-  }
-  end(endTime, exit) {
-    if (this.status._tag === "Ended")
-      return;
-    const startTime = this.status.startTime;
-    const durationNs = endTime - startTime;
-    const durationMs = Number(durationNs) / 1e6;
-    const indent = "  ".repeat(this.depth);
-    const attrs = Object.fromEntries(this.attributes);
-    const status = effect.Exit.isSuccess(exit) ? "ok" : "error";
-    console.log(
-      `${indent}[trace] ${this.name} ${durationMs.toFixed(2)}ms (${status})`,
-      Object.keys(attrs).length > 0 ? attrs : ""
-    );
-    this.status = { _tag: "Ended", startTime, endTime, exit };
-  }
-  attribute(key, value) {
-    this.attributes.set(key, value);
-  }
-  event(_name, _startTime, _attributes) {
-  }
-  addLinks(links) {
-    this.links.push(...links);
-  }
-};
-function getDepth(parent) {
-  if (parent._tag === "None")
-    return 0;
-  const p = parent.value;
-  if (p._tag === "ExternalSpan")
-    return 0;
-  return 1 + getDepth(p.parent);
-}
-var consoleTracer = effect.Tracer.make({
-  span: (name, parent, context, links, startTime, kind) => new ConsoleSpan(
-    name,
-    parent,
-    context,
-    links,
-    startTime,
-    kind,
-    getDepth(parent)
-  ),
-  context: (f) => f()
-});
-var consoleTracerLayer = effect.Layer.setTracer(
-  consoleTracer
-);
-
 Object.defineProperty(exports, 'S', {
   enumerable: true,
   get: function () { return effect.Schema; }