orizu 0.5.39 → 0.5.41

package/dist/dataset-lock-workflow.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from 'effect';
+declare const LockedDataset: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly rowCount: Schema.Number;
+    readonly lockedAt: Schema.String;
+    readonly lockedBy: Schema.NullOr<Schema.String>;
+}>;
+export type LockedDataset = typeof LockedDataset.Type;
+export declare function lockDataset(datasetId: string, reason: string | null): Promise<LockedDataset>;
+export {};
+//# sourceMappingURL=dataset-lock-workflow.d.ts.map

package/dist/dataset-lock-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-lock-workflow.d.ts","sourceRoot":"","sources":["../src/dataset-lock-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,MAAM,EAAE,MAAM,QAAQ,CAAA;AAU5D,QAAA,MAAM,aAAa;;;;;;EAMjB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAmDrD,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,CAIlG"}

package/dist/dataset-lock-workflow.js

@@ -0,0 +1,76 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect';
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+import { authedFetch } from './http.js';
+import { parseJsonResponse } from './json-response.js';
+// Loaded only through `await import(...)` from dataset-commands, like append.
+const MAY_BE_LOCKED = 'The dataset may already be locked: running `orizu datasets lock` again is safe and shows its current state.';
+const LockedDataset = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    rowCount: Schema.Number,
+    lockedAt: Schema.String,
+    lockedBy: Schema.NullOr(Schema.String),
+});
+const LockReply = Schema.Struct({ dataset: LockedDataset });
+// A refusal (4xx) means nothing was locked. After any other failure once the
+// request was sent, the lock may have committed; locking again is harmless.
+class LockFailure extends Error {
+    mayBeLocked;
+    constructor(message, mayBeLocked) {
+        super(message);
+        this.mayBeLocked = mayBeLocked;
+    }
+}
+function lockRequest(datasetId, reason, timeoutMs) {
+    return Effect.suspend(() => {
+        let sent = false;
+        let timedOut = false;
+        return Effect.tryPromise({
+            try: async (signal) => {
+                const request = new AbortController();
+                const abort = () => request.abort();
+                const timer = setTimeout(() => { timedOut = true; request.abort(); }, timeoutMs);
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener('abort', abort, { once: true });
+                try {
+                    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/lock`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(reason ? { reason } : {}),
+                        signal: request.signal,
+                    }, () => { sent = true; });
+                    if (!response.ok) {
+                        throw new LockFailure(`Lock failed: ${await response.text()}`, response.status < 400 || response.status >= 500);
+                    }
+                    const data = await parseJsonResponse(response, 'Dataset lock');
+                    const decoded = Schema.decodeUnknownResult(LockReply)(data);
+                    if (Result.isFailure(decoded)) {
+                        throw new LockFailure(`Dataset lock returned an unexpected response (status ${response.status}).`, true);
+                    }
+                    return decoded.success.dataset;
+                }
+                finally {
+                    clearTimeout(timer);
+                    signal.removeEventListener('abort', abort);
+                    request.abort();
+                }
+            },
+            catch: cause => {
+                if (timedOut)
+                    return new LockFailure('DATASET_TRANSFER_TIMEOUT: Dataset lock exceeded its deadline', true);
+                if (cause instanceof LockFailure)
+                    return cause;
+                return new LockFailure(cause instanceof Error ? cause.message : String(cause), sent);
+            },
+        });
+    }).pipe(Effect.mapError(failure => new Error(failure.mayBeLocked ? `${failure.message}\n${MAY_BE_LOCKED}` : failure.message)));
+}
+// Nothing to clean up, so signals keep Node's default handling.
+export async function lockDataset(datasetId, reason) {
+    const exit = await Effect.runPromiseExit(lockRequest(datasetId, reason, datasetTransferTimeoutMs()));
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    throw Cause.squash(exit.cause);
+}

package/dist/dataset-readme-workflow.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from 'effect';
+declare const SaveReply: Schema.Struct<{
+    readonly version: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly dataset_id: Schema.String;
+        readonly version_num: Schema.Number;
+        readonly created_at: Schema.String;
+    }>;
+}>;
+export type SavedReadmeVersion = typeof SaveReply.Type['version'];
+export declare function saveDatasetReadme(datasetId: string, markdown: string): Promise<SavedReadmeVersion>;
+export {};
+//# sourceMappingURL=dataset-readme-workflow.d.ts.map

package/dist/dataset-readme-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-readme-workflow.d.ts","sourceRoot":"","sources":["../src/dataset-readme-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,MAAM,EAAE,MAAM,QAAQ,CAAA;AAW5D,QAAA,MAAM,SAAS;;;;;;;EAOb,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;AAuDjE,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAIxG"}

package/dist/dataset-readme-workflow.js

@@ -0,0 +1,82 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect';
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+import { authedFetch } from './http.js';
+import { parseJsonResponse } from './json-response.js';
+// Loaded only through `await import(...)` from dataset-commands, like delete.
+const MAY_BE_SAVED = "The README may already be saved as a new version: check the dataset's README tab before saving again.";
+const SAVED_AT_SAME_TIME = 'Another README save for this dataset happened at the same time, so yours was not saved. Run the command again to save it as the next version.';
+const SaveReply = Schema.Struct({
+    version: Schema.Struct({
+        id: Schema.String,
+        dataset_id: Schema.String,
+        version_num: Schema.Number,
+        created_at: Schema.String,
+    }),
+});
+// A refusal (4xx) means nothing was saved. After any other failure once the
+// request was sent, a new version may exist; saving again would add another.
+class SaveFailure extends Error {
+    mayBeSaved;
+    constructor(message, mayBeSaved) {
+        super(message);
+        this.mayBeSaved = mayBeSaved;
+    }
+}
+function saveRequest(datasetId, markdown, timeoutMs) {
+    return Effect.suspend(() => {
+        let sent = false;
+        let timedOut = false;
+        return Effect.tryPromise({
+            try: async (signal) => {
+                const request = new AbortController();
+                const abort = () => request.abort();
+                const timer = setTimeout(() => { timedOut = true; request.abort(); }, timeoutMs);
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener('abort', abort, { once: true });
+                try {
+                    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/readme`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ markdown }),
+                        signal: request.signal,
+                    }, () => { sent = true; });
+                    if (!response.ok) {
+                        const message = `Failed to save dataset README: ${await response.text()}`;
+                        // The unique version number refused a save that lost a race.
+                        if (response.status === 409)
+                            throw new SaveFailure(`${message}\n${SAVED_AT_SAME_TIME}`, false);
+                        throw new SaveFailure(message, response.status < 400 || response.status >= 500);
+                    }
+                    const data = await parseJsonResponse(response, 'Dataset README save');
+                    const decoded = Schema.decodeUnknownResult(SaveReply)(data);
+                    if (Result.isFailure(decoded)) {
+                        throw new SaveFailure(`Dataset README save returned an unexpected response (status ${response.status}).`, true);
+                    }
+                    return decoded.success.version;
+                }
+                finally {
+                    clearTimeout(timer);
+                    signal.removeEventListener('abort', abort);
+                    request.abort();
+                }
+            },
+            catch: cause => {
+                if (timedOut)
+                    return new SaveFailure('DATASET_TRANSFER_TIMEOUT: README save exceeded its deadline', sent);
+                if (cause instanceof SaveFailure)
+                    return cause;
+                return new SaveFailure(cause instanceof Error ? cause.message : String(cause), sent);
+            },
+        });
+    }).pipe(Effect.mapError(failure => new Error(failure.mayBeSaved ? `${failure.message}\n${MAY_BE_SAVED}` : failure.message)));
+}
+// One request, never retried: a retry after an unknown outcome could add a
+// duplicate version.
+export async function saveDatasetReadme(datasetId, markdown) {
+    const exit = await Effect.runPromiseExit(saveRequest(datasetId, markdown, datasetTransferTimeoutMs()));
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    throw Cause.squash(exit.cause);
+}

