orizu 0.5.39 → 0.5.41

package/README.md

@@ -336,6 +336,10 @@ orizu logout
     <td>Download a dataset</td>
     <td><code>orizu datasets download --dataset &lt;datasetId&gt; --format jsonl --out ./dataset.jsonl</code></td>
   </tr>
+  <tr>
+    <td>Inspect saved splits and download validation rows</td>
+    <td><code>orizu datasets splits list &lt;datasetVersionId&gt; --json</code><br><code>orizu datasets splits show &lt;splitSetId&gt; --json</code><br><code>orizu datasets download --dataset-version &lt;datasetVersionId&gt; --split-set &lt;splitSetId&gt; --split validation --format jsonl --out ./validation.jsonl</code></td>
+  </tr>
   <tr>
     <td>Append dataset rows</td>
     <td><code>orizu datasets append --dataset &lt;datasetId&gt; --file ./datasets/support-extra.jsonl</code></td>
@@ -497,6 +501,39 @@ or interactive selection. SIGINT/SIGTERM closes append's owned JSONL reader and
 in-flight transport; retained interactive selection keeps ordinary process signal
 termination. Append adds no transient write retries or write deduplication.
 
+Dataset `edit-rows` and `delete-rows` use the same transfer deadline for each
+request, including its response body. When a request times out, loses its
+connection or gets a server error or a malformed reply, the message says the
+change may already be applied (or removed): check those rows before retrying.
+A refusal from the server (for example, a locked dataset) leaves `edit-rows`
+with the usual retry advice, and reports `delete-rows` as refused.
+SIGINT/SIGTERM aborts the request in flight and exits 130/143. Neither command
+retries a write automatically.
+
+Dataset `lock` uses the same transfer deadline for its request, including the
+response body. After a timeout, a lost connection, a server error or a malformed
+reply, the message says the dataset may already be locked: running `lock` again
+is safe and shows its current state. A refusal from the server keeps its usual
+message. Lock keeps ordinary process signal termination and never retries.
+
+Dataset `delete` asks you to type the dataset id first, then uses the same
+transfer deadline for its request, including the response body. After a
+timeout, a lost connection, a server error or a malformed reply, the message
+says the dataset may already be deleted: check with
+`orizu datasets list --status all` before retrying. When tasks or app versions
+still use the dataset, the refusal also names `orizu datasets archive <id>`.
+Delete keeps ordinary process signal termination and never retries.
+
+Dataset `readme set` uses the same transfer deadline for its request, including
+the response body. Each save adds a new README version. After a timeout, a lost
+connection, a server error or a malformed reply, the message says the README may
+already be saved as a new version: check the dataset's README tab before saving
+again, since another save would add a second version. When another save for the
+same dataset happened at the same time, the message says yours was not saved
+and to run the command again. A README file that cannot be read is named and
+nothing is sent. `readme set` keeps ordinary process signal termination and
+never retries.
+
 
 ## Interactive And Automated Usage
 
@@ -514,3 +551,43 @@ Use `--json` on supported task and app commands when automation needs structured
 - [skills/orizu/references/cli-reference.md](skills/orizu/references/cli-reference.md): compact command matrix and end-to-end flows
 
 If the server loses or cannot decode a database append acknowledgement, it preserves the request's prepared row artifacts because rows may already reference them. Unknown outcomes require inspection; automatic orphan reconciliation and write deduplication are not promised. Known SQL refusals clean up only that request's newly prepared artifacts.
