@crewhaus/eval-dataset 0.3.2 → 0.4.2

package/dist/index.d.ts

@@ -2,12 +2,14 @@
  * Catalog R-eval `eval-dataset` — load samples from JSONL, CSV, YAML, or HTTP.
  *
  * Sample shape is the contract every other eval-* module consumes:
- *   { id, input, expected_output?, expected_tools?, metadata? }
+ *   { id, input, history?, expected_output?, expected_tools?, metadata? }
  *
  * Loaders return an `AsyncIterable<Sample>` so 100k-row datasets stream rather
- * than load fully into memory. JSONL/CSV truly stream off the file system via
- * `Bun.file().stream()`. YAML and HTTP buffer (YAML can't stream; HTTP buffers
- * before re-dispatching to the format-specific loader).
+ * than load fully into memory. JSONL truly streams — local files via
+ * `Bun.file().stream()`, HTTP bodies via the fetch reader (B24) — through one
+ * shared incremental line parser, memory bounded by the longest line. CSV and
+ * YAML buffer their source whole, locally and over HTTP alike (YAML can't
+ * stream, CSV quoting spans physical lines).
  *
  * Reference: build-roadmap.md §16.
  */
@@ -17,21 +19,70 @@ import { loadCsv } from "./loaders/csv";
 import { loadHttp } from "./loaders/http";
 import { loadJsonl } from "./loaders/jsonl";
 import { loadYaml } from "./loaders/yaml";
+/**
+ * B14 — one prior conversation turn of a multi-turn sample. STRICT item
+ * shape: a history message is seeded into the eval session transcript
+ * VERBATIM (no model call runs for it), so an unknown key is an authoring
+ * mistake to reject loudly, not an extension point.
+ */
+export declare const HistoryMessageSchema: z.ZodObject<{
+    role: z.ZodEnum<["user", "assistant"]>;
+    content: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    role: "user" | "assistant";
+    content: string;
+}, {
+    role: "user" | "assistant";
+    content: string;
+}>;
+export type HistoryMessage = z.infer<typeof HistoryMessageSchema>;
 export declare const SampleSchema: z.ZodObject<{
     id: z.ZodString;
     input: z.ZodString;
+    /**
+     * B14 — optional prior conversation turns (MT-Bench-style multi-turn
+     * evaluation). `input` stays the required FINAL user message — every
+     * history-less dataset parses byte-identically — and when `history` is
+     * present the eval invoker seeds these messages into the session
+     * transcript verbatim before running `input`. Non-empty when present:
+     * `history: []` says "multi-turn" while carrying no turns, an authoring
+     * error worth rejecting at load. One DELIBERATE break rides along: a
+     * hand-authored dataset whose samples already carried a free-form
+     * `history` key was silently ignored before (Zod strip mode dropped the
+     * unknown key) — it now validates, so a shape-mismatched value fails the
+     * load loudly, and a shape-matched one starts seeding turns (changing
+     * that dataset's sample hashes). Rename the key or fix its shape.
+     */
+    history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant"]>;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        role: "user" | "assistant";
+        content: string;
+    }, {
+        role: "user" | "assistant";
+        content: string;
+    }>, "many">>;
     expected_output: z.ZodOptional<z.ZodString>;
     expected_tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     input: string;
