@jagilber-org/index-server 1.22.0

package/dist/config/defaultValues.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Centralized default values for timeouts, limits, thresholds, and other
+ * numeric constants used across configuration modules.
+ * Import from here instead of hardcoding magic numbers.
+ */
+export declare const DEFAULT_TIMEOUTS_MS: {
+    readonly FATAL_EXIT_DELAY: 15;
+    readonly IDLE_KEEPALIVE: 30000;
+    readonly REQUEST_TIMEOUT: 30000;
+    readonly HEARTBEAT: 5000;
+    readonly STALE_THRESHOLD: 15000;
+    readonly POLL_INTERVAL: 10000;
+    readonly TOOLCALL_FLUSH: 5000;
+    readonly TOOLCALL_COMPACT: 300000;
+    readonly HEALTH_MIN_UPTIME: 1000;
+    readonly MESSAGING_SWEEP: 60000;
+    readonly AUTO_BACKUP_INTERVAL: 3600000;
+    readonly SESSION_PERSISTENCE_INTERVAL: 30000;
+    readonly AUTO_REFRESH: 300000;
+};
+export declare const DEFAULT_LIMITS: {
+    readonly MAX_CONNECTIONS: 100;
+    readonly MAX_PORT_TRIES: 10;
+    readonly MAX_BULK_DELETE: 5;
+    readonly MAX_FEEDBACK_ENTRIES: 1000;
+    readonly MAX_MESSAGES: 10000;
+    readonly MAX_SESSION_HISTORY: 200;
+    readonly BODY_WARN_LENGTH: 100000;
+    readonly BODY_MIN_LENGTH: 1000;
+    readonly BODY_MAX_LENGTH: 1000000;
+    readonly AUTO_BACKUP_MAX_COUNT: 10;
+    readonly TOOLCALL_CHUNK_SIZE: 250;
+    readonly LIST_CONCURRENCY: 8;
+    readonly LIST_MAX_DURATION_MS: 7000;
+    readonly ATOMIC_WRITE_RETRIES: 5;
+    readonly ATOMIC_WRITE_BACKOFF_MS: 10;
+    readonly READ_RETRIES: 3;
+    readonly READ_BACKOFF_MS: 8;
+};
+export declare const DEFAULT_THRESHOLDS: {
+    readonly MEMORY_THRESHOLD: 0.95;
+    readonly ERROR_RATE_THRESHOLD: 10;
+    readonly RESOURCE_CAPACITY: 720;
+    readonly RESOURCE_SAMPLE_INTERVAL_MS: 5000;
+};
+export declare const DEFAULT_PORTS: {
+    readonly DASHBOARD: 8787;
+    readonly DASHBOARD_DEV: 4000;
+    readonly LEADER: 9090;
+    readonly LEADER_DEV: 4090;
+    readonly BOOTSTRAP_TOKEN_TTL_SEC: 900;
+};
+export declare const DEFAULT_GOVERNANCE: {
+    readonly HASH_CANON_VARIANTS: 1;
+    readonly HASH_CANON_VARIANTS_MAX: 8;
+    readonly HASH_IMPORT_SET_SIZE: 2;
+    readonly HASH_IMPORT_SET_SIZE_MAX: 5;
+    readonly USAGE_FLUSH_MS: 75;
+};
+export declare const DEFAULT_SEMANTIC: {
+    readonly MODEL: "Xenova/all-MiniLM-L6-v2";
+    readonly DEVICE: "cpu";
+};