+
+### Enrich validation rows while preserving split assignments
+
+Start with the immutable dataset version ID returned by dataset upload or version
+creation. List its saved split sets, then inspect one set to find the exact
+partition name (custom names and empty partitions are retained):
+
+```bash
+orizu datasets splits list DATASET_VERSION_ID --json
+orizu datasets splits show SPLIT_SET_ID --json > split.json
+orizu datasets download --dataset-version DATASET_VERSION_ID --split-set SPLIT_SET_ID --split validation --format jsonl --out validation.jsonl
+```
+
+`validation.jsonl` contains only that partition, in its saved order. Each row has
+its canonical `id` and the fields stored in that version. These reads stay fixed
+when the live dataset changes. No prompt, runner, scorer or optimization is needed.
+
+The assignment JSON retains set and partition metadata, including arrays, scalars
+and null values, together with exact saved memberships.
+
+Enrich the exported rows in your own workflow, keeping every `id` unchanged.
+Combine them with the other rows when preparing the complete enriched dataset.
+After uploading that dataset or creating its version, use the new version's ID
+explicitly to reuse every original assignment:
+
+```bash
+orizu datasets splits create TARGET_DATASET_VERSION_ID --from-file split.json --json
+```
+
+The import accepts the `name`, `strategy`, `seed`, `metadata` and
+`partitions: [{name, row_ids}]` from show JSON. Source identity is for inspection;
+the command's target version decides where assignments are created. Every
+referenced canonical row ID must exist in that target. Missing IDs fail instead
+of being dropped or remapped. Unknown or inaccessible versions, sets or names,
+mismatched selectors and incomplete artifacts fail; pinned reads never fall back
+to live data. Existing live downloads remain available with `--dataset`.
+
+For saved split names beginning with `--`, use the unambiguous equals spelling:
+`orizu datasets download --dataset-version DATASET_VERSION_ID --split-set SPLIT_SET_ID --split=--validation --format jsonl --out validation.jsonl`.
+The same spelling supports `--split=--json` and `--split=--help`; all pinned selectors remain required.

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

@@ -0,0 +1,11 @@
+import { Schema } from 'effect';
+declare const ClonedDataset: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly rowCount: Schema.Number;
+    readonly parentDatasetId: Schema.String;
+}>;
+export type ClonedDataset = typeof ClonedDataset.Type;
+export declare function cloneDataset(datasetId: string, name: string | null): Promise<ClonedDataset>;
+export {};
+//# sourceMappingURL=dataset-clone-workflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-clone-workflow.d.ts","sourceRoot":"","sources":["../src/dataset-clone-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,MAAM,EAAE,MAAM,QAAQ,CAAA;AAU5D,QAAA,MAAM,aAAa;;;;;EAKjB,CAAA;AAGF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AA6ErD,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,CAIjG"}

package/dist/dataset-clone-workflow.js

@@ -0,0 +1,100 @@
+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 lock.
+const SERVER_MAY_BE_CREATED = 'Dataset clone may already be created';
+const ClonedDataset = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    rowCount: Schema.Number,
+    parentDatasetId: Schema.String,
+});
+const CloneReply = Schema.Struct({ dataset: ClonedDataset });
+const ErrorReply = Schema.Struct({ error: Schema.String });
+// A refusal means nothing was cloned. After any other failure once the request
+// was sent, the clone may exist. Unlike lock, cloning again is not harmless: it
+// makes another copy, so the clone is never retried and the user is told to look.
+class CloneFailure extends Error {
+    mayBeCreated;
+    constructor(message, mayBeCreated) {
+        super(message);
+        this.mayBeCreated = mayBeCreated;
+    }
+}
+function mayBeCreatedGuidance(name) {
+    const target = name ? `a dataset named ${JSON.stringify(name)}` : 'a new dataset named after the source with " Copy" at the end';
+    return `The clone may already have been created. Run \`orizu datasets list\` and look for ${target} before cloning again: running clone again makes another copy.`;
+}
+// authedFetch raises this code only when it sent nothing, or when the server
+// answered 401 and the changed credentials stopped a replay. Nothing was cloned.
+function isAuthContextChange(cause) {
+    return cause instanceof Error && cause.message.startsWith('ORIZU_AUTH_CONTEXT_CHANGED:');
+}
+function serverError(text) {
+    try {
+        const decoded = Schema.decodeUnknownResult(ErrorReply)(JSON.parse(text));
+        return Result.isSuccess(decoded) ? decoded.success.error : null;
+    }
+    catch {
+        return null;
+    }
+}
+function cloneRequest(datasetId, name, 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)}/clone`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(name ? { name } : {}),
+                        signal: request.signal,
+                    }, () => { sent = true; });
+                    if (!response.ok) {
+                        const text = await response.text();
+                        const error = serverError(text);
+                        // The app's own 5xx bodies name what happened; anything else at 5xx
+                        // (a gateway page, an empty body) says nothing about the clone.
+                        const mayBeCreated = response.status < 400 || error === SERVER_MAY_BE_CREATED || (response.status >= 500 && error === null);
+                        throw new CloneFailure(`Clone failed: ${text}`, mayBeCreated);
+                    }
+                    const data = await parseJsonResponse(response, 'Dataset clone');
+                    const decoded = Schema.decodeUnknownResult(CloneReply)(data);
+                    if (Result.isFailure(decoded)) {
+                        throw new CloneFailure(`Dataset clone 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 CloneFailure('DATASET_TRANSFER_TIMEOUT: Dataset clone exceeded its deadline', true);
+                if (cause instanceof CloneFailure)
+                    return cause;
+                return new CloneFailure(cause instanceof Error ? cause.message : String(cause), sent && !isAuthContextChange(cause));
+            },
+        });
+    }).pipe(Effect.mapError(failure => new Error(failure.mayBeCreated ? `${failure.message}\n${mayBeCreatedGuidance(name)}` : failure.message)));
+}
+// Nothing to clean up, so signals keep Node's default handling.
+export async function cloneDataset(datasetId, name) {
+    const exit = await Effect.runPromiseExit(cloneRequest(datasetId, name, datasetTransferTimeoutMs()));
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    throw Cause.squash(exit.cause);
+}

