@leostera/evalkit 0.2.0 → 0.4.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as TrialMetadata, $t as Uuid, A as FixtureContext, At as RecordedErrorSchema, B as ReportStore, Bt as TrialSummarySchema, C as EvalRegistryMetadata, Ct as parseTrajectoryJsonl, D as ExpectToolCallStep, Dt as CheckpointResultSchema, E as EvaluatorWorkspace, Et as AutIdentitySchema, F as JsonValue, Ft as ScoreResultSchema, G as RunWriter, Gt as EvalMatrixCell, H as RunResult, Ht as EvalkitConfig, I as JudgeRule, It as TrajectoryEventSchema, J as ScoreValue, Jt as canonicalParameters, K as RunnerEvent, Kt as MatrixSelection, L as JudgeRunInfo, Lt as TrialManifestSchema, M as InlineFixture, Mt as RunMetadataSchema, N as JsonObject, Nt as RunStatusSchema, O as FileFixture, Ot as JsonValueSchema, P as JsonPrimitive, Pt as RunSummarySchema, Q as TranscriptStep, Qt as ResourceUriSchema, R as PredicateScorer, Rt as TrialMetadataSchema, S as EvalRegistry, St as user, T as EvalSuiteMetadata, Tt as ArtifactEntrySchema, U as RunStatus, Ut as defineConfig, V as RunMetadata, Vt as UsageSchema, W as RunSummary, Wt as EvalMatrix, X as ScoringRule, Xt as ResourceKindSchema, Y as ScoringContext, Yt as ResourceKind, Z as TrajectoryEvent, Zt as ResourceUri, _ as EvalCatalogEntry, _t as inlineFile, a as AggregateScoring, an as resourceUuid, at as Usage, b as EvalPolicy, bt as recordError, c as AutAdapter, ct as agent, d as AutIdentity, dt as defineEval, en as UuidSchema, et as TrialResult, f as AutSession, ft as defineSuite, g as DynamicFixture, gt as file, h as DirectoryFixture, ht as expectToolCall, i as AgentStep, in as resourceUriSchema, it as TurnView, j as FixtureVisibility, jt as RunManifestSchema, k as Fixture, kt as JudgeRunInfoSchema, l as AutContext, lt as authoringId, m as CheckpointResult, mt as dynamic, n as AgentRuntimeName, nn as parseResourceUri, nt as TrialSummary, o as ArtifactEntry, ot as UserStep, p as CandidateWorkspace, pt as directory, q as ScoreResult, qt as defineEvalMatrix, r as AgentRuntimes, rn as resourceUri, rt as TrialWriter, s as ArtifactView, st as WorkspaceView, t as AgentRuntime, tn as authorId, tt as TrialScoring, u as AutEvent, ut as defineAgent, v as EvalCatalogFixture, vt as judge, w as EvalSuite, wt as ApiErrorSchema, x as EvalRegistration, xt as registerEvals, y as EvalDefinition, yt as predicate, z as RecordedError, zt as TrialScoringSchema } from "./index-M5eRlMfd.mjs";
+import { $ as TrajectoryEvent, $t as ResourceKindSchema, A as FixtureContext, At as JsonValueSchema, B as ReportStore, Bt as TrialManifestSchema, C as EvalRegistryMetadata, Ct as registerEvals, D as ExpectToolCallStep, Dt as ArtifactEntrySchema, E as EvaluatorWorkspace, Et as ApiErrorSchema, F as JsonValue, Ft as RunSourceSchema, G as RunStatus, Gt as EvalkitConfig, H as RunMetadata, Ht as TrialScoringSchema, I as JudgeRule, It as RunStatusSchema, J as RunnerEvent, Jt as EvalMatrixCell, K as RunSummary, Kt as defineConfig, L as JudgeRunInfo, Lt as RunSummarySchema, M as InlineFixture, Mt as RecordedErrorSchema, N as JsonObject, Nt as RunManifestSchema, O as FileFixture, Ot as AutIdentitySchema, P as JsonPrimitive, Pt as RunMetadataSchema, Q as ScoringRule, Qt as ResourceKind, R as PredicateScorer, Rt as ScoreResultSchema, S as EvalRegistry, St as recordError, T as EvalSuiteMetadata, Tt as parseTrajectoryJsonl, U as RunResult, Ut as TrialSummarySchema, V as RunCatalog, Vt as TrialMetadataSchema, W as RunSource, Wt as UsageSchema, X as ScoreValue, Xt as defineEvalMatrix, Y as ScoreResult, Yt as MatrixSelection, Z as ScoringContext, Zt as canonicalParameters, _ as EvalCatalogEntry, _t as expectToolCall, a as AggregateScoring, an as parseResourceUri, at as TrialWriter, b as EvalPolicy, bt as judge, c as AutAdapter, cn as resourceUuid, ct as UserStep, d as AutIdentity, dt as authoringId, en as ResourceUri, et as TranscriptStep, f as AutSession, ft as defineAgent, g as DynamicFixture, gt as dynamic, h as DirectoryFixture, ht as directory, i as AgentStep, in as authorId, it as TrialSummary, j as FixtureVisibility, jt as JudgeRunInfoSchema, k as Fixture, kt as CheckpointResultSchema, l as AutContext, lt as WorkspaceView, m as CheckpointResult, mt as defineSuite, n as AgentRuntimeName, nn as Uuid, nt as TrialResult, o as ArtifactEntry, on as resourceUri, ot as TurnView, p as CandidateWorkspace, pt as defineEval, q as RunWriter, qt as EvalMatrix, r as AgentRuntimes, rn as UuidSchema, rt as TrialScoring, s as ArtifactView, sn as resourceUriSchema, st as Usage, t as AgentRuntime, tn as ResourceUriSchema, tt as TrialMetadata, u as AutEvent, ut as agent, v as EvalCatalogFixture, vt as file, w as EvalSuite, wt as user, x as EvalRegistration, xt as predicate, y as EvalDefinition, yt as inlineFile, z as RecordedError, zt as TrajectoryEventSchema } from "./index-U6TUTBf7.mjs";
 //#region ../agents/src/index.d.ts
 type PiAutOptions = {
   command?: string;
@@ -8,5 +8,5 @@ type PiAutOptions = {
 /** A local, one-prompt-per-turn AUT backed by Pi's non-interactive print mode. */
 export declare function piAgent(options?: PiAutOptions): AutAdapter;
 //#endregion
-export { AgentRuntime, AgentRuntimeName, AgentRuntimes, AgentStep, AggregateScoring, ApiErrorSchema, ArtifactEntry, ArtifactEntrySchema, ArtifactView, AutAdapter, AutContext, AutEvent, AutIdentity, AutIdentitySchema, AutSession, CandidateWorkspace, CheckpointResult, CheckpointResultSchema, DirectoryFixture, DynamicFixture, EvalCatalogEntry, EvalCatalogFixture, EvalDefinition, type EvalMatrix, type EvalMatrixCell, EvalPolicy, EvalRegistration, EvalRegistry, EvalRegistryMetadata, EvalSuite, EvalSuiteMetadata, type EvalkitConfig, EvaluatorWorkspace, ExpectToolCallStep, FileFixture, Fixture, FixtureContext, FixtureVisibility, InlineFixture, JsonObject, JsonPrimitive, JsonValue, JsonValueSchema, JudgeRule, JudgeRunInfo, JudgeRunInfoSchema, type MatrixSelection, PredicateScorer, RecordedError, RecordedErrorSchema, ReportStore, ResourceKind, ResourceKindSchema, ResourceUri, ResourceUriSchema, RunManifestSchema, RunMetadata, RunMetadataSchema, RunResult, RunStatus, RunStatusSchema, RunSummary, RunSummarySchema, RunWriter, RunnerEvent, ScoreResult, ScoreResultSchema, ScoreValue, ScoringContext, ScoringRule, TrajectoryEvent, TrajectoryEventSchema, TranscriptStep, TrialManifestSchema, TrialMetadata, TrialMetadataSchema, TrialResult, TrialScoring, TrialScoringSchema, TrialSummary, TrialSummarySchema, TrialWriter, TurnView, Usage, UsageSchema, UserStep, Uuid, UuidSchema, WorkspaceView, agent, authorId, authoringId, canonicalParameters, defineAgent, defineConfig, defineEval, defineEvalMatrix, defineSuite, directory, dynamic, expectToolCall, file, inlineFile, judge, parseResourceUri, parseTrajectoryJsonl, predicate, recordError, registerEvals, resourceUri, resourceUriSchema, resourceUuid, user };
+export { AgentRuntime, AgentRuntimeName, AgentRuntimes, AgentStep, AggregateScoring, ApiErrorSchema, ArtifactEntry, ArtifactEntrySchema, ArtifactView, AutAdapter, AutContext, AutEvent, AutIdentity, AutIdentitySchema, AutSession, CandidateWorkspace, CheckpointResult, CheckpointResultSchema, DirectoryFixture, DynamicFixture, EvalCatalogEntry, EvalCatalogFixture, EvalDefinition, type EvalMatrix, type EvalMatrixCell, EvalPolicy, EvalRegistration, EvalRegistry, EvalRegistryMetadata, EvalSuite, EvalSuiteMetadata, type EvalkitConfig, EvaluatorWorkspace, ExpectToolCallStep, FileFixture, Fixture, FixtureContext, FixtureVisibility, InlineFixture, JsonObject, JsonPrimitive, JsonValue, JsonValueSchema, JudgeRule, JudgeRunInfo, JudgeRunInfoSchema, type MatrixSelection, PredicateScorer, RecordedError, RecordedErrorSchema, ReportStore, ResourceKind, ResourceKindSchema, ResourceUri, ResourceUriSchema, RunCatalog, RunManifestSchema, RunMetadata, RunMetadataSchema, RunResult, RunSource, RunSourceSchema, RunStatus, RunStatusSchema, RunSummary, RunSummarySchema, RunWriter, RunnerEvent, ScoreResult, ScoreResultSchema, ScoreValue, ScoringContext, ScoringRule, TrajectoryEvent, TrajectoryEventSchema, TranscriptStep, TrialManifestSchema, TrialMetadata, TrialMetadataSchema, TrialResult, TrialScoring, TrialScoringSchema, TrialSummary, TrialSummarySchema, TrialWriter, TurnView, Usage, UsageSchema, UserStep, Uuid, UuidSchema, WorkspaceView, agent, authorId, authoringId, canonicalParameters, defineAgent, defineConfig, defineEval, defineEvalMatrix, defineSuite, directory, dynamic, expectToolCall, file, inlineFile, judge, parseResourceUri, parseTrajectoryJsonl, predicate, recordError, registerEvals, resourceUri, resourceUriSchema, resourceUuid, user };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as TrialManifestSchema, B as authorId, C as RecordedErrorSchema, D as RunSummarySchema, E as RunStatusSchema, F as defineEvalMatrix, H as resourceUri, I as canonicalParameters, L as ResourceKindSchema, M as TrialScoringSchema, N as TrialSummarySchema, O as ScoreResultSchema, P as UsageSchema, R as ResourceUriSchema, S as JudgeRunInfoSchema, T as RunMetadataSchema, U as resourceUriSchema, V as parseResourceUri, W as resourceUuid, _ as ApiErrorSchema, a as defineSuite, b as CheckpointResultSchema, c as expectToolCall, d as judge, f as predicate, g as parseTrajectoryJsonl, h as user, i as defineEval, j as TrialMetadataSchema, k as TrajectoryEventSchema, l as file, m as registerEvals, n as authoringId, o as directory, p as recordError, r as defineAgent, s as dynamic, t as agent, u as inlineFile, v as ArtifactEntrySchema, w as RunManifestSchema, x as JsonValueSchema, y as AutIdentitySchema, z as UuidSchema } from "./src-DrwwgaPn.mjs";
+import { A as TrajectoryEventSchema, B as UuidSchema, C as RecordedErrorSchema, D as RunStatusSchema, E as RunSourceSchema, F as UsageSchema, G as resourceUuid, H as parseResourceUri, I as defineEvalMatrix, L as canonicalParameters, M as TrialMetadataSchema, N as TrialScoringSchema, O as RunSummarySchema, P as TrialSummarySchema, R as ResourceKindSchema, S as JudgeRunInfoSchema, T as RunMetadataSchema, U as resourceUri, V as authorId, W as resourceUriSchema, _ as ApiErrorSchema, a as defineSuite, b as CheckpointResultSchema, c as expectToolCall, d as judge, f as predicate, g as parseTrajectoryJsonl, h as user, i as defineEval, j as TrialManifestSchema, k as ScoreResultSchema, l as file, m as registerEvals, n as authoringId, o as directory, p as recordError, r as defineAgent, s as dynamic, t as agent, u as inlineFile, v as ArtifactEntrySchema, w as RunManifestSchema, x as JsonValueSchema, y as AutIdentitySchema, z as ResourceUriSchema } from "./src-ButXPY8P.mjs";
 //#region ../core/src/config.ts
 /** Pure, typed project configuration. Loading/discovery belongs to the CLI. */
 function defineConfig(configuration) {
@@ -74,6 +74,6 @@ function piAgent(options = {}) {
 	});
 }
 //#endregion