package/dist/config/defaultValues.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Centralized default values for timeouts, limits, thresholds, and other
+ * numeric constants used across configuration modules.
+ * Import from here instead of hardcoding magic numbers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SEMANTIC = exports.DEFAULT_GOVERNANCE = exports.DEFAULT_PORTS = exports.DEFAULT_THRESHOLDS = exports.DEFAULT_LIMITS = exports.DEFAULT_TIMEOUTS_MS = void 0;
+// ── Timeouts (milliseconds) ──────────────────────────────────────────
+exports.DEFAULT_TIMEOUTS_MS = {
+    FATAL_EXIT_DELAY: 15,
+    IDLE_KEEPALIVE: 30000,
+    REQUEST_TIMEOUT: 30000,
+    HEARTBEAT: 5000,
+    STALE_THRESHOLD: 15000,
+    POLL_INTERVAL: 10000,
+    TOOLCALL_FLUSH: 5000,
+    TOOLCALL_COMPACT: 300000,
+    HEALTH_MIN_UPTIME: 1000,
+    MESSAGING_SWEEP: 60000,
+    AUTO_BACKUP_INTERVAL: 3600000,
+    SESSION_PERSISTENCE_INTERVAL: 30000,
+    AUTO_REFRESH: 300000,
+};
+// ── Limits ───────────────────────────────────────────────────────────
+exports.DEFAULT_LIMITS = {
+    MAX_CONNECTIONS: 100,
+    MAX_PORT_TRIES: 10,
+    MAX_BULK_DELETE: 5,
+    MAX_FEEDBACK_ENTRIES: 1000,
+    MAX_MESSAGES: 10000,
+    MAX_SESSION_HISTORY: 200,
+    BODY_WARN_LENGTH: 100000,
+    BODY_MIN_LENGTH: 1000,
+    BODY_MAX_LENGTH: 1000000,
+    AUTO_BACKUP_MAX_COUNT: 10,
+    TOOLCALL_CHUNK_SIZE: 250,
+    LIST_CONCURRENCY: 8,
+    LIST_MAX_DURATION_MS: 7000,
+    ATOMIC_WRITE_RETRIES: 5,
+    ATOMIC_WRITE_BACKOFF_MS: 10,
+    READ_RETRIES: 3,
+    READ_BACKOFF_MS: 8,
+};
+// ── Resource / health thresholds ─────────────────────────────────────
+exports.DEFAULT_THRESHOLDS = {
+    MEMORY_THRESHOLD: 0.95,
+    ERROR_RATE_THRESHOLD: 10,
+    RESOURCE_CAPACITY: 720,
+    RESOURCE_SAMPLE_INTERVAL_MS: 5000,
+};
+// ── Network ──────────────────────────────────────────────────────────
+exports.DEFAULT_PORTS = {
+    DASHBOARD: 8787,
+    DASHBOARD_DEV: 4000,
+    LEADER: 9090,
+    LEADER_DEV: 4090,
+    BOOTSTRAP_TOKEN_TTL_SEC: 900,
+};
+// ── Governance ───────────────────────────────────────────────────────
+exports.DEFAULT_GOVERNANCE = {
+    HASH_CANON_VARIANTS: 1,
+    HASH_CANON_VARIANTS_MAX: 8,
+    HASH_IMPORT_SET_SIZE: 2,
+    HASH_IMPORT_SET_SIZE_MAX: 5,
+    USAGE_FLUSH_MS: 75,
+};
+// ── Semantic search ──────────────────────────────────────────────────
+exports.DEFAULT_SEMANTIC = {
+    MODEL: 'Xenova/all-MiniLM-L6-v2',
+    DEVICE: 'cpu',
+};

package/dist/config/dirConstants.d.ts

@@ -0,0 +1,18 @@
+export declare const DIR: {
+    readonly LOGS: "logs";
+    readonly LOGS_TRACE: string;
+    readonly LOGS_MCP_SERVER: string;
+    readonly LOGS_AUDIT: string;
+    readonly LOGS_NORMALIZATION: string;
+    readonly DATA: "data";
+    readonly DATA_MODELS: string;
+    readonly DATA_STATE: string;
+    readonly DATA_EMBEDDINGS: string;
+    readonly DATA_SQLITE: string;
+    readonly DATA_MESSAGING: string;
+    readonly BACKUPS: "backups";
+    readonly INSTRUCTIONS: "instructions";
+    readonly METRICS: "metrics";
+    readonly FEEDBACK: "feedback";
+    readonly FLAGS: "flags.json";
+};

