@yargote/artifacts-cli 0.1.0-beta.10 → 0.1.0-beta.11

package/README.md

@@ -11,9 +11,9 @@ Use Node 24 or later. The beta targets macOS and Linux. Windows has not been ver
 Choose one persistent installation:
 
 ```sh
-npm install --global @yargote/artifacts-cli@0.1.0-beta.10
+npm install --global @yargote/artifacts-cli@0.1.0-beta.11
 # Or, with pnpm and an existing global bin directory on PATH:
-pnpm add --global @yargote/artifacts-cli@0.1.0-beta.10
+pnpm add --global @yargote/artifacts-cli@0.1.0-beta.11
 artifacts --version
 ```
 
@@ -22,8 +22,8 @@ If pnpm reports that no global bin directory exists, run `pnpm setup` and reopen
 For one-off execution, pin the same version:
 
 ```sh
-npx --yes @yargote/artifacts-cli@0.1.0-beta.10 --help
-pnpm dlx @yargote/artifacts-cli@0.1.0-beta.10 --help
+npx --yes @yargote/artifacts-cli@0.1.0-beta.11 --help
+pnpm dlx @yargote/artifacts-cli@0.1.0-beta.11 --help
 ```
 
 `@beta` follows future prereleases. Exact versions remain reproducible. No stable `latest` release is part of this beta. An organization's pnpm minimum release age or trust policy can delay a new release. Follow that policy rather than disabling it globally.
@@ -131,6 +131,7 @@ artifacts create --command FILE
 artifacts list [--limit N] [--cursor CURSOR] [--project NAME]
 artifacts projects
 artifacts search QUERY [--project NAME] [--limit N] [--cursor CURSOR]
+artifacts batch --command FILE
 artifacts read ID [--revision REV] [--response full|compact] [--out FILE [--quiet]]
 artifacts read --slug SLUG [--project NAME] [--revision REV] [--response full|compact]
                [--out FILE [--quiet]]
@@ -237,7 +238,7 @@ A slug is unique within the owner's project, matched by the project's stored spe
 
 ## Search pages
 
-`search QUERY` finds owned Markdown and text artifacts whose title, description, or content at the head revision contains every term of `QUERY`. Quote a query that contains spaces.
+`search QUERY` finds owned artifacts whose head revision contains every term of `QUERY`. Markdown and text match by title, description, and content. HTML matches by title, description, and visible text, without tags, attributes, scripts, or styles. A design matches by title and description only. Quote a query that contains spaces.
 
 ```sh
 artifacts search envigado
@@ -245,7 +246,23 @@ artifacts search "tarde envigado" --project mi-wiki
 artifacts search envigado --limit 5 --cursor 5
 ```
 
