reeval 0.0.1

package/dist/usage-DsYUqIUM.js

@@ -0,0 +1,24 @@
+//#region src/usage.ts
+/** Two counts as one; null only when neither reported any. */
+function addUsage(a, b) {
+	if (!a || !b) return a ?? b;
+	return {
+		input: a.input + b.input,
+		output: a.output + b.output,
+		cacheRead: a.cacheRead + b.cacheRead,
+		cacheWrite: a.cacheWrite + b.cacheWrite,
+		reasoning: a.reasoning === null && b.reasoning === null ? null : (a.reasoning ?? 0) + (b.reasoning ?? 0)
+	};
+}
+/** The total of every count that was reported; null when none was. */
+const sumUsage = (usages) => {
+	let total = null;
+	for (const u of usages) total = addUsage(total, u ?? null);
+	return total;
+};
+/** Every token the prompt side used: uncached input plus cache reads and writes. */
+const promptTokens = (u) => u.input + u.cacheRead + u.cacheWrite;
+//#endregion
+export { promptTokens as n, sumUsage as r, addUsage as t };
+
+//# sourceMappingURL=usage-DsYUqIUM.js.map

package/dist/usage-DsYUqIUM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-DsYUqIUM.js","names":[],"sources":["../src/usage.ts"],"mappings":";;AAGA,SAAgB,SAAS,GAAsB,GAAyC;CACtF,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO,KAAK;CAC1B,OAAO;EACL,OAAO,EAAE,QAAQ,EAAE;EACnB,QAAQ,EAAE,SAAS,EAAE;EACrB,WAAW,EAAE,YAAY,EAAE;EAC3B,YAAY,EAAE,aAAa,EAAE;EAC7B,WACE,EAAE,cAAc,QAAQ,EAAE,cAAc,OAAO,QAAQ,EAAE,aAAa,MAAM,EAAE,aAAa;CAC/F;AACF;;AAGA,MAAa,YAAY,WAAuE;CAC9F,IAAI,QAA2B;CAC/B,KAAK,MAAM,KAAK,QAAQ,QAAQ,SAAS,OAAO,KAAK,IAAI;CACzD,OAAO;AACT;;AAGA,MAAa,gBAAgB,MAAkB,EAAE,QAAQ,EAAE,YAAY,EAAE"}

package/dist/view/index.d.ts