package/dist/config/dirConstants.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIR = void 0;
+/**
+ * Centralized directory / file path segments used across configuration modules.
+ * All values are relative — combine with CWD via `path.join(CWD, DIR.X)`.
+ */
+const path_1 = __importDefault(require("path"));
+exports.DIR = {
+    LOGS: 'logs',
+    LOGS_TRACE: path_1.default.join('logs', 'trace'),
+    LOGS_MCP_SERVER: path_1.default.join('logs', 'mcp-server.log'),
+    LOGS_AUDIT: path_1.default.join('logs', 'instruction-transactions.log.jsonl'),
+    LOGS_NORMALIZATION: path_1.default.join('logs', 'index-normalization.log'),
+    DATA: 'data',
+    DATA_MODELS: path_1.default.join('data', 'models'),
+    DATA_STATE: path_1.default.join('data', 'state'),
+    DATA_EMBEDDINGS: path_1.default.join('data', 'embeddings.json'),
+    DATA_SQLITE: path_1.default.join('data', 'index.db'),
+    DATA_MESSAGING: path_1.default.join('data', 'messaging'),
+    BACKUPS: 'backups',
+    INSTRUCTIONS: 'instructions',
+    METRICS: 'metrics',
+    FEEDBACK: 'feedback',
+    FLAGS: 'flags.json',
+};

package/dist/config/featureConfig.d.ts

@@ -0,0 +1,61 @@
+export interface FeatureFlagsConfig {
+    file: string;
+    envNamespace: Record<string, string>;
+    indexFeatures: Set<string>;
+}
+export interface FeedbackConfig {
+    dir: string;
+    maxEntries: number;
+}
+export interface MessagingConfig {
+    dir: string;
+    maxMessages: number;
+    sweepIntervalMs: number;
+}
+type SemanticDevice = 'cpu' | 'cuda' | 'dml';
+export interface SemanticConfig {
+    enabled: boolean;
+    model: string;
+    cacheDir: string;
+    embeddingPath: string;
+    device: SemanticDevice;
+    localOnly: boolean;
+}
+export interface MinimalConfig {
+    debugOrdering: boolean;
+}
+export interface BootstrapSeedConfig {
+    autoSeed: boolean;
+    verbose: boolean;
+}
+export interface ValidationConfig {
+    mode: string;
+}
+export interface DynamicConfig {
+    dashboardConfig: Record<string, string>;
+    apiIntegration: Record<string, string>;
+}
+export interface GraphConfig {
+    includePrimaryEdges: boolean;
+    largeCategoryCap: number;
+    explicitIncludePrimaryEnv: boolean;
+    explicitLargeCategoryEnv: boolean;
+    signature: string;
+}
+export declare function parseFeatureFlagsConfig(): FeatureFlagsConfig;
+export declare function parseFeedbackConfig(): FeedbackConfig;
+export declare function parseMessagingConfig(): MessagingConfig;
+export declare function parseSemanticConfig(): SemanticConfig;
+export declare function parseMinimalConfig(): MinimalConfig;
+export declare function parseBootstrapSeedConfig(): BootstrapSeedConfig;
+export declare function parseValidationConfig(): ValidationConfig;
+export declare function parseDynamicConfig(): DynamicConfig;
+export declare function parseGraphConfig(): GraphConfig;
+export interface StorageConfig {
+    backend: 'json' | 'sqlite';
+    sqlitePath: string;
+    sqliteWal: boolean;
+    sqliteMigrateOnStart: boolean;
+}
+export declare function parseStorageConfig(): StorageConfig;
+export {};

