@m4trix/core 0.5.0 → 0.6.0

package/dist/matrix/index.js

@@ -0,0 +1,705 @@
+import { Brand, Schema, Effect, PubSub, Queue, Cause } from 'effect';
+export { Schema as S } from 'effect';
+import { randomUUID } from 'crypto';
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var ChannelName = Brand.refined(
+  (s) => typeof s === "string" && KEBAB_CASE_REGEX.test(s),
+  (s) => 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
+    };
+  }
+};
+var DEFAULT_CAPACITY = 16;
+var createEventPlane = (network, capacity = DEFAULT_CAPACITY) => Effect.gen(function* () {
+  const channels = network.getChannels();
+  const pubsubs = /* @__PURE__ */ new Map();
+  for (const channel of channels.values()) {
+    const pubsub = yield* PubSub.bounded(capacity);
+    pubsubs.set(channel.name, pubsub);
+  }
+  const getPubsub = (channel) => {
+    const p = pubsubs.get(channel);
+    if (!p)
+      throw new Error(`Channel not found: ${channel}`);
+    return p;
+  };
+  const publish = (channel, envelope) => PubSub.publish(getPubsub(channel), envelope);
+  const publishToChannels = (targetChannels, envelope) => Effect.all(
+    targetChannels.map((c) => publish(c.name, envelope)),
+    { concurrency: "unbounded" }
+  ).pipe(Effect.map((results) => results.every(Boolean)));
+  const subscribe = (channel) => PubSub.subscribe(getPubsub(channel));
+  const shutdown = Effect.all([...pubsubs.values()].map(PubSub.shutdown), {
+    concurrency: "unbounded"
+  }).pipe(Effect.asVoid);
+  return {
+    publish,
+    publishToChannels,
+    subscribe,
+    shutdown
+  };
+});
+var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue) => Effect.gen(function* () {
+  const listensTo = agent.getListensTo?.() ?? [];
+  const processOne = () => Effect.gen(function* () {
+    const envelope = yield* Queue.take(dequeue);
+    if (listensTo.length > 0 && !listensTo.includes(envelope.name)) {
+      return;
+    }
+    yield* Effect.tryPromise({
+      try: () => agent.invoke({
+        triggerEvent: envelope,
+        emit: (userEvent) => {
+          const fullEnvelope = {
+            name: userEvent.name,
+            meta: envelope.meta,
+            payload: userEvent.payload
+          };
+          if (emitQueue) {
+            Effect.runPromise(
+              Queue.offer(emitQueue, {
+                channels: publishesTo,
+                envelope: fullEnvelope
+              })
+            ).catch(() => {
+            });
+          } else {
+            Effect.runFork(
+              plane.publishToChannels(publishesTo, fullEnvelope)
+            );
+          }
+        }
+      }),
+      catch: (e) => e
+    });
+  }).pipe(
+    Effect.catchAllCause(
+      (cause) => Cause.isInterrupted(cause) ? Effect.void : Effect.sync(() => {
+        console.error(`Agent ${agent.getId()} failed:`, cause);
+      }).pipe(Effect.asVoid)
+    )
+  );
+  const loop = () => processOne().pipe(Effect.flatMap(() => loop()));
+  return yield* Effect.fork(loop());
+});
+var run = (network, plane, options) => Effect.gen(function* () {
+  const registrations = network.getAgentRegistrations();
+  const emitQueue = options?.emitQueue;
+  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
+      );
+    }
+  }
+  yield* Effect.never;
+});
+async function extractPayload(req) {
+  const webRequest = req.request;
+  if (webRequest?.method === "POST") {
+    const ct = webRequest.headers?.get?.("content-type") ?? "";
+    if (ct.includes("application/json")) {
+      try {
+        return await webRequest.json();
+      } catch {
+        return {};
+      }
+    }
+  }
+  const expressReq = req.req;
+  if (expressReq?.body != null) {
+    return expressReq.body;
+  }
+  return {};
+}
+function resolveChannels(network, select) {
+  const channels = network.getChannels();
+  if (select?.channels) {
+    const ch = select.channels;
+    const arr = Array.isArray(ch) ? ch : [ch];
+    return arr.map((c) => ChannelName(c));
+  }
+  const httpStreamChannels = [...channels.values()].filter((ch) => ch.getSinks().some(isHttpStreamSink)).map((ch) => ch.name);
+  if (httpStreamChannels.length > 0)
+    return httpStreamChannels;
+  const client = channels.get("client");
+  if (client)
+    return [client.name];
+  const first = channels.values().next().value;
+  return first ? [first.name] : [];
+}
+function streamFromDequeue(take, signal, eventFilter) {
+  const shouldInclude = (e) => !eventFilter?.length || eventFilter.includes(e.name);
+  return {
+    async *[Symbol.asyncIterator]() {
+      while (!signal?.aborted) {
+        const takePromise = take();
+        const abortPromise = signal ? new Promise((_, reject) => {
+          signal.addEventListener(
+            "abort",
+            () => reject(new DOMException("Aborted", "AbortError")),
+            { once: true }
+          );
+        }) : new Promise(() => {
+        });
+        let envelope;
+        try {
+          envelope = await Promise.race([takePromise, abortPromise]);
+        } catch (e) {
+          if (e instanceof DOMException && e.name === "AbortError")
+            break;
+          throw e;
+        }
+        if (shouldInclude(envelope))
+          yield envelope;
+      }
+    }
+  };
+}
+function expose(network, options) {
+  const { auth, select, plane: providedPlane, onRequest, startEventName = "request" } = options;
+  const channels = resolveChannels(network, select);
+  const eventFilter = select?.events;
+  const mainChannel = network.getMainChannel();
+  if (channels.length === 0) {
+    throw new Error("expose: no channels to subscribe to");
+  }
+  const createStream = async (req, consumer) => {
+    const payload = await extractPayload(req);
+    const signal = req.request?.signal;
+    const program = Effect.gen(function* () {
+      const plane = providedPlane ?? (yield* createEventPlane(network));
+      if (!providedPlane) {
+        const emitQueue = yield* Queue.unbounded();
+        yield* Effect.fork(
+          Effect.forever(
+            Queue.take(emitQueue).pipe(
+              Effect.flatMap(
+                ({ channels: chs, envelope }) => plane.publishToChannels(chs, envelope)
+              )
+            )
+          )
+        );
+        yield* Effect.fork(run(network, plane, { emitQueue }));
+        yield* Effect.sleep("10 millis");
+      }
+      const targetChannel = mainChannel?.name ?? channels[0];
+      const emitStartEvent = (p) => {
+        const pld = p ?? payload;
+        const envelope = {
+          name: startEventName,
+          meta: { runId: crypto.randomUUID() },
+          payload: pld
+        };
+        Effect.runPromise(plane.publish(targetChannel, envelope)).catch(() => {
+        });
+      };
+      const dequeue = yield* plane.subscribe(channels[0]);
+      if (onRequest) {
+        yield* Effect.tryPromise(
+          () => Promise.resolve(onRequest({ emitStartEvent, req, payload }))
+        );
+      } else if (!providedPlane) {
+        const envelope = {
+          name: startEventName,
+          meta: { runId: crypto.randomUUID() },
+          payload
+        };
+        yield* plane.publish(targetChannel, envelope);
+        yield* Effect.sleep("10 millis");
+      }
+      const take = () => Effect.runPromise(Queue.take(dequeue));
+      const stream = streamFromDequeue(take, signal ?? void 0, eventFilter);
+      if (consumer) {
+        return yield* Effect.tryPromise(() => consumer(stream));
+      }
+      return stream;
+    });
+    return Effect.runPromise(program.pipe(Effect.scoped));
+  };
+  return {
+    protocol: "sse",
+    createStream: async (req, consumer) => {
+      if (auth) {
+        const result = await auth(req);
+        if (!result.allowed) {
+          throw new ExposeAuthError(
+            result.message ?? "Unauthorized",
+            result.status ?? 401
+          );
+        }
+      }
+      return consumer ? createStream(req, consumer) : createStream(req);
+    }
+  };
+}
+var ExposeAuthError = class extends Error {
+  constructor(message, status = 401) {
+    super(message);
+    this.status = status;
+    this.name = "ExposeAuthError";
+  }
+};
+
+// src/matrix/agent-network/agent-network.ts
+var AgentNetwork = class _AgentNetwork {
+  constructor() {
+    this.channels = /* @__PURE__ */ new Map();
+    this.agentRegistrations = /* @__PURE__ */ new Map();
+    this.spawnerRegistrations = [];
+  }
+  /* ─── Public Static Factory ─── */
+  static setup(callback) {
+    const network = new _AgentNetwork();
+    const ctx = {
+      mainChannel: (name) => {
+        const channel = network.addChannel(name);
+        network.setMainChannel(channel);
+        return channel;
+      },
+      createChannel: (name) => network.addChannel(name),
+      sink: Sink,
+      registerAgent: (agent) => network.registerAgentInternal(agent),
+      spawner: (factory) => network.createSpawnerInternal(factory)
+    };
+    callback(ctx);
+    return network;
+  }
+  /* ─── Internal Builders ─── */
+  addChannel(name) {
+    const channelName = ChannelName(name);
+    const channel = new ConfiguredChannel(channelName);
+    this.channels.set(channelName, channel);
+    return channel;
+  }
+  setMainChannel(channel) {
+    this._mainChannel = channel;
+  }
+  registerAgentInternal(agent) {
+    const registration = {
+      agent,
+      subscribedTo: [],
+      publishesTo: []
+    };
+    this.agentRegistrations.set(agent.getId(), registration);
+    const binding = {
+      subscribe(channel) {
+        registration.subscribedTo.push(channel);
+        return binding;
+      },
+      publishTo(channel) {
+        registration.publishesTo.push(channel);
+        return binding;
+      }
+    };
+    return binding;
+  }
+  createSpawnerInternal(factoryClass) {
+    const reg = {
+      factoryClass,
+      registry: {}
+    };
+    this.spawnerRegistrations.push(reg);
+    const builder = {
+      listen(channel, event) {
+        reg.listenChannel = channel;
+        reg.listenEvent = event;
+        return builder;
+      },
+      registry(registry) {
+        reg.registry = registry;
+        return builder;
+      },
+      defaultBinding(fn) {
+        reg.defaultBindingFn = fn;
+        return builder;
+      },
+      onSpawn(fn) {
+        reg.onSpawnFn = fn;
+        return builder;
+      }
+    };
+    return builder;
+  }
+  /* ─── Accessors ─── */
+  getChannels() {
+    return this.channels;
+  }
+  getMainChannel() {
+    return this._mainChannel;
+  }
+  getAgentRegistrations() {
+    return this.agentRegistrations;
+  }
+  getSpawnerRegistrations() {
+    return this.spawnerRegistrations;
+  }
+  /**
+   * Expose the network as a streamable API (e.g. SSE). Returns an ExposedAPI
+   * that adapters (NextEndpoint, ExpressEndpoint) consume to produce streamed
+   * responses.
+   *
+   * @example
+   * const api = network.expose({ protocol: "sse", auth, select });
+   * export const GET = NextEndpoint.from(api).handler();
+   */
+  expose(options) {
+    return expose(this, options);
+  }
+  /**
+   * Starts the event plane: creates one PubSub per channel and runs subscriber
+   * loops for each (agent, channel) pair. Agents subscribed to a channel are
+   * invoked concurrently when events are published to that channel.
+   *
+   * Returns the EventPlane for publishing. Use `Effect.scoped` so the run is
+   * interrupted when the scope ends.
+   */
+  run(capacity) {
+    return this.runScoped(this, capacity);
+  }
+  runScoped(network, capacity) {
+    return Effect.gen(function* () {
+      const plane = yield* createEventPlane(network, capacity);
+      yield* Effect.fork(run(network, plane));
+      return plane;
+    });
+  }
+};
+var EventMetaSchema = Schema.Struct({
+  runId: Schema.String,
+  contextId: Schema.optional(Schema.String),
+  correlationId: Schema.optional(Schema.String),
+  causationId: Schema.optional(Schema.String),
+  ts: Schema.optional(Schema.Number)
+});
+var AgentNetworkEvent = {
+  of(name, payload) {
+    const decodePayload = Schema.decodeUnknown(payload);
+    const envelopeSchema = Schema.Struct({
+      name: Schema.Literal(name),
+      meta: EventMetaSchema,
+      payload
+    });
+    const decodeEnvelope = Schema.decodeUnknown(envelopeSchema);
+    const make = (meta, payload2) => Effect.runSync(
+      decodeEnvelope({ name, meta, payload: payload2 })
+    );
+    const makeEffect = (meta, payload2) => decodeEnvelope({ name, meta, payload: payload2 });
+    const is = Schema.is(envelopeSchema);
+    return {
+      _tag: "AgentNetworkEventDef",
+      name,
+      payload,
+      decodePayload,
+      decode: decodeEnvelope,
+      make,
+      makeEffect,
+      is
+    };
+  }
+};
+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-${randomUUID()}`);
+    __privateSet(this, _listensTo, listensTo ?? []);
+  }
+  getListensTo() {
+    return __privateGet(this, _listensTo);
+  }
+  async invoke(options) {
+    const { triggerEvent, emit } = options ?? {};
+    const emitFn = emit ?? ((_event) => {
+    });
+    await __privateGet(this, _logic).call(this, {
+      params: __privateGet(this, _params),
+      triggerEvent: triggerEvent ?? void 0,
+      emit: emitFn
+    });
+  }
+  getId() {
+    return __privateGet(this, _id);
+  }
+};
+_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;
+  }
+  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;
+  }
+  static run() {
+    return new _AgentFactory({});
+  }
+  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
+    );
+  }
+};
+
+// 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) {
+    if (api.protocol !== "sse") {
+      throw new Error(`NextEndpoint: unsupported protocol "${api.protocol}"`);
+    }
+    return {
+      handler() {
+        return async (request) => {
+          const req = { 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) {
+    if (api.protocol !== "sse") {
+      throw new Error(
+        `ExpressEndpoint: unsupported protocol "${api.protocol}"`
+      );
+    }
+    return {
+      handler() {
+        return async (req, res) => {
+          const controller = new AbortController();
+          req.on("close", () => controller.abort());
+          const exposeReq = {
+            request: { signal: controller.signal },
+            req,
+            res
+          };
+          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;
+          }
+        };
+      }
+    };
+  }
+};
+
+export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, EventMetaSchema, ExposeAuthError, ExpressEndpoint, NextEndpoint, Sink, formatSSE, isHttpStreamSink, toSSEStream };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map