@evolvingmachines/evolve 0.0.65 → 0.0.67

package/skills/evolve-evals/references/sdk-reference/checks.mdx

@@ -1,300 +0,0 @@
----
-title: "checks"
-description: "Start and read task quality checks."
----
-
-`checks()` returns the checks client.
-
-## create
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    create(input: { source: { directory: string } | { dataset: string }; name?: string; model_name?: string; rubric?: Rubric; prompt?: string; reasoning_effort?: string; sandbox_provider?: EvalSandboxProvider; n_concurrent?: number; include_task_names?: string[]; exclude_task_names?: string[]; n_tasks?: number; onUploadProgress?: (sentBytes: number, totalBytes: number) => void }): Promise<Check>
-    ```
-
-    Check a local task directory or a directory of them, uploaded as one archive (`upload_too_large` past the published ceiling), or a published dataset, nothing uploaded. Returns the accepted check with one `queued` result per task; an empty selection is refused with `no_checkable_tasks`, and a dataset version resolves as for a job (`dataset_not_found`, `no_active_version`, `version_not_ready`). A check on a dataset version also appears on every job spanning it, as `check` on `jobs().tasks()` rows.
-
-    ```ts
-    const check = await checks().create({ source: { dataset: "my-swe@1.0" } });
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def create(
-        directory: Optional[str] = None,
-        *,
-        dataset: Optional[str] = None,
-        name=None,
-        model_name=None,
-        rubric: Optional[Rubric] = None,
-        prompt=None,
-        reasoning_effort=None,
-        sandbox_provider=None,
-        n_concurrent=None,
-        include_task_names=None,
-        exclude_task_names=None,
-        n_tasks=None,
-        on_upload_progress=None,
-    ) -> Check
-    ```
-
-    Check a local task directory or a directory of them, uploaded as one archive (`upload_too_large` past the published ceiling), or a published dataset, nothing uploaded; one source, not both. Returns the accepted check with one `queued` result per task; an empty selection is refused with `no_checkable_tasks`, and a dataset version resolves as for a job. A check on a dataset version also appears on every job spanning it, as `check` on `jobs().tasks()` rows.
-
-    ```python
-    check = await checks().create(dataset="my-swe@1.0")
-    ```
-  </Tab>
-</Tabs>
-
-## get, list, watch
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    get(checkId: string): Promise<Check>
-    list(options?: { scope?: "my" | "shared" | "org"; status?: CheckStatus[]; dataset?: string; limit?: number; cursor?: string }): CheckList
-    watch(checkId: string, options?: { onProgress?: (check: Check) => void; signal?: AbortSignal; pollIntervalMs?: number }): Promise<Check>
-    ```
-
-    One check with its per-task results, your checks (`scope: "shared"` is your organizations' and the checks shared with your address; `scope: "org"` is every check in your organizations, yours included), or a poll until every task settled. `dataset` keeps only the checks on one dataset: a bare name is every version, `name@version` one version.
-
-    ```ts
-    const done = await checks().watch(check.id);
-    const onTb4 = await checks().list({ dataset: "terminal-bench-4@4.0" });
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def get(check_id: str) -> Check
-    def list(
-        *,
-        scope: Optional[JobListScope] = None,
-        status: Optional[List[CheckStatus]] = None,
-        dataset: Optional[str] = None,
-        limit: Optional[int] = None,
-        cursor: Optional[str] = None,
-    )
-    async def watch(
-        check_id: str,
-        *,
-        on_progress: Optional[Callable[[Check], None]] = None,
-        poll_interval_s: float = 2.0,
-        timeout_s: Optional[float] = None,
-    ) -> Check
-    ```
-
-    One check with its per-task results, your checks, or a poll until every task settled. `dataset` keeps only the checks on one dataset: a bare name is every version, `name@version` one version.
-
-    ```python
-    done = await checks().watch(check.id)
-    on_tb4 = await checks().list(dataset="terminal-bench-4@4.0")
-    ```
-  </Tab>
-</Tabs>
-
-## defaults
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    defaults(): Promise<CheckDefaults>
-    ```
-
-    The defaults a check runs under when you name none: `model_name`, `reasoning_effort`, `sandbox_provider`, the platform's `rubric`, and `prompt`, the built-in check prompt as a template with `{task_path}`, `{file_tree}` and `{criteria_guidance}` unrendered. Edit the rubric or the prompt from here and pass it to `create`; passed back unchanged, they run exactly as the defaults do, and the check records them as named, so a later change of the platform default does not move it.
-
-    ```ts
-    const { rubric } = await checks().defaults();
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def defaults() -> CheckDefaults
-    ```
-
-    The defaults a check runs under when you name none: `model_name`, `reasoning_effort`, `sandbox_provider`, the platform's `rubric`, and `prompt`, the built-in check prompt as a template with `{task_path}`, `{file_tree}` and `{criteria_guidance}` unrendered. Edit the rubric or the prompt from here and pass it to `create`; passed back unchanged, they run exactly as the defaults do, and the check records them as named, so a later change of the platform default does not move it.
-
-    ```python
-    rubric = (await checks().defaults())["rubric"]
-    ```
-  </Tab>
-</Tabs>
-
-## task, transcript, artifact
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    task(taskCheckId: string): Promise<TaskCheck>
-    transcript(
-      taskCheckId: string,
-      options?: { since?: number },
-    ): Promise<TaskCheckTranscript>
-    artifact(
-      taskCheckId: string,
-      stream: "trace-stdout" | "trace-stderr",
-    ): Promise<string | null>
-    artifact(
-      taskCheckId: string,
-      stream: "agent-home",
-    ): Promise<Record<string, string> | null>
-    ```
-
-    One task's result by its task check id, the checker's own transcript (everything after `since` in one read), or one stored artifact; a task check has no verifier log and no trajectory. An id you may not read answers `trial_not_found`.
-
-    ```ts
-    const result = await checks().task(done.results[0].id);
-    ```
-  </Tab>
-  <Tab title="Python">
-    The Python client has no per-task reads. A task's result is in `Check.results`, returned by `get` and `watch`.
-  </Tab>
-</Tabs>
-
-## download
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    download(id: string): Promise<Buffer>
-    download(
-      id: string,
-      options: { to: string },
-    ): Promise<string>
-    download(
-      id: string,
-      options: { stream: true },
-    ): Promise<ReadableStream<Uint8Array>>
-    ```
-
-    The whole check by its check id (`check-<id>/` with `check_report.json` and one folder per task), or one task's folder by its task check id (`check-<task>__<7 chars>/`), as one `.tar.gz`. Each task folder is a trial tree of the checker's own run, with `artifacts/check-result.json` on a completed run. An id that is neither answers `check_not_found`; an unsettled check or task check answers `check_not_terminal`.
-
-    ```ts
-    const path = await checks().download(
-      check.id,
-      { to: "./checks" },
-    );
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def download(
-        id: str,
-        *,
-        to: Optional[str] = None,
-    )
-    ```
-
-    The whole check by its check id (`check-<id>/` with `check_report.json` and one folder per task), or one task's folder by its task check id (`check-<task>__<7 chars>/`), as one `.tar.gz`. An id that is neither answers `check_not_found`; an unsettled check or task check answers `check_not_terminal`.
-
-    ```python
-    path = await checks().download(
-        check.id,
-        to="./checks",
-    )
-    ```
-  </Tab>
-</Tabs>
-
-## share, unshare, shares
-
-Share a check you created by link, by email, or both — the [job share](/sdk-reference/jobs#share) verbs on a check, with the same arguments and the same `JobShares` answer. `link: true` turns on the check's unlisted link and returns it (the same link on every later call); whoever opens it reads the check's report and downloads its check folder without signing in. Each address in `emails` gets an email with a link and reads the check after signing in with that address; an address without an account gets a sign-up link in the same email. Someone the check is shared with reads the report, each task check's files and the download, and lists it under `scope: "shared"`; they only read, and can never stop one of its task checks. Only the creator may share; another member of the organization is refused with `org_forbidden`. `unshare` takes the same arguments and turns the link off or removes those addresses; `shares` prints the share state. A check's `visibility` field says `PRIVATE` or `LINK`.
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    share(id: string, request: { link?: boolean; emails?: string[] }): Promise<JobShares>
-    unshare(id: string, request: { link?: boolean; emails?: string[] }): Promise<JobShares>
-    shares(id: string): Promise<JobShares>
-    ```
-
-    ```ts
-    const state = await checks().share(check.id, { link: true, emails: ["alice@example.org"] });
-    console.log(state.link.url);
-    await checks().unshare(check.id, { link: true });
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def share(id: str, *, link: bool = False, emails: list[str] | None = None) -> JobShares
-    async def unshare(id: str, *, link: bool = False, emails: list[str] | None = None) -> JobShares
-    async def shares(id: str) -> JobShares
-    ```
-
-    ```python
-    state = await checks().share(check["id"], link=True, emails=["alice@example.org"])
-    print(state.link.url)
-    await checks().unshare(check["id"], link=True)
-    ```
-  </Tab>
-</Tabs>
-
-## taskFilesystem(checkId: string, taskCheckId: string)
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    taskFilesystem(checkId: string, taskCheckId: string): RunFilesystem
-
-    interface RunFilesystem {
-      status(): Promise<FilesystemStatus>
-      list(options?: { path?: string; source?: "live" | "capture"; cursor?: string; limit?: number }): Promise<FilesystemListing>
-      read(path: string, options?: { source?: "live" | "capture"; range?: TrialFileRange }): Promise<Buffer>
-      search(options: { q: string; path?: string; regex?: boolean; limit?: number; source?: "live" | "capture" }): Promise<FilesystemSearchResult>
-      changes(options?: { source?: "live" | "capture"; phase?: "setup" | "agent" | "verifier" | "all"; cursor?: string; limit?: number }): Promise<FilesystemChanges>
-      archive(options?: { path?: string; source?: "live" | "capture" }): Promise<Buffer>
-      archive(options: { path?: string; source?: "live" | "capture"; to: string }): Promise<string>
-      watch(paths: string[]): Promise<FilesystemWatchResult>
-      events(options?: { lastEventId?: string; signal?: AbortSignal }): AsyncIterableIterator<FilesystemStreamEvent>
-      logs(options: { stream: SandboxLogStream; cursor?: string; limit?: number }): Promise<SandboxLogLines>
-      logEvents(options?: { lastEventId?: string; signal?: AbortSignal }): AsyncIterableIterator<SandboxLogEvent>
-      procs(): Promise<SandboxProcs>
-    }
-    ```
-
-    The task check's file system, sandbox logs and process list. While the box runs, every read sees it as it changes; after the run, the same reads answer from the kept tree. `status()` says which (`state`: `live`, `captured`, `capturing`, `none`), and `source` on a read forces one — a source that is not there is refused with `filesystem_state`.
-
-    `list` pages one folder by name; each entry says whether the run created or modified it and in which phase, and on the kept tree `captured: false` marks a file the run never touched (it lists but does not open — `not_captured`). `read` answers raw bytes, a slice with `range`. `search` finds text under a folder, or over the whole box when `path` is `/` (seconds); `truncated` says there was more. `changes` is the flat list of what the run created, modified or removed. `archive` is a `.tar.gz` of one subtree, in memory or saved under `to`; while the box runs, a subtree too large to read out in time is refused (`feature_unsupported`).
-
-    `events` yields change frames while the box lives (`state`, then one `fs` per change with its `seq`, `path` and `type`); on a provider without a native watcher, `watch(paths)` declares the folders you have open so their changes are reported (at most 8). `logs` pages one stream — `agent`, `verifier`, or `system` when the job asked for it; `setup` and `metrics` are named but not recorded today, so their page is empty with a `reason` — and `logEvents` follows every stream while the box lives. `procs` is the live process list.
-
-    ```ts
-    const fs = checks().taskFilesystem(check.id, check.results[0].id);
-    const { state } = await fs.status();
-    for (const entry of (await fs.list({ path: "/app/work" })).entries) console.log(entry.name, entry.changed);
-    const main = (await fs.read("/app/work/main.py")).toString("utf8");
-    for await (const frame of fs.events()) if (frame.event === "fs") console.log(frame.data.path, frame.data.type);
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    def task_filesystem(self, check_id: str, task_check_id: str) -> RunFilesystem
-
-    class RunFilesystem:
-        async def status(self) -> FilesystemStatus
-        async def list(self, *, path="/", source=None, cursor=None, limit=None) -> FilesystemListing
-        async def read(self, path, *, source=None, start=None, end=None, suffix=None) -> bytes
-        async def search(self, q, *, path="/", regex=False, limit=None, source=None) -> FilesystemSearchResult
-        async def changes(self, *, source=None, phase=None, cursor=None, limit=None) -> FilesystemChanges
-        async def archive(self, *, path="/", source=None, to=None)  # bytes, or the saved path with to=
-        async def watch(self, paths) -> FilesystemWatchResult
-        def events(self, *, last_event_id=None) -> AsyncIterator[FilesystemStreamEvent]
-        async def logs(self, stream, *, cursor=None, limit=None) -> SandboxLogLines
-        def log_events(self, *, last_event_id=None) -> AsyncIterator[SandboxLogEvent]
-        async def procs(self) -> SandboxProcs
-    ```
-
-    The same surface, the same words: `status().state` says whether the reads answer from the running box (`live`) or the kept tree (`captured`); `source=` forces one. `read` answers bytes, a slice with `start`/`end` or `suffix`. `events` and `log_events` are async iterators over the live streams.
-
-    ```python
-    fs = checks().task_filesystem(check["id"], check["results"][0]["id"])
-    print((await fs.status()).state)
-    for entry in (await fs.list(path="/app/work")).entries:
-        print(entry.name, entry.changed)
-    main = (await fs.read("/app/work/main.py")).decode()
-    async for frame in fs.events():
-        if frame.event == "fs":
-            print(frame.data["path"], frame.data["type"])
-    ```
-  </Tab>
-</Tabs>

package/skills/evolve-evals/references/sdk-reference/datasets.mdx

@@ -1,346 +0,0 @@
----
-title: "datasets"
-description: "The catalog: list, read, publish, download, activate, delete."
----
-
-`datasets()` returns the catalog client. A `ref` is `name` or `name@version`.
-
-## list, get, getActive
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    list(options?: { search?: string; limit?: number; cursor?: string }): DatasetList
-    get(
-      ref: string,
-      options?: { limit?: number; cursor?: string },
-    ): Promise<Dataset>
-    getActive(
-      name: string,
-      options?: { limit?: number; cursor?: string },
-    ): Promise<ActiveDataset>
-    ```
-
-    The catalog, one dataset with one page of its tasks (default 200, at most 500), or the active version alone. `getActive` throws `NoActiveVersionError` when nothing is runnable. A task row carries public fields only; see [Task](/sdk-reference/types#task).
-
-    ```ts
-    const dataset = await datasets().get("terminal-bench-4@4.0");
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    def list(
-        *,
-        search: Optional[str] = None,
-        limit: Optional[int] = None,
-        cursor: Optional[str] = None,
-    )
-    async def get(
-        ref: str,
-        *,
-        limit: Optional[int] = None,
-        cursor: Optional[str] = None,
-    ) -> Dataset
-    async def get_active(
-        name: str,
-        *,
-        limit: Optional[int] = None,
-        cursor: Optional[str] = None,
-    ) -> ActiveDataset
-    ```
-
-    The catalog, one dataset with one page of its tasks, or the active version alone. `get_active` raises `NoActiveVersionError` when nothing is runnable.
-
-    ```python
-    dataset = await datasets().get("terminal-bench-4@4.0")
-    ```
-  </Tab>
-</Tabs>
-
-## getTaskBuild
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    getTaskBuild(
-      ref: string,
-      taskName: string,
-    ): Promise<TaskBuild>
-    ```
-
-    One task's build record: its outcome and, on failure, the failing step and log.
-
-    ```ts
-    const build = await datasets().getTaskBuild("my-swe@1.0", "broken-task");
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def get_task_build(
-        ref: str,
-        task_name: str,
-    ) -> TaskBuild
-    ```
-
-    One task's build record: its outcome and, on failure, the failing step and log.
-
-    ```python
-    build = await datasets().get_task_build("my-swe@1.0", "broken-task")
-    ```
-  </Tab>
-</Tabs>
-
-## taskFiles
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    taskFiles(ref: string, taskName: string): TaskPackageFiles
-
-    interface TaskPackageFiles {
-      status(): Promise<TaskPackageFilesystemStatus>
-      list(options?: { path?: string; cursor?: string; limit?: number }): Promise<FilesystemListing>
-      read(path: string, options?: { range?: TrialFileRange }): Promise<Buffer>
-    }
-    ```
-
-    A published task's files, exactly as the platform stored them and as every trial ran against them: `list` pages one folder of the task directory (`/` holds `instruction.md`, `task.toml`, `environment/`, `tests/`), `read` answers one file's bytes. `ref` must name the version (`name@version`); a version imported before packages were kept is refused with `task_package_not_retained` (`status().package_retained` says so first).
-
-    ```ts
-    const files = datasets().taskFiles("my-swe@1.0", "abs-1");
-    const tests = await files.list({ path: "/tests" });
-    const script = (await files.read("/tests/test.sh")).toString("utf8");
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    def task_files(self, ref: str, task_name: str) -> TaskPackageFiles
-
-    class TaskPackageFiles:
-        async def status(self) -> TaskPackageFilesystemStatus
-        async def list(self, *, path="/", cursor=None, limit=None) -> FilesystemListing
-        async def read(self, path, *, start=None, end=None, suffix=None) -> bytes
-    ```
-
-    ```python
-    files = datasets().task_files("my-swe@1.0", "abs-1")
-    tests = await files.list(path="/tests")
-    script = (await files.read("/tests/test.sh")).decode()
-    ```
-  </Tab>
-</Tabs>
-
-## preflight
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    preflight(input: { source: { directory: string } }): Promise<DatasetPreflight>
-    ```
-
-    Dry-run a local folder of tasks: only each task's metadata is sent, nothing is uploaded or written.
-
-    ```ts
-    const verdict = await datasets().preflight({ source: { directory: "./my-swe" } });
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def preflight(
-        *,
-        directory: str,
-    ) -> DatasetPreflight
-    ```
-
-    Dry-run a local folder of tasks: only each task's metadata is sent, nothing is uploaded or written.
-
-    ```python
-    verdict = await datasets().preflight(directory="./my-swe")
-    ```
-  </Tab>
-</Tabs>
-
-## publish
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    publish(input: { source: DatasetSource; name?: string; version?: string; org?: string }, options?: { onUploadProgress?: (sentBytes: number, totalBytes: number) => void; onRegistered?: (importId: string) => void }): Promise<DatasetImport>
-    ```
-
-    Publish a version from one `source`: `{ git_url, git_ref, git_path? }` (an `https://` URL, and a subfolder that exists at the ref), `{ directory }`, `{ archive_url }` or `{ hub_package }`. `org` names the organization a new dataset lands in (omitted, the client's `org` default, else your personal one). An existing dataset stays where it is only when no org reaches the server; a named org, the client default included, that is not the dataset's own is refused with `invalid_input`, so a re-publish never moves a dataset. Returns the import record; follow it with `watchImport`.
-
-    `onUploadProgress` reports sent bytes for a directory source, and `onRegistered` fires once with the import id when a large upload begins. What is packed is on [datasets](/core-concepts/datasets#publish-your-own).
-
-    ```ts
-    const imp = await datasets().publish({
-      source: { directory: "./my-swe" },
-      name: "my-swe",
-      version: "1.0",
-    });
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def publish(
-        *,
-        git_url=None,
-        git_ref=None,
-        git_path=None,
-        directory=None,
-        archive_url=None,
-        hub_package=None,
-        name=None,
-        version=None,
-        org=None,
-        on_upload_progress=None,
-        on_registered=None,
-    ) -> DatasetImport
-    ```
-
-    Publish a version from one source: `git_url` with `git_ref` (and `git_path`), `directory`, `archive_url`, or `hub_package`. `org` names the organization a new dataset lands in (omitted, the client's `org` default, else your personal one). An existing dataset stays where it is only when no org reaches the server; a named org, the client default included, that is not the dataset's own is refused with `invalid_input`, so a re-publish never moves a dataset. Returns the import record; follow it with `watch_import`.
-
-    ```python
-    imp = await datasets().publish(
-        directory="./my-swe",
-        name="my-swe",
-        version="1.0",
-    )
-    ```
-  </Tab>
-</Tabs>
-
-## getImport, watchImport, listImports
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    getImport(id: string): Promise<DatasetImport>
-    watchImport(id: string, options?: { onStatus?: (datasetImport: DatasetImport) => void; onProgress?: (progress: DatasetImportProgress, datasetImport: DatasetImport) => void; onVersion?: (version: DatasetVersion, dataset: Dataset) => void; signal?: AbortSignal; pollIntervalMs?: number; settleTimeoutMs?: number }): Promise<DatasetImport>
-    listImports(options?: { status?: DatasetImportStatus; dataset?: string; limit?: number; cursor?: string }): DatasetImportList
-    ```
-
-    Read one publish, follow it until the version is READY or FAILED, or list your publishes. `watchImport` polls every `pollIntervalMs` (default 2000): `onStatus` fires on every status change, `onProgress` on every change of the five-phase `progress` (`extracting`, `parsing`, `building`, `copying`, `verifying`), `onVersion` on the version's state. `settleTimeoutMs` (default 30 minutes) bounds the wait; past it the watch throws `ImportSettleError` with the last observed state. `listImports` filters by `status` and `dataset`.
-
-    ```ts
-    const done = await datasets().watchImport(imp.id);
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def get_import(id: str) -> DatasetImport
-    async def watch_import(
-        id: str,
-        *,
-        on_status=None,
-        on_progress=None,
-        on_version=None,
-        poll_interval_s: float = 2.0,
-        timeout_s: Optional[float] = None,
-        settle_timeout_s: float = ...,
-    ) -> DatasetImport
-    def list_imports(
-        *,
-        status: Optional[str] = None,
-        dataset: Optional[str] = None,
-        limit: Optional[int] = None,
-        cursor: Optional[str] = None,
-    )
-    ```
-
-    Read one publish, follow it until the version is READY or FAILED, or list your publishes. `watch_import` polls every `poll_interval_s`: `on_status` fires on every status change, `on_progress` on every change of the five-phase `progress` (`extracting`, `parsing`, `building`, `copying`, `verifying`), `on_version` on the version's state. `settle_timeout_s` (default 30 minutes) bounds the wait; past it the watch raises `ImportSettleError` with the last observed state. `list_imports` filters by `status` and `dataset`.
-
-    ```python
-    done = await datasets().watch_import(imp.id)
-    ```
-  </Tab>
-</Tabs>
-
-## download
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    download(ref: string): Promise<Buffer>
-    download(
-      ref: string,
-      options: { to: string },
-    ): Promise<string>
-    download(
-      ref: string,
-      options: { stream: true },
-    ): Promise<ReadableStream<Uint8Array>>
-    ```
-
-    The original package of a dataset you own: the bytes, the saved file's path, or a stream. The Buffer and `{ to }` shapes verify the download against the digest the server states and throw `EvolveDigestMismatchError` on a mismatch; `{ stream: true }` is unverified. A version published before packages were retained answers `package_not_retained`. Prefer `{ to }` for anything sizeable.
-
-    ```ts
-    const path = await datasets().download(
-      "my-swe@1.0",
-      { to: "./corpora" },
-    );
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def download(
-        ref: str,
-        *,
-        to: Optional[str] = None,
-    )
-    ```
-
-    The original package of a dataset you own: the bytes, or with `to` the saved file's path. Both shapes verify the download against the digest the server states, raising `EvolveDigestMismatchError` on a mismatch. A version published before packages were retained answers `package_not_retained`. Prefer `to` for anything sizeable.
-
-    ```python
-    path = await datasets().download(
-        "my-swe@1.0",
-        to="./corpora",
-    )
-    ```
-  </Tab>
-</Tabs>
-
-## activate, update, delete
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    activate(
-      name: string,
-      version: string,
-    ): Promise<Dataset>
-    update(
-      name: string,
-      patch: { upstream_auto_import: boolean },
-    ): Promise<Dataset>
-    delete(name: string): Promise<void>
-    ```
-
-    Make a READY version the active one (`version_not_ready` while building, `version_not_activatable` for FAILED or ARCHIVED), switch automatic import of new upstream versions (`upstream_not_watchable` without a moving git ref), or delete a dataset you own (`dataset_not_owned` on a platform dataset, `dataset_in_use` naming the jobs that reference it).
-
-    ```ts
-    await datasets().activate("my-swe", "1.0");
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def activate(
-        name: str,
-        version: str,
-    ) -> Dataset
-    async def update(
-        name: str,
-        *,
-        upstream_auto_import: bool,
-    ) -> Dataset
-    async def delete(name: str) -> None
-    ```
-
-    Make a READY version the active one (`version_not_ready` while building, `version_not_activatable` for FAILED or ARCHIVED), switch automatic import of new upstream versions (`upstream_not_watchable` without a moving git ref), or delete a dataset you own (`dataset_not_owned` on a platform dataset, `dataset_in_use` naming the jobs that reference it).
-
-    ```python
-    await datasets().activate("my-swe", "1.0")
-    ```
-  </Tab>
-</Tabs>