-export { ApiErrorSchema, ArtifactEntrySchema, AutIdentitySchema, CheckpointResultSchema, JsonValueSchema, JudgeRunInfoSchema, RecordedErrorSchema, ResourceKindSchema, ResourceUriSchema, RunManifestSchema, RunMetadataSchema, RunStatusSchema, RunSummarySchema, ScoreResultSchema, TrajectoryEventSchema, TrialManifestSchema, TrialMetadataSchema, TrialScoringSchema, TrialSummarySchema, UsageSchema, UuidSchema, agent, authorId, authoringId, canonicalParameters, defineAgent, defineConfig, defineEval, defineEvalMatrix, defineSuite, directory, dynamic, expectToolCall, file, inlineFile, judge, parseResourceUri, parseTrajectoryJsonl, piAgent, predicate, recordError, registerEvals, resourceUri, resourceUriSchema, resourceUuid, user };
+export { ApiErrorSchema, ArtifactEntrySchema, AutIdentitySchema, CheckpointResultSchema, JsonValueSchema, JudgeRunInfoSchema, RecordedErrorSchema, ResourceKindSchema, ResourceUriSchema, RunManifestSchema, RunMetadataSchema, RunSourceSchema, RunStatusSchema, RunSummarySchema, ScoreResultSchema, TrajectoryEventSchema, TrialManifestSchema, TrialMetadataSchema, TrialScoringSchema, TrialSummarySchema, UsageSchema, UuidSchema, agent, authorId, authoringId, canonicalParameters, defineAgent, defineConfig, defineEval, defineEvalMatrix, defineSuite, directory, dynamic, expectToolCall, file, inlineFile, judge, parseResourceUri, parseTrajectoryJsonl, piAgent, predicate, recordError, registerEvals, resourceUri, resourceUriSchema, resourceUuid, user };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../core/src/config.ts","../../agents/src/index.ts"],"sourcesContent":["import type { EvalDefinition, EvalRegistry } from './index.js';\nimport type { EvalMatrixDefinition } from './matrix.js';\n\nexport type EvalkitConfig = {\n  /** Paths are relative to evalkit.config.js/ts, not the invoking shell directory. */\n  testDir?: string;\n  include?: readonly string[];\n  exclude?: readonly string[];\n  /** Explicit definitions are an alternative to discovery (e.g. hosted registries). */\n  evals?: readonly EvalDefinition[];\n  registry?: EvalRegistry;\n  /** Applied to every discovered eval. Values are forwarded, never provider-interpreted. */\n  matrix?: Omit<EvalMatrixDefinition, 'evals' | 'id'> & { id?: string };\n  execution?: { concurrency?: number; trials?: number; maxCells?: number };\n  reportDir?: string;\n  sandboxDir?: string;\n};\n\n/** Pure, typed project configuration. Loading/discovery belongs to the CLI. */\nexport function defineConfig<const T extends EvalkitConfig>(\n  configuration: T,\n): T {\n  return configuration;\n}\n","import { defineAgent, type AutAdapter } from '@evalkit/core';\n\nexport type AgentsSdkAutOptions = {\n  endpoint: string;\n  agent: string;\n  getToken?: () => Promise<string | undefined> | string | undefined;\n  instanceName?: (context: { runId: string; trialId: string }) => string;\n};\n\n/** Deferred remote Agents SDK transport. */\nexport function agentsSdk(_options: AgentsSdkAutOptions): AutAdapter {\n  throw new Error('Agents SDK transport is not implemented yet');\n}\n\nexport type PiAutOptions = {\n  command?: string;\n  /** Additional non-secret Pi arguments, such as an explicit model selection. */\n  args?: string[];\n};\n\n/** A local, one-prompt-per-turn AUT backed by Pi's non-interactive print mode. */\nexport function piAgent(options: PiAutOptions = {}): AutAdapter {\n  const command = options.command ?? 'pi';\n  return defineAgent({\n    identity: {\n      name: 'Pi Agent',\n      kind: 'process',\n      id: 'pi-agent',\n    },\n    runtimes: { local: { kind: 'process', configuration: { command } } },\n    async start({ context, onEvent }) {\n      await onEvent({ kind: 'started', timestamp: new Date().toISOString() });\n      let turn = 0;\n      return {\n        async send(message: string) {\n          turn += 1;\n          await onEvent({\n            kind: 'turn-started',\n            turn,\n            timestamp: new Date().toISOString(),\n          });\n          const process = Bun.spawn(\n            [\n              command,\n              '--print',\n              '--no-session',\n              '--no-tools',\n              ...(options.args ?? []),\n              message,\n            ],\n            { cwd: context.workspace.root, stdout: 'pipe', stderr: 'pipe' },\n          );\n          const [stdout, stderr, exitCode] = await Promise.all([\n            new Response(process.stdout).text(),\n            new Response(process.stderr).text(),\n            process.exited,\n          ]);\n          if (exitCode !== 0)\n            throw new Error(`Pi exited with ${exitCode}: ${stderr.trim()}`);\n          await onEvent({\n            kind: 'message',\n            role: 'assistant',\n            content: stdout.trim(),\n            timestamp: new Date().toISOString(),\n          });\n          await onEvent({\n            kind: 'turn-completed',\n            turn,\n            timestamp: new Date().toISOString(),\n          });\n        },\n        async close() {\n          await onEvent({\n            kind: 'completed',\n            timestamp: new Date().toISOString(),\n          });\n        },\n      };\n    },\n  });\n}\n"],"mappings":";;;AAmBA,SAAgB,aACd,eACG;CACH,OAAO;AACT;;;;ACFA,SAAgB,QAAQ,UAAwB,CAAC,GAAe;CAC9D,MAAM,UAAU,QAAQ,WAAW;CACnC,OAAO,YAAY;EACjB,UAAU;GACR,MAAM;GACN,MAAM;GACN,IAAI;EACN;EACA,UAAU,EAAE,OAAO;GAAE,MAAM;GAAW,eAAe,EAAE,QAAQ;EAAE,EAAE;EACnE,MAAM,MAAM,EAAE,SAAS,WAAW;GAChC,MAAM,QAAQ;IAAE,MAAM;IAAW,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;GAAE,CAAC;GACtE,IAAI,OAAO;GACX,OAAO;IACL,MAAM,KAAK,SAAiB;KAC1B,QAAQ;KACR,MAAM,QAAQ;MACZ,MAAM;MACN;MACA,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;KACD,MAAM,UAAU,IAAI,MAClB;MACE;MACA;MACA;MACA;MACA,GAAI,QAAQ,QAAQ,CAAC;MACrB;KACF,GACA;MAAE,KAAK,QAAQ,UAAU;MAAM,QAAQ;MAAQ,QAAQ;KAAO,CAChE;KACA,MAAM,CAAC,QAAQ,QAAQ,YAAY,MAAM,QAAQ,IAAI;MACnD,IAAI,SAAS,QAAQ,MAAM,CAAC,CAAC,KAAK;MAClC,IAAI,SAAS,QAAQ,MAAM,CAAC,CAAC,KAAK;MAClC,QAAQ;KACV,CAAC;KACD,IAAI,aAAa,GACf,MAAM,IAAI,MAAM,kBAAkB,SAAS,IAAI,OAAO,KAAK,GAAG;KAChE,MAAM,QAAQ;MACZ,MAAM;MACN,MAAM;MACN,SAAS,OAAO,KAAK;MACrB,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;KACD,MAAM,QAAQ;MACZ,MAAM;MACN;MACA,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;IACH;IACA,MAAM,QAAQ;KACZ,MAAM,QAAQ;MACZ,MAAM;MACN,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;IACH;GACF;EACF;CACF,CAAC;AACH"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../core/src/config.ts","../../agents/src/index.ts"],"sourcesContent":["import type { EvalDefinition, EvalRegistry } from './index.js';\nimport type { EvalMatrixDefinition } from './matrix.js';\n\nexport type EvalkitConfig = {\n  /** Paths are relative to evalkit.config.js/ts, not the invoking shell directory. */\n  testDir?: string;\n  include?: readonly string[];\n  exclude?: readonly string[];\n  /** Explicit definitions are an alternative to discovery (e.g. hosted registries). */\n  evals?: readonly EvalDefinition[];\n  registry?: EvalRegistry;\n  /** Applied to every discovered eval. Values are forwarded, never provider-interpreted. */\n  matrix?: Omit<EvalMatrixDefinition, 'evals' | 'id'> & { id?: string };\n  execution?: { concurrency?: number; trials?: number; maxCells?: number };\n  reportDir?: string;\n  sandboxDir?: string;\n  /** Where `evalkit share` uploads results. `EVALKIT_SHARE_URL` overrides it. */\n  share?: { url: string };\n};\n\n/** Pure, typed project configuration. Loading/discovery belongs to the CLI. */\nexport function defineConfig<const T extends EvalkitConfig>(\n  configuration: T,\n): T {\n  return configuration;\n}\n","import { defineAgent, type AutAdapter } from '@evalkit/core';\n\nexport type AgentsSdkAutOptions = {\n  endpoint: string;\n  agent: string;\n  getToken?: () => Promise<string | undefined> | string | undefined;\n  instanceName?: (context: { runId: string; trialId: string }) => string;\n};\n\n/** Deferred remote Agents SDK transport. */\nexport function agentsSdk(_options: AgentsSdkAutOptions): AutAdapter {\n  throw new Error('Agents SDK transport is not implemented yet');\n}\n\nexport type PiAutOptions = {\n  command?: string;\n  /** Additional non-secret Pi arguments, such as an explicit model selection. */\n  args?: string[];\n};\n\n/** A local, one-prompt-per-turn AUT backed by Pi's non-interactive print mode. */\nexport function piAgent(options: PiAutOptions = {}): AutAdapter {\n  const command = options.command ?? 'pi';\n  return defineAgent({\n    identity: {\n      name: 'Pi Agent',\n      kind: 'process',\n      id: 'pi-agent',\n    },\n    runtimes: { local: { kind: 'process', configuration: { command } } },\n    async start({ context, onEvent }) {\n      await onEvent({ kind: 'started', timestamp: new Date().toISOString() });\n      let turn = 0;\n      return {\n        async send(message: string) {\n          turn += 1;\n          await onEvent({\n            kind: 'turn-started',\n            turn,\n            timestamp: new Date().toISOString(),\n          });\n          const process = Bun.spawn(\n            [\n              command,\n              '--print',\n              '--no-session',\n              '--no-tools',\n              ...(options.args ?? []),\n              message,\n            ],\n            { cwd: context.workspace.root, stdout: 'pipe', stderr: 'pipe' },\n          );\n          const [stdout, stderr, exitCode] = await Promise.all([\n            new Response(process.stdout).text(),\n            new Response(process.stderr).text(),\n            process.exited,\n          ]);\n          if (exitCode !== 0)\n            throw new Error(`Pi exited with ${exitCode}: ${stderr.trim()}`);\n          await onEvent({\n            kind: 'message',\n            role: 'assistant',\n            content: stdout.trim(),\n            timestamp: new Date().toISOString(),\n          });\n          await onEvent({\n            kind: 'turn-completed',\n            turn,\n            timestamp: new Date().toISOString(),\n          });\n        },\n        async close() {\n          await onEvent({\n            kind: 'completed',\n            timestamp: new Date().toISOString(),\n          });\n        },\n      };\n    },\n  });\n}\n"],"mappings":";;;AAqBA,SAAgB,aACd,eACG;CACH,OAAO;AACT;;;;ACJA,SAAgB,QAAQ,UAAwB,CAAC,GAAe;CAC9D,MAAM,UAAU,QAAQ,WAAW;CACnC,OAAO,YAAY;EACjB,UAAU;GACR,MAAM;GACN,MAAM;GACN,IAAI;EACN;EACA,UAAU,EAAE,OAAO;GAAE,MAAM;GAAW,eAAe,EAAE,QAAQ;EAAE,EAAE;EACnE,MAAM,MAAM,EAAE,SAAS,WAAW;GAChC,MAAM,QAAQ;IAAE,MAAM;IAAW,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;GAAE,CAAC;GACtE,IAAI,OAAO;GACX,OAAO;IACL,MAAM,KAAK,SAAiB;KAC1B,QAAQ;KACR,MAAM,QAAQ;MACZ,MAAM;MACN;MACA,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;KACD,MAAM,UAAU,IAAI,MAClB;MACE;MACA;MACA;MACA;MACA,GAAI,QAAQ,QAAQ,CAAC;MACrB;KACF,GACA;MAAE,KAAK,QAAQ,UAAU;MAAM,QAAQ;MAAQ,QAAQ;KAAO,CAChE;KACA,MAAM,CAAC,QAAQ,QAAQ,YAAY,MAAM,QAAQ,IAAI;MACnD,IAAI,SAAS,QAAQ,MAAM,CAAC,CAAC,KAAK;MAClC,IAAI,SAAS,QAAQ,MAAM,CAAC,CAAC,KAAK;MAClC,QAAQ;KACV,CAAC;KACD,IAAI,aAAa,GACf,MAAM,IAAI,MAAM,kBAAkB,SAAS,IAAI,OAAO,KAAK,GAAG;KAChE,MAAM,QAAQ;MACZ,MAAM;MACN,MAAM;MACN,SAAS,OAAO,KAAK;MACrB,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;KACD,MAAM,QAAQ;MACZ,MAAM;MACN;MACA,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;IACH;IACA,MAAM,QAAQ;KACZ,MAAM,QAAQ;MACZ,MAAM;MACN,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;KACpC,CAAC;IACH;GACF;EACF;CACF,CAAC;AACH"}

