@ai-sdlc/orchestrator 0.10.0 → 0.14.0

package/dist/signal-ingestion/config.js

@@ -0,0 +1,587 @@
+/**
+ * Signal ingestion configuration loader for RFC-0030 Phase 2.
+ *
+ * Reads `.ai-sdlc/signal-ingestion.yaml`, validates its shape, and returns a
+ * fully-resolved `SignalIngestionConfig` with all defaults applied.
+ *
+ * Design decisions:
+ *  - Missing file → returns the default config (pipeline is disabled by default).
+ *  - Invalid YAML or schema mismatch → throws `SignalIngestionConfigError`.
+ *  - All numeric fields are validated to be non-negative finite numbers.
+ *  - `acceptedLanguages` defaults to `['en']` per RFC-0030 OQ-13.2 resolution.
+ *  - Tier multipliers and ICP resonance weights are read from the config; the
+ *    defaults match RFC-0030 §11.
+ *  - `flooding` block (RFC-0030 OQ-13.5 v0.3 re-walkthrough refinement,
+ *    AISDLC-433) replaces the legacy `sourceBaselineDriftMultiplier` knob
+ *    with a z-score detector on per-source rolling 7d baseline + quarantine.
+ *    The legacy `flooding.detection.sourceBaselineDriftMultiplier` field at
+ *    the LOADER level emits a `signal-ingestion-config-deprecated-field`
+ *    Decision; the loader translates it to the closest z-score equivalent
+ *    for one release window then hard-errors after the soak.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+// ── Default config path ─────────────────────────────────────────────────────
+export const DEFAULT_SIGNAL_INGESTION_CONFIG_PATH = '.ai-sdlc/signal-ingestion.yaml';
+// ── Defaults ────────────────────────────────────────────────────────────────
+export const DEFAULT_SIGNAL_INGESTION_CONFIG = {
+    enabled: false,
+    tierMultipliers: {
+        enterprise: 3.0,
+        mid: 1.5,
+        smb: 1.0,
+        free: 0.5,
+        churned: 2.0,
+    },
+    icpResonanceWeights: {
+        strong: 1.5,
+        partial: 1.0,
+        weak: 0.5,
+    },
+    recencyHalfLifeDays: 30,
+    tier2SignificanceThreshold: {
+        minSignalCount: 5,
+        minUniqueSources: 3,
+        minTier1SignalCount: 1,
+        minClusterAgeDays: 7,
+    },
+    saResonanceThresholds: {
+        fullWeight: 0.7,
+        discounted: 0.4,
+        excluded: 0.0,
+    },
+    clustering: {
+        algorithm: 'bm25',
+        similarityThreshold: 0.6,
+    },
+    d1Composition: {
+        signalPipelineWeight: 0.5,
+        backlogItemWeight: 0.5,
+    },
+    // RFC-0030 OQ-13.1 v0.3 — env-var-based adapters only. OAuth-required
+    // adapters (full Salesforce / HubSpot integrations, Zendesk-with-OAuth)
+    // defer to the future credential-management RFC.
+    adapters: [
+        'signal-source-support-ticket',
+        'signal-source-community-thread',
+        'signal-source-in-app-feedback',
+    ],
+    acceptedLanguages: ['en'],
+    languageDetection: {
+        library: 'franc',
+        minDetectionLength: 50,
+        onUndetermined: 'accept',
+    },
+    residencyEnforcement: {
+        sourceFromCompliancePosture: true,
+        enforcementPoints: {
+            fetchSignals: true,
+            clustering: true,
+            storage: true,
+            unifiedCostReport: true,
+        },
+        multiPostureBehavior: 'union',
+    },
+    manualEntry: {
+        dailyCapPerOperator: 10,
+        evidenceUrlOptional: true,
+        qualityMetric: {
+            enabled: true,
+            windowDays: 7,
+            shareWarningThreshold: 0.3,
+        },
+    },
+    flooding: {
+        detection: {
+            zScoreThreshold: 3.0,
+            windowMinutes: 60,
+            minUniqueSourcesForSuspicion: 3,
+            baselineDays: 7,
+        },
+        quarantine: {
+            enabled: true,
+            durationHours: 24,
+        },
+    },
+};
+// ── Error ───────────────────────────────────────────────────────────────────
+export class SignalIngestionConfigError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'SignalIngestionConfigError';
+    }
+}
+/**
+ * Load and resolve the signal ingestion configuration from
+ * `.ai-sdlc/signal-ingestion.yaml`.
+ *
+ * Returns `DEFAULT_SIGNAL_INGESTION_CONFIG` when the file is absent.
+ * Throws `SignalIngestionConfigError` on parse or validation failure.
+ */
+export function loadSignalIngestionConfig(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const configPath = options.configPath ?? resolve(projectRoot, DEFAULT_SIGNAL_INGESTION_CONFIG_PATH);
+    if (!existsSync(configPath)) {
+        return { ...DEFAULT_SIGNAL_INGESTION_CONFIG };
+    }
+    let raw;
+    try {
+        raw = readFileSync(configPath, 'utf8');
+    }
+    catch (err) {
+        throw new SignalIngestionConfigError(`Failed to read signal ingestion config at ${configPath}`, err);
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch (err) {
+        throw new SignalIngestionConfigError(`Failed to parse signal ingestion YAML at ${configPath}`, err);
+    }
+    return resolveConfig(parsed, configPath);
+}
+// ── Internal resolver ───────────────────────────────────────────────────────
+function resolveConfig(raw, filePath) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new SignalIngestionConfigError(`Signal ingestion config at ${filePath} must be a YAML object`);
+    }
+    const obj = raw;
+    // Validate top-level apiVersion / kind when present (advisory, not enforced)
+    const spec = obj['spec'] ?? obj;
+    return {
+        enabled: resolveBoolean(spec['enabled'], DEFAULT_SIGNAL_INGESTION_CONFIG.enabled),
+        tierMultipliers: resolveTierMultipliers(spec['tierMultipliers']),
+        icpResonanceWeights: resolveIcpResonanceWeights(spec['icpResonanceWeights']),
+        recencyHalfLifeDays: resolvePositiveNumber(spec['recencyHalfLifeDays'], DEFAULT_SIGNAL_INGESTION_CONFIG.recencyHalfLifeDays, 'recencyHalfLifeDays'),
+        tier2SignificanceThreshold: resolveTier2Threshold(spec['tier2SignificanceThreshold']),
+        saResonanceThresholds: resolveSaThresholds(spec['saResonanceThresholds']),
+        clustering: resolveClusteringConfig(spec['clustering']),
+        d1Composition: resolveD1Composition(spec['d1Composition']),
+        adapters: resolveStringArray(spec['adapters'], DEFAULT_SIGNAL_INGESTION_CONFIG.adapters),
+        acceptedLanguages: resolveLanguageList(spec['acceptedLanguages']),
+        languageDetection: resolveLanguageDetectionConfig(spec['languageDetection']),
+        residencyEnforcement: resolveResidencyEnforcement(spec['residencyEnforcement']),
+        manualEntry: resolveManualEntry(spec['manualEntry']),
+        flooding: resolveFloodingConfig(spec['flooding']),
+    };
+}
+function resolveFloodingConfig(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.flooding;
+    if (value === undefined || value === null) {
+        return { detection: { ...defaults.detection }, quarantine: { ...defaults.quarantine } };
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('flooding must be an object');
+    }
+    const obj = value;
+    return {
+        detection: resolveFloodingDetection(obj['detection']),
+        quarantine: resolveFloodingQuarantine(obj['quarantine']),
+    };
+}
+function resolveFloodingDetection(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.flooding.detection;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('flooding.detection must be an object');
+    }
+    const obj = value;
+    // Reject the deprecated `algorithm` field iff it's not `z-score` — only the
+    // z-score algorithm is supported post-AISDLC-433. (Operators with the
+    // `algorithm: z-score` line from the v0.3 RFC YAML pass through silently.)
+    if (obj['algorithm'] !== undefined &&
+        obj['algorithm'] !== null &&
+        obj['algorithm'] !== 'z-score') {
+        throw new SignalIngestionConfigError(`flooding.detection.algorithm must be 'z-score' (multiplier-based detector removed in AISDLC-433), got ${JSON.stringify(obj['algorithm'])}`);
+    }
+    return {
+        zScoreThreshold: resolvePositiveNumber(obj['zScoreThreshold'], defaults.zScoreThreshold, 'flooding.detection.zScoreThreshold'),
+        windowMinutes: resolvePositiveNumber(obj['windowMinutes'], defaults.windowMinutes, 'flooding.detection.windowMinutes'),
+        minUniqueSourcesForSuspicion: resolvePositiveNumber(obj['minUniqueSourcesForSuspicion'], defaults.minUniqueSourcesForSuspicion, 'flooding.detection.minUniqueSourcesForSuspicion'),
+        baselineDays: resolvePositiveNumber(obj['baselineDays'], defaults.baselineDays, 'flooding.detection.baselineDays'),
+    };
+}
+function resolveFloodingQuarantine(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.flooding.quarantine;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('flooding.quarantine must be an object');
+    }
+    const obj = value;
+    return {
+        enabled: resolveBoolean(obj['enabled'], defaults.enabled),
+        durationHours: resolvePositiveNumber(obj['durationHours'], defaults.durationHours, 'flooding.quarantine.durationHours'),
+    };
+}
+/**
+ * Env-var that flips legacy-field handling from "translate + emit Decision"
+ * to "hard-error". The intent: after the one-release-window soak, set this
+ * in CI so adopters who haven't migrated fail loudly. AISDLC-433 ships with
+ * the var OFF — translation + Decision routing is the cutover behaviour.
+ */
+const LEGACY_HARD_ERROR_ENV_VAR = 'AI_SDLC_SIGNAL_INGESTION_LEGACY_HARD_ERROR';
+/**
+ * Load + resolve config, AND surface every deprecated-field Decision the
+ * loader detected. Wraps `loadSignalIngestionConfig()` so callers that want
+ * the deprecation audit trail can opt in without changing the existing
+ * Pure-load callers (which keep using `loadSignalIngestionConfig`).
+ *
+ * Behaviour:
+ *  - When the legacy `flooding.detection.sourceBaselineDriftMultiplier` key
+ *    is present in the YAML AND `LEGACY_HARD_ERROR_ENV_VAR` is unset, the
+ *    loader translates it to `zScoreThreshold = legacyMultiplier × 0.6` (an
+ *    empirical mapping documented in the operator runbook — a 5× multiplier
+ *    over a per-source baseline corresponds approximately to a 3σ spike on
+ *    most production datasets) and emits one
+ *    `signal-ingestion-config-deprecated-field` Decision.
+ *  - When `LEGACY_HARD_ERROR_ENV_VAR=1`, the loader throws
+ *    `SignalIngestionConfigError` with a migration message.
+ *  - When neither legacy key nor v0.3 z-score key is present, the loader
+ *    fills in defaults silently (no deprecation noise).
+ */
+export function loadSignalIngestionConfigWithDeprecations(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const configPath = options.configPath ?? resolve(projectRoot, DEFAULT_SIGNAL_INGESTION_CONFIG_PATH);
+    // Read raw YAML to inspect for legacy keys BEFORE resolveConfig() strips them.
+    const deprecations = [];
+    if (existsSync(configPath)) {
+        let raw;
+        try {
+            raw = readFileSync(configPath, 'utf8');
+        }
+        catch (err) {
+            throw new SignalIngestionConfigError(`Failed to read signal ingestion config at ${configPath}`, err);
+        }
+        let parsed;
+        try {
+            parsed = parseYaml(raw);
+        }
+        catch (err) {
+            throw new SignalIngestionConfigError(`Failed to parse signal ingestion YAML at ${configPath}`, err);
+        }
+        const legacy = extractLegacyFloodingMultiplier(parsed);
+        if (legacy !== undefined) {
+            const hardError = isTruthyEnv(process.env[LEGACY_HARD_ERROR_ENV_VAR]);
+            if (hardError) {
+                throw new SignalIngestionConfigError(`flooding.detection.sourceBaselineDriftMultiplier is removed (AISDLC-433); ` +
+                    `migrate to flooding.detection.zScoreThreshold. ` +
+                    `See docs/operations/signal-ingestion.md §5 for the migration recipe.`);
+            }
+            // Translate legacy multiplier → z-score equivalent.
+            // Empirical mapping: a 5× multiplier ≈ 3σ on most production datasets
+            // (see operator runbook §5 for the derivation). Linear scaling around
+            // the default: `zScore = multiplier × 0.6` — preserves operator intent
+            // while letting the v0.3 algorithm take over.
+            const legacyMultiplier = Number(legacy);
+            const translatedZScore = Number.isFinite(legacyMultiplier)
+                ? legacyMultiplier * 0.6
+                : DEFAULT_SIGNAL_INGESTION_CONFIG.flooding.detection.zScoreThreshold;
+            deprecations.push({
+                type: 'Decision',
+                decision: 'signal-ingestion-config-deprecated-field',
+                field: 'flooding.detection.sourceBaselineDriftMultiplier',
+                replacement: 'flooding.detection.zScoreThreshold',
+                legacyValue: legacy,
+                translatedTo: translatedZScore,
+                message: `flooding.detection.sourceBaselineDriftMultiplier (legacy value ${JSON.stringify(legacy)}) ` +
+                    `is deprecated and will be removed after the one-release-window soak. ` +
+                    `Translated to flooding.detection.zScoreThreshold = ${translatedZScore} for this release. ` +
+                    `Migrate by setting flooding.detection.zScoreThreshold explicitly in ` +
+                    `.ai-sdlc/signal-ingestion.yaml (recommended default 3.0). ` +
+                    `See docs/operations/signal-ingestion.md §5 for the full migration recipe.`,
+            });
+            // Mutate the parsed object so resolveConfig sees a translated value (the
+            // operator's intent is preserved through the legacy-to-z-score mapping).
+            injectTranslatedZScore(parsed, translatedZScore);
+        }
+        const config = resolveConfig(parsed, configPath);
+        return { config, deprecations };
+    }
+    // File absent → defaults; no deprecations.
+    return { config: { ...DEFAULT_SIGNAL_INGESTION_CONFIG }, deprecations };
+}
+function isTruthyEnv(value) {
+    if (value === undefined)
+        return false;
+    const v = value.trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+function extractLegacyFloodingMultiplier(parsed) {
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return undefined;
+    const root = parsed;
+    const spec = root['spec'] ?? root;
+    const flooding = spec['flooding'];
+    if (typeof flooding !== 'object' || flooding === null)
+        return undefined;
+    const detection = flooding['detection'];
+    if (typeof detection !== 'object' || detection === null)
+        return undefined;
+    return detection['sourceBaselineDriftMultiplier'];
+}
+function injectTranslatedZScore(parsed, zScoreThreshold) {
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return;
+    const root = parsed;
+    const spec = root['spec'] ?? root;
+    const flooding = spec['flooding'];
+    if (typeof flooding !== 'object' || flooding === null)
+        return;
+    const detection = flooding['detection'];
+    if (typeof detection !== 'object' || detection === null)
+        return;
+    const detectionObj = detection;
+    // Only inject when operator did NOT also supply the explicit v0.3 key;
+    // an explicit v0.3 value takes precedence over the translated legacy value
+    // (operator's stated intent wins over the inferred translation).
+    if (detectionObj['zScoreThreshold'] === undefined) {
+        detectionObj['zScoreThreshold'] = zScoreThreshold;
+    }
+    // Strip the legacy key so resolveFloodingDetection() doesn't see it via any
+    // future additionalProperties check.
+    delete detectionObj['sourceBaselineDriftMultiplier'];
+}
+function resolveBoolean(value, defaultValue) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    if (typeof value === 'boolean')
+        return value;
+    throw new SignalIngestionConfigError(`Expected boolean, got ${JSON.stringify(value)}`);
+}
+function resolvePositiveNumber(value, defaultValue, field) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0) {
+        throw new SignalIngestionConfigError(`Field ${field} must be a non-negative finite number, got ${JSON.stringify(value)}`);
+    }
+    return n;
+}
+function resolveNonNegativeNumber(value, defaultValue, field) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0) {
+        throw new SignalIngestionConfigError(`Field ${field} must be a non-negative finite number, got ${JSON.stringify(value)}`);
+    }
+    return n;
+}
+function resolveTierMultipliers(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.tierMultipliers;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('tierMultipliers must be an object');
+    }
+    const obj = value;
+    return {
+        enterprise: resolveNonNegativeNumber(obj['enterprise'], defaults.enterprise, 'enterprise'),
+        mid: resolveNonNegativeNumber(obj['mid'], defaults.mid, 'mid'),
+        smb: resolveNonNegativeNumber(obj['smb'], defaults.smb, 'smb'),
+        free: resolveNonNegativeNumber(obj['free'], defaults.free, 'free'),
+        churned: resolveNonNegativeNumber(obj['churned'], defaults.churned, 'churned'),
+    };
+}
+function resolveIcpResonanceWeights(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.icpResonanceWeights;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('icpResonanceWeights must be an object');
+    }
+    const obj = value;
+    return {
+        strong: resolveNonNegativeNumber(obj['strong'], defaults.strong, 'strong'),
+        partial: resolveNonNegativeNumber(obj['partial'], defaults.partial, 'partial'),
+        weak: resolveNonNegativeNumber(obj['weak'], defaults.weak, 'weak'),
+    };
+}
+function resolveTier2Threshold(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.tier2SignificanceThreshold;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('tier2SignificanceThreshold must be an object');
+    }
+    const obj = value;
+    return {
+        minSignalCount: resolvePositiveNumber(obj['minSignalCount'], defaults.minSignalCount, 'minSignalCount'),
+        minUniqueSources: resolvePositiveNumber(obj['minUniqueSources'], defaults.minUniqueSources, 'minUniqueSources'),
+        minTier1SignalCount: resolvePositiveNumber(obj['minTier1SignalCount'], defaults.minTier1SignalCount, 'minTier1SignalCount'),
+        minClusterAgeDays: resolvePositiveNumber(obj['minClusterAgeDays'], defaults.minClusterAgeDays, 'minClusterAgeDays'),
+    };
+}
+function resolveSaThresholds(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.saResonanceThresholds;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('saResonanceThresholds must be an object');
+    }
+    const obj = value;
+    return {
+        fullWeight: resolveNonNegativeNumber(obj['fullWeight'], defaults.fullWeight, 'fullWeight'),
+        discounted: resolveNonNegativeNumber(obj['discounted'], defaults.discounted, 'discounted'),
+        excluded: resolveNonNegativeNumber(obj['excluded'], defaults.excluded, 'excluded'),
+    };
+}
+function resolveD1Composition(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.d1Composition;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('d1Composition must be an object');
+    }
+    const obj = value;
+    return {
+        signalPipelineWeight: resolveNonNegativeNumber(obj['signalPipelineWeight'], defaults.signalPipelineWeight, 'signalPipelineWeight'),
+        backlogItemWeight: resolveNonNegativeNumber(obj['backlogItemWeight'], defaults.backlogItemWeight, 'backlogItemWeight'),
+    };
+}
+function resolveClusteringConfig(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.clustering;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('clustering must be an object');
+    }
+    const obj = value;
+    const algorithm = obj['algorithm'];
+    if (algorithm !== undefined && algorithm !== 'bm25' && algorithm !== 'embedding') {
+        throw new SignalIngestionConfigError(`clustering.algorithm must be 'bm25' or 'embedding', got ${JSON.stringify(algorithm)}`);
+    }
+    return {
+        algorithm: algorithm ?? defaults.algorithm,
+        similarityThreshold: resolveNonNegativeNumber(obj['similarityThreshold'], defaults.similarityThreshold, 'similarityThreshold'),
+    };
+}
+function resolveStringArray(value, defaultValue) {
+    if (value === undefined || value === null)
+        return [...defaultValue];
+    if (!Array.isArray(value))
+        throw new SignalIngestionConfigError('adapters must be an array');
+    if (!value.every((v) => typeof v === 'string')) {
+        throw new SignalIngestionConfigError('adapters entries must be strings');
+    }
+    return value;
+}
+function resolveResidencyEnforcement(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.residencyEnforcement;
+    if (value === undefined || value === null) {
+        return {
+            sourceFromCompliancePosture: defaults.sourceFromCompliancePosture,
+            enforcementPoints: { ...defaults.enforcementPoints },
+            multiPostureBehavior: defaults.multiPostureBehavior,
+        };
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('residencyEnforcement must be an object');
+    }
+    const obj = value;
+    const points = obj['enforcementPoints'];
+    let enforcementPoints = { ...defaults.enforcementPoints };
+    if (points !== undefined && points !== null) {
+        if (typeof points !== 'object' || Array.isArray(points)) {
+            throw new SignalIngestionConfigError('residencyEnforcement.enforcementPoints must be an object');
+        }
+        const p = points;
+        enforcementPoints = {
+            fetchSignals: resolveBoolean(p['fetchSignals'], defaults.enforcementPoints.fetchSignals),
+            clustering: resolveBoolean(p['clustering'], defaults.enforcementPoints.clustering),
+            storage: resolveBoolean(p['storage'], defaults.enforcementPoints.storage),
+            unifiedCostReport: resolveBoolean(p['unifiedCostReport'], defaults.enforcementPoints.unifiedCostReport),
+        };
+    }
+    const multi = obj['multiPostureBehavior'];
+    if (multi !== undefined && multi !== null && multi !== 'union') {
+        throw new SignalIngestionConfigError(`residencyEnforcement.multiPostureBehavior must be 'union' (v1 only), got ${JSON.stringify(multi)}`);
+    }
+    return {
+        sourceFromCompliancePosture: resolveBoolean(obj['sourceFromCompliancePosture'], defaults.sourceFromCompliancePosture),
+        enforcementPoints,
+        multiPostureBehavior: 'union',
+    };
+}
+function resolveManualEntry(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.manualEntry;
+    if (value === undefined || value === null) {
+        return {
+            dailyCapPerOperator: defaults.dailyCapPerOperator,
+            evidenceUrlOptional: defaults.evidenceUrlOptional,
+            qualityMetric: { ...defaults.qualityMetric },
+        };
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('manualEntry must be an object');
+    }
+    const obj = value;
+    const qm = obj['qualityMetric'];
+    let qualityMetric;
+    if (qm === undefined || qm === null) {
+        qualityMetric = { ...defaults.qualityMetric };
+    }
+    else if (typeof qm !== 'object' || Array.isArray(qm)) {
+        throw new SignalIngestionConfigError('manualEntry.qualityMetric must be an object');
+    }
+    else {
+        const q = qm;
+        qualityMetric = {
+            enabled: resolveBoolean(q['enabled'], defaults.qualityMetric.enabled),
+            windowDays: resolvePositiveNumber(q['windowDays'], defaults.qualityMetric.windowDays, 'manualEntry.qualityMetric.windowDays'),
+            shareWarningThreshold: resolveShareThreshold(q['shareWarningThreshold'], defaults.qualityMetric.shareWarningThreshold),
+        };
+    }
+    return {
+        dailyCapPerOperator: resolveNonNegativeNumber(obj['dailyCapPerOperator'], defaults.dailyCapPerOperator, 'manualEntry.dailyCapPerOperator'),
+        evidenceUrlOptional: resolveBoolean(obj['evidenceUrlOptional'], defaults.evidenceUrlOptional),
+        qualityMetric,
+    };
+}
+function resolveShareThreshold(value, defaultValue) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+        throw new SignalIngestionConfigError(`manualEntry.qualityMetric.shareWarningThreshold must be a number in [0, 1], got ${JSON.stringify(value)}`);
+    }
+    return n;
+}
+function resolveLanguageDetectionConfig(value) {
+    const defaults = DEFAULT_SIGNAL_INGESTION_CONFIG.languageDetection;
+    if (value === undefined || value === null)
+        return { ...defaults };
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new SignalIngestionConfigError('languageDetection must be an object');
+    }
+    const obj = value;
+    const library = obj['library'];
+    if (library !== undefined && library !== 'franc' && library !== 'none') {
+        throw new SignalIngestionConfigError(`languageDetection.library must be 'franc' or 'none', got ${JSON.stringify(library)}`);
+    }
+    const onUndetermined = obj['onUndetermined'];
+    if (onUndetermined !== undefined && onUndetermined !== 'accept' && onUndetermined !== 'drop') {
+        throw new SignalIngestionConfigError(`languageDetection.onUndetermined must be 'accept' or 'drop', got ${JSON.stringify(onUndetermined)}`);
+    }
+    return {
+        library: library ?? defaults.library,
+        minDetectionLength: resolvePositiveNumber(obj['minDetectionLength'], defaults.minDetectionLength, 'minDetectionLength'),
+        onUndetermined: onUndetermined ?? defaults.onUndetermined,
+    };
+}
+function resolveLanguageList(value) {
+    if (value === undefined || value === null)
+        return [...DEFAULT_SIGNAL_INGESTION_CONFIG.acceptedLanguages];
+    if (!Array.isArray(value))
+        throw new SignalIngestionConfigError('acceptedLanguages must be an array');
+    if (!value.every((v) => typeof v === 'string')) {
+        throw new SignalIngestionConfigError('acceptedLanguages entries must be strings');
+    }
+    // Normalize to lowercase BCP-47 language tags
+    return value.map((lang) => lang.toLowerCase());
+}
+//# sourceMappingURL=config.js.map