@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/client-web/src/sql-lens-view.ts

@@ -0,0 +1,247 @@
+export type SqlLensStatusState = "idle" | "running" | "completed" | "failed" | "cancelled" | "unknown";
+
+export interface SqlLensPanelView {
+  readonly status: { readonly state: SqlLensStatusState; readonly at: string | null; readonly error: string | null };
+  readonly timeoutMs: number;
+  readonly latest: {
+    readonly database: string;
+    readonly query: string;
+    readonly columns: readonly string[];
+    readonly rows: readonly Record<string, unknown>[];
+    readonly rowInventory: {
+      readonly scanned: number;
+      readonly returned: number;
+      readonly shown: number;
+      readonly truncated: boolean;
+      readonly displayLimit: number;
+    };
+  } | null;
+  readonly limits: typeof limitsDefaults;
+  readonly malformed: boolean;
+}
+
+const visibleRows = 12;
+const visibleColumns = 32;
+const maxColumnName = 512;
+const maxDisplayString = 16_384;
+const maxStatusError = 2_000;
+const visibleStatusError = 500;
+const defaults = {
+  timeoutMs: 5_000,
+} as const;
+const limitsDefaults = {
+  queryLength: 65_536,
+  databaseBytes: 268_435_456,
+  rows: 100,
+  columns: 128,
+  stringLength: 16_384,
+  resultBytes: 1_048_576,
+  blobPreviewBytes: 256,
+  panelRows: 20,
+} as const;
+const rootKeys = new Set(["status", "timeoutMs", "latest", "limits"]);
+const statusKeys = new Set(["state", "at", "error"]);
+const latestKeys = new Set(["database", "query", "columns", "rows", "truncated", "scannedRows", "rowInventory"]);
+const rowInventoryKeys = new Set(["scanned", "returned", "shown", "truncated", "displayLimit"]);
+const cellKeys = new Set(["type", "bytes", "previewBase64", "truncated"]);
+const limitKeys = new Set(Object.keys(limitsDefaults));
+const unsafeUnicode = /[\p{Cc}\p{Cf}\p{Cs}\u2028\u2029]/u;
+
+function ownDataRecord(value: unknown, allowed: ReadonlySet<string>): Record<string, unknown> | undefined {
+  try {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string" || !allowed.has(key))) return undefined;
+    const output = Object.create(null) as Record<string, unknown>;
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (!("value" in descriptor)) return undefined;
+      output[key] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function hasExactly(source: Record<string, unknown>, keys: ReadonlySet<string>): boolean {
+  const own = Object.keys(source);
+  return own.length === keys.size && own.every((key) => keys.has(key));
+}
+
+function safeInteger(value: unknown, maximum: number): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= maximum ? value : undefined;
+}
+
+function safeText(value: unknown, maximum: number, allowEmpty = false): string | undefined {
+  if (typeof value !== "string" || (!allowEmpty && value.length === 0) || unsafeUnicode.test(value)) return undefined;
+  if ([...value].length > maximum || new TextEncoder().encode(value).byteLength > maximum) return undefined;
+  return value;
+}
+
+function timestamp(value: unknown): string | undefined {
+  if (typeof value !== "string" || value.length > 64) return undefined;
+  const milliseconds = Date.parse(value);
+  if (!Number.isFinite(milliseconds)) return undefined;
+  try {
+    return new Date(milliseconds).toISOString() === value ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function ownDataArray(value: unknown, maximum: number): unknown[] | undefined {
+  try {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    const length: unknown = lengthDescriptor !== undefined && "value" in lengthDescriptor ? lengthDescriptor.value : undefined;
+    if (!Number.isSafeInteger(length) || (length as number) < 0 || (length as number) > maximum) return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (
+      Reflect.ownKeys(descriptors).some(
+        (key) => key !== "length" && (typeof key !== "string" || !/^\d+$/u.test(key) || Number(key) >= (length as number) || String(Number(key)) !== key),
+      ) ||
+      Object.values(descriptors).some((descriptor) => !("value" in descriptor))
+    )
+      return undefined;
+    const output: unknown[] = [];
+    for (let index = 0; index < (length as number); index += 1) {
+      const descriptor = descriptors[String(index)];
+      if (descriptor === undefined || !("value" in descriptor)) return undefined;
+      output.push(descriptor.value);
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function statusView(value: unknown): SqlLensPanelView["status"] | undefined {
+  const source = ownDataRecord(value, statusKeys);
+  if (source === undefined) return undefined;
+  if (source.state === "idle" && hasExactly(source, new Set(["state"]))) return { state: "idle", at: null, error: null };
+  if (source.state === "running" && hasExactly(source, new Set(["state"]))) return { state: "running", at: null, error: null };
+  const at = timestamp(source.at);
+  if (source.state === "completed" && at !== undefined && hasExactly(source, new Set(["state", "at"]))) return { state: "completed", at, error: null };
+  if ((source.state === "failed" || source.state === "cancelled") && at !== undefined && hasExactly(source, statusKeys)) {
+    const error = safeText(source.error, maxStatusError);
+    if (error !== undefined) return { state: source.state, at, error: [...error].slice(0, visibleStatusError).join("") };
+  }
+  return undefined;
+}
+
+function cellView(value: unknown): unknown {
+  if (value === null) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string") return safeText(value, maxDisplayString, true);
+  const source = ownDataRecord(value, cellKeys);
+  if (
+    source === undefined ||
+    !hasExactly(source, cellKeys) ||
+    source.type !== "blob" ||
+    typeof source.truncated !== "boolean" ||
+    typeof source.previewBase64 !== "string" ||
+    source.previewBase64.length > 344 ||
+    !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(source.previewBase64)
+  )
+    return undefined;
+  const bytes = safeInteger(source.bytes, Number.MAX_SAFE_INTEGER);
+  return bytes === undefined ? undefined : { type: "blob", bytes, previewBase64: source.previewBase64, truncated: source.truncated };
+}
+
+function latestView(value: unknown): SqlLensPanelView["latest"] | undefined {
+  const source = ownDataRecord(value, latestKeys);
+  if (source === undefined || !hasExactly(source, latestKeys)) return undefined;
+  const database = safeText(source.database, 4_096);
+  const query = safeText(source.query, limitsDefaults.queryLength);
+  const columnsRaw = ownDataArray(source.columns, limitsDefaults.columns);
+  const rowsRaw = ownDataArray(source.rows, limitsDefaults.panelRows);
+  const scannedRows = safeInteger(source.scannedRows, Number.MAX_SAFE_INTEGER);
+  const inventory = ownDataRecord(source.rowInventory, rowInventoryKeys);
+  if (
+    database === undefined ||
+    query === undefined ||
+    columnsRaw === undefined ||
+    rowsRaw === undefined ||
+    scannedRows === undefined ||
+    inventory === undefined ||
+    !hasExactly(inventory, rowInventoryKeys) ||
+    typeof source.truncated !== "boolean"
+  )
+    return undefined;
+  const columns: string[] = [];
+  for (const value of columnsRaw) {
+    const column = safeText(value, maxColumnName);
+    if (column === undefined) return undefined;
+    columns.push(column);
+  }
+  if (columns.length === 0 || new Set(columns).size !== columns.length) return undefined;
+  const scanned = safeInteger(inventory.scanned, Number.MAX_SAFE_INTEGER);
+  const returned = safeInteger(inventory.returned, limitsDefaults.panelRows);
+  const shown = safeInteger(inventory.shown, limitsDefaults.panelRows);
+  if (
+    scanned === undefined ||
+    returned === undefined ||
+    shown === undefined ||
+    scanned !== scannedRows ||
+    returned !== rowsRaw.length ||
+    shown !== returned ||
+    shown > scanned ||
+    inventory.displayLimit !== limitsDefaults.panelRows ||
+    typeof inventory.truncated !== "boolean"
+  )
+    return undefined;
+  const rows: Record<string, unknown>[] = [];
+  for (const rawRow of rowsRaw) {
+    const row = ownDataRecord(rawRow, new Set(columns));
+    if (row === undefined || Object.keys(row).length !== columns.length) return undefined;
+    const normalized: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (const column of columns) {
+      const cell = cellView(row[column]);
+      if (cell === undefined) return undefined;
+      normalized[column] = cell;
+    }
+    rows.push(normalized);
+  }
+  return {
+    database,
+    query,
+    columns: columns.slice(0, visibleColumns),
+    rows: rows.slice(0, visibleRows),
+    rowInventory: {
+      scanned,
+      returned,
+      shown: rows.length,
+      truncated: source.truncated || inventory.truncated || rows.length !== returned || columns.length > visibleColumns,
+      displayLimit: limitsDefaults.panelRows,
+    },
+  };
+}
+
+function validLimits(value: unknown): value is typeof limitsDefaults {
+  const source = ownDataRecord(value, limitKeys);
+  return source !== undefined && hasExactly(source, limitKeys) && Object.entries(limitsDefaults).every(([key, expected]) => source[key] === expected);
+}
+
+function malformedView(): SqlLensPanelView {
+  return {
+    status: { state: "unknown", at: null, error: null },
+    timeoutMs: defaults.timeoutMs,
+    latest: null,
+    malformed: true,
+    limits: { ...limitsDefaults },
+  };
+}
+
+export function sqlLensPanelView(data: unknown): SqlLensPanelView {
+  const source = ownDataRecord(data, rootKeys);
+  if (source === undefined || !hasExactly(source, rootKeys)) return malformedView();
+  const timeoutMs = safeInteger(source.timeoutMs, 30_000);
+  if (timeoutMs === undefined || timeoutMs < 100 || !validLimits(source.limits)) return malformedView();
+  const status = statusView(source.status);
+  if (status === undefined) return malformedView();
+  const latest = source.latest === null ? null : latestView(source.latest);
+  if (latest === undefined || (status.state === "idle" && latest !== null) || (status.state === "completed" && latest === null)) return malformedView();
+  return { status, timeoutMs, latest, malformed: false, limits: { ...limitsDefaults } };
+}

package/packages/client-web/src/test-harness-view.ts

@@ -0,0 +1,170 @@
+export type TestHarnessStatus = "passed" | "failed" | "timed-out" | "cancelled";
+
+export interface TestHarnessRunView {
+  readonly script: string;
+  readonly command: string;
+  readonly status: TestHarnessStatus;
+  readonly exitCode: number | null;
+  readonly signal: string | null;
+  readonly durationMs: number;
+  readonly output: string;
+  readonly outputBytes: number;
+  readonly outputTruncated: boolean;
+  readonly outputSanitized: boolean;
+}
+
+export interface TestHarnessPanelView {
+  readonly allowedScripts: readonly string[];
+  readonly latest: TestHarnessRunView | null;
+  readonly limits: { readonly timeoutMs: number; readonly outputBytes: number };
+  readonly truncated: boolean;
+}
+
+const allowedScripts = ["test", "build", "format:check", "lint", "typecheck"] as const;
+const outputBytes = 12 * 1024;
+const defaultTimeoutMs = 120_000;
+const minimumTimeoutMs = 100;
+const maximumTimeoutMs = 600_000;
+const maximumDurationMs = maximumTimeoutMs + 10_000;
+
+function ownDataRecord(value: unknown): Record<string, unknown> | undefined {
+  try {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string")) return undefined;
+    const output = Object.create(null) as Record<string, unknown>;
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (!("value" in descriptor)) return undefined;
+      output[key] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function hasExactKeys(value: Record<string, unknown>, expected: readonly string[]): boolean {
+  const keys = Object.keys(value);
+  const allowed = new Set(expected);
+  return keys.length === expected.length && keys.every((key) => allowed.has(key));
+}
+
+function safeInteger(value: unknown, minimum: number, maximum: number): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum && value <= maximum;
+}
+
+function exactAllowedScripts(value: unknown): boolean {
+  try {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return false;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Reflect.ownKeys(descriptors);
+    if (keys.length !== allowedScripts.length + 1 || keys.some((key) => typeof key !== "string")) return false;
+    const length = Object.getOwnPropertyDescriptor(value, "length");
+    if (length === undefined || !("value" in length) || length.value !== allowedScripts.length) return false;
+    return allowedScripts.every((script, index) => {
+      const descriptor = descriptors[String(index)];
+      return descriptor !== undefined && "value" in descriptor && descriptor.value === script;
+    });
+  } catch {
+    return false;
+  }
+}
+
+function replaceUnsafeControls(value: string): string {
+  let output = "";
+  for (const codePoint of value) {
+    const code = codePoint.codePointAt(0)!;
+    const safeCharacter = code === 9 || code === 10 || (code >= 32 && code !== 127 && (code < 128 || code > 159) && !/[\p{Cf}\p{Cs}]/u.test(codePoint));
+    output += safeCharacter ? codePoint : "�";
+  }
+  return output;
+}
+
+function boundedOutput(value: unknown): { value: string | undefined; altered: boolean } {
+  if (typeof value !== "string") return { value: undefined, altered: true };
+  const sample = value.slice(0, outputBytes * 2 + 1);
+  const sanitized = replaceUnsafeControls(sample.replaceAll(/\r\n?/gu, "\n"));
+  let bytes = 0;
+  let output = "";
+  for (const codePoint of sanitized) {
+    const size = new TextEncoder().encode(codePoint).byteLength;
+    if (bytes + size > outputBytes) break;
+    bytes += size;
+    output += codePoint;
+  }
+  return { value: output, altered: sample.length !== value.length || output !== value };
+}
+
+function signalValue(value: unknown): string | null | undefined {
+  if (value === null) return null;
+  return typeof value === "string" && /^SIG[A-Z0-9]{1,24}$/u.test(value) ? value : undefined;
+}
+
+function runView(value: unknown): { value: TestHarnessRunView | null; altered: boolean } {
+  if (value === null) return { value: null, altered: false };
+  const source = ownDataRecord(value);
+  if (
+    source === undefined ||
+    !hasExactKeys(source, ["script", "command", "status", "exitCode", "signal", "durationMs", "output", "outputBytes", "outputTruncated", "outputSanitized"])
+  )
+    return { value: null, altered: true };
+  const script = source.script;
+  const status = source.status;
+  const exitCode = source.exitCode;
+  const signal = signalValue(source.signal);
+  const output = boundedOutput(source.output);
+  if (
+    typeof script !== "string" ||
+    !allowedScripts.includes(script as (typeof allowedScripts)[number]) ||
+    source.command !== `npm run ${script}` ||
+    (status !== "passed" && status !== "failed" && status !== "timed-out" && status !== "cancelled") ||
+    !safeInteger(source.durationMs, 0, maximumDurationMs) ||
+    !safeInteger(source.outputBytes, 0, Number.MAX_SAFE_INTEGER) ||
+    typeof source.outputTruncated !== "boolean" ||
+    typeof source.outputSanitized !== "boolean" ||
+    signal === undefined ||
+    output.value === undefined
+  )
+    return { value: null, altered: true };
+  const validOutcome =
+    (status === "passed" && exitCode === 0 && signal === null) ||
+    (status === "failed" && (exitCode === null || (safeInteger(exitCode, 1, 255) && exitCode !== 0 && signal === null))) ||
+    ((status === "timed-out" || status === "cancelled") && exitCode === null);
+  const renderedBytes = new TextEncoder().encode(output.value).byteLength;
+  const validAccounting = source.outputTruncated
+    ? source.outputBytes >= outputBytes
+    : source.outputBytes <= outputBytes && (source.outputSanitized || source.outputBytes === renderedBytes);
+  if (!validOutcome || !validAccounting) return { value: null, altered: true };
+  return {
+    value: {
+      script,
+      command: source.command,
+      status,
+      exitCode,
+      signal,
+      durationMs: source.durationMs,
+      output: output.value,
+      outputBytes: source.outputBytes,
+      outputTruncated: source.outputTruncated,
+      outputSanitized: source.outputSanitized,
+    },
+    altered: output.altered,
+  };
+}
+
+export function testHarnessPanelView(data: unknown): TestHarnessPanelView {
+  const source = ownDataRecord(data);
+  const limitsSource = ownDataRecord(source?.limits);
+  const timeoutMs = safeInteger(limitsSource?.timeoutMs, minimumTimeoutMs, maximumTimeoutMs) ? limitsSource.timeoutMs : defaultTimeoutMs;
+  const limitsValid = limitsSource !== undefined && hasExactKeys(limitsSource, ["timeoutMs", "outputBytes"]) && limitsSource.outputBytes === outputBytes;
+  const scriptsValid = exactAllowedScripts(source?.allowedScripts);
+  const latest = runView(source?.latest);
+  return {
+    allowedScripts: [...allowedScripts],
+    latest: latest.value,
+    limits: { timeoutMs, outputBytes },
+    truncated: source === undefined || !hasExactKeys(source, ["allowedScripts", "latest", "limits"]) || !limitsValid || !scriptsValid || latest.altered,
+  };
+}

package/packages/client-web/src/token-guard-view.ts

@@ -0,0 +1,75 @@
+export interface TokenGuardPanelView {
+  readonly maxPercent: number;
+  readonly maxRunTokens: number;
+  readonly percent: number | null;
+  readonly tokens: number | null;
+  readonly contextWindow: number | null;
+  readonly runTokens: number | null;
+  readonly runExceeded: boolean;
+  readonly exceeded: boolean;
+  readonly aborts: number;
+  readonly lastError: string | null;
+  readonly limits: {
+    readonly maxRunTokens: number;
+    readonly errorCharacters: number;
+    readonly streamingUpdateInterval: number;
+  };
+}
+
+const defaults = {
+  maxPercent: 90,
+  maxRunTokens: 10_000_000,
+  errorCharacters: 2_000,
+  streamingUpdateInterval: 32,
+  maxCount: 4_294_967_295,
+} as const;
+
+function dataProperty(value: unknown, key: PropertyKey): unknown {
+  if (typeof value !== "object" || value === null) return undefined;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function count(value: unknown, maximum: number = defaults.maxCount): number | null {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= maximum ? value : null;
+}
+
+function boundedText(value: unknown): string | null {
+  if (typeof value !== "string" || value === "") return null;
+  return value.replaceAll("\0", "�").slice(0, defaults.errorCharacters);
+}
+
+export function tokenGuardPanelView(data: unknown): TokenGuardPanelView {
+  const rawMaxPercent = dataProperty(data, "maxPercent");
+  const maxPercent =
+    typeof rawMaxPercent === "number" && Number.isFinite(rawMaxPercent) && rawMaxPercent >= 1 && rawMaxPercent <= 100 ? rawMaxPercent : defaults.maxPercent;
+  const maxRunTokens = count(dataProperty(data, "maxRunTokens"), defaults.maxRunTokens) ?? 0;
+  const rawPercent = dataProperty(data, "percent");
+  const percent = typeof rawPercent === "number" && Number.isFinite(rawPercent) && rawPercent >= 0 ? rawPercent : null;
+  const tokens = count(dataProperty(data, "tokens"));
+  const contextWindowValue = count(dataProperty(data, "contextWindow"));
+  const contextWindow = contextWindowValue !== null && contextWindowValue > 0 ? contextWindowValue : null;
+  const runTokens = count(dataProperty(data, "runTokens"));
+  const runExceeded = maxRunTokens > 0 && runTokens !== null && runTokens >= maxRunTokens;
+  return {
+    maxPercent,
+    maxRunTokens,
+    percent,
+    tokens,
+    contextWindow,
+    runTokens,
+    runExceeded,
+    exceeded: (percent !== null && percent >= maxPercent) || runExceeded,
+    aborts: count(dataProperty(data, "aborts")) ?? 0,
+    lastError: boundedText(dataProperty(data, "lastError")),
+    limits: {
+      maxRunTokens: defaults.maxRunTokens,
+      errorCharacters: defaults.errorCharacters,
+      streamingUpdateInterval: defaults.streamingUpdateInterval,
+    },
+  };
+}

package/packages/client-web/src/turn-rewind-view.ts

@@ -0,0 +1,120 @@
+const defaults = {
+  candidates: 50,
+  displayCandidates: 8,
+  scannedEntries: 4_096,
+  contentParts: 1_000,
+  previewCharacters: 500,
+  entryIdCharacters: 200,
+  editorTextCharacters: 4_096,
+  errorCharacters: 2_000,
+} as const;
+
+function dataProperty(value: unknown, name: string): unknown {
+  if (value === null || typeof value !== "object") return undefined;
+  const descriptor = Object.getOwnPropertyDescriptor(value, name);
+  return descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+}
+
+function limit(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= fallback ? value : fallback;
+}
+
+function count(value: unknown, maximum: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= maximum ? value : 0;
+}
+
+function text(value: unknown, maximum: number, fallback = ""): string {
+  if (typeof value !== "string") return fallback;
+  return value.slice(0, maximum).replaceAll("\0", "�") || fallback;
+}
+
+function timestamp(value: unknown): string | null {
+  if (typeof value !== "string" || value.length > 64) return null;
+  try {
+    return new Date(value).toISOString() === value ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function candidate(value: unknown, limits: { entryIdCharacters: number; previewCharacters: number }) {
+  return {
+    entryId: text(dataProperty(value, "entryId"), limits.entryIdCharacters, "unknown"),
+    text: text(dataProperty(value, "text"), limits.previewCharacters, "未命名轮次"),
+  };
+}
+
+function listedCandidate(value: unknown, limits: { entryIdCharacters: number; previewCharacters: number }) {
+  const entryId = dataProperty(value, "entryId");
+  const candidateText = dataProperty(value, "text");
+  if (typeof entryId !== "string" || typeof candidateText !== "string") return undefined;
+  const normalized = {
+    entryId: text(entryId, limits.entryIdCharacters),
+    text: text(candidateText, limits.previewCharacters),
+  };
+  return normalized.entryId === "" || normalized.text === "" ? undefined : normalized;
+}
+
+type OperationStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+
+function operation(value: unknown, limits: { entryIdCharacters: number; previewCharacters: number; editorTextCharacters: number; errorCharacters: number }) {
+  const rawStatus = dataProperty(value, "status");
+  const status: OperationStatus | undefined =
+    rawStatus === "queued" || rawStatus === "running" || rawStatus === "completed" || rawStatus === "failed" || rawStatus === "cancelled"
+      ? rawStatus
+      : undefined;
+  if (status === undefined) return null;
+  return {
+    status,
+    target: candidate(dataProperty(value, "target"), limits),
+    cancelled: dataProperty(value, "cancelled") === true,
+    summarized: dataProperty(value, "summarized") === true,
+    editorText: text(dataProperty(value, "editorText"), limits.editorTextCharacters) || null,
+    error: status === "failed" || status === "cancelled" ? text(dataProperty(value, "error"), limits.errorCharacters) || null : null,
+    requestedAt: timestamp(dataProperty(value, "requestedAt")),
+    startedAt: timestamp(dataProperty(value, "startedAt")),
+    finishedAt: timestamp(dataProperty(value, "finishedAt")),
+  };
+}
+
+export function turnRewindPanelView(data: unknown) {
+  const rawLimits = dataProperty(data, "limits");
+  const limits = {
+    candidates: limit(dataProperty(rawLimits, "candidates"), defaults.candidates),
+    displayCandidates: defaults.displayCandidates,
+    scannedEntries: limit(dataProperty(rawLimits, "scannedEntries"), defaults.scannedEntries),
+    contentParts: limit(dataProperty(rawLimits, "contentParts"), defaults.contentParts),
+    previewCharacters: limit(dataProperty(rawLimits, "previewCharacters"), defaults.previewCharacters),
+    entryIdCharacters: limit(dataProperty(rawLimits, "entryIdCharacters"), defaults.entryIdCharacters),
+    editorTextCharacters: limit(dataProperty(rawLimits, "editorTextCharacters"), defaults.editorTextCharacters),
+    errorCharacters: limit(dataProperty(rawLimits, "errorCharacters"), defaults.errorCharacters),
+  };
+  const rawCandidates = dataProperty(data, "candidates");
+  const visibleCandidates: Array<{ entryId: string; text: string }> = [];
+  if (Array.isArray(rawCandidates)) {
+    const start = Math.max(0, rawCandidates.length - Math.min(limits.candidates, limits.displayCandidates));
+    for (let index = start; index < rawCandidates.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(rawCandidates, String(index));
+      if (descriptor === undefined || !("value" in descriptor)) continue;
+      const normalized = listedCandidate(descriptor.value, limits);
+      if (normalized !== undefined) visibleCandidates.push(normalized);
+    }
+  }
+  const rawInventory = dataProperty(data, "inventory");
+  const displayTruncated = Array.isArray(rawCandidates) && rawCandidates.length > visibleCandidates.length;
+  const scanTruncated = dataProperty(rawInventory, "scanTruncated") === true;
+  const candidateTruncated = dataProperty(rawInventory, "candidateTruncated") === true;
+  return {
+    candidates: visibleCandidates,
+    inventory: {
+      scannedEntries: count(dataProperty(rawInventory, "scannedEntries"), limits.scannedEntries),
+      shown: count(dataProperty(rawInventory, "shown"), limits.candidates),
+      truncated: dataProperty(rawInventory, "truncated") === true || scanTruncated || candidateTruncated || displayTruncated,
+      scanTruncated,
+      candidateTruncated,
+      displayTruncated,
+    },
+    latest: operation(dataProperty(data, "latest"), limits),
+    limits,
+  };
+}