orizu 0.5.39 → 0.5.40

package/src/instruction-sets-cli.ts

@@ -1,9 +1,9 @@
 import { authedFetch } from './http.js'
 import { INSTRUCTION_SET_COMPONENT_KEY } from './instruction-set-lock/index.js'
 import { loadInstructionSetManifest, MAX_INSTRUCTION_SET_COMPONENT_BYTES, type InstructionSetManifest } from './instruction-set-manifest.js'
-import { sanitizeHumanInlineText, sanitizeTerminalText } from './json-response.js'
-import { parseSyncTarget, planSyncRequest, syncPayloadToDisk, type SyncPayload, type SyncTarget } from './instruction-set-sync/index.js'
-import { applyPrune, applyUpdate, lockedProfileIdentity, makeUpdatePlan, planPrune, PruneKeepUnresolvedError, readUpdateLock } from './instruction-set-update/index.js'
+import { responsePayload, sanitizeHumanInlineText, sanitizeTerminalText } from './json-response.js'
+import { parseSyncTarget, planSyncRequest, type SyncTarget } from './instruction-set-sync/index.js'
+import { applyPrune, planPrune, PruneKeepUnresolvedError } from './instruction-set-update/index.js'
 import { printVerifyReport, verifyInstructionSetTree } from './instruction-set-verify/index.js'
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
@@ -74,12 +74,8 @@ function lifecycleOptionValues(args: string[], command: 'update' | 'prune', flag
   return values
 }
 