package/dist/dataset-commands.d.ts

@@ -1,4 +1,6 @@
 declare function createDatasetVersion(): Promise<void>;
+declare function listDatasetSplitSets(): Promise<void>;
+declare function showDatasetSplitSet(): Promise<void>;
 declare function createDatasetSplitSet(): Promise<void>;
 declare function listDatasets(): Promise<void>;
 declare function uploadDataset(): Promise<void>;
@@ -12,5 +14,5 @@ declare function deleteDataset(): Promise<void>;
 declare function lockDataset(): Promise<void>;
 declare function cloneDataset(): Promise<void>;
 declare function downloadAnnotations(): Promise<void>;
-export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };
+export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, listDatasetSplitSets, showDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };
 //# sourceMappingURL=dataset-commands.d.ts.map

package/dist/dataset-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-commands.d.ts","sourceRoot":"","sources":["../src/dataset-commands.ts"],"names":[],"mappings":"AA6IA,iBAAe,oBAAoB,kBAiClC;AAED,iBAAe,qBAAqB,kBAkDnC;AAED,iBAAe,YAAY,kBAW1B;AAsBD,iBAAe,aAAa,kBAiC3B;AAED,iBAAe,WAAW,kBAwCzB;AAED,iBAAe,gBAAgB,kBA+C9B;AAgBD,iBAAe,eAAe,kBA8B7B;AAED,iBAAe,iBAAiB,kBAU/B;AAED,iBAAe,eAAe,kBAyB7B;AAED,iBAAe,iBAAiB,kBAyC/B;AA0BD,iBAAe,aAAa,kBA8B3B;AAED,iBAAe,WAAW,kBAwCzB;AAED,iBAAe,YAAY,kBAuC1B;AAED,iBAAe,mBAAmB,kBA+BjC;AAED,OAAO,EACL,aAAa,EACb,YAAY,EACZ,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,YAAY,EACZ,mBAAmB,GACpB,CAAA"}
+{"version":3,"file":"dataset-commands.d.ts","sourceRoot":"","sources":["../src/dataset-commands.ts"],"names":[],"mappings":"AAuHA,iBAAe,oBAAoB,kBAkClC;AAED,iBAAe,oBAAoB,kBAYlC;AAED,iBAAe,mBAAmB,kBAcjC;AAED,iBAAe,qBAAqB,kBAkDnC;AAED,iBAAe,YAAY,kBAW1B;AAsBD,iBAAe,aAAa,kBAiC3B;AAED,iBAAe,WAAW,kBAwCzB;AAED,iBAAe,gBAAgB,kBA+B9B;AAgBD,iBAAe,eAAe,kBA6C7B;AAED,iBAAe,iBAAiB,kBAU/B;AAED,iBAAe,eAAe,kBA2B7B;AAED,iBAAe,iBAAiB,kBA2B/B;AA0BD,iBAAe,aAAa,kBAuB3B;AAED,iBAAe,WAAW,kBAuBzB;AAED,iBAAe,YAAY,kBAuB1B;AAED,iBAAe,mBAAmB,kBA0BjC;AAED,OAAO,EACL,aAAa,EACb,YAAY,EACZ,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,YAAY,EACZ,mBAAmB,GACpB,CAAA"}