-The query is plain text of 1 to 256 characters. Every whitespace-separated term must match, letter case and accents are ignored, and operators or punctuation in the query are treated as text, so input such as `"foo" OR NEAR(` never fails with a syntax error. HTML and design artifacts, older revisions, and artifacts shared with the caller are not searched. `--project NAME` limits results to one project, matched regardless of letter case. `--limit` is 1 to 25 and defaults to 10. The command prints `{ "items": [...], "nextCursor": "10" }`; pass `nextCursor` as `--cursor` for the next page, and `null` means there are no more results. Items are `{ artifactId, project, slug, title, snippet, rank }`, ordered by `rank` and then `artifactId`. `rank` is the FTS5 `bm25` score, where lower is more relevant, and `snippet` is an excerpt with each match wrapped in `**`. Search requires `artifacts:read`.
+The query is plain text of 1 to 256 characters. Every whitespace-separated term must match, letter case and accents are ignored, and operators or punctuation in the query are treated as text, so input such as `"foo" OR NEAR(` never fails with a syntax error. Attachments, older revisions, and artifacts shared with the caller are not searched. `--project NAME` limits results to one project, matched regardless of letter case. `--limit` is 1 to 25 and defaults to 10. The command prints `{ "items": [...], "nextCursor": "10" }`; pass `nextCursor` as `--cursor` for the next page, and `null` means there are no more results. Items are `{ artifactId, project, slug, title, snippet, rank }`, ordered by `rank` and then `artifactId`. `rank` is the FTS5 `bm25` score, where lower is more relevant, and `snippet` is an excerpt with each match wrapped in `**`. Search requires `artifacts:read`.
+
+## Apply a batch
+
+`batch --command FILE` applies 1 to 25 create, update, and move operations as one all-or-nothing command. The file holds the complete command with its `requestId`, and the CLI retains it before submission like the other `--command` mutations, so `artifacts retry REQUEST_ID` replays a lost batch.
+
+```json
+{
+  "requestId": "ingest-2026-11-07",
+  "operations": [
+    { "op": "create", "project": "mi-wiki", "slug": "concepts/rag", "snapshot": { "metadata": { "title": "RAG", "description": "" }, "content": { "kind": "markdown", "text": "# RAG" }, "files": [] } },
+    { "op": "update", "project": "mi-wiki", "slug": "index", "expectedRevisionId": "REV", "snapshot": { "metadata": { "title": "Index", "description": "" }, "content": { "kind": "markdown", "text": "- [RAG](concepts/rag.md)" }, "files": [] } }
+  ]
+}
+```
+
+Each operation is `{ op: 'create', snapshot, project?, slug? }`, `{ op: 'update', snapshot, expectedRevisionId? }` addressed by exactly one of `artifactId` or `slug`, with `project` only alongside `slug`, or `{ op: 'move', project?, slug? }` addressed by exactly one of `artifactId` or `from: { project?, slug }`. A move takes the `move` fields: it needs `project`, `slug`, or both, an absent field keeps its value, and `null` clears it. A slug may name a page created earlier in the same batch, and later operations address a moved page by its new slug. `expectedRevisionId` must equal the head at that point in the batch, and it may be omitted only for a page that an earlier operation in the batch created or updated, whose revision ID the caller cannot know. Operations run in order, and the first failure commits nothing: its error, such as `conflict` with `currentRevisionId`, `slug_conflict`, or `not_found`, carries `index`, the 0-based position of the failing operation. Each snapshot keeps the 1 MiB and 32-file limits, and the whole batch has a 4 MiB ceiling of decoded content and metadata. The result is `{ results: [{ index, artifactId, revisionId }] }`, one entry per operation. A move creates no revision, so its `revisionId` is the head it left in place. The batch writes one receipt: the same `requestId` returns it, and a changed batch fails with `request_conflict`. Search reflects the batch when it commits. A batch never publishes. Batch requires `artifacts:write`.
 
 ## Share publication access
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yargote/artifacts-cli",
-  "version": "0.1.0-beta.10",
+  "version": "0.1.0-beta.11",
   "private": false,
   "type": "module",
   "description": "Command-line client for the Artifacts REST API.",
@@ -27,8 +27,8 @@
     "skills"
   ],
   "dependencies": {
-    "@yargote/artifacts-contracts": "0.1.0-beta.10",
-    "@yargote/artifacts-client": "0.1.0-beta.10",
+    "@yargote/artifacts-contracts": "0.1.0-beta.11",
+    "@yargote/artifacts-client": "0.1.0-beta.11",
     "openid-client": "6.8.8",
     "zod": "4.6.5"
   },

package/skills/artifacts-cli/SKILL.md

@@ -37,7 +37,9 @@ When the user names a project for new content, add `--project NAME` to `create`.
 
 When the user names a page, add `--slug SLUG` such as `concepts/rag` to `create`, and read it later with `read --project NAME --slug SLUG`, or `read --slug SLUG` for an unfiled page, instead of listing for its ID. Omit the `.md` suffix. A `slug_conflict` error names the `artifactId` that already holds the slug in that project. Rename a page with `move ID --slug SLUG` and clear its slug with `move ID --no-slug`. A move to another project keeps the slug, and a move into a used slug fails with `slug_conflict` without changing anything.
 
