@graphrefly/ts 0.0.1 → 0.0.2

package/dist/chunk-MQEQMS7B.js

@@ -0,0 +1,1009 @@
+// src/adapters/nestjs.ts
+var NEST_BOUNDARY_ENVELOPE_VERSION = 1;
+var NEST_BOUNDARY_PAYLOAD_MAX_BYTES = 64 * 1024;
+var NEST_HTTP_DIAGNOSTICS_MAX_RETAINED = 100;
+var GRAPHREFLY_ROOT_GRAPH = /* @__PURE__ */ Symbol.for("graphrefly:root-graph");
+var GRAPHREFLY_MODULE_OPTIONS = /* @__PURE__ */ Symbol.for("graphrefly:module-options");
+var GRAPHREFLY_REQUEST_GRAPH = /* @__PURE__ */ Symbol.for("graphrefly:request-graph");
+var EVENT_HANDLERS = /* @__PURE__ */ new WeakMap();
+var INTERVAL_HANDLERS = /* @__PURE__ */ new WeakMap();
+var CRON_HANDLERS = /* @__PURE__ */ new WeakMap();
+var NEST_BOUNDARY_BINDINGS = /* @__PURE__ */ new WeakMap();
+function getGraphToken(name) {
+  assertNonEmptyString(name, "getGraphToken(name)");
+  return /* @__PURE__ */ Symbol.for(`graphrefly:graph:${name}`);
+}
+function getNodeToken(path) {
+  assertNonEmptyString(path, "getNodeToken(path)");
+  return /* @__PURE__ */ Symbol.for(`graphrefly:node:${path}`);
+}
+function getNestBoundaryToken(bindingId) {
+  assertNonEmptyString(bindingId, "getNestBoundaryToken(bindingId)");
+  return /* @__PURE__ */ Symbol.for(`graphrefly:nest-boundary:${bindingId}`);
+}
+function nestProvider(provide, useValue) {
+  return { provide, useValue };
+}
+function fromNestReq(graph, opts = {}) {
+  return nestIngress(graph, "request", opts);
+}
+function fromNestGuard(graph, opts = {}) {
+  return nestIngress(graph, "guard", opts);
+}
+function fromNestIntercept(graph, opts = {}) {
+  return nestIngress(graph, "interceptor", opts);
+}
+function fromNestError(graph, opts = {}) {
+  return nestIngress(graph, "error", opts);
+}
+function fromNestLifecycle(graph, opts = {}) {
+  return nestIngress(graph, "lifecycle", opts);
+}
+function fromNestCron(graph, opts = {}) {
+  return nestIngress(graph, "cron", opts);
+}
+function fromNestDiagnostics(graph, opts = {}) {
+  return nestIngress(graph, "diagnostics", {
+    ...opts,
+    payload: (diagnostic) => sanitizeNestDiagnostic(diagnostic, opts.phase)
+  });
+}
+function fromNestWs(graph, opts = {}) {
+  return nestIngress(graph, "ws", opts);
+}
+function fromNestMessage(graph, opts = {}) {
+  return nestIngress(graph, "message", opts);
+}
+function toNestHttp(egress, opts = {}) {
+  const bindingId = stableBindingId("http", opts);
+  const scopedBindingId = opts.bindingId;
+  const maxDiagnostics = diagnosticsRetainedLimit(opts.maxDiagnostics);
+  const maxPayloadBytes = payloadByteLimit(opts.maxPayloadBytes);
+  const pending = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  let active = true;
+  let terminal;
+  const report = (diagnostic) => {
+    pushDiagnostic(diagnostics, diagnostic, maxDiagnostics);
+    try {
+      const phase = diagnostic.phase ?? opts.diagnosticPhase ?? "http";
+      const payload = sanitizeNestDiagnostic({ ...diagnostic, phase }, phase);
+      opts.diagnosticBoundary?.emit(payload, { payload });
+    } catch {
+    }
+  };
+  const keyOf = (requestId, requestBindingId) => requestBindingId === void 0 ? requestId : `${requestBindingId}\0${requestId}`;
+  const rejectEntry = (entry, error, envelope, message) => {
+    try {
+      entry.handle.reject(error, envelope);
+    } catch (rejectError) {
+      report({
+        kind: "reject-threw",
+        requestId: entry.requestId,
+        bindingId: entry.bindingId,
+        message,
+        error: rejectError
+      });
+    }
+  };
+  const rejectPending = (kind, error, message) => {
+    const entries = [...pending.values()];
+    pending.clear();
+    if (entries.length === 0) return 0;
+    report({ kind, bindingId: scopedBindingId, message, error });
+    for (const entry of entries) {
+      rejectEntry(entry, error, void 0, `toNestHttp(${bindingId}) pending reject threw`);
+    }
+    return entries.length;
+  };
+  const unsubscribe = egress.subscribe((msg) => {
+    if (!active) return;
+    if (msg[0] === "ERROR" || msg[0] === "COMPLETE" || msg[0] === "TEARDOWN") {
+      const error = msg[0] === "ERROR" ? msg[1] : new Error(`toNestHttp(${bindingId}) egress received ${msg[0]}`);
+      const message = `toNestHttp(${bindingId}) rejected pending requests after ${msg[0]}`;
+      terminal = { error, message };
+      const rejectedCount = rejectPending("terminal-egress", error, message);
+      if (rejectedCount === 0)
+        report({ kind: "terminal-egress", bindingId: scopedBindingId, message, error });
+      return;
+    }
+    if (msg[0] !== "DATA") return;
+    const envelope = msg[1];
+    const malformed = validateEnvelope(envelope, maxPayloadBytes);
+    if (malformed !== void 0) {
+      const correlated = malformedCorrelation(msg[1], scopedBindingId);
+      if (correlated !== void 0) {
+        const pendingKey2 = keyOf(correlated.requestId, scopedBindingId);
+        const entry2 = pending.get(pendingKey2);
+        if (entry2 !== void 0) {
+          pending.delete(pendingKey2);
+          rejectEntry(
+            entry2,
+            new Error(malformed),
+            void 0,
+            `toNestHttp(${bindingId}) rejected malformed correlated egress`
+          );
+        }
+      }
+      report({
+        kind: "malformed-egress",
+        requestId: correlated?.requestId,
+        bindingId: correlated?.bindingId,
+        message: malformed
+      });
+      return;
+    }
+    if (scopedBindingId !== void 0 && envelope.bindingId !== scopedBindingId) {
+      report({
+        kind: "binding-mismatch",
+        requestId: envelope.requestId,
+        bindingId: envelope.bindingId,
+        expectedBindingId: scopedBindingId,
+        message: `toNestHttp(${bindingId}) ignored egress for binding ${envelope.bindingId}`
+      });
+      return;
+    }
+    const pendingKey = keyOf(envelope.requestId, scopedBindingId);
+    const entry = pending.get(pendingKey);
+    if (entry === void 0) {
+      report({
+        kind: "stale-egress",
+        requestId: envelope.requestId,
+        bindingId: envelope.bindingId,
+        message: `toNestHttp(${bindingId}) ignored stale requestId ${envelope.requestId}`
+      });
+      return;
+    }
+    pending.delete(pendingKey);
+    try {
+      entry.handle.resolve(
+        opts.transform?.(envelope.payload, envelope) ?? envelope.payload,
+        envelope
+      );
+    } catch (error) {
+      report({
+        kind: "resolve-threw",
+        requestId: envelope.requestId,
+        bindingId: envelope.bindingId,
+        message: `toNestHttp(${bindingId}) response handle threw while resolving`,
+        error
+      });
+      rejectEntry(
+        entry,
+        error,
+        envelope,
+        `toNestHttp(${bindingId}) response handle threw while rejecting`
+      );
+    }
+  });
+  return {
+    kind: "http",
+    bindingId,
+    attach(registration) {
+      if (!active) throw new Error(`toNestHttp(${bindingId}) is disposed`);
+      assertNonEmptyString(registration.requestId, "toNestHttp.attach(requestId)");
+      const registrationBindingId = registration.bindingId ?? scopedBindingId;
+      if (scopedBindingId !== void 0 && registrationBindingId !== scopedBindingId) {
+        throw new Error(
+          `toNestHttp.attach expected bindingId ${scopedBindingId}, got ${registrationBindingId}`
+        );
+      }
+      if (terminal !== void 0) {
+        const entry2 = {
+          requestId: registration.requestId,
+          bindingId: registrationBindingId,
+          handle: registration.handle
+        };
+        report({
+          kind: "terminal-egress",
+          requestId: registration.requestId,
+          bindingId: registrationBindingId,
+          message: terminal.message,
+          error: terminal.error
+        });
+        rejectEntry(
+          entry2,
+          terminal.error,
+          void 0,
+          `toNestHttp(${bindingId}) terminal response handle reject threw`
+        );
+        return () => false;
+      }
+      const key = keyOf(registration.requestId, scopedBindingId);
+      if (pending.has(key)) {
+        throw new Error(`toNestHttp.attach duplicate pending requestId ${registration.requestId}`);
+      }
+      const entry = {
+        requestId: registration.requestId,
+        bindingId: registrationBindingId,
+        handle: registration.handle
+      };
+      pending.set(key, entry);
+      return () => {
+        if (pending.get(key) !== entry) return false;
+        return pending.delete(key);
+      };
+    },
+    pendingCount: () => pending.size,
+    diagnostics: () => diagnostics.slice(),
+    dispose() {
+      if (!active) return;
+      active = false;
+      rejectPending(
+        "dispose-pending",
+        new Error(`toNestHttp(${bindingId}) disposed before response resolution`),
+        `toNestHttp(${bindingId}) rejected pending requests during dispose`
+      );
+      unsubscribe();
+    }
+  };
+}
+function GraphReq(boundary, opts = {}) {
+  return graphIngressBinding("request", boundary, opts);
+}
+function GraphGuard(boundary, opts = {}) {
+  return graphIngressBinding("guard", boundary, opts);
+}
+function GraphIntercept(boundary, opts = {}) {
+  return graphIngressBinding("interceptor", boundary, opts);
+}
+function GraphFilter(boundary, opts = {}) {
+  return graphIngressBinding("error", boundary, opts);
+}
+function GraphError(boundary, opts = {}) {
+  return GraphFilter(boundary, opts);
+}
+function GraphLifecycle(boundary, opts = {}) {
+  return graphIngressBinding("lifecycle", boundary, opts);
+}
+function GraphCron(boundary, opts = {}) {
+  return graphIngressBinding("cron", boundary, opts);
+}
+function GraphWs(boundary, opts = {}) {
+  return graphIngressBinding("ws", boundary, opts);
+}
+function GraphMessage(boundary, opts = {}) {
+  return graphIngressBinding("message", boundary, opts);
+}
+function GraphHttpReply(replyNode, opts) {
+  const bindingId = opts?.bindingId;
+  if (typeof bindingId !== "string" || bindingId.length === 0) {
+    throw new Error("GraphHttpReply requires a non-empty bindingId");
+  }
+  return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => ({
+    direction: "egress",
+    kind: "http",
+    bindingId,
+    methodKey,
+    replyNode,
+    order: opts.order,
+    issueResponse: opts.issueResponse,
+    protocolError: opts.protocolError
+  }));
+}
+function GraphGuardDecision(decisionNode, opts) {
+  const bindingId = opts?.bindingId;
+  if (typeof bindingId !== "string" || bindingId.length === 0) {
+    throw new Error("GraphGuardDecision requires a non-empty bindingId");
+  }
+  return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => ({
+    direction: "egress",
+    kind: "guard-decision",
+    bindingId,
+    methodKey,
+    decisionNode,
+    order: opts.order,
+    issueResponse: opts.issueResponse,
+    protocolError: opts.protocolError
+  }));
+}
+function GraphWsAck(ackNode, opts) {
+  return graphReplyBinding("ws-ack", ackNode, opts, "GraphWsAck");
+}
+function GraphWsReply(replyNode, opts) {
+  return graphReplyBinding("ws-reply", replyNode, opts, "GraphWsReply");
+}
+function GraphMessageReply(replyNode, opts) {
+  return graphReplyBinding("message-reply", replyNode, opts, "GraphMessageReply");
+}
+function createNestGraphBoundaryRunner(opts = {}) {
+  const httpBoundaries = /* @__PURE__ */ new Map();
+  const httpBoundaryFor = (node, bindingId) => {
+    let byBinding = httpBoundaries.get(node);
+    if (byBinding === void 0) {
+      byBinding = /* @__PURE__ */ new Map();
+      httpBoundaries.set(node, byBinding);
+    }
+    let boundary = byBinding.get(bindingId);
+    if (boundary === void 0) {
+      boundary = toNestHttp(node, {
+        bindingId,
+        diagnosticBoundary: opts.diagnosticBoundary,
+        diagnosticPhase: opts.diagnosticPhase ?? "http"
+      });
+      byBinding.set(bindingId, boundary);
+    }
+    return boundary;
+  };
+  return {
+    run(target, methodKey, host, opts2 = {}) {
+      const ctor = typeof target === "function" ? target : target.constructor;
+      const bindings = getNestBoundaryBindings(ctor, methodKey);
+      if (bindings.length === 0) return void 0;
+      const requestId = requestIdFromRunOptions(host, opts2);
+      const replies = bindings.filter(isHttpReplyBinding);
+      const ingress = bindings.filter(
+        (binding) => binding.direction === "ingress" && (binding.kind === "request" || binding.kind === "interceptor")
+      );
+      if (replies.length > 0 && ingress.length === 0) {
+        throw new Error("Nest GraphHttpReply requires at least one ingress boundary");
+      }
+      const ingressEmits = ingress.map((binding) => ({
+        binding,
+        requestId: requestIdFromBinding(host, binding) ?? requestId
+      }));
+      const replyRequestIds = uniqueDefinedStrings(ingressEmits.map((entry) => entry.requestId));
+      if (replies.length > 0 && replyRequestIds.length === 0) {
+        throw new Error("Nest GraphHttpReply requires a stable requestId");
+      }
+      const cleanups = [];
+      let resolveReply;
+      let rejectReply;
+      const replyPromise = replies.length === 0 ? void 0 : new Promise((resolve, reject) => {
+        resolveReply = resolve;
+        rejectReply = reject;
+      });
+      try {
+        for (const reply of replies) {
+          const http = httpBoundaryFor(reply.replyNode, reply.bindingId);
+          for (const replyRequestId of replyRequestIds) {
+            cleanups.push(
+              http.attach({
+                requestId: replyRequestId,
+                bindingId: reply.bindingId,
+                handle: {
+                  resolve: resolveReply ?? (() => void 0),
+                  reject: rejectReply ?? (() => void 0)
+                }
+              })
+            );
+          }
+        }
+        for (const entry of ingressEmits) {
+          entry.binding.boundary.emit(host, {
+            bindingId: entry.binding.bindingId,
+            requestId: entry.requestId,
+            ...bindingPayloadEmitOption(host, entry.binding),
+            requireRequestId: requiresRequestId(entry.binding.kind)
+          });
+        }
+      } catch (error) {
+        for (const cleanup of cleanups) cleanup();
+        throw error;
+      }
+      return replyPromise?.finally(() => {
+        for (const cleanup of cleanups) cleanup();
+      });
+    },
+    dispose() {
+      for (const byBinding of httpBoundaries.values()) {
+        for (const boundary of byBinding.values()) boundary.dispose();
+      }
+      httpBoundaries.clear();
+    }
+  };
+}
+function createNestGraphBoundaryInterceptor(opts = {}) {
+  const runner = opts.runner ?? createNestGraphBoundaryRunner(opts);
+  let nextRequestSeq = 1;
+  return {
+    intercept(context, next) {
+      const ctor = context.getClass();
+      const handler = context.getHandler();
+      const methodKey = methodKeyForHandler(ctor, handler);
+      if (methodKey === void 0) return next?.handle();
+      const bindings = getNestBoundaryBindings(ctor, methodKey);
+      const needsSyntheticRequestId = bindings.some(
+        (binding) => binding.direction === "egress" || binding.direction === "ingress" && requiresRequestId(binding.kind)
+      );
+      const host = opts.host?.(context) ?? defaultNestHttpHost(context, () => nextRequestSeq++, needsSyntheticRequestId) ?? {};
+      const result = runner.run(ctor, methodKey, host, opts);
+      return result ?? next?.handle();
+    },
+    dispose() {
+      runner.dispose();
+    }
+  };
+}
+function getNestBoundaryBindings(target, methodKey) {
+  const ctor = typeof target === "function" ? target : target.constructor;
+  const bindings = boundaryBindingsFor(ctor);
+  return sortBoundaryBindings(
+    methodKey === void 0 ? bindings : bindings.filter((binding) => binding.methodKey === methodKey)
+  );
+}
+function resolveNestMethodKey(ctor, handler) {
+  return methodKeyForHandler(ctor, handler);
+}
+function bindingRequestId(host, binding, fallback) {
+  if (binding.direction === "ingress") {
+    const requestId = requestIdFromBinding(host, binding);
+    if (requestId !== void 0) return requestId;
+  }
+  if (typeof fallback === "string") {
+    assertNonEmptyString(fallback, "requestId");
+    return fallback;
+  }
+  if (typeof fallback === "function") {
+    const requestId = fallback(host);
+    if (requestId !== void 0) assertNonEmptyString(requestId, "requestId");
+    return requestId;
+  }
+  return requestIdOf(host, {}, {});
+}
+function bindingEmitOptions(host, binding, requestId) {
+  return {
+    bindingId: binding.bindingId,
+    requestId,
+    ...bindingPayloadEmitOption(host, binding),
+    requireRequestId: requiresRequestId(binding.kind)
+  };
+}
+function isDataIssue(value) {
+  return value !== null && typeof value === "object" && value.kind === "issue" && typeof value.code === "string" && typeof value.message === "string";
+}
+function isHttpDataIssue(value) {
+  return isDataIssue(value) && Number.isInteger(value.status);
+}
+function issueResponse(issue, _host) {
+  if (isHttpDataIssue(issue)) {
+    return {
+      status: issue.status,
+      body: issue.body ?? { code: issue.code, message: issue.message },
+      headers: issue.headers
+    };
+  }
+  return {
+    status: 400,
+    body: { code: issue.code, message: issue.message }
+  };
+}
+function protocolError(_errorPayload, _host) {
+  return {
+    status: 500,
+    body: { code: "graphrefly.protocol_error", message: "GraphReFly reply pipeline failed" }
+  };
+}
+function lowerHttpReplyPayload(payload, host, opts = {}) {
+  if (isHttpResponsePayload(payload)) return payload;
+  if (isDataIssue(payload)) return (opts.issueResponse ?? issueResponse)(payload, host);
+  return { status: 200, body: payload };
+}
+function lowerProtocolError(errorPayload, host, opts = {}) {
+  return (opts.protocolError ?? protocolError)(errorPayload, host);
+}
+function sanitizeNestDiagnostic(diagnostic, defaultPhase = "adapter") {
+  const payload = {
+    kind: diagnostic.kind,
+    phase: diagnostic.phase ?? defaultPhase,
+    message: diagnostic.message,
+    ...optionalStringField("requestId", diagnostic.requestId),
+    ...optionalStringField("bindingId", diagnostic.bindingId),
+    ...optionalStringField("expectedBindingId", diagnostic.expectedBindingId),
+    ...optionalDiagnosticError(diagnostic.error)
+  };
+  assertGraphVisibleData(payload, "NestDiagnosticPayload", NEST_BOUNDARY_PAYLOAD_MAX_BYTES);
+  return payload;
+}
+function nestIngress(graph, kind, opts) {
+  const bindingId = stableBindingId(kind, opts);
+  const version = parseEnvelopeVersion(opts.version ?? NEST_BOUNDARY_ENVELOPE_VERSION, "version");
+  const maxPayloadBytes = payloadByteLimit(opts.maxPayloadBytes);
+  const node = graph.node([], null, {
+    name: opts.name,
+    meta: { adapter: "nestjs", boundary: "ingress", kind, bindingId, version }
+  });
+  return {
+    kind,
+    bindingId,
+    version,
+    node,
+    envelope(host, emitOpts = {}) {
+      const requestId = requestIdOf(host, opts, {
+        ...emitOpts,
+        requireRequestId: emitOpts.requireRequestId ?? opts.requireRequestId ?? requiresRequestId(kind)
+      });
+      const envelopeBindingId = emitOpts.bindingId ?? bindingId;
+      assertNonEmptyString(envelopeBindingId, "NestBoundaryEnvelope.bindingId");
+      const envelopeVersion = parseEnvelopeVersion(
+        emitOpts.version ?? version,
+        "NestBoundaryEnvelope.version"
+      );
+      const payload = "payload" in emitOpts ? emitOpts.payload : opts.payload !== void 0 ? opts.payload(host) : host;
+      assertGraphVisibleData(payload, "NestBoundaryEnvelope.payload", maxPayloadBytes);
+      const envelope = {
+        bindingId: envelopeBindingId,
+        version: envelopeVersion,
+        payload
+      };
+      return requestId === void 0 ? envelope : { ...envelope, requestId };
+    },
+    emit(host, emitOpts = {}) {
+      const envelope = this.envelope(host, emitOpts);
+      node.down([["DATA", envelope]]);
+      return envelope;
+    }
+  };
+}
+function stableBindingId(kind, opts) {
+  const bindingId = opts.bindingId ?? opts.name ?? `nestjs.${kind}`;
+  assertNonEmptyString(bindingId, "bindingId");
+  return bindingId;
+}
+function requiresRequestId(kind) {
+  return kind === "request" || kind === "guard" || kind === "interceptor" || kind === "error";
+}
+function requestIdFromRunOptions(host, opts) {
+  if (typeof opts.requestId === "string") {
+    assertNonEmptyString(opts.requestId, "requestId");
+    return opts.requestId;
+  }
+  if (typeof opts.requestId === "function") {
+    const requestId = opts.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString(requestId, "requestId");
+    return requestId;
+  }
+  return requestIdOf(host, {}, {});
+}
+function requestIdFromBinding(host, binding) {
+  if (typeof binding.requestId === "string") {
+    assertNonEmptyString(binding.requestId, "requestId");
+    return binding.requestId;
+  }
+  if (typeof binding.requestId === "function") {
+    const requestId = binding.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString(requestId, "requestId");
+    return requestId;
+  }
+  return void 0;
+}
+function bindingPayloadEmitOption(host, binding) {
+  return binding.payload === void 0 ? {} : { payload: binding.payload(host) };
+}
+function isHttpResponsePayload(value) {
+  if (value === null || typeof value !== "object") return false;
+  const status = value.status;
+  if (!Number.isInteger(status)) return false;
+  const headers = value.headers;
+  return headers === void 0 || isStringRecord(headers);
+}
+function isStringRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  for (const entry of Object.values(value)) if (typeof entry !== "string") return false;
+  return true;
+}
+function isHttpReplyBinding(binding) {
+  return binding.direction === "egress" && binding.kind === "http";
+}
+function uniqueDefinedStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (value !== void 0) seen.add(value);
+  }
+  return [...seen];
+}
+function defaultNestHttpHost(context, nextSeq, needsSyntheticRequestId) {
+  const request = context.switchToHttp?.().getRequest();
+  if (request === void 0 || request === null || typeof request !== "object") return request;
+  if (requestIdFromRecord(request) !== void 0) return request;
+  const headerId = requestIdFromHeaders(request.headers);
+  if (headerId !== void 0 || needsSyntheticRequestId) {
+    return { ...request, requestId: headerId ?? `nestjs-request:${nextSeq()}` };
+  }
+  return request;
+}
+function requestIdFromRecord(record) {
+  for (const key of ["requestId", "id"]) {
+    const value = record[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
+}
+function requestIdFromHeaders(headers) {
+  if (headers === null || typeof headers !== "object") return void 0;
+  for (const key of ["x-request-id", "x-correlation-id"]) {
+    const value = headers[key];
+    const first = Array.isArray(value) ? value[0] : value;
+    if (typeof first === "string" && first.trim().length > 0) return first.trim();
+  }
+  return void 0;
+}
+function graphIngressBinding(kind, boundary, opts) {
+  if (boundary.kind !== kind) {
+    throw new Error(`Graph${kind} expected a ${kind} boundary, got ${boundary.kind}`);
+  }
+  const bindingId = opts.bindingId ?? boundary.bindingId;
+  assertNonEmptyString(bindingId, "bindingId");
+  return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => ({
+    direction: "ingress",
+    kind,
+    bindingId,
+    methodKey,
+    boundary,
+    payload: opts.payload,
+    requestId: opts.requestId,
+    order: opts.order,
+    mode: opts.mode,
+    issueResponse: opts.issueResponse,
+    protocolError: opts.protocolError
+  }));
+}
+function graphReplyBinding(kind, node, opts, decoratorName) {
+  const bindingId = opts?.bindingId;
+  if (typeof bindingId !== "string" || bindingId.length === 0) {
+    throw new Error(`${decoratorName} requires a non-empty bindingId`);
+  }
+  const replyNode = node;
+  return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => {
+    if (kind === "ws-ack") {
+      return {
+        direction: "egress",
+        kind,
+        bindingId,
+        methodKey,
+        ackNode: replyNode,
+        order: opts.order
+      };
+    }
+    return {
+      direction: "egress",
+      kind,
+      bindingId,
+      methodKey,
+      replyNode,
+      order: opts.order
+    };
+  });
+}
+function methodKeyForHandler(ctor, handler) {
+  for (const binding of boundaryBindingsFor(ctor)) {
+    const candidate = methodOnPrototypeChain(ctor, binding.methodKey);
+    if (candidate === handler || String(binding.methodKey) === handler.name)
+      return binding.methodKey;
+  }
+  return void 0;
+}
+function boundaryBindingsFor(ctor) {
+  const bindings = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = ctor;
+  while (typeof current === "function" && current !== Function.prototype) {
+    for (const binding of NEST_BOUNDARY_BINDINGS.get(current) ?? []) {
+      if (seen.has(binding)) continue;
+      seen.add(binding);
+      bindings.push(binding);
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return bindings;
+}
+function sortBoundaryBindings(bindings) {
+  return bindings.map((binding, index) => ({ binding, index })).sort((a, b) => (a.binding.order ?? 0) - (b.binding.order ?? 0) || a.index - b.index).map(({ binding }) => binding);
+}
+function methodOnPrototypeChain(ctor, methodKey) {
+  let proto = ctor.prototype;
+  while (proto !== null && typeof proto === "object") {
+    if (Object.hasOwn(proto, methodKey)) {
+      return proto[methodKey];
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function requestIdOf(host, opts, emitOpts) {
+  const fromEmit = emitOpts.requestId;
+  if (fromEmit !== void 0) {
+    assertNonEmptyString(fromEmit, "requestId");
+    return fromEmit;
+  }
+  if (typeof opts.requestId === "string") {
+    assertNonEmptyString(opts.requestId, "requestId");
+    return opts.requestId;
+  }
+  if (typeof opts.requestId === "function") {
+    const requestId = opts.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString(requestId, "requestId");
+    return requestId;
+  }
+  const record = host;
+  if (typeof record?.requestId === "string" && record.requestId.length > 0) return record.requestId;
+  if (typeof record?.id === "string" && record.id.length > 0) return record.id;
+  if (emitOpts.requireRequestId ?? opts.requireRequestId ?? false) {
+    throw new Error("Nest boundary ingress requires a stable requestId");
+  }
+  return void 0;
+}
+function validateEnvelope(value, maxPayloadBytes) {
+  try {
+    assertGraphVisibleData(value, "NestBoundaryEnvelope", maxPayloadBytes);
+  } catch (error) {
+    return error instanceof Error ? error.message : "egress envelope must be data-only material";
+  }
+  if (value === null || typeof value !== "object") return "egress DATA is not an envelope object";
+  const envelope = value;
+  if (typeof envelope.requestId !== "string" || envelope.requestId.length === 0) {
+    return "egress envelope requestId must be a non-empty string";
+  }
+  if (typeof envelope.bindingId !== "string" || envelope.bindingId.length === 0) {
+    return "egress envelope bindingId must be a non-empty string";
+  }
+  try {
+    parseEnvelopeVersion(envelope.version, "egress envelope version");
+  } catch {
+    return `egress envelope version must be ${NEST_BOUNDARY_ENVELOPE_VERSION}`;
+  }
+  return void 0;
+}
+function malformedCorrelation(value, scopedBindingId) {
+  if (value === null || typeof value !== "object") return void 0;
+  const requestId = value.requestId;
+  const bindingId = value.bindingId;
+  if (typeof requestId !== "string" || requestId.length === 0) return void 0;
+  if (typeof bindingId !== "string" || bindingId.length === 0) return void 0;
+  if (scopedBindingId !== void 0 && bindingId !== scopedBindingId) return void 0;
+  return { requestId, bindingId };
+}
+function parseEnvelopeVersion(value, label) {
+  if (value !== NEST_BOUNDARY_ENVELOPE_VERSION) {
+    throw new Error(`${label} must be ${NEST_BOUNDARY_ENVELOPE_VERSION}`);
+  }
+  return value;
+}
+function assertNonEmptyString(value, label) {
+  if (value.length === 0) throw new Error(`${label} must be a non-empty string`);
+}
+function optionalStringField(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function optionalDiagnosticError(error) {
+  const summarized = summarizeDiagnosticError(error);
+  return summarized === void 0 ? {} : { error: summarized };
+}
+function summarizeDiagnosticError(error) {
+  if (error === void 0) return void 0;
+  if (error instanceof Error) {
+    return {
+      ...optionalDiagnosticName(safeDiagnosticString(() => error.name)),
+      message: safeDiagnosticString(() => error.message) ?? "diagnostic error"
+    };
+  }
+  if (typeof error === "string") return { message: error };
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+    return { message: String(error) };
+  }
+  if (typeof error === "symbol") return { message: error.description ?? "symbol" };
+  if (typeof error === "function") return { message: "opaque diagnostic function" };
+  if (error !== null && typeof error === "object") {
+    const record = error;
+    const message = safeDiagnosticString(() => record.message);
+    if (message !== void 0) {
+      return {
+        ...optionalDiagnosticName(safeDiagnosticString(() => record.name)),
+        message
+      };
+    }
+    return { message: "opaque diagnostic error" };
+  }
+  return { message: String(error) };
+}
+function safeDiagnosticString(read) {
+  try {
+    const value = read();
+    return typeof value === "string" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function optionalDiagnosticName(name) {
+  return name === void 0 || name.length === 0 ? {} : { name };
+}
+function payloadByteLimit(value) {
+  if (value === void 0) return NEST_BOUNDARY_PAYLOAD_MAX_BYTES;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error("Nest boundary maxPayloadBytes must be a positive safe integer");
+  }
+  return value;
+}
+function diagnosticsRetainedLimit(value) {
+  if (value === void 0) return NEST_HTTP_DIAGNOSTICS_MAX_RETAINED;
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("toNestHttp maxDiagnostics must be a non-negative safe integer");
+  }
+  return value;
+}
+function pushDiagnostic(diagnostics, diagnostic, maxDiagnostics) {
+  if (maxDiagnostics === 0) return;
+  diagnostics.push(diagnostic);
+  if (diagnostics.length > maxDiagnostics)
+    diagnostics.splice(0, diagnostics.length - maxDiagnostics);
+}
+function assertGraphVisibleData(value, path, maxPayloadBytes, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === void 0) {
+    throw new TypeError(`${path} cannot be undefined; undefined is SENTINEL/no DATA`);
+  }
+  if (value === null) return;
+  const type = typeof value;
+  if (type === "string" || type === "boolean") return;
+  if (type === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`${path} number must be finite`);
+    return;
+  }
+  if (type === "function" || type === "symbol" || type === "bigint") {
+    throw new TypeError(`${path} must be data-only; found ${type}`);
+  }
+  if (type !== "object") return;
+  if (seen.has(value)) throw new TypeError(`${path} must be acyclic data`);
+  seen.add(value);
+  if (Array.isArray(value)) {
+    try {
+      for (let i = 0; i < value.length; i += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, i);
+        if (descriptor === void 0) {
+          throw new TypeError(`${path}[${i}] cannot be a sparse array hole`);
+        }
+        if (!descriptor.enumerable || !("value" in descriptor)) {
+          throw new TypeError(`${path}[${i}] must be enumerable plain data`);
+        }
+        assertGraphVisibleData(descriptor.value, `${path}[${i}]`, maxPayloadBytes, seen);
+      }
+      for (const key of Reflect.ownKeys(value)) {
+        if (key === "length") continue;
+        if (typeof key === "symbol" || !/^(0|[1-9]\d*)$/.test(key)) {
+          throw new TypeError(`${path} arrays must not carry hidden or extra properties`);
+        }
+      }
+      assertPayloadSize(value, path, maxPayloadBytes);
+    } finally {
+      seen.delete(value);
+    }
+    return;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`${path} must be a plain data object or array`);
+  }
+  try {
+    for (const key of Reflect.ownKeys(value)) {
+      if (typeof key === "symbol") throw new TypeError(`${path} must not carry symbol keys`);
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0) continue;
+      if (!descriptor.enumerable || !("value" in descriptor)) {
+        throw new TypeError(`${path}.${key} must be enumerable plain data`);
+      }
+      assertGraphVisibleData(descriptor.value, `${path}.${key}`, maxPayloadBytes, seen);
+    }
+    assertPayloadSize(value, path, maxPayloadBytes);
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertPayloadSize(value, path, maxPayloadBytes) {
+  const serialized = JSON.stringify(value);
+  if (serialized !== void 0 && utf8ByteLength(serialized) > maxPayloadBytes) {
+    throw new TypeError(`${path} exceeds ${maxPayloadBytes} bytes`);
+  }
+}
+function utf8ByteLength(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 128) {
+      bytes += 1;
+    } else if (code < 2048) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i += 1;
+      } else {
+        bytes += 3;
+      }
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function sameMeta(a, b) {
+  const left = a;
+  const right = b;
+  const keys = Reflect.ownKeys(left);
+  if (keys.length !== Reflect.ownKeys(right).length) return false;
+  for (const key of keys) {
+    if (!Object.is(left[key], right[key])) return false;
+  }
+  return true;
+}
+function pushUniqueMeta(registry, ctor, item) {
+  const existing = registry.get(ctor) ?? [];
+  if (existing.some((current) => sameMeta(current, item))) return;
+  registry.set(ctor, [...existing, item]);
+}
+function registerMeta(registry, meta) {
+  return ((targetOrValue, contextOrKey) => {
+    if (typeof contextOrKey === "object" && contextOrKey !== null) {
+      const methodKey = contextOrKey.name;
+      contextOrKey.addInitializer(function() {
+        const ctor2 = this.constructor;
+        pushUniqueMeta(registry, ctor2, meta(methodKey));
+      });
+      return;
+    }
+    const ctor = targetOrValue.constructor;
+    pushUniqueMeta(registry, ctor, meta(contextOrKey));
+  });
+}
+function OnGraphEvent(nodeName) {
+  return registerMeta(EVENT_HANDLERS, (methodKey) => ({ nodeName, methodKey }));
+}
+function GraphInterval(ms) {
+  return registerMeta(INTERVAL_HANDLERS, (methodKey) => ({ ms, methodKey }));
+}
+
+export {
+  NEST_BOUNDARY_ENVELOPE_VERSION,
+  NEST_BOUNDARY_PAYLOAD_MAX_BYTES,
+  NEST_HTTP_DIAGNOSTICS_MAX_RETAINED,
+  GRAPHREFLY_ROOT_GRAPH,
+  GRAPHREFLY_MODULE_OPTIONS,
+  GRAPHREFLY_REQUEST_GRAPH,
+  EVENT_HANDLERS,
+  INTERVAL_HANDLERS,
+  CRON_HANDLERS,
+  NEST_BOUNDARY_BINDINGS,
+  getGraphToken,
+  getNodeToken,
+  getNestBoundaryToken,
+  nestProvider,
+  fromNestReq,
+  fromNestGuard,
+  fromNestIntercept,
+  fromNestError,
+  fromNestLifecycle,
+  fromNestCron,
+  fromNestDiagnostics,
+  fromNestWs,
+  fromNestMessage,
+  toNestHttp,
+  GraphReq,
+  GraphGuard,
+  GraphIntercept,
+  GraphFilter,
+  GraphError,
+  GraphLifecycle,
+  GraphCron,
+  GraphWs,
+  GraphMessage,
+  GraphHttpReply,
+  GraphGuardDecision,
+  GraphWsAck,
+  GraphWsReply,
+  GraphMessageReply,
+  createNestGraphBoundaryRunner,
+  createNestGraphBoundaryInterceptor,
+  getNestBoundaryBindings,
+  resolveNestMethodKey,
+  bindingRequestId,
+  bindingEmitOptions,
+  isDataIssue,
+  isHttpDataIssue,
+  issueResponse,
+  protocolError,
+  lowerHttpReplyPayload,
+  lowerProtocolError,
+  sanitizeNestDiagnostic,
+  OnGraphEvent,
+  GraphInterval
+};
+//# sourceMappingURL=chunk-MQEQMS7B.js.map