package/dist/dataset-commands.js

@@ -1,22 +1,30 @@
 // ORI-2044: moved from index.ts to keep dataset commands together.
-import { readFileSync, writeFileSync } from 'fs';
+import { readFileSync } from 'fs';
 import { basename, extname } from 'path';
 import { createInterface } from 'readline/promises';
 import { stdin as input, stdout as output } from 'process';
-import { getArg, expandHomePath, getPositionalArg, hasJsonFlag, getArchiveListStatus, cliArgs, isInteractiveTerminal, } from './command-line-arguments.js';
+import { getArg, hasArg, expandHomePath, getPositionalArg, hasJsonFlag, getArchiveListStatus, cliArgs, isInteractiveTerminal, } from './command-line-arguments.js';
 import { resolveProjectSlug, fetchDatasets, selectDatasetInteractively, selectTaskIdInteractively, } from './account-directory.js';
 import { sanitizeTerminalText, parseJsonResponse } from './json-response.js';
 import { authedFetch } from './http.js';
-import { extractErrorMessage } from './error-response.js';
 import { printJson, printLine } from './cli-console-output.js';
 import { readJsonFile } from './app-commands.js';
 import { printDatasetSummaries } from './archive-artifacts-cli.js';
 import { formatTerminalLink } from './auth-commands.js';
 import { parseDatasetFile } from './file-parser.js';
 import { parseDatasetReference } from './dataset-download.js';
-import { editDatasetRows as runEditDatasetRows } from './dataset-edit-rows.js';
 import { parseCommaSeparated } from './task-commands.js';
 const MAX_README_LENGTH = 200_000;