-To find a page by what it says, run `artifacts search QUERY`, optionally with `--project NAME`, instead of listing and reading every artifact. Every term must match, and letter case and accents are ignored. Read a hit by its `artifactId`, or by `--project` and `--slug` when it has a slug. Search covers only owned Markdown and text artifacts at their head revision.
+To find a page by what it says, run `artifacts search QUERY`, optionally with `--project NAME`, instead of listing and reading every artifact. Every term must match, and letter case and accents are ignored. Read a hit by its `artifactId`, or by `--project` and `--slug` when it has a slug. Search covers owned artifacts at their head revision. Markdown and text match by title, description, and content. HTML matches by title, description, and visible text, without tags, attributes, scripts, or styles. A design matches by title and description only. Attachments, older revisions, and shared artifacts are not searched.
+
+To change several pages together, such as an ingest that creates pages and updates the index and log, or a reorganization that moves pages and renames their slugs, write one batch command file and run `artifacts batch --command FILE` instead of one command per page. To patch a page that already exists, such as appending to the log, use an `edit` operation with only the changed fields instead of restating its full snapshot. All operations commit or none do, and a failure names the 0-based `index` of the failing operation. Fix that operation and send the corrected batch in a file with a new `requestId`, because the CLI already retained the failed one. A batch never publishes.
 
 Use `move ID --project NAME` to file an existing artifact under a project and `move ID --no-project` to remove it from one. A move changes only the project. It creates no revision and leaves the publication unchanged. It is a retained mutation, so recover an uncertain move with `retry`. Verify it with `read` or `list --project NAME`. A project disappears when its last artifact leaves it.
 

package/skills/artifacts-cli/references/commands.md