package/dist/dataset-row-workflow.d.ts

@@ -0,0 +1,14 @@
+export interface DatasetRowsOptions {
+    datasetId: string;
+    json: boolean;
+    printJson: (value: Record<string, unknown>) => void;
+    printLine: (value: string) => void;
+    sanitize: (value: string) => string;
+}
+export declare function editDatasetRows(options: DatasetRowsOptions & {
+    file: string;
+}): Promise<0 | 130 | 143>;
+export declare function deleteDatasetRows(options: DatasetRowsOptions & {
+    rowIds: string[];
+}): Promise<0 | 130 | 143>;
+//# sourceMappingURL=dataset-row-workflow.d.ts.map

package/dist/dataset-row-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-row-workflow.d.ts","sourceRoot":"","sources":["../src/dataset-row-workflow.ts"],"names":[],"mappings":"AA4BA,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACnD,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CACpC;AA+MD,wBAAgB,eAAe,CAAC,OAAO,EAAE,kBAAkB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAEtG;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,OAAO,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAE5G"}

package/dist/dataset-row-workflow.js

@@ -0,0 +1,202 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect';
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+import { extractErrorMessage } from './error-response.js';
+import { parseDatasetFile } from './file-parser.js';
+import { authedFetch } from './http.js';
+import { parseJsonResponse } from './json-response.js';
+// Loaded only through `await import(...)` from dataset-commands, like append.
+const MAX_REQUEST_BYTES = 3 * 1024 * 1024;
+const MAX_CHUNK_ROWS = 10;
+const EMPTY_REQUEST_BYTES = Buffer.byteLength('{"rows":[]}', 'utf8');
+class RowsRequestFailure extends Error {
+    outcome;
+    _tag = 'RowsRequestFailure';
+    constructor(message, outcome) {
+        super(message);
+        this.outcome = outcome;
+    }
+}
+const Dataset = Schema.Struct({ id: Schema.String, name: Schema.String, rowCount: Schema.Number });
+const EditAcknowledgement = Schema.Struct({ dataset: Dataset, updatedCount: Schema.Number });
+function normalizeRows(rows) {
+    if (rows.length === 0) {
+        throw new Error('Dataset edit file must contain at least one row');
+    }
+    const seenRowIds = new Set();
+    return rows.map((row, index) => {
+        const rowId = typeof row.id === 'string' ? row.id.trim() : '';
+        if (!rowId) {
+            throw new Error(`Dataset edit file rows[${index}] must include a non-empty string id`);
+        }
+        if (seenRowIds.has(rowId)) {
+            throw new Error(`Dataset edit file rows[${index}].id duplicates a previous row id`);
+        }
+        seenRowIds.add(rowId);
+        return { ...row, id: rowId };
+    });
+}
+function chunkRows(rows, sanitize) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentBytes = EMPTY_REQUEST_BYTES;
+    for (const row of rows) {
+        const rowBytes = Buffer.byteLength(JSON.stringify(row), 'utf8');
+        const framedRowBytes = rowBytes + (currentChunk.length > 0 ? 1 : 0);
+        if (currentChunk.length > 0 &&
+            (currentChunk.length >= MAX_CHUNK_ROWS || currentBytes + framedRowBytes > MAX_REQUEST_BYTES)) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentBytes = EMPTY_REQUEST_BYTES;
+        }
+        const singleRowRequestBytes = EMPTY_REQUEST_BYTES + rowBytes;
+        if (singleRowRequestBytes > MAX_REQUEST_BYTES) {
+            throw new Error(`Dataset edit row ${sanitize(row.id)} is ${singleRowRequestBytes} bytes, ` +
+                `which exceeds the ${MAX_REQUEST_BYTES}-byte edit request limit`);
+        }
+        currentChunk.push(row);
+        currentBytes += rowBytes + (currentChunk.length > 1 ? 1 : 0);
+    }
+    if (currentChunk.length > 0)
+        chunks.push(currentChunk);
+    return chunks;
+}
+// One rows request with a deadline that covers the whole reply. A deadline,
+// a lost connection or a broken reply after sending is an unknown outcome.
+function rowsRequest(datasetId, method, body, label, timeoutMs, read) {
+    return Effect.suspend(() => {
+        let sent = false;
+        let timedOut = false;
+        return Effect.tryPromise({
+            try: async (signal) => {
+                const request = new AbortController();
+                const abort = () => request.abort();
+                const timer = setTimeout(() => { timedOut = true; request.abort(); }, timeoutMs);
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener('abort', abort, { once: true });
+                try {
+                    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
+                        method,
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(body),
+                        signal: request.signal,
+                    }, () => { sent = true; });
+                    return await read(response);
+                }
+                finally {
+                    clearTimeout(timer);
+                    signal.removeEventListener('abort', abort);
+                    request.abort();
+                }
+            },
+            catch: cause => {
+                if (timedOut) {
+                    return sent
+                        ? new RowsRequestFailure(`DATASET_TRANSFER_TIMEOUT: ${label} exceeded its deadline`, 'unknown')
+                        : new RowsRequestFailure(`DATASET_TRANSFER_TIMEOUT: ${label} exceeded its deadline before the request was sent`, 'not_sent');
+                }
+                if (cause instanceof RowsRequestFailure)
+                    return cause;
+                return new RowsRequestFailure(cause instanceof Error ? cause.message : String(cause), sent ? 'unknown' : 'not_sent');
+            },
+        });
+    });
+}
+function refusalOutcome(status) {
+    return status >= 400 && status < 500 ? 'rejected' : 'unknown';
+}
+function editProgram(options, timeoutMs) {
+    return Effect.gen(function* () {
+        const chunks = yield* Effect.try({
+            try: () => chunkRows(normalizeRows(parseDatasetFile(options.file).rows), options.sanitize),
+            catch: cause => cause,
+        });
+        let totalUpdated = 0;
+        // normalizeRows refuses an empty file, so the loop always sets this.
+        let lastResult;
+        for (let index = 0; index < chunks.length; index += 1) {
+            const chunk = chunks[index];
+            if (!options.json && chunks.length > 1) {
+                options.printLine(`Updating chunk ${index + 1}/${chunks.length} (${chunk.length} rows)...`);
+            }
+            const acknowledged = yield* Effect.result(rowsRequest(options.datasetId, 'PATCH', { rows: chunk }, 'Dataset row edit', timeoutMs, async (response) => {
+                if (!response.ok) {
+                    throw new RowsRequestFailure(`HTTP ${response.status}: ${await extractErrorMessage(response)}`, refusalOutcome(response.status));
+                }
+                const data = await response.json();
+                const decoded = Schema.decodeUnknownResult(EditAcknowledgement)(data);
+                if (Result.isFailure(decoded)) {
+                    throw new RowsRequestFailure(`Server returned an unreadable acknowledgement for a ${chunk.length}-row chunk`, 'unknown');
+                }
+                if (!Number.isInteger(decoded.success.updatedCount) || decoded.success.updatedCount !== chunk.length) {
+                    throw new RowsRequestFailure(`Server reported ${String(decoded.success.updatedCount)} updated rows for a ${chunk.length}-row chunk`, 'unknown');
+                }
+                return decoded.success;
+            }));
+            if (Result.isFailure(acknowledged)) {
+                const { message, outcome } = acknowledged.failure;
+                const advice = outcome === 'unknown'
+                    ? 'This chunk may already be applied: check these rows in the dataset before retrying.'
+                    : 'Retry with a file containing only the remaining row edits.';
+                return yield* Effect.fail(new Error(`Chunk ${index + 1}/${chunks.length} failed: ${message}\n` +
+                    `${totalUpdated} rows from ${index} chunk(s) were already updated. ${advice}`));
+            }
+            totalUpdated += acknowledged.success.updatedCount;
+            lastResult = acknowledged.success;
+        }
+        if (options.json) {
+            options.printJson({ dataset: lastResult.dataset, updatedCount: totalUpdated });
+            return;
+        }
+        options.printLine(`Updated ${totalUpdated} rows in dataset ${options.sanitize(lastResult.dataset.name)} ` +
+            `(${options.sanitize(lastResult.dataset.id)}). Current row count: ${lastResult.dataset.rowCount}`);
+    });
+}
+function deleteProgram(options, timeoutMs) {
+    return Effect.gen(function* () {
+        const deleted = yield* rowsRequest(options.datasetId, 'DELETE', { rowIds: options.rowIds }, 'Dataset row removal', timeoutMs, async (response) => {
+            if (!response.ok) {
+                throw new RowsRequestFailure(await response.text(), refusalOutcome(response.status));
+            }
+            return parseJsonResponse(response, 'Dataset delete rows');
+        }).pipe(Effect.mapError(({ message, outcome }) => new Error(`Delete rows failed: ${message}` +
+            (outcome === 'unknown' ? '\nThe rows may already be removed: check the dataset before retrying.' : ''))));
+        if (options.json) {
+            options.printJson({ dataset: deleted.dataset, deletedCount: deleted.deletedCount });
+            return;
+        }
+        options.printLine(`Deleted ${deleted.deletedCount} rows from dataset ${options.sanitize(deleted.dataset.name)} (${options.sanitize(deleted.dataset.id)}). New row count: ${deleted.dataset.rowCount}`);
+    });
+}
+// Ctrl-C or SIGTERM aborts the request in flight. Returns the exit code for
+// an interruption; other failures throw their original error.
+async function runRowsCommand(name, program) {
+    const timeoutMs = datasetTransferTimeoutMs();
+    const controller = new AbortController();
+    let interrupted;
+    const interrupt = () => { interrupted ??= 130; controller.abort(); };
+    const terminate = () => { interrupted ??= 143; controller.abort(); };
+    process.on('SIGINT', interrupt);
+    process.on('SIGTERM', terminate);
+    try {
+        const exit = await Effect.runPromiseExit(program(timeoutMs), { signal: controller.signal });
+        if (interrupted !== undefined) {
+            process.stderr.write(`${name} interrupted. The request in flight may already be applied: check the dataset before retrying.\n`);
+            return interrupted;
+        }
+        if (Exit.isFailure(exit))
+            throw Cause.squash(exit.cause);
+        return 0;
+    }
+    finally {
+        process.removeListener('SIGINT', interrupt);
+        process.removeListener('SIGTERM', terminate);
+    }
+}
+export function editDatasetRows(options) {
+    return runRowsCommand('Dataset row edit', timeoutMs => editProgram(options, timeoutMs));
+}
+export function deleteDatasetRows(options) {
+    return runRowsCommand('Dataset row removal', timeoutMs => deleteProgram(options, timeoutMs));
+}

