@aopslabs/aops-server 0.2.0

package/build/server/chunks/registry-DO8ob5o1.js

@@ -0,0 +1,660 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { validateHostConfig, DomainPluginRegistry, normalizeDomainName } from '@aopslabs/host-core';
+import { p as private_env } from './index.js-BQnOaW3H.js';
+import './aops-runtime-config-CHpDUCdE.js';
+import { existsSync } from 'node:fs';
+import { Worker } from 'node:worker_threads';
+import { A as AdmissionDecisionCache, b as buildAdmittedDomainSnapshot, C as CommercialArtifactError } from './admission-snapshot-C2wGfTWE.js';
+
+const COMMUNITY_FREE_DOMAIN_IDS = Object.freeze([
+  "agentspace",
+  "chatv3",
+  "docman",
+  "projectman",
+  "sys"
+]);
+const COMMERCIAL_INTEGRITY_LISTENER_READY_EVENT = "aops-community:commercial-integrity-listener-ready";
+const COMMERCIAL_INTEGRITY_HOST_SHUTDOWN_EVENT = "aops-community:commercial-integrity-host-shutdown";
+const SCHEDULE_RETRY_MS = 6e4;
+const MAX_TIMER_DELAY_MS = 2147e6;
+const COMMERCIAL_INTEGRITY_WORKER_TIMEOUT_MS = 15 * 6e4;
+function resolveCommercialIntegrityWorkerModuleUrl(moduleUrl = import.meta.url) {
+  const modulePath = fileURLToPath(moduleUrl);
+  const moduleDirectory = path.dirname(modulePath);
+  const builtChunk = modulePath.includes(
+    `${path.sep}build${path.sep}server${path.sep}chunks${path.sep}`
+  );
+  const packageRoot = path.resolve(
+    moduleDirectory,
+    ...builtChunk ? ["..", "..", ".."] : ["..", ".."]
+  );
+  return pathToFileURL(path.join(
+    packageRoot,
+    "runtime",
+    "commercial-integrity-worker.mjs"
+  ));
+}
+const cache = new AdmissionDecisionCache(buildAdmittedDomainSnapshot({
+  generation: 1,
+  freeDomains: COMMUNITY_FREE_DOMAIN_IDS
+}));
+let commercialRuntime = null;
+let commercialFailureLatched = false;
+let integrityTimer = null;
+let integrityWorkerRunning = false;
+let integritySchedulerStopped = false;
+let activeIntegrityWorker = null;
+let integrityRuntime = Object.freeze({
+  state: "disabled",
+  listenerReady: false,
+  dueAt: null,
+  lastVerifiedAt: null,
+  failure: null
+});
+function normalizedFailure(error, now) {
+  return Object.freeze({
+    stage: error instanceof CommercialArtifactError ? error.stage : "commercial-integrity-scheduler",
+    decision: error instanceof CommercialArtifactError ? error.decision : "deny",
+    reason: error instanceof CommercialArtifactError ? error.reason : error instanceof Error ? error.message : "scheduled_verification_failed",
+    detectedAt: now.toISOString()
+  });
+}
+function applyScheduledCommercialIntegrityFailure(error, now) {
+  if (commercialFailureLatched) return;
+  commercialFailureLatched = true;
+  cache.replace(buildAdmittedDomainSnapshot({
+    generation: cache.read().generation + 1,
+    freeDomains: COMMUNITY_FREE_DOMAIN_IDS,
+    now
+  }));
+  commercialRuntime = null;
+  integrityRuntime = Object.freeze({
+    state: "failed-closed",
+    listenerReady: integrityRuntime.listenerReady,
+    dueAt: null,
+    lastVerifiedAt: integrityRuntime.lastVerifiedAt,
+    failure: normalizedFailure(error, now)
+  });
+}
+const configuredAdmission = process.env.AOPS_COMMERCIAL_ADMISSION_CONFIG?.trim();
+if (configuredAdmission) {
+  try {
+    const { loadCommercialAdmissionSnapshot } = await import('./commercial-admission-loader-V_vXHdVa.js');
+    const loaded = loadCommercialAdmissionSnapshot(
+      configuredAdmission,
+      COMMUNITY_FREE_DOMAIN_IDS
+    );
+    cache.replace(loaded.snapshot);
+    commercialRuntime = loaded.runtime;
+    integrityRuntime = Object.freeze({
+      ...integrityRuntime,
+      state: "waiting"
+    });
+  } catch (error) {
+    applyScheduledCommercialIntegrityFailure(error, /* @__PURE__ */ new Date());
+  }
+}
+function getHostAdmissionSnapshot() {
+  return cache.read();
+}
+function getCommercialRuntimeProjection() {
+  return commercialRuntime;
+}
+function runCommercialIntegrityVerificationWorker(input, now, options = {}) {
+  return new Promise((resolve, reject) => {
+    const workerData = {
+      input,
+      now: now.toISOString()
+    };
+    const worker = options.workerSource ? new Worker(options.workerSource, {
+      eval: true,
+      workerData
+    }) : new Worker(options.workerModuleUrl ?? resolveCommercialIntegrityWorkerModuleUrl(), {
+      workerData
+    });
+    activeIntegrityWorker = worker;
+    let settled = false;
+    let timeout = null;
+    const markSettled = () => {
+      if (settled) return false;
+      settled = true;
+      activeIntegrityWorker = null;
+      if (timeout) clearTimeout(timeout);
+      timeout = null;
+      return true;
+    };
+    const fail = (error) => {
+      if (!markSettled()) return;
+      reject(error);
+    };
+    worker.once("error", fail);
+    worker.once("exit", (code) => {
+      if (!settled) {
+        fail(new Error(code === 0 ? "commercial_integrity_worker_no_result" : "commercial_integrity_worker_failed"));
+      }
+    });
+    worker.once("message", (message) => {
+      if (!markSettled()) return;
+      if (message.ok) resolve();
+      else reject(new CommercialArtifactError(
+        message.stage,
+        message.reason,
+        message.decision === "quarantine" ? "quarantine" : "deny"
+      ));
+    });
+    timeout = setTimeout(() => {
+      void worker.terminate();
+      fail(new Error("commercial_integrity_worker_timeout"));
+    }, options.timeoutMs ?? COMMERCIAL_INTEGRITY_WORKER_TIMEOUT_MS);
+    timeout.unref();
+  });
+}
+function setIntegrityTimer(callback, delayMs) {
+  if (integritySchedulerStopped) return;
+  if (integrityTimer) clearTimeout(integrityTimer);
+  integrityTimer = setTimeout(callback, Math.min(Math.max(delayMs, 0), MAX_TIMER_DELAY_MS));
+  integrityTimer.unref();
+}
+async function runScheduledIntegrityVerification() {
+  if (!configuredAdmission || integrityWorkerRunning || integritySchedulerStopped) return;
+  integrityWorkerRunning = true;
+  const now = /* @__PURE__ */ new Date();
+  integrityRuntime = Object.freeze({
+    ...integrityRuntime,
+    state: "verifying",
+    listenerReady: true,
+    dueAt: now.toISOString()
+  });
+  try {
+    const { resolveCommercialIntegrityWorkerInput } = await import('./commercial-admission-loader-V_vXHdVa.js');
+    await runCommercialIntegrityVerificationWorker(
+      resolveCommercialIntegrityWorkerInput(configuredAdmission),
+      now
+    );
+    integrityRuntime = Object.freeze({
+      state: commercialFailureLatched ? "recovery-verified-restart-required" : "verified",
+      listenerReady: true,
+      dueAt: null,
+      lastVerifiedAt: now.toISOString(),
+      failure: integrityRuntime.failure
+    });
+  } catch (error) {
+    applyScheduledCommercialIntegrityFailure(error, /* @__PURE__ */ new Date());
+  } finally {
+    integrityWorkerRunning = false;
+    if (!integritySchedulerStopped) {
+      setIntegrityTimer(() => {
+        void planScheduledIntegrityVerification();
+      }, SCHEDULE_RETRY_MS);
+    }
+  }
+}
+async function planScheduledIntegrityVerification() {
+  if (!configuredAdmission || integrityWorkerRunning || integritySchedulerStopped) return;
+  const now = /* @__PURE__ */ new Date();
+  try {
+    const { readCommercialAdmissionIntegritySchedule } = await import('./commercial-admission-loader-V_vXHdVa.js');
+    const schedule = readCommercialAdmissionIntegritySchedule(configuredAdmission, now);
+    if (schedule.state === "authority-unavailable" || schedule.state === "quarantined") {
+      applyScheduledCommercialIntegrityFailure(
+        new Error(schedule.state === "quarantined" ? "integrity_scheduled_quarantine_active" : "integrity_authority_unavailable"),
+        now
+      );
+      setIntegrityTimer(() => {
+        void planScheduledIntegrityVerification();
+      }, SCHEDULE_RETRY_MS);
+      return;
+    }
+    if (schedule.state === "due" || !schedule.dueAt) {
+      await runScheduledIntegrityVerification();
+      return;
+    }
+    const delayMs = Math.max(0, Date.parse(schedule.dueAt) - now.getTime());
+    integrityRuntime = Object.freeze({
+      state: commercialFailureLatched ? "recovery-verified-restart-required" : "waiting",
+      listenerReady: true,
+      dueAt: schedule.dueAt,
+      lastVerifiedAt: schedule.verifiedAt,
+      failure: integrityRuntime.failure
+    });
+    setIntegrityTimer(() => {
+      void planScheduledIntegrityVerification();
+    }, delayMs);
+  } catch (error) {
+    applyScheduledCommercialIntegrityFailure(error, now);
+    setIntegrityTimer(() => {
+      void planScheduledIntegrityVerification();
+    }, SCHEDULE_RETRY_MS);
+  }
+}
+function startHostCommercialIntegrityScheduler() {
+  if (!configuredAdmission || integrityRuntime.listenerReady) return;
+  integritySchedulerStopped = false;
+  integrityRuntime = Object.freeze({ ...integrityRuntime, listenerReady: true });
+  void planScheduledIntegrityVerification();
+}
+function stopHostCommercialIntegrityScheduler() {
+  integritySchedulerStopped = true;
+  if (integrityTimer) clearTimeout(integrityTimer);
+  integrityTimer = null;
+  if (activeIntegrityWorker) void activeIntegrityWorker.terminate();
+  activeIntegrityWorker = null;
+}
+process.once(
+  COMMERCIAL_INTEGRITY_LISTENER_READY_EVENT,
+  startHostCommercialIntegrityScheduler
+);
+process.once(
+  COMMERCIAL_INTEGRITY_HOST_SHUTDOWN_EVENT,
+  stopHostCommercialIntegrityScheduler
+);
+function checkHostDomainAdmission(domain, operationId, now) {
+  return cache.check(domain, operationId, now);
+}
+function getAdmittedDomainIds() {
+  return getHostAdmissionSnapshot().orderedDomains.map((decision) => decision.domain);
+}
+function getHostAdmissionDiagnostics() {
+  const snapshot = getHostAdmissionSnapshot();
+  return Object.freeze({
+    schemaVersion: 1,
+    generation: snapshot.generation,
+    createdAt: snapshot.createdAt,
+    runtimeRegistration: Object.freeze({
+      state: commercialRuntime ? "derived-from-verified-evidence" : "community-only",
+      domain: commercialRuntime?.domain ?? null
+    }),
+    commercialIntegrity: integrityRuntime,
+    domains: Object.freeze(snapshot.orderedDomains.map((decision) => Object.freeze({
+      domain: decision.domain,
+      plane: decision.plane,
+      state: decision.state,
+      reason: decision.reason,
+      productId: decision.productId,
+      manifestDigest: decision.manifestDigest,
+      closureDigest: decision.closureDigest,
+      entitlementEpoch: decision.entitlementEpoch,
+      refreshAfter: decision.refreshAfter,
+      fullUntil: decision.fullUntil,
+      expiresAt: decision.expiresAt,
+      migrationEligible: decision.migrationEligible
+    })))
+  });
+}
+const host = { "name": "aops-community-server", "apiBasePath": "/api" };
+const runtime = { "env": { "AOPS_PG_URL": { "fromEnv": "AOPS_PG_URL", "required": true } } };
+const pluginLoader = { "strictAllowlist": true, "tolerantBootstrap": false, "allowlist": ["@aopslabs/domain-host-plugin-sys", "./runtime/agentspace-host-adapter.mjs", "./runtime/docman-host-adapter.mjs", "./runtime/projectman-host-adapter.mjs", "@aopslabs/domain-host-plugin-chatv3"] };
+const diagnostics = { "exposePluginBootstrap": true };
+const agentGateway = { "enabled": true, "includeLocal": true, "catalog": { "enabled": true, "manifestProviders": [{ "id": "sys-dcm", "domain": "sys", "enabled": true, "module": "@aopslabs/domain-kit-sys", "exportName": "buildSysDomainCapabilityManifest", "options": { "domainVersion": "0.0.1", "includeDocs": true } }, { "id": "agentspace-dcm", "domain": "agentspace", "enabled": true, "module": "./runtime/agentspace-tooling.mjs", "exportName": "buildCommunityAgentspaceDomainCapabilityManifest", "options": { "domainVersion": "0.0.4", "includeDocs": true } }, { "id": "docman-dcm", "domain": "docman", "enabled": true, "module": "./runtime/docman-tooling.mjs", "exportName": "buildAopsDocmanDomainCapabilityManifest", "options": { "domainVersion": "0.1.3", "includeDocs": true } }, { "id": "projectman-dcm", "domain": "projectman", "enabled": true, "module": "@aopslabs/domain-kit-projectman", "exportName": "buildProjectmanDomainCapabilityManifest", "options": { "domainVersion": "0.1.2", "includeDocs": true } }, { "id": "chatv3-dcm", "domain": "chatv3", "enabled": true, "module": "@aopslabs/domain-kit-chatv3", "exportName": "buildChatv3DomainCapabilityManifest", "options": { "domainVersion": "0.1.0", "includeDocs": true } }] }, "sources": [] };
+const plugins = [{ "domain": "sys", "enabled": true, "module": "@aopslabs/domain-host-plugin-sys", "factory": "createSysPlugin" }, { "domain": "agentspace", "enabled": true, "module": "./runtime/agentspace-host-adapter.mjs", "factory": "createCommunityAgentspacePlugin", "options": { "defaultTenantId": "123e4567-e89b-41d4-a000-000000000001" } }, { "domain": "docman", "enabled": true, "module": "./runtime/docman-host-adapter.mjs", "factory": "createDocmanPlugin", "options": { "defaultScopeId": "00000000-0000-4000-8000-000000000000" } }, { "domain": "projectman", "enabled": true, "module": "./runtime/projectman-host-adapter.mjs", "factory": "createProjectmanPlugin", "options": { "defaultProjectId": "123e4567-e89b-41d4-a000-000000000000", "enableAopsWriteback": true, "failOnWritebackError": false } }, { "domain": "chatv3", "enabled": true, "module": "@aopslabs/domain-host-plugin-chatv3", "factory": "createChatv3Plugin" }];
+const configRaw = {
+  host,
+  runtime,
+  pluginLoader,
+  diagnostics,
+  agentGateway,
+  plugins
+};
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SERVER_PACKAGE_ROOT_CANDIDATE = [
+  path.resolve(MODULE_DIR, "../../.."),
+  path.resolve(MODULE_DIR, "../../../.."),
+  path.resolve(MODULE_DIR, "../..")
+].find(
+  (candidate) => existsSync(path.join(candidate, "runtime", "agentspace-host-adapter.mjs"))
+);
+if (!SERVER_PACKAGE_ROOT_CANDIDATE) {
+  throw new Error("community_server_package_root_not_found");
+}
+const SERVER_PACKAGE_ROOT = SERVER_PACKAGE_ROOT_CANDIDATE;
+function resolveCommunityPackageModule(moduleName) {
+  if (!moduleName) throw new Error("community_host_module_missing");
+  if (!moduleName.startsWith("./runtime/")) return moduleName;
+  return path.join(SERVER_PACKAGE_ROOT, moduleName.slice(2));
+}
+const COMMUNITY_PLUGIN_MODULES = Object.freeze([
+  "@aopslabs/domain-host-plugin-sys",
+  resolveCommunityPackageModule("./runtime/agentspace-host-adapter.mjs"),
+  resolveCommunityPackageModule("./runtime/docman-host-adapter.mjs"),
+  resolveCommunityPackageModule("./runtime/projectman-host-adapter.mjs"),
+  "@aopslabs/domain-host-plugin-chatv3"
+]);
+const COMMUNITY_RUNTIME_ENV_KEYS = Object.freeze(["AOPS_PG_URL"]);
+const codepointCompare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const sorted = (values) => [...values].sort(codepointCompare);
+const normalize = (value) => String(value ?? "").trim().toLowerCase();
+function exactSet(label, actual, expected) {
+  const left = sorted(actual.map(normalize).filter(Boolean));
+  const right = sorted(expected.map(normalize).filter(Boolean));
+  if (new Set(left).size !== left.length || new Set(right).size !== right.length || left.length !== right.length || !left.every((value, index) => value === right[index])) {
+    throw new Error(`community_host_config_set_mismatch:${label}:expected=${right.join(",")}:actual=${left.join(",")}`);
+  }
+}
+function inventory(config) {
+  return {
+    pluginDomains: (config.plugins ?? []).map((plugin) => normalize(plugin.domain)).filter(Boolean),
+    manifestProviderDomains: (config.agentGateway?.catalog?.manifestProviders ?? []).map((provider) => normalize(provider.domain)).filter(Boolean),
+    sourceDomains: (config.agentGateway?.sources ?? []).map((source) => normalize(source.domain)).filter(Boolean)
+  };
+}
+function validateStaticCommunityConfig(input) {
+  const config = structuredClone(input);
+  config.plugins = (config.plugins ?? []).map((plugin) => ({
+    ...plugin,
+    module: resolveCommunityPackageModule(plugin.module)
+  }));
+  if (config.agentGateway?.catalog) {
+    config.agentGateway.catalog.manifestProviders = (config.agentGateway.catalog.manifestProviders ?? []).map((provider) => ({
+      ...provider,
+      module: resolveCommunityPackageModule(provider.module)
+    }));
+  }
+  if (config.pluginLoader) {
+    config.pluginLoader.allowlist = (config.pluginLoader.allowlist ?? []).map(resolveCommunityPackageModule);
+  }
+  const commercial = getCommercialRuntimeProjection();
+  if (commercial) {
+    config.plugins = [
+      ...config.plugins ?? [],
+      {
+        domain: commercial.domain,
+        enabled: true,
+        module: commercial.pluginModule,
+        factory: commercial.pluginFactory
+      }
+    ];
+    const catalog = config.agentGateway?.catalog;
+    if (!catalog) throw new Error("community_host_config_catalog_missing");
+    catalog.manifestProviders = [
+      ...catalog.manifestProviders ?? [],
+      {
+        id: `${commercial.domain}-commercial-dcm`,
+        domain: commercial.domain,
+        enabled: true,
+        module: commercial.manifestModule,
+        exportName: commercial.manifestExport
+      }
+    ];
+    const loader = config.pluginLoader;
+    if (!loader) throw new Error("community_host_config_plugin_loader_missing");
+    loader.allowlist = [...loader.allowlist ?? [], commercial.pluginModule];
+  }
+  const issues = validateHostConfig(config);
+  if (issues.length > 0) {
+    const first = issues[0];
+    throw new Error(`host_config_invalid:${first.code}:${first.path}`);
+  }
+  const domains = inventory(config);
+  const admittedDomains = getAdmittedDomainIds();
+  exactSet("plugins", domains.pluginDomains, admittedDomains);
+  exactSet("manifest-providers", domains.manifestProviderDomains, admittedDomains);
+  exactSet("remote-sources", domains.sourceDomains, []);
+  exactSet(
+    "plugin-loader",
+    config.pluginLoader?.allowlist ?? [],
+    commercial ? [...COMMUNITY_PLUGIN_MODULES, commercial.pluginModule] : COMMUNITY_PLUGIN_MODULES
+  );
+  exactSet("runtime-env", Object.keys(config.runtime?.env ?? {}), COMMUNITY_RUNTIME_ENV_KEYS);
+  if (config.pluginLoader?.strictAllowlist !== true || config.pluginLoader?.tolerantBootstrap !== false || config.agentGateway?.enabled !== true || config.agentGateway?.includeLocal !== true || config.agentGateway?.catalog?.enabled !== true) {
+    throw new Error("community_host_config_policy_mismatch");
+  }
+  return config;
+}
+const STATIC_HOST_CONFIG = validateStaticCommunityConfig(configRaw);
+const EMPTY_INVENTORY = Object.freeze({
+  pluginDomains: [],
+  manifestProviderDomains: [],
+  sourceDomains: []
+});
+function getHostConfig() {
+  return structuredClone(STATIC_HOST_CONFIG);
+}
+function getHostRegistrationDiagnostics() {
+  const explicit = inventory(STATIC_HOST_CONFIG);
+  return {
+    registrationsDir: "<disabled:community-static-host-config>",
+    count: 0,
+    precedence: ["host.config.json"],
+    explicit,
+    installed: structuredClone(EMPTY_INVENTORY),
+    effective: structuredClone(explicit),
+    registrations: []
+  };
+}
+function applyHostRuntimeEnv(config) {
+  const processEnv = process.env;
+  const bindings = config.runtime?.env ?? {};
+  exactSet("runtime-env-apply", Object.keys(bindings), COMMUNITY_RUNTIME_ENV_KEYS);
+  for (const [targetKey, binding] of Object.entries(bindings)) {
+    const resolved = (typeof binding.value === "string" ? binding.value : void 0) ?? (typeof binding.fromEnv === "string" ? private_env[binding.fromEnv] ?? processEnv[binding.fromEnv] : void 0) ?? (typeof binding.default === "string" ? binding.default : void 0);
+    if ((!resolved || resolved.trim().length === 0) && binding.required === true) {
+      throw new Error(`host_runtime_env_required:${targetKey}`);
+    }
+    if (resolved && resolved.trim().length > 0) processEnv[targetKey] = resolved;
+  }
+}
+function guardCommercialPluginExecution(instance, domain, checkAdmission) {
+  const baseExecute = instance.execute;
+  if (typeof baseExecute !== "function") return instance;
+  return {
+    ...instance,
+    execute: async (args) => {
+      const operationId = String(args?.match?.route?.operation ?? "").trim();
+      if (!operationId) {
+        throw new Error(`domain_admission_denied:${domain}:operation_not_admitted`);
+      }
+      const admission = checkAdmission(domain, operationId);
+      if (!admission.allowed) {
+        throw new Error(`domain_admission_denied:${domain}:${admission.reason}`);
+      }
+      return baseExecute.call(instance, args);
+    }
+  };
+}
+const runtimeImport = new Function("specifier", "return import(specifier)");
+const nodeRequire = createRequire(import.meta.url);
+let pluginImportVersion = 0;
+const DEFAULT_DIAGNOSTICS = {
+  attempt: 0,
+  state: "idle",
+  loadedDomains: [],
+  plugins: []
+};
+let singletonPromise = null;
+let bootstrapAttempt = 0;
+let registryDiagnostics = { ...DEFAULT_DIAGNOSTICS };
+function extractErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error ?? "unknown_error");
+}
+function resolveModuleSpecifier(moduleName) {
+  const trimmed = moduleName.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.startsWith("file://")) return trimmed;
+  if (path.isAbsolute(trimmed)) return pathToFileURL(trimmed).href;
+  if (!trimmed.startsWith(".")) {
+    const resolvePaths = [process.cwd(), path.resolve(process.cwd(), "apps/aops-server")];
+    try {
+      const resolved = nodeRequire.resolve(trimmed, { paths: resolvePaths });
+      return pathToFileURL(resolved).href;
+    } catch {
+      return trimmed;
+    }
+  }
+  const absolutePath = path.resolve(process.cwd(), trimmed);
+  return pathToFileURL(absolutePath).href;
+}
+function withImportVersion(specifier) {
+  if (!specifier.startsWith("file://")) return specifier;
+  const url = new URL(specifier);
+  url.searchParams.set("v", String(pluginImportVersion));
+  return url.href;
+}
+function isModuleAllowed(moduleName, resolvedSpecifier, policy) {
+  const allowlist = policy.allowlist ?? [];
+  if (allowlist.length === 0) return policy.strictAllowlist === false;
+  return allowlist.includes(moduleName) || allowlist.includes(resolvedSpecifier);
+}
+function assertModuleAllowed(moduleName, resolvedSpecifier, pluginConfig, policy) {
+  if (isModuleAllowed(moduleName, resolvedSpecifier, policy)) return;
+  if ((policy.allowlist ?? []).length === 0 && policy.strictAllowlist) {
+    throw new Error(`plugin_module_allowlist_empty:${pluginConfig.domain}`);
+  }
+  throw new Error(`plugin_module_not_allowed:${pluginConfig.domain}:${moduleName}`);
+}
+async function createPluginFromConfig(pluginConfig, policy) {
+  const moduleName = pluginConfig.module;
+  if (!moduleName) {
+    throw new Error(`plugin_module_missing:${pluginConfig.domain}`);
+  }
+  const resolvedSpecifier = resolveModuleSpecifier(moduleName);
+  assertModuleAllowed(moduleName, resolvedSpecifier, pluginConfig, policy);
+  const exportName = pluginConfig.factory?.trim() || "createPlugin";
+  let mod;
+  try {
+    mod = await runtimeImport(withImportVersion(resolvedSpecifier));
+  } catch (error) {
+    throw new Error(
+      `plugin_module_import_failed:${pluginConfig.domain}:${moduleName}:${extractErrorMessage(error)}`
+    );
+  }
+  const maybeFactory = mod[exportName] ?? mod.default;
+  if (typeof maybeFactory !== "function") {
+    throw new Error(`plugin_factory_not_found:${pluginConfig.domain}:${moduleName}#${exportName}`);
+  }
+  const instance = await Promise.resolve(
+    maybeFactory(pluginConfig.options)
+  );
+  if (!instance || typeof instance !== "object") {
+    throw new Error(`plugin_factory_invalid_result:${pluginConfig.domain}`);
+  }
+  const configDomain = normalizeDomainName(pluginConfig.domain);
+  const pluginDomain = normalizeDomainName(instance.domain ?? "");
+  if (configDomain && pluginDomain && configDomain !== pluginDomain) {
+    throw new Error(`plugin_config_domain_mismatch:${configDomain}:${pluginDomain}`);
+  }
+  return guardCommercialPluginExecution(
+    instance,
+    configDomain,
+    checkHostDomainAdmission
+  );
+}
+async function buildRegistry() {
+  const registry = new DomainPluginRegistry();
+  const config = getHostConfig();
+  const policy = config.pluginLoader ?? {
+    allowlist: [],
+    strictAllowlist: false,
+    tolerantBootstrap: false
+  };
+  const tolerantBootstrap = policy.tolerantBootstrap === true;
+  const plugins2 = config.plugins ?? [];
+  const diagnostics2 = {
+    attempt: ++bootstrapAttempt,
+    state: "building",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    loadedDomains: [],
+    plugins: []
+  };
+  registryDiagnostics = diagnostics2;
+  applyHostRuntimeEnv(config);
+  const failedDomains = [];
+  try {
+    for (const pluginConfig of plugins2) {
+      const pluginStart = Date.now();
+      const domain = normalizeDomainName(pluginConfig.domain ?? "");
+      const moduleName = pluginConfig.module?.trim() || null;
+      const factoryName = pluginConfig.factory?.trim() || "createPlugin";
+      if (pluginConfig.enabled === false) {
+        diagnostics2.plugins.push({
+          domain,
+          module: moduleName,
+          factory: factoryName,
+          status: "skipped",
+          durationMs: Date.now() - pluginStart
+        });
+        continue;
+      }
+      if (!checkHostDomainAdmission(domain).allowed) {
+        diagnostics2.plugins.push({
+          domain,
+          module: moduleName,
+          factory: factoryName,
+          status: "skipped",
+          durationMs: Date.now() - pluginStart,
+          error: "domain_not_admitted"
+        });
+        continue;
+      }
+      try {
+        const plugin = await createPluginFromConfig(pluginConfig, policy);
+        registry.register(plugin);
+        diagnostics2.plugins.push({
+          domain: normalizeDomainName(plugin.domain ?? domain),
+          module: moduleName,
+          factory: factoryName,
+          status: "loaded",
+          durationMs: Date.now() - pluginStart
+        });
+      } catch (error) {
+        const message = extractErrorMessage(error);
+        diagnostics2.plugins.push({
+          domain,
+          module: moduleName,
+          factory: factoryName,
+          status: "failed",
+          durationMs: Date.now() - pluginStart,
+          error: message
+        });
+        if (tolerantBootstrap) {
+          failedDomains.push(domain);
+          continue;
+        }
+        throw new Error(`plugin_bootstrap_failed:${domain}:${message}`);
+      }
+    }
+    diagnostics2.state = "ready";
+    if (failedDomains.length > 0) {
+      diagnostics2.error = `plugin_bootstrap_partial_failure:${failedDomains.join(",")}`;
+    }
+    diagnostics2.loadedDomains = registry.listDomains();
+    diagnostics2.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    registryDiagnostics = diagnostics2;
+    return registry;
+  } catch (error) {
+    diagnostics2.state = "failed";
+    diagnostics2.error = extractErrorMessage(error);
+    diagnostics2.loadedDomains = registry.listDomains();
+    diagnostics2.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    registryDiagnostics = diagnostics2;
+    throw error;
+  }
+}
+async function getHostPluginRegistry() {
+  if (singletonPromise) return singletonPromise;
+  singletonPromise = buildRegistry().catch((error) => {
+    singletonPromise = null;
+    throw error;
+  });
+  return singletonPromise;
+}
+function getHostPluginRegistryDiagnostics() {
+  return {
+    ...registryDiagnostics,
+    loadedDomains: [...registryDiagnostics.loadedDomains],
+    plugins: registryDiagnostics.plugins.map((plugin) => ({ ...plugin }))
+  };
+}
+function resetHostPluginRegistry() {
+  singletonPromise = null;
+  pluginImportVersion += 1;
+  registryDiagnostics = {
+    ...DEFAULT_DIAGNOSTICS,
+    loadedDomains: [],
+    plugins: []
+  };
+}
+
+export { getHostRegistrationDiagnostics as a, getHostPluginRegistryDiagnostics as b, getHostAdmissionDiagnostics as c, checkHostDomainAdmission as d, getHostPluginRegistry as e, resetHostPluginRegistry as f, getHostConfig as g, resolveCommunityPackageModule as r };

