malice

export type HistoryRepairPolicy =

  | 'StartRecent'

  | 'Bridge'

  | { BridgeShortGaps: { threshold_ms: number } };

export interface HistoryRepairBudget {

  max_pages: number;

  max_events: number;

  max_duration_ms: number;

}

export interface HistoryRepairFailure {

  kind: string;

  message: string;

  server?: { status: number; errcode: string; message: string } | null;

  [key: string]: unknown;

}

export interface HistoryRepairReport {

  room_id: string;

  requested_policy: HistoryRepairPolicy;

  strategy: 'Recent' | 'Overlap' | 'Bridge';

  coverage_duration_ms: number | null;

  threshold_evaluated: boolean;

  pages: number;

  events: number;

  phase: 'FetchingRecent' | 'Bridging' | 'Ready' | 'Paused';

  continuity: 'Unresolved' | 'Verified' | 'AccessibleStart';

  recent_available: boolean;

  stop: 'Cancelled' | 'Budget' | 'HistoryUnavailable' | 'NoAnchor' | 'CursorStalled' | null;

  failure: HistoryRepairFailure | null;

}

export const DEFAULT_HISTORY_REPAIR_BUDGET: HistoryRepairBudget = {

  max_pages: 10,

  max_events: 1000,

  max_duration_ms: 15000

};

function record(value: unknown): Record<string, unknown> | null {

  return typeof value === 'object' && value !== null && !Array.isArray(value)

    ? (value as Record<string, unknown>)

    : null;

}

function safeNonnegativeInteger(value: unknown): value is number {

  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;

}

export function parseHistoryRepairPolicy(value: unknown): HistoryRepairPolicy | null {

  if (value === 'StartRecent' || value === 'Bridge') return value;

  const outer = record(value);

  const details = outer && record(outer['BridgeShortGaps']);

  if (!outer || Object.keys(outer).length !== 1 || !details || Object.keys(details).length !== 1 || !safeNonnegativeInteger(details['threshold_ms'])) return null;

  return { BridgeShortGaps: { threshold_ms: details['threshold_ms'] } };

}

function isOneOf<T extends string>(value: unknown, values: readonly T[]): value is T {

  return typeof value === 'string' && (values as readonly string[]).includes(value);

}

export function parseHistoryRepairReport(value: unknown): HistoryRepairReport | null {

  const data = record(value);

  if (!data) return null;

  const policy = parseHistoryRepairPolicy(data['requested_policy']);

  const failure = data['failure'];

  const failureData = failure === null ? null : record(failure);

  if (

    typeof data['room_id'] !== 'string' || !policy ||

    !isOneOf(data['strategy'], ['Recent', 'Overlap', 'Bridge']) ||

    !(data['coverage_duration_ms'] === null || safeNonnegativeInteger(data['coverage_duration_ms'])) ||

    typeof data['threshold_evaluated'] !== 'boolean' ||

    !safeNonnegativeInteger(data['pages']) || !safeNonnegativeInteger(data['events']) ||

    !isOneOf(data['phase'], ['FetchingRecent', 'Bridging', 'Ready', 'Paused']) ||

    !isOneOf(data['continuity'], ['Unresolved', 'Verified', 'AccessibleStart']) ||

    typeof data['recent_available'] !== 'boolean' ||

    !(data['stop'] === null || isOneOf(data['stop'], ['Cancelled', 'Budget', 'HistoryUnavailable', 'NoAnchor', 'CursorStalled'])) ||

    !(failure === null || (failureData && typeof failureData['kind'] === 'string' && typeof failureData['message'] === 'string'))

  ) return null;

  return {

    room_id: data['room_id'],

    requested_policy: policy,

    strategy: data['strategy'],

    coverage_duration_ms: data['coverage_duration_ms'],

    threshold_evaluated: data['threshold_evaluated'],

    pages: data['pages'],

    events: data['events'],

    phase: data['phase'],

    continuity: data['continuity'],

    recent_available: data['recent_available'],

    stop: data['stop'],

    failure: failureData as HistoryRepairFailure | null

  };

}