package/dist/dataset-split-reads.d.ts

@@ -0,0 +1,28 @@
+export declare function listDatasetSplits(versionId: string): Promise<{
+    readonly dataset_version_id: string;
+    readonly split_sets: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly strategy: string;
+        readonly seed: number | null;
+        readonly partitions: readonly {
+            readonly name: string;
+            readonly row_count: number;
+        }[];
+    }[];
+}>;
+export declare function showDatasetSplit(setId: string): Promise<{
+    readonly split_set_id: string;
+    readonly dataset_version_id: string;
+    readonly name: string;
+    readonly strategy: string;
+    readonly seed: number | null;
+    readonly metadata: unknown;
+    readonly partitions: readonly {
+        readonly name: string;
+        readonly row_ids: readonly string[];
+        readonly metadata: unknown;
+    }[];
+}>;
+export declare function downloadPinnedDatasetSplit(versionId: string, setId: string, split: string, format: string, filename: string): Promise<void>;
+//# sourceMappingURL=dataset-split-reads.d.ts.map

package/dist/dataset-split-reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-split-reads.d.ts","sourceRoot":"","sources":["../src/dataset-split-reads.ts"],"names":[],"mappings":"AA6BA,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM;;;;;;;;;;;;GAA+H;AAClL,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;GAA4G;AAE1J,wBAAsB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,iBAUjI"}

