@jagilber-org/index-server 1.19.1

package/SECURITY.md

@@ -0,0 +1,50 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+|---------|--------------------|
+| 1.x.x   | ✅ Active support  |
+| < 1.0   | ❌ End of life     |
+
+## Reporting a Vulnerability
+
+**Do NOT open public issues for security vulnerabilities.**
+
+Please report suspected vulnerabilities privately using one of these methods:
+
+1. **GitHub Security Advisories** (preferred) — create a new advisory on the [dev repository](https://github.com/jagilber-dev/index-server/security/advisories).
+2. **Email** — contact the maintainer at the email listed in the repository's GitHub profile.
+
+When reporting, include:
+
+- Reproduction steps and environment details
+- Impact assessment and affected versions
+- Any relevant logs or proof-of-concept (redact sensitive data)
+
+### Response Timeline
+
+- **Acknowledgement**: within 48 hours of receipt
+- **Detailed response**: within 7 business days
+- **Fix or mitigation**: coordinated with reporter before public disclosure
+
+## Vulnerability Disclosure
+
+We follow responsible disclosure practices:
+
+- Confirm the issue and assign a CVE if applicable.
+- Prepare a fix and coordinate a release timeline with the reporter.
+- Credit reporters who wish to be acknowledged in the advisory and changelog.
+
+## Security Practices
+
+- **Pre-commit hooks** scan for secrets and PII before code leaves the developer machine
+- **Bootstrap gating** — all mutation operations require explicit bootstrap confirmation
+- **Audit logging** — every Index mutation is logged with timestamp, action, and actor
+- **Content scanning** — automated checks before public publishing via dual-repo workflow
+- **Mutation controls** — `INDEX_SERVER_MUTATION` environment variable gates write operations
+- **Auth key support** — optional `INDEX_SERVER_AUTH_KEY` for securing dashboard and API access
+
+## Hardening Notes
+
+This project includes enterprise hardening (see `HARDENING-DESIGN.md`). Keep auth secrets (`INDEX_SERVER_AUTH_KEY`) private. Avoid committing credentials or tokens.

package/dist/config/configUtils.d.ts

@@ -0,0 +1,11 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export declare const CWD: string;
+export declare function toAbsolute(raw: string | undefined, fallback?: string): string;
+export declare function numberFromEnv(name: string, defaultValue: number): number;
+export declare function optionalNumberFromEnv(name: string): number | undefined;
+export declare function floatFromEnv(name: string, defaultValue: number): number;
+export declare function optionalIntFromEnv(name: string): number | undefined;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function stringFromEnv(name: string, defaultValue: string): string;
+export declare function parseCsvEnv(name: string): string[];
+export declare function parseJSONMaybe<T = unknown>(src?: string): T | undefined;

package/dist/config/configUtils.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CWD = void 0;
+exports.toAbsolute = toAbsolute;
+exports.numberFromEnv = numberFromEnv;
+exports.optionalNumberFromEnv = optionalNumberFromEnv;
+exports.floatFromEnv = floatFromEnv;
+exports.optionalIntFromEnv = optionalIntFromEnv;
+exports.clamp = clamp;
+exports.stringFromEnv = stringFromEnv;
+exports.parseCsvEnv = parseCsvEnv;
+exports.parseJSONMaybe = parseJSONMaybe;
+/**
+ * Shared low-level utilities used by config domain modules.
+ * No imports from other local config files — safe to import anywhere.
+ */
+const path_1 = __importDefault(require("path"));
+exports.CWD = process.cwd();
+function toAbsolute(raw, fallback) {
+    if (raw && raw.trim().length) {
+        return path_1.default.isAbsolute(raw) ? raw : path_1.default.resolve(exports.CWD, raw);
+    }
+    if (fallback && fallback.trim().length) {
+        return path_1.default.isAbsolute(fallback) ? fallback : path_1.default.resolve(exports.CWD, fallback);
+    }
+    return exports.CWD;
+}
+function numberFromEnv(name, defaultValue) {
+    const raw = process.env[name];
+    if (!raw)
+        return defaultValue;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : defaultValue;
+}
+function optionalNumberFromEnv(name) {
+    const raw = process.env[name];
+    if (raw === undefined)
+        return undefined;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : undefined;
+}
+function floatFromEnv(name, defaultValue) {
+    const raw = process.env[name];
+    if (!raw)
+        return defaultValue;
+    const value = Number.parseFloat(raw);
+    return Number.isFinite(value) ? value : defaultValue;
+}
+function optionalIntFromEnv(name) {
+    const raw = process.env[name];
+    if (raw === undefined)
+        return undefined;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) ? value : undefined;
+}
+function clamp(value, min, max) {
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+function stringFromEnv(name, defaultValue) {
+    const raw = process.env[name];
+    if (raw && raw.trim().length)
+        return raw;
+    return defaultValue;
+}
+function parseCsvEnv(name) {
+    const raw = process.env[name];
+    if (!raw)
+        return [];
+    return raw.split(/[,\s]+/).map(s => s.trim()).filter(Boolean);
+}
+function parseJSONMaybe(src) {
+    if (!src)
+        return undefined;
+    try {
+        return JSON.parse(src);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/config/dashboardConfig.d.ts

@@ -0,0 +1,45 @@
+interface DashboardTlsConfig {
+    enabled: boolean;
+    certPath?: string;
+    keyPath?: string;
+    caPath?: string;
+}
+interface DashboardHttpConfig {
+    enable: boolean;
+    port: number;
+    host: string;
+    maxPortTries: number;
+    enableHttpMetrics: boolean;
+    requestTimeoutMs: number;
+    maxConnections: number;
+    verboseLogging: boolean;
+    mutationEnabled: boolean;
+    adminApiKey?: string;
+    tls: DashboardTlsConfig;
+}
+interface DashboardAdminConfig {
+    maxSessionHistory: number;
+    backupsDir: string;
+    instructionsDir: string;
+    stateDir: string;
+}
+interface DashboardSessionPersistenceConfig {
+    enabled: boolean;
+    persistenceDir: string;
+    backupIntegration: boolean;
+    retention: {
+        maxHistoryEntries: number;
+        maxHistoryDays: number;
+        maxConnectionHistoryDays: number;
+    };
+    persistenceIntervalMs: number;
+    deduplicationEnabled: boolean;
+}
+export interface DashboardConfig {
+    http: DashboardHttpConfig;
+    admin: DashboardAdminConfig;
+    sessionPersistence: DashboardSessionPersistenceConfig;
+    graphEnabled: boolean;
+}
+export declare function parseDashboardConfig(mutationEnabled: boolean, instructionsBaseDir: string): DashboardConfig;
+export {};

package/dist/config/dashboardConfig.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDashboardConfig = parseDashboardConfig;
+/**
+ * Dashboard domain config: HTTP server, TLS, WebSocket, and session persistence settings.
+ */
+const path_1 = __importDefault(require("path"));
+const envUtils_1 = require("../utils/envUtils");
+const SessionPersistence_js_1 = require("../models/SessionPersistence.js");
+const configUtils_1 = require("./configUtils");
+const dirConstants_1 = require("./dirConstants");
+const defaultValues_1 = require("./defaultValues");
+function parseDashboardConfig(mutationEnabled, instructionsBaseDir) {
+    const persistenceDefaults = SessionPersistence_js_1.DEFAULT_SESSION_PERSISTENCE_CONFIG;
+    const persistenceEnv = SessionPersistence_js_1.SESSION_PERSISTENCE_ENV_VARS;
+    const persistenceEnabled = (0, envUtils_1.parseBooleanEnv)(process.env[persistenceEnv.ENABLED], persistenceDefaults.enabled);
+    const persistenceDir = (0, configUtils_1.toAbsolute)(process.env[persistenceEnv.PERSISTENCE_DIR], persistenceDefaults.persistenceDir);
+    const persistenceInterval = (0, configUtils_1.numberFromEnv)(persistenceEnv.PERSISTENCE_INTERVAL_MS, persistenceDefaults.persistence.intervalMs);
+    const backupsDir = (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_BACKUPS_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.BACKUPS));
+    const stateDir = (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_STATE_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.DATA_STATE));
+    return {
+        http: {
+            enable: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DASHBOARD'),
+            port: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_DASHBOARD_PORT', defaultValues_1.DEFAULT_PORTS.DASHBOARD),
+            host: (0, configUtils_1.stringFromEnv)('INDEX_SERVER_DASHBOARD_HOST', '127.0.0.1'),
+            maxPortTries: Math.max(1, (0, configUtils_1.numberFromEnv)('INDEX_SERVER_DASHBOARD_TRIES', defaultValues_1.DEFAULT_LIMITS.MAX_PORT_TRIES)),
+            enableHttpMetrics: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_HTTP_METRICS', true),
+            requestTimeoutMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_REQUEST_TIMEOUT', defaultValues_1.DEFAULT_TIMEOUTS_MS.REQUEST_TIMEOUT),
+            maxConnections: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_MAX_CONNECTIONS', defaultValues_1.DEFAULT_LIMITS.MAX_CONNECTIONS),
+            verboseLogging: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_VERBOSE_LOGGING'),
+            mutationEnabled,
+            adminApiKey: process.env.INDEX_SERVER_ADMIN_API_KEY || undefined,
+            tls: {
+                enabled: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DASHBOARD_TLS'),
+                certPath: process.env.INDEX_SERVER_DASHBOARD_TLS_CERT || undefined,
+                keyPath: process.env.INDEX_SERVER_DASHBOARD_TLS_KEY || undefined,
+                caPath: process.env.INDEX_SERVER_DASHBOARD_TLS_CA || undefined,
+            },
+        },
+        admin: {
+            maxSessionHistory: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_ADMIN_MAX_SESSION_HISTORY', defaultValues_1.DEFAULT_LIMITS.MAX_SESSION_HISTORY),
+            backupsDir,
+            instructionsDir: instructionsBaseDir,
+            stateDir,
+        },
+        sessionPersistence: {
+            enabled: persistenceEnabled,
+            persistenceDir,
+            backupIntegration: (0, envUtils_1.parseBooleanEnv)(process.env[persistenceEnv.BACKUP_INTEGRATION], persistenceDefaults.backupIntegration),
+            retention: {
+                maxHistoryEntries: (0, configUtils_1.numberFromEnv)(persistenceEnv.MAX_HISTORY_ENTRIES, persistenceDefaults.retention.maxHistoryEntries),
+                maxHistoryDays: (0, configUtils_1.numberFromEnv)(persistenceEnv.MAX_HISTORY_DAYS, persistenceDefaults.retention.maxHistoryDays),
+                maxConnectionHistoryDays: (0, configUtils_1.numberFromEnv)(persistenceEnv.MAX_CONNECTION_HISTORY_DAYS, persistenceDefaults.retention.maxConnectionHistoryDays),
+            },
+            persistenceIntervalMs: persistenceInterval,
+            deduplicationEnabled: (0, envUtils_1.parseBooleanEnv)(process.env[persistenceEnv.DEDUPLICATION_ENABLED], persistenceDefaults.deduplication.enabled),
+        },
+        graphEnabled: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DASHBOARD_GRAPH'),
+    };
+}

package/dist/config/defaultValues.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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_MAX_LENGTH: 20000;
+    readonly BODY_MIN_LENGTH: 1000;
+    readonly BODY_ABS_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 LEADER: 9090;
+    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,70 @@
+"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_MAX_LENGTH: 20000,
+    BODY_MIN_LENGTH: 1000,
+    BODY_ABS_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,
+    LEADER: 9090,
+    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,17 @@
+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 BACKUPS: "backups";
+    readonly INSTRUCTIONS: "instructions";
+    readonly METRICS: "metrics";
+    readonly FEEDBACK: "feedback";
+    readonly FLAGS: "flags.json";
+};

package/dist/config/dirConstants.js

@@ -0,0 +1,28 @@
+"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'),
+    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)),
+        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),
+    };
+}