+function readReadmeFile(readmeFile) {
+    try {
+        return readFileSync(expandHomePath(readmeFile), 'utf8');
+    }
+    catch (error) {
+        const missing = error instanceof Error && 'code' in error && error.code === 'ENOENT';
+        const reason = missing ? 'file not found' : error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read README file ${readmeFile}: ${reason}`);
+    }
+}
 function readReadmeMarkdownFromArgs(usage) {
     const readmeFile = getArg('--readme-file');
     const readmeText = getArg('--readme-text');
@@ -24,7 +32,7 @@ function readReadmeMarkdownFromArgs(usage) {
         throw new Error(`Use either --readme-file or --readme-text, not both.\n${usage}`);
     }
     const markdown = readmeFile !== null
-        ? readFileSync(expandHomePath(readmeFile), 'utf8')
+        ? readReadmeFile(readmeFile)
         : readmeText;
     if (markdown !== null && markdown.length > MAX_README_LENGTH) {
         throw new Error(`README markdown is too large. Maximum size is ${MAX_README_LENGTH} characters.`);
@@ -72,22 +80,6 @@ async function resolveDatasetIdForProject(datasetRef, projectArg) {
     }
     return matches[0].id;
 }
-async function requestDatasetVersionSnapshot(datasetId, options = {}) {
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/versions`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            ...(options.versionLabel ? { versionLabel: options.versionLabel } : {}),
-            ...(options.readmeMarkdown !== undefined && options.readmeMarkdown !== null
-                ? { readmeMarkdown: options.readmeMarkdown }
-                : {}),
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to create dataset version: ${await extractErrorMessage(response)}`);
-    }
-    return parseJsonResponse(response, 'Dataset version create');
-}
 async function createDatasetVersion() {
     const datasetId = getPositionalArg(3) || getArg('--dataset');
     const versionLabel = getArg('--label') || getArg('--version-label') || null;
@@ -98,7 +90,8 @@ async function createDatasetVersion() {
     }
     const readmeMarkdown = readReadmeMarkdownFromArgs(usage);
     const resolvedDatasetId = await resolveDatasetIdForProject(datasetId, project);
-    const data = await requestDatasetVersionSnapshot(resolvedDatasetId, {
+    const { createDatasetVersionSnapshot } = await import('./dataset-version-workflow.js');
+    const data = await createDatasetVersionSnapshot(resolvedDatasetId, {
         versionLabel,
         readmeMarkdown,
     });
@@ -116,6 +109,41 @@ async function createDatasetVersion() {
     printLine(`Created dataset version ${sanitizeTerminalText(data.datasetVersion.id)}` +
         (details ? ` (${sanitizeTerminalText(details)})` : ''));
 }
+async function listDatasetSplitSets() {
+    const versionId = getPositionalArg(3);
+    if (!versionId)
+        throw new Error('Usage: orizu datasets splits list <datasetVersionId> [--json]');
+    const { listDatasetSplits } = await import('./dataset-split-reads.js');
+    const data = await listDatasetSplits(versionId);
+    if (hasJsonFlag())
+        return printJson({ ...data });
+    printLine(`Dataset version ${sanitizeTerminalText(data.dataset_version_id)}`);
+    for (const set of data.split_sets) {
+        printLine(`${sanitizeTerminalText(set.name)} (${sanitizeTerminalText(set.id)})`);
+        for (const partition of set.partitions)
+            printLine(`  ${sanitizeTerminalText(partition.name)}: ${partition.row_count} rows`);
+    }
+    if (!data.split_sets.length)
+        printLine('No saved split sets.');
+}
+async function showDatasetSplitSet() {
+    const setId = getPositionalArg(3);
+    if (!setId)
+        throw new Error('Usage: orizu datasets splits show <splitSetId> [--json]');
+    const { showDatasetSplit } = await import('./dataset-split-reads.js');
+    const data = await showDatasetSplit(setId);
+    if (hasJsonFlag())
+        return printJson({ ...data });
+    printLine(`${sanitizeTerminalText(data.name)} (${sanitizeTerminalText(data.split_set_id)})`);
+    printLine(`Dataset version: ${sanitizeTerminalText(data.dataset_version_id)}`);
+    printLine(`Strategy: ${sanitizeTerminalText(data.strategy)}; seed: ${data.seed ?? 'none'}`);
+    printLine(`Metadata: ${sanitizeTerminalText(JSON.stringify(data.metadata))}`);
+    for (const partition of data.partitions) {
+        printLine(`${sanitizeTerminalText(partition.name)}: ${partition.row_ids.length} rows`);
+        for (const id of partition.row_ids)
+            printLine(`  ${sanitizeTerminalText(id)}`);
+    }
+}
 async function createDatasetSplitSet() {
     const datasetVersionId = getPositionalArg(3) || getArg('--dataset-version');
     const splitFile = getArg('--from-file');
@@ -132,7 +160,7 @@ async function createDatasetSplitSet() {
         throw new Error('Usage: orizu datasets splits create <datasetVersionId> [--from-file <split.json>] [--name <name>] [--seed <n>] [--train <ratio>] [--validation <ratio>] [--test <ratio>] [--json]');
     }
     const partitions = splitSpec && Array.isArray(splitSpec.partitions) ? splitSpec.partitions : undefined;
-    const metadata = splitSpec && typeof splitSpec.metadata === 'object' && splitSpec.metadata !== null
+    const metadata = splitSpec && Object.prototype.hasOwnProperty.call(splitSpec, 'metadata')
         ? splitSpec.metadata
         : undefined;
     const response = await authedFetch(`/api/cli/dataset-versions/${encodeURIComponent(datasetVersionId)}/split-sets`, {
@@ -264,25 +292,18 @@ async function setDatasetReadme() {
         throw new Error(usage);
     }
     const resolvedDatasetId = await resolveDatasetIdForProject(datasetId, project);
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(resolvedDatasetId)}/readme`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ markdown: readmeMarkdown }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to save dataset README: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset README save');
+    const { saveDatasetReadme } = await import('./dataset-readme-workflow.js');
+    const version = await saveDatasetReadme(resolvedDatasetId, readmeMarkdown);
     if (hasJsonFlag()) {
         printJson({
-            dataset_id: data.version.dataset_id,
-            readme_version_id: data.version.id,
-            readme_version_num: data.version.version_num,
+            dataset_id: version.dataset_id,
+            readme_version_id: version.id,
+            readme_version_num: version.version_num,
         });
         return;
     }
-    printLine(`Saved README v${data.version.version_num} for dataset ` +
-        `${sanitizeTerminalText(data.version.dataset_id)} (${sanitizeTerminalText(data.version.id)}).`);
+    printLine(`Saved README v${version.version_num} for dataset ` +
+        `${sanitizeTerminalText(version.dataset_id)} (${sanitizeTerminalText(version.id)}).`);
 }
 function getDatasetReferenceInput() {
     const fromFlag = getArg('--dataset');
@@ -303,6 +324,24 @@ async function downloadDataset() {
     if (!['csv', 'json', 'jsonl'].includes(format)) {
         throw new Error('format must be one of: csv, json, jsonl');
     }
+    const versionId = getArg('--dataset-version'), setId = getArg('--split-set');
+    const inlineSplit = cliArgs.find(argument => argument.startsWith('--split='));
+    const split = inlineSplit === undefined ? getArg('--split') : inlineSplit.slice('--split='.length);
+    if (['--dataset-version', '--split-set', '--split'].some(flag => hasArg(flag) || cliArgs.some(argument => argument.startsWith(`${flag}=`)))) {
+        if (!versionId || !setId || !split || [versionId, setId].some(value => value.startsWith('--')) || (inlineSplit === undefined && split.startsWith('--')))
+            throw new Error('Pinned download requires --dataset-version, --split-set and --split together');
+        if (datasetInput)
+            throw new Error('Use --dataset-version with split selectors without a live --dataset or dataset argument');
+        if (format === 'csv')
+            throw new Error('Pinned download format must be json or jsonl');
+        const filename = outPathArg ? expandHomePath(outPathArg) : `${versionId}.${format}`;
+        const { downloadPinnedDatasetSplit } = await import('./dataset-split-reads.js');
+        await downloadPinnedDatasetSplit(versionId, setId, split, format, filename);
+        if (hasJsonFlag())
+            return printJson({ dataset_version_id: versionId, split_set_id: setId, split, format, savedTo: filename });
+        printLine(`Saved split ${sanitizeTerminalText(split)} from dataset version ${sanitizeTerminalText(versionId)} (${format.toUpperCase()}) to ${sanitizeTerminalText(filename)}`);
+        return;
+    }
     let datasetId;
     if (datasetInput) {
         datasetId = parseDatasetReference(datasetInput).datasetId;
@@ -349,7 +388,8 @@ async function editDatasetRows() {
         const selected = await selectDatasetInteractively(projectArg);
         datasetId = selected.datasetId;
     }
-    await runEditDatasetRows({
+    const { editDatasetRows: runEditDatasetRows } = await import('./dataset-row-workflow.js');
+    const exitCode = await runEditDatasetRows({
         datasetId,
         file: expandHomePath(fileArg),
         json: hasJsonFlag(),
@@ -357,6 +397,8 @@ async function editDatasetRows() {
         printLine,
         sanitize: sanitizeTerminalText,
     });
+    if (exitCode !== 0)
+        process.exitCode = exitCode;
 }
 async function deleteDatasetRows() {
     const projectArg = getArg('--project');
@@ -373,22 +415,17 @@ async function deleteDatasetRows() {
         const selected = await selectDatasetInteractively(projectArg);
         datasetId = selected.datasetId;
     }
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
-        method: 'DELETE',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            rowIds,
-        }),
+    const { deleteDatasetRows: runDeleteDatasetRows } = await import('./dataset-row-workflow.js');
+    const exitCode = await runDeleteDatasetRows({
+        datasetId,
+        rowIds,
+        json: hasJsonFlag(),
+        printJson,
+        printLine,
+        sanitize: sanitizeTerminalText,
     });
-    if (!response.ok) {
-        throw new Error(`Delete rows failed: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset delete rows');
-    if (hasJsonFlag()) {
-        printJson({ dataset: data.dataset, deletedCount: data.deletedCount });
-        return;
-    }
-    printLine(`Deleted ${data.deletedCount} rows from dataset ${sanitizeTerminalText(data.dataset.name)} (${sanitizeTerminalText(data.dataset.id)}). New row count: ${data.dataset.rowCount}`);
+    if (exitCode !== 0)
+        process.exitCode = exitCode;
 }
 async function confirmDatasetDeletion(dataset) {
     if (!isInteractiveTerminal()) {
@@ -419,18 +456,15 @@ async function deleteDataset() {
         dataset = await selectDatasetInteractively(projectArg);
     }
     await confirmDatasetDeletion(dataset);
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(dataset.datasetId)}`, {
-        method: 'DELETE',
-    });
-    if (!response.ok) {
-        throw new Error(`Delete failed: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset delete');
+    const { deleteDataset: requestDelete } = await import('./dataset-delete-workflow.js');
+    // Only a dataset picked from a project's list has a known project; with
+    // --dataset, --project is never checked against the dataset.
+    const deleted = await requestDelete(dataset.datasetId, dataset.project ?? null);
     if (hasJsonFlag()) {
-        printJson({ dataset: data.dataset, deleted: true });
+        printJson({ dataset: deleted, deleted: true });
         return;
     }
-    printLine(`Deleted dataset ${sanitizeTerminalText(data.dataset.id)}.`);
+    printLine(`Deleted dataset ${sanitizeTerminalText(deleted.id)}.`);
 }
 async function lockDataset() {
     const projectArg = getArg('--project');
@@ -444,20 +478,13 @@ async function lockDataset() {
         const selected = await selectDatasetInteractively(projectArg);
         datasetId = selected.datasetId;
     }
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/lock`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(reason ? { reason } : {}),
-    });
-    if (!response.ok) {
-        throw new Error(`Lock failed: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset lock');
+    const { lockDataset: requestLock } = await import('./dataset-lock-workflow.js');
+    const dataset = await requestLock(datasetId, reason);
     if (hasJsonFlag()) {
-        printJson({ dataset: data.dataset });
+        printJson({ dataset });
         return;
     }
-    printLine(`Locked dataset ${sanitizeTerminalText(data.dataset.name)} (${sanitizeTerminalText(data.dataset.id)}) at ${sanitizeTerminalText(data.dataset.lockedAt)}. Row count: ${data.dataset.rowCount}`);
+    printLine(`Locked dataset ${sanitizeTerminalText(dataset.name)} (${sanitizeTerminalText(dataset.id)}) at ${sanitizeTerminalText(dataset.lockedAt)}. Row count: ${dataset.rowCount}`);
 }
 async function cloneDataset() {
     const projectArg = getArg('--project');
@@ -471,20 +498,13 @@ async function cloneDataset() {
         const selected = await selectDatasetInteractively(projectArg);
         datasetId = selected.datasetId;
     }
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/clone`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(name ? { name } : {}),
-    });
-    if (!response.ok) {
-        throw new Error(`Clone failed: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset clone');
+    const { cloneDataset: requestClone } = await import('./dataset-clone-workflow.js');
+    const dataset = await requestClone(datasetId, name ?? null);
     if (hasJsonFlag()) {
-        printJson({ dataset: data.dataset });
+        printJson({ dataset });
         return;
     }
-    printLine(`Cloned dataset ${sanitizeTerminalText(data.dataset.parentDatasetId)} -> ${sanitizeTerminalText(data.dataset.name)} (${sanitizeTerminalText(data.dataset.id)}). Row count: ${data.dataset.rowCount}`);
+    printLine(`Cloned dataset ${sanitizeTerminalText(dataset.parentDatasetId)} -> ${sanitizeTerminalText(dataset.name)} (${sanitizeTerminalText(dataset.id)}). Row count: ${dataset.rowCount}`);
 }
 async function downloadAnnotations() {
     let taskId = getArg('--task');
@@ -496,20 +516,16 @@ async function downloadAnnotations() {
     if (!taskId) {
         taskId = await selectTaskIdInteractively();
     }
-    const response = await authedFetch(`/api/cli/tasks/${taskId}/export?format=${format}`);
-    if (!response.ok) {
-        throw new Error(`Download failed: ${await response.text()}`);
-    }
     const fallbackName = `${taskId}.${format}`;
     const filename = outPathArg
         ? expandHomePath(outPathArg)
         : fallbackName;
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    writeFileSync(filename, bytes);
+    const { runTaskExportDownload } = await import('./task-export-workflow.js');
+    await runTaskExportDownload(taskId, format, filename);
     if (hasJsonFlag()) {
         printJson({ taskId, format, savedTo: filename });
         return;
     }
     printLine(`Saved ${format.toUpperCase()} export to ${sanitizeTerminalText(filename)}`);
 }
-export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };
+export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, listDatasetSplitSets, showDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };

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

@@ -0,0 +1,4 @@
+export declare function deleteDataset(datasetId: string, project: string | null): Promise<{
+    id: string;
+}>;
+//# sourceMappingURL=dataset-delete-workflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-delete-workflow.d.ts","sourceRoot":"","sources":["../src/dataset-delete-workflow.ts"],"names":[],"mappings":"AAmEA,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAItG"}

package/dist/dataset-delete-workflow.js

@@ -0,0 +1,75 @@
+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_DELETED = 'The dataset may already be deleted: check with `orizu datasets list --status all` before retrying.';
+const DeleteReply = Schema.Struct({ dataset: Schema.Struct({ id: Schema.String }) });
+// A refusal (4xx) means nothing was deleted. After any other failure once the
+// request was sent, the delete may have committed, and it cannot be undone.
+class DeleteFailure extends Error {
+    mayBeDeleted;
+    constructor(message, mayBeDeleted) {
+        super(message);
+        this.mayBeDeleted = mayBeDeleted;
+    }
+}
+function deleteRequest(datasetId, project, 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)}`, {
+                        method: 'DELETE',
+                        signal: request.signal,
+                    }, () => { sent = true; });
+                    if (!response.ok) {
+                        const message = `Delete failed: ${await response.text()}`;
+                        // A dependency refusal: archiving keeps the dataset and its references.
+                        if (response.status === 409) {
+                            const archive = `orizu datasets archive ${datasetId}${project ? ` --project ${project}` : ''}`;
+                            throw new DeleteFailure(`${message}\nArchive it instead: \`${archive}\``, false);
+                        }
+                        throw new DeleteFailure(message, response.status < 400 || response.status >= 500);
+                    }
+                    const data = await parseJsonResponse(response, 'Dataset delete');
+                    const decoded = Schema.decodeUnknownResult(DeleteReply)(data);
+                    if (Result.isFailure(decoded)) {
+                        throw new DeleteFailure(`Dataset delete 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 DeleteFailure('DATASET_TRANSFER_TIMEOUT: Dataset delete exceeded its deadline', true);
+                if (cause instanceof DeleteFailure)
+                    return cause;
+                return new DeleteFailure(cause instanceof Error ? cause.message : String(cause), sent);
+            },
+        });
+    }).pipe(Effect.mapError(failure => new Error(failure.mayBeDeleted ? `${failure.message}\n${MAY_BE_DELETED}` : failure.message)));
+}
+// Runs after the typed confirmation. Nothing to clean up, so signals keep
+// Node's default handling.
+// `project` (team/project), when known, goes into the archive hint.
+export async function deleteDataset(datasetId, project) {
+    const exit = await Effect.runPromiseExit(deleteRequest(datasetId, project, datasetTransferTimeoutMs()));
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    throw Cause.squash(exit.cause);
+}