-async function responsePayload(response: Response, action: string): Promise<Record<string, unknown>> {
-  const payload = await response.json().catch(() => ({})) as Record<string, unknown>
-  if (!response.ok) {
-    throw new Error(`${action} failed (${response.status}): ${typeof payload.error === 'string' ? payload.error : response.statusText}`)
-  }
-  return payload
+function printInterrupted(io: InstructionSetsCommandIo, message: string) {
+  io.print(io.json ? JSON.stringify({ error: message }) : message)
 }
 
 const SAFE_SEGMENT = /^[A-Za-z0-9._-]+$/u
@@ -340,23 +336,14 @@ export async function instructionSetsCommand(args: string[], io: InstructionSets
   const project = await io.resolveProjectSlug(projectOption)
   if (subcommand === 'update') {
     const output = lifecycleOptionValues(args, 'update', '--out')[0] ?? '.'
-    const lock = readUpdateLock(output, project)
-    const payloads: SyncPayload[] = []
-    for (const [setSlug, set] of Object.entries(lock.instructionSets)) {
-      const barePath = `/api/cli/instruction-sets/${encodeURIComponent(setSlug)}/sync?project=${encodeURIComponent(project)}`
-      payloads.push(await responsePayload(await authedFetch(barePath, { method: 'GET' }), 'Instruction sets update') as unknown as SyncPayload)
-      for (const profileSlugValue of Object.keys(set.profiles)) {
-        const identity = lockedProfileIdentity(output, setSlug, profileSlugValue)
-        const query = new URLSearchParams({ project, profile: identity })
-        const path = `/api/cli/instruction-sets/${encodeURIComponent(setSlug)}/sync?${query.toString()}`
-        payloads.push(await responsePayload(await authedFetch(path, { method: 'GET' }), 'Instruction sets update') as unknown as SyncPayload)
-      }
-    }
-    const plan = makeUpdatePlan(project, lock, payloads)
     const isApproved = args.includes('--yes')
-    const result = isApproved
-      ? await applyUpdate(output, project, plan, args.includes('--no-sync'))
-      : { absent: [], warnings: [] }
+    const { updateInstructionSets } = await import('./instruction-delivery.js')
+    const updated = await updateInstructionSets(output, project, isApproved, args.includes('--no-sync'))
+    if ('interrupted' in updated) {
+      printInterrupted(io, 'Instruction sets update interrupted; some sets may already be updated. Run orizu instructions update again, then orizu instructions verify.')
+      return updated.interrupted
+    }
+    const { plan, result } = updated
     if (io.json) io.print(JSON.stringify({ plan: plan.lines, applied: isApproved, absent: result.absent, warnings: result.warnings }))
     else {
       for (const line of plan.lines) io.print(line)
@@ -527,11 +514,16 @@ export async function instructionSetsCommand(args: string[], io: InstructionSets
     if (unknownOption) throw new Error(`instruction_set_sync_option_unknown:${unknownOption}`)
     const output = requiredOptionValue(args, subcommand, '--out') ?? '.'
     const plan = planSyncRequest(reference, requiredOptionValue(args, subcommand, '--version'), output, project)
-    const payload = await responsePayload(await authedFetch(plan.path, { method: 'GET' }), 'Instruction sets sync') as unknown as SyncPayload
-    const result = syncPayloadToDisk(output, project, plan, payload, {
+    const { syncInstructionSet } = await import('./instruction-delivery.js')
+    const delivered = await syncInstructionSet(output, project, plan, {
       forceHelpers: args.includes('--force-helpers'),
       target: syncTarget!,
     })
+    if ('interrupted' in delivered) {
+      printInterrupted(io, 'Instruction set sync interrupted; any unpublished staged version was removed. Run orizu instructions sync again.')
+      return delivered.interrupted
+    }
+    const { payload, result } = delivered
     if (io.json) io.print(JSON.stringify({ ...payload, warnings: result.warnings }))
     else {
       io.print(`Synced ${reference} to ${result.destination}`)

package/src/json-response.ts

@@ -35,3 +35,11 @@ export async function parseJsonResponse<T>(
     )
   }
 }
+
+export async function responsePayload(response: Response, action: string): Promise<Record<string, unknown>> {
+  const payload = await response.json().catch(() => ({})) as Record<string, unknown>
+  if (!response.ok) {
+    throw new Error(`${action} failed (${response.status}): ${typeof payload.error === 'string' ? payload.error : response.statusText}`)
+  }
+  return payload
+}

package/src/preview-runtime.ts

@@ -112,8 +112,8 @@ interface PreviewPage {
   screenshot: (options: { path: string; fullPage: boolean }) => Promise<unknown>
   waitForTimeout: (timeout: number) => Promise<unknown>
   once?: (event: string, listener: () => void) => unknown
-  on?: (event: string, listener: () => void) => unknown
-  off?: (event: string, listener: () => void) => unknown
+  on?: (event: string, listener: (error: Error) => void) => unknown
+  off?: (event: string, listener: (error: Error) => void) => unknown
 }
 
 function isNodeError(error: unknown): error is NodeJS.ErrnoException {
@@ -256,19 +256,32 @@ export async function runLocalAppPreview(options: AppPreviewOptions): Promise<Ap
       headless: !options.headed,
       ...(chromiumExecutablePath ? { executablePath: chromiumExecutablePath } : {}),
     })
-    const page = await browser.newPage({ viewport: { width: 1440, height: 1000 } })
-
+    let page: PreviewPage | null = null
+    let handleRenderError: ((error: Error) => void) | undefined
+    let hasFinishedKeepingOpen = false
     try {
-      await page.goto(url, { waitUntil: 'networkidle' })
-      await page.waitForSelector('[data-orizu-preview-ready="true"]', { timeout: 15_000 })
+      page = await browser.newPage({ viewport: { width: 1440, height: 1000 } })
+      const renderError = new Promise<never>((_, reject) => {
+        handleRenderError = error => reject(new Error(`App preview render failed: ${error.message}`))
+        page?.on?.('pageerror', handleRenderError)
+      })
+      // Listen before navigation: React can fail before the ready marker mounts.
+      await Promise.race([
+        page.goto(url, { waitUntil: 'networkidle' }).then(() =>
+          page!.waitForSelector('[data-orizu-preview-ready="true"]', { timeout: 15_000 })
+        ),
+        renderError,
+      ])
       if (options.screenshotPath) {
         await page.screenshot({ path: options.screenshotPath, fullPage: true })
       }
       if (options.keepOpen) {
         await waitForPreviewClose(page, browser)
+        hasFinishedKeepingOpen = true
       }
     } finally {
-      if (!options.keepOpen) {
+      if (handleRenderError) page?.off?.('pageerror', handleRenderError)
+      if (!hasFinishedKeepingOpen) {
         await browser.close()
       }
     }
@@ -826,7 +839,8 @@ export default TextContent
 import React from 'react'
 function cn(...values) { return values.filter(Boolean).join(' ') }
 export function CodeBlock({ code, children, className, ...props }) {
-  return <pre {...props} className={cn('overflow-auto rounded-md border bg-muted p-3 font-mono text-xs', className)}><code>{children ?? code}</code></pre>
+  const codeText = Array.isArray(code) ? code.map(line => line.content).join('\\n') : code
+  return <pre {...props} className={cn('overflow-auto rounded-md border bg-muted p-3 font-mono text-xs', className)}><code>{children ?? codeText}</code></pre>
 }
 export default CodeBlock
 `
@@ -843,8 +857,24 @@ export default Prose
   const contentRendererSource = `
 import React from 'react'
 function cn(...values) { return values.filter(Boolean).join(' ') }
-export function ContentRenderer({ content, children, className, ...props }) {
-  return <div {...props} className={cn('whitespace-pre-wrap text-sm leading-relaxed', className)}>{children ?? content}</div>
+export function ContentRenderer({ contentType, content, maxHeight = '400px', customRenderer, className }) {
+  let renderedContent
+  switch (contentType) {
+    case 'image':
+      renderedContent = <div className="flex items-center justify-center p-2"><img src={content} alt="Content" width={800} height={600} className="max-w-full object-contain" style={{ maxHeight, height: 'auto', width: 'auto' }} /></div>
+      break
+    case 'video':
+      renderedContent = <div className="flex h-full justify-center p-2"><video src={content} controls className="max-h-full max-w-full" /></div>
+      break
+    case 'custom':
+      renderedContent = customRenderer ? customRenderer({ content }) : <p className="text-destructive">Custom renderer required for custom content type</p>
+      break
+    default:
+      renderedContent = <p>Invalid content type</p>
+  }
+  return maxHeight
+    ? <div className={cn('overflow-auto', className)} style={{ maxHeight }}>{renderedContent}</div>
+    : renderedContent
 }
 export default ContentRenderer
 `

package/src/task-export-workflow.ts

@@ -0,0 +1,56 @@
+import { Effect, Exit, Result } from 'effect'
+import { renameSync, rmSync, writeFileSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+
+import { authedFetch } from './http.js'
+
+export type TaskExportFormat = 'csv' | 'json' | 'jsonl'
+
+// Node's "CODE: description, syscall 'path'" without the syscall and path, so a
+// failed save names the user's target rather than the temp file.
+function saveFailureReason(cause: unknown): string {
+  const message = cause instanceof Error ? cause.message : String(cause)
+  return message.replace(/, \w+( '.*')?$/, '')
+}
+
+/**
+ * Writes the export beside `target` and renames it over the target, so a failed
+ * or interrupted save never touches the file the user already has. The temp file
+ * is removed whenever the save does not finish.
+ */
+function saveExportFile(target: string, bytes: Uint8Array) {
+  const temp = join(dirname(target), `.${basename(target)}.${process.pid}.tmp`)
+  return Effect.acquireUseRelease(
+    Effect.succeed(temp),
+    path => Effect.try({
+      try: () => {
+        writeFileSync(path, bytes, { flag: 'wx' })
+        renameSync(path, target)
+      },
+      catch: cause => new Error(`Could not save export to ${target}: ${saveFailureReason(cause)}`, { cause }),
+    }),
+    (path, exit) => Exit.isSuccess(exit) ? Effect.void : Effect.sync(() => rmSync(path, { force: true }))
+  )
+}
+
+/**
+ * `orizu tasks export`: one GET of the export, never retried, then a safe save.
+ * A refused export fails with `Download failed: <body>` before anything is written.
+ */
+function downloadTaskExport(taskId: string, format: TaskExportFormat, target: string) {
+  return Effect.gen(function* () {
+    const response = yield* Effect.promise(() => authedFetch(`/api/cli/tasks/${taskId}/export?format=${format}`))
+    if (!response.ok) {
+      const body = yield* Effect.promise(() => response.text())
+      return yield* Effect.fail(new Error(`Download failed: ${body}`))
+    }
+    const bytes = new Uint8Array(yield* Effect.promise(() => response.arrayBuffer()))
+    yield* saveExportFile(target, bytes)
+  })
+}
+
+/** Promise runner for the command: rejects with the message the CLI prints. */
+export async function runTaskExportDownload(taskId: string, format: TaskExportFormat, target: string): Promise<void> {
+  const result = await Effect.runPromise(Effect.result(downloadTaskExport(taskId, format, target)))
+  if (Result.isFailure(result)) throw result.failure
+}

package/src/workbench-cli.ts

@@ -1176,7 +1176,7 @@ function formatSessionFinishOutcome(result: SessionFinishResult): string {
 // The web page's failed line, with the reason the server mapped (ORI-2264).
 function failedRunLine(run: { status: string; failureReason?: unknown }): string | null {
   return run.status === 'failed' && typeof run.failureReason === 'string' && run.failureReason
-    ? `The agent stopped: ${run.failureReason}.`
+    ? run.failureReason === 'The selected model is unavailable in this session.' ? run.failureReason : `The agent stopped: ${run.failureReason}.`
     : null
 }
 

package/vendor/skills/orizu/references/cli-reference.md

@@ -351,6 +351,40 @@ orizu datasets lock --dataset <datasetId|datasetUrl> --reason "Finalize for labe
 orizu datasets clone --dataset <datasetId|datasetUrl> --name "Batch 1 Copy"
 ```
 
+For validation-first enrichment, start with an explicit immutable version ID
+returned by upload or version creation. Discover the saved names, export the
+assignments, then download only the selected partition:
+
+```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
+```
+
+The download retains canonical `id` values and existing fields in saved partition
+order; `--format json` is also supported. Custom partition names and empty splits
+are valid. Pinned reads remain unchanged after live row edits and require no
+prompt, runner, scorer or optimization. Unknown/inaccessible or mismatched
+selectors and incomplete artifacts fail without live-data fallback.
+
+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.
+
+Enrich rows outside Orizu, preserving every canonical `id`. Assemble the complete
+enriched dataset, including other partitions, and upload or version it. Import
+assignments into the explicit new version:
+
+```bash
+orizu datasets splits create TARGET_DATASET_VERSION_ID --from-file split.json --json
+```
+
+Show JSON preserves `name`, `strategy`, `seed`, `metadata`, and
+`partitions: [{name, row_ids, metadata}]`. Set and partition metadata retain
+their JSON values, including arrays, scalars and null. Source identity never overrides the command's
+target. Every referenced ID must exist in the target; missing IDs fail rather
+than being dropped or remapped. Reads follow existing project permissions.
+
 Dataset version and split-set commands used by prompt runs are covered in `prompt-control-plane.md`.
 
 ### Model configs

package/vendor/skills/orizu/references/dataset-design.md

@@ -73,7 +73,7 @@ orizu datasets splits create <upload-returned-dataset-version-id> --from-file ./
 
 Reserve `orizu datasets versions create` for a subsequent snapshot, and give it a new label such as `v2`; labels are unique within a dataset. The dataset README should record source approval, source locators, sampling decisions, deduplication rules, the coverage table, ground-truth status, and the split rationale.
 
-The dataset version freezes its rows. Server-side split membership is mutable, but the CLI exposes no split-set read operation, so membership cannot be re-read through the CLI. Treat the independently reviewed local split file plus the returned split-set ID as the canonical record available to this workflow. Do not mutate that server-side split set; pass the recorded `--dataset-version-id` and `--split-set-id` to `orizu optimizations run-gepa`, and record the CLI verification gap explicitly rather than claiming the server membership was re-verified.
+The dataset version freezes its rows. After creating the split set, re-read its saved membership with `orizu datasets splits show <split-set-id> --json` and confirm it matches the reviewed local split file before relying on it; the saved split set, not the local file, is the canonical record. Do not mutate that server-side split set; pass the recorded `--dataset-version-id` and `--split-set-id` to `orizu optimizations run-gepa`.
 
 ## Guard live rows before annotation and version later data
 

package/dist/dataset-edit-rows.d.ts

@@ -1,10 +0,0 @@
-export interface DatasetEditRowsOptions {
-    datasetId: string;
-    file: string;
-    json: boolean;
-    printJson: (value: Record<string, unknown>) => void;
-    printLine: (value: string) => void;
-    sanitize: (value: string) => string;
-}
-export declare function editDatasetRows(options: DatasetEditRowsOptions): Promise<void>;
-//# sourceMappingURL=dataset-edit-rows.d.ts.map

package/dist/dataset-edit-rows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataset-edit-rows.d.ts","sourceRoot":"","sources":["../src/dataset-edit-rows.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,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;AAsDD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+CpF"}

package/dist/dataset-edit-rows.js

@@ -1,90 +0,0 @@
-import { extractErrorMessage } from './error-response.js';
-import { parseDatasetFile } from './file-parser.js';
-import { authedFetch } from './http.js';
-const MAX_REQUEST_BYTES = 3 * 1024 * 1024;
-const MAX_CHUNK_ROWS = 10;
-const EMPTY_REQUEST_BYTES = Buffer.byteLength('{"rows":[]}', 'utf8');
-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;
-}
-export async function editDatasetRows(options) {
-    const { rows } = parseDatasetFile(options.file);
-    const chunks = chunkRows(normalizeRows(rows), options.sanitize);
-    let totalUpdated = 0;
-    let lastResult = null;
-    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)...`);
-        }
-        try {
-            const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(options.datasetId)}/rows`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ rows: chunk }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${await extractErrorMessage(response)}`);
-            }
-            const data = await response.json();
-            if (!Number.isInteger(data.updatedCount) || data.updatedCount !== chunk.length) {
-                throw new Error(`Server reported ${String(data.updatedCount)} updated rows for a ${chunk.length}-row chunk`);
-            }
-            totalUpdated += data.updatedCount;
-            lastResult = data;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Chunk ${index + 1}/${chunks.length} failed: ${message}\n` +
-                `${totalUpdated} rows from ${index} chunk(s) were already updated. ` +
-                'Retry with a file containing only the remaining row edits.');
-        }
-    }
-    if (!lastResult)
-        throw new Error('Dataset edit file must contain at least one row');
-    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}`);
-}

package/src/dataset-edit-rows.ts

@@ -1,124 +0,0 @@
-import { extractErrorMessage } from './error-response.js'
-import { parseDatasetFile } from './file-parser.js'
-import { authedFetch } from './http.js'
-
-const MAX_REQUEST_BYTES = 3 * 1024 * 1024
-const MAX_CHUNK_ROWS = 10
-const EMPTY_REQUEST_BYTES = Buffer.byteLength('{"rows":[]}', 'utf8')
-
-type DatasetRowEdit = Record<string, unknown> & { id: string }
-
-type EditRowsResponse = {
-  dataset: { id: string; name: string; rowCount: number }
-  updatedCount: number
-}
-
-export interface DatasetEditRowsOptions {
-  datasetId: string
-  file: string
-  json: boolean
-  printJson: (value: Record<string, unknown>) => void
-  printLine: (value: string) => void
-  sanitize: (value: string) => string
-}
-
-function normalizeRows(rows: Array<Record<string, unknown>>): DatasetRowEdit[] {
-  if (rows.length === 0) {
-    throw new Error('Dataset edit file must contain at least one row')
-  }
-
-  const seenRowIds = new Set<string>()
-  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: DatasetRowEdit[], sanitize: (value: string) => string): DatasetRowEdit[][] {
-  const chunks: DatasetRowEdit[][] = []
-  let currentChunk: DatasetRowEdit[] = []
-  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
-}
-
-export async function editDatasetRows(options: DatasetEditRowsOptions): Promise<void> {
-  const { rows } = parseDatasetFile(options.file)
-  const chunks = chunkRows(normalizeRows(rows), options.sanitize)
-  let totalUpdated = 0
-  let lastResult: EditRowsResponse | null = null
-
-  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)...`)
-    }
-
-    try {
-      const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(options.datasetId)}/rows`, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ rows: chunk }),
-      })
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${await extractErrorMessage(response)}`)
-      }
-
-      const data = await response.json() as EditRowsResponse
-      if (!Number.isInteger(data.updatedCount) || data.updatedCount !== chunk.length) {
-        throw new Error(`Server reported ${String(data.updatedCount)} updated rows for a ${chunk.length}-row chunk`)
-      }
-      totalUpdated += data.updatedCount
-      lastResult = data
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      throw new Error(
-        `Chunk ${index + 1}/${chunks.length} failed: ${message}\n` +
-        `${totalUpdated} rows from ${index} chunk(s) were already updated. ` +
-        'Retry with a file containing only the remaining row edits.'
-      )
-    }
-  }
-
-  if (!lastResult) throw new Error('Dataset edit file must contain at least one row')
-  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}`
-  )
-}