@yargote/artifacts-client 0.0.0-stage → 0.1.0-beta.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yerson Argote
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,85 @@
-# Temporary Holding Version
+# Artifacts HTTP client reference
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@yargote/artifacts-client` is a typed Fetch client for the Artifacts REST API. It depends on `@yargote/artifacts-contracts` and Zod. It does not install the artifact store or a database driver. Node 24 or later is required.
+
+```sh
+npm install @yargote/artifacts-client@0.1.0-beta.10
+```
+
+```ts
+import { createArtifactHttpClient, HttpError } from '@yargote/artifacts-client';
+
+const client = createArtifactHttpClient({
+	resource: process.env.ARTIFACTS_SERVER!,
+	accessToken: async () => obtainAccessToken(),
+	timeoutMs: 30_000,
+});
+
+const identity = await client.identity();
+const document = await client.read({ artifactId: 'artifact-id' });
+```
+
+## Configuration
+
+`createArtifactHttpClient({ resource, accessToken, fetch?, timeoutMs? })` returns an `ArtifactHttpClient`.
+
+`resource` is the exact canonical REST OAuth resource. Set it to the deployment's `API_URL` origin, such as `https://artifacts.example`, to use routes under `/v1`. Request access tokens for that same origin. MCP uses a separate `/mcp` audience. The client appends `/v1` to the supplied resource and does not remove or rewrite paths. Older deployments without `API_URL` retain their complete MCP resource and `/mcp/v1` routes.
+
+HTTPS is required except for HTTP on `localhost`, `127.0.0.1`, or `[::1]`. Credentials, queries, fragments, and noncanonical URLs are rejected. The client has no default resource.
+
+`accessToken` is a bearer token or an asynchronous function that returns one. The function runs once per method call. The caller owns credential storage and refresh.
+
+`fetch` defaults to `globalThis.fetch`. `timeoutMs` defaults to 30 seconds and covers the request and response body. It must be a positive safe integer no greater than 2147483647.
+
+## Methods
+
+Every method makes one HTTP request. The client does not retry, follow redirects, rebase conflicts, or change expected versions.
+
+| Method | Input | Result |
+| --- | --- | --- |
+| `identity()` | None | Verified user, session, client, and scopes |
+| `create(command)` | `requestId`, complete `snapshot`, optional `project`, `slug`, and `response` | Artifact receipt |
+| `list(query?)` | Optional `limit`, `cursor`, and `project` | Artifact summaries and `nextCursor` |
+| `projects()` | None | `{ items: [{ name, artifactCount }] }` |
+| `search(query)` | `query`, optional `project`, `limit`, and `cursor` | `{ items: SearchHit[], nextCursor }` |
+| `read(query)` | Exactly one of `artifactId` or `slug` with optional `project`, optional `revisionId` and `response` | Artifact revision |
+| `update(command)` | `requestId`, `artifactId`, `expectedRevisionId`, complete `snapshot`, optional `response` | Artifact receipt |
+| `history(query)` | `artifactId`, optional `limit`, `beforeSequence`, and `response` | Revisions and `nextBeforeSequence` |
+| `publish(command)` | `requestId`, `artifactId`, `revisionId`, `expectedPublicationVersion` | Publication receipt |
+| `share(command)` | `requestId`, `artifactId`, `email`, optional `notify` and `requireNew: true` | Share receipt with optional notification disposition |
+| `listShares(query)` | `artifactId` | `{ items: Share[] }` |
+| `unshare(command)` | `requestId`, `artifactId`, `shareId` | `void` after an empty HTTP 204 |
+| `move(command)` | `requestId`, `artifactId`, and at least one of `project` (name or null) and `slug` (slug or null) | `{ artifactId, project }` |
+| `export(query)` | `artifactId`, `revisionId` | `{ filename, mediaType, bytes, sha256 }` |
+
+Create, read, and update accept `response: 'compact'`. The returned revision contains metadata and file summaries. Omitted response and `response: 'full'` return the complete snapshot. History accepts `response: 'summary'` or `response: 'full'`. Its page limit is ten revisions. Overloads reflect these projections in the return type.
+
+All commands and JSON responses pass the strict domain schemas. An omitted mutation `response` remains omitted in the transmitted command. JSON responses are bounded at 64 MiB, which accommodates ten maximum-size revisions with JSON escaping. Archives are bounded at 8 MiB. Export verifies the binary bytes against `X-Artifact-SHA256` and returns the bytes without rebuilding the ZIP.
+
+All sharing methods require `artifacts:publish` and artifact ownership. `share` trims and lowercases the email. The client places identifiers in encoded URL segments and sends `{ requestId, email }` plus any explicitly supplied `notify` or `requireNew` for share or `{ requestId }` for unshare. `unshare` resolves with `undefined` and requires no JSON content type on its empty response.
+
+Artifact reads and list items include `project`, a name or null. A project name matches an existing project regardless of letter case and keeps its stored spelling. `move` never creates a revision or changes the publication. `projects()` lists only projects that contain artifacts, ordered by name. Because response schemas are strict, this client requires a server that returns `project`. Version `0.1.0-beta.4` and earlier reject responses from such a server with `invalid_response`.
+
+Artifact reads and list items also include `slug`, a page name or null. `read({ project, slug })` calls `GET /lookup` and `read({ artifactId })` calls `GET /artifacts/:artifactId`. An omitted `project` reads the unfiled namespace. A used slug fails `create` with an `HttpError` whose code is `slug_conflict`, status 409, and whose details name the holder's `artifactId`. Version `0.1.0-beta.7` and earlier reject responses that include `slug` with `invalid_response`. `move` sets, changes, or clears the slug: an omitted field keeps its value and `null` clears it. A move into a used slug fails with the same `slug_conflict`. The move result is unchanged, so published clients keep parsing it. Read the artifact to see its new slug.
+
+`search({ query, project?, limit?, cursor? })` calls `GET /search` and searches the caller's owned Markdown and text artifacts at their head revision. 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. 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. `limit` is 1 to 25 and defaults to 10.
+
+`prepareArtifactEdit(client, { artifactId, requestId, changes })` reads the current full snapshot and prepares an immutable update command. Metadata and content changes merge into that snapshot. An explicit `files` array replaces the attachments. The helper does not submit the update. Retain its exact output before sending it.
+
+## Errors and retries
+
+`HttpError` extends `Error` and contains `status`, `code`, and `details`. Server conflicts preserve the server's details. Transport failures use status `0` and code `network_error` or `timeout`. Rejected redirects use `redirect_refused`. Invalid response schemas use `invalid_response`. Oversized responses use `response_too_large`. A mismatched archive digest uses `archive_digest_mismatch`.
+
+Invalid local commands throw a Zod validation error before any HTTP request. Invalid configuration throws `TypeError`.
+
+A caller that needs recovery retains the complete create, update, publish, move, share, or unshare command before its first request. While the artifact exists, retrying that exact command returns the original receipt or confirms unshare with another empty 204. Changing `response`, the snapshot, an expected version, or a sharing argument changes the command. A conflict requires a new deliberate command with a new request ID. A replayed receipt describes the original operation and can differ from a fresh read. Replaying a share after revocation returns its historical receipt without restoring access. A new unshare command for a removed share returns `not_found`.
+
+## Compiled installation
+
+The registry package contains compiled ESM JavaScript and declarations. Consumers need no TypeScript loader or database package. For repository development, `pnpm build:packages` produces local tarballs and a `dist/packages/manifest.json` inventory. `pnpm test:packages` verifies an ordinary Node consumer and its types.
+
+This package is MIT licensed. The license applies to this package and does not license the private Artifacts application repository.
+
+Permanent deletion from the panel invalidates historical content-bearing receipts. An exact create, update, publish or move retry for a deleted artifact returns `not_found`; request identity remains reserved, so a changed command still returns `request_conflict` and an old create cannot recreate it. Live-session and scope checks still precede replay. This package exposes no deletion operation.
+
+`notify: true` requests one invitation attempt. The result adds `notification` with `status: "requested"`, or `status: "skipped"` and `reason: "disabled"` or `"rate_limited"`. A rate-limited result includes the next UTC day in `retryAt`. Access succeeds in each case. `requested` does not confirm delivery. Exact retries never send again. A fresh request can notify existing access. `requireNew: true` atomically rejects existing access with `conflict` and `details.reason: "share_exists"`. Plain and explicit-false results keep the five grant fields.

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@yargote/artifacts-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.10",
+  "private": false,
+  "type": "module",
+  "description": "Typed HTTP client for the Artifacts REST API.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yersonargotev/artifacts.git",
+    "directory": "packages/client"
+  },
+  "homepage": "https://github.com/yersonargotev",
+  "bugs": {
+    "url": "https://github.com/yersonargotev"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@yargote/artifacts-contracts": "0.1.0-beta.10",
+    "zod": "4.6.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta",
+    "provenance": false
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { createSchema, exportSchema, historySchema, listSchema, listSharesSchema, moveResultSchema, moveSchema, publishResultSchema, publishSchema, readSchema, searchSchema, shareSchema, unshareSchema, type ArtifactRead, type SearchResult, type Share, type ShareResult, type UpdateInput } from '@yargote/artifacts-contracts';
+import { historyResultSchema, listResultSchema, projectsResultSchema, summaryHistoryResultSchema, type Identity } from '@yargote/artifacts-contracts/http';
+import type { CompactArtifactRead } from '@yargote/artifacts-contracts/workflow';
+export type { ArtifactRead, Share, Snapshot, UpdateInput } from '@yargote/artifacts-contracts';
+export type { Identity } from '@yargote/artifacts-contracts/http';
+export type { CompactArtifactRead, RevisionSummary } from '@yargote/artifacts-contracts/workflow';
+export { prepareArtifactEdit } from '@yargote/artifacts-contracts/workflow';
+export type CreateInput = z.input<typeof createSchema>;
+export type ReadInput = z.input<typeof readSchema>;
+export type PublishInput = z.input<typeof publishSchema>;
+export type ShareInput = z.input<typeof shareSchema>;
+export type UnshareInput = z.input<typeof unshareSchema>;
+export type ListSharesInput = z.input<typeof listSharesSchema>;
+export type ListSharesResult = {
+    items: Share[];
+};
+export type ListInput = z.input<typeof listSchema>;
+export type SearchInput = z.input<typeof searchSchema>;
+export type { SearchResult };
+export type MoveInput = z.input<typeof moveSchema>;
+export type MoveResult = z.infer<typeof moveResultSchema>;
+export type ProjectsResult = z.infer<typeof projectsResultSchema>;
+export type HistoryInput = z.input<typeof historySchema>;
+export type ExportInput = z.input<typeof exportSchema>;
+export type ArtifactArchive = {
+    filename: string;
+    mediaType: 'application/zip';
+    bytes: Uint8Array;
+    sha256: string;
+};
+export type HistoryResult = z.infer<typeof historyResultSchema>;
+export type SummaryHistoryResult = z.infer<typeof summaryHistoryResultSchema>;
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+    constructor(status: number, code: string, message: string, details?: Record<string, unknown>, options?: ErrorOptions);
+}
+export interface ArtifactHttpClient {
+    identity(): Promise<Identity>;
+    create(input: CreateInput & {
+        response: 'compact';
+    }): Promise<CompactArtifactRead>;
+    create(input: CreateInput & {
+        response?: 'full';
+    }): Promise<ArtifactRead>;
+    create(input: CreateInput): Promise<ArtifactRead | CompactArtifactRead>;
+    list(input?: ListInput): Promise<z.infer<typeof listResultSchema>>;
+    projects(): Promise<ProjectsResult>;
+    search(input: SearchInput): Promise<SearchResult>;
+    read(input: ReadInput & {
+        response: 'compact';
+    }): Promise<CompactArtifactRead>;
+    read(input: ReadInput & {
+        response?: 'full';
+    }): Promise<ArtifactRead>;
+    read(input: ReadInput): Promise<ArtifactRead | CompactArtifactRead>;
+    update(input: UpdateInput & {
+        response: 'compact';
+    }): Promise<CompactArtifactRead>;
+    update(input: UpdateInput & {
+        response?: 'full';
+    }): Promise<ArtifactRead>;
+    update(input: UpdateInput): Promise<ArtifactRead | CompactArtifactRead>;
+    history(input: HistoryInput & {
+        response: 'summary';
+    }): Promise<SummaryHistoryResult>;
+    history(input: HistoryInput & {
+        response?: 'full';
+    }): Promise<HistoryResult>;
+    history(input: HistoryInput): Promise<HistoryResult | SummaryHistoryResult>;
+    publish(input: PublishInput): Promise<z.infer<typeof publishResultSchema>>;
+    share(input: ShareInput): Promise<ShareResult>;
+    unshare(input: UnshareInput): Promise<void>;
+    listShares(input: ListSharesInput): Promise<ListSharesResult>;
+    move(input: MoveInput): Promise<MoveResult>;
+    export(input: ExportInput): Promise<ArtifactArchive>;
+}
+export declare function createArtifactHttpClient(options: {
+    resource: string;
+    accessToken: string | (() => Promise<string>);
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}): ArtifactHttpClient;