@@ -0,0 +1,645 @@
+import { $ as SandboxWarning, At as contrastEffort, Ct as EffortSample, Dt as cellContrast, Et as VERDICT_TEXT, Ft as effortSummary, It as effortVerdict, K as Outcome, Lt as formatCount, Mt as effortLabel, Nt as effortOf, Ot as cellEffort, Pt as effortSample, Rt as formatRatio, St as EffortContrast, Tt as Spread, _t as JudgementRecord, at as TranscriptEvent, bt as CellEffort, ct as TurnStatus, dt as AttemptRecord, ft as CellRecord, gt as HistoryEntry, ht as HistoryCell, it as TokenUsage, jt as effortChangeLabel, kt as cellSamples, mt as FileRef, pt as EvalEntry, vt as RunRecord, wt as EffortVerdict, xt as EFFORT_ALPHA, yt as StackSummary, zt as formatSeconds } from "../types-DLec-6Cx.js";
+//#region src/view/analysis.d.ts
+/** Bumped when the system prompt or output schema changes: an older analysis is superseded. */
+export declare const ANALYSIS_PROMPT_VERSION = "analysis-v2";
+/** Bumped when the digest's shape or selection rules change. */
+export declare const DIGEST_VERSION = 1;
+export type Confidence = 'high' | 'medium' | 'low';
+export type AnalysisClaim = {
+  text: string;
+  /** Fact (`F3`), evidence (`E2`, `E2:L39`), attempt (`r2/scaffold/reeval-good#1`) or check ids. */
+  cites: string[];
+  confidence: Confidence;
+  /** Exact spans from the cited evidence; a claim whose quote isn't there is dropped. */
+  quotes?: string[];
+  /** Numbers in the text that no cited fact or evidence contains. */
+  unverifiedNumbers?: string[];
+};
+export type AnomalyKind = 'es-bug' | 'eval-design' | 'judge' | 'noise' | 'other';
+export type AnalysisAnomaly = {
+  text: string;
+  kind: AnomalyKind;
+  cites: string[];
+};
+export type ActionKind = 'skill' | 'docs' | 'eval' | 'judge' | 'es' | 'harness';
+export type Level = 'high' | 'medium' | 'low';
+export type AnalysisAction = {
+  title: string;
+  target: string;
+  kind: ActionKind;
+  change: string;
+  expectedEffect: string;
+  /** An `reeval` command that shows the effect; null when the model's didn't parse as reeval's CLI. */
+  verify: string | null;
+  /** Why the model's verify command was rejected. */
+  verifyProblem?: string;
+  impact: Level;
+  effort: Level;
+  cites: string[];
+};
+export type AnalysisBody = {
+  tldr: string;
+  whatHappened: AnalysisClaim[];
+  results: AnalysisClaim[];
+  why: AnalysisClaim[];
+  anomalies: AnalysisAnomaly[];
+  actions: AnalysisAction[];
+  confidence: {
+    overall: Confidence;
+    why: string;
+  };
+};
+export type AnalysisValidation = {
+  /** Citations checked, and those that named nothing in the digest. */
+  citations: number;
+  invalid: string[];
+  /** Claims, anomalies and actions dropped for having no valid citation or an invented quote. */
+  dropped: number;
+  commands: number;
+  invalidCommands: string[];
+  unverifiedNumbers: number;
+};
+export type AnalysisScope = {
+  kind: 'run';
+  head: string;
+  /** Resolved once, so a nearer ancestor recorded later doesn't change what this analysed. */
+  base: string | null;
+  /** An eval filter (substring of the eval id), or null for every eval. */
+  evals: string | null;
+};
+export type AnalysisDoc = {
+  kind: 'es-analysis';
+  schemaVersion: 1;
+  scope: AnalysisScope;
+  /** The run the analysis belongs to: the scope's head. */
+  anchor: string;
+  inputs: {
+    records: Array<{
+      runId: string;
+      sha256: string;
+    }>;
+    digestVersion: number;
+    digestHash: string;
+  };
+  promptVersion: string;
+  model: string;
+  resolvedModel: string | null;
+  route: 'direct' | 'gateway' | 'fake';
+  usage: {
+    inputTokens: number | null;
+    outputTokens: number | null;
+  };
+  latencyMs: number;
+  createdAt: string;
+  author: string;
+  validation: AnalysisValidation;
+  analysis: AnalysisBody;
+  /** Short attempt ids used in citations, and where each attempt is. */
+  attempts: Record<string, {
+    runId: string;
+    evalSlug: string;
+    attempt: string;
+  }>;
+  /** Each cited fact or evidence id, summarised in one line. */
+  cited: Record<string, string>;
+};
+/** One analysis file the studio can show: saved in the run's folder, or in the local cache. */
+export type AnalysisEntry = {
+  file: string;
+  source: 'saved' | 'cached';
+  doc: AnalysisDoc;
+};
+export type AnalysisIndex = {
+  runId: string;
+  entries: AnalysisEntry[];
+};
+export declare const analysisDataPath: (runId: string) => string;
+/** Newest first, saved before cached at the same time. */
+export declare function sortAnalyses(entries: AnalysisEntry[]): AnalysisEntry[];
+/** Superseded by a newer prompt or digest version: the studio says so. */
+export declare const isSuperseded: (doc: AnalysisDoc) => boolean;
+//#endregion
+//#region src/view/compare.d.ts
+export type CompareStatus = 'regressed' | 'fixed' | 'same' | 'drift' | 'added' | 'removed' | 'infra';
+export type CompareRow = {
+  id: string;
+  status: CompareStatus;
+  base: Outcome | null;
+  head: Outcome | null;
+  /** For `drift`: what changed, e.g. `evals/helpers.ts changed` or `harness config changed`. */
+  changes?: string[];
+  /**
+   * When the runs ran different cells of the eval: the cells only head or only base has. Then
+   * `status`, `base` and `head` are over the cells both have.
+   */
+  cells?: {
+    added: string[];
+    removed: string[];
+  };
+  /** Cells in both runs, with each side's lift (variants) and effort. */
+  perCell?: CompareCell[];
+};
+export type CompareCell = {
+  key: string;
+  base: Pick<HistoryCell, 'lift' | 'effort' | 'pass' | 'fail'>;
+  head: Pick<HistoryCell, 'lift' | 'effort' | 'pass' | 'fail'>;
+};
+export type StackChange = {
+  field: keyof StackSummary;
+  label: string;
+  base: string;
+  head: string;
+  /** Not covered by eval fingerprints, so outcome flips across it are drift, not regressions. */
+  outsideFingerprint: boolean;
+};
+type StackCell = Pick<HistoryCell, 'key' | 'harness' | 'environment' | 'environmentDigest' | 'fingerprint' | 'fingerprintParts'>;
+/** A run's stack, and its cells when known: the per-cell fields then compare over shared cells. */
+export type StackSource = Pick<HistoryEntry, 'stack'> & {
+  evals?: ReadonlyArray<{
+    id: string;
+    cells: readonly StackCell[];
+  }>;
+};
+/**
+ * What changed in the stack between two runs. With both runs' cells, images, agent CLIs,
+ * harnesses and environments compare over the cells both have, so a run over fewer cells isn't
+ * drift. Reported served-judge lists only compare when both have one.
+ */
+export declare function stackChanges(base: StackSource, head: StackSource): StackChange[];
+/**
+ * Whether any of these cells changed fingerprint since `seen` last had it, then records them.
+ * A cell `seen` doesn't have yet is new coverage, not a change.
+ */
+export declare function cellsChanged(seen: Map<string, string>, evalId: string, cells: ReadonlyArray<Pick<HistoryCell, 'key' | 'fingerprint'>>): boolean;
+type ComparableEval = Pick<HistoryEntry['evals'][number], 'id' | 'fingerprint' | 'outcome' | 'sources' | 'cells'>;
+type Comparable = Pick<HistoryEntry, 'stack'> & {
+  evals: ComparableEval[];
+};
+/** Which source files were added, removed or changed. */
+export declare function sourceChanges(before: ComparableEval['sources'], after: ComparableEval['sources']): string[];
+/** Why two runs of an eval aren't comparable: the source files and fingerprint parts that differ. */
+export declare function whyChanged(base: ComparableEval, head: ComparableEval): string[];
+export declare function compare(base: Comparable, head: Comparable): CompareRow[];
+//#endregion
+//#region src/view/debug.d.ts
+/**
+ * An attempt's local debug data, as `reeval run` writes it to `.reeval/debug/<runId>/<eval>/<cell>/<n>/`
+ * and `reeval studio` serves it. Browser-safe. Never part of a record or the history folder.
+ *
+ *   debug.log        the `-v` trace, one line per event, always written
+ *   requests.ndjson  one line per egress gateway request, always written
+ *   trace.ndjson     raw payloads (`-vv`), written when the attempt fails or with `--trace`
+ */
+export declare const DEBUG_LOG = "debug.log";
+export declare const REQUESTS_FILE = "requests.ndjson";
+export declare const TRACE_FILE = "trace.ndjson";
+/** What part of the attempt a line is about, in the order an attempt goes through them. */
+export declare const DEBUG_PHASES: readonly ['plan', 'image', 'container', 'env', 'broker', 'harness', 'check', 'judge', 'gateway', 'teardown', 'docker'];
+export type DebugPhase = (typeof DEBUG_PHASES)[number];
+/** One debug line: level 1 is `-v`, level 2 is `-vv` only. */
+export type DebugLine = {
+  at: number;
+  level: 1 | 2;
+  phase: DebugPhase;
+  text: string;
+  /** More lines under it, e.g. a docker command's output or a raw payload. */
+  detail?: string;
+};
+/** One raw trace entry: `ms` is since the attempt started. */
+export type TraceEntry = {
+  at: string;
+  ms: number;
+  phase: DebugPhase;
+  kind: string;
+  data: unknown;
+};
+/** One request through the egress gateway, or one tunnel it passed through without reading. */
+export type DebugRequest = {
+  at: string;
+  method: string;
+  url: string;
+  host: string;
+  port: number;
+  via: 'tunnel' | 'decrypted' | 'http';
+  allowed: boolean;
+  status?: number;
+  reason?: string;
+  sent: number;
+  received: number;
+  /** Brokered secrets and the harness credential swapped in, by name. */
+  substituted: string[];
+  ms: number;
+};
+/** What the studio's Debug tab shows for one attempt. */
+export type DebugView = {
+  lines: Array<{
+    at: string;
+    phase: string;
+    text: string;
+  }>;
+  requests: DebugRequest[];
+  /** Whether `trace.ndjson` was kept. */
+  trace: boolean;
+};
+/**
+ * The studio server's debug API (`reeval studio` only): an attempt's DebugView (null when it has no
+ * local data), and its raw trace.
+ */
+export declare const debugApiPath: (runId: string, attemptKey: string) => string;
+export declare const traceApiPath: (runId: string, attemptKey: string) => string;
+/** `12:50:01`, or `12:50:01.234` with milliseconds, in UTC like every reeval timestamp. */
+export declare const debugTime: (at: number, ms: boolean) => string;
+/** A line of debug.log: `2026-09-26T12:50:01.234Z plan      text`. */
+export declare const debugLogLine: (line: Pick<DebugLine, 'at' | 'phase' | 'text'>) => string;
+/** debug.log's lines; a line that isn't one (a wrapped message) continues the one before. */
+export declare function parseDebugLog(text: string): DebugView['lines'];
+export declare function parseNdjson<T>(text: string): T[];
+/** `512 B`, `1.2 KB`, `3.4 MB`. */
+export declare function formatBytes(n: number): string;
+/**
+ * The gateway line for a request: method, URL, status, allowed or blocked and why, bytes each way,
+ * time, and which secrets were swapped in (by name).
+ */
+export declare function requestLine(r: Omit<DebugRequest, 'at'>): string;
+//#endregion
+//#region src/view/header.d.ts
+/** The derived header of one run: what listings, indexes and comparisons need without the record. */
+export declare function runHeader(record: RunRecord, recorded: boolean): HistoryEntry;
+//#endregion
+//#region src/view/live.d.ts
+/** The progress file's name inside the run's staging directory. */
+export declare const LIVE_FILE = "live.json";
+export declare const LIVE_SCHEMA_VERSION = 1;
+/** Where an attempt is: waiting, running, or finished with its outcome. */
+export type LiveStatus = 'queued' | 'running' | 'pass' | 'fail' | 'infra_error' | 'skipped';
+export type LiveAttempt = {
+  /** The attempt key, `<eval id> # <cell key>#<n>`, as in the record. */
+  key: string;
+  evalId: string;
+  name: string;
+  file: string;
+  /** The cell key, e.g. `fake/default/fake`. */
+  cell: string;
+  n: number;
+  status: LiveStatus;
+  startedAt: string | null;
+  durationMs: number | null;
+};
+/** Attempts finished, and of those how many passed, failed or errored; and how many are running. */
+export type LiveCounts = {
+  done: number;
+  passed: number;
+  failed: number;
+  errored: number;
+  skipped: number;
+  running: number;
+};
+/** What the run is doing: running attempts, cancelling them, or assembling its record. */
+export type LivePhase = 'running' | 'cancelling' | 'finishing';
+export type LiveProgress = {
+  schemaVersion: 1;
+  runId: string;
+  startedAt: string;
+  /** The `reeval run` process and the host it runs on, so a killed run can be told apart. */
+  pid: number;
+  host: string;
+  /** Rewritten every few seconds while the run is alive. */
+  heartbeatAt: string;
+  phase: LivePhase;
+  planned: number;
+  counts: LiveCounts;
+  attempts: LiveAttempt[];
+};
+/** A live run as the studio lists it: `stopped` when its process is gone or went quiet. */
+export type LiveRun = Omit<LiveProgress, 'schemaVersion' | 'pid' | 'host' | 'heartbeatAt'> & {
+  state: LivePhase | 'stopped';
+};
+export type LiveIndex = {
+  runs: LiveRun[];
+};
+export declare const liveApiPath = "api/live";
+export declare const liveTranscriptPath: (runId: string, attemptKey: string) => string;
+export declare const FINISHED: readonly LiveStatus[];
+export declare const isFinished: (status: LiveStatus) => boolean;
+export declare function liveCounts(attempts: readonly Pick<LiveAttempt, 'status'>[]): LiveCounts;
+/**
+ * A progress file as the studio reads it, or null when it isn't one it can read: half-written,
+ * corrupt, or from a newer reeval. Counts are recomputed from the attempts, never trusted.
+ */
+export declare function readableLiveProgress(value: unknown): LiveProgress | null;
+//#endregion
+//#region src/view/model.d.ts
+export type EvalCatalogEntry = {
+  slug: string;
+  id: string;
+  file: string;
+  /** Group names, then the eval name. */
+  path: string[];
+  runs: number;
+  latest: {
+    runId: string;
+    outcome: Outcome;
+  };
+};
+export type IndexManifest = {
+  generatedAt: string;
+  /** Newest first. */
+  shards: Array<{
+    id: string;
+    runs: number;
+  }>;
+  latest: string | null;
+  evals: EvalCatalogEntry[];
+};
+export type StudioInfo = {
+  mode: 'live' | 'static';
+  es: string;
+  project: string;
+  generatedAt: string;
+  /** `debug`: local debug data (`.reeval/debug`) can be read; never in a static build. */
+  features: {
+    live: boolean;
+    scratch: boolean;
+    artifacts: boolean;
+    debug: boolean;
+  };
+};
+/** Splits `file › group › … › name` back into its parts. */
+export declare function splitEvalId(id: string): {
+  file: string;
+  path: string[];
+};
+/** Month shards (newest run first) and the manifest over them, from every run's header. */
+export declare function buildIndex(entries: HistoryEntry[], generatedAt?: string): {
+  manifest: IndexManifest;
+  shards: Map<string, HistoryEntry[]>;
+};
+/** Every file the index consists of, by relative path. */
+export declare function indexFiles(entries: HistoryEntry[], generatedAt?: string): Map<string, unknown>;
+export declare function formatDuration(ms: number | null | undefined): string;
+export declare const formatPercent: (rate: number | null) => string;
+/**
+ * A harness of the run's stack as `cursor (model composer-2.5, served composer-2.5[fast=true])`:
+ * the configured model, then the variant the harness says it resolved.
+ */
+export declare function harnessLabel(h: RunRecord['stack']['harnesses'][number]): string;
+/** Harness-reported tokens as `127k in (98k cached) · 776 out`; null when none were reported. */
+export declare function formatUsage(usage: TokenUsage | null | undefined): string | null;
+export declare const shortSha: (sha: string | null | undefined) => string;
+/**
+ * An attempt's effort, counted as the CLI's turn lines count it: tool calls, then file edits.
+ * Edit calls become one file edit per file they change, so they're counted apart, never summed.
+ */
+export declare function activityLabel(a: Pick<AttemptRecord['activity'], 'tools' | 'fileEdits'>): string;
+/**
+ * A run's outcome, as `reeval run`'s exit code has it: a failed gated cell (or a budget stop) fails
+ * the run, while failures in ungated cells (controls, by default) don't.
+ */
+export declare function runOutcome(run: {
+  status: RunRecord['status'];
+  evals: ReadonlyArray<{
+    outcome: Outcome;
+  }>;
+}): Outcome;
+export type RunRow = {
+  entry: HistoryEntry;
+  passed: number;
+  /** Attempts that reached a verdict or errored; skips excluded. */
+  total: number;
+  /** Stack changes in the cells it shares with earlier runs, and in the judge since the previous complete run. */
+  drift: StackChange[];
+  /** Evals with a cell whose fingerprint changed since the last run that had that cell. */
+  changedEvals: number;
+};
+/**
+ * Newest first. Drift is measured per cell, against the last run that had it: a run over fewer
+ * cells (a filtered run) is no drift, and neither is the full run after it. The judge's settings
+ * compare with the next older complete run.
+ */
+export declare function runRows(entries: HistoryEntry[]): RunRow[];
+/** Attempt counts; `missed` is ungated cells' failures, which `fail` leaves out. */
+export type Tally = {
+  pass: number;
+  fail: number;
+  missed: number;
+  infra: number;
+  skipped: number;
+};
+export type TreeNode = {
+  kind: 'group';
+  key: string;
+  name: string;
+  tally: Tally;
+  children: TreeNode[];
+} | {
+  kind: 'eval';
+  key: string;
+  name: string;
+  tally: Tally;
+  eval: EvalEntry;
+};
+/** Files, then groups, then evals, each with attempt counts; failing branches sort first. */
+export declare function evalTree(record: Pick<RunRecord, 'evals'>): TreeNode[];
+export type CellRow = {
+  key: string;
+  harness: string;
+  environment: string;
+  sandbox: string;
+  role: CellRecord['role'];
+  /** Whether the cell's failures fail the eval: its gate isn't `'none'`. */
+  gated: boolean;
+  gate: CellRecord['gate'];
+  overrides: string[];
+  runs: number;
+  pass: number;
+  fail: number;
+  infraError: number;
+  skipped: number;
+  passRate: number | null;
+  outcome: Outcome;
+  /** A variant's lift over its control, in whole points (from the record), else null. */
+  lift: number | null;
+  /** Its 95% interval in whole points, and whether that spans 0. */
+  liftInterval: {
+    lo: number;
+    hi: number;
+    withinNoise: boolean;
+  } | null;
+  /** The interval's lower bound is below the compare's `minLift`. */
+  belowMinLift: boolean;
+  /** Median tool calls and agent time over the cell's counted attempts. */
+  effort: CellEffort | null;
+  /** A variant's effort against its control, with the rank test's verdict. */
+  effortVsControl: EffortContrast | null;
+  attempts: AttemptRecord[];
+};
+/** One row per cell: controls and variants, with each variant's recorded lift. */
+export declare function cellRows(e: EvalEntry): CellRow[];
+/** Whether an eval needs the cells table: several cells, or several runs of one. */
+export declare const isMatrix: (e: Pick<EvalEntry, 'cells'>) => boolean;
+export type EvalHistoryPoint = {
+  run: HistoryEntry;
+  outcome: Outcome;
+  passRate: number | null;
+  cells: HistoryCell[];
+  /** A cell's fingerprint differs from the last run that had that cell. */
+  changed: boolean;
+};
+/** One eval across runs, oldest first. */
+export declare function evalHistory(entries: HistoryEntry[], slug: string): EvalHistoryPoint[];
+export type CompareViewRow = {
+  id: string;
+  slug: string | null;
+  status: CompareStatus;
+  base: Outcome | null;
+  head: Outcome | null;
+  basePassRate: number | null;
+  headPassRate: number | null;
+  /** See `CompareRow`: then the pass rates are over the cells both runs have too. */
+  cells?: CompareRow['cells'];
+  changes?: string[];
+  /** Mean judge score per run; null without judgements or without the record. */
+  baseScore: number | null;
+  headScore: number | null;
+  /** Cells in both runs, with lift and effort on each side. */
+  perCell: CompareCell[];
+};
+export declare const COMPARE_ORDER: CompareStatus[];
+/**
+ * Whether some of an eval's cells aren't gated (`gate: 'none'`, e.g. controls under
+ * `compare.gate: 'variants'`). Its pass rate then covers fewer attempts than its pass count, so
+ * the eval line labels the rate `gated`: `2/4 · 100% gated`.
+ */
+export declare const hasUngatedCells: (cells: readonly Pick<HistoryCell, 'gate'>[]) => boolean;
+/**
+ * An expected miss: a failed attempt in an ungated cell (a control, by default). It's reported
+ * apart from failures, since it fails neither its eval nor the run.
+ */
+export declare const isUngatedMiss: (e: {
+  cells: readonly Pick<HistoryCell, 'key' | 'gate'>[];
+}, a: Pick<AttemptRecord, 'cell' | 'outcome' | 'error'>) => boolean;
+/** `reeval compare`'s classification, plus pass rates and judge-score deltas from the records. */
+export declare function compareView(base: HistoryEntry, head: HistoryEntry, records?: {
+  base?: RunRecord;
+  head?: RunRecord;
+}): {
+  rows: CompareViewRow[];
+  counts: Record<CompareStatus, number>;
+  changes: StackChange[];
+};
+export type TranscriptLine = ({
+  turn: number;
+} & TranscriptEvent) | {
+  turn: number;
+  ts: string;
+  atMs: number;
+  type: 'prompt';
+  text: string;
+} | {
+  turn: number;
+  ts: string;
+  atMs: number;
+  type: 'turn-end';
+  status: TurnStatus;
+  durationMs: number;
+};
+export type TranscriptItem = {
+  kind: 'turn';
+  turn: number;
+  prompt: string;
+  ts: string;
+} | {
+  kind: 'event';
+  turn: number;
+  event: TranscriptLine;
+} | {
+  kind: 'turn-end';
+  turn: number;
+  status: TurnStatus;
+  durationMs: number;
+};
+/** Parses `transcript.jsonl`, skipping lines that aren't JSON (a truncated tail, say). */
+export declare function parseTranscript(text: string): TranscriptLine[];
+export declare function transcriptItems(lines: TranscriptLine[]): TranscriptItem[];
+export type PatchFile = {
+  path: string;
+  status: 'added' | 'deleted' | 'modified' | 'renamed' | 'binary';
+  added: number;
+  removed: number;
+  text: string;
+};
+/** Splits a git patch into one entry per file, with line counts. */
+export declare function splitPatch(patch: string): PatchFile[];
+export declare const findEval: (record: Pick<RunRecord, 'evals'>, slug: string) => EvalEntry | undefined;
+export declare const findAttempt: (e: EvalEntry, attemptId: string) => AttemptRecord | undefined;
+/** The attempt to open by default: the first failure, else the first attempt. */
+export declare const defaultAttempt: (e: EvalEntry) => AttemptRecord | undefined;
+//#endregion
+//#region src/view/paths.d.ts
+/**
+ * The studio's data API is a file layout: `reeval studio` serves these relative paths and
+ * `reeval studio build` writes them to disk, so the web client reads both the same way.
+ *
+ *   studio.json                         mode, project and features
+ *   data/index/manifest.json            shard list and eval catalog
+ *   data/index/<YYYY-MM>.json           run headers started that UTC month, newest first
+ *   data/runs/<runId>.json              the record, byte for byte
+ *   data/runs/<runId>/<artifact path>   artifacts, raw
+ *   data/analysis/<runId>.json          the run's saved analyses (and, live, cached ones)
+ */
+export declare const RUN_ID: RegExp;
+export declare const studioPath = "studio.json";
+export declare const manifestPath = "data/index/manifest.json";
+export declare const shardPath: (id: string) => string;
+export declare const recordPath: (runId: string) => string;
+export declare const artifactPath: (runId: string, path: string) => string;
+/** A shard id: the UTC month a run started in. */
+export declare const shardOf: (startedAt: string) => string;
+export type DataTarget = {
+  kind: 'studio';
+} | {
+  kind: 'manifest';
+} | {
+  kind: 'shard';
+  id: string;
+} | {
+  kind: 'record';
+  runId: string;
+} | {
+  kind: 'analysis';
+  runId: string;
+} | {
+  kind: 'artifact';
+  runId: string;
+  segments: string[];
+};
+/**
+ * Maps a request path (relative, without a leading slash, already percent-decoded once) to what
+ * it names, or null. Every segment must match an allowlist, so `.`, `..`, empty segments,
+ * backslashes and NUL never get through.
+ */
+export declare function parseDataPath(path: string): DataTarget | null;
+/** Artifacts are untrusted agent output: JSON stays JSON, everything else is plain text. */
+export declare const artifactType: (name: string) => string;
+//#endregion
+//#region src/view/record.d.ts
+/** A file from a newer reeval, whose schemaVersion this reeval doesn't know. */
+export declare class NewerSchemaError extends Error {
+  name: string;
+  /** The message without its subject: `written by a newer reeval (…). Upgrade reeval to read it.` */
+  readonly reason: string;
+  constructor(what: string, version: number, newest: number);
+}
+/**
+ * A record as every reader sees it: migrated to this reeval's schemaVersion, with each field added
+ * after it was written read as its default, so older runs keep loading in `reeval show`, `reeval query`,
+ * compare, history and the studio. A record from a newer reeval throws a `NewerSchemaError`.
+ */
+export declare function readableRecord(record: RunRecord, what?: string): RunRecord;
+/** A transcript line as every reader sees it. */
+export declare const readableTranscriptLine: (line: TranscriptLine) => TranscriptLine;
+/** An analysis document as every reader sees it; one from a newer reeval throws. */
+export declare const readableAnalysis: (doc: AnalysisDoc, what?: string) => AnalysisDoc;
+//#endregion
+export { type AttemptRecord, CellEffort, type CellRecord, EFFORT_ALPHA, EffortContrast, EffortSample, EffortVerdict, type EvalEntry, type FileRef, type HistoryCell, type HistoryEntry, type JudgementRecord, type Outcome, type RunRecord, type SandboxWarning, Spread, type StackSummary, type TranscriptEvent, VERDICT_TEXT, cellContrast, cellEffort, cellSamples, contrastEffort, effortChangeLabel, effortLabel, effortOf, effortSample, effortSummary, effortVerdict, formatCount, formatRatio, formatSeconds };
+//# sourceMappingURL=index.d.ts.map