package/dist/runner.d.mts

@@ -1,4 +1,4 @@
-import { B as ReportStore, F as JsonValue, Gt as EvalMatrixCell, H as RunResult, Kt as MatrixSelection, N as JsonObject, V as RunMetadata, Wt as EvalMatrix, Z as TrajectoryEvent, n as AgentRuntimeName, y as EvalDefinition } from "./index-M5eRlMfd.mjs";
+import { $ as TrajectoryEvent, B as ReportStore, F as JsonValue, H as RunMetadata, Jt as EvalMatrixCell, N as JsonObject, U as RunResult, V as RunCatalog, W as RunSource, Yt as MatrixSelection, n as AgentRuntimeName, qt as EvalMatrix, y as EvalDefinition } from "./index-U6TUTBf7.mjs";
 import { Effect } from "effect";
 //#region ../runner/src/errors.d.ts
 declare const AutExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -45,7 +45,7 @@ export declare function localReportStore(rootDirectory: string): ReportStore;
 //#endregion
 //#region ../runner/src/local-report-reader.d.ts
 export declare const readRunManifest: (root: string, runId: string) => Promise<{
-  readonly schemaVersion: 2 | 3;
+  readonly schemaVersion: 2 | 3 | 4;
   readonly runUri: string;
   readonly evalId: string;
   readonly suiteId?: string | undefined;
@@ -63,6 +63,20 @@ export declare const readRunManifest: (root: string, runId: string) => Promise<{
     readonly version?: string | undefined;
   } | undefined;
   readonly startedAt: string;
+  readonly source?: {
+    readonly repo: string;
+    readonly project: string;
+    readonly commit: string;
+    readonly ref?: string | undefined;
+    readonly committedAt?: string | undefined;
+    readonly dirty: boolean;
+    readonly ci?: {
+      readonly provider: string;
+      readonly pipeline?: string | undefined;
+      readonly job?: string | undefined;
+      readonly url?: string | undefined;
+    } | undefined;
+  } | undefined;
   readonly status?: "cancelled" | "completed" | "failed" | "running" | undefined;
 }>;
 export declare const readRunSummary: (root: string, runId: string) => Promise<{
@@ -79,7 +93,7 @@ export declare const readRunSummary: (root: string, runId: string) => Promise<{
   } | undefined;
 }>;
 export declare const readTrialManifest: (root: string, runId: string, trialId: string) => Promise<{
-  readonly schemaVersion: 2 | 3;
+  readonly schemaVersion: 2 | 3 | 4;
   readonly runUri: string;
   readonly trialUri: string;
   readonly trialIndex: number;
@@ -282,6 +296,10 @@ export type RunEvalOptions = {
   semaphore?: Effect.Semaphore;
   /** Base directory for persistent local trial workspaces. Omit for an ephemeral OS temp workspace. */
   workspaceRoot?: string;
+  /** Repository and commit the eval code came from, recorded in the manifest. */
+  source?: RunSource;
+  /** The project's evals and suites at run time, saved beside the manifest. */
+  catalog?: RunCatalog;
   now?: () => Date;
 };
 /** Effect-native aggregate eval execution entry point. */

package/dist/runner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.mts","names":["_$_evalkit_core0.JsonValue","_$_evalkit_core0.TrajectoryEvent"],"sources":["../../runner/src/errors.ts","../../runner/src/local-report-store.ts","../../runner/src/local-report-reader.ts","../../runner/src/matrix.ts","../../runner/src/index.ts"],"mappings":";;;;;;qBAEa,0BAA0B;EACrC;EACA;;;;;qBAGW,qBAAqB;EAChC;EACA;;;;;qBAGW,oBAAoB;EAC/B;EACA;;;;;qBAGW,qBAAqB;EAChC;EACA;;;;;qBASW,iCAAiC;EAG5C;EACA;EACA;EACA;;;;;wBCmGc,iBAAiB,wBAAwB;;;qBC/G5C,kBAAe,cAAgB,kBAAe;;;;;;0BAA9CA;;;;;;;;;;;;;;;qBAEA,iBAAc,cAAgB,kBAAe;;;;;;;;;;;;;qBAE7C,oBAAiB,cAChB,eACC,oBACE;;;;;;;0BAHJA;;;;;;;;;;;;;;;qBASA,mBAAgB,cACf,eACC,oBACE;;;;;;;;;;;0BAHJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBASA,mBAAgB,cACf,eACC,oBACE;;;;;;;wBAHJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBASS,gBACpB,cACA,eACA,kBAAe,QAHKC;;;;wBC3CN,UACd,QAAQ,YACR,SAAS,KACP;EAGA,YAAY;EACZ,YACE,MAAM,gBACN,QAAQ,qBACE;IAEb,OAAO;EAAS;EAAe;EAAgB;;;;YCoBtC;EACV,QAAQ;EACR;EACA;EACA;;EAEA;;EAEA,aAAa;;EAEb,SAAS;;EAET,UAAU;;EAEV;;EAEA,YAAY,OAAO;;EAEnB;EACA,YAAY;;;wBASE,QACd,YAAY,gBACZ,SAAS,iBACR,OAAO,OAAO"}
+{"version":3,"file":"runner.d.mts","names":["_$_evalkit_core0.JsonValue","_$_evalkit_core0.TrajectoryEvent"],"sources":["../../runner/src/errors.ts","../../runner/src/local-report-store.ts","../../runner/src/local-report-reader.ts","../../runner/src/matrix.ts","../../runner/src/index.ts"],"mappings":";;;;;;qBAEa,0BAA0B;EACrC;EACA;;;;;qBAGW,qBAAqB;EAChC;EACA;;;;;qBAGW,oBAAoB;EAC/B;EACA;;;;;qBAGW,qBAAqB;EAChC;EACA;;;;;qBASW,iCAAiC;EAG5C;EACA;EACA;EACA;;;;;wBCqGc,iBAAiB,wBAAwB;;;qBCjH5C,kBAAe,cAAgB,kBAAe;;;;;;0BAA9CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEA,iBAAc,cAAgB,kBAAe;;;;;;;;;;;;;qBAE7C,oBAAiB,cAChB,eACC,oBACE;;;;;;;0BAHJA;;;;;;;;;;;;;;;qBASA,mBAAgB,cACf,eACC,oBACE;;;;;;;;;;;0BAHJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBASA,mBAAgB,cACf,eACC,oBACE;;;;;;;wBAHJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBASS,gBACpB,cACA,eACA,kBAAe,QAHKC;;;;wBC3CN,UACd,QAAQ,YACR,SAAS,KACP;EAGA,YAAY;EACZ,YACE,MAAM,gBACN,QAAQ,qBACE;IAEb,OAAO;EAAS;EAAe;EAAgB;;;;YCsBtC;EACV,QAAQ;EACR;EACA;EACA;;EAEA;;EAEA,aAAa;;EAEb,SAAS;;EAET,UAAU;;EAEV;;EAEA,YAAY,OAAO;;EAEnB;;EAEA,SAAS;;EAET,UAAU;EACV,YAAY;;;wBASE,QACd,YAAY,gBACZ,SAAS,iBACR,OAAO,OAAO"}

package/dist/runner.mjs

@@ -1,2 +1,2 @@
-import { a as readTrialEvents, c as readTrialSummary, d as CheckpointExecutionError, f as FixtureError, i as readRunSummary, l as localReportStore, m as ScoringError, n as runMatrix, o as readTrialManifest, p as ReportError, r as readRunManifest, s as readTrialScoring, t as runEval, u as AutExecutionError } from "./src-DluldGKn.mjs";
+import { a as readTrialEvents, c as readTrialSummary, d as CheckpointExecutionError, f as FixtureError, i as readRunSummary, l as localReportStore, m as ScoringError, n as runMatrix, o as readTrialManifest, p as ReportError, r as readRunManifest, s as readTrialScoring, t as runEval, u as AutExecutionError } from "./src-DoPs9Yug.mjs";
 export { AutExecutionError, CheckpointExecutionError, FixtureError, ReportError, ScoringError, localReportStore, readRunManifest, readRunSummary, readTrialEvents, readTrialManifest, readTrialScoring, readTrialSummary, runEval, runMatrix };

package/dist/share-worker.d.mts

@@ -0,0 +1,51 @@
+import { h as R2BucketLike, o as SqlValue, r as ShareIndex } from "./index-db-HdZXelOS.mjs";
+//#region ../share/src/index-do.d.ts
+/** The subset of Durable Object state used by the index. */
+type DurableObjectStateLike = {
+  storage: {
+    sql: {
+      exec(query: string, ...params: SqlValue[]): {
+        toArray(): unknown[];
+      };
+    };
+    transactionSync<T>(work: () => T): T;
+  };
+};
+type DurableObjectNamespaceLike = {
+  idFromName(name: string): unknown;
+  get(id: unknown): {
+    fetch(request: Request): Promise<Response>;
+  };
+};
+/**
+ * One SQLite-backed Durable Object holds the whole index. It serializes every
+ * write, so concurrent uploads for the same commit never race.
+ * Bind it with `new_sqlite_classes: ["ShareIndex"]`.
+ */
+declare class ShareIndexObject {
+  private readonly db;
+  constructor(state: DurableObjectStateLike);
+  fetch(request: Request): Promise<Response>;
+}
+/** The Worker's view of the index: each call is one request to the object. */
+declare function durableObjectIndex(namespace: DurableObjectNamespaceLike): ShareIndex;
+//#endregion
+//#region ../share/src/worker.d.ts
+/**
+ * Bindings for a share server Worker (see `wrangler.jsonc` in this package):
+ * RESULTS (R2), INDEX (SQLite Durable Object, class ShareIndex), and ASSETS
+ * (static assets: the bundled dashboard, with `run_worker_first: true`).
+ */
+type ShareEnv = {
+  RESULTS: R2BucketLike;
+  INDEX: Parameters<typeof durableObjectIndex>[0];
+  ASSETS: {
+    fetch(request: Request): Promise<Response>;
+  };
+};
+declare const _default: {
+  fetch(request: Request, env: ShareEnv): Promise<Response> | Response;
+};
+//#endregion
+export { type ShareEnv, ShareIndexObject as ShareIndex, _default as default };
+//# sourceMappingURL=share-worker.d.mts.map

package/dist/share-worker.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-worker.d.mts","names":[],"sources":["../../share/src/index-do.ts","../../share/src/worker.ts"],"mappings":";;;KAGK;EACH;IACE;MACE,KAAK,kBAAkB,QAAQ;QAAe;;;IAEhD,gBAAgB,GAAG,YAAY,IAAI;;;KAIlC;EACH,WAAW;EACX,IAAI;IAAgB,MAAM,SAAS,UAAU,QAAQ;;;;;;;;cAmB1C;mBACM;EAEjB,YAAY,OAAO;EAYb,MAAM,SAAS,UAAU,QAAQ;;;iBAezB,mBACd,WAAW,6BACV;;;;;;;;KCtDS;EACV,SAAS;EACT,OAAO,kBAAkB;EACzB;IAAU,MAAM,SAAS,UAAU,QAAQ;;;;EAI3C,MAAK,SAAU,SAAO,KAAO,WAAW,QAAQ,YAAY"}

package/dist/share-worker.mjs

@@ -0,0 +1,73 @@
+import { r as createShareApp, t as ShareIndexDb } from "./index-db-vbqEGFaU.mjs";
+import { t as r2Files } from "./files-C-U0-PWW.mjs";
+//#region ../share/src/index-do.ts
+const METHODS = [
+	"hasRun",
+	"recordRun",
+	"repos",
+	"commits",
+	"runs",
+	"resolve",
+	"latest"
+];
+/**
+* One SQLite-backed Durable Object holds the whole index. It serializes every
+* write, so concurrent uploads for the same commit never race.
+* Bind it with `new_sqlite_classes: ["ShareIndex"]`.
+*/
+var ShareIndexObject = class {
+	db;
+	constructor(state) {
+		const { sql } = state.storage;
+		this.db = new ShareIndexDb({
+			all: (query, ...params) => sql.exec(query, ...params).toArray(),
+			run: (query, ...params) => {
+				sql.exec(query, ...params);
+			},
+			transaction: (work) => state.storage.transactionSync(work)
+		});
+	}
+	async fetch(request) {
+		const { method, args } = await request.json();
+		if (!METHODS.includes(method)) return new Response(`Unknown index method: ${String(method)}`, { status: 400 });
+		const call = this.db[method];
+		return Response.json({ result: call.apply(this.db, args) ?? null });
+	}
+};
+/** The Worker's view of the index: each call is one request to the object. */
+function durableObjectIndex(namespace) {
+	const stub = namespace.get(namespace.idFromName("index"));
+	const call = async (method, ...args) => {
+		const response = await stub.fetch(new Request("https://share-index/rpc", {
+			method: "POST",
+			body: JSON.stringify({
+				method,
+				args
+			})
+		}));
+		if (!response.ok) throw new Error(`Index ${method} failed: ${await response.text()}`);
+		const { result } = await response.json();
+		return result ?? void 0;
+	};
+	return Object.fromEntries(METHODS.map((method) => [method, (...args) => call(method, ...args)]));
+}
+//#endregion
+//#region ../share/src/worker.ts
+var worker_default = { fetch(request, env) {
+	const asset = (path) => env.ASSETS.fetch(new Request(new URL(path, "https://assets.local")));
+	return createShareApp({
+		files: r2Files(env.RESULTS),
+		index: durableObjectIndex(env.INDEX),
+		assets: {
+			index: async () => (await asset("/")).text(),
+			get: async (path) => {
+				const response = await asset(`/assets/${path}`);
+				return response.ok ? response : null;
+			}
+		}
+	}).fetch(request);
+} };
+//#endregion
+export { ShareIndexObject as ShareIndex, worker_default as default };
+
+//# sourceMappingURL=share-worker.mjs.map

package/dist/share-worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-worker.mjs","names":[],"sources":["../../share/src/index-do.ts","../../share/src/worker.ts"],"sourcesContent":["import { ShareIndexDb, type ShareIndex, type SqlValue } from './index-db.js';\n\n/** The subset of Durable Object state used by the index. */\ntype DurableObjectStateLike = {\n  storage: {\n    sql: {\n      exec(query: string, ...params: SqlValue[]): { toArray(): unknown[] };\n    };\n    transactionSync<T>(work: () => T): T;\n  };\n};\n\ntype DurableObjectNamespaceLike = {\n  idFromName(name: string): unknown;\n  get(id: unknown): { fetch(request: Request): Promise<Response> };\n};\n\nconst METHODS = [\n  'hasRun',\n  'recordRun',\n  'repos',\n  'commits',\n  'runs',\n  'resolve',\n  'latest',\n] as const satisfies readonly (keyof ShareIndex)[];\ntype Method = (typeof METHODS)[number];\n\n/**\n * One SQLite-backed Durable Object holds the whole index. It serializes every\n * write, so concurrent uploads for the same commit never race.\n * Bind it with `new_sqlite_classes: [\"ShareIndex\"]`.\n */\nexport class ShareIndexObject {\n  private readonly db: ShareIndexDb;\n\n  constructor(state: DurableObjectStateLike) {\n    const { sql } = state.storage;\n    this.db = new ShareIndexDb({\n      all: <T>(query: string, ...params: SqlValue[]) =>\n        sql.exec(query, ...params).toArray() as T[],\n      run: (query, ...params) => {\n        sql.exec(query, ...params);\n      },\n      transaction: (work) => state.storage.transactionSync(work),\n    });\n  }\n\n  async fetch(request: Request): Promise<Response> {\n    const { method, args } = (await request.json()) as {\n      method: Method;\n      args: unknown[];\n    };\n    if (!METHODS.includes(method))\n      return new Response(`Unknown index method: ${String(method)}`, {\n        status: 400,\n      });\n    const call = this.db[method] as (...values: unknown[]) => unknown;\n    return Response.json({ result: call.apply(this.db, args) ?? null });\n  }\n}\n\n/** The Worker's view of the index: each call is one request to the object. */\nexport function durableObjectIndex(\n  namespace: DurableObjectNamespaceLike,\n): ShareIndex {\n  const stub = namespace.get(namespace.idFromName('index'));\n  const call = async (method: Method, ...args: unknown[]) => {\n    const response = await stub.fetch(\n      new Request('https://share-index/rpc', {\n        method: 'POST',\n        body: JSON.stringify({ method, args }),\n      }),\n    );\n    if (!response.ok)\n      throw new Error(`Index ${method} failed: ${await response.text()}`);\n    const { result } = (await response.json()) as { result: unknown };\n    return result ?? undefined;\n  };\n  return Object.fromEntries(\n    METHODS.map((method) => [\n      method,\n      (...args: unknown[]) => call(method, ...args),\n    ]),\n  ) as unknown as ShareIndex;\n}\n","import { createShareApp } from './app.js';\nimport { r2Files, type R2BucketLike } from './files.js';\nimport { durableObjectIndex } from './index-do.js';\n\nexport { ShareIndexObject as ShareIndex } from './index-do.js';\n\n/**\n * Bindings for a share server Worker (see `wrangler.jsonc` in this package):\n * RESULTS (R2), INDEX (SQLite Durable Object, class ShareIndex), and ASSETS\n * (static assets: the bundled dashboard, with `run_worker_first: true`).\n */\nexport type ShareEnv = {\n  RESULTS: R2BucketLike;\n  INDEX: Parameters<typeof durableObjectIndex>[0];\n  ASSETS: { fetch(request: Request): Promise<Response> };\n};\n\nexport default {\n  fetch(request: Request, env: ShareEnv): Promise<Response> | Response {\n    const asset = (path: string) =>\n      env.ASSETS.fetch(new Request(new URL(path, 'https://assets.local')));\n    const app = createShareApp({\n      files: r2Files(env.RESULTS),\n      index: durableObjectIndex(env.INDEX),\n      assets: {\n        // Static assets redirect /index.html to /, so ask for / directly.\n        index: async () => (await asset('/')).text(),\n        get: async (path) => {\n          const response = await asset(`/assets/${path}`);\n          return response.ok ? response : null;\n        },\n      },\n    });\n    return app.fetch(request);\n  },\n};\n"],"mappings":";;;AAiBA,MAAM,UAAU;CACd;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;AAQA,IAAa,mBAAb,MAA8B;CAC5B;CAEA,YAAY,OAA+B;EACzC,MAAM,EAAE,QAAQ,MAAM;EACtB,KAAK,KAAK,IAAI,aAAa;GACzB,MAAS,OAAe,GAAG,WACzB,IAAI,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,QAAQ;GACrC,MAAM,OAAO,GAAG,WAAW;IACzB,IAAI,KAAK,OAAO,GAAG,MAAM;GAC3B;GACA,cAAc,SAAS,MAAM,QAAQ,gBAAgB,IAAI;EAC3D,CAAC;CACH;CAEA,MAAM,MAAM,SAAqC;EAC/C,MAAM,EAAE,QAAQ,SAAU,MAAM,QAAQ,KAAK;EAI7C,IAAI,CAAC,QAAQ,SAAS,MAAM,GAC1B,OAAO,IAAI,SAAS,yBAAyB,OAAO,MAAM,KAAK,EAC7D,QAAQ,IACV,CAAC;EACH,MAAM,OAAO,KAAK,GAAG;EACrB,OAAO,SAAS,KAAK,EAAE,QAAQ,KAAK,MAAM,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC;CACpE;AACF;;AAGA,SAAgB,mBACd,WACY;CACZ,MAAM,OAAO,UAAU,IAAI,UAAU,WAAW,OAAO,CAAC;CACxD,MAAM,OAAO,OAAO,QAAgB,GAAG,SAAoB;EACzD,MAAM,WAAW,MAAM,KAAK,MAC1B,IAAI,QAAQ,2BAA2B;GACrC,QAAQ;GACR,MAAM,KAAK,UAAU;IAAE;IAAQ;GAAK,CAAC;EACvC,CAAC,CACH;EACA,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,SAAS,OAAO,WAAW,MAAM,SAAS,KAAK,GAAG;EACpE,MAAM,EAAE,WAAY,MAAM,SAAS,KAAK;EACxC,OAAO,UAAU,KAAA;CACnB;CACA,OAAO,OAAO,YACZ,QAAQ,KAAK,WAAW,CACtB,SACC,GAAG,SAAoB,KAAK,QAAQ,GAAG,IAAI,CAC9C,CAAC,CACH;AACF;;;ACpEA,IAAA,iBAAe,EACb,MAAM,SAAkB,KAA6C;CACnE,MAAM,SAAS,SACb,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI,IAAI,MAAM,sBAAsB,CAAC,CAAC;CAarE,OAZY,eAAe;EACzB,OAAO,QAAQ,IAAI,OAAO;EAC1B,OAAO,mBAAmB,IAAI,KAAK;EACnC,QAAQ;GAEN,OAAO,aAAa,MAAM,MAAM,GAAG,EAAA,CAAG,KAAK;GAC3C,KAAK,OAAO,SAAS;IACnB,MAAM,WAAW,MAAM,MAAM,WAAW,MAAM;IAC9C,OAAO,SAAS,KAAK,WAAW;GAClC;EACF;CACF,CACS,CAAC,CAAC,MAAM,OAAO;AAC1B,EACF"}

package/dist/share.d.mts

@@ -0,0 +1,116 @@
+import { _ as r2Files, a as Sql, c as SharedRun, d as BUNDLE_FORMAT, f as BundleFile, g as ShareFiles, h as R2BucketLike, i as ShareIndexDb, l as SharedRunStatus, m as encodeBundle, n as RepoRow, p as decodeBundle, r as ShareIndex, s as asyncIndex, t as CommitRow, u as parseUpload } from "./index-db-HdZXelOS.mjs";
+import { Hono } from "hono";
+//#region ../share/src/app.d.ts
+/** The bundled dashboard: its index.html template and its JS/CSS files. */
+type DashboardAssets = {
+  index(): Promise<string>;
+  get(path: string): Promise<Response | null>;
+};
+/** One structured log event. Bounded fields only; never file contents. */
+type ShareEvent = {
+  event: 'share.upload';
+  outcome: 'created' | 'exists';
+  repo: string;
+  commit: string;
+  runId: string;
+  files: number;
+  bytes: number;
+} | {
+  event: 'share.upload';
+  outcome: 'rejected';
+  reason: string;
+} | {
+  event: 'share.reindex';
+  runs: number;
+  indexed: number;
+} | {
+  event: 'share.error';
+  method: string;
+  path: string;
+  error: string;
+};
+type ShareAppOptions = {
+  files: ShareFiles;
+  index: ShareIndex;
+  assets: DashboardAssets;
+  /** Uncompressed bundle limit; the compressed body must also fit a Worker request. */
+  maxBundleBytes?: number;
+  /** Defaults to one JSON line per event on stdout (Workers Logs indexes these). */
+  log?: (event: ShareEvent) => void;
+};
+/**
+ * The share server: a small JSON API plus the dashboard app. It stores
+ * uploaded run bundles and shows one read-only snapshot per repository commit.
+ *
+ *   POST /api/v1/uploads                         one run bundle
+ *   POST /api/v1/reindex                         rebuild the index from stored run.json files
+ *   GET  /api/v1/repos                           indexed repositories
+ *   GET  /api/v1/repos/<repo>/-/commits          commits, newest first
+ *   GET  /api/v1/repos/<repo>/-/<sha>/data/…     snapshot data
+ *   GET  /assets/*                               dashboard JS/CSS
+ *   GET  /<repo>                                 → latest commit
+ *   GET  /<repo>/-/<ref|prefix>/…                → full SHA
+ *   GET  everything else                         the dashboard app
+ *
+ * There is no authentication: run it on a private network.
+ */
+export declare function createShareApp(options: ShareAppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//#endregion
+//#region ../share/src/fs-files.d.ts
+/** Result files in a directory, for `evalkit share serve` and tests. */
+export declare function directoryFiles(root: string): ShareFiles;
+//#endregion
+//#region ../share/src/html.d.ts
+/**
+ * Turn the dashboard's index.html into a read-only page. The app derives its
+ * router basename from `<base href>`. A static snapshot reads `data/…` below
+ * the base; on the share server, `share` says where the API is.
+ */
+type ShareContext = {
+  /** All repositories: `/api/v1/repos`. */
+  repos: string;
+  /** This repository's commits, for the version picker. */
+  commits?: string;
+  /** This commit's snapshot data (replaces `<base>/data/`). */
+  data?: string;
+  repo?: string;
+  /** A ref or SHA with no shared results. */
+  missing?: string;
+};
+export declare function dashboardIndex(html: string, options: {
+  base: string;
+  assets?: string;
+  share?: ShareContext;
+}): string;
+//#endregion
+//#region ../share/src/index-bun.d.ts
+/** The index in a SQLite file, for `evalkit share serve` and tests. */
+export declare function sqliteIndex(path: string): ShareIndex;
+//#endregion
+//#region ../share/src/node.d.ts
+/** Serve the bundled dashboard from a directory (`dist/dashboard`). */
+export declare function directoryAssets(root: string): DashboardAssets;
+/** A share server on Bun: files and `index.sqlite` live in `dir`. */
+export declare function createDirectoryShareApp(options: {
+  dir: string;
+  dashboardRoot: string;
+}): Promise<import("hono").Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">>;
+//#endregion
+//#region ../share/src/paths.d.ts
+/**
+ * The only files a run bundle may contain (the snapshot format from
+ * `evalkit build`, for one run). Never evaluator workspaces.
+ */
+export declare function allowedRunPath(path: string): boolean;
+/**
+ * Repository key: normalized host/path, plus `/~<project>` for an eval
+ * project below the repository root. Used in storage keys and URLs.
+ */
+export declare function repoKey(source: {
+  repo: string;
+  project: string;
+}): string;
+export declare function validRepoKey(key: string): boolean;
+//#endregion
+export { BUNDLE_FORMAT, type BundleFile, type CommitRow, type DashboardAssets, type R2BucketLike, type RepoRow, type ShareAppOptions, type ShareEvent, type ShareFiles, type ShareIndex, ShareIndexDb, type SharedRun, type SharedRunStatus, type Sql, asyncIndex, decodeBundle, encodeBundle, parseUpload, r2Files };
+//# sourceMappingURL=share.d.mts.map

package/dist/share.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share.d.mts","names":[],"sources":["../../share/src/app.ts","../../share/src/fs-files.ts","../../share/src/html.ts","../../share/src/index-bun.ts","../../share/src/node.ts","../../share/src/paths.ts"],"mappings":";;;;KAiBY;EACV,SAAS;EACT,IAAI,eAAe,QAAQ;;;KAIjB;EAEN;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAuB;EAAqB;;EAC5C;EAAwB;EAAc;;EACtC;EAAsB;EAAgB;EAAc;;KAE9C;EACV,OAAO;EACP,OAAO;EACP,QAAQ;;EAER;;EAEA,OAAO,OAAO;;;;;;;;;;;;;;;;;;wBAiCA,eAAe,SAAS,kBAAe,0BAAA,+BAAA;;;;wBCxEvC,eAAe,eAAe;;;;;;;;KCAlC;;EAEV;;EAEA;;EAEA;EACA;;EAEA;;wBAGc,eACd,cACA;EAAW;EAAc;EAAiB,QAAQ;;;;;wBCfpC,YAAY,eAAe;;;;wBCU3B,gBAAgB,eAAe;;wBAsBzB,wBAAwB;EAC5C;EACA;IACD,uBAAA,0BAAA,+BAAA;;;;;;;wBCfe,eAAe;;;;;wBAef,QAAQ;EAAU;EAAc;;wBAIhC,aAAa"}

package/dist/share.mjs

@@ -0,0 +1,4 @@
+import { a as allowedRunPath, c as dashboardIndex, d as encodeBundle, i as parseUpload, l as BUNDLE_FORMAT, n as asyncIndex, o as repoKey, r as createShareApp, s as validRepoKey, t as ShareIndexDb, u as decodeBundle } from "./index-db-vbqEGFaU.mjs";
+import { t as r2Files } from "./files-C-U0-PWW.mjs";
+import { i as directoryFiles, n as directoryAssets, r as sqliteIndex, t as createDirectoryShareApp } from "./src-DzZueFn3.mjs";
+export { BUNDLE_FORMAT, ShareIndexDb, allowedRunPath, asyncIndex, createDirectoryShareApp, createShareApp, dashboardIndex, decodeBundle, directoryAssets, directoryFiles, encodeBundle, parseUpload, r2Files, repoKey, sqliteIndex, validRepoKey };

package/dist/{src-DrwwgaPn.mjs → src-ButXPY8P.mjs}

@@ -202,18 +202,33 @@ const MatrixCellSchema = Schema.Struct({
 	id: Schema.String,
 	cellKey: Schema.String
 });
+const RunSourceSchema = Schema.Struct({
+	repo: Schema.String,
+	project: Schema.String,
+	commit: Schema.String,
+	ref: Schema.optional(Schema.String),
+	committedAt: Schema.optional(Schema.String),
+	dirty: Schema.Boolean,
+	ci: Schema.optional(Schema.Struct({
+		provider: Schema.String,
+		pipeline: Schema.optional(Schema.String),
+		job: Schema.optional(Schema.String),
+		url: Schema.optional(Schema.String)
+	}))
+});
 const RunMetadataSchema = Schema.Struct({
-	schemaVersion: Schema.Literal(2, 3),
+	schemaVersion: Schema.Literal(2, 3, 4),
 	runUri: resourceUriSchema("run"),
 	evalId: Schema.String,
 	suiteId: Schema.optional(Schema.String),
 	parameters: Schema.optional(ParametersSchema),
 	matrix: Schema.optional(MatrixCellSchema),
 	aut: Schema.optional(AutIdentitySchema),
-	startedAt: Schema.String
+	startedAt: Schema.String,
+	source: Schema.optional(RunSourceSchema)
 });
 const TrialMetadataSchema = Schema.Struct({
-	schemaVersion: Schema.Literal(2, 3),
+	schemaVersion: Schema.Literal(2, 3, 4),
 	runUri: resourceUriSchema("run"),
 	trialUri: resourceUriSchema("trial"),
 	trialIndex: Schema.Number,
@@ -671,6 +686,6 @@ function recordError(error) {
 	};
 }
 //#endregion
-export { TrialManifestSchema as A, authorId as B, RecordedErrorSchema as C, RunSummarySchema as D, RunStatusSchema as E, defineEvalMatrix as F, resourceUri as H, canonicalParameters as I, ResourceKindSchema as L, TrialScoringSchema as M, TrialSummarySchema as N, ScoreResultSchema as O, UsageSchema as P, ResourceUriSchema as R, JudgeRunInfoSchema as S, RunMetadataSchema as T, resourceUriSchema as U, parseResourceUri as V, resourceUuid as W, ApiErrorSchema as _, defineSuite as a, CheckpointResultSchema as b, expectToolCall as c, judge as d, predicate as f, parseTrajectoryJsonl as g, user as h, defineEval as i, TrialMetadataSchema as j, TrajectoryEventSchema as k, file as l, registerEvals as m, authoringId as n, directory as o, recordError as p, defineAgent as r, dynamic as s, agent as t, inlineFile as u, ArtifactEntrySchema as v, RunManifestSchema as w, JsonValueSchema as x, AutIdentitySchema as y, UuidSchema as z };
+export { TrajectoryEventSchema as A, UuidSchema as B, RecordedErrorSchema as C, RunStatusSchema as D, RunSourceSchema as E, UsageSchema as F, resourceUuid as G, parseResourceUri as H, defineEvalMatrix as I, canonicalParameters as L, TrialMetadataSchema as M, TrialScoringSchema as N, RunSummarySchema as O, TrialSummarySchema as P, ResourceKindSchema as R, JudgeRunInfoSchema as S, RunMetadataSchema as T, resourceUri as U, authorId as V, resourceUriSchema as W, ApiErrorSchema as _, defineSuite as a, CheckpointResultSchema as b, expectToolCall as c, judge as d, predicate as f, parseTrajectoryJsonl as g, user as h, defineEval as i, TrialManifestSchema as j, ScoreResultSchema as k, file as l, registerEvals as m, authoringId as n, directory as o, recordError as p, defineAgent as r, dynamic as s, agent as t, inlineFile as u, ArtifactEntrySchema as v, RunManifestSchema as w, JsonValueSchema as x, AutIdentitySchema as y, ResourceUriSchema as z };
 
-//# sourceMappingURL=src-DrwwgaPn.mjs.map
+//# sourceMappingURL=src-ButXPY8P.mjs.map