@graphrefly/ts 0.0.1 → 0.0.2

package/dist/adapters/nestjs/native.cjs

@@ -0,0 +1,1391 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/nestjs/native.ts
+var native_exports = {};
+__export(native_exports, {
+  GRAPHREFLY_NEST_CRON_SCHEDULER: () => GRAPHREFLY_NEST_CRON_SCHEDULER,
+  GRAPHREFLY_NEST_EXCEPTION_FILTER: () => GRAPHREFLY_NEST_EXCEPTION_FILTER,
+  GRAPHREFLY_NEST_LIFECYCLE_HOOKS: () => GRAPHREFLY_NEST_LIFECYCLE_HOOKS,
+  GraphExceptionFilterBridge: () => GraphExceptionFilterBridge,
+  GraphGuardDeniedException: () => GraphGuardDeniedException,
+  GraphGuardDeniedFilter: () => GraphGuardDeniedFilter,
+  createGraphCronController: () => createGraphCronController,
+  createGraphExceptionFilter: () => createGraphExceptionFilter,
+  createGraphGuardDeniedFilter: () => createGraphGuardDeniedFilter,
+  graphCronTarget: () => graphCronTarget,
+  graphLifecycleTarget: () => graphLifecycleTarget,
+  isGraphGuardDeniedException: () => isGraphGuardDeniedException,
+  provideGraphBoundaryInterceptor: () => provideGraphBoundaryInterceptor,
+  provideGraphCronScheduler: () => provideGraphCronScheduler,
+  provideGraphExceptionFilter: () => provideGraphExceptionFilter,
+  provideGraphGuard: () => provideGraphGuard,
+  provideGraphGuardDeniedFilter: () => provideGraphGuardDeniedFilter,
+  provideGraphLifecycleHooks: () => provideGraphLifecycleHooks,
+  provideGraphNativeHttpProviders: () => provideGraphNativeHttpProviders,
+  provideGraphNativeProviders: () => provideGraphNativeProviders
+});
+module.exports = __toCommonJS(native_exports);
+var import_common = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_rxjs = require("rxjs");
+
+// src/graph/sources.ts
+function assertNonEmptyString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+}
+function parseCronField(field, min, max) {
+  if (field.length === 0) throw new Error("Invalid cron field: empty");
+  const out = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    if (part.length === 0) throw new Error(`Invalid cron field: ${field}`);
+    const stepParts = part.split("/");
+    if (stepParts.length > 2) throw new Error(`Invalid cron step: ${part}`);
+    const [range, stepText] = stepParts;
+    if (range == null || range.length === 0) throw new Error(`Invalid cron field: ${field}`);
+    if (stepText === "") throw new Error(`Invalid cron step: ${part}`);
+    const step = stepText == null ? 1 : parseCronInt(stepText, `Invalid cron step: ${part}`);
+    if (step < 1) throw new Error(`Invalid cron step: ${part}`);
+    let start;
+    let end;
+    if (range === "*") {
+      start = min;
+      end = max;
+    } else if (range.includes("-")) {
+      const [a, b, extra] = range.split("-");
+      if (extra !== void 0 || a === "" || b === "")
+        throw new Error(`Invalid cron field: ${field}`);
+      start = parseCronInt(a, `Invalid cron field: ${field}`);
+      end = parseCronInt(b, `Invalid cron field: ${field}`);
+    } else {
+      start = parseCronInt(range, `Invalid cron field: ${field}`);
+      end = start;
+    }
+    if (!Number.isInteger(start) || !Number.isInteger(end)) {
+      throw new Error(`Invalid cron field: ${field}`);
+    }
+    if (start < min || end > max) {
+      throw new RangeError(`Cron field out of range: ${field} (${min}-${max})`);
+    }
+    if (start > end) throw new Error(`Invalid cron range: ${start}-${end} in ${field}`);
+    for (let i = start; i <= end; i += step) out.add(i);
+  }
+  return out;
+}
+function parseCronInt(text, message) {
+  if (!/^\d+$/.test(text)) throw new Error(message);
+  const value = Number.parseInt(text, 10);
+  if (!Number.isSafeInteger(value)) throw new Error(message);
+  return value;
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5 || parts.some((part) => part.length === 0)) {
+    throw new Error(`Invalid cron: expected 5 fields, got ${parts.length}`);
+  }
+  return {
+    minutes: parseCronField(parts[0], 0, 59),
+    hours: parseCronField(parts[1], 0, 23),
+    daysOfMonth: parseCronField(parts[2], 1, 31),
+    months: parseCronField(parts[3], 1, 12),
+    daysOfWeek: parseCronField(parts[4], 0, 6)
+  };
+}
+function matchesCron(schedule, date, opts = {}) {
+  const fields = cronWallClockFields(date, opts.timezone);
+  return schedule.minutes.has(fields.minute) && schedule.hours.has(fields.hour) && schedule.daysOfMonth.has(fields.day) && schedule.months.has(fields.month) && schedule.daysOfWeek.has(fields.dayOfWeek);
+}
+function cronWallClockFields(date, timezone) {
+  if (timezone === void 0) {
+    return {
+      year: date.getFullYear(),
+      month: date.getMonth() + 1,
+      day: date.getDate(),
+      hour: date.getHours(),
+      minute: date.getMinutes(),
+      dayOfWeek: date.getDay()
+    };
+  }
+  const parts = timezoneFormatter(timezone).formatToParts(date);
+  const values = {};
+  for (const part of parts) {
+    if (part.type === "year" || part.type === "month" || part.type === "day" || part.type === "hour" || part.type === "minute") {
+      values[part.type] = Number.parseInt(part.value, 10);
+    }
+  }
+  const year = values.year;
+  const month = values.month;
+  const day = values.day;
+  const hour = values.hour;
+  const minute = values.minute;
+  if (year === void 0 || month === void 0 || day === void 0 || hour === void 0 || minute === void 0) {
+    throw new Error(`fromCron: timezone projection failed for ${timezone}`);
+  }
+  return {
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    dayOfWeek: new Date(Date.UTC(year, month - 1, day)).getUTCDay()
+  };
+}
+var TIMEZONE_FORMATTERS = /* @__PURE__ */ new Map();
+function timezoneFormatter(timezone) {
+  const existing = TIMEZONE_FORMATTERS.get(timezone);
+  if (existing !== void 0) return existing;
+  assertNonEmptyString(timezone, "fromCron: timezone");
+  try {
+    const formatter = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    });
+    formatter.format(/* @__PURE__ */ new Date(0));
+    TIMEZONE_FORMATTERS.set(timezone, formatter);
+    return formatter;
+  } catch (error) {
+    throw new RangeError(
+      `fromCron: unsupported IANA timezone '${timezone}' (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+}
+
+// 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 NEST_BOUNDARY_BINDINGS = /* @__PURE__ */ new WeakMap();
+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`);
+      assertNonEmptyString2(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 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 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") {
+    assertNonEmptyString2(fallback, "requestId");
+    return fallback;
+  }
+  if (typeof fallback === "function") {
+    const requestId = fallback(host);
+    if (requestId !== void 0) assertNonEmptyString2(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 stableBindingId(kind, opts) {
+  const bindingId = opts.bindingId ?? opts.name ?? `nestjs.${kind}`;
+  assertNonEmptyString2(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") {
+    assertNonEmptyString2(opts.requestId, "requestId");
+    return opts.requestId;
+  }
+  if (typeof opts.requestId === "function") {
+    const requestId = opts.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString2(requestId, "requestId");
+    return requestId;
+  }
+  return requestIdOf(host, {}, {});
+}
+function requestIdFromBinding(host, binding) {
+  if (typeof binding.requestId === "string") {
+    assertNonEmptyString2(binding.requestId, "requestId");
+    return binding.requestId;
+  }
+  if (typeof binding.requestId === "function") {
+    const requestId = binding.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString2(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 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) {
+    assertNonEmptyString2(fromEmit, "requestId");
+    return fromEmit;
+  }
+  if (typeof opts.requestId === "string") {
+    assertNonEmptyString2(opts.requestId, "requestId");
+    return opts.requestId;
+  }
+  if (typeof opts.requestId === "function") {
+    const requestId = opts.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString2(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 assertNonEmptyString2(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;
+}
+
+// src/adapters/nestjs/native.ts
+var GRAPHREFLY_NEST_CRON_SCHEDULER = /* @__PURE__ */ Symbol.for("graphrefly:nest:cron-scheduler");
+var GRAPHREFLY_NEST_EXCEPTION_FILTER = /* @__PURE__ */ Symbol.for("graphrefly:nest:exception-filter");
+var GRAPHREFLY_NEST_LIFECYCLE_HOOKS = /* @__PURE__ */ Symbol.for("graphrefly:nest:lifecycle-hooks");
+function provideGraphBoundaryInterceptor(opts = {}) {
+  return { provide: import_core.APP_INTERCEPTOR, useValue: new GraphBoundaryInterceptorBridge(opts) };
+}
+function provideGraphGuard(opts = {}) {
+  return { provide: import_core.APP_GUARD, useValue: new GraphGuardBridge(opts) };
+}
+function provideGraphExceptionFilter(opts) {
+  return { provide: GRAPHREFLY_NEST_EXCEPTION_FILTER, useValue: createGraphExceptionFilter(opts) };
+}
+function createGraphExceptionFilter(opts) {
+  return new GraphExceptionFilterBridge(opts);
+}
+function provideGraphGuardDeniedFilter() {
+  return GraphGuardDeniedFilter;
+}
+function createGraphGuardDeniedFilter() {
+  return new GraphGuardDeniedFilter();
+}
+function provideGraphCronScheduler(opts) {
+  return { provide: GRAPHREFLY_NEST_CRON_SCHEDULER, useValue: new GraphCronSchedulerBridge(opts) };
+}
+function provideGraphLifecycleHooks(opts) {
+  return {
+    provide: GRAPHREFLY_NEST_LIFECYCLE_HOOKS,
+    useValue: new GraphLifecycleHooksBridge(opts)
+  };
+}
+function provideGraphNativeHttpProviders(opts = {}) {
+  const providers = [];
+  if (opts.boundaryInterceptor !== false)
+    providers.push(provideGraphBoundaryInterceptor(opts.boundaryInterceptor ?? {}));
+  if (opts.guard !== false) providers.push(provideGraphGuard(opts.guard ?? {}));
+  if (opts.guardDeniedFilter ?? true) providers.push(provideGraphGuardDeniedFilter());
+  if (opts.exceptionFilter !== void 0)
+    providers.push(provideGraphExceptionFilter(opts.exceptionFilter));
+  return providers;
+}
+function provideGraphNativeProviders(opts = {}) {
+  const providers = [];
+  if (opts.http !== false) providers.push(...provideGraphNativeHttpProviders(opts.http ?? {}));
+  if (opts.cronScheduler !== void 0)
+    providers.push(provideGraphCronScheduler(opts.cronScheduler));
+  if (opts.lifecycleHooks !== void 0)
+    providers.push(provideGraphLifecycleHooks(opts.lifecycleHooks));
+  return providers;
+}
+function graphCronTarget(target, methodKey, opts) {
+  return { ...opts, target, methodKey };
+}
+function graphLifecycleTarget(target, methodKey, opts = {}) {
+  return { ...opts, target, methodKey };
+}
+function createGraphCronController(opts) {
+  return new GraphCronControllerImpl(opts);
+}
+var GraphBoundaryInterceptorBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.runner = createNestGraphBoundaryRunner({
+      diagnosticBoundary: opts.diagnosticBoundary,
+      diagnosticPhase: "http"
+    });
+  }
+  runner;
+  intercept(context, next) {
+    const host = this.opts.host?.(context) ?? defaultHttpHost(context);
+    const result = this.runner.run(
+      context.getClass(),
+      methodKeyForContext(context),
+      host,
+      this.opts
+    );
+    const reply = firstHttpReply(context);
+    const value = result === void 0 ? next.handle() : Promise.resolve(result).then(
+      (payload) => writeHttpResponse(
+        context,
+        lowerHttpReplyPayload(payload, host, {
+          issueResponse: reply?.issueResponse ?? this.opts.issueResponse
+        })
+      ),
+      (errorPayload) => writeHttpResponse(
+        context,
+        lowerProtocolError(errorPayload, host, {
+          protocolError: reply?.protocolError ?? this.opts.protocolError
+        })
+      )
+    );
+    return isObservableLike(value) ? value : (0, import_rxjs.from)(Promise.resolve(value));
+  }
+  onModuleDestroy() {
+    this.runner.dispose();
+  }
+};
+var GraphGuardBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  decisions = /* @__PURE__ */ new WeakMap();
+  disposableDecisions = /* @__PURE__ */ new Set();
+  async canActivate(context) {
+    const methodKey = methodKeyForContext(context);
+    const bindings = getNestBoundaryBindings(context.getClass(), methodKey);
+    const guards = bindings.filter(isGuardIngress);
+    if (guards.length === 0) return true;
+    const decisions = bindings.filter(isGuardDecision);
+    if (decisions.length === 0) return false;
+    const host = this.opts.host?.(context) ?? defaultHttpHost(context);
+    const guardEmits = guards.map((guard) => ({
+      guard,
+      requestId: bindingRequestId(host, guard, this.opts.requestId)
+    }));
+    if (guardEmits.some((entry) => entry.requestId === void 0)) return false;
+    const requestIds = new Set(guardEmits.map((entry) => entry.requestId));
+    const cleanups = [];
+    try {
+      const pending = [];
+      for (const requestId of requestIds) {
+        for (const decision of decisions) {
+          const state = { status: "pending", binding: decision };
+          pending.push(state);
+          cleanups.push(
+            this.decisionBoundary(decision).attach({
+              requestId,
+              bindingId: decision.bindingId,
+              handle: {
+                resolve(payload) {
+                  state.status = "resolved";
+                  state.payload = payload;
+                },
+                reject(error) {
+                  state.status = "rejected";
+                  state.error = error;
+                }
+              }
+            })
+          );
+        }
+      }
+      for (const entry of guardEmits)
+        entry.guard.boundary.emit(host, bindingEmitOptions(host, entry.guard, entry.requestId));
+      const rejected = pending.find((state) => state.status === "rejected");
+      if (rejected !== void 0) {
+        throw new GraphGuardProtocolErrorException(
+          lowerProtocolError(rejected.error, host, {
+            protocolError: rejected.binding.protocolError ?? this.opts.protocolError
+          })
+        );
+      }
+      if (pending.some((state) => state.status !== "resolved")) return false;
+      const denied = pending.find(
+        (state) => state.status === "resolved" && state.payload?.kind === "deny"
+      );
+      if (denied !== void 0) {
+        throw new GraphGuardDeniedException(
+          guardDecisionResponse(denied.payload, host, {
+            issueResponse: denied.binding.issueResponse ?? this.opts.issueResponse
+          })
+        );
+      }
+      return pending.every((state) => state.payload?.kind === "allow");
+    } catch (error) {
+      if (isGraphGuardDeniedException(error) || error instanceof GraphGuardProtocolErrorException) {
+        throw error;
+      }
+      return false;
+    } finally {
+      for (const cleanup of cleanups) cleanup();
+    }
+  }
+  onModuleDestroy() {
+    for (const boundary of this.disposableDecisions) boundary.dispose();
+    this.disposableDecisions.clear();
+  }
+  decisionBoundary(binding) {
+    const node = binding.decisionNode;
+    let byBinding = this.decisions.get(node);
+    if (byBinding === void 0) {
+      byBinding = /* @__PURE__ */ new Map();
+      this.decisions.set(node, byBinding);
+    }
+    const existing = byBinding.get(binding.bindingId);
+    if (existing !== void 0) return existing;
+    const boundary = toNestHttp(binding.decisionNode, {
+      bindingId: binding.bindingId,
+      diagnosticBoundary: this.opts.diagnosticBoundary,
+      diagnosticPhase: "guard"
+    });
+    byBinding.set(binding.bindingId, boundary);
+    this.disposableDecisions.add(boundary);
+    return boundary;
+  }
+};
+var GraphExceptionFilterBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  replies = /* @__PURE__ */ new WeakMap();
+  disposableReplies = /* @__PURE__ */ new Set();
+  catch(exception, host) {
+    const target = this.opts.target(host, exception);
+    if (target === void 0) throw exception;
+    const bindings = getNestBoundaryBindings(target.target, target.methodKey);
+    const filters = bindings.filter(isErrorIngress);
+    if (filters.length === 0) throw exception;
+    const nativeHost = this.opts.host?.(host, exception) ?? defaultArgumentsHost(host, exception);
+    const filterEmits = filters.map((filter) => ({
+      filter,
+      requestId: bindingRequestId(nativeHost, filter, this.opts.requestId)
+    }));
+    const handleFilters = filterEmits.filter((entry) => entry.filter.mode !== "observe");
+    const observeOnly = handleFilters.length === 0;
+    const replies = bindings.filter(isHttpReply);
+    const cleanups = [];
+    const emitFilters = () => {
+      for (const entry of filterEmits) {
+        entry.filter.boundary.emit(
+          nativeHost,
+          bindingEmitOptions(nativeHost, entry.filter, entry.requestId)
+        );
+      }
+    };
+    if (observeOnly) {
+      emitFilters();
+      throw exception;
+    }
+    const requestIds = new Set(
+      handleFilters.map((entry) => entry.requestId).filter((requestId) => requestId !== void 0)
+    );
+    if (replies.length === 0 || requestIds.size === 0) {
+      for (const entry of filterEmits) {
+        if (entry.requestId === void 0) continue;
+        entry.filter.boundary.emit(
+          nativeHost,
+          bindingEmitOptions(nativeHost, entry.filter, entry.requestId)
+        );
+      }
+      const filter = handleFilters[0]?.filter;
+      const lowered = lowerCaughtException(exception, nativeHost, {
+        issueResponse: filter?.issueResponse ?? this.opts.issueResponse,
+        protocolError: filter?.protocolError ?? this.opts.protocolError
+      });
+      return writeHttpResponse(host, lowered);
+    }
+    const pending = [];
+    try {
+      for (const requestId of requestIds) {
+        for (const reply of replies) {
+          const state = { status: "pending", reply };
+          pending.push(state);
+          cleanups.push(
+            this.replyBoundary(reply).attach({
+              requestId,
+              bindingId: reply.bindingId,
+              handle: {
+                resolve(payload) {
+                  state.status = "resolved";
+                  state.payload = payload;
+                },
+                reject(error) {
+                  state.status = "rejected";
+                  state.error = error;
+                }
+              }
+            })
+          );
+        }
+      }
+      emitFilters();
+      const resolved = pending.find((state) => state.status === "resolved");
+      if (resolved !== void 0) {
+        return writeHttpResponse(
+          host,
+          lowerHttpReplyPayload(resolved.payload, nativeHost, {
+            issueResponse: resolved.reply.issueResponse ?? handleFilters[0]?.filter.issueResponse ?? this.opts.issueResponse
+          })
+        );
+      }
+      const rejected = pending.find((state) => state.status === "rejected");
+      if (rejected !== void 0) {
+        return writeHttpResponse(
+          host,
+          lowerProtocolError(rejected.error, nativeHost, {
+            protocolError: rejected.reply.protocolError ?? handleFilters[0]?.filter.protocolError ?? this.opts.protocolError
+          })
+        );
+      }
+      const filter = handleFilters[0]?.filter;
+      return writeHttpResponse(
+        host,
+        lowerCaughtException(exception, nativeHost, {
+          issueResponse: filter?.issueResponse ?? this.opts.issueResponse,
+          protocolError: filter?.protocolError ?? this.opts.protocolError
+        })
+      );
+    } finally {
+      for (const cleanup of cleanups) cleanup();
+    }
+  }
+  onModuleDestroy() {
+    for (const boundary of this.disposableReplies) boundary.dispose();
+    this.disposableReplies.clear();
+  }
+  replyBoundary(binding) {
+    const node = binding.replyNode;
+    let byBinding = this.replies.get(node);
+    if (byBinding === void 0) {
+      byBinding = /* @__PURE__ */ new Map();
+      this.replies.set(node, byBinding);
+    }
+    const existing = byBinding.get(binding.bindingId);
+    if (existing !== void 0) return existing;
+    const boundary = toNestHttp(binding.replyNode, {
+      bindingId: binding.bindingId,
+      diagnosticBoundary: this.opts.diagnosticBoundary,
+      diagnosticPhase: "filter"
+    });
+    byBinding.set(binding.bindingId, boundary);
+    this.disposableReplies.add(boundary);
+    return boundary;
+  }
+};
+var GraphCronControllerImpl = class {
+  targets;
+  constructor(opts) {
+    this.targets = opts.targets.map((target) => ({
+      target,
+      schedule: parseCron(target.expr),
+      fired: /* @__PURE__ */ new Set()
+    }));
+  }
+  check(now) {
+    for (const entry of this.targets) {
+      emitCronTarget(entry.target, entry.schedule, entry.fired, now);
+    }
+  }
+};
+var GraphCronSchedulerBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  timers = [];
+  onModuleInit() {
+    try {
+      for (const target of this.opts.targets) this.startTarget(target);
+    } catch (error) {
+      this.onModuleDestroy();
+      throw error;
+    }
+  }
+  onModuleDestroy() {
+    for (const timer of this.timers.splice(0)) clearInterval(timer);
+  }
+  startTarget(target) {
+    const tickMs = target.tickMs ?? 6e4;
+    if (!Number.isFinite(tickMs) || tickMs <= 0) {
+      throw new RangeError("provideGraphCronScheduler: tickMs must be a positive finite number");
+    }
+    const controller = createGraphCronController({ targets: [target] });
+    const check = () => controller.check(/* @__PURE__ */ new Date());
+    check();
+    this.timers.push(setInterval(check, tickMs));
+  }
+};
+var GraphLifecycleHooksBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  onModuleInit() {
+    this.emit("module-init");
+  }
+  onModuleDestroy() {
+    this.emit("module-destroy");
+  }
+  emit(event) {
+    for (const target of this.opts.targets) {
+      if (target.event !== void 0 && target.event !== event) continue;
+      const host = target.host?.(event) ?? { event };
+      for (const binding of lifecycleBindings(target)) {
+        binding.boundary.emit(host, bindingEmitOptions(host, binding, void 0));
+      }
+    }
+  }
+};
+function methodKeyForContext(context) {
+  const resolved = resolveNestMethodKey(
+    context.getClass(),
+    context.getHandler()
+  );
+  return resolved ?? context.getHandler().name;
+}
+function defaultHttpHost(context) {
+  const request = context.switchToHttp?.().getRequest?.();
+  return request ?? {};
+}
+function defaultArgumentsHost(host, exception) {
+  const request = host.switchToHttp?.().getRequest?.();
+  if (request !== void 0 && request !== null) return { ...request, exception };
+  return { exception };
+}
+function isObservableLike(value) {
+  return value !== null && typeof value === "object" && typeof value.subscribe === "function";
+}
+function isGuardIngress(binding) {
+  return binding.direction === "ingress" && binding.kind === "guard";
+}
+function isErrorIngress(binding) {
+  return binding.direction === "ingress" && binding.kind === "error";
+}
+function isHttpReply(binding) {
+  return binding.direction === "egress" && binding.kind === "http";
+}
+function isGuardDecision(binding) {
+  return binding.direction === "egress" && binding.kind === "guard-decision";
+}
+function firstHttpReply(context) {
+  return getNestBoundaryBindings(context.getClass(), methodKeyForContext(context)).find(
+    isHttpReply
+  );
+}
+function lifecycleBindings(target) {
+  return getNestBoundaryBindings(target.target, target.methodKey).filter(
+    (binding) => binding.direction === "ingress" && binding.kind === "lifecycle"
+  );
+}
+function cronBindings(target) {
+  return getNestBoundaryBindings(target.target, target.methodKey).filter(
+    (binding) => binding.direction === "ingress" && binding.kind === "cron"
+  );
+}
+function emitCronTarget(target, schedule, fired, now) {
+  if (!matchesCron(schedule, now, { timezone: target.timezone })) return;
+  const key = cronProviderMinuteKey(now, target.timezone);
+  for (const existing of fired) {
+    if (!existing.startsWith(`${key.dayKey}:`)) fired.delete(existing);
+  }
+  if (fired.has(key.minuteKey)) return;
+  fired.add(key.minuteKey);
+  const host = target.host?.(now) ?? {
+    iso: now.toISOString(),
+    timestamp_ms: now.getTime(),
+    timestamp_ns: (BigInt(now.getTime()) * 1000000n).toString(),
+    timezone: target.timezone
+  };
+  for (const binding of cronBindings(target)) {
+    binding.boundary.emit(host, bindingEmitOptions(host, binding, void 0));
+  }
+}
+function cronProviderMinuteKey(date, timezone) {
+  if (timezone === void 0) {
+    const dayKey2 = `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+    return { dayKey: dayKey2, minuteKey: `${dayKey2}:${date.getHours()}:${date.getMinutes()}` };
+  }
+  const parts = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const byType = new Map(parts.map((part) => [part.type, part.value]));
+  const dayKey = `${byType.get("year")}-${byType.get("month")}-${byType.get("day")}`;
+  return { dayKey, minuteKey: `${dayKey}:${byType.get("hour")}:${byType.get("minute")}` };
+}
+function lowerCaughtException(exception, host, opts) {
+  if (isDataIssue(exception)) return lowerHttpReplyPayload(exception, host, opts);
+  return (opts.protocolError ?? protocolError)(exception, host);
+}
+function guardDecisionResponse(decision, host, opts) {
+  if (decision.issue !== void 0) return lowerHttpReplyPayload(decision.issue, host, opts);
+  if (Number.isInteger(decision.status)) {
+    return {
+      status: decision.status,
+      body: decision.body ?? {
+        code: "graphrefly.guard_denied",
+        message: decision.reason ?? "GraphReFly guard denied request"
+      },
+      headers: decision.headers
+    };
+  }
+  return {
+    status: 403,
+    body: {
+      code: "graphrefly.guard_denied",
+      message: decision.reason ?? "GraphReFly guard denied request"
+    },
+    headers: decision.headers
+  };
+}
+var GraphGuardDeniedException = class extends import_common.HttpException {
+  payload;
+  constructor(payload) {
+    super(payload.body ?? {}, payload.status);
+    this.payload = payload;
+  }
+};
+var GraphGuardProtocolErrorException = class extends import_common.HttpException {
+  constructor(payload) {
+    super(payload.body ?? {}, payload.status);
+  }
+};
+function isGraphGuardDeniedException(value) {
+  return value instanceof GraphGuardDeniedException;
+}
+var GraphGuardDeniedFilter = class {
+  catch(exception, host) {
+    if (!isGraphGuardDeniedException(exception)) throw exception;
+    return writeHttpResponse(host, exception.payload);
+  }
+};
+(0, import_common.Catch)(GraphGuardDeniedException)(GraphGuardDeniedFilter);
+function writeHttpResponse(host, payload) {
+  const response = host.switchToHttp?.().getResponse?.();
+  if (response === void 0) return payload;
+  for (const [name, value] of Object.entries(payload.headers ?? {})) {
+    if (typeof response.setHeader === "function") response.setHeader(name, value);
+    else response.header?.(name, value);
+  }
+  response.status?.(payload.status);
+  if (typeof response.json === "function") return response.json(payload.body ?? {});
+  if (typeof response.send === "function") return response.send(payload.body);
+  return payload;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GRAPHREFLY_NEST_CRON_SCHEDULER,
+  GRAPHREFLY_NEST_EXCEPTION_FILTER,
+  GRAPHREFLY_NEST_LIFECYCLE_HOOKS,
+  GraphExceptionFilterBridge,
+  GraphGuardDeniedException,
+  GraphGuardDeniedFilter,
+  createGraphCronController,
+  createGraphExceptionFilter,
+  createGraphGuardDeniedFilter,
+  graphCronTarget,
+  graphLifecycleTarget,
+  isGraphGuardDeniedException,
+  provideGraphBoundaryInterceptor,
+  provideGraphCronScheduler,
+  provideGraphExceptionFilter,
+  provideGraphGuard,
+  provideGraphGuardDeniedFilter,
+  provideGraphLifecycleHooks,
+  provideGraphNativeHttpProviders,
+  provideGraphNativeProviders
+});
+//# sourceMappingURL=native.cjs.map