package/dist/dataset-split-reads.js

@@ -0,0 +1,47 @@
+import { Effect, Result, Schema } from 'effect';
+import { writeFileSync } from 'node:fs';
+import { authedFetch } from './http.js';
+import { extractErrorMessage } from './error-response.js';
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+const SplitExport = Schema.Struct({
+    split_set_id: Schema.String, dataset_version_id: Schema.String,
+    name: Schema.String, strategy: Schema.String, seed: Schema.NullOr(Schema.Number), metadata: Schema.Unknown,
+    partitions: Schema.Array(Schema.Struct({ name: Schema.String, row_ids: Schema.Array(Schema.String), metadata: Schema.Unknown })),
+});
+const SplitList = Schema.Struct({
+    dataset_version_id: Schema.String,
+    split_sets: Schema.Array(Schema.Struct({ id: Schema.String, name: Schema.String, strategy: Schema.String, seed: Schema.NullOr(Schema.Number), partitions: Schema.Array(Schema.Struct({ name: Schema.String, row_count: Schema.Number })) })),
+});
+async function read(path, decode) {
+    const result = await Effect.runPromise(Effect.result(Effect.tryPromise({
+        try: async (signal) => {
+            const response = await authedFetch(path, { signal });
+            if (!response.ok)
+                throw new Error(await extractErrorMessage(response));
+            try {
+                return decode(await response.json());
+            }
+            catch (cause) {
+                throw new Error('Dataset split response is incomplete or unreadable', { cause });
+            }
+        }, catch: cause => cause instanceof Error ? cause : new Error('Dataset split read failed', { cause }),
+    }).pipe(Effect.timeoutOrElse({ duration: datasetTransferTimeoutMs(), orElse: () => Effect.fail(new Error('Dataset split read exceeded its deadline')) }))));
+    if (Result.isFailure(result))
+        throw result.failure;
+    return result.success;
+}
+export function listDatasetSplits(versionId) { return read(`/api/cli/dataset-versions/${encodeURIComponent(versionId)}/split-sets`, Schema.decodeUnknownSync(SplitList)); }
+export function showDatasetSplit(setId) { return read(`/api/cli/split-sets/${encodeURIComponent(setId)}`, Schema.decodeUnknownSync(SplitExport)); }
+export async function downloadPinnedDatasetSplit(versionId, setId, split, format, filename) {
+    const query = new URLSearchParams({ split_set: setId, split, format });
+    const result = await Effect.runPromise(Effect.result(Effect.tryPromise({
+        try: async (signal) => {
+            const response = await authedFetch(`/api/cli/dataset-versions/${encodeURIComponent(versionId)}/download?${query}`, { signal });
+            if (!response.ok)
+                throw new Error(`Download failed: ${await extractErrorMessage(response)}`);
+            return new Uint8Array(await response.arrayBuffer());
+        }, catch: cause => cause instanceof Error ? cause : new Error('Dataset split download failed', { cause }),
+    }).pipe(Effect.timeoutOrElse({ duration: datasetTransferTimeoutMs(), orElse: () => Effect.fail(new Error('Dataset split download exceeded its deadline')) }), Effect.flatMap(bytes => Effect.try({ try: () => writeFileSync(filename, bytes, { mode: 0o600 }), catch: cause => new Error('Could not save dataset split download', { cause }) })))));
+    if (Result.isFailure(result))
+        throw result.failure;
+}

