create-principles-disciple 1.82.0 → 1.83.0

package/console/dist/ui/utils/validators.js

@@ -0,0 +1,995 @@
+/**
+ * Runtime validators for untrusted API response data.
+ *
+ * These validators follow the Runtime Contract Rules (ERR-001/005/009/013):
+ * - All input is treated as `unknown` (Rule 1)
+ * - No `as` type assertions to bypass validation (Rule 2)
+ * - Required fields fail loud when missing (Rule 3)
+ * - Uses `Object.hasOwn()` for untrusted object keys (Rule 5)
+ * - Graceful degradation includes a reason (Rule 9)
+ */
+// ── Primitive guards ──────────────────────────────────────────────────────────
+function isString(v) {
+    return typeof v === 'string';
+}
+function isNumber(v) {
+    return typeof v === 'number' && !Number.isNaN(v);
+}
+function isBoolean(v) {
+    return typeof v === 'boolean';
+}
+function isObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** Read a nullable string field from an untrusted object. */
+function readNullableString(v, key) {
+    if (!Object.hasOwn(v, key))
+        return { valid: true, value: null };
+    const val = v[key];
+    if (val === null || typeof val === 'string')
+        return { valid: true, value: val };
+    return { valid: false };
+}
+/** Read a nullable number field from an untrusted object. */
+function readNullableNumber(v, key) {
+    if (!Object.hasOwn(v, key))
+        return { valid: true, value: null };
+    const val = v[key];
+    if (val === null || (typeof val === 'number' && !Number.isNaN(val)))
+        return { valid: true, value: val };
+    return { valid: false };
+}
+// ── Generic array element validator ───────────────────────────────────────────
+function validateArray(v, validateElement) {
+    if (!Array.isArray(v))
+        return null;
+    const result = [];
+    for (const el of v) {
+        const validated = validateElement(el);
+        if (validated === null)
+            return null;
+        result.push(validated);
+    }
+    return result;
+}
+export function validateErrorResponse(v) {
+    if (!isObject(v))
+        return null;
+    const result = {};
+    if (Object.hasOwn(v, 'message') && isString(v.message)) {
+        result.message = v.message;
+    }
+    if (Object.hasOwn(v, 'error') && isString(v.error)) {
+        result.error = v.error;
+    }
+    if (Object.hasOwn(v, 'nextAction') && isString(v.nextAction)) {
+        result.nextAction = v.nextAction;
+    }
+    return result;
+}
+// ── Request headers validator ─────────────────────────────────────────────────
+/**
+ * Validates that `options.headers` is a plain object with string values.
+ * Returns null if the value is not a valid headers object.
+ * Used instead of `as Record<string, string>` on untrusted RequestInit.headers.
+ */
+export function validateHeaders(v) {
+    if (v === undefined || v === null)
+        return null;
+    if (!isObject(v))
+        return null;
+    const result = {};
+    for (const key of Object.keys(v)) {
+        const value = v[key];
+        if (!isString(value))
+            return null;
+        result[key] = value;
+    }
+    return result;
+}
+export function validateFeedbackReport(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'createdAt') || !isString(v.createdAt))
+        return null;
+    if (!Object.hasOwn(v, 'report') || !isObject(v.report))
+        return null;
+    return { id: v.id, createdAt: v.createdAt, report: v.report };
+}
+export function validateFeedbackDraftsList(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'drafts') || !Array.isArray(v.drafts))
+        return null;
+    return validateArray(v.drafts, (item) => {
+        if (!isObject(item))
+            return null;
+        if (!Object.hasOwn(item, 'id') || !isString(item.id))
+            return null;
+        if (!Object.hasOwn(item, 'createdAt') || !isString(item.createdAt))
+            return null;
+        if (!Object.hasOwn(item, 'type') || !isString(item.type))
+            return null;
+        if (!Object.hasOwn(item, 'title') || !isString(item.title))
+            return null;
+        return { id: item.id, createdAt: item.createdAt, type: item.type, title: item.title };
+    });
+}
+export function validateFeedbackDraftEnvelope(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'report') || !isObject(v.report))
+        return null;
+    return { report: v.report };
+}
+export function validateDeleteEnvelope(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'deleted') || !isBoolean(v.deleted))
+        return null;
+    return { deleted: v.deleted };
+}
+function validateWorkspaceConfig(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'workspaceName') || !isString(v.workspaceName))
+        return null;
+    if (!Object.hasOwn(v, 'enabled') || !isBoolean(v.enabled))
+        return null;
+    const displayName = readNullableString(v, 'displayName');
+    if (!displayName.valid)
+        return null;
+    if (!Object.hasOwn(v, 'syncEnabled') || !isBoolean(v.syncEnabled))
+        return null;
+    return {
+        workspaceName: v.workspaceName,
+        enabled: v.enabled,
+        displayName: displayName.value,
+        syncEnabled: v.syncEnabled,
+    };
+}
+export function validateWorkspaceEntry(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'name') || !isString(v.name))
+        return null;
+    if (!Object.hasOwn(v, 'path') || !isString(v.path))
+        return null;
+    const lastSync = readNullableString(v, 'lastSync');
+    if (!lastSync.valid)
+        return null;
+    let config = null;
+    if (Object.hasOwn(v, 'config') && v.config !== null) {
+        config = validateWorkspaceConfig(v.config);
+        if (config === null)
+            return null;
+    }
+    return {
+        name: v.name,
+        path: v.path,
+        lastSync: lastSync.value,
+        config,
+    };
+}
+export function validateWorkspaceList(v) {
+    return validateArray(v, validateWorkspaceEntry);
+}
+export function validateRemovedEnvelope(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'removed') || !isString(v.removed))
+        return null;
+    return { removed: v.removed };
+}
+export function validateSyncResult(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'success') || !isBoolean(v.success))
+        return null;
+    if (!Object.hasOwn(v, 'syncedAt') || !isString(v.syncedAt))
+        return null;
+    return { success: v.success, syncedAt: v.syncedAt };
+}
+function validateReadinessStatus(v) {
+    switch (v) {
+        case 'ready':
+        case 'not_ready':
+        case 'needs_setup':
+        case 'disabled':
+        case 'unknown':
+            return v;
+        default:
+            return null;
+    }
+}
+function validateRuntimeProfileSummary(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'type') || !isString(v.type))
+        return null;
+    if (!Object.hasOwn(v, 'label') || !isString(v.label))
+        return null;
+    if (Object.hasOwn(v, 'apiKeyEnv') && !isString(v.apiKeyEnv))
+        return null;
+    if (!Object.hasOwn(v, 'readiness'))
+        return null;
+    const readiness = validateReadinessStatus(v.readiness);
+    if (readiness === null)
+        return null;
+    return {
+        id: v.id, type: v.type, label: v.label,
+        ...(Object.hasOwn(v, 'apiKeyEnv') && isString(v.apiKeyEnv) ? { apiKeyEnv: v.apiKeyEnv } : {}),
+        readiness,
+    };
+}
+function validateFeatureSummary(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'category') || !isString(v.category))
+        return null;
+    if (!Object.hasOwn(v, 'enabled') || !isBoolean(v.enabled))
+        return null;
+    return { id: v.id, category: v.category, enabled: v.enabled };
+}
+function validateAgentSummary(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'name') || !isString(v.name))
+        return null;
+    if (!Object.hasOwn(v, 'enabled') || !isBoolean(v.enabled))
+        return null;
+    if (!Object.hasOwn(v, 'runtimeProfileId') || !isString(v.runtimeProfileId))
+        return null;
+    if (!Object.hasOwn(v, 'runtimeProfileLabel') || !isString(v.runtimeProfileLabel))
+        return null;
+    if (!Object.hasOwn(v, 'readiness'))
+        return null;
+    const readiness = validateReadinessStatus(v.readiness);
+    if (readiness === null)
+        return null;
+    return { name: v.name, enabled: v.enabled, runtimeProfileId: v.runtimeProfileId, runtimeProfileLabel: v.runtimeProfileLabel, readiness };
+}
+function validateConfigError(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'path') || !isString(v.path))
+        return null;
+    if (!Object.hasOwn(v, 'reason') || !isString(v.reason))
+        return null;
+    if (!Object.hasOwn(v, 'nextAction') || !isString(v.nextAction))
+        return null;
+    return { path: v.path, reason: v.reason, nextAction: v.nextAction };
+}
+function validateConfigSource(v) {
+    switch (v) {
+        case 'defaults':
+        case 'user_config':
+            return v;
+        default:
+            return null;
+    }
+}
+export function validateConfigSummary(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'version') || !isNumber(v.version))
+        return null;
+    if (!Object.hasOwn(v, 'source'))
+        return null;
+    const source = validateConfigSource(v.source);
+    if (source === null)
+        return null;
+    if (!Object.hasOwn(v, 'features') || !Array.isArray(v.features))
+        return null;
+    if (!Object.hasOwn(v, 'runtimeProfiles') || !Array.isArray(v.runtimeProfiles))
+        return null;
+    if (!Object.hasOwn(v, 'defaultRuntime') || !isString(v.defaultRuntime))
+        return null;
+    if (!Object.hasOwn(v, 'agents') || !Array.isArray(v.agents))
+        return null;
+    if (!Object.hasOwn(v, 'ui') || !isObject(v.ui))
+        return null;
+    if (!Object.hasOwn(v, 'warnings') || !Array.isArray(v.warnings))
+        return null;
+    const features = validateArray(v.features, validateFeatureSummary);
+    if (features === null)
+        return null;
+    const runtimeProfiles = validateArray(v.runtimeProfiles, validateRuntimeProfileSummary);
+    if (runtimeProfiles === null)
+        return null;
+    const agents = validateArray(v.agents, validateAgentSummary);
+    if (agents === null)
+        return null;
+    const warnings = validateArray(v.warnings, (el) => isString(el) ? el : null);
+    if (warnings === null)
+        return null;
+    // ui.diagnostics.mode
+    const { ui } = v;
+    if (!Object.hasOwn(ui, 'diagnostics') || !isObject(ui.diagnostics))
+        return null;
+    if (!Object.hasOwn(ui.diagnostics, 'mode') || !isString(ui.diagnostics.mode))
+        return null;
+    let errors;
+    if (Object.hasOwn(v, 'errors') && Array.isArray(v.errors)) {
+        errors = validateArray(v.errors, validateConfigError) ?? undefined;
+    }
+    return {
+        version: v.version, source, features, runtimeProfiles,
+        defaultRuntime: v.defaultRuntime, agents,
+        ui: { diagnostics: { mode: ui.diagnostics.mode } },
+        warnings, errors,
+    };
+}
+export function validateConfigCatalog(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'profiles') || !Array.isArray(v.profiles))
+        return null;
+    const profiles = validateArray(v.profiles, validateRuntimeProfileSummary);
+    if (profiles === null)
+        return null;
+    let errors;
+    if (Object.hasOwn(v, 'errors') && Array.isArray(v.errors)) {
+        errors = validateArray(v.errors, validateConfigError) ?? undefined;
+    }
+    return { profiles, errors };
+}
+export function validateAgentBindingUpdate(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'agent') || !isString(v.agent))
+        return null;
+    if (!Object.hasOwn(v, 'runtimeProfile') || !isString(v.runtimeProfile))
+        return null;
+    if (!Object.hasOwn(v, 'enabled') || !isBoolean(v.enabled))
+        return null;
+    return { agent: v.agent, runtimeProfile: v.runtimeProfile, enabled: v.enabled };
+}
+export function validateReadinessCheck(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'agent') || !isString(v.agent))
+        return null;
+    if (!Object.hasOwn(v, 'readiness'))
+        return null;
+    const readiness = validateReadinessStatus(v.readiness);
+    if (readiness === null)
+        return null;
+    if (!Object.hasOwn(v, 'profileId') || !isString(v.profileId))
+        return null;
+    if (!Object.hasOwn(v, 'profileLabel') || !isString(v.profileLabel))
+        return null;
+    const result = { agent: v.agent, readiness, profileId: v.profileId, profileLabel: v.profileLabel };
+    if (Object.hasOwn(v, 'reason') && isString(v.reason))
+        result.reason = v.reason;
+    if (Object.hasOwn(v, 'nextAction') && isString(v.nextAction))
+        result.nextAction = v.nextAction;
+    return result;
+}
+export function validateDefaultRuntimeUpdate(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'defaultRuntime') || !isString(v.defaultRuntime))
+        return null;
+    return { defaultRuntime: v.defaultRuntime };
+}
+function validateHealthCheckItem(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'name') || !isString(v.name))
+        return null;
+    if (!Object.hasOwn(v, 'status') || !isString(v.status))
+        return null;
+    if (!Object.hasOwn(v, 'message') || !isString(v.message))
+        return null;
+    if (!Object.hasOwn(v, 'lastCheck') || !isString(v.lastCheck))
+        return null;
+    return { id: v.id, name: v.name, status: v.status, message: v.message, lastCheck: v.lastCheck };
+}
+export function validateConfigReadiness(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'checks') || !Array.isArray(v.checks))
+        return null;
+    if (!Object.hasOwn(v, 'generatedAt') || !isString(v.generatedAt))
+        return null;
+    const checks = validateArray(v.checks, validateHealthCheckItem);
+    if (checks === null)
+        return null;
+    return { checks, generatedAt: v.generatedAt };
+}
+function validateStagnationSignal(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'type') || !isString(v.type))
+        return null;
+    if (!Object.hasOwn(v, 'principleId') || !isString(v.principleId))
+        return null;
+    if (!Object.hasOwn(v, 'daysSince') || !isNumber(v.daysSince))
+        return null;
+    return { type: v.type, principleId: v.principleId, daysSince: v.daysSince };
+}
+const VALID_GOVERNANCE_STATES = new Set(['none', 'in_progress', 'owner_review_ready', 'degraded']);
+const VALID_STATE_REASON_CODES = new Set([
+    'state_db_missing', 'no_pipeline_activity', 'pending_approvals',
+    'pipeline_active', 'consumed_candidates', 'degraded_state',
+]);
+const VALID_NEXT_ACTION_CODES = new Set([
+    'run_config_doctor', 'wait_for_pipeline', 'review_approvals',
+    'check_degraded_signals', 'check_pipeline_status',
+]);
+const VALID_DEGRADED_REASON_CODES = new Set(['task_retry_wait', 'task_failed', 'approval_table_missing']);
+const VALID_DEGRADED_NEXT_ACTION_CODES = new Set(['check_task_status', 'fix_and_retry', 'run_integrity_check']);
+function validateDegradedSignal(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'reasonCode') || !isString(v.reasonCode))
+        return null;
+    if (!VALID_DEGRADED_REASON_CODES.has(v.reasonCode))
+        return null;
+    if (!Object.hasOwn(v, 'nextActionCode') || !isString(v.nextActionCode))
+        return null;
+    if (!VALID_DEGRADED_NEXT_ACTION_CODES.has(v.nextActionCode))
+        return null;
+    if (!Object.hasOwn(v, 'reason') || !isString(v.reason))
+        return null;
+    if (!Object.hasOwn(v, 'nextAction') || !isString(v.nextAction))
+        return null;
+    if (!Object.hasOwn(v, 'source') || !isString(v.source))
+        return null;
+    return {
+        reasonCode: v.reasonCode,
+        nextActionCode: v.nextActionCode,
+        reason: v.reason,
+        nextAction: v.nextAction,
+        source: v.source,
+    };
+}
+export function validateGovernanceQueue(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'pendingReviewCount') || !isNumber(v.pendingReviewCount))
+        return null;
+    if (!Object.hasOwn(v, 'behaviorDeviationCount') || !isNumber(v.behaviorDeviationCount))
+        return null;
+    if (!Object.hasOwn(v, 'stagnationSignals') || !Array.isArray(v.stagnationSignals))
+        return null;
+    if (!Object.hasOwn(v, 'governanceState') || !isString(v.governanceState))
+        return null;
+    if (!VALID_GOVERNANCE_STATES.has(v.governanceState))
+        return null;
+    if (!Object.hasOwn(v, 'stateReasonCode') || !isString(v.stateReasonCode))
+        return null;
+    if (!VALID_STATE_REASON_CODES.has(v.stateReasonCode))
+        return null;
+    if (!Object.hasOwn(v, 'nextActionCode') || !isString(v.nextActionCode))
+        return null;
+    if (!VALID_NEXT_ACTION_CODES.has(v.nextActionCode))
+        return null;
+    if (!Object.hasOwn(v, 'stateReason') || !isString(v.stateReason))
+        return null;
+    if (!Object.hasOwn(v, 'nextAction') || !isString(v.nextAction))
+        return null;
+    const signals = validateArray(v.stagnationSignals, validateStagnationSignal);
+    if (signals === null)
+        return null;
+    const result = {
+        pendingReviewCount: v.pendingReviewCount,
+        behaviorDeviationCount: v.behaviorDeviationCount,
+        stagnationSignals: signals,
+        governanceState: VALID_GOVERNANCE_STATES.has(v.governanceState)
+            ? v.governanceState
+            : 'none',
+        stateReasonCode: v.stateReasonCode,
+        nextActionCode: v.nextActionCode,
+        stateReason: v.stateReason,
+        nextAction: v.nextAction,
+    };
+    // Optional fields — fail loud when present but wrong type (ERR-009)
+    if (Object.hasOwn(v, 'inProgressSummary')) {
+        if (!isString(v.inProgressSummary))
+            return null;
+        result.inProgressSummary = v.inProgressSummary;
+    }
+    if (Object.hasOwn(v, 'degradedSignals')) {
+        if (!Array.isArray(v.degradedSignals))
+            return null;
+        const ds = validateArray(v.degradedSignals, validateDegradedSignal);
+        if (ds === null)
+            return null;
+        result.degradedSignals = ds;
+    }
+    if (Object.hasOwn(v, 'note')) {
+        if (!isString(v.note))
+            return null;
+        result.note = v.note;
+    }
+    if (Object.hasOwn(v, 'generatedAt')) {
+        if (!isString(v.generatedAt))
+            return null;
+        result.generatedAt = v.generatedAt;
+    }
+    return result;
+}
+function validateActivationRecord(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'artifactId') || !isString(v.artifactId))
+        return null;
+    if (!Object.hasOwn(v, 'principleId') || !isString(v.principleId))
+        return null;
+    if (!Object.hasOwn(v, 'channel') || !isString(v.channel))
+        return null;
+    if (!Object.hasOwn(v, 'action') || !isString(v.action))
+        return null;
+    if (!Object.hasOwn(v, 'targetRef') || !isString(v.targetRef))
+        return null;
+    const activatedAt = readNullableString(v, 'activatedAt');
+    if (!activatedAt.valid)
+        return null;
+    if (!Object.hasOwn(v, 'status') || !isString(v.status))
+        return null;
+    return {
+        id: v.id, artifactId: v.artifactId, principleId: v.principleId,
+        channel: v.channel, action: v.action, targetRef: v.targetRef,
+        activatedAt: activatedAt.value,
+        status: v.status,
+    };
+}
+export function validateActivations(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'activations') || !Array.isArray(v.activations))
+        return null;
+    if (!Object.hasOwn(v, 'generatedAt') || !isString(v.generatedAt))
+        return null;
+    const activations = validateArray(v.activations, validateActivationRecord);
+    if (activations === null)
+        return null;
+    const result = { activations, generatedAt: v.generatedAt };
+    if (Object.hasOwn(v, 'note') && isString(v.note))
+        result.note = v.note;
+    return result;
+}
+export function validateDisableActivation(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'activationId') || !isString(v.activationId))
+        return null;
+    if (!Object.hasOwn(v, 'status') || !isString(v.status))
+        return null;
+    return { activationId: v.activationId, status: v.status };
+}
+function validateLifecycleAdherence(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'insufficientData') || !isBoolean(v.insufficientData))
+        return null;
+    const rate = readNullableNumber(v, 'rate');
+    if (!rate.valid)
+        return null;
+    if (!Object.hasOwn(v, 'note') || !isString(v.note))
+        return null;
+    return {
+        insufficientData: v.insufficientData,
+        rate: rate.value,
+        note: v.note,
+    };
+}
+function validateLifecycleRuleMetric(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'ruleId') || !isString(v.ruleId))
+        return null;
+    if (!Object.hasOwn(v, 'triggered') || !isNumber(v.triggered))
+        return null;
+    const lastTriggeredAt = readNullableString(v, 'lastTriggeredAt');
+    if (!lastTriggeredAt.valid)
+        return null;
+    return {
+        ruleId: v.ruleId, triggered: v.triggered,
+        lastTriggeredAt: lastTriggeredAt.value,
+    };
+}
+export function validateLifecycleMetrics(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'principleId') || !isString(v.principleId))
+        return null;
+    if (!Object.hasOwn(v, 'adherence'))
+        return null;
+    const adherence = validateLifecycleAdherence(v.adherence);
+    if (adherence === null)
+        return null;
+    if (!Object.hasOwn(v, 'ruleMetrics') || !Array.isArray(v.ruleMetrics))
+        return null;
+    const ruleMetrics = validateArray(v.ruleMetrics, validateLifecycleRuleMetric);
+    if (ruleMetrics === null)
+        return null;
+    return { principleId: v.principleId, adherence, ruleMetrics };
+}
+export function validateUpdateStatus(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'currentVersion') || !isString(v.currentVersion))
+        return null;
+    if (!Object.hasOwn(v, 'latestVersion') || !isString(v.latestVersion))
+        return null;
+    if (!Object.hasOwn(v, 'updateAvailable') || !isBoolean(v.updateAvailable))
+        return null;
+    if (!Object.hasOwn(v, 'lastChecked') || !isString(v.lastChecked))
+        return null;
+    return { currentVersion: v.currentVersion, latestVersion: v.latestVersion, updateAvailable: v.updateAvailable, lastChecked: v.lastChecked };
+}
+function validateUpdateHistoryEntry(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'version') || !isString(v.version))
+        return null;
+    if (!Object.hasOwn(v, 'appliedAt') || !isString(v.appliedAt))
+        return null;
+    if (!Object.hasOwn(v, 'notes') || !isString(v.notes))
+        return null;
+    return { version: v.version, appliedAt: v.appliedAt, notes: v.notes };
+}
+export function validateUpdateHistory(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'updates') || !Array.isArray(v.updates))
+        return null;
+    const updates = validateArray(v.updates, validateUpdateHistoryEntry);
+    if (updates === null)
+        return null;
+    return { updates };
+}
+function validateApprovalRecord(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'approvalId') || !isString(v.approvalId))
+        return null;
+    if (!Object.hasOwn(v, 'artifactId') || !isString(v.artifactId))
+        return null;
+    if (!Object.hasOwn(v, 'channel') || !isString(v.channel))
+        return null;
+    if (!Object.hasOwn(v, 'riskLevel') || !isString(v.riskLevel))
+        return null;
+    if (!Object.hasOwn(v, 'status') || !isString(v.status))
+        return null;
+    if (Object.hasOwn(v, 'confidence') && !isNumber(v.confidence))
+        return null;
+    if (!Object.hasOwn(v, 'requestedAt') || !isString(v.requestedAt))
+        return null;
+    const result = {
+        approvalId: v.approvalId, artifactId: v.artifactId, channel: v.channel,
+        riskLevel: v.riskLevel, status: v.status,
+        confidence: Object.hasOwn(v, 'confidence') && isNumber(v.confidence) ? v.confidence : undefined,
+        requestedAt: v.requestedAt,
+        decidedAt: Object.hasOwn(v, 'decidedAt') && isString(v.decidedAt) ? v.decidedAt : undefined,
+        decidedBy: Object.hasOwn(v, 'decidedBy') && isString(v.decidedBy) ? v.decidedBy : undefined,
+        decisionNote: Object.hasOwn(v, 'decisionNote') && isString(v.decisionNote) ? v.decisionNote : undefined,
+        rejectionReason: Object.hasOwn(v, 'rejectionReason') && isString(v.rejectionReason) ? v.rejectionReason : undefined,
+        summary: Object.hasOwn(v, 'summary') && isString(v.summary) ? v.summary : undefined,
+        triggerReason: Object.hasOwn(v, 'triggerReason') && isString(v.triggerReason) ? v.triggerReason : undefined,
+        confidenceLabel: Object.hasOwn(v, 'confidenceLabel') && isString(v.confidenceLabel) ? v.confidenceLabel : undefined,
+        confidenceExplanation: Object.hasOwn(v, 'confidenceExplanation') && isString(v.confidenceExplanation) ? v.confidenceExplanation : undefined,
+        effectDescription: Object.hasOwn(v, 'effectDescription') && isString(v.effectDescription) ? v.effectDescription : undefined,
+        rejectionEffect: Object.hasOwn(v, 'rejectionEffect') && isString(v.rejectionEffect) ? v.rejectionEffect : undefined,
+    };
+    if (Object.hasOwn(v, 'isMvpProven') && isBoolean(v.isMvpProven))
+        result.isMvpProven = v.isMvpProven;
+    return result;
+}
+export function validateApprovalListResult(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'items') || !Array.isArray(v.items))
+        return null;
+    if (!Object.hasOwn(v, 'total') || !isNumber(v.total))
+        return null;
+    if (!Object.hasOwn(v, 'stats') || !isObject(v.stats))
+        return null;
+    const { stats } = v;
+    if (!Object.hasOwn(stats, 'pending') || !isNumber(stats.pending))
+        return null;
+    if (!Object.hasOwn(stats, 'approved') || !isNumber(stats.approved))
+        return null;
+    if (!Object.hasOwn(stats, 'rejected') || !isNumber(stats.rejected))
+        return null;
+    if (!Object.hasOwn(stats, 'cancelled') || !isNumber(stats.cancelled))
+        return null;
+    const items = validateArray(v.items, validateApprovalRecord);
+    if (items === null)
+        return null;
+    return { items, total: v.total, stats: { pending: stats.pending, approved: stats.approved, rejected: stats.rejected, cancelled: stats.cancelled } };
+}
+// Re-export the private validateApprovalRecord for direct use
+export { validateApprovalRecord as validateApprovalRecordDirect };
+const VALID_WARNING_CODES = ['technical_pattern', 'diagnostic_residue', 'title_too_long'];
+function isReadabilityWarningCode(value) {
+    return isString(value) && VALID_WARNING_CODES.includes(value);
+}
+function validatePrincipleListItem(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'text') || !isString(v.text))
+        return null;
+    if (!Object.hasOwn(v, 'triggerPattern') || !isString(v.triggerPattern))
+        return null;
+    if (!Object.hasOwn(v, 'action') || !isString(v.action))
+        return null;
+    if (!Object.hasOwn(v, 'status') || !isString(v.status))
+        return null;
+    if (!Object.hasOwn(v, 'priority') || !isString(v.priority))
+        return null;
+    if (!Object.hasOwn(v, 'scope') || !isString(v.scope))
+        return null;
+    const domain = readNullableString(v, 'domain');
+    if (!domain.valid)
+        return null;
+    if (!Object.hasOwn(v, 'evaluability') || !isString(v.evaluability))
+        return null;
+    if (!Object.hasOwn(v, 'valueScore') || !isNumber(v.valueScore))
+        return null;
+    if (!Object.hasOwn(v, 'adherenceRate') || !isNumber(v.adherenceRate))
+        return null;
+    if (!Object.hasOwn(v, 'painPreventedCount') || !isNumber(v.painPreventedCount))
+        return null;
+    if (!Object.hasOwn(v, 'ruleCount') || !isNumber(v.ruleCount))
+        return null;
+    if (!Object.hasOwn(v, 'conflictsWithCount') || !isNumber(v.conflictsWithCount))
+        return null;
+    if (!Object.hasOwn(v, 'createdAt') || !isString(v.createdAt))
+        return null;
+    if (!Object.hasOwn(v, 'updatedAt') || !isString(v.updatedAt))
+        return null;
+    const result = {
+        id: v.id, text: v.text, triggerPattern: v.triggerPattern, action: v.action,
+        status: v.status, priority: v.priority, scope: v.scope,
+        domain: domain.value,
+        evaluability: v.evaluability, valueScore: v.valueScore, adherenceRate: v.adherenceRate,
+        painPreventedCount: v.painPreventedCount, ruleCount: v.ruleCount,
+        conflictsWithCount: v.conflictsWithCount, createdAt: v.createdAt, updatedAt: v.updatedAt,
+        // PRI-332: detectedLanguage — absent defaults to 'unknown'; present but malformed → fail loud (ERR-009)
+        detectedLanguage: 'unknown',
+    };
+    if (Object.hasOwn(v, 'detectedLanguage')) {
+        if (!isString(v.detectedLanguage))
+            return null;
+        result.detectedLanguage = v.detectedLanguage;
+    }
+    // PRI-332 P1-5: readabilityWarningCode is optional — fail loud when present but invalid (ERR-009)
+    if (Object.hasOwn(v, 'readabilityWarningCode')) {
+        if (!isReadabilityWarningCode(v.readabilityWarningCode))
+            return null;
+        result.readabilityWarningCode = v.readabilityWarningCode;
+    }
+    return result;
+}
+export function validatePrinciplesList(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'principles') || !Array.isArray(v.principles))
+        return null;
+    if (!Object.hasOwn(v, 'summary') || !isObject(v.summary))
+        return null;
+    const s = v.summary;
+    const { candidate, probation, active, deprecated, archived, total } = s;
+    if (!isNumber(candidate) || !isNumber(probation) || !isNumber(active) || !isNumber(deprecated) || !isNumber(archived) || !isNumber(total))
+        return null;
+    const principles = validateArray(v.principles, validatePrincipleListItem);
+    if (principles === null)
+        return null;
+    // categories is optional (PRI-330) — EP-01: runtime validate, no `as` bypass
+    // When present but invalid, fail loud (ERR-009: required-ish fields fail loud)
+    let categories;
+    if (Object.hasOwn(v, 'categories')) {
+        if (!isObject(v.categories))
+            return null; // categories exists but is not an object → reject
+        const raw = v.categories;
+        const validated = {};
+        for (const [key, val] of Object.entries(raw)) {
+            if (!isNumber(val))
+                return null; // categories value is not a number → reject
+            validated[key] = val;
+        }
+        if (Object.keys(validated).length > 0) {
+            categories = validated;
+        }
+    }
+    // approvalCrossCheckUnavailable — optional string, fail loud if wrong type
+    // (ERR-009: required-ish fields fail loud; ERR-002: no silent degradation)
+    if (Object.hasOwn(v, 'approvalCrossCheckUnavailable') && !isString(v.approvalCrossCheckUnavailable)) {
+        return null;
+    }
+    const approvalCrossCheckUnavailable = isString(v.approvalCrossCheckUnavailable)
+        ? v.approvalCrossCheckUnavailable
+        : undefined;
+    return {
+        principles,
+        summary: { candidate, probation, active, deprecated, archived, total },
+        ...(categories !== undefined ? { categories } : {}),
+        ...(approvalCrossCheckUnavailable !== undefined ? { approvalCrossCheckUnavailable } : {}),
+    };
+}
+function validateApprovalGroupRecord(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'artifactId') || !isString(v.artifactId))
+        return null;
+    if (!Object.hasOwn(v, 'channel') || !isString(v.channel))
+        return null;
+    if (!Object.hasOwn(v, 'createdAt') || !isString(v.createdAt))
+        return null;
+    return { id: v.id, artifactId: v.artifactId, channel: v.channel, createdAt: v.createdAt };
+}
+function validateApprovalGroup(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'principleId') || !isString(v.principleId))
+        return null;
+    if (!Object.hasOwn(v, 'principleTitle') || !isString(v.principleTitle))
+        return null;
+    if (!Object.hasOwn(v, 'status') || !isString(v.status))
+        return null;
+    if (!Object.hasOwn(v, 'records') || !Array.isArray(v.records))
+        return null;
+    const records = validateArray(v.records, validateApprovalGroupRecord);
+    if (records === null)
+        return null;
+    return { principleId: v.principleId, principleTitle: v.principleTitle, status: v.status, records };
+}
+export function validateApprovalsGrouped(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'groups') || !Array.isArray(v.groups))
+        return null;
+    if (!Object.hasOwn(v, 'generatedAt') || !isString(v.generatedAt))
+        return null;
+    const groups = validateArray(v.groups, validateApprovalGroup);
+    if (groups === null)
+        return null;
+    const result = { groups, generatedAt: v.generatedAt };
+    if (Object.hasOwn(v, 'note') && isString(v.note))
+        result.note = v.note;
+    return result;
+}
+// ── Evidence Chain (PRI-331) ──────────────────────────────────────────────────
+const VALID_EVIDENCE_CHAIN_STATES = new Set([
+    'evidence_only',
+    'pain_recorded',
+    'diagnosis_queued',
+    'diagnosis_running',
+    'diagnosis_succeeded',
+    'diagnosis_failed',
+    'diagnosis_retry_wait',
+    'candidate_generated',
+    'internalization_started',
+]);
+function validateEvidenceChainRecord(v) {
+    if (!isObject(v))
+        return null;
+    // Required fields (ERR-009: fail loud when missing)
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'sourceKind') || !isString(v.sourceKind))
+        return null;
+    if (!Object.hasOwn(v, 'observedAt') || !isString(v.observedAt))
+        return null;
+    if (!Object.hasOwn(v, 'state') || !isString(v.state))
+        return null;
+    if (!VALID_EVIDENCE_CHAIN_STATES.has(v.state))
+        return null;
+    if (!Object.hasOwn(v, 'summary') || !isString(v.summary))
+        return null;
+    const result = {
+        id: v.id,
+        sourceKind: v.sourceKind,
+        observedAt: v.observedAt,
+        state: v.state,
+        summary: v.summary,
+    };
+    // Optional fields — fail loud when present but wrong type (ERR-009)
+    if (Object.hasOwn(v, 'admissionDecision')) {
+        if (!isString(v.admissionDecision))
+            return null;
+        result.admissionDecision = v.admissionDecision;
+    }
+    if (Object.hasOwn(v, 'linkedPainId')) {
+        if (!isString(v.linkedPainId))
+            return null;
+        result.linkedPainId = v.linkedPainId;
+    }
+    if (Object.hasOwn(v, 'linkedTaskId')) {
+        if (!isString(v.linkedTaskId))
+            return null;
+        result.linkedTaskId = v.linkedTaskId;
+    }
+    if (Object.hasOwn(v, 'linkedTaskStatus')) {
+        if (!isString(v.linkedTaskStatus))
+            return null;
+        result.linkedTaskStatus = v.linkedTaskStatus;
+    }
+    if (Object.hasOwn(v, 'linkedCandidateId')) {
+        if (!isString(v.linkedCandidateId))
+            return null;
+        result.linkedCandidateId = v.linkedCandidateId;
+    }
+    if (Object.hasOwn(v, 'linkedPrincipleId')) {
+        if (!isString(v.linkedPrincipleId))
+            return null;
+        result.linkedPrincipleId = v.linkedPrincipleId;
+    }
+    if (Object.hasOwn(v, 'failureReason')) {
+        if (!isString(v.failureReason))
+            return null;
+        result.failureReason = v.failureReason;
+    }
+    if (Object.hasOwn(v, 'degradedReason')) {
+        if (!isString(v.degradedReason))
+            return null;
+        result.degradedReason = v.degradedReason;
+    }
+    if (Object.hasOwn(v, 'nextAction')) {
+        if (!isString(v.nextAction))
+            return null;
+        result.nextAction = v.nextAction;
+    }
+    return result;
+}
+export function validateEvidenceChain(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'records') || !Array.isArray(v.records))
+        return null;
+    if (!Object.hasOwn(v, 'generatedAt') || !isString(v.generatedAt))
+        return null;
+    const records = validateArray(v.records, validateEvidenceChainRecord);
+    if (records === null)
+        return null;
+    const result = {
+        records,
+        generatedAt: v.generatedAt,
+    };
+    if (Object.hasOwn(v, 'degradedReason')) {
+        if (!isString(v.degradedReason))
+            return null;
+        result.degradedReason = v.degradedReason;
+    }
+    if (Object.hasOwn(v, 'nextAction')) {
+        if (!isString(v.nextAction))
+            return null;
+        result.nextAction = v.nextAction;
+    }
+    if (Object.hasOwn(v, 'note')) {
+        if (!isString(v.note))
+            return null;
+        result.note = v.note;
+    }
+    return result;
+}
+const VALID_OUTPUT_LANGUAGE_VALUES = ['zh-CN', 'en'];
+export function validateOutputLanguage(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'outputLanguage') || !isString(v.outputLanguage))
+        return null;
+    if (!VALID_OUTPUT_LANGUAGE_VALUES.includes(v.outputLanguage))
+        return null;
+    if (!Object.hasOwn(v, 'source') || !isString(v.source))
+        return null;
+    return { outputLanguage: v.outputLanguage, source: v.source };
+}