package/dist/config/featureConfig.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFeatureFlagsConfig = parseFeatureFlagsConfig;
+exports.parseFeedbackConfig = parseFeedbackConfig;
+exports.parseMessagingConfig = parseMessagingConfig;
+exports.parseSemanticConfig = parseSemanticConfig;
+exports.parseMinimalConfig = parseMinimalConfig;
+exports.parseBootstrapSeedConfig = parseBootstrapSeedConfig;
+exports.parseValidationConfig = parseValidationConfig;
+exports.parseDynamicConfig = parseDynamicConfig;
+exports.parseGraphConfig = parseGraphConfig;
+exports.parseStorageConfig = parseStorageConfig;
+/**
+ * Feature domain config: feature flags, feedback, messaging, semantic search,
+ * minimal mode, bootstrap seed, validation, dynamic config, and graph settings.
+ */
+const path_1 = __importDefault(require("path"));
+const envUtils_1 = require("../utils/envUtils");
+const configUtils_1 = require("./configUtils");
+const dirConstants_1 = require("./dirConstants");
+const defaultValues_1 = require("./defaultValues");
+function parseFeatureFlagsConfig() {
+    const envNamespace = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (key.startsWith('INDEX_SERVER_FLAG_') && typeof value === 'string') {
+            envNamespace[key.substring('INDEX_SERVER_FLAG_'.length).toLowerCase()] = value;
+        }
+    }
+    return {
+        file: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_FLAGS_FILE, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.FLAGS)),
+        envNamespace,
+        indexFeatures: new Set((0, configUtils_1.parseCsvEnv)('INDEX_SERVER_FEATURES')),
+    };
+}
+function parseFeedbackConfig() {
+    return {
+        dir: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_FEEDBACK_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.FEEDBACK)),
+        maxEntries: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_FEEDBACK_MAX_ENTRIES', defaultValues_1.DEFAULT_LIMITS.MAX_FEEDBACK_ENTRIES),
+    };
+}
+function parseMessagingConfig() {
+    return {
+        dir: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_MESSAGING_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.DATA_MESSAGING)),
+        maxMessages: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_MESSAGING_MAX', defaultValues_1.DEFAULT_LIMITS.MAX_MESSAGES),
+        sweepIntervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_MESSAGING_SWEEP_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.MESSAGING_SWEEP),
+    };
+}
+function parseSemanticConfig() {
+    const validDevices = ['cpu', 'cuda', 'dml'];
+    const rawDevice = (process.env.INDEX_SERVER_SEMANTIC_DEVICE || 'cpu').toLowerCase();
+    const device = validDevices.includes(rawDevice) ? rawDevice : 'cpu';
+    return {
+        enabled: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_SEMANTIC_ENABLED'),
+        model: process.env.INDEX_SERVER_SEMANTIC_MODEL || defaultValues_1.DEFAULT_SEMANTIC.MODEL,
+        cacheDir: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_SEMANTIC_CACHE_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.DATA_MODELS)),
+        embeddingPath: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_EMBEDDING_PATH, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.DATA_EMBEDDINGS)),
+        device,
+        localOnly: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_SEMANTIC_LOCAL_ONLY', true),
+    };
+}
+function parseMinimalConfig() {
+    return {
+        debugOrdering: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_MINIMAL_DEBUG'),
+    };
+}
+function parseBootstrapSeedConfig() {
+    return {
+        autoSeed: process.env.INDEX_SERVER_AUTO_SEED === undefined ? true : process.env.INDEX_SERVER_AUTO_SEED !== '0',
+        verbose: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_SEED_VERBOSE'),
+    };
+}
+function parseValidationConfig() {
+    return {
+        mode: (process.env.INDEX_SERVER_VALIDATION_MODE || 'zod').toLowerCase(),
+    };
+}
+function parseDynamicConfig() {
+    return {
+        dashboardConfig: {},
+        apiIntegration: {},
+    };
+}
+function parseGraphConfig() {
+    const includeRaw = process.env.INDEX_SERVER_GRAPH_INCLUDE_PRIMARY_EDGES;
+    const includePrimaryEdges = includeRaw === undefined ? true : (0, envUtils_1.parseBooleanEnv)(includeRaw, true);
+    const largeRaw = process.env.INDEX_SERVER_GRAPH_LARGE_CATEGORY_CAP;
+    let largeCategoryCap = Number.POSITIVE_INFINITY;
+    let explicitLargeCategoryEnv = false;
+    if (largeRaw && largeRaw.trim().length) {
+        const parsed = Number.parseInt(largeRaw, 10);
+        if (Number.isFinite(parsed) && parsed >= 0) {
+            largeCategoryCap = parsed;
+        }
+        explicitLargeCategoryEnv = true;
+    }
+    const explicitIncludePrimaryEnv = includeRaw !== undefined;
+    const signature = `${includePrimaryEdges ? 'P1' : 'P0'}:${explicitLargeCategoryEnv ? largeCategoryCap : 'INF'}`;
+    return {
+        includePrimaryEdges,
+        largeCategoryCap,
+        explicitIncludePrimaryEnv,
+        explicitLargeCategoryEnv,
+        signature,
+    };
+}
+function parseStorageConfig() {
+    const raw = (process.env.INDEX_SERVER_STORAGE_BACKEND || 'json').toLowerCase();
+    const backend = (raw === 'sqlite' ? 'sqlite' : 'json');
+    if (backend === 'sqlite') {
+        console.warn('[config] ⚠️  EXPERIMENTAL: SQLite storage backend selected. Limited testing has been performed. Use at your own risk.');
+    }
+    return {
+        backend,
+        sqlitePath: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_SQLITE_PATH, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.DATA_SQLITE)),
+        sqliteWal: (0, envUtils_1.parseBooleanEnv)(process.env.INDEX_SERVER_SQLITE_WAL, true),
+        sqliteMigrateOnStart: (0, envUtils_1.parseBooleanEnv)(process.env.INDEX_SERVER_SQLITE_MIGRATE_ON_START, true),
+    };
+}

