@tangle-network/agent-eval 0.135.4 → 0.137.0

package/dist/index-BipJlj-C.d.ts

@@ -0,0 +1,316 @@
+import { b as RolloutSplit } from "./schema-Cef2cFmb.js";
+import { _ as SupervisorRunReport, b as SupervisorRunTree, g as SupervisorRunReader, h as SupervisorRunNodeRole, s as PatchStats, v as SupervisorRunRollup, y as SupervisorRunSources } from "./types-Dea6tiVI.js";
+//#region src/supervisor-run/source-facts.d.ts
+interface Tokens {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  /** False when the event carried no cache counters at all — not "zero cached". */
+  hasCache: boolean;
+}
+interface SpendLike {
+  tokens: Tokens;
+  usd: number;
+}
+interface SpawnRow {
+  /** Zero-based row among parsed journal objects. */
+  sourceRow: number;
+  id: string;
+  parent: string | null;
+  label: string;
+  role: SupervisorRunNodeRole;
+  at: number | null;
+  /** False when identity, parentage, label, or role was malformed. */
+  valid: boolean;
+  invalidFields: readonly string[];
+}
+interface CloseRow {
+  id: string;
+  kind: 'settled' | 'cancelled';
+  status: string | null;
+  /** String verdict from legacy journals, or valid/invalid for a structured verdict. */
+  verdict: string | null;
+  /** Structured verdict validity, when recorded. */
+  valid: boolean | null;
+  /** Structured verdict score, preserved without boolean coercion. */
+  score: number | null;
+  /** The verdict exactly as the journal carried it. */
+  rawVerdict: unknown | null;
+  at: number | null;
+  spend: SpendLike;
+  /** False when the close event carried no spend object — not "spent nothing". */
+  hasSpend: boolean;
+}
+interface WorkerLogFacts {
+  /** Position in `SupervisorRunSources.workers`, retained for exact evidence paths. */
+  sourceIndex: number;
+  workerId: string | null;
+  label: string;
+  /** `false` means the artifact was missing; a captured empty artifact is `true`. */
+  inboxCaptured: boolean;
+  eventsCaptured: boolean;
+  inboxInvalidRows: number;
+  eventsInvalidRows: number;
+  started: number | null;
+  /** True once a `finished` event was seen — independent of whether its `at` parsed. */
+  finished: boolean;
+  finishedAt: number | null;
+  passed: boolean | null;
+  /** Numeric score exactly as the finished event recorded it. */
+  score: number | null;
+  /** `patchBytes` as reported by the finished event (not the patch file's size). */
+  finishedPatchBytes: number | null;
+  evidenceBytes: number;
+  /** Unique queued request ids, or null when exact accounting is unavailable. */
+  steersQueued: number | null;
+  /** Unique matched request ids acknowledged as delivered, or null when unavailable. */
+  steersDelivered: number | null;
+  steersQueuedUnavailable: string | null;
+  steersDeliveredUnavailable: string | null;
+  questions: number;
+  steerRequests: SteerRequestFact[];
+  steerAcknowledgements: SteerAcknowledgementFact[];
+}
+interface SteerRequestFact {
+  /** Durable inbox request id; null when the row did not retain one. */
+  requestId: string | null;
+  row: number;
+}
+interface SteerAcknowledgementFact {
+  /** Worker event request id; null when the event cannot be correlated. */
+  requestId: string | null;
+  /** `null` means the acknowledgement omitted delivery status. */
+  delivered: boolean | null;
+  row: number;
+}
+/**
+ * The tree + timeline the report is computed from, exposed because the rollout-row
+ * minter needs exactly the same parse (one parser, two consumers).
+ */
+interface SupervisorTreeFacts {
+  readonly rootId: string | null;
+  readonly spawns: readonly SpawnRow[];
+  readonly closes: readonly CloseRow[];
+  readonly workerSpawns: readonly SpawnRow[];
+  readonly workerCloses: readonly CloseRow[];
+  readonly brain: {
+    tokensIn: number;
+    tokensOut: number;
+    cacheRead: number;
+    cacheWrite: number;
+    /** False when no metered event carried cache counters — not "nothing cached". */
+    hasCache: boolean;
+    usd: number;
+    meteredCount: number;
+  };
+  readonly workerLogs: ReadonlyMap<string, WorkerLogFacts>;
+  /** Every worker source row, including duplicate identities that a map cannot retain. */
+  readonly workerLogRows: readonly WorkerLogFacts[];
+  /** Non-empty journal lines that were not JSON objects. */
+  readonly journalInvalidRows: number;
+  /** Parsed once with the journal and worker artifacts. */
+  readonly state: Record<string, unknown> | null;
+  readonly startedAt: number | null;
+  readonly completedAt: number | null;
+}
+declare function parseSupervisorTree(src: SupervisorRunSources): SupervisorTreeFacts;
+//#endregion
+//#region src/supervisor-run/analyze.d.ts
+/**
+ * Analyze already-read supervisor-run bytes. Pure and synchronous: same bytes
+ * in, same report out (modulo `generatedAt`, which `now` pins in tests).
+ */
+declare function analyzeSupervisorRunSources(src: SupervisorRunSources, now?: () => number): SupervisorRunReport;
+/** Unified-diff stats. Counts `+++ b/<path>` targets, body +/- lines, and test-file touches. */
+declare function parsePatch(text: string): PatchStats;
+/**
+ * Aggregate many supervisor-run reports. A metric no run could measure stays
+ * `unavailable` rather than becoming a 0-valued mean, and cells whose steer
+ * count was unavailable are counted separately from cells that measured zero.
+ */
+declare function rollupSupervisorRuns(reports: readonly SupervisorRunReport[]): SupervisorRunRollup;
+//#endregion
+//#region src/supervisor-run/claude-code-reader.d.ts
+/** Tool names that spawn a child agent. `Task` is the older name for `Agent`. */
+declare const DEFAULT_SPAWN_TOOLS: readonly ['Agent', 'Task'];
+/** Tool names that deliver a message to an ALREADY-RUNNING child agent. */
+declare const DEFAULT_STEER_TOOLS: readonly ['SendMessage'];
+/** Tool names that stop a running child agent. */
+declare const DEFAULT_CANCEL_TOOLS: readonly ['TaskStop', 'KillAgent'];
+interface ClaudeCodeReaderOptions {
+  /** The main session transcript: `~/.claude/projects/<slug>/<sessionId>.jsonl`. */
+  readonly transcriptPath: string;
+  /**
+   * Directory of child transcripts. Defaults to `<transcript-dir>/<sessionId>/subagents`.
+   * `null` skips the join, and every per-worker token count becomes unavailable.
+   */
+  readonly subagentsDir?: string | null;
+  readonly runRef?: string;
+  readonly instanceId?: string | null;
+  readonly arm?: string | null;
+  readonly spawnTools?: readonly string[];
+  readonly steerTools?: readonly string[];
+  readonly cancelTools?: readonly string[];
+}
+/**
+ * Read a Claude Code session (plus its subagent transcripts) as supervision-tree
+ * source bytes. Never throws on a missing artifact.
+ */
+declare function readClaudeCodeSupervisorRun(opts: ClaudeCodeReaderOptions): Promise<SupervisorRunSources>;
+/** A `SupervisorRunReader` over a Claude Code session — the same contract loops implements. */
+declare function claudeCodeSupervisorRunReader(opts: ClaudeCodeReaderOptions): SupervisorRunReader;
+//#endregion
+//#region src/supervisor-run/integrity-types.d.ts
+declare const SUPERVISOR_RUN_INTEGRITY_SCHEMA = "tangle.supervisor-run-integrity@1";
+type SupervisorRunIntegritySeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+type SupervisorRunSourceOnlyCheckCode = 'journal-event-cardinality' | 'worker-control-join' | 'steer-ack-correlation';
+type SupervisorRunIntegrityIssueCode = 'source-checks-unavailable' | 'node-schema-invalid' | 'node-checks-unavailable' | 'root-unavailable' | 'duplicate-rollout-id' | 'declared-root-missing' | 'root-has-parent' | 'root-role-invalid' | 'detached-node' | 'parent-missing' | 'cross-run-parent' | 'child-before-parent' | 'child-after-parent-close' | 'close-before-start' | 'parent-cycle' | 'child-terminal-unavailable' | 'transcript-unavailable' | 'profile-id-unavailable' | 'source-row-malformed' | 'source-event-identity-unavailable' | 'duplicate-spawn' | 'orphan-terminal' | 'duplicate-terminal' | 'worker-controls-unavailable' | 'worker-control-join-unavailable' | 'steer-request-id-unavailable' | 'steer-ack-id-unavailable' | 'steer-ack-status-unavailable' | 'duplicate-steer-request-id' | 'missing-steer-ack' | 'duplicate-steer-ack' | 'unknown-steer-ack' | 'steer-not-delivered';
+interface SupervisorRunIntegrityEvidence {
+  readonly path: string;
+  readonly value: unknown;
+}
+interface SupervisorRunIntegrityIssue {
+  readonly code: SupervisorRunIntegrityIssueCode;
+  readonly area: 'control-integrity' | 'capture-integrity';
+  readonly severity: SupervisorRunIntegritySeverity;
+  readonly subject: string;
+  readonly claim: string;
+  readonly detail: string;
+  readonly evidence: readonly SupervisorRunIntegrityEvidence[];
+  readonly recommendedAction: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface SupervisorRunIntegrityReport {
+  readonly schema: typeof SUPERVISOR_RUN_INTEGRITY_SCHEMA;
+  readonly runRef: string;
+  readonly input: 'sources' | 'tree';
+  readonly tree: SupervisorRunTree;
+  readonly issues: readonly SupervisorRunIntegrityIssue[];
+}
+interface SupervisorRunIntegrityOptions {
+  /** Pins rollout provenance when source input must be projected into a tree. */
+  readonly capturedAt?: string;
+}
+//#endregion
+//#region src/supervisor-run/integrity.d.ts
+/**
+ * Run deterministic integrity checks over source bytes or an already minted tree.
+ * Source input is parsed exactly once and reused by projection and source-only checks.
+ */
+declare function analyzeSupervisorRunIntegrity(input: SupervisorRunSources | SupervisorRunTree, options?: SupervisorRunIntegrityOptions): SupervisorRunIntegrityReport;
+//#endregion
+//#region src/supervisor-run/loops-reader.d.ts
+/** Locate the (single) supervisor run dir under `<ws>/.loops/supervisor`. */
+declare function findSupervisorRunDirIn(ws: string): Promise<string | null>;
+interface LoopsReaderOptions {
+  /** Override the workspace dir (default `<runDir>/ws`). */
+  readonly ws?: string;
+  /** Delivered patch path (default: `patchPath` from result.json). */
+  readonly patchPath?: string;
+  /** opencode sqlite store; set to `null` to skip the worker-token join entirely. */
+  readonly opencodeDb?: string | null;
+  /** Ledger to fall back to when the run has no `judge.json` (matched on iid + arm + runDir). */
+  readonly ledgerPath?: string;
+}
+/**
+ * Read a loops supervisor run directory into source bytes. Never throws on a
+ * missing artifact — an absent file becomes a `null` field, which is what makes
+ * the dependent metric `unavailable` instead of 0.
+ */
+declare function readLoopsSupervisorRun(runDir: string, opts?: LoopsReaderOptions): Promise<SupervisorRunSources>;
+/** The loops on-disk layout, as a `SupervisorRunReader`. */
+declare function loopsSupervisorRunReader(runDir: string, opts?: LoopsReaderOptions): SupervisorRunReader;
+/**
+ * Analyze a supervisor run. Accepts a run directory (read through the loops
+ * reader), any `SupervisorRunReader`, or already-read source bytes — so a
+ * caller with its own store never has to touch the filesystem layout.
+ */
+declare function analyzeSupervisorRun(input: string | SupervisorRunReader | SupervisorRunSources, opts?: LoopsReaderOptions): Promise<SupervisorRunReport>;
+interface WriteSupervisorRunOptions extends LoopsReaderOptions {
+  /** Append the headline block here (the experiment's run log). */
+  readonly appendHeadlineTo?: string;
+  /** Also console.log the headline (default true). */
+  readonly echo?: boolean;
+  /**
+   * Write `run-report.{json,md}` here instead of into the run dir. Set when
+   * reporting over a run directory that must stay READ-ONLY (a live run, an
+   * archived generation).
+   */
+  readonly reportDir?: string;
+}
+/**
+ * Read a completed run, write `run-report.json` + `run-report.md` beside its
+ * artifacts, and append the headline block to the run log. Never throws on a
+ * missing artifact — a run that produced nothing still yields a report whose
+ * every metric says why.
+ */
+declare function writeSupervisorRunReport(runDir: string, opts?: WriteSupervisorRunOptions): Promise<SupervisorRunReport>;
+/**
+ * File stem for out-of-tree reports. Built from the run path's identifying
+ * segments — candidate tag (the segment under `arm-runs/`), rep, instance, arm
+ * — so two runs of the same instance from different candidates/reps never
+ * overwrite each other.
+ */
+declare function supervisorReportStem(runDir: string): string;
+/**
+ * Best-effort wrapper for a hot path: a reporting failure must never kill a run
+ * that already produced real work. Returns null and logs the reason instead.
+ */
+declare function writeSupervisorRunReportSafe(runDir: string, opts?: WriteSupervisorRunOptions): Promise<SupervisorRunReport | null>;
+/**
+ * Report every run under an experiment `outDir` (any depth of
+ * `runs/<iid>/<arm>`), write each run's report, and write the rollup at
+ * `<outDir>/run-report-round.{json,md}`.
+ */
+declare function reportSupervisorRound(outDir: string, opts?: WriteSupervisorRunOptions & {
+  title?: string;
+}): Promise<SupervisorRunRollup>;
+/** Every `<...>/runs/<iid>/<arm>` directory under `root`. */
+declare function findSupervisorRunDirs(root: string): Promise<string[]>;
+//#endregion
+//#region src/supervisor-run/render.d.ts
+/**
+ * The block appended to a run log after every run — the answers an operator asks
+ * for, in the log tail, with no extra command.
+ */
+declare function renderSupervisorRunHeadline(r: SupervisorRunReport): string;
+declare function renderSupervisorRunMarkdown(r: SupervisorRunReport): string;
+declare function renderSupervisorRollupMarkdown(rollup: SupervisorRunRollup, title?: string): string;
+//#endregion
+//#region src/supervisor-run/rollout-nodes.d.ts
+interface SupervisorRolloutOptions {
+  /** Benchmark/suite id for `task.suite`. Defaults to `'supervisor-run'`. */
+  readonly suite?: string;
+  /** `task.split`. Defaults to `'search'` (the trainable pool). */
+  readonly split?: RolloutSplit;
+  /** Replicate index. Defaults to 0. */
+  readonly rep?: number;
+  /** Sampling seed the campaign pinned. Defaults to null (not recorded). */
+  readonly seed?: number | null;
+  /** `run_id` for every node. Defaults to the supervisor root id, else `runRef`. */
+  readonly runId?: string;
+  /** Harness that drove the supervisor. */
+  readonly supervisorHarness?: string | null;
+  /** Harness that drove the workers. */
+  readonly workerHarness?: string | null;
+  /** Model the supervisor ran on. */
+  readonly supervisorModel?: string | null;
+  /** Model the workers ran on. */
+  readonly workerModel?: string | null;
+  readonly experimentId?: string | null;
+  readonly candidateId?: string | null;
+  readonly generation?: number | null;
+  readonly candidateIndex?: number | null;
+  /** Pins `provenance.captured_at`; defaults to now. */
+  readonly capturedAt?: string;
+}
+/**
+ * Mint the supervision tree as rollout rows. Returns the rows plus the gaps
+ * that made any of them incomplete — same unavailable-vs-zero discipline as
+ * the report: a row with no transcript says WHY, it never pretends to be empty.
+ */
+declare function supervisorRunRolloutLines(src: SupervisorRunSources, opts?: SupervisorRolloutOptions): SupervisorRunTree;
+//#endregion
+export { claudeCodeSupervisorRunReader as A, WorkerLogFacts as B, SupervisorRunIntegrityReport as C, DEFAULT_CANCEL_TOOLS as D, ClaudeCodeReaderOptions as E, CloseRow as F, SpawnRow as I, SteerAcknowledgementFact as L, analyzeSupervisorRunSources as M, parsePatch as N, DEFAULT_SPAWN_TOOLS as O, rollupSupervisorRuns as P, SteerRequestFact as R, SupervisorRunIntegrityOptions as S, SupervisorRunSourceOnlyCheckCode as T, parseSupervisorTree as V, analyzeSupervisorRunIntegrity as _, renderSupervisorRunMarkdown as a, SupervisorRunIntegrityIssue as b, analyzeSupervisorRun as c, loopsSupervisorRunReader as d, readLoopsSupervisorRun as f, writeSupervisorRunReportSafe as g, writeSupervisorRunReport as h, renderSupervisorRunHeadline as i, readClaudeCodeSupervisorRun as j, DEFAULT_STEER_TOOLS as k, findSupervisorRunDirIn as l, supervisorReportStem as m, supervisorRunRolloutLines as n, LoopsReaderOptions as o, reportSupervisorRound as p, renderSupervisorRollupMarkdown as r, WriteSupervisorRunOptions as s, SupervisorRolloutOptions as t, findSupervisorRunDirs as u, SUPERVISOR_RUN_INTEGRITY_SCHEMA as v, SupervisorRunIntegritySeverity as w, SupervisorRunIntegrityIssueCode as x, SupervisorRunIntegrityEvidence as y, SupervisorTreeFacts as z };
+//# sourceMappingURL=index-BipJlj-C.d.ts.map

package/dist/index-BipJlj-C.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BipJlj-C.d.ts","names":[],"sources":["../src/supervisor-run/source-facts.ts","../src/supervisor-run/analyze.ts","../src/supervisor-run/claude-code-reader.ts","../src/supervisor-run/integrity-types.ts","../src/supervisor-run/integrity.ts","../src/supervisor-run/loops-reader.ts","../src/supervisor-run/render.ts","../src/supervisor-run/rollout-nodes.ts"],"mappings":";;;UAqBU;EACR;EACA;EACA;EACA;;EAEA;;UAGQ;EACR,QAAQ;EACR;;UAgFe;;EAEf;EACA;EACA;EACA;EACA,MAAM;EACN;;EAEA;EACA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,OAAO;;EAEP;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA,eAAe;EACf,uBAAuB;;UAGR;;EAEf;EACA;;UAGe;;EAEf;;EAEA;EACA;;;;;;UAOe;WACN;WACA,iBAAiB;WACjB,iBAAiB;WACjB,uBAAuB;WACvB,uBAAuB;WACvB;IACP;IACA;IACA;IACA;;IAEA;IACA;IACA;;WAEO,YAAY,oBAAoB;;WAEhC,wBAAwB;;WAExB;;WAEA,OAAO;WACP;WACA;;iBA+BK,oBAAoB,KAAK,uBAAuB;;;;;;;iBC5LhD,4BACd,KAAK,sBACL,qBACC;;iBA6oBa,WAAW,eAAe;;;;;;iBA+C1B,qBAAqB,kBAAkB,wBAAwB;;;;cCrrBlE;;cAEA;;cAEA;UASI;;WAEN;;;;;WAKA;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;iBAmOW,4BACpB,MAAM,0BACL,QAAQ;;iBAiUK,8BAA8B,MAAM,0BAA0B;;;cCnoBjE;KAED;KAEA;KAKA;UAmCK;WACN;WACA;;UAGM;WACN,MAAM;WACN;WACA,UAAU;WACV;WACA;WACA;WACA,mBAAmB;WACnB;WACA,WAAW,SAAS;;UAGd;WACN,eAAe;WACf;WACA;WACA,MAAM;WACN,iBAAiB;;UAGX;;WAEN;;;;;;;;iBC5BK,8BACd,OAAO,uBAAuB,mBAC9B,UAAS,gCACR;;;;iBCPmB,uBAAuB,aAAa;UAOzC;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;;iBAQW,uBACpB,gBACA,OAAM,qBACL,QAAQ;;iBAmKK,yBACd,gBACA,OAAM,qBACL;;;;;;iBAkCmB,qBACpB,gBAAgB,sBAAsB,sBACtC,OAAM,qBACL,QAAQ;UAYM,kCAAkC;;WAExC;;WAEA;;;;;;WAMA;;;;;;;;iBASW,yBACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;;iBAuBK,qBAAqB;;;;;iBAiBf,6BACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;iBAgBW,sBACpB,gBACA,OAAM;EAA8B;IACnC,QAAQ;;iBA0BW,sBAAsB,eAAe;;;;;;;iBCrX3C,4BAA4B,GAAG;iBAgC/B,4BAA4B,GAAG;iBAwK/B,+BACd,QAAQ,qBACR;;;UCtLe;;WAEN;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;iBAwBK,0BACd,KAAK,sBACL,OAAM,2BACL"}

package/dist/{index-CQsJcqch.d.ts → index-BnP1QJUv.d.ts}

@@ -1,7 +1,7 @@
-import { s as RunSplitTag } from "./run-record-DcObtIGh.js";
-import { R as Scenario, a as CampaignResult, d as DispatchContext } from "./types-DiWLru6Z.js";
-import { sn as CampaignStorage } from "./skillopt-optimization-method-CwSYkv35.js";
-import "./index-B4Fjfo5U.js";
+import { s as RunSplitTag } from "./run-record-BPCa2rQ8.js";
+import { R as Scenario, a as CampaignResult, d as DispatchContext } from "./types-CTGbIm57.js";
+import { sn as CampaignStorage } from "./skillopt-optimization-method-BpbnlvAZ.js";
+import "./index-C-Pr4OWg.js";
 //#region src/benchmarks/types.d.ts
 type BenchmarkTaskKind = 'retrieval' | 'rag-answer' | 'hallucination' | 'kb-improvement' | 'routing' | 'custom';
 type BenchmarkFamily = 'beir' | 'mteb-retrieval' | 'msmarco' | 'trec-dl' | 'miracl' | 'lotte' | 'bright' | 'crag' | 'hotpotqa' | 'kilt' | 'ragtruth' | 'faithbench' | 'first-party' | 'custom';
@@ -332,4 +332,4 @@ declare namespace index_d_exports {
 }
 //#endregion
 export { BenchmarkMetricCalibrationOptions as A, BenchmarkSource as B, BenchmarkRunOptions as C, runBenchmarkAdapter as D, renderBenchmarkReportMarkdown as E, BenchmarkDatasetItem as F, deterministicSplit as H, BenchmarkEvaluation as I, BenchmarkFamily as L, calibrateBenchmarkMetric as M, BENCHMARK_SPLIT_SEED as N, summarizeBenchmarkCampaign as O, BenchmarkAdapter as P, BenchmarkResponder as R, BenchmarkReport as S, BenchmarkSliceSummary as T, BenchmarkTaskKind as V, parseJsonlRows as _, StandardRetrievalDocument as a, retrievalMetricsAtCutoff as b, StandardRetrievalQrel as c, buildStandardRetrievalItems as d, createRetrievalIdBenchmarkAdapter as f, parseBeirQueriesJsonl as g, parseBeirCorpusJsonl as h, StandardRetrievalArtifact as i, BenchmarkMetricCalibrationResult as j, index_d_exports$1 as k, StandardRetrievalQuery as l, normalizeRetrievedDocumentIds as m, BuildStandardRetrievalItemsOptions as n, StandardRetrievalEvaluationOptions as o, evaluateStandardRetrieval as p, RetrievalIdAdapterOptions as r, StandardRetrievalPayload as s, index_d_exports as t, StandardRetrievalResult as u, parseQrels as v, BenchmarkRunResult as w, BenchmarkDistribution as x, parseTsvRows as y, BenchmarkScenario as z };
-//# sourceMappingURL=index-CQsJcqch.d.ts.map
+//# sourceMappingURL=index-BnP1QJUv.d.ts.map

package/dist/{index-CQsJcqch.d.ts.map → index-BnP1QJUv.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CQsJcqch.d.ts","names":[],"sources":["../src/benchmarks/types.ts","../src/benchmarks/calibration.ts","../src/benchmarks/routing/dataset.ts","../src/benchmarks/routing/index.ts","../src/benchmarks/runner.ts","../src/benchmarks/standard-formats.ts","../src/benchmarks/index.ts"],"mappings":"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"}
+{"version":3,"file":"index-BnP1QJUv.d.ts","names":[],"sources":["../src/benchmarks/types.ts","../src/benchmarks/calibration.ts","../src/benchmarks/routing/dataset.ts","../src/benchmarks/routing/index.ts","../src/benchmarks/runner.ts","../src/benchmarks/standard-formats.ts","../src/benchmarks/index.ts"],"mappings":"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"}