@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/chunk-LBAJK24K.js

@@ -0,0 +1,1071 @@
+import {
+  fromCron
+} from "./chunk-7EGRP2VX.js";
+import {
+  cqrs
+} from "./chunk-NY2PYHNC.js";
+import {
+  createWatermarkController,
+  toObservable
+} from "./chunk-3QZY5BI7.js";
+import {
+  __decorateElement,
+  __decoratorStart,
+  __export,
+  __runInitializers
+} from "./chunk-AZDQPQ3V.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,
+  observeSSE: () => observeSSE,
+  observeSubscription: () => observeSubscription,
+  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
+import { DATA } from "@graphrefly/pure-ts/core";
+import { fromTimer } from "@graphrefly/pure-ts/extra";
+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(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(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 existingEntries = eventNode.cache;
+    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 entries = m[1];
+          for (const entry of 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
+import {
+  COMPLETE,
+  DATA as DATA2,
+  ERROR,
+  TEARDOWN
+} from "@graphrefly/pure-ts/core";
+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 === DATA2) {
+            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 === DATA2) {
+        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 === DATA2) {
+          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
+import { DEFAULT_ACTOR, normalizeActor } from "@graphrefly/pure-ts/core";
+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 { Graph } from "@graphrefly/pure-ts/graph";
+import {
+  Module,
+  Scope
+} from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+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({ name: "orderCount", events: ["orderPlaced"], reducer: (_s, evts) => evts.length, initial: 0 });
+   *   },
+   * })
+   * ```
+   */
+  static forCqrs(opts) {
+    const providers = [
+      {
+        provide: getGraphToken(opts.name),
+        useFactory: (rootGraph) => {
+          const g = cqrs(opts.name, opts.cqrs);
+          if (opts.eventStorage) g.attachEventStorage(opts.eventStorage);
+          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,
+  GraphReflyModule,
+  nestjs_exports
+};
+//# sourceMappingURL=chunk-LBAJK24K.js.map