@@ -132,7 +132,17 @@ artifacts search "tarde envigado" --project "mi wiki"
 artifacts search envigado --limit 5 --cursor 5
 ```
 
-`search QUERY` finds owned Markdown and text artifacts whose title, description, or content at the head revision contains every term. Quote a query with spaces. The query is plain text of 1 to 256 characters. Every whitespace-separated term must match, letter case and accents are ignored, and operators or punctuation in the query are treated as text, so input such as `"foo" OR NEAR(` never fails with a syntax error. HTML and design artifacts, older revisions, and artifacts shared with the caller are not searched. `--project` matches regardless of letter case. `--limit` is 1 to 25 and defaults to 10. Items are `{ artifactId, project, slug, title, snippet, rank }`, ordered by `rank` and then `artifactId`. `rank` is the FTS5 `bm25` score, where lower is more relevant, and `snippet` is an excerpt with each match wrapped in `**`. Pass `nextCursor` as `--cursor` for the next page; `null` means there are no more results.
+`search QUERY` finds owned artifacts whose head revision contains every term. Markdown and text match by title, description, and content. HTML matches by title, description, and visible text, without tags, attributes, scripts, or styles. A design matches by title and description only. Quote a query with spaces. The query is plain text of 1 to 256 characters. Every whitespace-separated term must match, letter case and accents are ignored, and operators or punctuation in the query are treated as text, so input such as `"foo" OR NEAR(` never fails with a syntax error. Attachments, older revisions, and artifacts shared with the caller are not searched. `--project` matches regardless of letter case. `--limit` is 1 to 25 and defaults to 10. Items are `{ artifactId, project, slug, title, snippet, rank }`, ordered by `rank` and then `artifactId`. `rank` is the FTS5 `bm25` score, where lower is more relevant, and `snippet` is an excerpt with each match wrapped in `**`. Pass `nextCursor` as `--cursor` for the next page; `null` means there are no more results.
+
+## Apply a batch
+
+Check that installed help lists `batch` before using it.
+
+```sh
+artifacts batch --command ingest.json
+```
+
+The file holds `{ requestId, operations }`. Each operation is `{ op: 'create', snapshot, project?, slug? }`, `{ op: 'update', snapshot, expectedRevisionId? }` addressed by exactly one of `artifactId` or `slug`, with `project` only alongside `slug`, `{ op: 'edit', changes }` with the same address as `update`, or `{ op: 'move', project?, slug? }` addressed by exactly one of `artifactId` or `from: { project?, slug }`. An edit takes the `changes` of `edit --changes`: metadata and content fields merge into the head snapshot, and an explicit `files` array replaces the attachments. The CLI reads the head of each edited page before submission and sends the edit as an `update` with that head as `expectedRevisionId`. An edit therefore addresses a page that exists before the batch: an edit of a page that does not exist yet fails with `not_found` and its `index` before anything is retained or sent. If the page changed after the CLI read it, or an earlier operation in the same batch writes it, the batch fails with `conflict` at the edit's `index`. Use `update` for a page that the batch already creates or writes. A move takes the `move` fields: it needs `project`, `slug`, or both, an absent field keeps its value, and `null` clears it. A slug may name a page created earlier in the same batch, and later operations address a moved page by its new slug. `expectedRevisionId` must equal the head at that point in the batch, and it may be omitted only for a page that an earlier operation in the batch created or updated, whose revision ID the caller cannot know. Operations run in order, and the first failure commits nothing: its error, such as `conflict` with `currentRevisionId`, `slug_conflict`, or `not_found`, carries `index`, the 0-based position of the failing operation. Each snapshot keeps the 1 MiB and 32-file limits, and the whole batch has a 4 MiB ceiling of decoded content and metadata. The result is `{ results: [{ index, artifactId, revisionId }] }`, one entry per operation. A move creates no revision, so its `revisionId` is the head it left in place. The batch writes one receipt: the same `requestId` returns it, and a changed batch fails with `request_conflict`. Search reflects the batch when it commits. A batch never publishes. The CLI retains the prepared command, with each edit already turned into its `update`, before submission, so `artifacts retry REQUEST_ID` replays a lost batch exactly as it was prepared.
 
 ## Edit without losing retained data
 

package/src/index.js

@@ -8,7 +8,7 @@ import { parseArgs } from 'node:util';
 import { z } from 'zod';
 import { createSchema, listSharesSchema, moveSchema, publishSchema, shareSchema, unshareSchema, updateSchema } from '@yargote/artifacts-contracts';
 import { canonicalResource } from '@yargote/artifacts-contracts/http';
-import { createArtifactHttpClient, HttpError, prepareArtifactEdit } from '@yargote/artifacts-client';
+import { BatchOperationError, createArtifactHttpClient, HttpError, prepareArtifactEdit, prepareBatch } from '@yargote/artifacts-client';
 import { accessToken, login, logout } from "./auth.js";
 import { CredentialStore } from "./credentials.js";
 import { loadOperation, retainOperation, submitOperation } from "./operations.js";
@@ -45,6 +45,7 @@ Commands:
          [--response full|compact]
   update [ID] --command FILE
   edit ID --changes FILE [--request-id ID]
+  batch --command FILE
   history ID [--limit N] [--before-sequence N] [--summary]
   publish ID --revision REV --expected-version N [--request-id ID]
   publish [ID] --command FILE
@@ -56,7 +57,8 @@ Commands:
   unshare ID SHARE_ID [--request-id ID]
   retry REQUEST_ID
 
-Mutation command files contain the complete create, update, or publish JSON.
+Mutation command files contain the complete create, update, publish, or batch
+JSON.
 Mutation request IDs default to a random UUID. Commands are retained before
 submission. Retry sends the exact retained command for the same server and owner.
 Projects group artifacts by name without regard to letter case. A project
@@ -68,9 +70,21 @@ project keeps the slug.
 A slug such as concepts/rag names an artifact within its project, or within
 the unfiled artifacts without --project. Read --slug finds it without its ID.
 Create or move fails with slug_conflict when the project already uses the slug.
-Search finds owned Markdown and text artifacts whose title, description, or
-content contains every term of QUERY, ignoring letter case and accents. Quote a
-QUERY with spaces. Results are ordered by relevance with a **bold** snippet.
+Search finds owned artifacts whose head contains every term of QUERY, ignoring
+letter case and accents. It reads Markdown and text content, the visible text
+of HTML, and the title and description of every kind. Quote a QUERY with
+spaces. Results are ordered by relevance with a **bold** snippet.
+Batch applies 1 to 25 create, update, edit, and move operations from one command
+file with a requestId and operations. All succeed or none do. A failure names the
+0-based index of its operation. An update addresses its artifact by artifactId or
+by project and slug, including a page created earlier in the batch, and omits
+expectedRevisionId only for such a page. An edit takes the same address and the
+changes of edit --changes for a page that exists before the batch. The CLI reads
+its head and sends an update with that expectedRevisionId, so a page changed
+meanwhile, or written earlier in the batch, fails with conflict; use update for
+such a page. Retry sends the prepared batch. A move addresses its artifact by
+artifactId or by from { project, slug } and takes the move project and slug.
+Later operations address a moved page by its new slug. A batch never publishes.
 Read --out saves the returned artifact JSON. Export --out saves the ZIP.
 Read --quiet requires --out and suppresses successful JSON stdout.
 Output files are created exclusively and never overwrite an existing path.
@@ -101,7 +115,7 @@ const commandOptions = {
     create: ['snapshot', 'project', 'slug', 'request-id', 'response', 'command'],
     list: ['limit', 'cursor', 'project'], projects: [], search: ['project', 'limit', 'cursor'], read: ['slug', 'project', 'revision', 'response', 'out', 'quiet'],
     update: ['snapshot', 'expected-revision', 'request-id', 'response', 'command'],
-    edit: ['changes', 'request-id'], history: ['limit', 'before-sequence', 'summary'],
+    edit: ['changes', 'request-id'], batch: ['command'], history: ['limit', 'before-sequence', 'summary'],
     publish: ['revision', 'expected-version', 'request-id', 'command'],
     share: ['email', 'notify', 'request-id'], shares: [], unshare: ['request-id'],
     export: ['revision', 'out'], move: ['project', 'no-project', 'slug', 'no-slug', 'request-id'], retry: [],
@@ -230,9 +244,9 @@ async function main() {
         if (extra.length)
             throw new UsageError('--command cannot be combined with mutation options');
         const value = await jsonFile(required('command'));
-        if (kind === 'create') {
+        if (kind === 'create' || kind === 'batch') {
             none();
-            return { kind, command: createSchema.parse(value) };
+            return kind === 'create' ? { kind, command: createSchema.parse(value) } : { kind, command: await prepareBatch(client, value) };
         }
         const mutation = kind === 'update' ? { kind, command: updateSchema.parse(value) } : { kind, command: publishSchema.parse(value) };
         const id = argument(false);
@@ -290,6 +304,7 @@ async function main() {
             const input = await prepareArtifactEdit(client, { artifactId, requestId: values['request-id'] ?? randomUUID(), changes: changes });
             return mutate({ kind: 'update', command: updateSchema.parse(input) });
         }
+        case 'batch': return mutate(await commandFile('batch'));
         case 'history': return client.history({ artifactId: argument(), ...(values.limit === undefined ? {} : { limit: integer('limit') }), ...(values['before-sequence'] === undefined ? {} : { beforeSequence: integer('before-sequence') }), ...(values.summary ? { response: 'summary' } : {}) });
         case 'publish': {
             if (values.command)
@@ -327,17 +342,23 @@ async function main() {
         }
     }
 }
+function errorBody(error) {
+    if (error instanceof BatchOperationError) {
+        const body = errorBody(error.cause);
+        return { ...body, details: { ...body.details, index: error.index } };
+    }
+    return error instanceof HttpError
+        ? { code: error.code, message: error.message, status: error.status, details: error.details }
+        : error instanceof z.ZodError
+            ? { code: 'invalid_input', message: 'Input does not match the artifact command schema', details: { issues: error.issues } }
+            : { code: error instanceof UsageError || error instanceof TypeError || error instanceof SyntaxError ? 'invalid_arguments' : 'local_error', message: error instanceof Error ? error.message : 'Command failed', details: {} };
+}
 try {
     const result = await main();
     if (result !== undefined)
         process.stdout.write(`${JSON.stringify(result)}\n`);
 }
 catch (error) {
-    const body = error instanceof HttpError
-        ? { code: error.code, message: error.message, status: error.status, details: error.details }
-        : error instanceof z.ZodError
-            ? { code: 'invalid_input', message: 'Input does not match the artifact command schema', details: { issues: error.issues } }
-            : { code: error instanceof UsageError || error instanceof TypeError || error instanceof SyntaxError ? 'invalid_arguments' : 'local_error', message: error instanceof Error ? error.message : 'Command failed', details: {} };
-    process.stderr.write(`${JSON.stringify({ error: body })}\n`);
+    process.stderr.write(`${JSON.stringify({ error: errorBody(error) })}\n`);
     process.exitCode = 1;
 }

package/src/operations.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { createSchema, moveSchema, publishSchema, shareSchema, unshareSchema, updateSchema } from '@yargote/artifacts-contracts';
+import { batchSchema, createSchema, moveSchema, publishSchema, shareSchema, unshareSchema, updateSchema } from '@yargote/artifacts-contracts';
 import type { ArtifactHttpClient } from '@yargote/artifacts-client';
 export declare const operationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"create">;
@@ -123,6 +123,84 @@ export declare const operationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     version: z.ZodLiteral<1>;
     resource: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     ownerId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"batch">;
+    command: z.ZodObject<{
+        requestId: z.ZodString;
+        operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"create">;
+            snapshot: z.ZodObject<{
+                metadata: z.ZodObject<{
+                    title: z.ZodString;
+                    description: z.ZodString;
+                    custom: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+                content: z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        text: "text";
+                        html: "html";
+                        markdown: "markdown";
+                        design: "design";
+                    }>;
+                    text: z.ZodString;
+                }, z.core.$strict>;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    mediaType: z.ZodString;
+                    encoding: z.ZodEnum<{
+                        utf8: "utf8";
+                        base64: "base64";
+                    }>;
+                    data: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            project: z.ZodOptional<z.ZodString>;
+            slug: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            expectedRevisionId: z.ZodOptional<z.ZodString>;
+            snapshot: z.ZodObject<{
+                metadata: z.ZodObject<{
+                    title: z.ZodString;
+                    description: z.ZodString;
+                    custom: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+                content: z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        text: "text";
+                        html: "html";
+                        markdown: "markdown";
+                        design: "design";
+                    }>;
+                    text: z.ZodString;
+                }, z.core.$strict>;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    mediaType: z.ZodString;
+                    encoding: z.ZodEnum<{
+                        utf8: "utf8";
+                        base64: "base64";
+                    }>;
+                    data: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            artifactId: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            slug: z.ZodOptional<z.ZodString>;
+            op: z.ZodLiteral<"update">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"move">;
+            artifactId: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodObject<{
+                project: z.ZodOptional<z.ZodString>;
+                slug: z.ZodString;
+            }, z.core.$strict>>;
+            project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            slug: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>], "op">>;
+    }, z.core.$strict>;
+    version: z.ZodLiteral<1>;
+    resource: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    ownerId: z.ZodString;
 }, z.core.$strict>], "kind">;
 export type PreparedOperation = z.infer<typeof operationSchema>;
 export type Mutation = {
@@ -143,11 +221,20 @@ export type Mutation = {
 } | {
     kind: 'unshare';
     command: z.input<typeof unshareSchema>;
+} | {
+    kind: 'batch';
+    command: z.input<typeof batchSchema>;
 };
 export declare function operationPath(stateDir: string, resource: string, requestId: string): string;
 export declare function retainOperation(stateDir: string, resource: string, ownerId: string, mutation: Mutation): Promise<PreparedOperation>;
 export declare function loadOperation(stateDir: string, requestId: string, resource: string, ownerId: string): Promise<PreparedOperation>;
 export declare function submitOperation(client: ArtifactHttpClient, operation: PreparedOperation): Promise<void> | Promise<{
+    results: {
+        index: number;
+        artifactId: string;
+        revisionId: string;
+    }[];
+}> | Promise<{
     shareId: string;
     artifactId: string;
     kind: "email";

package/src/operations.js

@@ -3,7 +3,7 @@ import { lstat, mkdir, open } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { createSchema, moveSchema, publishSchema, shareSchema, unshareSchema, updateSchema } from '@yargote/artifacts-contracts';
+import { batchSchema, createSchema, moveSchema, publishSchema, shareSchema, unshareSchema, updateSchema } from '@yargote/artifacts-contracts';
 import { canonicalResource } from '@yargote/artifacts-contracts/http';
 const binding = {
     version: z.literal(1),
@@ -17,6 +17,7 @@ export const operationSchema = z.discriminatedUnion('kind', [
     z.strictObject({ ...binding, kind: z.literal('move'), command: moveSchema }),
     z.strictObject({ ...binding, kind: z.literal('share'), command: shareSchema }),
     z.strictObject({ ...binding, kind: z.literal('unshare'), command: unshareSchema }),
+    z.strictObject({ ...binding, kind: z.literal('batch'), command: batchSchema }),
 ]);
 export function operationPath(stateDir, resource, requestId) {
     createSchema.shape.requestId.parse(requestId);
@@ -92,6 +93,7 @@ export function submitOperation(client, operation) {
         case 'move': return client.move(operation.command);
         case 'share': return client.share(operation.command);
         case 'unshare': return client.unshare(operation.command);
+        case 'batch': return client.batch(operation.command);
     }
     const exhaustive = operation;
     throw new Error(`Unsupported retained operation: ${exhaustive}`);