package/dist/view/index.js

@@ -0,0 +1,8 @@
+import { a as parseDataPath, c as shardPath, i as manifestPath, l as studioPath, n as artifactPath, o as recordPath, r as artifactType, s as shardOf, t as RUN_ID } from "../paths-CBvm6pap.js";
+import { a as debugApiPath, c as formatBytes, d as requestLine, f as traceApiPath, i as TRACE_FILE, l as parseDebugLog, n as DEBUG_PHASES, o as debugLogLine, r as REQUESTS_FILE, s as debugTime, t as DEBUG_LOG, u as parseNdjson } from "../debug-D24NOQH1.js";
+import { a as sortAnalyses, i as isSuperseded, n as DIGEST_VERSION, r as analysisDataPath, t as ANALYSIS_PROMPT_VERSION } from "../analysis-CxSCt1YY.js";
+import { A as cellSamples, B as formatSeconds, C as splitEvalId, D as VERDICT_TEXT, E as EFFORT_ALPHA, F as effortSample, G as whyChanged, H as compare, I as effortSummary, L as effortVerdict, M as effortChangeLabel, N as effortLabel, O as cellContrast, P as effortOf, R as formatCount, S as shortSha, T as transcriptItems, U as sourceChanges, V as cellsChanged, W as stackChanges, _ as isMatrix, a as compareView, b as runOutcome, c as evalTree, d as formatDuration, f as formatPercent, g as indexFiles, h as hasUngatedCells, i as cellRows, j as contrastEffort, k as cellEffort, l as findAttempt, m as harnessLabel, n as activityLabel, o as defaultAttempt, p as formatUsage, r as buildIndex, s as evalHistory, t as COMPARE_ORDER, u as findEval, v as isUngatedMiss, w as splitPatch, x as runRows, y as parseTranscript, z as formatRatio } from "../model-CDL98xue.js";
+import { t as runHeader } from "../header-DzFDoMCI.js";
+import { o as readableRecord, r as readableAnalysis, s as readableTranscriptLine, t as NewerSchemaError } from "../record-DQ8wzyco.js";
+import { a as liveApiPath, c as readableLiveProgress, i as isFinished, n as LIVE_FILE, o as liveCounts, r as LIVE_SCHEMA_VERSION, s as liveTranscriptPath, t as FINISHED } from "../live-Bs3LReMV.js";
+export { ANALYSIS_PROMPT_VERSION, COMPARE_ORDER, DEBUG_LOG, DEBUG_PHASES, DIGEST_VERSION, EFFORT_ALPHA, FINISHED, LIVE_FILE, LIVE_SCHEMA_VERSION, NewerSchemaError, REQUESTS_FILE, RUN_ID, TRACE_FILE, VERDICT_TEXT, activityLabel, analysisDataPath, artifactPath, artifactType, buildIndex, cellContrast, cellEffort, cellRows, cellSamples, cellsChanged, compare, compareView, contrastEffort, debugApiPath, debugLogLine, debugTime, defaultAttempt, effortChangeLabel, effortLabel, effortOf, effortSample, effortSummary, effortVerdict, evalHistory, evalTree, findAttempt, findEval, formatBytes, formatCount, formatDuration, formatPercent, formatRatio, formatSeconds, formatUsage, harnessLabel, hasUngatedCells, indexFiles, isFinished, isMatrix, isSuperseded, isUngatedMiss, liveApiPath, liveCounts, liveTranscriptPath, manifestPath, parseDataPath, parseDebugLog, parseNdjson, parseTranscript, readableAnalysis, readableLiveProgress, readableRecord, readableTranscriptLine, recordPath, requestLine, runHeader, runOutcome, runRows, shardOf, shardPath, shortSha, sortAnalyses, sourceChanges, splitEvalId, splitPatch, stackChanges, studioPath, traceApiPath, transcriptItems, whyChanged };