package/src/index.js

@@ -0,0 +1,198 @@
+import { z } from 'zod';
+import { artifactReadSchema, createSchema, exportSchema, historySchema, listSchema, listSharesSchema, moveResultSchema, moveSchema, publishResultSchema, publishSchema, readSchema, searchResultSchema, searchSchema, shareCommandResultSchema, shareResultSchema, shareSchema, unshareSchema, updateSchema } from '@yargote/artifacts-contracts';
+import { compactArtifactReadSchema, historyResultSchema, httpErrorSchema, identitySchema, listResultSchema, projectsResultSchema, restBase, summaryHistoryResultSchema } from '@yargote/artifacts-contracts/http';
+export { prepareArtifactEdit } from '@yargote/artifacts-contracts/workflow';
+export class HttpError extends Error {
+    status;
+    code;
+    details;
+    constructor(status, code, message, details = {}, options) {
+        super(message, options);
+        this.name = 'HttpError';
+        this.status = status;
+        this.code = code;
+        this.details = details;
+    }
+}
+const maxJsonBytes = 64 * 1024 * 1024;
+const maxArchiveBytes = 8 * 1024 * 1024;
+const listSharesResultSchema = z.strictObject({ items: z.array(shareResultSchema) });
+async function boundedBytes(response, maximum) {
+    const length = response.headers.get('content-length');
+    if (length !== null && (!/^\d+$/.test(length) || Number(length) > maximum)) {
+        await response.body?.cancel();
+        throw new HttpError(response.status, 'response_too_large', 'The server response exceeds the size limit');
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        return new Uint8Array();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            size += next.value.byteLength;
+            if (size > maximum) {
+                await reader.cancel();
+                throw new HttpError(response.status, 'response_too_large', 'The server response exceeds the size limit');
+            }
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function query(values) {
+    const parameters = new URLSearchParams();
+    for (const [key, value] of Object.entries(values))
+        if (value !== undefined)
+            parameters.set(key, String(value));
+    const encoded = parameters.toString();
+    return encoded ? `?${encoded}` : '';
+}
+function parseResponse(schema, value, status) {
+    const result = schema.safeParse(value);
+    if (!result.success)
+        throw new HttpError(status, 'invalid_response', 'The server returned an invalid response');
+    return result.data;
+}
+export function createArtifactHttpClient(options) {
+    const base = restBase(options.resource);
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
+        throw new TypeError('timeoutMs must be a positive integer no greater than 2147483647');
+    async function request(path, method, expectedStatus, parse, input, maximum = maxJsonBytes) {
+        const token = typeof options.accessToken === 'string' ? options.accessToken : await options.accessToken();
+        if (!token || /[\r\n]/.test(token))
+            throw new TypeError('A nonempty access token is required');
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetcher(`${base}${path}`, {
+                method,
+                redirect: 'manual',
+                signal: controller.signal,
+                headers: { authorization: `Bearer ${token}`, accept: maximum === maxArchiveBytes ? 'application/zip, application/json' : 'application/json', ...(input === undefined ? {} : { 'content-type': 'application/json' }) },
+                ...(input === undefined ? {} : { body: JSON.stringify(input) }),
+            });
+            if (response.status >= 300 && response.status < 400) {
+                await response.body?.cancel();
+                throw new HttpError(response.status, 'redirect_refused', 'The server attempted to redirect an authenticated request');
+            }
+            const bytes = await boundedBytes(response, response.ok ? maximum : Math.min(maximum, 1024 * 1024));
+            if (!response.ok) {
+                let value;
+                try {
+                    value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+                }
+                catch {
+                    throw new HttpError(response.status, 'invalid_response', 'The server returned an invalid error response');
+                }
+                const { error } = parseResponse(httpErrorSchema, value, response.status);
+                throw new HttpError(response.status, error.code, error.message, error.details);
+            }
+            if (response.status !== expectedStatus)
+                throw new HttpError(response.status, 'invalid_response', `The server returned status ${response.status}, expected ${expectedStatus}`);
+            return await parse(response, bytes);
+        }
+        catch (error) {
+            if (error instanceof HttpError)
+                throw error;
+            if (controller.signal.aborted)
+                throw new HttpError(0, 'timeout', 'The server request timed out', {}, { cause: error });
+            throw new HttpError(0, 'network_error', 'The server request failed', {}, { cause: error });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    function json(path, method, schema, input) {
+        return request(path, method, method === 'POST' ? 201 : 200, (response, bytes) => {
+            if (response.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json')
+                throw new HttpError(response.status, 'invalid_response', 'The server did not return JSON');
+            let value;
+            try {
+                value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+            }
+            catch {
+                throw new HttpError(response.status, 'invalid_response', 'The server returned invalid JSON');
+            }
+            return parseResponse(schema, value, response.status);
+        }, input);
+    }
+    const client = {
+        identity: () => json('/identity', 'GET', identitySchema),
+        create(value) {
+            const input = createSchema.parse(value);
+            return json('/artifacts', 'POST', input.response === 'compact' ? compactArtifactReadSchema : artifactReadSchema, input);
+        },
+        list(value = {}) {
+            return json(`/artifacts${query(listSchema.parse(value))}`, 'GET', listResultSchema);
+        },
+        projects: () => json('/projects', 'GET', projectsResultSchema),
+        search(value) {
+            return json(`/search${query(searchSchema.parse(value))}`, 'GET', searchResultSchema);
+        },
+        read(value) {
+            const { artifactId, ...parameters } = readSchema.parse(value);
+            return json(`${artifactId === undefined ? '/lookup' : `/artifacts/${encodeURIComponent(artifactId)}`}${query(parameters)}`, 'GET', parameters.response === 'compact' ? compactArtifactReadSchema : artifactReadSchema);
+        },
+        update(value) {
+            const input = updateSchema.parse(value);
+            return json(`/artifacts/${encodeURIComponent(input.artifactId)}`, 'PUT', input.response === 'compact' ? compactArtifactReadSchema : artifactReadSchema, input);
+        },
+        history(value) {
+            const { artifactId, ...parameters } = historySchema.parse(value);
+            return json(`/artifacts/${encodeURIComponent(artifactId)}/history${query(parameters)}`, 'GET', parameters.response === 'summary' ? summaryHistoryResultSchema : historyResultSchema);
+        },
+        publish(value) {
+            const input = publishSchema.parse(value);
+            return json(`/artifacts/${encodeURIComponent(input.artifactId)}/publication`, 'PUT', publishResultSchema, input);
+        },
+        share(value) {
+            const { artifactId, ...input } = shareSchema.parse(value);
+            return json(`/artifacts/${encodeURIComponent(artifactId)}/shares`, 'POST', shareCommandResultSchema, input);
+        },
+        listShares(value) {
+            const { artifactId } = listSharesSchema.parse(value);
+            return json(`/artifacts/${encodeURIComponent(artifactId)}/shares`, 'GET', listSharesResultSchema);
+        },
+        unshare(value) {
+            const { artifactId, shareId, ...input } = unshareSchema.parse(value);
+            return request(`/artifacts/${encodeURIComponent(artifactId)}/shares/${encodeURIComponent(shareId)}`, 'DELETE', 204, (response, bytes) => {
+                if (bytes.byteLength !== 0)
+                    throw new HttpError(response.status, 'invalid_response', 'The server returned a nonempty response');
+            }, input);
+        },
+        move(value) {
+            const input = moveSchema.parse(value);
+            return json(`/artifacts/${encodeURIComponent(input.artifactId)}/project`, 'PUT', moveResultSchema, input);
+        },
+        export(value) {
+            const input = exportSchema.parse(value);
+            return request(`/artifacts/${encodeURIComponent(input.artifactId)}/revisions/${encodeURIComponent(input.revisionId)}/export`, 'GET', 200, async (response, bytes) => {
+                const disposition = response.headers.get('content-disposition');
+                const filename = /^attachment; filename="([A-Za-z0-9._-]+\.zip)"$/.exec(disposition ?? '')?.[1];
+                const digest = response.headers.get('x-artifact-sha256');
+                if (!filename || !digest || !/^[a-f0-9]{64}$/.test(digest) || response.headers.get('content-type')?.split(';')[0].trim() !== 'application/zip')
+                    throw new HttpError(response.status, 'invalid_response', 'The server returned invalid archive headers');
+                const actualDigest = Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', new Uint8Array(bytes))), (byte) => byte.toString(16).padStart(2, '0')).join('');
+                if (actualDigest !== digest)
+                    throw new HttpError(response.status, 'archive_digest_mismatch', 'The archive SHA-256 does not match its response header');
+                return { filename, mediaType: 'application/zip', bytes, sha256: digest };
+            }, undefined, maxArchiveBytes);
+        },
+    };
+    return client;
+}