@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/chunk-DST5DKZS.js

@@ -1,1371 +0,0 @@
-import {
-  createWatermarkController,
-  toObservable
-} from "./chunk-OFVJBJXR.js";
-import {
-  domainMeta
-} from "./chunk-JSCT3CR4.js";
-import {
-  reactiveLog
-} from "./chunk-J2VBW3DZ.js";
-import {
-  fromCron,
-  fromTimer,
-  keepalive
-} from "./chunk-BVZYTZ5H.js";
-import {
-  Graph
-} from "./chunk-PF7GRZMW.js";
-import {
-  DEFAULT_ACTOR,
-  batch,
-  derived,
-  node,
-  normalizeActor,
-  policy,
-  state,
-  wallClockNs
-} from "./chunk-PHOUUNK7.js";
-import {
-  COMPLETE,
-  DATA,
-  ERROR,
-  TEARDOWN,
-  __decorateElement,
-  __decoratorStart,
-  __export,
-  __runInitializers
-} from "./chunk-SX52TAR4.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
-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 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
-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 domainMeta("cqrs", kind, extra);
-}
-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, versioning: 0 });
-    const entries = log.entries;
-    const guarded = derived(
-      [entries],
-      ([snapshot]) => snapshot,
-      {
-        name,
-        describeKind: "state",
-        meta: cqrsMeta("event", { event_name: name }),
-        guard: EVENT_GUARD,
-        initial: entries.cache
-      }
-    );
-    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 entries = snapshot;
-          allEvents.push(...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);
-    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, _actions) => {
-        const errNode = sagaRef.n.meta.error;
-        for (let i = 0; i < snapshots.length; i++) {
-          const batch2 = snapshots[i];
-          if (batch2 == null || batch2.length === 0) continue;
-          const entries = batch2.at(-1);
-          if (!entries) continue;
-          const eName = eventNames[i];
-          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);
-    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-DST5DKZS.js.map