+    history?: {
+        role: "user" | "assistant";
+        content: string;
+    }[] | undefined;
     expected_output?: string | undefined;
     expected_tools?: string[] | undefined;
     metadata?: Record<string, unknown> | undefined;
 }, {
     id: string;
     input: string;
+    history?: {
+        role: "user" | "assistant";
+        content: string;
+    }[] | undefined;
     expected_output?: string | undefined;
     expected_tools?: string[] | undefined;
     metadata?: Record<string, unknown> | undefined;
@@ -42,18 +93,50 @@ export declare const DatasetSchema: z.ZodObject<{
     samples: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         input: z.ZodString;
+        /**
+         * B14 — optional prior conversation turns (MT-Bench-style multi-turn
+         * evaluation). `input` stays the required FINAL user message — every
+         * history-less dataset parses byte-identically — and when `history` is
+         * present the eval invoker seeds these messages into the session
+         * transcript verbatim before running `input`. Non-empty when present:
+         * `history: []` says "multi-turn" while carrying no turns, an authoring
+         * error worth rejecting at load. One DELIBERATE break rides along: a
+         * hand-authored dataset whose samples already carried a free-form
+         * `history` key was silently ignored before (Zod strip mode dropped the
+         * unknown key) — it now validates, so a shape-mismatched value fails the
+         * load loudly, and a shape-matched one starts seeding turns (changing
+         * that dataset's sample hashes). Rename the key or fix its shape.
+         */
+        history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<["user", "assistant"]>;
+            content: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            role: "user" | "assistant";
+            content: string;
+        }, {
+            role: "user" | "assistant";
+            content: string;
+        }>, "many">>;
         expected_output: z.ZodOptional<z.ZodString>;
         expected_tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
         id: string;
         input: string;
+        history?: {
+            role: "user" | "assistant";
+            content: string;
+        }[] | undefined;
         expected_output?: string | undefined;
         expected_tools?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;
     }, {
         id: string;
         input: string;
+        history?: {
+            role: "user" | "assistant";
+            content: string;
+        }[] | undefined;
         expected_output?: string | undefined;
         expected_tools?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;
@@ -63,6 +146,10 @@ export declare const DatasetSchema: z.ZodObject<{
     samples: {
         id: string;
         input: string;
+        history?: {
+            role: "user" | "assistant";
+            content: string;
+        }[] | undefined;
         expected_output?: string | undefined;
         expected_tools?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;
@@ -72,6 +159,10 @@ export declare const DatasetSchema: z.ZodObject<{
     samples: {
         id: string;
         input: string;
+        history?: {
+            role: "user" | "assistant";
+            content: string;
+        }[] | undefined;
         expected_output?: string | undefined;
         expected_tools?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;

package/dist/index.js

@@ -2,12 +2,14 @@
  * Catalog R-eval `eval-dataset` — load samples from JSONL, CSV, YAML, or HTTP.
  *
  * Sample shape is the contract every other eval-* module consumes:
- *   { id, input, expected_output?, expected_tools?, metadata? }
+ *   { id, input, history?, expected_output?, expected_tools?, metadata? }
  *
  * Loaders return an `AsyncIterable<Sample>` so 100k-row datasets stream rather
- * than load fully into memory. JSONL/CSV truly stream off the file system via
- * `Bun.file().stream()`. YAML and HTTP buffer (YAML can't stream; HTTP buffers
- * before re-dispatching to the format-specific loader).
+ * than load fully into memory. JSONL truly streams — local files via
+ * `Bun.file().stream()`, HTTP bodies via the fetch reader (B24) — through one
+ * shared incremental line parser, memory bounded by the longest line. CSV and
+ * YAML buffer their source whole, locally and over HTTP alike (YAML can't
+ * stream, CSV quoting spans physical lines).
  *
  * Reference: build-roadmap.md §16.
  */
@@ -17,9 +19,36 @@ import { loadCsv } from "./loaders/csv";
 import { loadHttp } from "./loaders/http";
 import { loadJsonl } from "./loaders/jsonl";
 import { loadYaml } from "./loaders/yaml";
+/**
+ * B14 — one prior conversation turn of a multi-turn sample. STRICT item
+ * shape: a history message is seeded into the eval session transcript
+ * VERBATIM (no model call runs for it), so an unknown key is an authoring
+ * mistake to reject loudly, not an extension point.
+ */
+export const HistoryMessageSchema = z
+    .object({
+    role: z.enum(["user", "assistant"]),
+    content: z.string(),
+})
+    .strict();
 export const SampleSchema = z.object({
     id: z.string().min(1),
     input: z.string(),
+    /**
+     * B14 — optional prior conversation turns (MT-Bench-style multi-turn
+     * evaluation). `input` stays the required FINAL user message — every
+     * history-less dataset parses byte-identically — and when `history` is
+     * present the eval invoker seeds these messages into the session
+     * transcript verbatim before running `input`. Non-empty when present:
+     * `history: []` says "multi-turn" while carrying no turns, an authoring
+     * error worth rejecting at load. One DELIBERATE break rides along: a
+     * hand-authored dataset whose samples already carried a free-form
+     * `history` key was silently ignored before (Zod strip mode dropped the
+     * unknown key) — it now validates, so a shape-mismatched value fails the
+     * load loudly, and a shape-matched one starts seeding turns (changing
+     * that dataset's sample hashes). Rename the key or fix its shape.
+     */
+    history: z.array(HistoryMessageSchema).min(1).optional(),
     expected_output: z.string().optional(),
     expected_tools: z.array(z.string()).optional(),
     metadata: z.record(z.unknown()).optional(),

package/dist/loaders/csv.d.ts

@@ -1,5 +1,19 @@
-import { type LoadedDataset } from "../index";
+import { type LoadedDataset, type Sample } from "../index";
 export declare function loadCsv(path: string): Promise<LoadedDataset>;
+/**
+ * Shared CSV row → Sample generator (the file loader and the HTTP CSV path
+ * both dispatch here, so structured-column handling can never drift between
+ * them). Empty cells are omitted — a blank column keeps the sample
+ * byte-identical to one authored without it. Structured columns:
+ *   - `expected_tools` — comma-split list.
+ *   - `metadata` (NEW-formats-1) / `history` (B14) — JSON-encoded cells,
+ *     parsed here so CSV datasets can carry the fields the rest of the
+ *     eval system leans on (slicing, provenance, multi-turn). Malformed
+ *     JSON is a hard `DatasetLoadError` naming the row — the raw string
+ *     would otherwise reach schema validation and fail with a far more
+ *     confusing type error (previously EVERY non-empty metadata cell did).
+ */
+export declare function csvRowsToSamples(rows: ReadonlyArray<ReadonlyArray<string>>, header: ReadonlyArray<string>, source: string): AsyncIterable<Sample>;
 /**
  * RFC 4180-style CSV parser. Handles:
  * - quoted fields with embedded commas, newlines (CRLF/LF), and escaped `""`

package/dist/loaders/csv.js

@@ -14,13 +14,26 @@ export async function loadCsv(path) {
     }
     return {
         name,
-        samples: rowsToSamples(dataRows, header, path),
+        samples: csvRowsToSamples(dataRows, header, path),
     };
 }
 async function* emptyIterable() {
     /* nothing */
 }
-async function* rowsToSamples(rows, header, path) {
+/**
+ * Shared CSV row → Sample generator (the file loader and the HTTP CSV path
+ * both dispatch here, so structured-column handling can never drift between
+ * them). Empty cells are omitted — a blank column keeps the sample
+ * byte-identical to one authored without it. Structured columns:
+ *   - `expected_tools` — comma-split list.
+ *   - `metadata` (NEW-formats-1) / `history` (B14) — JSON-encoded cells,
+ *     parsed here so CSV datasets can carry the fields the rest of the
+ *     eval system leans on (slicing, provenance, multi-turn). Malformed
+ *     JSON is a hard `DatasetLoadError` naming the row — the raw string
+ *     would otherwise reach schema validation and fail with a far more
+ *     confusing type error (previously EVERY non-empty metadata cell did).
+ */
+export async function* csvRowsToSamples(rows, header, source) {
     let rowNo = 1; // header was row 0
     for (const row of rows) {
         rowNo += 1;
@@ -32,20 +45,30 @@ async function* rowsToSamples(rows, header, path) {
             if (key === undefined)
                 continue;
             const cell = row[i] ?? "";
-            // expected_tools is the only array-shaped field — comma-split
-            if (key === "expected_tools" && cell !== "") {
+            if (cell === "")
+                continue;
+            if (key === "expected_tools") {
+                // expected_tools is the only comma-split field.
                 obj[key] = cell
                     .split(",")
                     .map((s) => s.trim())
                     .filter((s) => s.length > 0);
             }
-            else if (cell !== "") {
+            else if (key === "metadata" || key === "history") {
+                try {
+                    obj[key] = JSON.parse(cell);
+                }
+                catch (err) {
+                    throw new DatasetLoadError(`malformed JSON in "${key}" column on row ${rowNo} of ${source}`, err);
+                }
+            }
+            else {
                 obj[key] = cell;
             }
         }
         const result = SampleSchema.safeParse(obj);
         if (!result.success) {
-            throw new DatasetLoadError(`invalid sample on row ${rowNo} of ${path}: ${result.error.message}`);
+            throw new DatasetLoadError(`invalid sample on row ${rowNo} of ${source}: ${result.error.message}`);
         }
         yield result.data;
     }

package/dist/loaders/http.d.ts

@@ -1,10 +1,14 @@
 import { type LoadedDataset } from "../index";
 /**
- * HTTP loader — fetches the URL into memory, then dispatches to the
- * appropriate format parser based on the URL extension first, then
- * the response Content-Type as a fallback.
+ * HTTP loader — dispatches on the URL extension first, then the response
+ * Content-Type as a fallback.
  *
- * Buffers the entire body in memory; HuggingFace-scale datasets should
- * be downloaded ahead of time and loaded via the local-file loaders.
+ * B24 — `.jsonl`/`.ndjson` bodies STREAM line-by-line off the fetch body
+ * reader through the SAME incremental parser as the local file loader:
+ * memory stays bounded by the longest line, not the body, so a multi-GB
+ * JSONL URL parses as it downloads. CSV and YAML buffer the entire body via
+ * `response.text()` — YAML cannot be parsed incrementally and CSV quoting
+ * can span physical lines — matching the (also buffered) local CSV/YAML
+ * loaders.
  */
 export declare function loadHttp(url: string): Promise<LoadedDataset>;

package/dist/loaders/http.js

@@ -1,37 +1,45 @@
 import { parse as parseYaml } from "yaml";
 import { DatasetLoadError } from "../errors";
 import { DatasetSchema, SampleSchema } from "../index";
-import { parseCsv } from "./csv";
+import { csvRowsToSamples, parseCsv } from "./csv";
+import { samplesFromJsonlStream, samplesFromJsonlText } from "./jsonl";
 /**
- * HTTP loader — fetches the URL into memory, then dispatches to the
- * appropriate format parser based on the URL extension first, then
- * the response Content-Type as a fallback.
+ * HTTP loader — dispatches on the URL extension first, then the response
+ * Content-Type as a fallback.
  *
- * Buffers the entire body in memory; HuggingFace-scale datasets should
- * be downloaded ahead of time and loaded via the local-file loaders.
+ * B24 — `.jsonl`/`.ndjson` bodies STREAM line-by-line off the fetch body
+ * reader through the SAME incremental parser as the local file loader:
+ * memory stays bounded by the longest line, not the body, so a multi-GB
+ * JSONL URL parses as it downloads. CSV and YAML buffer the entire body via
+ * `response.text()` — YAML cannot be parsed incrementally and CSV quoting
+ * can span physical lines — matching the (also buffered) local CSV/YAML
+ * loaders.
  */
 export async function loadHttp(url) {
     const response = await fetch(url);
     if (!response.ok) {
         throw new DatasetLoadError(`HTTP ${response.status} fetching ${url}`);
     }
-    const text = await response.text();
     const ct = (response.headers.get("content-type") ?? "").toLowerCase();
     const lower = url.toLowerCase();
     if (lower.endsWith(".jsonl") ||
         lower.endsWith(".ndjson") ||
         ct.includes("application/x-jsonlines") ||
         ct.includes("application/x-ndjson")) {
-        return { name: deriveName(url), samples: parseJsonlText(text, url) };
+        return { name: deriveName(url), samples: streamJsonlBody(response, url) };
     }
     if (lower.endsWith(".csv") || ct.includes("text/csv")) {
-        return { name: deriveName(url), samples: parseCsvText(text, url) };
+        // Buffered: CSV quoting can span physical lines. Rows then flow through
+        // the SAME row → Sample generator as the file loader (metadata/history
+        // JSON columns included).
+        const [header, ...dataRows] = parseCsv(await response.text());
+        return { name: deriveName(url), samples: csvRowsToSamples(dataRows, header ?? [], url) };
     }
     if (lower.endsWith(".yaml") ||
         lower.endsWith(".yml") ||
         ct.includes("application/yaml") ||
         ct.includes("text/yaml")) {
-        return parseYamlText(text, url);
+        return parseYamlText(await response.text(), url);
     }
     throw new DatasetLoadError(`unrecognized HTTP dataset format for ${url} (content-type: ${ct || "unknown"})`);
 }
@@ -45,57 +53,19 @@ function deriveName(url) {
         return "remote-dataset";
     }
 }
-async function* parseJsonlText(text, source) {
-    let lineNo = 0;
-    for (const raw of text.split(/\r?\n/)) {
-        lineNo += 1;
-        if (raw.trim() === "")
-            continue;
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch (err) {
-            throw new DatasetLoadError(`malformed JSON on line ${lineNo} of ${source}`, err);
-        }
-        const result = SampleSchema.safeParse(parsed);
-        if (!result.success) {
-            throw new DatasetLoadError(`invalid sample on line ${lineNo} of ${source}: ${result.error.message}`);
-        }
-        yield result.data;
-    }
-}
-async function* parseCsvText(text, source) {
-    const [header, ...dataRows] = parseCsv(text);
-    if (!header)
+/**
+ * B24 — HTTP `.jsonl` delegates to the shared incremental JSONL parser (see
+ * `loaders/jsonl.ts`) over the fetch body reader. A null body (null-body
+ * statuses, minimal Response stubs) falls back to buffering — there is
+ * nothing to stream.
+ */
+async function* streamJsonlBody(response, source) {
+    const body = response.body;
+    if (body === null || body === undefined) {
+        yield* samplesFromJsonlText(await response.text(), source);
         return;
-    let rowNo = 1;
-    for (const row of dataRows) {
-        rowNo += 1;
-        if (row.length === 1 && row[0] === "")
-            continue;
-        const obj = {};
-        for (let i = 0; i < header.length; i++) {
-            const key = header[i];
-            if (key === undefined)
-                continue;
-            const cell = row[i] ?? "";
-            if (key === "expected_tools" && cell !== "") {
-                obj[key] = cell
-                    .split(",")
-                    .map((s) => s.trim())
-                    .filter((s) => s.length > 0);
-            }
-            else if (cell !== "") {
-                obj[key] = cell;
-            }
-        }
-        const result = SampleSchema.safeParse(obj);
-        if (!result.success) {
-            throw new DatasetLoadError(`invalid sample on row ${rowNo} of ${source}: ${result.error.message}`);
-        }
-        yield result.data;
     }
+    yield* samplesFromJsonlStream(body, source);
 }
 function parseYamlText(text, source) {
     let parsed;

package/dist/loaders/jsonl.d.ts

@@ -1,2 +1,15 @@
-import { type LoadedDataset } from "../index";
+import { type LoadedDataset, type Sample } from "../index";
 export declare function loadJsonl(path: string): Promise<LoadedDataset>;
+/**
+ * Buffered-text JSONL → Sample generator (the HTTP loader's null-body
+ * fallback). Same parser, same line numbering as the streaming path.
+ */
+export declare function samplesFromJsonlText(text: string, source: string): AsyncIterable<Sample>;
+/**
+ * B24 — incremental JSONL over any byte stream (local file or fetch body):
+ * pull chunks off the reader, split on newlines (tolerating CRLF and JSON
+ * lines split across chunk boundaries), and validate each line as it
+ * arrives. Line numbering matches the buffered parser's exactly (blank lines
+ * count, then skip).
+ */
+export declare function samplesFromJsonlStream(stream: ReadableStream<Uint8Array>, source: string): AsyncIterable<Sample>;

package/dist/loaders/jsonl.js

@@ -8,28 +8,99 @@ export async function loadJsonl(path) {
     }
     return {
         name: basename(path).replace(/\.(jsonl|ndjson)$/i, ""),
-        samples: streamJsonl(path),
+        samples: streamJsonlFile(path),
     };
 }
-async function* streamJsonl(path) {
-    const file = Bun.file(path);
-    const text = await file.text();
+/**
+ * B24 — local `.jsonl` files stream through the SAME incremental line parser
+ * as HTTP bodies: `Bun.file().stream()` is a `ReadableStream<Uint8Array>`
+ * exactly like a fetch body, so memory stays bounded by the longest line, not
+ * the file. The generator wrapper keeps the file unopened until the caller
+ * actually iterates (loaders hand back lazy iterables, not open handles).
+ */
+async function* streamJsonlFile(path) {
+    yield* samplesFromJsonlStream(Bun.file(path).stream(), path);
+}
+/**
+ * One line-numbering + parse + validate closure shared by every JSONL entry
+ * point (local file, HTTP body, buffered fallback), so error messages
+ * ("malformed JSON on line N of SOURCE") can never drift between loaders.
+ * Blank lines count toward numbering, then skip; a trailing `\r` (CRLF input
+ * split on `\n`) is tolerated.
+ */
+function makeLineParser(source) {
     let lineNo = 0;
-    for (const raw of text.split(/\r?\n/)) {
+    return (line) => {
         lineNo += 1;
+        const raw = line.endsWith("\r") ? line.slice(0, -1) : line;
         if (raw.trim() === "")
-            continue;
+            return undefined;
         let parsed;
         try {
             parsed = JSON.parse(raw);
         }
         catch (err) {
-            throw new DatasetLoadError(`malformed JSON on line ${lineNo} of ${path}`, err);
+            throw new DatasetLoadError(`malformed JSON on line ${lineNo} of ${source}`, err);
         }
         const result = SampleSchema.safeParse(parsed);
         if (!result.success) {
-            throw new DatasetLoadError(`invalid sample on line ${lineNo} of ${path}: ${result.error.message}`);
+            throw new DatasetLoadError(`invalid sample on line ${lineNo} of ${source}: ${result.error.message}`);
+        }
+        return result.data;
+    };
+}
+/**
+ * Buffered-text JSONL → Sample generator (the HTTP loader's null-body
+ * fallback). Same parser, same line numbering as the streaming path.
+ */
+export async function* samplesFromJsonlText(text, source) {
+    const parseLine = makeLineParser(source);
+    for (const line of text.split("\n")) {
+        const sample = parseLine(line);
+        if (sample !== undefined)
+            yield sample;
+    }
+}
+/**
+ * B24 — incremental JSONL over any byte stream (local file or fetch body):
+ * pull chunks off the reader, split on newlines (tolerating CRLF and JSON
+ * lines split across chunk boundaries), and validate each line as it
+ * arrives. Line numbering matches the buffered parser's exactly (blank lines
+ * count, then skip).
+ */
+export async function* samplesFromJsonlStream(stream, source) {
+    const parseLine = makeLineParser(source);
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let carry = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            carry += decoder.decode(value, { stream: true });
+            let nl = carry.indexOf("\n");
+            while (nl !== -1) {
+                const line = carry.slice(0, nl);
+                carry = carry.slice(nl + 1);
+                const sample = parseLine(line);
+                if (sample !== undefined)
+                    yield sample;
+                nl = carry.indexOf("\n");
+            }
         }
-        yield result.data;
+        // Flush any multi-byte tail the decoder held back, then the final
+        // (newline-less) line — or the trailing "" a newline-terminated source
+        // leaves, which parseLine counts and skips like the buffered parser.
+        carry += decoder.decode();
+        const last = parseLine(carry);
+        if (last !== undefined)
+            yield last;
+    }
+    finally {
+        // Early exit (consumer break, invalid line mid-stream) must not leave a
+        // connection or file handle dangling; on normal completion this is a
+        // no-op.
+        await reader.cancel().catch(() => { });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/eval-dataset",
-  "version": "0.3.2",
+  "version": "0.4.2",
   "type": "module",
   "description": "Eval dataset loaders (JSONL, CSV, YAML, HTTP) with a lazy iterator API",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.3.2",
+    "@crewhaus/errors": "0.4.2",
     "yaml": "^2.6.0",
     "zod": "^3.23.8"
   },