@saasicat/nest 0.2.0

package/dist/discovery/index.cjs

@@ -0,0 +1,588 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/discovery/index.ts
+var discovery_exports = {};
+__export(discovery_exports, {
+  DEFINES_QUOTA_KEY: () => DEFINES_QUOTA_KEY,
+  DISCOVERY_APP_INFO_TOKEN: () => DISCOVERY_APP_INFO_TOKEN,
+  DISCOVERY_SNAPSHOT_PATH_TOKEN: () => DISCOVERY_SNAPSHOT_PATH_TOKEN,
+  DISCOVERY_SNAPSHOT_TOKEN: () => DISCOVERY_SNAPSHOT_TOKEN,
+  DefinesQuota: () => DefinesQuota,
+  DiscoveryModule: () => DiscoveryModule,
+  DiscoveryScanner: () => DiscoveryScanner,
+  DiscoverySnapshotNotFoundError: () => DiscoverySnapshotNotFoundError,
+  ENFORCE_QUOTA_KEY: () => ENFORCE_QUOTA_KEY,
+  EnforceQuota: () => EnforceQuota,
+  IMPLEMENTS_CAPABILITY_KEY: () => IMPLEMENTS_CAPABILITY_KEY,
+  ImplementsCapability: () => ImplementsCapability,
+  REQUIRES_CAPABILITY_KEY: () => REQUIRES_CAPABILITY_KEY,
+  RequiresCapability: () => RequiresCapability,
+  buildDiscoveryController: () => buildDiscoveryController,
+  computeSnapshotHash: () => computeSnapshotHash,
+  loadDiscoverySnapshotFromFile: () => loadDiscoverySnapshotFromFile,
+  runHeadlessDiscoveryScan: () => runHeadlessDiscoveryScan
+});
+module.exports = __toCommonJS(discovery_exports);
+
+// src/discovery/decorators.ts
+var import_common = require("@nestjs/common");
+
+// src/discovery/tokens.ts
+var IMPLEMENTS_CAPABILITY_KEY = "discovery:implements-capability";
+var REQUIRES_CAPABILITY_KEY = "discovery:requires-capability";
+var DEFINES_QUOTA_KEY = "discovery:defines-quota";
+var ENFORCE_QUOTA_KEY = "discovery:enforce-quota";
+var DISCOVERY_SNAPSHOT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/DiscoverySnapshot");
+
+// src/discovery/decorators.ts
+var ImplementsCapability = /* @__PURE__ */ __name((capabilityKey, options = {}) => (0, import_common.SetMetadata)(IMPLEMENTS_CAPABILITY_KEY, {
+  capabilityKey,
+  ...options
+}), "ImplementsCapability");
+var RequiresCapability = /* @__PURE__ */ __name((...capabilityKeys) => (0, import_common.SetMetadata)(REQUIRES_CAPABILITY_KEY, capabilityKeys), "RequiresCapability");
+var DefinesQuota = /* @__PURE__ */ __name((options) => (0, import_common.SetMetadata)(DEFINES_QUOTA_KEY, options), "DefinesQuota");
+var EnforceQuota = /* @__PURE__ */ __name((quotaKey, options = {}) => (0, import_common.SetMetadata)(ENFORCE_QUOTA_KEY, {
+  quotaKey,
+  incrementBy: options.incrementBy ?? 1,
+  timing: options.timing ?? "before"
+}), "EnforceQuota");
+
+// src/discovery/discovery.scanner.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_common2 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var DEFAULT_APP_INFO = {
+  key: "unknown",
+  version: "0.0.0"
+};
+var DISCOVERY_APP_INFO_TOKEN = /* @__PURE__ */ Symbol("DISCOVERY_APP_INFO");
+var DISCOVERY_SNAPSHOT_PATH_TOKEN = /* @__PURE__ */ Symbol("DISCOVERY_SNAPSHOT_PATH");
+var DiscoveryScanner = class _DiscoveryScanner {
+  static {
+    __name(this, "DiscoveryScanner");
+  }
+  discoveryService;
+  metadataScanner;
+  reflector;
+  appInfo;
+  snapshotPath;
+  logger = new import_common2.Logger(_DiscoveryScanner.name);
+  snapshot = null;
+  // Explicit @Inject instead of type reflection: in the platform package
+  // build tsup/esbuild do not emit `design:paramtypes` metadata, so Nest
+  // cannot otherwise resolve the DI targets at the constructor
+  // (UndefinedDependencyException at the consumer's boot). Pattern
+  // analogous to admin/admin-manifest.module.ts.
+  constructor(discoveryService, metadataScanner, reflector, appInfo = DEFAULT_APP_INFO, snapshotPath = null) {
+    this.discoveryService = discoveryService;
+    this.metadataScanner = metadataScanner;
+    this.reflector = reflector;
+    this.appInfo = appInfo;
+    this.snapshotPath = snapshotPath;
+  }
+  onApplicationBootstrap() {
+    this.snapshot = this.buildSnapshot();
+    this.logger.log(`Discovery snapshot built: ${this.snapshot.capabilities.length} capabilities, ${this.snapshot.features.length} features, ${this.snapshot.quotas.length} quotas (hash=${this.snapshot.hash.slice(0, 12)}\u2026)`);
+    if (this.snapshotPath) {
+      this.persistSnapshot(this.snapshotPath, this.snapshot);
+    }
+  }
+  persistSnapshot(path, snapshot) {
+    try {
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), {
+        recursive: true
+      });
+      (0, import_node_fs.writeFileSync)(path, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+      this.logger.log(`Discovery snapshot persisted to ${path}`);
+    } catch (err) {
+      this.logger.warn(`Discovery snapshot konnte nicht nach ${path} geschrieben werden: ${err.message}`);
+    }
+  }
+  /**
+   * Returns the boot-time snapshot. Before `onApplicationBootstrap` (e.g. in
+   * tests) the snapshot is built lazily.
+   */
+  getSnapshot() {
+    if (!this.snapshot) {
+      this.snapshot = this.buildSnapshot();
+    }
+    return this.snapshot;
+  }
+  /**
+   * Forces a re-scan (SuperAdmin "re-run discovery" or tests with
+   * dynamically registered providers). `scannedAt` is set anew and the
+   * snapshot — as at boot — is persisted to disk so that the last scan
+   * actually performed is preserved.
+   */
+  rebuildSnapshot() {
+    this.snapshot = this.buildSnapshot();
+    if (this.snapshotPath) {
+      this.persistSnapshot(this.snapshotPath, this.snapshot);
+    }
+    return this.snapshot;
+  }
+  buildSnapshot() {
+    const capabilitiesByKey = /* @__PURE__ */ new Map();
+    const quotasByKey = /* @__PURE__ */ new Map();
+    const enforceRefs = [];
+    const wrappers = [
+      ...this.discoveryService.getProviders(),
+      ...this.discoveryService.getControllers()
+    ];
+    for (const wrapper of wrappers) {
+      const instance = wrapper.instance;
+      if (!instance || typeof instance !== "object") continue;
+      const ctor = instance.constructor;
+      if (!ctor) continue;
+      const quotaOpts = this.reflector.get(DEFINES_QUOTA_KEY, ctor);
+      if (quotaOpts) {
+        this.registerQuota(quotasByKey, quotaOpts, ctor.name);
+      }
+      const prototype = Object.getPrototypeOf(instance);
+      const methodNames = this.metadataScanner.getAllMethodNames(prototype);
+      for (const methodName of methodNames) {
+        const methodRef = instance[methodName];
+        if (typeof methodRef !== "function") continue;
+        const capMeta = this.reflector.get(IMPLEMENTS_CAPABILITY_KEY, methodRef);
+        if (capMeta) {
+          this.registerCapability(capabilitiesByKey, capMeta, `${ctor.name}.${methodName}`);
+        }
+        const enforceMeta = this.reflector.get(ENFORCE_QUOTA_KEY, methodRef);
+        if (enforceMeta && capMeta) {
+          enforceRefs.push({
+            capabilityKey: capMeta.capabilityKey,
+            quotaKey: enforceMeta.quotaKey
+          });
+        }
+      }
+    }
+    const capabilities = sortByKey([
+      ...capabilitiesByKey.values()
+    ], (c) => c.capabilityKey);
+    const features = aggregateFeatures(capabilities);
+    const quotas = sortByKey(decorateQuotasWithEnforcers([
+      ...quotasByKey.values()
+    ], enforceRefs), (q) => q.quotaKey);
+    const snapshot = {
+      schemaVersion: 1,
+      scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      app: {
+        ...this.appInfo
+      },
+      capabilities,
+      features,
+      quotas,
+      hash: ""
+    };
+    snapshot.hash = computeSnapshotHash(snapshot);
+    return snapshot;
+  }
+  registerCapability(target, meta, declaredAt) {
+    const existing = target.get(meta.capabilityKey);
+    if (existing) {
+      this.logger.warn(`Capability '${meta.capabilityKey}' wird an mehreren Stellen deklariert (${existing.declaredAt} und ${declaredAt}); erste Deklaration gewinnt`);
+      return;
+    }
+    target.set(meta.capabilityKey, {
+      capabilityKey: meta.capabilityKey,
+      label: meta.label ?? null,
+      feature: meta.feature ?? null,
+      status: meta.status ?? "active",
+      kind: meta.kind ?? "endpoint",
+      owner: meta.owner ?? null,
+      replacementKey: meta.replacementKey ?? null,
+      removalPlannedAt: meta.removalPlannedAt ?? null,
+      reason: meta.reason ?? null,
+      requires: normalizeKeyList(meta.requires),
+      replaces: normalizeKeyList(meta.replaces),
+      declaredAt
+    });
+  }
+  registerQuota(target, opts, declaredAt) {
+    const existing = target.get(opts.key);
+    if (existing) {
+      this.logger.warn(`Quota '${opts.key}' wird an mehreren Stellen definiert (${existing.declaredAt} und ${declaredAt}); erste Definition gewinnt`);
+      return;
+    }
+    target.set(opts.key, {
+      quotaKey: opts.key,
+      label: opts.label,
+      unit: opts.unit,
+      policy: opts.policy,
+      feature: opts.feature ?? null,
+      replaces: normalizeKeyList(opts.replaces),
+      declaredAt,
+      enforcedBy: []
+    });
+  }
+};
+DiscoveryScanner = _ts_decorate([
+  (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_common2.Inject)(import_core.DiscoveryService)),
+  _ts_param(1, (0, import_common2.Inject)(import_core.MetadataScanner)),
+  _ts_param(2, (0, import_common2.Inject)(import_core.Reflector)),
+  _ts_param(3, (0, import_common2.Optional)()),
+  _ts_param(3, (0, import_common2.Inject)(DISCOVERY_APP_INFO_TOKEN)),
+  _ts_param(4, (0, import_common2.Optional)()),
+  _ts_param(4, (0, import_common2.Inject)(DISCOVERY_SNAPSHOT_PATH_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
+    typeof import_core.MetadataScanner === "undefined" ? Object : import_core.MetadataScanner,
+    typeof import_core.Reflector === "undefined" ? Object : import_core.Reflector,
+    typeof DiscoveryAppInfo === "undefined" ? Object : DiscoveryAppInfo,
+    Object
+  ])
+], DiscoveryScanner);
+function aggregateFeatures(capabilities) {
+  const byFeature = /* @__PURE__ */ new Map();
+  for (const cap of capabilities) {
+    if (!cap.feature) continue;
+    const acc = byFeature.get(cap.feature) ?? {
+      capabilityKeys: [],
+      requires: /* @__PURE__ */ new Set(),
+      replaces: /* @__PURE__ */ new Set()
+    };
+    acc.capabilityKeys.push(cap.capabilityKey);
+    for (const key of cap.requires ?? []) acc.requires.add(key);
+    for (const key of cap.replaces ?? []) acc.replaces.add(key);
+    byFeature.set(cap.feature, acc);
+  }
+  return sortByKey([
+    ...byFeature.entries()
+  ].map(([featureKey, acc]) => {
+    acc.requires.delete(featureKey);
+    acc.replaces.delete(featureKey);
+    return {
+      featureKey,
+      capabilityKeys: [
+        ...acc.capabilityKeys
+      ].sort((a, b) => a.localeCompare(b)),
+      requires: setToSortedListOrNull(acc.requires),
+      replaces: setToSortedListOrNull(acc.replaces)
+    };
+  }), (f) => f.featureKey);
+}
+__name(aggregateFeatures, "aggregateFeatures");
+function normalizeKeyList(keys) {
+  if (!keys || keys.length === 0) return null;
+  return [
+    ...new Set(keys)
+  ].sort((a, b) => a.localeCompare(b));
+}
+__name(normalizeKeyList, "normalizeKeyList");
+function setToSortedListOrNull(keys) {
+  if (keys.size === 0) return null;
+  return [
+    ...keys
+  ].sort((a, b) => a.localeCompare(b));
+}
+__name(setToSortedListOrNull, "setToSortedListOrNull");
+function decorateQuotasWithEnforcers(quotas, enforceRefs) {
+  const enforcedByQuota = /* @__PURE__ */ new Map();
+  for (const ref of enforceRefs) {
+    const set = enforcedByQuota.get(ref.quotaKey) ?? /* @__PURE__ */ new Set();
+    set.add(ref.capabilityKey);
+    enforcedByQuota.set(ref.quotaKey, set);
+  }
+  return quotas.map((q) => ({
+    ...q,
+    enforcedBy: [
+      ...enforcedByQuota.get(q.quotaKey) ?? /* @__PURE__ */ new Set()
+    ].sort((a, b) => a.localeCompare(b))
+  }));
+}
+__name(decorateQuotasWithEnforcers, "decorateQuotasWithEnforcers");
+function sortByKey(items, keyFn) {
+  return [
+    ...items
+  ].sort((a, b) => keyFn(a).localeCompare(keyFn(b)));
+}
+__name(sortByKey, "sortByKey");
+function computeSnapshotHash(snapshot) {
+  const stableInput = {
+    schemaVersion: snapshot.schemaVersion,
+    appKey: snapshot.app.key,
+    capabilities: snapshot.capabilities.map((c) => ({
+      ...c
+    })),
+    features: snapshot.features,
+    quotas: snapshot.quotas
+  };
+  const json = canonicalStringify(stableInput);
+  return `sha256-${(0, import_node_crypto.createHash)("sha256").update(json).digest("hex")}`;
+}
+__name(computeSnapshotHash, "computeSnapshotHash");
+function canonicalStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const sorted = {};
+      for (const k of Object.keys(val).sort()) {
+        sorted[k] = val[k];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+__name(canonicalStringify, "canonicalStringify");
+
+// src/discovery/discovery.module.ts
+var import_common4 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+
+// src/discovery/discovery.controller.ts
+var import_common3 = require("@nestjs/common");
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+function buildDiscoveryController(guards) {
+  let GeneratedDiscoveryController = class GeneratedDiscoveryController {
+    static {
+      __name(this, "GeneratedDiscoveryController");
+    }
+    scanner;
+    // Explicit @Inject instead of type reflection: tsup/esbuild do not emit
+    // any `design:paramtypes` metadata, so otherwise Nest cannot resolve the
+    // service type on the constructor.
+    constructor(scanner) {
+      this.scanner = scanner;
+    }
+    getDiscovery(ifNoneMatch, res) {
+      const snapshot = this.scanner.getSnapshot();
+      const etag = `"${snapshot.hash}-${snapshot.scannedAt}"`;
+      res.header("ETag", etag);
+      if (ifNoneMatch && ifNoneMatch === etag) {
+        res.status(import_common3.HttpStatus.NOT_MODIFIED);
+        return null;
+      }
+      return snapshot;
+    }
+    /**
+     * Forces a fresh code scan and returns the new snapshot.
+     * `scannedAt` is updated; the Capability/Feature/Quota data
+     * are identical within the running process (code is stable at runtime).
+     */
+    rescanDiscovery() {
+      return this.scanner.rebuildSnapshot();
+    }
+  };
+  _ts_decorate2([
+    (0, import_common3.Get)("discovery"),
+    (0, import_common3.Header)("Cache-Control", "private, no-cache"),
+    _ts_param2(0, (0, import_common3.Headers)("if-none-match")),
+    _ts_param2(1, (0, import_common3.Res)({
+      passthrough: true
+    })),
+    _ts_metadata2("design:type", Function),
+    _ts_metadata2("design:paramtypes", [
+      Object,
+      typeof HttpResponseLike === "undefined" ? Object : HttpResponseLike
+    ]),
+    _ts_metadata2("design:returntype", Object)
+  ], GeneratedDiscoveryController.prototype, "getDiscovery", null);
+  _ts_decorate2([
+    (0, import_common3.Post)("discovery/rescan"),
+    _ts_metadata2("design:type", Function),
+    _ts_metadata2("design:paramtypes", []),
+    _ts_metadata2("design:returntype", typeof DiscoverySnapshot === "undefined" ? Object : DiscoverySnapshot)
+  ], GeneratedDiscoveryController.prototype, "rescanDiscovery", null);
+  GeneratedDiscoveryController = _ts_decorate2([
+    (0, import_common3.Controller)("admin"),
+    (0, import_common3.UseGuards)(...guards),
+    _ts_param2(0, (0, import_common3.Inject)(DiscoveryScanner)),
+    _ts_metadata2("design:type", Function),
+    _ts_metadata2("design:paramtypes", [
+      typeof DiscoveryScanner === "undefined" ? Object : DiscoveryScanner
+    ])
+  ], GeneratedDiscoveryController);
+  return GeneratedDiscoveryController;
+}
+__name(buildDiscoveryController, "buildDiscoveryController");
+
+// src/discovery/discovery.module.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var DiscoveryModule = class _DiscoveryModule {
+  static {
+    __name(this, "DiscoveryModule");
+  }
+  static forRoot(options) {
+    const isGlobal = options.isGlobal ?? true;
+    const controllers = [];
+    if (options.controller) {
+      controllers.push(buildDiscoveryController(options.controller.guards));
+    }
+    const providers = [
+      {
+        provide: DISCOVERY_APP_INFO_TOKEN,
+        useValue: options.app
+      },
+      {
+        provide: DISCOVERY_SNAPSHOT_PATH_TOKEN,
+        useValue: options.snapshotPath ?? null
+      },
+      DiscoveryScanner,
+      {
+        provide: DISCOVERY_SNAPSHOT_TOKEN,
+        useFactory: /* @__PURE__ */ __name((scanner) => scanner.getSnapshot(), "useFactory"),
+        inject: [
+          DiscoveryScanner
+        ]
+      }
+    ];
+    return {
+      module: _DiscoveryModule,
+      imports: [
+        import_core2.DiscoveryModule,
+        ...options.imports ?? []
+      ],
+      controllers,
+      providers,
+      exports: [
+        DiscoveryScanner,
+        DISCOVERY_SNAPSHOT_TOKEN
+      ],
+      global: isGlobal
+    };
+  }
+};
+DiscoveryModule = _ts_decorate3([
+  (0, import_common4.Module)({})
+], DiscoveryModule);
+
+// src/discovery/snapshot-loader.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var DiscoverySnapshotNotFoundError = class extends Error {
+  static {
+    __name(this, "DiscoverySnapshotNotFoundError");
+  }
+  path;
+  constructor(path) {
+    super(`Discovery-Snapshot-Datei nicht gefunden: ${path}. Booten Sie zuerst die App mit DISCOVERY_SNAPSHOT_PATH oder DiscoveryModule.forRoot({ snapshotPath: '\u2026' }), damit der Scanner die Datei beim OnApplicationBootstrap-Hook schreibt.`), this.path = path;
+    this.name = "DiscoverySnapshotNotFoundError";
+  }
+};
+function loadDiscoverySnapshotFromFile(path) {
+  const absolute = (0, import_node_path2.resolve)(path);
+  if (!(0, import_node_fs2.existsSync)(absolute)) {
+    throw new DiscoverySnapshotNotFoundError(absolute);
+  }
+  const raw = (0, import_node_fs2.readFileSync)(absolute, "utf-8");
+  return JSON.parse(raw);
+}
+__name(loadDiscoverySnapshotFromFile, "loadDiscoverySnapshotFromFile");
+
+// src/discovery/headless-scan.ts
+var import_core3 = require("@nestjs/core");
+async function runHeadlessDiscoveryScan(appModule, options = {}) {
+  const exit = options.exit ?? ((code) => process.exit(code));
+  try {
+    const app = await import_core3.NestFactory.createApplicationContext(appModule, {
+      logger: options.logger ?? [
+        "error",
+        "warn",
+        "log"
+      ]
+    });
+    try {
+      return resolveSnapshotFromContext(app);
+    } finally {
+      await app.close();
+    }
+  } catch (err) {
+    console.error("[discovery-scan] FEHLER:", err instanceof Error ? err.message : err);
+    return exit(4);
+  }
+}
+__name(runHeadlessDiscoveryScan, "runHeadlessDiscoveryScan");
+function resolveSnapshotFromContext(app) {
+  try {
+    return app.get(DISCOVERY_SNAPSHOT_TOKEN, {
+      strict: false
+    });
+  } catch {
+    return app.get(DiscoveryScanner, {
+      strict: false
+    }).getSnapshot();
+  }
+}
+__name(resolveSnapshotFromContext, "resolveSnapshotFromContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFINES_QUOTA_KEY,
+  DISCOVERY_APP_INFO_TOKEN,
+  DISCOVERY_SNAPSHOT_PATH_TOKEN,
+  DISCOVERY_SNAPSHOT_TOKEN,
+  DefinesQuota,
+  DiscoveryModule,
+  DiscoveryScanner,
+  DiscoverySnapshotNotFoundError,
+  ENFORCE_QUOTA_KEY,
+  EnforceQuota,
+  IMPLEMENTS_CAPABILITY_KEY,
+  ImplementsCapability,
+  REQUIRES_CAPABILITY_KEY,
+  RequiresCapability,
+  buildDiscoveryController,
+  computeSnapshotHash,
+  loadDiscoverySnapshotFromFile,
+  runHeadlessDiscoveryScan
+});