package/build/server/chunks/request-base-url-zKJpVUv5.js

@@ -0,0 +1,35 @@
+function isLoopbackHostname(value) {
+  const hostname = value.trim().toLowerCase();
+  if (hostname === "localhost" || hostname === "[::1]") return true;
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(hostname);
+  if (!match) return false;
+  const octets = match.slice(1).map(Number);
+  return octets[0] === 127 && octets.every((octet) => octet >= 0 && octet <= 255);
+}
+const VALIDATED_PUBLIC_ORIGIN_HEADER = "x-aops-validated-public-origin";
+function exposureFromEnvironment(processEnv) {
+  const exposure = String(processEnv.AOPS_SERVER_EXPOSURE ?? "").trim();
+  const legacy = String(processEnv.AOPS_COMMUNITY_HOST_MODE ?? "").trim();
+  if (exposure && legacy && exposure !== legacy) {
+    throw new Error("community_server_exposure_env_mismatch");
+  }
+  return exposure || legacy || "loopback";
+}
+function resolveRequestBaseUrl(request, url, processEnv = process.env) {
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || !isLoopbackHostname(url.hostname)) {
+    throw new Error("community_server_loopback_request_origin_required");
+  }
+  const exposure = exposureFromEnvironment(processEnv);
+  const forwardedOrigin = request.headers.get(VALIDATED_PUBLIC_ORIGIN_HEADER);
+  if (exposure === "authenticated-network") {
+    throw new Error(
+      "community_server_authenticated_network_retired_use_remote_session_target"
+    );
+  }
+  if (forwardedOrigin) {
+    throw new Error("community_server_validated_public_origin_unexpected");
+  }
+  return url.origin;
+}
+
+export { resolveRequestBaseUrl as r };