package/dist/dataset-transfer-upload.d.ts

@@ -1,3 +1,4 @@
+import { type DatasetVersionResponse } from './dataset-version-workflow.js';
 export interface DatasetUploadResponse {
     dataset: {
         id: string;
@@ -12,11 +13,6 @@ export interface DatasetUploadResponse {
         created_at: string;
     } | null;
 }
-interface DatasetSnapshot {
-    datasetVersion: {
-        id: string;
-    };
-}
 type UploadRows = Array<Record<string, unknown>>;
 type UploadSource = {
     kind: 'jsonl';
@@ -36,7 +32,7 @@ export interface DatasetUploadOptions {
 }
 export declare function transferDatasetUpload(options: DatasetUploadOptions): Promise<{
     data: DatasetUploadResponse;
-    version: DatasetSnapshot;
+    version: DatasetVersionResponse;
 }>;
 export {};
 //# sourceMappingURL=dataset-transfer-upload.d.ts.map

package/dist/dataset-transfer-upload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-transfer-upload.d.ts","sourceRoot":"","sources":["../src/dataset-transfer-upload.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACzF,aAAa,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC/E;AAED,UAAU,eAAe;IAAG,cAAc,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE;AAE5D,KAAK,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAChD,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAA;CAAE,CAAA;AAE9H,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,YAAY,CAAA;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CACnD;AAoHD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,qBAAqB,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,CAAC,CAEvI"}
+{"version":3,"file":"dataset-transfer-upload.d.ts","sourceRoot":"","sources":["../src/dataset-transfer-upload.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsD,KAAK,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAM/H,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACzF,aAAa,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC/E;AAGD,KAAK,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAChD,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAA;CAAE,CAAA;AAE9H,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,YAAY,CAAA;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CACnD;AA2HD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,qBAAqB,CAAC;IAAC,OAAO,EAAE,sBAAsB,CAAA;CAAE,CAAC,CAE9I"}

package/dist/dataset-transfer-upload.js

@@ -1,6 +1,7 @@
 import { Context, Effect, Layer, Result } from 'effect';
 import { ensureDatasetUploadSnapshot } from './dataset-upload-snapshot.js';
 import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+import { datasetVersionSnapshot } from './dataset-version-workflow.js';
 import { extractErrorMessage } from './error-response.js';
 import { authedFetch } from './http.js';
 import { parseJsonResponse, sanitizeTerminalText } from './json-response.js';
@@ -18,6 +19,12 @@ class DatasetInputFailure extends Error {
     constructor(cause) { super(cause instanceof Error ? cause.message : String(cause), { cause }); }
 }
 const DatasetUploadApi = Context.Service('orizu/DatasetUploadApi');
+// authedFetch raises this code only when it sent nothing, or after the server
+// answered 401 (it writes nothing) and the stored credentials changed, so it
+// refused to replay. Either way nothing was written (ORI-2431).
+function isAuthContextChange(cause) {
+    return cause instanceof Error && cause.message.startsWith('ORIZU_AUTH_CONTEXT_CHANGED:');
+}
 // Only the existing authentication client's rejected-token refresh may replay a
 // request. No transient/transport retries belong around these non-idempotent writes.
 function post(path, body, context, prefix, timeoutMs) {
@@ -34,7 +41,7 @@ function post(path, body, context, prefix, timeoutMs) {
                 }
                 return await parseJsonResponse(response, context);
             },
-            catch: cause => cause instanceof DatasetWriteFailure ? cause : new DatasetWriteFailure(cause instanceof Error ? cause.message : String(cause), requestStarted ? 'unknown' : 'rejected', { cause }),
+            catch: cause => cause instanceof DatasetWriteFailure ? cause : new DatasetWriteFailure(cause instanceof Error ? cause.message : String(cause), requestStarted && !isAuthContextChange(cause) ? 'unknown' : 'rejected', { cause }),
         }).pipe(Effect.timeoutOrElse({
             duration: timeoutMs,
             orElse: () => Effect.fail(new DatasetWriteFailure(`DATASET_TRANSFER_TIMEOUT: ${context} exceeded its deadline`, requestStarted ? 'unknown' : 'rejected')),
@@ -49,7 +56,7 @@ function liveUploadApi(options) {
             ...(options.readmeMarkdown !== null ? { readmeMarkdown: options.readmeMarkdown } : {}),
         }, 'Dataset upload', 'Upload failed', timeoutMs),
         append: (id, rows) => post(`/api/cli/datasets/${encodeURIComponent(id)}/rows`, { rows }, 'Dataset append', 'Append failed', timeoutMs),
-        snapshot: id => post(`/api/cli/datasets/${encodeURIComponent(id)}/versions`, {}, 'Dataset version create', 'Failed to create dataset version', timeoutMs),
+        snapshot: id => datasetVersionSnapshot(id, {}, timeoutMs),
     });
 }
 async function expectedPromise(program) {

package/dist/dataset-upload-snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-upload-snapshot.d.ts","sourceRoot":"","sources":["../src/dataset-upload-snapshot.ts"],"names":[],"mappings":"AAAA,UAAU,uBAAuB;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,sBAAsB;IAC9B,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAA;KACX,CAAA;CACF;AAED,wBAAsB,2BAA2B,CAAC,CAAC,SAAS,sBAAsB,EAChF,OAAO,EAAE,uBAAuB,EAChC,UAAU,EAAE,OAAO,EACnB,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAChD,OAAO,CAAC,CAAC,CAAC,CAwBZ"}
+{"version":3,"file":"dataset-upload-snapshot.d.ts","sourceRoot":"","sources":["../src/dataset-upload-snapshot.ts"],"names":[],"mappings":"AAEA,UAAU,uBAAuB;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,sBAAsB;IAC9B,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAA;KACX,CAAA;CACF;AAED,wBAAsB,2BAA2B,CAAC,CAAC,SAAS,sBAAsB,EAChF,OAAO,EAAE,uBAAuB,EAChC,UAAU,EAAE,OAAO,EACnB,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAChD,OAAO,CAAC,CAAC,CAAC,CA6BZ"}

package/dist/dataset-upload-snapshot.js

@@ -1,3 +1,4 @@
+import { DatasetVersionFailure, VERSION_MAY_BE_CREATED } from './dataset-version-workflow.js';
 export async function ensureDatasetUploadSnapshot(dataset, jsonOutput, createSnapshot) {
     try {
         return await createSnapshot(dataset.id);
@@ -5,6 +6,8 @@ export async function ensureDatasetUploadSnapshot(dataset, jsonOutput, createSna
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
         const retryCommand = `orizu datasets versions create --dataset ${dataset.id}`;
+        // After an unclear outcome the version may exist; check before retrying.
+        const mayBeCreated = error instanceof DatasetVersionFailure && error.mayBeCreated;
         if (jsonOutput) {
             throw new Error(JSON.stringify({
                 error: 'Dataset upload completed but dataset version creation failed',
@@ -13,10 +16,13 @@ export async function ensureDatasetUploadSnapshot(dataset, jsonOutput, createSna
                 dataset_id: dataset.id,
                 dataset_version_id: null,
                 retry_command: retryCommand,
+                ...(mayBeCreated ? { may_be_created: true } : {}),
             }));
         }
         throw new Error(`Dataset upload completed but dataset version creation failed: ${detail}\n` +
             `Dataset ${dataset.name} (${dataset.id}) was created with ${dataset.rowCount} rows. ` +
-            `Retry only the snapshot step with: ${retryCommand}`);
+            (mayBeCreated
+                ? `${VERSION_MAY_BE_CREATED} If it is not there, create it with: ${retryCommand}`
+                : `Retry only the snapshot step with: ${retryCommand}`));
     }
 }

package/dist/dataset-version-workflow.d.ts

@@ -0,0 +1,24 @@
+import { Effect, Schema } from 'effect';
+export declare const VERSION_MAY_BE_CREATED = "The version may already be created: check the dataset's versions in the web app before creating it again.";
+declare const CreateReply: Schema.Struct<{
+    readonly datasetVersion: Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly rowCount: Schema.Number;
+        readonly artifactFormat: Schema.optional<Schema.String>;
+        readonly artifactStoragePath: Schema.optional<Schema.String>;
+    }>;
+}>;
+export type DatasetVersionResponse = typeof CreateReply.Type;
+export interface DatasetVersionRequest {
+    versionLabel?: string | null;
+    readmeMarkdown?: string | null;
+}
+export declare class DatasetVersionFailure extends Error {
+    readonly mayBeCreated: boolean;
+    readonly _tag = "DatasetVersionFailure";
+    constructor(message: string, mayBeCreated: boolean);
+}
+export declare function datasetVersionSnapshot(datasetId: string, options: DatasetVersionRequest, timeoutMs: number): Effect.Effect<DatasetVersionResponse, DatasetVersionFailure>;
+export declare function createDatasetVersionSnapshot(datasetId: string, options: DatasetVersionRequest): Promise<DatasetVersionResponse>;
+export {};
+//# sourceMappingURL=dataset-version-workflow.d.ts.map

package/dist/dataset-version-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-version-workflow.d.ts","sourceRoot":"","sources":["../src/dataset-version-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAgB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAS5D,eAAO,MAAM,sBAAsB,8GAA8G,CAAA;AAIjJ,QAAA,MAAM,WAAW;;;;;;;EAOf,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAE5D,MAAM,WAAW,qBAAqB;IACpC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAMD,qBAAa,qBAAsB,SAAQ,KAAK;IAEjB,QAAQ,CAAC,YAAY,EAAE,OAAO;IAD3D,QAAQ,CAAC,IAAI,2BAA0B;gBAC3B,OAAO,EAAE,MAAM,EAAW,YAAY,EAAE,OAAO;CAC5D;AAaD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,sBAAsB,EAAE,qBAAqB,CAAC,CA+CzK;AAED,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAMrI"}