@mh-gg/runtime-config 0.1.1-alpha.20260813T095547173Z

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matterhorn contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,4 @@
+# @mh-gg/runtime-config
+
+Shared relay, signaling, ICE/TURN, transport, and runtime-profile configuration.
+This package does not parse room-authority or publisher options.

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@mh-gg/runtime-config",
+  "version": "0.1.1-alpha.20260813T095547173Z",
+  "description": "Shared runtime, relay, signaling, and ICE configuration for Matterhorn.",
+  "type": "commonjs",
+  "main": "src/index.cjs",
+  "exports": {
+    ".": "./src/index.cjs"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "license": "MIT",
+  "files": [
+    "src",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "coverage": "node --test --experimental-test-coverage --test-coverage-lines=80 --test-coverage-functions=80 --test-coverage-branches=80 --test-coverage-include=src/*.cjs test/*.test.cjs"
+  }
+}

package/src/index.cjs

@@ -0,0 +1,714 @@
+const path = require("node:path");
+const PROTOCOL = 1;
+const DEFAULT_RELAY_MAX_EVENTS = 10000;
+const DEFAULT_RELAY_MAX_EVENTS_PER_ROOM = 2500;
+const DEFAULT_RELAY_MAX_BYTES_PER_ROOM = 8 * 1024 * 1024;
+const DEFAULT_RELAY_MAX_BYTES_TOTAL = 256 * 1024 * 1024;
+const DEFAULT_RELAY_MAX_FILE_BYTES = 10 * 1024 * 1024;
+const DEFAULT_RELAY_MAX_FILE_BYTES_PER_ROOM = 1024 * 1024 * 1024;
+const DEFAULT_RELAY_MAX_FILE_BYTES_TOTAL = 10 * 1024 * 1024 * 1024;
+const DEFAULT_RELAY_FILE_ROOM_POLICY = "allow-all";
+const DEFAULT_RELAY_MAX_EVENTS_PER_PUBKEY_WINDOW = 240;
+const DEFAULT_RELAY_PUBKEY_QUOTA_WINDOW_SECONDS = 10 * 60;
+const DEFAULT_RELAY_MAX_EVENT_BYTES = 8 * 1024;
+const DEFAULT_RELAY_MAX_NIP44_EVENT_BYTES = 60 * 1024;
+const DEFAULT_RELAY_MAX_FUTURE_SECONDS = 10 * 60;
+const DEFAULT_RELAY_ACTIVE_FANOUT = 4;
+const DEFAULT_RELAY_SFU_MAX_PARTICIPANTS = 16;
+const DEFAULT_RELAY_MAX_IPC_MESSAGE_BYTES = 256 * 1024;
+const DEFAULT_RELAY_MAX_ROOM_MESSAGE_BYTES = 64 * 1024;
+const DEFAULT_RELAY_MAX_MESH_MESSAGE_BYTES = 4 * 1024 * 1024;
+const DEFAULT_RELAY_MAX_NOSTR_MESSAGE_BYTES = 64 * 1024;
+const DEFAULT_RELAY_MAX_CALL_SIGNAL_BYTES = 32 * 1024;
+const DEFAULT_RELAY_RATE_WINDOW_MS = 10 * 1000;
+const DEFAULT_RELAY_MAX_UNAUTHENTICATED_MESSAGES_PER_WINDOW = 20;
+const DEFAULT_RELAY_MAX_ROOM_MESSAGES_PER_WINDOW = 120;
+const DEFAULT_RELAY_MAX_MESH_MESSAGES_PER_WINDOW = 240;
+const DEFAULT_RELAY_MAX_IPC_MESSAGES_PER_WINDOW = 240;
+const DEFAULT_RELAY_HEARTBEAT_MS = 1000;
+const DEFAULT_RELAY_HEARTBEAT_TIMEOUT_MS = 2500;
+const DEFAULT_RELAY_FAILOVER_MS = 3500;
+const DEFAULT_RELAY_EDGE_MAX_QUEUED_FRAMES_PER_CONNECTION = 1000;
+const DEFAULT_RELAY_EDGE_MAX_QUEUED_BYTES_PER_CONNECTION = 8 * 1024 * 1024;
+const DEFAULT_RELAY_EDGE_MAX_QUEUED_BYTES_TOTAL = 128 * 1024 * 1024;
+const DEFAULT_RELAY_EDGE_QUEUE_BACKPRESSURE_RATIO = 0.8;
+const DEFAULT_RELAY_EDGE_MAX_MIGRATION_DURATION_MS = 30 * 1000;
+const RELAY_TRANSPORT_MODE_STANDALONE = "standalone";
+const RELAY_TRANSPORT_MODE_EDGE = "edge";
+const RELAY_TRANSPORT_MODE_EDGE_WORKER = "edge-worker";
+const RELAY_TRANSPORT_MODES = new Set([
+  RELAY_TRANSPORT_MODE_STANDALONE,
+  RELAY_TRANSPORT_MODE_EDGE,
+  RELAY_TRANSPORT_MODE_EDGE_WORKER
+]);
+const MATTERHORN_PROFILE_DEVELOPMENT = "development";
+const MATTERHORN_PROFILE_ALPHA = "alpha";
+const MATTERHORN_PROFILE_PRODUCTION = "production";
+const MATTERHORN_PROFILES = new Set([
+  MATTERHORN_PROFILE_DEVELOPMENT,
+  MATTERHORN_PROFILE_ALPHA,
+  MATTERHORN_PROFILE_PRODUCTION
+]);
+
+
+
+function requireCliValue(argv, index, token) {
+  const value = argv[index + 1];
+  if (value === undefined || String(value).startsWith("--")) {
+    throw new Error(`${token} requires a value.`);
+  }
+  return value;
+}
+
+function requireFiniteNumber(value, name, { integer = false, min = 0, max = Number.MAX_SAFE_INTEGER, optional = false } = {}) {
+  if (optional && value === undefined) return undefined;
+  if (!Number.isFinite(value)) throw new Error(`${name} must be a finite number.`);
+  if (integer && !Number.isInteger(value)) throw new Error(`${name} must be an integer.`);
+  if (value < min || value > max) throw new Error(`${name} must be between ${min} and ${max}.`);
+  return value;
+}
+
+function validateRelayNumericOptions(args) {
+  const integerNonNegative = [
+    "ipcPort", "activeRelayFanout", "relayHeartbeatMs", "relayHeartbeatTimeoutMs", "relayFailoverMs",
+    "maxEvents", "maxEventsPerRoom", "maxBytesPerRoom", "maxBytesTotal", "maxFileBytes",
+    "maxFileBytesPerRoom", "maxFileBytesTotal", "maxEventsPerPubkeyWindow",
+    "pubkeyQuotaWindowSeconds", "maxEventBytes", "maxFutureSeconds", "sfuMaxParticipants",
+    "edgeMaxQueuedFramesPerConnection", "edgeMaxQueuedBytesPerConnection", "edgeMaxQueuedBytesTotal",
+    "edgeMaxMigrationDurationMs", "edgeRolloutReadyTimeoutMs", "edgeRolloutCanaryTimeoutMs",
+    "edgeRolloutFlushTimeoutMs", "edgeRolloutActivationTimeoutMs", "edgePostActivationBakeMs"
+  ];
+  for (const key of integerNonNegative) {
+    if (args[key] !== undefined) requireFiniteNumber(args[key], key, { integer: true, min: key === "ipcPort" ? 1 : 0, max: key === "ipcPort" ? 65535 : Number.MAX_SAFE_INTEGER });
+  }
+  if (args.quotaWarningRatio !== undefined) requireFiniteNumber(args.quotaWarningRatio, "quotaWarningRatio", { min: 0, max: 1 });
+  requireFiniteNumber(args.edgeQueueBackpressureRatio, "edgeQueueBackpressureRatio", { min: 0, max: 1 });
+  if (args.relayHeartbeatTimeoutMs < args.relayHeartbeatMs) {
+    throw new Error("relayHeartbeatTimeoutMs must be greater than or equal to relayHeartbeatMs.");
+  }
+  if (args.maxEventsPerRoom > args.maxEvents) {
+    throw new Error("maxEventsPerRoom cannot exceed maxEvents.");
+  }
+  if (args.maxBytesPerRoom > args.maxBytesTotal) {
+    throw new Error("maxBytesPerRoom cannot exceed maxBytesTotal.");
+  }
+  if (args.maxFileBytes > args.maxFileBytesPerRoom) {
+    throw new Error("maxFileBytes cannot exceed maxFileBytesPerRoom.");
+  }
+  if (args.maxFileBytesPerRoom > args.maxFileBytesTotal) {
+    throw new Error("maxFileBytesPerRoom cannot exceed maxFileBytesTotal.");
+  }
+  if (!["allow-all", "allow-list"].includes(args.fileRoomPolicy)) {
+    throw new Error("fileRoomPolicy must be allow-all or allow-list.");
+  }
+  if (args.edgeMaxQueuedBytesPerConnection > args.edgeMaxQueuedBytesTotal) {
+    throw new Error("edgeMaxQueuedBytesPerConnection cannot exceed edgeMaxQueuedBytesTotal.");
+  }
+  return args;
+}
+
+function parseRelayPeers(value) {
+  return String(value || "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseIceServers(value) {
+  if (Array.isArray(value)) return value.map(normalizeIceServer).filter(Boolean);
+  return String(value || "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((urls) => ({ urls: normalizeIceServerUrl(urls, "ICE server") }));
+}
+
+function normalizeIceServerUrl(value, name) {
+  const url = String(value || "").trim();
+  if (!/^(stun|stuns|turn|turns):[^,\s]+$/i.test(url)) {
+    throw new Error(`Invalid ${name} URL ${JSON.stringify(value)}.`);
+  }
+  return url;
+}
+
+function normalizeIceServer(server) {
+  if (!server) return undefined;
+  if (typeof server === "string") return { urls: normalizeIceServerUrl(server, "ICE server") };
+  if (typeof server !== "object") throw new Error(`Invalid ICE server ${JSON.stringify(server)}.`);
+  const urls = Array.isArray(server.urls)
+    ? server.urls.map((url) => normalizeIceServerUrl(url, "ICE server"))
+    : normalizeIceServerUrl(server.urls, "ICE server");
+  const normalized = { urls };
+  if (typeof server.username === "string") normalized.username = server.username;
+  if (Object.prototype.hasOwnProperty.call(server, "credential")) normalized.credential = server.credential;
+  return normalized;
+}
+
+function iceServerUrls(servers) {
+  return servers.flatMap((server) => Array.isArray(server.urls) ? server.urls : [server.urls]);
+}
+
+function redactIceServers(servers) {
+  return parseIceServers(servers).map((server) => {
+    const redacted = { ...server };
+    if (Object.prototype.hasOwnProperty.call(redacted, "credential")) redacted.credential = "<redacted>";
+    return redacted;
+  });
+}
+
+function normalizeTurnCredential(value, name) {
+  const text = String(value || "").trim();
+  if (!text) throw new Error(`${name} is required when MATTERHORN_TURN_URLS is set.`);
+  return text;
+}
+
+function parseTurnIceServers(env = process.env) {
+  const urls = String(env.MATTERHORN_TURN_URLS || "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  if (!urls.length) return [];
+  const username = normalizeTurnCredential(env.MATTERHORN_TURN_USERNAME, "MATTERHORN_TURN_USERNAME");
+  const credential = normalizeTurnCredential(env.MATTERHORN_TURN_CREDENTIAL, "MATTERHORN_TURN_CREDENTIAL");
+  return [{
+    urls: urls.map((entry) => {
+      const url = normalizeIceServerUrl(entry, "MATTERHORN_TURN_URLS");
+      if (!/^turns?:/i.test(url)) throw new Error(`Invalid MATTERHORN_TURN_URLS entry ${JSON.stringify(entry)}.`);
+      return url;
+    }),
+    username,
+    credential
+  }];
+}
+
+function normalizeIceMode(value) {
+  const mode = String(value || "").trim().toLowerCase();
+  if (!mode) return undefined;
+  if (["local", "external", "none"].includes(mode)) return mode;
+  throw new Error("MATTERHORN_ICE_MODE must be local, external, or none.");
+}
+
+function parseExternalIceServersJson(value) {
+  if (!String(value || "").trim()) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(`MATTERHORN_EXTERNAL_ICE_SERVERS_JSON is not valid JSON: ${error.message}`);
+  }
+  if (!Array.isArray(parsed)) throw new Error("MATTERHORN_EXTERNAL_ICE_SERVERS_JSON must be an array.");
+  return parsed.map(normalizeIceServer).filter(Boolean);
+}
+
+function localTurnIceServers(env = process.env) {
+  const turnHost = String(env.MATTERHORN_TURN_HOST || env.MATTERHORN_TURN_REALM || "").trim();
+  const turnPort = String(env.MATTERHORN_TURN_PORT || "3478").trim();
+  const turnsPort = String(env.MATTERHORN_TURNS_PORT || "5349").trim();
+  const turnsEnabled = parseBool(env.MATTERHORN_TURNS_ENABLED);
+  const stun = turnHost ? [{ urls: normalizeIceServerUrl(`stun:${turnHost}:${turnPort}`, "MATTERHORN_TURN_HOST") }] : [];
+  const explicitTurn = parseTurnIceServers(env);
+  if (explicitTurn.length || !turnHost) return [...stun, ...explicitTurn];
+  const username = normalizeTurnCredential(env.MATTERHORN_TURN_USERNAME, "MATTERHORN_TURN_USERNAME");
+  const credential = normalizeTurnCredential(env.MATTERHORN_TURN_CREDENTIAL, "MATTERHORN_TURN_CREDENTIAL");
+  const urls = [
+    normalizeIceServerUrl(`turn:${turnHost}:${turnPort}?transport=udp`, "MATTERHORN_TURN_HOST"),
+    normalizeIceServerUrl(`turn:${turnHost}:${turnPort}?transport=tcp`, "MATTERHORN_TURN_HOST")
+  ];
+  if (turnsEnabled) urls.push(normalizeIceServerUrl(`turns:${turnHost}:${turnsPort}?transport=tcp`, "MATTERHORN_TURN_HOST"));
+  return [...stun, { urls, username, credential }];
+}
+
+function configuredIceServers(env = process.env, fallback = "stun:stun.l.google.com:19302") {
+  const mode = normalizeIceMode(env.MATTERHORN_ICE_MODE);
+  if (mode === "none") return [];
+  if (mode === "external") {
+    const external = parseExternalIceServersJson(env.MATTERHORN_EXTERNAL_ICE_SERVERS_JSON);
+    if (external.length) return external;
+    return [...parseIceServers(env.ICE_SERVERS || ""), ...parseTurnIceServers(env)];
+  }
+  if (mode === "local") {
+    return [...parseIceServers(env.ICE_SERVERS || ""), ...localTurnIceServers(env)];
+  }
+  const configured = parseIceServers(env.ICE_SERVERS || fallback);
+  return [...configured, ...parseTurnIceServers(env)];
+}
+
+function parseBool(value) {
+  return ["1", "true", "yes", "on"].includes(String(value || "").trim().toLowerCase());
+}
+
+function isMatterhornProfile(value) {
+  return MATTERHORN_PROFILES.has(value);
+}
+
+function defaultMatterhornProfile(env = process.env) {
+  return env.NODE_ENV === "production" ? MATTERHORN_PROFILE_PRODUCTION : MATTERHORN_PROFILE_DEVELOPMENT;
+}
+
+function normalizeMatterhornProfile(value, fallback = MATTERHORN_PROFILE_DEVELOPMENT) {
+  const profile = String(value || fallback || "").trim().toLowerCase();
+  if (!isMatterhornProfile(profile)) throw new Error(`Invalid Matterhorn profile ${JSON.stringify(value)}.`);
+  return profile;
+}
+
+function defaultRuntimeDataDir() {
+  return path.resolve(".matterhorn");
+}
+
+function defaultRelayStoragePath(dataDir) {
+  return path.join(dataDir, "relay");
+}
+
+function resolveStoragePath(value, fallback) {
+  const raw = String(value || fallback || "");
+  if (raw === "~") return require("node:os").homedir();
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return path.join(require("node:os").homedir(), raw.slice(2));
+  }
+  return path.resolve(raw);
+}
+
+function parseRelayNumeric(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function normalizeRelayTransportMode(value) {
+  const mode = String(value || "").trim();
+  if (!mode) return undefined;
+  if (RELAY_TRANSPORT_MODES.has(mode)) return mode;
+  throw new Error(`Invalid relay transport mode ${JSON.stringify(value)}.`);
+}
+
+function resolveRelayTransportMode(input = {}, options = {}) {
+  const edgeSocket = String(input.edgeSocket || "").trim();
+  const mode = normalizeRelayTransportMode(input.transportMode)
+    || (edgeSocket ? RELAY_TRANSPORT_MODE_EDGE_WORKER : RELAY_TRANSPORT_MODE_STANDALONE);
+
+  if (mode === RELAY_TRANSPORT_MODE_EDGE) {
+    if (!options.allowEdgeMode) throw new Error("Relay edge mode must be started with matterhorn relay edge start, not matterhorn relay start.");
+    if (!edgeSocket) throw new Error("edge transport mode requires --socket or MATTERHORN_RELAY_EDGE_SOCKET.");
+    return mode;
+  }
+  if (mode === RELAY_TRANSPORT_MODE_EDGE_WORKER && !edgeSocket) {
+    throw new Error("edge-worker transport mode requires --edge-socket or MATTERHORN_RELAY_EDGE_SOCKET.");
+  }
+  if (mode === RELAY_TRANSPORT_MODE_STANDALONE && edgeSocket) {
+    throw new Error("Configured edge socket requires edge-worker transport mode; refusing to start standalone with edge-worker configuration.");
+  }
+  return mode;
+}
+
+function parseRelayArgsFromEnv(env, options = {}) {
+  const defaultStoragePath = options.defaultStoragePath || defaultRelayStoragePath(options.defaultDataDir || defaultRuntimeDataDir());
+  const iceServerConfigs = configuredIceServers(env);
+  return {
+    matterhornProfile: normalizeMatterhornProfile(env.MATTERHORN_PROFILE, defaultMatterhornProfile(env)),
+    ipcHost: env.MATTERHORN_RELAY_IPC_HOST || options.defaultIpcHost || "127.0.0.1",
+    ipcPort: parseRelayNumeric(env.MATTERHORN_RELAY_IPC_PORT, options.defaultIpcPort || 42777),
+    storagePath: env.MATTERHORN_RELAY_STORAGE || defaultStoragePath,
+    relayPeerId: env.MATTERHORN_RELAY_PEER_ID || undefined,
+    relayName: env.MATTERHORN_RELAY_NAME || undefined,
+    relayDomain: env.MATTERHORN_RELAY_DOMAIN || undefined,
+    relayLauncherUrl: env.MATTERHORN_RELAY_LAUNCHER_URL || undefined,
+    relayVaultUrl: env.MATTERHORN_RELAY_VAULT_URL || undefined,
+    relayAppHostUrl: env.MATTERHORN_RELAY_APP_HOST_URL || undefined,
+    relayRoomWebSocketUrl: env.MATTERHORN_RELAY_ROOM_WEBSOCKET_URL || undefined,
+    oauthEnabled: parseBool(env.MATTERHORN_OAUTH_ENABLED),
+    oauthConfigPath: env.MATTERHORN_OAUTH_CONFIG || undefined,
+    oauthDeliveryOrigin: env.MATTERHORN_OAUTH_DELIVERY_ORIGIN || undefined,
+    relayPeers: parseRelayPeers(env.MATTERHORN_RELAY_PEERS),
+    relayRefs: parseRelayPeers(env.MATTERHORN_RELAY_REFS),
+    nondiscoverable: parseBool(env.MATTERHORN_RELAY_NONDISCOVERABLE),
+    activeRelayFanout: parseRelayNumeric(env.MATTERHORN_RELAY_ACTIVE_FANOUT, DEFAULT_RELAY_ACTIVE_FANOUT),
+    relayHeartbeatMs: parseRelayNumeric(env.MATTERHORN_RELAY_HEARTBEAT_MS, DEFAULT_RELAY_HEARTBEAT_MS),
+    relayHeartbeatTimeoutMs: parseRelayNumeric(env.MATTERHORN_RELAY_HEARTBEAT_TIMEOUT_MS, DEFAULT_RELAY_HEARTBEAT_TIMEOUT_MS),
+    relayFailoverMs: parseRelayNumeric(env.MATTERHORN_RELAY_FAILOVER_MS, DEFAULT_RELAY_FAILOVER_MS),
+    maxEvents: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_EVENTS, DEFAULT_RELAY_MAX_EVENTS),
+    maxEventsPerRoom: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_EVENTS_PER_ROOM, DEFAULT_RELAY_MAX_EVENTS_PER_ROOM),
+    maxBytesPerRoom: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_BYTES_PER_ROOM, DEFAULT_RELAY_MAX_BYTES_PER_ROOM),
+    maxBytesTotal: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_BYTES_TOTAL, DEFAULT_RELAY_MAX_BYTES_TOTAL),
+    maxFileBytes: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_FILE_BYTES, DEFAULT_RELAY_MAX_FILE_BYTES),
+    maxFileBytesPerRoom: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_FILE_BYTES_PER_ROOM, DEFAULT_RELAY_MAX_FILE_BYTES_PER_ROOM),
+    maxFileBytesTotal: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_FILE_BYTES_TOTAL, DEFAULT_RELAY_MAX_FILE_BYTES_TOTAL),
+    fileRoomPolicy: String(env.MATTERHORN_RELAY_FILE_ROOM_POLICY || DEFAULT_RELAY_FILE_ROOM_POLICY).trim().toLowerCase(),
+    fileAllowedRooms: parseRelayPeers(env.MATTERHORN_RELAY_FILE_ALLOWED_ROOMS),
+    fileDeniedRooms: parseRelayPeers(env.MATTERHORN_RELAY_FILE_DENIED_ROOMS),
+    quotaWarningRatio: parseRelayNumeric(env.MATTERHORN_RELAY_QUOTA_WARNING_RATIO, undefined),
+    relayTrustMode: env.MATTERHORN_RELAY_TRUST_MODE || undefined,
+    transportMode: env.MATTERHORN_RELAY_TRANSPORT_MODE || undefined,
+    edgeSocket: env.MATTERHORN_RELAY_EDGE_SOCKET || undefined,
+    edgeWorkerId: env.MATTERHORN_RELAY_EDGE_WORKER_ID || undefined,
+    edgeWorkerSecretFile: env.MATTERHORN_RELAY_EDGE_WORKER_SECRET_FILE || undefined,
+    allowInsecureWorkerAuth: parseBool(env.MATTERHORN_RELAY_ALLOW_INSECURE_WORKER_AUTH),
+    relayPackageName: env.MATTERHORN_RELAY_PACKAGE_NAME || undefined,
+    relayPackageTag: env.MATTERHORN_RELAY_PACKAGE_TAG || undefined,
+    relayPackageVersion: env.MATTERHORN_RELAY_PACKAGE_VERSION || undefined,
+    relayWorkerImage: env.MATTERHORN_RELAY_WORKER_IMAGE || undefined,
+    relayWorkerImageMode: env.MATTERHORN_RELAY_WORKER_IMAGE_MODE || undefined,
+    relayWorkerImagePrefix: env.MATTERHORN_RELAY_WORKER_IMAGE_PREFIX || undefined,
+    relayWorkerImageBuildContext: env.MATTERHORN_RELAY_WORKER_IMAGE_BUILD_CONTEXT || undefined,
+    relayWorkerCliPackageName: env.MATTERHORN_RELAY_WORKER_CLI_PACKAGE_NAME || undefined,
+    relayWorkerController: env.MATTERHORN_RELAY_WORKER_CONTROLLER || undefined,
+    relayWorkerComposeFile: env.MATTERHORN_RELAY_COMPOSE_FILE || undefined,
+    relayWorkerComposeProjectDirectory: env.MATTERHORN_RELAY_COMPOSE_PROJECT_DIRECTORY || undefined,
+    relayWorkerComposeProjectName: env.MATTERHORN_RELAY_COMPOSE_PROJECT_NAME || undefined,
+    relayReleaseStorageClass: env.MATTERHORN_RELAY_RELEASE_STORAGE_CLASS || env.MATTERHORN_RELAY_STORAGE_MIGRATION_CLASS || undefined,
+    relayAllowStorageBreakingRollout: parseBool(env.MATTERHORN_RELAY_ALLOW_STORAGE_BREAKING_ROLLOUT),
+    relayStorageBackupDir: env.MATTERHORN_RELAY_STORAGE_BACKUP_DIR || undefined,
+    edgeRolloutStatePath: env.MATTERHORN_RELAY_ROLLOUT_STATE || undefined,
+    edgeRolloutLockPath: env.MATTERHORN_RELAY_ROLLOUT_LOCK || undefined,
+    edgeRolloutReadyTimeoutMs: parseRelayNumeric(env.MATTERHORN_RELAY_ROLLOUT_READY_TIMEOUT_MS, undefined),
+    edgeRolloutCanaryTimeoutMs: parseRelayNumeric(env.MATTERHORN_RELAY_ROLLOUT_CANARY_TIMEOUT_MS, undefined),
+    edgeRolloutFlushTimeoutMs: parseRelayNumeric(env.MATTERHORN_RELAY_ROLLOUT_FLUSH_TIMEOUT_MS, undefined),
+    edgeRolloutActivationTimeoutMs: parseRelayNumeric(env.MATTERHORN_RELAY_ROLLOUT_ACTIVATION_TIMEOUT_MS, undefined),
+    edgePostActivationBakeMs: parseRelayNumeric(env.MATTERHORN_RELAY_EDGE_POST_ACTIVATION_BAKE_MS || env.MATTERHORN_RELAY_ROLLOUT_BAKE_MS, undefined),
+    edgeQueuePath: env.MATTERHORN_RELAY_EDGE_QUEUE || env.MATTERHORN_RELAY_EDGE_QUEUE_PATH || undefined,
+    edgeMaxQueuedFramesPerConnection: parseRelayNumeric(env.MATTERHORN_RELAY_EDGE_MAX_QUEUED_FRAMES_PER_CONNECTION, DEFAULT_RELAY_EDGE_MAX_QUEUED_FRAMES_PER_CONNECTION),
+    edgeMaxQueuedBytesPerConnection: parseRelayNumeric(env.MATTERHORN_RELAY_EDGE_MAX_QUEUED_BYTES_PER_CONNECTION, DEFAULT_RELAY_EDGE_MAX_QUEUED_BYTES_PER_CONNECTION),
+    edgeMaxQueuedBytesTotal: parseRelayNumeric(env.MATTERHORN_RELAY_EDGE_MAX_QUEUED_BYTES_TOTAL, DEFAULT_RELAY_EDGE_MAX_QUEUED_BYTES_TOTAL),
+    edgeQueueBackpressureRatio: parseRelayNumeric(env.MATTERHORN_RELAY_EDGE_QUEUE_BACKPRESSURE_RATIO, DEFAULT_RELAY_EDGE_QUEUE_BACKPRESSURE_RATIO),
+    edgeMaxMigrationDurationMs: parseRelayNumeric(env.MATTERHORN_RELAY_EDGE_MAX_MIGRATION_DURATION_MS, DEFAULT_RELAY_EDGE_MAX_MIGRATION_DURATION_MS),
+    maxEventsPerPubkeyWindow: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_EVENTS_PER_PUBKEY_WINDOW, DEFAULT_RELAY_MAX_EVENTS_PER_PUBKEY_WINDOW),
+    pubkeyQuotaWindowSeconds: parseRelayNumeric(env.MATTERHORN_RELAY_PUBKEY_QUOTA_WINDOW_SECONDS, DEFAULT_RELAY_PUBKEY_QUOTA_WINDOW_SECONDS),
+    maxEventBytes: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_EVENT_BYTES, DEFAULT_RELAY_MAX_EVENT_BYTES),
+    maxFutureSeconds: parseRelayNumeric(env.MATTERHORN_RELAY_MAX_FUTURE_SECONDS, DEFAULT_RELAY_MAX_FUTURE_SECONDS),
+    sfuEnabled: parseBool(env.MATTERHORN_RELAY_SFU),
+    sfuPeerId: env.MATTERHORN_RELAY_SFU_PEER_ID || undefined,
+    sfuMaxParticipants: parseRelayNumeric(env.MATTERHORN_RELAY_SFU_MAX_PARTICIPANTS, DEFAULT_RELAY_SFU_MAX_PARTICIPANTS),
+    iceServers: iceServerUrls(iceServerConfigs).join(","),
+    iceServerConfigs,
+    localPeerjs: parseBool(env.MATTERHORN_RELAY_PEERJS_LOCAL)
+  };
+}
+
+function applyRelayCliArg(args, token, index, argv, warn) {
+  const key = token.slice(2);
+  const value = argv[index + 1];
+  const valueOptions = new Set([
+    "host", "ipc-host", "port", "ipc-port", "data-dir", "storage", "profile", "matterhorn-profile",
+    "relay-peer-id", "name", "relay-name", "relay-domain", "relay-launcher-url", "relay-vault-url", "relay-app-host-url", "relay-room-websocket-url", "oauth-config", "oauth-delivery-origin", "relay-peer", "addRelay", "add-relay", "active-relay-fanout",
+    "relay-heartbeat-ms", "relay-heartbeat-timeout-ms", "relay-failover-ms", "max-events", "max-events-per-room",
+    "max-bytes-per-room", "max-room-data-total", "max-relay-data-total", "max-file-bytes",
+    "max-file-bytes-per-room", "max-file-bytes-total", "file-room-policy", "allow-file-room",
+    "deny-file-room", "quota-warning-ratio", "transport-mode",
+    "edge-socket", "socket", "edge-worker-id", "edge-worker-secret-file", "worker-secret-file", "package",    "package-tag", "package-version", "worker-image", "worker-image-mode", "worker-image-prefix",
+    "worker-image-build-context", "worker-cli-package", "worker-controller", "compose-file",
+    "compose-project-directory", "compose-project-name", "release-storage-class", "storage-migration-class",
+    "storage-backup-dir", "rollout-state", "rollout-lock", "rollout-ready-timeout-ms",
+    "rollout-canary-timeout-ms", "rollout-flush-timeout-ms", "rollout-activation-timeout-ms",
+    "post-activation-bake-ms", "edge-queue", "edge-queue-path", "edge-max-queued-frames-per-connection",
+    "edge-max-queued-bytes-per-connection", "edge-max-queued-bytes-total", "edge-queue-backpressure-ratio",
+    "edge-max-migration-duration-ms", "max-events-per-pubkey-window", "pubkey-quota-window-seconds",
+    "max-event-bytes", "max-future-seconds", "sfu-peer-id", "sfu-max-participants", "ice"
+  ]);
+  if (valueOptions.has(key)) requireCliValue(argv, index, token);
+  switch (key) {
+    case "host":
+    case "ipc-host":
+      return { index: index + 1, updates: { ipcHost: value } };
+    case "port":
+    case "ipc-port":
+      return { index: index + 1, updates: { ipcPort: Number(value) } };
+    case "data-dir":
+      return { index: index + 1, updates: { dataDir: value } };
+    case "storage":
+      return { index: index + 1, updates: { storagePath: value } };
+    case "profile":
+    case "matterhorn-profile":
+      return { index: index + 1, updates: { matterhornProfile: normalizeMatterhornProfile(value) } };
+    case "relay-peer-id":
+      return { index: index + 1, updates: { relayPeerId: value } };
+    case "name":
+    case "relay-name":
+      return { index: index + 1, updates: { relayName: value } };
+    case "relay-domain":
+      return { index: index + 1, updates: { relayDomain: value } };
+    case "relay-launcher-url":
+      return { index: index + 1, updates: { relayLauncherUrl: value } };
+    case "relay-vault-url":
+      return { index: index + 1, updates: { relayVaultUrl: value } };
+    case "relay-app-host-url":
+      return { index: index + 1, updates: { relayAppHostUrl: value } };
+    case "relay-room-websocket-url":
+      return { index: index + 1, updates: { relayRoomWebSocketUrl: value } };
+    case "relay-peer":
+      return { index: index + 1, updates: { relayPeers: [...args.relayPeers, value] } };
+    case "addRelay":    case "add-relay":
+      return { index: index + 1, updates: { relayRefs: [...args.relayRefs, value] } };
+    case "nondiscoverable":
+      return { index, updates: { nondiscoverable: true } };
+    case "active-relay-fanout":
+      return { index: index + 1, updates: { activeRelayFanout: Number(value) } };
+    case "relay-heartbeat-ms":
+      return { index: index + 1, updates: { relayHeartbeatMs: Number(value) } };
+    case "relay-heartbeat-timeout-ms":
+      return { index: index + 1, updates: { relayHeartbeatTimeoutMs: Number(value) } };
+    case "relay-failover-ms":
+      return { index: index + 1, updates: { relayFailoverMs: Number(value) } };
+    case "max-events":
+      return { index: index + 1, updates: { maxEvents: Number(value) } };
+    case "max-events-per-room":
+      return { index: index + 1, updates: { maxEventsPerRoom: Number(value) } };
+    case "max-bytes-per-room":
+    case "max-room-data-total":
+      return { index: index + 1, updates: { maxBytesPerRoom: Number(value) } };
+    case "max-relay-data-total":
+      return { index: index + 1, updates: { maxBytesTotal: Number(value) } };
+    case "max-file-bytes":
+      return { index: index + 1, updates: { maxFileBytes: Number(value) } };
+    case "max-file-bytes-per-room":
+      return { index: index + 1, updates: { maxFileBytesPerRoom: Number(value) } };
+    case "max-file-bytes-total":
+      return { index: index + 1, updates: { maxFileBytesTotal: Number(value) } };
+    case "file-room-policy":
+      return { index: index + 1, updates: { fileRoomPolicy: String(value).trim().toLowerCase() } };
+    case "allow-file-room":
+      return { index: index + 1, updates: { fileAllowedRooms: [...args.fileAllowedRooms, value] } };
+    case "deny-file-room":
+      return { index: index + 1, updates: { fileDeniedRooms: [...args.fileDeniedRooms, value] } };
+    case "quota-warning-ratio":
+      return { index: index + 1, updates: { quotaWarningRatio: Number(value) } };
+    case "auto-trust-relays":
+      return { index, updates: { relayTrustMode: "accept" } };
+    case "manual-trust-relays":
+    case "no-auto-trust-relays":
+      return { index, updates: { relayTrustMode: "pending" } };
+    case "auto-reject-relays":
+      return { index, updates: { relayTrustMode: "reject" } };
+    case "transport-mode":
+      return { index: index + 1, updates: { transportMode: value } };
+    case "oauth":
+      return { index, updates: { oauthEnabled: true } };
+    case "no-oauth":
+      return { index, updates: { oauthEnabled: false } };
+    case "oauth-delivery-origin":
+      return { index: index + 1, updates: { oauthDeliveryOrigin: value } };
+    case "oauth-config":
+      return { index: index + 1, updates: { oauthConfigPath: value } };
+    case "edge-socket":
+    case "socket":
+      return { index: index + 1, updates: { edgeSocket: value } };
+    case "edge-worker-id":
+      return { index: index + 1, updates: { edgeWorkerId: value } };
+    case "edge-worker-secret-file":
+    case "worker-secret-file":
+      return { index: index + 1, updates: { edgeWorkerSecretFile: value } };
+    case "allow-insecure-worker-auth":
+      return { index, updates: { allowInsecureWorkerAuth: true } };
+    case "package":
+      return { index: index + 1, updates: { relayPackageName: value } };
+    case "package-tag":
+      return { index: index + 1, updates: { relayPackageTag: value } };
+    case "package-version":
+      return { index: index + 1, updates: { relayPackageVersion: value } };
+    case "worker-image":
+      return { index: index + 1, updates: { relayWorkerImage: value } };
+    case "worker-image-mode":
+      return { index: index + 1, updates: { relayWorkerImageMode: value } };
+    case "worker-image-prefix":
+      return { index: index + 1, updates: { relayWorkerImagePrefix: value } };
+    case "worker-image-build-context":
+      return { index: index + 1, updates: { relayWorkerImageBuildContext: value } };
+    case "worker-cli-package":
+      return { index: index + 1, updates: { relayWorkerCliPackageName: value } };
+    case "worker-controller":
+      return { index: index + 1, updates: { relayWorkerController: value } };
+    case "compose-file":
+      return { index: index + 1, updates: { relayWorkerComposeFile: value } };
+    case "compose-project-directory":
+      return { index: index + 1, updates: { relayWorkerComposeProjectDirectory: value } };
+    case "compose-project-name":
+      return { index: index + 1, updates: { relayWorkerComposeProjectName: value } };
+    case "release-storage-class":
+    case "storage-migration-class":
+      return { index: index + 1, updates: { relayReleaseStorageClass: value } };
+    case "allow-storage-breaking-rollout":
+      return { index, updates: { relayAllowStorageBreakingRollout: true } };
+    case "storage-backup-dir":
+      return { index: index + 1, updates: { relayStorageBackupDir: value } };
+    case "rollout-state":
+      return { index: index + 1, updates: { edgeRolloutStatePath: value } };
+    case "rollout-lock":
+      return { index: index + 1, updates: { edgeRolloutLockPath: value } };
+    case "rollout-ready-timeout-ms":
+      return { index: index + 1, updates: { edgeRolloutReadyTimeoutMs: Number(value) } };
+    case "rollout-canary-timeout-ms":
+      return { index: index + 1, updates: { edgeRolloutCanaryTimeoutMs: Number(value) } };
+    case "rollout-flush-timeout-ms":
+      return { index: index + 1, updates: { edgeRolloutFlushTimeoutMs: Number(value) } };
+    case "rollout-activation-timeout-ms":
+      return { index: index + 1, updates: { edgeRolloutActivationTimeoutMs: Number(value) } };
+    case "post-activation-bake-ms":
+      return { index: index + 1, updates: { edgePostActivationBakeMs: Number(value) } };
+    case "edge-queue":
+    case "edge-queue-path":
+      return { index: index + 1, updates: { edgeQueuePath: value } };
+    case "edge-max-queued-frames-per-connection":
+      return { index: index + 1, updates: { edgeMaxQueuedFramesPerConnection: Number(value) } };
+    case "edge-max-queued-bytes-per-connection":
+      return { index: index + 1, updates: { edgeMaxQueuedBytesPerConnection: Number(value) } };
+    case "edge-max-queued-bytes-total":
+      return { index: index + 1, updates: { edgeMaxQueuedBytesTotal: Number(value) } };
+    case "edge-queue-backpressure-ratio":
+      return { index: index + 1, updates: { edgeQueueBackpressureRatio: Number(value) } };
+    case "edge-max-migration-duration-ms":
+      return { index: index + 1, updates: { edgeMaxMigrationDurationMs: Number(value) } };
+    case "max-events-per-pubkey-window":
+      return { index: index + 1, updates: { maxEventsPerPubkeyWindow: Number(value) } };
+    case "pubkey-quota-window-seconds":
+      return { index: index + 1, updates: { pubkeyQuotaWindowSeconds: Number(value) } };
+    case "max-event-bytes":
+      return { index: index + 1, updates: { maxEventBytes: Number(value) } };
+    case "max-future-seconds":
+      return { index: index + 1, updates: { maxFutureSeconds: Number(value) } };
+    case "sfu":
+      return { index, updates: { sfuEnabled: true } };
+    case "no-sfu":
+      return { index, updates: { sfuEnabled: false } };
+    case "sfu-peer-id":
+      return { index: index + 1, updates: { sfuPeerId: value } };
+    case "sfu-max-participants":
+      return { index: index + 1, updates: { sfuMaxParticipants: Number(value) } };
+    case "ice":
+      return { index: index + 1, updates: { iceServers: value, iceServerConfigs: parseIceServers(value) } };
+    case "local-peerjs":
+    case "peerjs-local":
+      return { index, updates: { localPeerjs: true } };
+    case "no-local-peerjs":
+      return { index, updates: { localPeerjs: false } };
+    default:
+      warn(`Unknown relay option: ${token}`);
+      return { index, updates: {} };
+  }
+}
+
+function parseRelayArgs(argv, options = {}) {
+  const env = options.env || process.env;
+  const warn = options.warn || console.warn;
+  const defaultStoragePath = options.defaultStoragePath || defaultRelayStoragePath(options.defaultDataDir || defaultRuntimeDataDir());
+  const storageExplicit = Boolean(env.MATTERHORN_RELAY_STORAGE) || argv.includes("--storage");
+  const args = parseRelayArgsFromEnv(env, {
+    ...options,
+    defaultStoragePath,
+    defaultIpcPort: options.defaultIpcPort || 42777
+  });
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const result = applyRelayCliArg(args, token, index, argv, warn);
+    index = result.index;
+    Object.assign(args, result.updates);
+  }
+
+  if (args.dataDir) args.dataDir = path.resolve(args.dataDir);
+  args.storagePath = storageExplicit
+    ? resolveStoragePath(args.storagePath, defaultStoragePath)
+    : args.dataDir
+      ? defaultRelayStoragePath(args.dataDir)
+      : resolveStoragePath(args.storagePath, defaultStoragePath);
+  if (args.edgeQueuePath) args.edgeQueuePath = resolveStoragePath(args.edgeQueuePath);
+  if (args.edgeRolloutStatePath) args.edgeRolloutStatePath = resolveStoragePath(args.edgeRolloutStatePath);
+  if (args.edgeRolloutLockPath) args.edgeRolloutLockPath = resolveStoragePath(args.edgeRolloutLockPath);
+  if (args.relayWorkerImageBuildContext) args.relayWorkerImageBuildContext = path.resolve(args.relayWorkerImageBuildContext);
+  if (args.relayWorkerComposeFile) args.relayWorkerComposeFile = path.resolve(args.relayWorkerComposeFile);
+  if (args.relayWorkerComposeProjectDirectory) args.relayWorkerComposeProjectDirectory = path.resolve(args.relayWorkerComposeProjectDirectory);
+  if (args.relayStorageBackupDir) args.relayStorageBackupDir = path.resolve(args.relayStorageBackupDir);
+  args.transportMode = resolveRelayTransportMode(args, { allowEdgeMode: options.allowEdgeMode === true });
+  return validateRelayNumericOptions(args);
+}
+
+function parseRelayEdgeArgs(argv, options = {}) {
+  const env = options.env || process.env;
+  const warn = options.warn || console.warn;
+  const defaultStoragePath = options.defaultStoragePath || defaultRelayStoragePath(options.defaultDataDir || defaultRuntimeDataDir());
+  const args = parseRelayArgsFromEnv(env, {
+    ...options,
+    defaultStoragePath,
+    defaultIpcPort: options.defaultIpcPort || 42777
+  });
+  args.transportMode = RELAY_TRANSPORT_MODE_EDGE;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const result = applyRelayCliArg(args, token, index, argv, warn);
+    index = result.index;
+    Object.assign(args, result.updates);
+  }
+
+  args.transportMode = RELAY_TRANSPORT_MODE_EDGE;
+  args.storagePath = resolveStoragePath(args.storagePath, defaultStoragePath);
+  if (args.edgeQueuePath) args.edgeQueuePath = resolveStoragePath(args.edgeQueuePath);
+  if (args.edgeRolloutStatePath) args.edgeRolloutStatePath = resolveStoragePath(args.edgeRolloutStatePath);
+  if (args.edgeRolloutLockPath) args.edgeRolloutLockPath = resolveStoragePath(args.edgeRolloutLockPath);
+  if (args.relayWorkerImageBuildContext) args.relayWorkerImageBuildContext = path.resolve(args.relayWorkerImageBuildContext);
+  if (args.relayWorkerComposeFile) args.relayWorkerComposeFile = path.resolve(args.relayWorkerComposeFile);
+  if (args.relayWorkerComposeProjectDirectory) args.relayWorkerComposeProjectDirectory = path.resolve(args.relayWorkerComposeProjectDirectory);
+  if (args.relayStorageBackupDir) args.relayStorageBackupDir = path.resolve(args.relayStorageBackupDir);
+  if (args.dataDir) args.dataDir = path.resolve(args.dataDir);
+  args.transportMode = resolveRelayTransportMode(args, { allowEdgeMode: true });
+  return validateRelayNumericOptions(args);
+}
+
+module.exports = {
+  DEFAULT_RELAY_ACTIVE_FANOUT,
+  DEFAULT_RELAY_FAILOVER_MS,
+  DEFAULT_RELAY_EDGE_MAX_QUEUED_BYTES_PER_CONNECTION,
+  DEFAULT_RELAY_EDGE_MAX_QUEUED_BYTES_TOTAL,
+  DEFAULT_RELAY_EDGE_MAX_QUEUED_FRAMES_PER_CONNECTION,
+  DEFAULT_RELAY_EDGE_MAX_MIGRATION_DURATION_MS,
+  DEFAULT_RELAY_EDGE_QUEUE_BACKPRESSURE_RATIO,
+  DEFAULT_RELAY_HEARTBEAT_MS,
+  DEFAULT_RELAY_HEARTBEAT_TIMEOUT_MS,
+  DEFAULT_RELAY_MAX_CALL_SIGNAL_BYTES,
+  DEFAULT_RELAY_MAX_BYTES_PER_ROOM,
+  DEFAULT_RELAY_MAX_BYTES_TOTAL,
+  DEFAULT_RELAY_MAX_FILE_BYTES,
+  DEFAULT_RELAY_MAX_FILE_BYTES_PER_ROOM,
+  DEFAULT_RELAY_MAX_FILE_BYTES_TOTAL,
+  DEFAULT_RELAY_FILE_ROOM_POLICY,
+  DEFAULT_RELAY_MAX_EVENT_BYTES,
+  DEFAULT_RELAY_MAX_NIP44_EVENT_BYTES,
+  DEFAULT_RELAY_MAX_EVENTS_PER_PUBKEY_WINDOW,
+  DEFAULT_RELAY_MAX_EVENTS_PER_ROOM,
+  DEFAULT_RELAY_MAX_EVENTS,
+  DEFAULT_RELAY_MAX_FUTURE_SECONDS,
+  DEFAULT_RELAY_MAX_IPC_MESSAGE_BYTES,
+  DEFAULT_RELAY_MAX_IPC_MESSAGES_PER_WINDOW,
+  DEFAULT_RELAY_MAX_MESH_MESSAGE_BYTES,
+  DEFAULT_RELAY_MAX_MESH_MESSAGES_PER_WINDOW,
+  DEFAULT_RELAY_MAX_NOSTR_MESSAGE_BYTES,
+  DEFAULT_RELAY_MAX_ROOM_MESSAGE_BYTES,
+  DEFAULT_RELAY_MAX_ROOM_MESSAGES_PER_WINDOW,
+  DEFAULT_RELAY_MAX_UNAUTHENTICATED_MESSAGES_PER_WINDOW,
+  DEFAULT_RELAY_PUBKEY_QUOTA_WINDOW_SECONDS,
+  DEFAULT_RELAY_RATE_WINDOW_MS,
+  DEFAULT_RELAY_SFU_MAX_PARTICIPANTS,
+  MATTERHORN_PROFILE_ALPHA,
+  MATTERHORN_PROFILE_DEVELOPMENT,
+  RELAY_TRANSPORT_MODE_EDGE,
+  RELAY_TRANSPORT_MODE_EDGE_WORKER,
+  RELAY_TRANSPORT_MODE_STANDALONE,
+  MATTERHORN_PROFILE_PRODUCTION,
+  PROTOCOL,
+  defaultRuntimeDataDir,
+  defaultRelayStoragePath,
+  configuredIceServers,
+  defaultMatterhornProfile,
+  isMatterhornProfile,
+  parseExternalIceServersJson,
+  parseTurnIceServers,
+  normalizeIceMode,
+  normalizeMatterhornProfile,
+  normalizeRelayTransportMode,
+  parseBool,
+  parseIceServers,
+  parseRelayArgs,
+  parseRelayEdgeArgs,
+  parseRelayPeers,
+  redactIceServers,
+  resolveRelayTransportMode,
+  resolveStoragePath
+};