@tangle-network/agent-eval 0.20.10 → 0.20.12

package/dist/feedback-trajectory-BGQ_ANCN.d.ts

@@ -0,0 +1,345 @@
+import { D as DatasetSplit, a as DatasetScenario } from './dataset-B9qvlm_o.js';
+import { T as TraceEmitter, F as FailureClass, a as TraceStore } from './emitter-BYO2nSDA.js';
+
+/**
+ * Policy-based agent control runtime.
+ *
+ * This is the minimal reusable loop behind driver-agent patterns:
+ *
+ *   observe state -> validate -> decide next action -> act -> observe -> ...
+ *
+ * It deliberately does not model named "topologies". Direct execution,
+ * critic/revise, driver intervention, specialist calls, and human escalation
+ * are all just actions chosen by the control policy.
+ */
+
+type ControlSeverity = 'info' | 'warning' | 'error' | 'critical';
+type ControlActionFailureMode = 'continue' | 'stop';
+interface ControlEvalResult {
+    /** Stable validator or judge id. */
+    id: string;
+    /** Whether this check passed. */
+    passed: boolean;
+    /** Optional normalized score. 1 = best, 0 = worst. */
+    score?: number;
+    /** Objective validators should usually be "error" or "critical" when failed. */
+    severity?: ControlSeverity;
+    /** Human-readable result. */
+    detail?: string;
+    /** Small evidence string or pointer. Avoid large payloads. */
+    evidence?: string;
+    /** True when the result came from deterministic state, not LLM judgment. */
+    objective?: boolean;
+    /** Structured details for downstream control policies and reports. */
+    metadata?: Record<string, unknown>;
+}
+interface ControlBudget {
+    maxSteps: number;
+    maxWallMs?: number;
+    maxCostUsd?: number;
+}
+interface ControlStopPolicies<TState, TAction> {
+    /**
+     * Stop after N consecutive steps with no state fingerprint change and
+     * less than `minScoreDelta` score movement. Disabled when omitted.
+     */
+    maxNoProgressSteps?: number;
+    /**
+     * Stop after the same action fingerprint is selected N consecutive
+     * times. Disabled when omitted.
+     */
+    maxRepeatedActions?: number;
+    /** Minimum score movement that counts as progress. Default 0.001. */
+    minScoreDelta?: number;
+    /** Override the default JSON/string fingerprint for state comparisons. */
+    stateFingerprint?: (state: TState) => string;
+    /** Override the default JSON/string fingerprint for repeated-action checks. */
+    actionFingerprint?: (action: TAction) => string;
+}
+interface ControlContext<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    intent: string;
+    state: TState;
+    evals: TEval[];
+    history: ControlStep<TState, TAction, TActionResult, TEval>[];
+    budget: ControlBudget;
+    stepIndex: number;
+    wallMs: number;
+    spentCostUsd: number;
+    remainingCostUsd?: number;
+    abortSignal: AbortSignal;
+    emitter?: TraceEmitter;
+}
+type ControlDecision<TAction> = {
+    type: 'continue';
+    action: TAction;
+    reason?: string;
+} | {
+    type: 'stop';
+    reason: string;
+    pass?: boolean;
+    score?: number;
+};
+interface StopDecision {
+    stop: boolean;
+    pass: boolean;
+    reason: string;
+    score?: number;
+    failureClass?: FailureClass;
+}
+interface ControlActionOutcome<TActionResult> {
+    ok: boolean;
+    result?: TActionResult;
+    error?: string;
+    costUsd?: number;
+    durationMs: number;
+}
+interface ControlRuntimeError {
+    phase: 'observe' | 'validate' | 'decide' | 'act' | 'stop-policy' | 'on-step' | 'trace';
+    stepIndex: number;
+    message: string;
+}
+interface ControlStep<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    index: number;
+    decision: ControlDecision<TAction>;
+    beforeState: TState;
+    afterState: TState;
+    evalsBefore: TEval[];
+    evalsAfter: TEval[];
+    actionOutcome?: ControlActionOutcome<TActionResult>;
+    startedAt: string;
+    endedAt: string;
+}
+interface ControlRunResult<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    intent: string;
+    pass: boolean;
+    completed: boolean;
+    reason: string;
+    score?: number;
+    steps: ControlStep<TState, TAction, TActionResult, TEval>[];
+    finalState: TState | undefined;
+    finalEvals: TEval[];
+    wallMs: number;
+    spentCostUsd: number;
+    runId: string | null;
+    failureClass?: FailureClass;
+    runtimeErrors: ControlRuntimeError[];
+    stoppedBy: 'policy' | 'stop-policy' | 'budget' | 'abort' | 'runtime-error';
+}
+interface ControlRuntimeConfig<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    intent: string;
+    budget?: Partial<ControlBudget>;
+    signal?: AbortSignal;
+    /** Defaults to `continue`: action failures are recorded, then the policy gets another chance. */
+    actionFailure?: ControlActionFailureMode;
+    /**
+     * Extract cost from an action result. Used for `maxCostUsd` budget
+     * enforcement and trace budget ledger emission.
+     */
+    getActionCostUsd?: (ctx: {
+        action: TAction;
+        result: TActionResult;
+        state: TState;
+        evals: TEval[];
+        history: ControlStep<TState, TAction, TActionResult, TEval>[];
+    }) => number | undefined;
+    /** Read typed task/product state. Prefer structured state over transcript-only context. */
+    observe: (ctx: {
+        history: ControlStep<TState, TAction, TActionResult, TEval>[];
+        abortSignal: AbortSignal;
+    }) => Promise<TState> | TState;
+    /** Objective validators first, subjective judges only where objective state is insufficient. */
+    validate: (ctx: {
+        intent: string;
+        state: TState;
+        history: ControlStep<TState, TAction, TActionResult, TEval>[];
+        abortSignal: AbortSignal;
+    }) => Promise<TEval[]> | TEval[];
+    /** Choose the next control action. Can call a worker, ask user, run critic, inspect state, or stop. */
+    decide: (ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<ControlDecision<TAction>> | ControlDecision<TAction>;
+    /** Execute the action selected by the policy. */
+    act: (action: TAction, ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<TActionResult> | TActionResult;
+    /** Final stopping policy. Called before decide and after each action. */
+    shouldStop?: (ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<StopDecision> | StopDecision;
+    /** Optional hook for tracing or live progress updates. */
+    onStep?: (step: ControlStep<TState, TAction, TActionResult, TEval>) => Promise<void> | void;
+    /** Optional generic stuck-loop policies. Custom `shouldStop` still runs first. */
+    stopPolicies?: ControlStopPolicies<TState, TAction>;
+    /** Optional trace sink. Emits one run plus one span per control step. */
+    store?: TraceStore;
+    scenarioId?: string;
+    projectId?: string;
+    variantId?: string;
+}
+declare function runAgentControlLoop<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult>(config: ControlRuntimeConfig<TState, TAction, TActionResult, TEval>): Promise<ControlRunResult<TState, TAction, TActionResult, TEval>>;
+declare function stopOnNoProgress<TState, TAction>(maxNoProgressSteps: number, options?: Omit<ControlStopPolicies<TState, TAction>, 'maxNoProgressSteps'>): ControlStopPolicies<TState, TAction>;
+declare function stopOnRepeatedAction<TState, TAction>(maxRepeatedActions: number, options?: Omit<ControlStopPolicies<TState, TAction>, 'maxRepeatedActions'>): ControlStopPolicies<TState, TAction>;
+declare function objectiveEval(input: Omit<ControlEvalResult, 'objective'>): ControlEvalResult;
+declare function subjectiveEval(input: Omit<ControlEvalResult, 'objective'>): ControlEvalResult;
+declare function allCriticalPassed(evals: ControlEvalResult[]): boolean;
+
+type FeedbackArtifactType = 'text' | 'code' | 'plan' | 'research' | 'action' | 'ui' | 'decision' | 'data' | 'other';
+type FeedbackLabelSource = 'user' | 'judge' | 'environment' | 'metric' | 'policy' | 'system';
+type FeedbackLabelKind = 'approve' | 'reject' | 'select' | 'edit' | 'rank' | 'rate' | 'comment' | 'metric_outcome' | 'policy_block' | 'revision_request';
+type FeedbackSeverity = 'info' | 'warning' | 'error' | 'critical';
+interface FeedbackTask {
+    intent: string;
+    context?: unknown;
+}
+interface ProposedSideEffect {
+    type: string;
+    risk?: 'low' | 'medium' | 'high';
+    costUsd?: number;
+    externalSideEffect?: boolean;
+    requiresApproval?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackLabel {
+    id?: string;
+    source: FeedbackLabelSource;
+    kind: FeedbackLabelKind;
+    value: unknown;
+    reason?: string;
+    severity?: FeedbackSeverity;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackAttempt {
+    id: string;
+    stepIndex: number;
+    artifactType: FeedbackArtifactType;
+    artifact: unknown;
+    options?: unknown[];
+    proposedAction?: ProposedSideEffect;
+    evals?: ControlEvalResult[];
+    feedback?: FeedbackLabel[];
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackOutcome {
+    success?: boolean;
+    score?: number;
+    metrics?: Record<string, number>;
+    costUsd?: number;
+    detail?: string;
+    observedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackTrajectory {
+    id: string;
+    projectId?: string;
+    scenarioId?: string;
+    task: FeedbackTask;
+    attempts: FeedbackAttempt[];
+    labels: FeedbackLabel[];
+    outcome?: FeedbackOutcome;
+    split?: DatasetSplit;
+    tags?: Record<string, string>;
+    createdAt: string;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackTrajectoryStore {
+    save(trajectory: FeedbackTrajectory): Promise<void>;
+    get(id: string): Promise<FeedbackTrajectory | null>;
+    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
+    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
+    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
+}
+interface FeedbackTrajectoryFilter {
+    projectId?: string;
+    scenarioId?: string;
+    split?: DatasetSplit;
+    tag?: [string, string];
+}
+interface FeedbackSplitPolicy {
+    trainPct?: number;
+    devPct?: number;
+    testPct?: number;
+    holdoutPct?: number;
+}
+interface PreferenceMemoryEntry {
+    instruction: string;
+    rationale: string;
+    weight: number;
+    sourceTrajectoryId: string;
+    sourceLabelId?: string;
+    category?: string;
+}
+interface FeedbackOptimizerRow {
+    scenarioId: string;
+    trajectoryId: string;
+    labelKinds: FeedbackLabelKind[];
+    score?: number;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackReplayResult {
+    trajectoryId: string;
+    pass: boolean;
+    score?: number;
+    labels: FeedbackLabel[];
+    outcome?: FeedbackOutcome;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackReplayAdapter {
+    replay(trajectory: FeedbackTrajectory): Promise<Omit<FeedbackReplayResult, 'trajectoryId'>> | Omit<FeedbackReplayResult, 'trajectoryId'>;
+}
+declare class InMemoryFeedbackTrajectoryStore implements FeedbackTrajectoryStore {
+    private readonly trajectories;
+    save(trajectory: FeedbackTrajectory): Promise<void>;
+    get(id: string): Promise<FeedbackTrajectory | null>;
+    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
+    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
+    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
+}
+declare class FileSystemFeedbackTrajectoryStore implements FeedbackTrajectoryStore {
+    private readonly dir;
+    private readonly memory;
+    private loaded;
+    constructor(options: {
+        dir: string;
+    });
+    save(trajectory: FeedbackTrajectory): Promise<void>;
+    get(id: string): Promise<FeedbackTrajectory | null>;
+    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
+    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
+    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
+    private append;
+    private load;
+}
+declare function createFeedbackTrajectory(input: {
+    id?: string;
+    projectId?: string;
+    scenarioId?: string;
+    task: FeedbackTask;
+    attempts?: FeedbackAttempt[];
+    labels?: FeedbackLabel[];
+    outcome?: FeedbackOutcome;
+    split?: DatasetSplit;
+    tags?: Record<string, string>;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+}): FeedbackTrajectory;
+declare function assignFeedbackSplit(trajectory: Pick<FeedbackTrajectory, 'id' | 'projectId' | 'scenarioId' | 'task'>, policy?: FeedbackSplitPolicy): DatasetSplit;
+declare function withAssignedFeedbackSplit(trajectory: FeedbackTrajectory, policy?: FeedbackSplitPolicy): FeedbackTrajectory;
+declare function feedbackTrajectoryToDatasetScenario(trajectory: FeedbackTrajectory): DatasetScenario;
+declare function feedbackTrajectoriesToDatasetScenarios(trajectories: FeedbackTrajectory[]): DatasetScenario[];
+declare function feedbackTrajectoryToOptimizerRow(trajectory: FeedbackTrajectory): FeedbackOptimizerRow;
+declare function feedbackTrajectoriesToOptimizerRows(trajectories: FeedbackTrajectory[]): FeedbackOptimizerRow[];
+declare function replayFeedbackTrajectory(trajectory: FeedbackTrajectory, adapter: FeedbackReplayAdapter): Promise<FeedbackReplayResult>;
+declare function replayFeedbackTrajectories(trajectories: FeedbackTrajectory[], adapter: FeedbackReplayAdapter): Promise<FeedbackReplayResult[]>;
+declare function summarizePreferenceMemory(trajectories: FeedbackTrajectory[], options?: {
+    maxEntries?: number;
+}): PreferenceMemoryEntry[];
+declare function renderPreferenceMemoryMarkdown(entries: PreferenceMemoryEntry[]): string;
+declare function serializeFeedbackTrajectoriesJsonl(trajectories: FeedbackTrajectory[]): string;
+declare function parseFeedbackTrajectoriesJsonl(jsonl: string): FeedbackTrajectory[];
+declare function controlRunToFeedbackTrajectory<TState, TAction, TActionResult>(run: ControlRunResult<TState, TAction, TActionResult>, options?: {
+    projectId?: string;
+    scenarioId?: string;
+    artifactType?: FeedbackArtifactType;
+    artifactFromStep?: (step: ControlStep<TState, TAction, TActionResult>) => unknown;
+    proposedActionFromStep?: (step: ControlStep<TState, TAction, TActionResult>) => ProposedSideEffect | undefined;
+    createdAt?: string;
+}): FeedbackTrajectory;
+
+export { type ProposedSideEffect as A, allCriticalPassed as B, type ControlSeverity as C, assignFeedbackSplit as D, controlRunToFeedbackTrajectory as E, type FeedbackLabel as F, createFeedbackTrajectory as G, feedbackTrajectoriesToDatasetScenarios as H, InMemoryFeedbackTrajectoryStore as I, feedbackTrajectoriesToOptimizerRows as J, feedbackTrajectoryToDatasetScenario as K, feedbackTrajectoryToOptimizerRow as L, objectiveEval as M, parseFeedbackTrajectoriesJsonl as N, renderPreferenceMemoryMarkdown as O, type PreferenceMemoryEntry as P, replayFeedbackTrajectories as Q, replayFeedbackTrajectory as R, type StopDecision as S, runAgentControlLoop as T, serializeFeedbackTrajectoriesJsonl as U, stopOnNoProgress as V, stopOnRepeatedAction as W, subjectiveEval as X, summarizePreferenceMemory as Y, withAssignedFeedbackSplit as Z, type FeedbackTrajectoryStore as a, type FeedbackTrajectory as b, type ControlEvalResult as c, type ControlActionFailureMode as d, type ControlActionOutcome as e, type ControlBudget as f, type ControlContext as g, type ControlDecision as h, type ControlRunResult as i, type ControlRuntimeConfig as j, type ControlRuntimeError as k, type ControlStep as l, type ControlStopPolicies as m, type FeedbackArtifactType as n, type FeedbackAttempt as o, type FeedbackLabelKind as p, type FeedbackLabelSource as q, type FeedbackOptimizerRow as r, type FeedbackOutcome as s, type FeedbackReplayAdapter as t, type FeedbackReplayResult as u, type FeedbackSeverity as v, type FeedbackSplitPolicy as w, type FeedbackTask as x, type FeedbackTrajectoryFilter as y, FileSystemFeedbackTrajectoryStore as z };

package/dist/{index-1PZOtZFr.d.ts → index-c5saLbKD.d.ts}

@@ -1,135 +1,4 @@
-/**
- * Paper-grade RunRecord schema + runtime validator.
- *
- * Every run that participates in a promotion gate, paper table, or
- * researcher loop SHOULD be recorded as a `RunRecord`. The mandatory
- * fields are exactly those the paper "Two Loops, Three Roles" requires
- * for reproducibility: who/what/when/cost/seed/hash, plus the search vs
- * holdout split tag and either a `searchScore` or a `holdoutScore`.
- *
- * This is intentionally NOT a replacement for the rich `Run` /
- * `ProposeReviewReport` / `ScenarioResult` types already in the
- * package. Those are runtime structures with full provenance. A
- * `RunRecord` is the analysis-time projection — the JSON-friendly
- * row you'd put in a parquet file or paste into a notebook.
- *
- * Validate at the boundary:
- *
- *   const rec = validateRunRecord(rawJson)         // throws on missing
- *   const ok  = isRunRecord(rawJson)               // boolean check
- *   const rec = parseRunRecordSafe(rawJson)        // { ok, value | error }
- *
- * The validator runs in pure TS — zod is intentionally NOT a
- * dependency. Round-trip tested in `tests/run-record.test.ts`.
- */
-/** Search/dev/holdout split tag. 'search' is the paper-grade alias for the
- *  combined train+test pool that the optimizer is allowed to read. */
-type RunSplitTag = 'search' | 'dev' | 'holdout';
-interface RunTokenUsage {
-    input: number;
-    output: number;
-    cached?: number;
-}
-interface RunJudgeMetadata {
-    model: string;
-    promptVersion: string;
-    /** [0,1] confidence the judge declared. Constant judge confidence
-     *  across many runs is a fallback signal (see `canary.ts`). */
-    confidence: number;
-    /** True if the judge degraded to a fallback path (rules-only,
-     *  prior-call cache, etc.). The canary uses this to alert. */
-    fallback: boolean;
-}
-interface RunOutcome {
-    /** Score on the search/optimization split. Optional because a
-     *  holdout-only evaluation only fills `holdoutScore`. */
-    searchScore?: number;
-    /** Score on the held-out split. Optional because a search-only run
-     *  only fills `searchScore`. At least one must be present. */
-    holdoutScore?: number;
-    /** Bag of any other metric the run produced — judge dimensions,
-     *  pass/fail counters, latency stats, etc. Numeric only — keeps
-     *  reporters honest. */
-    raw: Record<string, number>;
-}
-/**
- * Mandatory paper-grade fields for a single evaluation run. Optional
- * fields are extension points; mandatory fields throw if missing.
- *
- * Hash discipline:
- *   - `promptHash` is the sha256 of the EFFECTIVE prompt sent to the
- *     model (after any steering bundle merge).
- *   - `configHash` is the sha256 of the effective run config (model,
- *     temperature, tools, judges, splits). The pair (promptHash,
- *     configHash) uniquely identifies an experimental cell.
- *
- * Model snapshot discipline:
- *   - `model` MUST encode a snapshot version. Bare aliases like
- *     `claude-sonnet-4` or `gpt-4o` are banned — they remap silently.
- *     Use `claude-sonnet-4-6@2025-04-15` or `gpt-4o-2024-11-20`.
- */
-interface RunRecord {
-    /** UUID for the run. */
-    runId: string;
-    /** Logical experiment grouping (a treatment vs a baseline within
-     *  the same sweep should share `experimentId`). */
-    experimentId: string;
-    /** Stable identifier for the candidate (variant) being run. The
-     *  promotion gate compares two `candidateId`s on matched items. */
-    candidateId: string;
-    /** RNG seed for the run. Always recorded — silent re-seeding is
-     *  the most common cause of non-reproducible numbers. */
-    seed: number;
-    /** Model identifier WITH snapshot version. */
-    model: string;
-    /** sha256 of the effective prompt (post-steering). */
-    promptHash: string;
-    /** sha256 of the effective config. */
-    configHash: string;
-    /** Git SHA the harness was run from. */
-    commitSha: string;
-    /** End-to-end wall-clock duration in milliseconds. */
-    wallMs: number;
-    /** Time spent queued before execution started, if known. */
-    queueMs?: number;
-    /** Total USD cost. Mandatory — runs without a cost number are
-     *  unbounded by definition and must not be admitted into the gate. */
-    costUsd: number;
-    /** Token usage breakdown. */
-    tokenUsage: RunTokenUsage;
-    /** Judge-side metadata, if a judge was used. */
-    judgeMetadata?: RunJudgeMetadata;
-    /** Per-split scores + raw bag. */
-    outcome: RunOutcome;
-    /** Categorical failure tag, when the run failed and the harness
-     *  classified it. Free-form string; standard tags live in
-     *  `failure-taxonomy.ts`. */
-    failureMode?: string;
-    /** Which split this run was drawn from. */
-    splitTag: RunSplitTag;
-}
-declare class RunRecordValidationError extends Error {
-    readonly path: string;
-    constructor(message: string, path?: string);
-}
-/**
- * Strict validator. Throws `RunRecordValidationError` on the first
- * missing or wrongly-typed field. Returns the input cast to
- * `RunRecord` on success — the validator does not coerce.
- */
-declare function validateRunRecord(input: unknown): RunRecord;
-/** Boolean validator — convenience for filtering arrays. */
-declare function isRunRecord(input: unknown): input is RunRecord;
-/** Non-throwing validator — returns a discriminated union. */
-declare function parseRunRecordSafe(input: unknown): {
-    ok: true;
-    value: RunRecord;
-} | {
-    ok: false;
-    error: RunRecordValidationError;
-};
-/** Round-trip helper — `JSON.parse(JSON.stringify(record))` then validate. */
-declare function roundTripRunRecord(record: RunRecord): RunRecord;
+import { R as RunSplitTag } from './run-record-CX_jcAyr.js';
 
 /**
  * Shared types for the reference benchmark wrappers under
@@ -287,4 +156,4 @@ declare namespace index {
   export { index_BENCHMARK_SPLIT_SEED as BENCHMARK_SPLIT_SEED, type index_BenchmarkAdapter as BenchmarkAdapter, type index_BenchmarkDatasetItem as BenchmarkDatasetItem, type index_BenchmarkEvaluation as BenchmarkEvaluation, index_deterministicSplit as deterministicSplit, index$1 as routing };
 }
 
-export { BENCHMARK_SPLIT_SEED as B, type RunRecord as R, type RunSplitTag as a, type BenchmarkAdapter as b, type BenchmarkDatasetItem as c, type BenchmarkEvaluation as d, type RunJudgeMetadata as e, type RunOutcome as f, RunRecordValidationError as g, type RunTokenUsage as h, deterministicSplit as i, index as j, isRunRecord as k, index$1 as l, parseRunRecordSafe as p, roundTripRunRecord as r, validateRunRecord as v };
+export { BENCHMARK_SPLIT_SEED as B, type BenchmarkAdapter as a, type BenchmarkDatasetItem as b, type BenchmarkEvaluation as c, deterministicSplit as d, index$1 as e, index as i };