package/dist/config/runtimeConfig.d.ts

@@ -0,0 +1,151 @@
+import { LogLevel } from './configUtils';
+import type { ServerConfig, LoggingConfig, MetricsConfig, AtomicFsConfig, PreflightConfig, TracingConfig } from './serverConfig';
+import type { DashboardConfig } from './dashboardConfig';
+import type { FeatureFlagsConfig, FeedbackConfig, MessagingConfig, SemanticConfig, MinimalConfig, BootstrapSeedConfig, ValidationConfig, DynamicConfig, GraphConfig, StorageConfig } from './featureConfig';
+export type IndexMode = 'normal' | 'memoize' | 'memoize+hash' | 'reload' | 'reload+memo';
+export type { LogLevel };
+export type { MessagingConfig } from './featureConfig';
+export type { StorageConfig } from './featureConfig';
+interface TimingMap {
+    [key: string]: number;
+}
+interface BufferRingConfig {
+    append: boolean;
+    preload: boolean;
+}
+interface CoverageConfig {
+    hardMin?: number;
+    target?: number;
+    fastMode: boolean;
+    strictMode: boolean;
+}
+interface IndexReadRetriesConfig {
+    attempts: number;
+    backoffMs: number;
+}
+interface IndexGovernanceConfig {
+    trailingNewline: boolean;
+    hashHardeningEnabled: boolean;
+    hashCanonVariants: number;
+    hashImportSetSize: number;
+}
+interface IndexConfig {
+    mode: IndexMode;
+    baseDir: string;
+    reloadAlways: boolean;
+    memoize: boolean;
+    memoizeDisabledExplicitly: boolean;
+    memoizeHash: boolean;
+    normalizationLog?: string | boolean;
+    fileTrace: boolean;
+    eventSilent: boolean;
+    readRetries: IndexReadRetriesConfig;
+    usageFlushMs: number;
+    disableUsageClamp: boolean;
+    govHash: IndexGovernanceConfig;
+    maxFiles?: number;
+    loadWarningThreshold?: number;
+    /** Configurable warn/truncate/reject threshold for instruction body length (default 100000). */
+    bodyWarnLength: number;
+    /** Hard maximum body character length — schema reject ceiling, always 1MB. Not configurable. */
+    bodyMaxLength: number;
+    autoSplitOversized: boolean;
+    autoUsageTrack: boolean;
+}
+interface InstructionsManifestConfig {
+    writeEnabled: boolean;
+    fastload: boolean;
+}
+interface InstructionsCIContextConfig {
+    inCI: boolean;
+    githubActions: boolean;
+    tfBuild: boolean;
+}
+interface InstructionsAuditLogConfig {
+    enabled: boolean;
+    file?: string;
+    rawValue?: string;
+    usesDefault: boolean;
+}
+interface InstructionsListValidationConfig {
+    forceFullScan: boolean;
+    allowSampling: boolean;
+    effectiveSampleSize?: number;
+    sampleSeed?: number;
+    concurrency: number;
+    maxDurationMs: number;
+}
+interface InstructionsConfig {
+    workspaceId?: string;
+    agentId?: string;
+    canonicalDisable: boolean;
+    strictVisibility: boolean;
+    strictCreate: boolean;
+    strictRemove: boolean;
+    requireCategory: boolean;
+    traceQueryDiag: boolean;
+    manifest: InstructionsManifestConfig;
+    ciContext: InstructionsCIContextConfig;
+    auditLog: InstructionsAuditLogConfig;
+    listValidation: InstructionsListValidationConfig;
+}
+interface MutationConfig {
+    enabled: boolean;
+    dispatcherTiming: boolean;
+    maxBulkDelete: number;
+    backupBeforeBulkDelete: boolean;
+    autoBackupEnabled: boolean;
+    autoBackupIntervalMs: number;
+    autoBackupMaxCount: number;
+}
+export interface RuntimeConfig {
+    profile: string;
+    testMode: string | undefined;
+    index: IndexConfig;
+    mutationEnabled: boolean;
+    logLevel: LogLevel;
+    trace: Set<string>;
+    initFeatures: Set<string>;
+    bufferRing: BufferRingConfig;
+    timing: (key: string, fallback?: number) => number | undefined;
+    rawTiming: TimingMap;
+    coverage: CoverageConfig;
+    dashboard: DashboardConfig;
+    server: ServerConfig;
+    logging: LoggingConfig;
+    metrics: MetricsConfig;
+    instructions: InstructionsConfig;
+    tracing: TracingConfig;
+    mutation: MutationConfig;
+    featureFlags: FeatureFlagsConfig;
+    feedback: FeedbackConfig;
+    messaging: MessagingConfig;
+    semantic: SemanticConfig;
+    minimal: MinimalConfig;
+    bootstrapSeed: BootstrapSeedConfig;
+    atomicFs: AtomicFsConfig;
+    preflight: PreflightConfig;
+    validation: ValidationConfig;
+    dynamic: DynamicConfig;
+    graph: GraphConfig;
+    storage: StorageConfig;
+}
+/** Valid profile names supported by the wizard and runtime. */
+export declare const VALID_PROFILES: readonly ["default", "enhanced", "experimental"];
+export type ProfileName = typeof VALID_PROFILES[number];
+/**
+ * Parse all environment variables and construct a fresh {@link RuntimeConfig} object.
+ * Prefer {@link getRuntimeConfig} for normal use — this function always re-parses.
+ * @returns Fully resolved runtime configuration object
+ */
+export declare function loadRuntimeConfig(): RuntimeConfig;
+/**
+ * Return the cached singleton {@link RuntimeConfig}, loading it on first call.
+ * @returns The application-wide runtime configuration
+ */
+export declare function getRuntimeConfig(): RuntimeConfig;
+/**
+ * Force a reload of the runtime configuration by discarding the cache and re-parsing all env vars.
+ * @returns The freshly loaded runtime configuration
+ */
+export declare function reloadRuntimeConfig(): RuntimeConfig;