@graphrefly/graphrefly 0.1.0

package/dist/chunk-QW7H3ICI.js

@@ -0,0 +1,1372 @@
+import {
+  createWatermarkController,
+  fromCron,
+  fromTimer,
+  observeGraph$,
+  observeNode$,
+  reactiveLog,
+  toMessages$,
+  toObservable
+} from "./chunk-KWXPDASV.js";
+import {
+  Graph
+} from "./chunk-6W5SGIGB.js";
+import {
+  COMPLETE,
+  DATA,
+  DEFAULT_ACTOR,
+  ERROR,
+  TEARDOWN,
+  __decorateElement,
+  __decoratorStart,
+  __export,
+  __runInitializers,
+  batch,
+  derived,
+  node,
+  normalizeActor,
+  policy,
+  state,
+  wallClockNs
+} from "./chunk-5X3LAO3B.js";
+
+// src/compat/nestjs/index.ts
+var nestjs_exports = {};
+__export(nestjs_exports, {
+  ACTOR_KEY: () => ACTOR_KEY,
+  COMMAND_HANDLERS: () => COMMAND_HANDLERS,
+  CQRS_EVENT_HANDLERS: () => CQRS_EVENT_HANDLERS,
+  CRON_HANDLERS: () => CRON_HANDLERS,
+  CommandHandler: () => CommandHandler,
+  EVENT_HANDLERS: () => EVENT_HANDLERS,
+  EventHandler: () => EventHandler,
+  GRAPHREFLY_REQUEST_GRAPH: () => GRAPHREFLY_REQUEST_GRAPH,
+  GRAPHREFLY_ROOT_GRAPH: () => GRAPHREFLY_ROOT_GRAPH,
+  GraphCron: () => GraphCron,
+  GraphInterval: () => GraphInterval,
+  GraphReflyEventExplorer: () => GraphReflyEventExplorer,
+  GraphReflyGuard: () => GraphReflyGuard,
+  GraphReflyGuardImpl: () => GraphReflyGuardImpl,
+  GraphReflyModule: () => GraphReflyModule,
+  INTERVAL_HANDLERS: () => INTERVAL_HANDLERS,
+  InjectCqrsGraph: () => InjectCqrsGraph,
+  InjectGraph: () => InjectGraph,
+  InjectNode: () => InjectNode,
+  ObserveGateway: () => ObserveGateway,
+  OnGraphEvent: () => OnGraphEvent,
+  QUERY_HANDLERS: () => QUERY_HANDLERS,
+  QueryHandler: () => QueryHandler,
+  SAGA_HANDLERS: () => SAGA_HANDLERS,
+  SagaHandler: () => SagaHandler,
+  fromHeader: () => fromHeader,
+  fromJwtPayload: () => fromJwtPayload,
+  getActor: () => getActor,
+  getGraphToken: () => getGraphToken,
+  getNodeToken: () => getNodeToken,
+  observeGraph$: () => observeGraph$,
+  observeNode$: () => observeNode$,
+  observeSSE: () => observeSSE,
+  observeSubscription: () => observeSubscription,
+  toMessages$: () => toMessages$,
+  toObservable: () => toObservable
+});
+
+// src/compat/nestjs/decorators.ts
+import { Inject } from "@nestjs/common";
+
+// src/compat/nestjs/tokens.ts
+var GRAPHREFLY_ROOT_GRAPH = /* @__PURE__ */ Symbol.for("graphrefly:root-graph");
+var GRAPHREFLY_REQUEST_GRAPH = /* @__PURE__ */ Symbol.for("graphrefly:request-graph");
+function getGraphToken(name) {
+  return /* @__PURE__ */ Symbol.for(`graphrefly:graph:${name}`);
+}
+function getNodeToken(path) {
+  return /* @__PURE__ */ Symbol.for(`graphrefly:node:${path}`);
+}
+
+// src/compat/nestjs/decorators.ts
+var EVENT_HANDLERS = /* @__PURE__ */ new Map();
+var INTERVAL_HANDLERS = /* @__PURE__ */ new Map();
+var CRON_HANDLERS = /* @__PURE__ */ new Map();
+var COMMAND_HANDLERS = /* @__PURE__ */ new Map();
+var CQRS_EVENT_HANDLERS = /* @__PURE__ */ new Map();
+var QUERY_HANDLERS = /* @__PURE__ */ new Map();
+var SAGA_HANDLERS = /* @__PURE__ */ new Map();
+function InjectGraph(name) {
+  if (name === "request") return Inject(GRAPHREFLY_REQUEST_GRAPH);
+  return Inject(name ? getGraphToken(name) : GRAPHREFLY_ROOT_GRAPH);
+}
+function InjectCqrsGraph(name) {
+  return Inject(getGraphToken(name));
+}
+function InjectNode(path) {
+  return Inject(getNodeToken(path));
+}
+function OnGraphEvent(nodeName) {
+  return (_value, context) => {
+    const methodKey = context.name;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const existing = EVENT_HANDLERS.get(ctor) ?? [];
+      existing.push({ nodeName, methodKey });
+      EVENT_HANDLERS.set(ctor, existing);
+    });
+  };
+}
+function GraphInterval(ms) {
+  return (_value, context) => {
+    const methodKey = context.name;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const existing = INTERVAL_HANDLERS.get(ctor) ?? [];
+      existing.push({ ms, methodKey });
+      INTERVAL_HANDLERS.set(ctor, existing);
+    });
+  };
+}
+function GraphCron(expr) {
+  return (_value, context) => {
+    const methodKey = context.name;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const existing = CRON_HANDLERS.get(ctor) ?? [];
+      existing.push({ expr, methodKey });
+      CRON_HANDLERS.set(ctor, existing);
+    });
+  };
+}
+function CommandHandler(cqrsName, commandName) {
+  return (_value, context) => {
+    const methodKey = context.name;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const existing = COMMAND_HANDLERS.get(ctor) ?? [];
+      existing.push({ cqrsName, commandName, methodKey });
+      COMMAND_HANDLERS.set(ctor, existing);
+    });
+  };
+}
+function EventHandler(cqrsName, eventName) {
+  return (_value, context) => {
+    const methodKey = context.name;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const existing = CQRS_EVENT_HANDLERS.get(ctor) ?? [];
+      existing.push({ cqrsName, eventName, methodKey });
+      CQRS_EVENT_HANDLERS.set(ctor, existing);
+    });
+  };
+}
+function QueryHandler(cqrsName, projectionName) {
+  return (_value, context) => {
+    const methodKey = context.name;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const existing = QUERY_HANDLERS.get(ctor) ?? [];
+      existing.push({ cqrsName, projectionName, methodKey });
+      QUERY_HANDLERS.set(ctor, existing);
+    });
+  };
+}
+function SagaHandler(cqrsName, sagaName, eventNames) {
+  return (_value, context) => {
+    const methodKey = context.name;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const existing = SAGA_HANDLERS.get(ctor) ?? [];
+      existing.push({ cqrsName, eventNames, sagaName, methodKey });
+      SAGA_HANDLERS.set(ctor, existing);
+    });
+  };
+}
+
+// src/compat/nestjs/explorer.ts
+var scheduleSeq = 0;
+var GraphReflyEventExplorer = class {
+  constructor(graph, moduleRef) {
+    this.graph = graph;
+    this.moduleRef = moduleRef;
+  }
+  disposers = [];
+  scheduleNodeNames = [];
+  onModuleInit() {
+    this.wireEvents();
+    this.wireIntervals();
+    this.wireCrons();
+    this.wireCqrsCommands();
+    this.wireCqrsEvents();
+    this.wireCqrsQueries();
+    this.wireCqrsSagas();
+  }
+  onModuleDestroy() {
+    for (const dispose of this.disposers) dispose();
+    this.disposers.length = 0;
+    for (const name of this.scheduleNodeNames) {
+      try {
+        this.graph.remove(name);
+      } catch {
+      }
+    }
+    this.scheduleNodeNames.length = 0;
+  }
+  // -----------------------------------------------------------------------
+  // @OnGraphEvent — reactive subscription via graph.observe()
+  // -----------------------------------------------------------------------
+  wireEvents() {
+    for (const [ctor, metas] of EVENT_HANDLERS) {
+      const instance = this.resolveInstance(ctor);
+      if (!instance) continue;
+      for (const meta of metas) {
+        this.wireEventHandler(instance, meta);
+      }
+    }
+  }
+  wireEventHandler(instance, meta) {
+    const method = instance[meta.methodKey];
+    if (typeof method !== "function") return;
+    const bound = method.bind(instance);
+    const handle = this.observeNode(meta.nodeName);
+    const unsub = handle.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) {
+          bound(m[1]);
+        }
+      }
+    });
+    this.disposers.push(unsub);
+  }
+  // -----------------------------------------------------------------------
+  // @GraphInterval — reactive via fromTimer central timer primitive
+  // -----------------------------------------------------------------------
+  wireIntervals() {
+    for (const [ctor, metas] of INTERVAL_HANDLERS) {
+      const instance = this.resolveInstance(ctor);
+      if (!instance) continue;
+      for (const meta of metas) {
+        this.wireIntervalHandler(instance, ctor, meta);
+      }
+    }
+  }
+  wireIntervalHandler(instance, ctor, meta) {
+    const method = instance[meta.methodKey];
+    if (typeof method !== "function") return;
+    const bound = method.bind(instance);
+    const className = ctor.name ?? "anonymous";
+    const nodeName = `__schedule__.${className}.${String(meta.methodKey)}.${scheduleSeq++}`;
+    const timerNode = fromTimer(meta.ms, { period: meta.ms, name: nodeName });
+    this.graph.add(nodeName, timerNode);
+    this.scheduleNodeNames.push(nodeName);
+    const handle = this.observeNode(nodeName);
+    const unsub = handle.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) bound(m[1]);
+      }
+    });
+    this.disposers.push(unsub);
+  }
+  // -----------------------------------------------------------------------
+  // @GraphCron — reactive via fromCron central timer primitive
+  // -----------------------------------------------------------------------
+  wireCrons() {
+    for (const [ctor, metas] of CRON_HANDLERS) {
+      const instance = this.resolveInstance(ctor);
+      if (!instance) continue;
+      for (const meta of metas) {
+        this.wireCronHandler(instance, ctor, meta);
+      }
+    }
+  }
+  wireCronHandler(instance, ctor, meta) {
+    const method = instance[meta.methodKey];
+    if (typeof method !== "function") return;
+    const bound = method.bind(instance);
+    const className = ctor.name ?? "anonymous";
+    const nodeName = `__schedule__.${className}.${String(meta.methodKey)}.${scheduleSeq++}`;
+    const cronNode = fromCron(meta.expr, { name: nodeName });
+    this.graph.add(nodeName, cronNode);
+    this.scheduleNodeNames.push(nodeName);
+    const handle = this.observeNode(nodeName);
+    const unsub = handle.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) bound(m[1]);
+      }
+    });
+    this.disposers.push(unsub);
+  }
+  // -----------------------------------------------------------------------
+  // @CommandHandler — register method as CqrsGraph command handler
+  // -----------------------------------------------------------------------
+  wireCqrsCommands() {
+    for (const [ctor, metas] of COMMAND_HANDLERS) {
+      const instance = this.resolveInstance(ctor);
+      if (!instance) continue;
+      for (const meta of metas) {
+        this.wireCqrsCommand(instance, meta);
+      }
+    }
+  }
+  wireCqrsCommand(instance, meta) {
+    const method = instance[meta.methodKey];
+    if (typeof method !== "function") return;
+    const bound = method.bind(instance);
+    const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
+    if (!cqrsGraph) return;
+    cqrsGraph.command(meta.commandName, bound);
+  }
+  // -----------------------------------------------------------------------
+  // @EventHandler — subscribe method to CQRS event stream
+  // -----------------------------------------------------------------------
+  wireCqrsEvents() {
+    for (const [ctor, metas] of CQRS_EVENT_HANDLERS) {
+      const instance = this.resolveInstance(ctor);
+      if (!instance) continue;
+      for (const meta of metas) {
+        this.wireCqrsEventHandler(instance, meta);
+      }
+    }
+  }
+  wireCqrsEventHandler(instance, meta) {
+    const method = instance[meta.methodKey];
+    if (typeof method !== "function") return;
+    const bound = method.bind(instance);
+    const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
+    if (!cqrsGraph) return;
+    cqrsGraph.event(meta.eventName);
+    const eventNode = cqrsGraph.resolve(meta.eventName);
+    const currentSnap = eventNode.get();
+    const existingEntries = currentSnap?.value?.entries;
+    let lastSeq = existingEntries && existingEntries.length > 0 ? existingEntries[existingEntries.length - 1].seq : 0;
+    const handle = this.observeNodeOn(cqrsGraph, meta.eventName);
+    const unsub = handle.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) {
+          const snap = m[1];
+          for (const entry of snap.value.entries) {
+            if (entry.seq > lastSeq) {
+              bound(entry);
+              lastSeq = entry.seq;
+            }
+          }
+        }
+      }
+    });
+    this.disposers.push(unsub);
+  }
+  // -----------------------------------------------------------------------
+  // @QueryHandler — subscribe method to CQRS projection changes
+  // -----------------------------------------------------------------------
+  wireCqrsQueries() {
+    for (const [ctor, metas] of QUERY_HANDLERS) {
+      const instance = this.resolveInstance(ctor);
+      if (!instance) continue;
+      for (const meta of metas) {
+        this.wireCqrsQuery(instance, meta);
+      }
+    }
+  }
+  wireCqrsQuery(instance, meta) {
+    const method = instance[meta.methodKey];
+    if (typeof method !== "function") return;
+    const bound = method.bind(instance);
+    const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
+    if (!cqrsGraph) return;
+    const handle = this.observeNodeOn(cqrsGraph, meta.projectionName);
+    const unsub = handle.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) {
+          bound(m[1]);
+        }
+      }
+    });
+    this.disposers.push(unsub);
+  }
+  // -----------------------------------------------------------------------
+  // @SagaHandler — register method as CqrsGraph saga (subgraph side effect)
+  // -----------------------------------------------------------------------
+  wireCqrsSagas() {
+    for (const [ctor, metas] of SAGA_HANDLERS) {
+      const instance = this.resolveInstance(ctor);
+      if (!instance) continue;
+      for (const meta of metas) {
+        this.wireCqrsSaga(instance, meta);
+      }
+    }
+  }
+  wireCqrsSaga(instance, meta) {
+    const method = instance[meta.methodKey];
+    if (typeof method !== "function") return;
+    const bound = method.bind(instance);
+    const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
+    if (!cqrsGraph) return;
+    cqrsGraph.saga(meta.sagaName, meta.eventNames, bound);
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  observeNode(name) {
+    return this.graph.observe(name);
+  }
+  observeNodeOn(graph, name) {
+    return graph.observe(name);
+  }
+  resolveCqrsGraph(name) {
+    try {
+      return this.moduleRef.get(getGraphToken(name), { strict: false });
+    } catch {
+      console.warn(
+        `[GraphReFly] CqrsGraph "${name}" not found in DI \u2014 did you import GraphReflyModule.forCqrs({ name: "${name}" })?`
+      );
+      return null;
+    }
+  }
+  resolveInstance(ctor) {
+    try {
+      return this.moduleRef.get(ctor, { strict: false });
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/compat/nestjs/gateway.ts
+function observeSSE(graph, path, opts) {
+  const { actor, serialize = defaultSerialize, keepAliveMs, signal } = opts ?? {};
+  const encoder = new TextEncoder();
+  let stop;
+  const useBackpressure = opts?.highWaterMark != null;
+  let wm;
+  let pullResolve;
+  const taggedBuf = [];
+  let closed = false;
+  return new ReadableStream({
+    start(controller) {
+      let keepAlive;
+      let unsub = () => {
+      };
+      const close = () => {
+        if (closed) return;
+        closed = true;
+        if (keepAlive !== void 0) clearInterval(keepAlive);
+        signal?.removeEventListener("abort", onAbort);
+        unsub();
+        wm?.dispose();
+        pullResolve?.();
+        pullResolve = void 0;
+        for (const entry of taggedBuf) controller.enqueue(entry.frame);
+        taggedBuf.length = 0;
+        controller.close();
+      };
+      stop = close;
+      const onAbort = () => close();
+      const handle = graph.observe(path, { actor });
+      if (useBackpressure) {
+        wm = createWatermarkController((msgs) => handle.up(msgs), {
+          highWaterMark: opts.highWaterMark,
+          lowWaterMark: opts.lowWaterMark ?? Math.floor(opts.highWaterMark / 2)
+        });
+      }
+      unsub = handle.subscribe((msgs) => {
+        for (const msg of msgs) {
+          if (closed) return;
+          const t = msg[0];
+          if (t === DATA) {
+            const frame = encoder.encode(sseFrame("data", serialize(msg[1])));
+            if (useBackpressure) {
+              taggedBuf.push({ frame, counted: true });
+              wm.onEnqueue();
+              pullResolve?.();
+              pullResolve = void 0;
+            } else {
+              controller.enqueue(frame);
+            }
+          } else if (t === ERROR) {
+            const frame = encoder.encode(sseFrame("error", serialize(msg[1])));
+            if (useBackpressure) {
+              taggedBuf.push({ frame, counted: false });
+              pullResolve?.();
+              pullResolve = void 0;
+            } else {
+              controller.enqueue(frame);
+            }
+            close();
+            return;
+          } else if (t === COMPLETE || t === TEARDOWN) {
+            if (t === COMPLETE) {
+              const frame = encoder.encode(sseFrame("complete"));
+              if (useBackpressure) {
+                taggedBuf.push({ frame, counted: false });
+                pullResolve?.();
+                pullResolve = void 0;
+              } else {
+                controller.enqueue(frame);
+              }
+            }
+            close();
+            return;
+          }
+        }
+      });
+      if (keepAliveMs !== void 0 && keepAliveMs > 0) {
+        keepAlive = setInterval(() => {
+          if (closed) return;
+          if (useBackpressure) {
+            taggedBuf.push({ frame: encoder.encode(": keepalive\n\n"), counted: false });
+            pullResolve?.();
+            pullResolve = void 0;
+          } else {
+            controller.enqueue(encoder.encode(": keepalive\n\n"));
+          }
+        }, keepAliveMs);
+      }
+      if (signal?.aborted) onAbort();
+      else signal?.addEventListener("abort", onAbort, { once: true });
+    },
+    pull(controller) {
+      if (!useBackpressure) return;
+      if (closed) return;
+      if (taggedBuf.length > 0) {
+        const entry = taggedBuf.shift();
+        controller.enqueue(entry.frame);
+        if (entry.counted) wm.onDequeue();
+        return;
+      }
+      return new Promise((resolve) => {
+        pullResolve = resolve;
+      });
+    },
+    cancel() {
+      try {
+        stop?.();
+      } catch {
+      }
+    }
+  });
+}
+function observeSubscription(graph, path, opts) {
+  const { actor, filter } = opts ?? {};
+  const queue = [];
+  const waiters = [];
+  let disposed = false;
+  const handle = graph.observe(path, { actor });
+  const wm = opts?.highWaterMark != null ? createWatermarkController((msgs) => handle.up(msgs), {
+    highWaterMark: opts.highWaterMark,
+    lowWaterMark: opts.lowWaterMark ?? Math.floor(opts.highWaterMark / 2)
+  }) : void 0;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    wm?.dispose();
+    unsub();
+  };
+  const push = (item) => {
+    if (disposed) return;
+    if (waiters.length > 0) {
+      const w = waiters.shift();
+      if (item.done && item.error) w.reject(item.error);
+      else if (item.done) w.resolve({ done: true, value: void 0 });
+      else w.resolve({ done: false, value: item.value });
+    } else {
+      queue.push(item);
+      if (!item.done) wm?.onEnqueue();
+    }
+  };
+  const unsub = handle.subscribe((msgs) => {
+    for (const msg of msgs) {
+      const t = msg[0];
+      if (t === DATA) {
+        const value = msg[1];
+        if (filter && !filter(value)) continue;
+        push({ done: false, value });
+      } else if (t === ERROR) {
+        const err = msg[1] instanceof Error ? msg[1] : new Error(String(msg[1]));
+        push({ done: true, error: err });
+        dispose();
+        return;
+      } else if (t === COMPLETE || t === TEARDOWN) {
+        push({ done: true });
+        dispose();
+        return;
+      }
+    }
+  });
+  const iterator = {
+    next() {
+      if (queue.length > 0) {
+        const item = queue.shift();
+        if (!item.done) wm?.onDequeue();
+        if (item.done && item.error) return Promise.reject(item.error);
+        return Promise.resolve(
+          item.done ? { done: true, value: void 0 } : { done: false, value: item.value }
+        );
+      }
+      if (disposed) return Promise.resolve({ done: true, value: void 0 });
+      return new Promise((resolve, reject) => {
+        waiters.push({ resolve, reject });
+      });
+    },
+    return() {
+      dispose();
+      for (const w of waiters) w.resolve({ done: true, value: void 0 });
+      waiters.length = 0;
+      return Promise.resolve({ done: true, value: void 0 });
+    },
+    throw(err) {
+      dispose();
+      return Promise.reject(err);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  return iterator;
+}
+var ObserveGateway = class {
+  constructor(graph, opts) {
+    this.graph = graph;
+    this.extractActor = opts?.extractActor ?? (() => void 0);
+    this.parse = opts?.parse ?? defaultParseCommand;
+    this.highWaterMark = opts?.highWaterMark;
+    this.lowWaterMark = opts?.lowWaterMark;
+  }
+  clients = /* @__PURE__ */ new Map();
+  extractActor;
+  parse;
+  highWaterMark;
+  lowWaterMark;
+  /**
+   * Register a new client. Call from `handleConnection`.
+   */
+  handleConnection(client) {
+    if (!this.clients.has(client)) {
+      this.clients.set(client, /* @__PURE__ */ new Map());
+    }
+  }
+  /**
+   * Unregister a client and dispose all its subscriptions. Call from `handleDisconnect`.
+   */
+  handleDisconnect(client) {
+    const subs = this.clients.get(client);
+    if (!subs) return;
+    for (const entry of subs.values()) {
+      entry.wm?.dispose();
+      entry.unsub();
+    }
+    this.clients.delete(client);
+  }
+  /**
+   * Handle an incoming client message (subscribe/unsubscribe/ack command).
+   *
+   * @param client - The WebSocket client reference.
+   * @param raw - Raw message data (string or parsed object).
+   * @param send - Function to send a message back to the client.
+   *   Defaults to `client.send(JSON.stringify(msg))`.
+   */
+  handleMessage(client, raw, send) {
+    const sender = send ?? defaultSend.bind(null, client);
+    let cmd;
+    try {
+      cmd = typeof raw === "string" ? this.parse(raw) : raw;
+    } catch {
+      sender({ type: "err", message: "invalid command" });
+      return;
+    }
+    if (cmd.type === "subscribe") {
+      this.subscribe(client, cmd.path, sender);
+    } else if (cmd.type === "unsubscribe") {
+      this.unsubscribe(client, cmd.path, sender);
+    } else if (cmd.type === "ack") {
+      this.ack(client, cmd.path, cmd.count ?? 1);
+    } else {
+      sender({ type: "err", message: `unknown command type: ${cmd.type}` });
+    }
+  }
+  /**
+   * Number of active subscriptions for a client. Useful for tests.
+   */
+  subscriptionCount(client) {
+    return this.clients.get(client)?.size ?? 0;
+  }
+  /**
+   * Dispose all clients and subscriptions.
+   */
+  destroy() {
+    for (const [client] of this.clients) {
+      this.handleDisconnect(client);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  subscribe(client, path, send) {
+    let subs = this.clients.get(client);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Map();
+      this.clients.set(client, subs);
+    }
+    if (subs.has(path)) {
+      send({ type: "subscribed", path });
+      return;
+    }
+    const actor = this.extractActor(client);
+    let handle;
+    try {
+      handle = this.graph.observe(path, { actor });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      send({ type: "err", message });
+      return;
+    }
+    const wm = this.highWaterMark != null ? createWatermarkController((msgs) => handle.up(msgs), {
+      highWaterMark: this.highWaterMark,
+      lowWaterMark: this.lowWaterMark ?? Math.floor(this.highWaterMark / 2)
+    }) : void 0;
+    const cleanup = () => {
+      wm?.dispose();
+      unsub();
+      subs.delete(path);
+    };
+    const unsub = handle.subscribe((msgs) => {
+      for (const msg of msgs) {
+        const t = msg[0];
+        if (t === DATA) {
+          wm?.onEnqueue();
+          trySend(send, { type: "data", path, value: msg[1] });
+        } else if (t === ERROR) {
+          const errMsg = msg[1] instanceof Error ? msg[1].message : String(msg[1]);
+          trySend(send, { type: "error", path, error: errMsg });
+          cleanup();
+          return;
+        } else if (t === COMPLETE || t === TEARDOWN) {
+          trySend(send, { type: "complete", path });
+          cleanup();
+          return;
+        }
+      }
+    });
+    subs.set(path, { unsub, wm });
+    send({ type: "subscribed", path });
+  }
+  unsubscribe(client, path, send) {
+    const subs = this.clients.get(client);
+    const entry = subs?.get(path);
+    if (entry) {
+      entry.wm?.dispose();
+      entry.unsub();
+      subs.delete(path);
+    }
+    send({ type: "unsubscribed", path });
+  }
+  ack(client, path, count) {
+    const entry = this.clients.get(client)?.get(path);
+    if (!entry?.wm) return;
+    const n = Math.min(Math.max(0, Math.floor(count)), 1024);
+    for (let i = 0; i < n; i++) entry.wm.onDequeue();
+  }
+};
+function defaultSerialize(value) {
+  if (value instanceof Error) return value.message;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function sseFrame(event, data) {
+  let frame = `event: ${event}
+`;
+  if (data !== void 0) {
+    for (const line of data.split("\n")) {
+      frame += `data: ${line}
+`;
+    }
+  }
+  frame += "\n";
+  return frame;
+}
+function defaultParseCommand(data) {
+  return JSON.parse(data);
+}
+function defaultSend(client, msg) {
+  try {
+    client.send(JSON.stringify(msg));
+  } catch {
+  }
+}
+function trySend(send, msg) {
+  try {
+    send(msg);
+  } catch {
+  }
+}
+
+// src/compat/nestjs/guard.ts
+var ACTOR_KEY = "graphReflyActor";
+function fromJwtPayload(mapping) {
+  return (context) => {
+    const req = context.switchToHttp().getRequest();
+    const user = req?.user;
+    if (user == null) return void 0;
+    if (mapping) return mapping(user);
+    return user;
+  };
+}
+function fromHeader(headerName = "x-graphrefly-actor") {
+  return (context) => {
+    const req = context.switchToHttp().getRequest();
+    const raw = req?.headers?.[headerName.toLowerCase()];
+    if (typeof raw !== "string" || raw.length === 0) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  };
+}
+function getActor(req) {
+  const actor = req?.[ACTOR_KEY];
+  return actor != null ? normalizeActor(actor) : DEFAULT_ACTOR;
+}
+var GraphReflyGuardImpl = class {
+  constructor(extractor) {
+    this.extractor = extractor;
+  }
+  canActivate(context) {
+    const actor = normalizeActor(this.extractor(context));
+    const req = context.switchToHttp().getRequest();
+    if (req != null) {
+      req[ACTOR_KEY] = actor;
+    }
+    return true;
+  }
+};
+function GraphReflyGuard(extractor) {
+  return new GraphReflyGuardImpl(extractor ?? fromJwtPayload());
+}
+
+// src/compat/nestjs/module.ts
+import {
+  Module,
+  Scope
+} from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+
+// src/patterns/cqrs.ts
+var cqrs_exports = {};
+__export(cqrs_exports, {
+  CqrsGraph: () => CqrsGraph,
+  MemoryEventStore: () => MemoryEventStore,
+  cqrs: () => cqrs
+});
+var COMMAND_GUARD = policy((allow, deny) => {
+  allow("write");
+  allow("signal");
+  deny("observe");
+});
+var PROJECTION_GUARD = policy((allow, deny) => {
+  allow("observe");
+  allow("signal");
+  deny("write");
+});
+var EVENT_GUARD = policy((allow, deny) => {
+  allow("observe");
+  allow("signal");
+  deny("write");
+});
+function cqrsMeta(kind, extra) {
+  return { cqrs: true, cqrs_type: kind, ...extra ?? {} };
+}
+function keepalive(n) {
+  return n.subscribe(() => {
+  });
+}
+var MemoryEventStore = class {
+  _store = /* @__PURE__ */ new Map();
+  persist(event) {
+    let list = this._store.get(event.type);
+    if (!list) {
+      list = [];
+      this._store.set(event.type, list);
+    }
+    list.push(event);
+  }
+  loadEvents(eventType, cursor) {
+    const list = this._store.get(eventType) ?? [];
+    const sinceTs = cursor?.timestampNs;
+    const sinceSeq = cursor?.seq;
+    const events = sinceTs == null ? [...list] : list.filter(
+      (e) => e.timestampNs > sinceTs || e.timestampNs === sinceTs && e.seq > (sinceSeq ?? -1)
+    );
+    const lastEvent = events.length > 0 ? events[events.length - 1] : void 0;
+    return {
+      events,
+      cursor: lastEvent ? { timestampNs: lastEvent.timestampNs, seq: lastEvent.seq } : cursor
+    };
+  }
+  clear() {
+    this._store.clear();
+  }
+};
+var CqrsGraph = class extends Graph {
+  _eventLogs = /* @__PURE__ */ new Map();
+  _commandHandlers = /* @__PURE__ */ new Map();
+  _projections = /* @__PURE__ */ new Set();
+  _sagas = /* @__PURE__ */ new Set();
+  _keepaliveDisposers = [];
+  _eventStore;
+  _seq = 0;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  // -- Events ---------------------------------------------------------------
+  /**
+   * Register a named event stream backed by `reactiveLog`.
+   * Guard denies external `write` — only commands append internally.
+   */
+  event(name) {
+    const existing = this._eventLogs.get(name);
+    if (existing) return existing.node;
+    const log = reactiveLog([], { name });
+    const entries = log.entries;
+    const guarded = derived(
+      [entries],
+      ([snapshot]) => snapshot,
+      {
+        name,
+        describeKind: "state",
+        meta: cqrsMeta("event", { event_name: name }),
+        guard: EVENT_GUARD,
+        initial: entries.get()
+      }
+    );
+    this.add(name, guarded);
+    this._keepaliveDisposers.push(keepalive(guarded));
+    this._eventLogs.set(name, { log, node: guarded });
+    return guarded;
+  }
+  /** Internal: append to an event log, auto-registering if needed. */
+  _appendEvent(eventName, payload) {
+    let entry = this._eventLogs.get(eventName);
+    if (!entry) {
+      this.event(eventName);
+      entry = this._eventLogs.get(eventName);
+    }
+    if (entry.node.status === "completed" || entry.node.status === "errored") {
+      throw new Error(
+        `Cannot dispatch to terminated event stream "${eventName}" (status: ${entry.node.status}).`
+      );
+    }
+    const nv = entry.log.entries.v;
+    const evt = {
+      type: eventName,
+      payload,
+      timestampNs: wallClockNs(),
+      seq: ++this._seq,
+      ...nv != null ? { v0: { id: nv.id, version: nv.version } } : {}
+    };
+    entry.log.append(evt);
+    if (this._eventStore) {
+      this._eventStore.persist(evt);
+    }
+  }
+  // -- Commands -------------------------------------------------------------
+  /**
+   * Register a command with its handler. Guard denies `observe` (write-only).
+   * Use `dispatch(name, payload)` to execute.
+   *
+   * The command node carries dynamic `meta.error` — a reactive companion
+   * that holds the last handler error (or `null` on success).
+   */
+  command(name, handler) {
+    const cmdNode = state(void 0, {
+      name,
+      describeKind: "state",
+      meta: {
+        ...cqrsMeta("command", { command_name: name }),
+        error: null
+      },
+      guard: COMMAND_GUARD
+    });
+    this.add(name, cmdNode);
+    this._commandHandlers.set(name, handler);
+    return cmdNode;
+  }
+  /**
+   * Execute a registered command. Wraps the entire dispatch in `batch()` so
+   * the command node DATA and all emitted events settle atomically.
+   *
+   * If the handler throws, `meta.error` on the command node is set to the
+   * error and the exception is re-thrown.
+   */
+  dispatch(commandName, payload) {
+    const handler = this._commandHandlers.get(commandName);
+    if (!handler) {
+      throw new Error(`Unknown command: "${commandName}". Register with .command() first.`);
+    }
+    const cmdNode = this.resolve(commandName);
+    batch(() => {
+      cmdNode.down([[DATA, payload]], { internal: true });
+      try {
+        handler(payload, { emit: (eName, data) => this._appendEvent(eName, data) });
+        cmdNode.meta.error.down([[DATA, null]], { internal: true });
+      } catch (err) {
+        cmdNode.meta.error.down([[DATA, err]], { internal: true });
+        throw err;
+      }
+    });
+  }
+  // -- Projections ----------------------------------------------------------
+  /**
+   * Register a read-only projection derived from event streams.
+   * Guard denies `write` — value is computed from events only.
+   *
+   * **Purity contract:** The `reducer` must be a pure function — it receives
+   * the original `initial` on every invocation (full event-sourcing replay).
+   * Never mutate `initial`; always return a new value.
+   */
+  projection(name, eventNames, reducer, initial) {
+    const eventNodes = eventNames.map((eName) => {
+      if (!this._eventLogs.has(eName)) this.event(eName);
+      return this._eventLogs.get(eName).node;
+    });
+    const projNode = derived(
+      eventNodes,
+      (snapshots) => {
+        const allEvents = [];
+        for (const snapshot of snapshots) {
+          const snap = snapshot;
+          allEvents.push(...snap.value.entries);
+        }
+        allEvents.sort((a, b) => a.timestampNs - b.timestampNs || a.seq - b.seq);
+        return reducer(initial, allEvents);
+      },
+      {
+        name,
+        describeKind: "derived",
+        meta: cqrsMeta("projection", { projection_name: name, source_events: eventNames }),
+        guard: PROJECTION_GUARD,
+        initial
+      }
+    );
+    this.add(name, projNode);
+    for (const eName of eventNames) this.connect(eName, name);
+    this._keepaliveDisposers.push(keepalive(projNode));
+    this._projections.add(name);
+    return projNode;
+  }
+  // -- Sagas ----------------------------------------------------------------
+  /**
+   * Register an event-driven side effect. Runs handler for each **new** event
+   * from the specified streams (tracks last-processed entry count per stream).
+   *
+   * The saga node carries dynamic `meta.error` — a reactive companion that
+   * holds the last handler error (or `null` on success). Handler errors do
+   * not propagate out of the saga run (the event cursor still advances so
+   * the same entry is not delivered twice).
+   */
+  saga(name, eventNames, handler) {
+    const eventNodes = eventNames.map((eName) => {
+      if (!this._eventLogs.has(eName)) this.event(eName);
+      return this._eventLogs.get(eName).node;
+    });
+    const lastCounts = /* @__PURE__ */ new Map();
+    const sagaRef = {};
+    const sagaNode = node(
+      eventNodes,
+      (snapshots) => {
+        const errNode = sagaRef.n.meta.error;
+        for (let i = 0; i < snapshots.length; i++) {
+          const snap = snapshots[i];
+          const eName = eventNames[i];
+          const entries = snap.value.entries;
+          const lastCount = lastCounts.get(eName) ?? 0;
+          if (entries.length > lastCount) {
+            const newEntries = entries.slice(lastCount);
+            for (const entry of newEntries) {
+              try {
+                handler(entry);
+                errNode.down([[DATA, null]], { internal: true });
+              } catch (err) {
+                errNode.down([[DATA, err]], { internal: true });
+              }
+            }
+            lastCounts.set(eName, entries.length);
+          }
+        }
+      },
+      {
+        name,
+        describeKind: "effect",
+        meta: {
+          ...cqrsMeta("saga", { saga_name: name, source_events: eventNames }),
+          error: null
+        }
+      }
+    );
+    sagaRef.n = sagaNode;
+    this.add(name, sagaNode);
+    for (const eName of eventNames) this.connect(eName, name);
+    this._keepaliveDisposers.push(keepalive(sagaNode));
+    this._sagas.add(name);
+    return sagaNode;
+  }
+  // -- Event store ----------------------------------------------------------
+  useEventStore(adapter) {
+    this._eventStore = adapter;
+  }
+  /**
+   * Replay persisted events through a reducer to rebuild a read model.
+   * Requires an event store adapter wired via `useEventStore()`.
+   */
+  async rebuildProjection(eventNames, reducer, initial) {
+    if (!this._eventStore) {
+      throw new Error("No event store wired. Call useEventStore() first.");
+    }
+    const allEvents = [];
+    for (const eName of eventNames) {
+      const result = await this._eventStore.loadEvents(eName);
+      allEvents.push(...result.events);
+    }
+    allEvents.sort((a, b) => a.timestampNs - b.timestampNs || a.seq - b.seq);
+    return reducer(initial, allEvents);
+  }
+};
+function cqrs(name, opts) {
+  return new CqrsGraph(name, opts);
+}
+
+// src/compat/nestjs/module.ts
+var GraphReflyRootLifecycle = class {
+  constructor(graph) {
+    this.graph = graph;
+  }
+  onModuleDestroy() {
+    this.graph.destroy();
+  }
+};
+var GraphReflyRequestLifecycle = class {
+  graph = new Graph("request");
+  onModuleDestroy() {
+    this.graph.destroy();
+  }
+};
+var _GraphReflyModule_decorators, _init;
+_GraphReflyModule_decorators = [Module({})];
+var _GraphReflyModule = class _GraphReflyModule {
+  /**
+   * Register the root `Graph` singleton in the NestJS DI container.
+   *
+   * The root graph is `@Global()` — injectable everywhere without importing
+   * the module again. Use `@InjectGraph()` to inject it.
+   *
+   * Lifecycle:
+   * - **init:** Graph created in factory. If `build` is provided, it runs
+   *   first (registers nodes/mounts). If `snapshot` is provided, values
+   *   are restored via `graph.restore()`.
+   * - **destroy:** Calls `graph.destroy()` — sends `[[TEARDOWN]]` to all
+   *   nodes, including mounted feature subgraphs (cascading teardown).
+   */
+  static forRoot(opts) {
+    const options = opts ?? {};
+    const graphName = options.name ?? "root";
+    const providers = [
+      {
+        provide: GRAPHREFLY_ROOT_GRAPH,
+        useFactory: () => {
+          const g = new Graph(graphName);
+          if (options.build) options.build(g);
+          if (options.snapshot) g.restore(options.snapshot);
+          return g;
+        }
+      },
+      {
+        provide: /* @__PURE__ */ Symbol.for("graphrefly:root-lifecycle"),
+        useFactory: (graph) => new GraphReflyRootLifecycle(graph),
+        inject: [GRAPHREFLY_ROOT_GRAPH]
+      },
+      {
+        provide: GraphReflyEventExplorer,
+        useFactory: (graph, moduleRef) => new GraphReflyEventExplorer(graph, moduleRef),
+        inject: [GRAPHREFLY_ROOT_GRAPH, ModuleRef]
+      }
+    ];
+    if (options.nodes) {
+      for (const path of options.nodes) {
+        providers.push({
+          provide: getNodeToken(path),
+          useFactory: (graph) => graph.resolve(path),
+          inject: [GRAPHREFLY_ROOT_GRAPH]
+        });
+      }
+    }
+    if (options.requestScope) {
+      providers.push(
+        {
+          provide: /* @__PURE__ */ Symbol.for("graphrefly:request-lifecycle"),
+          useFactory: () => new GraphReflyRequestLifecycle(),
+          scope: Scope.REQUEST
+        },
+        {
+          provide: GRAPHREFLY_REQUEST_GRAPH,
+          useFactory: (lifecycle) => lifecycle.graph,
+          inject: [/* @__PURE__ */ Symbol.for("graphrefly:request-lifecycle")],
+          scope: Scope.REQUEST
+        }
+      );
+    }
+    return {
+      module: _GraphReflyModule,
+      global: true,
+      providers,
+      exports: [
+        GRAPHREFLY_ROOT_GRAPH,
+        ...(options.nodes ?? []).map(getNodeToken),
+        ...options.requestScope ? [GRAPHREFLY_REQUEST_GRAPH] : []
+      ]
+    };
+  }
+  /**
+   * Register a feature subgraph that auto-mounts into the root graph.
+   *
+   * The feature graph is created in the factory, built/restored, then
+   * mounted into root via `root.mount(name, featureGraph)`. On app
+   * shutdown, root's `graph.destroy()` cascades TEARDOWN through all
+   * mounted subgraphs (no explicit remove needed).
+   *
+   * Node tokens are auto-qualified as `featureName::path` to prevent
+   * collisions between features declaring nodes with the same local name.
+   *
+   * Injectable via `@InjectGraph(name)`.
+   */
+  static forFeature(opts) {
+    const providers = [
+      {
+        provide: getGraphToken(opts.name),
+        useFactory: (rootGraph) => {
+          const g = new Graph(opts.name);
+          if (opts.build) opts.build(g);
+          if (opts.snapshot) g.restore(opts.snapshot);
+          rootGraph.mount(opts.name, g);
+          return g;
+        },
+        inject: [GRAPHREFLY_ROOT_GRAPH]
+      }
+    ];
+    if (opts.nodes) {
+      for (const path of opts.nodes) {
+        providers.push({
+          provide: getNodeToken(`${opts.name}::${path}`),
+          useFactory: (graph) => graph.resolve(path),
+          inject: [getGraphToken(opts.name)]
+        });
+      }
+    }
+    return {
+      module: _GraphReflyModule,
+      providers,
+      exports: [
+        getGraphToken(opts.name),
+        ...(opts.nodes ?? []).map((p) => getNodeToken(`${opts.name}::${p}`))
+      ]
+    };
+  }
+  /**
+   * Register a CQRS subgraph that auto-mounts into the root graph.
+   *
+   * Creates a `CqrsGraph` via the `cqrs()` factory (roadmap §4.5), mounts it
+   * into the root graph, and exposes it for DI via `@InjectGraph(name)`.
+   *
+   * CQRS decorators (`@CommandHandler`, `@EventHandler`, `@QueryHandler`,
+   * `@SagaHandler`) are discovered by the explorer and wired to this graph
+   * on module init.
+   *
+   * @example
+   * ```ts
+   * GraphReflyModule.forCqrs({
+   *   name: "orders",
+   *   build: (g) => {
+   *     g.event("orderPlaced");
+   *     g.projection("orderCount", ["orderPlaced"], (_s, evts) => evts.length, 0);
+   *   },
+   * })
+   * ```
+   */
+  static forCqrs(opts) {
+    const providers = [
+      {
+        provide: getGraphToken(opts.name),
+        useFactory: (rootGraph) => {
+          const g = cqrs(opts.name, opts.cqrs);
+          if (opts.eventStore) g.useEventStore(opts.eventStore);
+          if (opts.build) opts.build(g);
+          rootGraph.mount(opts.name, g);
+          return g;
+        },
+        inject: [GRAPHREFLY_ROOT_GRAPH]
+      }
+    ];
+    if (opts.nodes) {
+      for (const path of opts.nodes) {
+        providers.push({
+          provide: getNodeToken(`${opts.name}::${path}`),
+          useFactory: (graph) => graph.resolve(path),
+          inject: [getGraphToken(opts.name)]
+        });
+      }
+    }
+    return {
+      module: _GraphReflyModule,
+      providers,
+      exports: [
+        getGraphToken(opts.name),
+        ...(opts.nodes ?? []).map((p) => getNodeToken(`${opts.name}::${p}`))
+      ]
+    };
+  }
+};
+_init = __decoratorStart(null);
+_GraphReflyModule = __decorateElement(_init, 0, "GraphReflyModule", _GraphReflyModule_decorators, _GraphReflyModule);
+__runInitializers(_init, 1, _GraphReflyModule);
+var GraphReflyModule = _GraphReflyModule;
+
+export {
+  GRAPHREFLY_ROOT_GRAPH,
+  GRAPHREFLY_REQUEST_GRAPH,
+  getGraphToken,
+  getNodeToken,
+  EVENT_HANDLERS,
+  INTERVAL_HANDLERS,
+  CRON_HANDLERS,
+  COMMAND_HANDLERS,
+  CQRS_EVENT_HANDLERS,
+  QUERY_HANDLERS,
+  SAGA_HANDLERS,
+  InjectGraph,
+  InjectCqrsGraph,
+  InjectNode,
+  OnGraphEvent,
+  GraphInterval,
+  GraphCron,
+  CommandHandler,
+  EventHandler,
+  QueryHandler,
+  SagaHandler,
+  GraphReflyEventExplorer,
+  observeSSE,
+  observeSubscription,
+  ObserveGateway,
+  ACTOR_KEY,
+  fromJwtPayload,
+  fromHeader,
+  getActor,
+  GraphReflyGuardImpl,
+  GraphReflyGuard,
+  cqrs_exports,
+  GraphReflyModule,
+  nestjs_exports
+};
+//# sourceMappingURL=chunk-QW7H3ICI.js.map