@deepseek-ai/dsh-client-file-upload 0.1.3-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+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.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/client/file-upload/README.md
+README.md: 2c19e1a564d7b58226e6ccd3cb5b7c81e1b1c14e
+README.zh.md: d1553d40d953dd6378a954c43a9b7a36b7334953

package/README.md

@@ -0,0 +1,101 @@
+---
+description: "Session-addressed browser file uploads with streaming intake, progress, cancellation, and staged receipts for later prompts."
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-client-file-upload
+
+English | [中文](README.zh.md)
+
+## Summary
+
+This package lets browser features store a `Blob`, exact bytes, or a `ReadableStream<Uint8Array>` for one Session and receive an opaque receipt for a later prompt. Served pages send Blob and stream bodies without aggregating their bytes on the page thread; pages whose Host runs in another execution context supply a Fetch-shaped carrier before Cordis boots. Callers can observe consumed bytes and cancel an active operation. A stream body is consumed once and transfers ownership when it crosses a Worker boundary. The standalone `?fixture` page uses the generated Remote for replayable Blob and exact-byte inputs.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+Mount the package before a consumer that injects `fileUpload`, then call `ctx.fileUpload.upload(sessionId, body, name, signal, onProgress)`. The Session identity addresses both the raw route and generated Remote fallback; callers do not assemble either request.
+
+```yaml
+- id: file-upload
+  name: '@deepseek-ai/dsh-client-file-upload'
+```
+
+The package has no Cordis configuration fields. A `Blob` uses XMLHttpRequest inside a dedicated Worker so the service can report browser upload progress, including the total when the browser provides it. A `ReadableStream` transfers to that Worker and feeds Fetch incrementally; progress reports consumed bytes without a total. An `AbortSignal` terminates the dedicated Worker or reaches a page-owned carrier. Exact bytes and fixture Blob inputs use the generated Remote.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+The Client plugin provides `ctx.fileUpload`. Its `upload()` method receives the owning Session identity, assembles the raw route request, and invokes the generated Remote fallback for replayable inputs. The provider reads the optional pre-Cordis `__DSH_FILE_UPLOAD__` hook once. Without a hook, each non-fixture raw request owns a short-lived Worker and releases it after completion, failure, or cancellation. With the hook, the service sends the body through the page-owned Fetch carrier; the Web Worker runtime transfers stream bodies through its request frame and exposes them to the Host HTTP bridge as backpressured chunks.
+
+The Host plugin provides `ctx.fileUploads`. It owns the authenticated streaming route, encoded Remote fallback, command receipt resolver, and staged-receipt lifecycle; encoded admission, attachment-error recognition, and byte storage stay behind `ctx.attachments`. Receipt tables use the receiving Agent's Session object as their key. The Session Controller registers the resolver that can resume a cold ordinary Agent and consumes receipts during prompt admission. Prompt delivery holds each receipt binding in a disposable transaction: disposal restores the previous binding until successful delivery commits it, and queue or history observation then retires the committed receipt.
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Host streaming route, attachment-service admission, and Agent-scoped receipt lifecycle |
+| [`src/types.ts`](src/types.ts) | encoded request, receipt, and durable result types |
+| [`src/client/contract.ts`](src/client/contract.ts) | Client upload, progress, and page-hook types |
+| [`src/client/runtime.ts`](src/client/runtime.ts) | Dedicated Worker and page-owned carrier implementations |
+| [`src/client/index.ts`](src/client/index.ts) | Client plugin registration and `ctx.fileUpload` declaration |
+
+</details>
+
+**Runtime invariant:** No companion is published. Each upload receipt belongs to one exact Session, and each request uses one selected carrier. Unsupported stream carriers fail before the body is sent.
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+- [Connection](../connection/README.md) — authenticated RPC, exact Host routes, and connection generations.
+- [Session Controller](../../api/session-controller/README.md) — prompt admission that consumes staged receipts.
+- [Web Worker runtime](../../experimental/webworker-runtime/README.md) — the page-to-Host Worker request tunnel.
+- [Client group map](../README.md) — browser services and UI feature packages.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+None, as this package transfers browser request bodies and contributes no model input.
+
+#### KV Cache effect
+
+None; this package neither assembles nor sends a provider request.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+These limits apply to the transport operation itself.
+
+- **Uploads are not resumable** — a failed or cancelled retry starts from the first byte.
+- **Stream bodies are one-shot** — transferring a `ReadableStream` locks the caller's object, so retry requires a newly created stream.
+- **Stream progress has no total** — callers receive consumed-byte counts because the stream API carries no byte length.
+- **The browser Worker is self-contained** — its source is emitted from a function string. Adding runtime imports requires moving it to a standalone Worker entry bundled by tsdown.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,101 @@
+---
+description: "按 Session 寻址上传浏览器文件，提供流式接收、进度、取消和供后续 prompt 使用的暂存凭证。"
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-client-file-upload
+
+[English](README.md) | 中文
+
+## 概述
+
+本包让浏览器功能为一个 Session 存储 `Blob`、精确字节或 `ReadableStream<Uint8Array>`，并取得供后续 prompt 使用的不透明凭证。普通服务页面发送 Blob 和 stream 请求体时，不会在页面线程聚合全部字节；Host 位于其他执行上下文中的页面会在 Cordis 启动前提供 Fetch 形式的载体。调用方可以观察已消费字节并取消活动操作。stream 请求体只能消费一次，跨 Worker 边界时会转移所有权。独立的 `?fixture` 页面通过生成的 Remote 处理可重放的 Blob 与精确字节输入。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+在注入 `fileUpload` 的消费方之前挂载本包，再调用 `ctx.fileUpload.upload(sessionId, body, name, signal, onProgress)`。Session 标识同时用于寻址原始路由和生成的 Remote 兜底；调用方不组装这两种请求。
+
+```yaml
+- id: file-upload
+  name: '@deepseek-ai/dsh-client-file-upload'
+```
+
+本包没有 Cordis 配置字段。`Blob` 在专用 Worker 内通过 XMLHttpRequest 发送，因此服务可以报告浏览器上传进度，并在浏览器提供总量时一并报告。`ReadableStream` 会转移给该 Worker，再增量传入 Fetch；进度只报告已消费字节，不包含总量。`AbortSignal` 会终止专用 Worker，或传递给页面自己提供的载体。精确字节与 fixture Blob 输入使用生成的 Remote。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+Client 插件提供 `ctx.fileUpload`。其 `upload()` 方法接收所属 Session 标识，组装原始路由请求，并为可重放输入调用生成的 Remote 兜底。提供方只读取一次可选的 Cordis 启动前 `__DSH_FILE_UPLOAD__` 钩子。没有该钩子时，每个非 fixture 原始请求拥有一个短期 Worker，并在完成、失败或取消后释放。存在该钩子时，服务通过页面自己提供的 Fetch 载体发送请求体；Web Worker runtime 会通过请求帧转移 stream 请求体，再以带背压的分片形式交给 Host HTTP bridge。
+
+Host 插件提供 `ctx.fileUploads`。它拥有经过认证的流式路由、编码 Remote 兜底、命令凭证解析器与暂存凭证生命周期；编码准入、附件错误识别与字节存储仍由 `ctx.attachments` 提供。凭证表以接收方 Agent 的 Session 对象为键。Session Controller 注册可恢复休眠普通 Agent 的解析器，并在 prompt 准入时消费凭证。Prompt 投递通过可释放事务持有每个凭证绑定。成功投递提交事务前，释放会恢复原绑定；提交后，队列或历史观察会退休该凭证。
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Host 流式路由、附件服务准入与按 Agent scope 管理的凭证生命周期 |
+| [`src/types.ts`](src/types.ts) | 编码请求、凭证与持久结果类型 |
+| [`src/client/contract.ts`](src/client/contract.ts) | Client 上传、进度与页面钩子类型 |
+| [`src/client/runtime.ts`](src/client/runtime.ts) | 专用 Worker 与页面自有载体实现 |
+| [`src/client/index.ts`](src/client/index.ts) | Client 插件注册与 `ctx.fileUpload` 声明 |
+
+</details>
+
+**运行时不变式：** 不发布伴生入口。每个上传凭证只属于一个准确的 Session，每个请求只使用一个已选定载体。载体不支持的 stream 会在发送请求体前失败。
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+- [Connection](../connection/README.zh.md)——认证 RPC、Host 精确路由与 connection generation。
+- [Session Controller](../../api/session-controller/README.zh.md)——消费暂存凭证的 prompt 准入。
+- [Web Worker runtime](../../experimental/webworker-runtime/README.zh.md)——页面到 Host Worker 的请求隧道。
+- [客户端组地图](../README.zh.md)——浏览器服务与 UI 功能包。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+无。本包只传输浏览器请求体，不提供模型输入。
+
+#### KV Cache 影响
+
+无；本包既不组装也不发送提供方请求。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+以下限制适用于传输操作本身。
+
+- **上传不能断点续传**：失败或取消后的重试会从第一个字节开始。
+- **stream 请求体只能使用一次**：转移 `ReadableStream` 会锁定调用方的对象，因此重试必须重新创建 stream。
+- **stream 进度没有总量**：stream API 不携带字节长度，因此调用方只能收到已消费字节数。
+- **浏览器 Worker 必须自包含**：其源代码由函数字符串生成。如果实现需要运行时 import，就必须迁移为由 tsdown 打包的独立 Worker 入口。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/client.js

@@ -0,0 +1,333 @@
+window.__ModuleLoader__.load({
+	id: "@deepseek-ai/dsh-client-file-upload",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let _deepseek_ai_cordis = require("@deepseek-ai/cordis");
+		//#region ../../util/crypto/lib/index.js
+		/**
+		* UUID minting that works in every JavaScript context this repository ships
+		* to. `crypto.randomUUID` is a secure-context Web API — a page or worker
+		* served over plain HTTP on a LAN address has no such method — while
+		* `crypto.getRandomValues` is unrestricted everywhere (browsers, workers,
+		* Node ≥ 19). One implementation here replaces per-caller polyfills; the
+		* `no-restricted-properties` lint rule points `crypto.randomUUID` callers at
+		* this module.
+		* @module @deepseek-ai/dsh-util-crypto
+		*/
+		/**
+		* Encode bytes as canonical base64 without overflowing function argument limits.
+		* @param data - Bytes to encode.
+		* @returns base64 text.
+		*/
+		function bytesToBase64(data) {
+			let binary = "";
+			const chunk = 32768;
+			for (let offset = 0; offset < data.length; offset += chunk) binary += String.fromCharCode(...data.subarray(offset, offset + chunk));
+			return btoa(binary);
+		}
+		//#endregion
+		//#region ../../typert/protocol/lib/index.js
+		/** The one Remote failure class shared by owners, the Gateway, and consumers. */
+		/**
+		* One Remote call failure: a real Error carrying its stable code and typed
+		* details. Owners throw it at the failure point; the Host Gateway encodes it
+		* onto the wire unchanged; the Client face rebuilds an instance for the
+		* `RemoteResult` error branch, so `throw result.error` keeps throw semantics.
+		* Discrimination is always by `code`, never by instanceof.
+		*/
+		var RemoteError = class extends Error {
+			code;
+			details;
+			/** Structural marker: cross-realm/bundle identification never uses instanceof. */
+			isDSHRemoteError = true;
+			/**
+			* @param code - stable failure code declared in {@link RemoteErrorDetailsMap}.
+			* @param message - human diagnostic carried across the wire.
+			* @param details - structured payload typed by the code.
+			* @param options - standard Error options (`cause` survives in-process only).
+			*/
+			constructor(code, message, details, options) {
+				super(message, options);
+				this.code = code;
+				this.details = details;
+				this.name = "RemoteError";
+			}
+		};
+		//#endregion
+		//#region lib/types/protocol.js
+		/** Authenticated raw-byte route owned by the file-upload service. */
+		const FILE_UPLOAD_PATH = "/api/session/uploadFileBinary";
+		//#endregion
+		//#region lib/types/client/runtime.js
+		/** Background browser upload implementation for Blob and byte-stream bodies. */
+		/**
+		* Self-contained Worker body; its string form becomes the Blob Worker source.
+		* @param scope - Worker global used for requests and progress messages.
+		* @param createXhr - XMLHttpRequest factory used for Blob progress.
+		* @param doFetch - Fetch carrier used for one-shot ReadableStream bodies.
+		*/
+		function fileUploadWorker(scope = self, createXhr = () => new XMLHttpRequest(), doFetch = (input, init) => fetch(input, init)) {
+			scope.onmessage = (event) => {
+				const request = event.data;
+				if (request.body instanceof Blob) {
+					const xhr = createXhr();
+					xhr.open("POST", request.url);
+					xhr.withCredentials = true;
+					for (const [name, value] of Object.entries(request.headers)) xhr.setRequestHeader(name, value);
+					xhr.upload.onprogress = (progress) => {
+						scope.postMessage({
+							kind: "progress",
+							loaded: progress.loaded,
+							...progress.lengthComputable ? { total: progress.total } : {}
+						});
+					};
+					xhr.onload = () => {
+						scope.postMessage({
+							kind: "complete",
+							status: xhr.status,
+							body: xhr.responseText
+						});
+					};
+					xhr.onerror = () => {
+						scope.postMessage({
+							kind: "error",
+							message: "background upload transport failed"
+						});
+					};
+					xhr.send(request.body);
+					return;
+				}
+				if (!(request.body instanceof ReadableStream)) {
+					scope.postMessage({
+						kind: "error",
+						message: "background upload worker received an invalid body"
+					});
+					return;
+				}
+				const source = request.body;
+				(async () => {
+					const reader = source.getReader();
+					let loaded = 0;
+					const body = new ReadableStream({
+						async pull(controller) {
+							const item = await reader.read();
+							if (item.done) {
+								controller.close();
+								return;
+							}
+							if (!(item.value instanceof Uint8Array)) throw new TypeError("background upload stream produced a non-Uint8Array chunk");
+							loaded += item.value.byteLength;
+							scope.postMessage({
+								kind: "progress",
+								loaded
+							});
+							controller.enqueue(item.value);
+						},
+						async cancel(reason) {
+							await reader.cancel(reason);
+						}
+					});
+					const response = await doFetch(request.url, {
+						method: "POST",
+						headers: request.headers,
+						credentials: "include",
+						body,
+						duplex: "half"
+					});
+					scope.postMessage({
+						kind: "complete",
+						status: response.status,
+						body: await response.text()
+					});
+				})().catch((error) => {
+					scope.postMessage({
+						kind: "error",
+						message: error instanceof Error ? error.message : String(error)
+					});
+				});
+			};
+		}
+		/** Cordis service that owns one background carrier per upload operation. */
+		var FileUploadRuntime = class extends _deepseek_ai_cordis.Service {
+			available;
+			transport;
+			/** @param ctx - providing Client context. */
+			constructor(ctx) {
+				super(ctx, "fileUpload");
+				const hook = globalThis.__DSH_FILE_UPLOAD__;
+				this.available = hook !== void 0 || !isFixturePage();
+				this.transport = hook === void 0 ? workerTransport() : customTransport(hook.fetch);
+			}
+			/**
+			* Post one body with the carrier selected before Cordis boot.
+			* @param request - target, body, cancellation, and progress observer.
+			* @returns the response status and text body.
+			*/
+			post(request) {
+				if (!this.available) return Promise.reject(/* @__PURE__ */ new Error("background upload is unavailable in fixture mode"));
+				return this.transport.post(request);
+			}
+			/**
+			* Store one file for a Session.
+			* @param sessionId - Session that owns the staged receipt.
+			* @param data - browser Blob, exact bytes, or a one-shot byte stream.
+			* @param name - optional display name.
+			* @param signal - optional cancellation for the active upload.
+			* @param onProgress - optional byte-progress observer for background bodies.
+			* @returns the staged receipt and durable file reference, or a business error.
+			*/
+			async upload(sessionId, data, name, signal, onProgress) {
+				if (!(data instanceof Uint8Array) && this.available) {
+					const query = new URLSearchParams({ sessionId });
+					if (name !== void 0) query.set("name", name);
+					const response = await this.post({
+						path: `${FILE_UPLOAD_PATH}?${query.toString()}`,
+						body: data,
+						headers: { "content-type": "application/octet-stream" },
+						...signal === void 0 ? {} : { signal },
+						...onProgress === void 0 ? {} : { onProgress }
+					});
+					if (response.status !== 200) throw new Error(`file upload transport failed with HTTP ${String(response.status)}`);
+					return parseFileUploadResult(response.body);
+				}
+				if (!(data instanceof Uint8Array) && !(data instanceof Blob)) throw new Error("stream file upload requires a background carrier");
+				const bytes = data instanceof Uint8Array ? data : new Uint8Array(await data.arrayBuffer());
+				return this.ctx.remote.fileUploads.upload(sessionId, {
+					data: bytesToBase64(bytes),
+					...name === void 0 ? {} : { name }
+				}, signal);
+			}
+		};
+		function customTransport(customFetch) {
+			return { async post(request) {
+				const init = {
+					method: "POST",
+					...request.headers === void 0 ? {} : { headers: request.headers },
+					body: request.body,
+					...request.body instanceof ReadableStream ? { duplex: "half" } : {},
+					...request.signal === void 0 ? {} : { signal: request.signal }
+				};
+				const response = await customFetch(resolveUrl(request.path), init);
+				return {
+					status: response.status,
+					body: await response.text()
+				};
+			} };
+		}
+		function workerTransport() {
+			return { post(request) {
+				if (typeof Worker !== "function") return Promise.reject(/* @__PURE__ */ new Error("background upload requires Web Worker support"));
+				const workerUrl = URL.createObjectURL(new Blob([`(${fileUploadWorker.toString()})()`], { type: "text/javascript" }));
+				const worker = new Worker(workerUrl, { name: "dsh-file-upload" });
+				URL.revokeObjectURL(workerUrl);
+				return new Promise((resolve, reject) => {
+					let settled = false;
+					const abort = () => {
+						settled = true;
+						worker.terminate();
+						request.signal?.removeEventListener("abort", abort);
+						reject(new DOMException("The operation was aborted.", "AbortError"));
+					};
+					const finish = (settle) => {
+						if (settled) return;
+						settled = true;
+						request.signal?.removeEventListener("abort", abort);
+						worker.terminate();
+						settle();
+					};
+					worker.onmessage = (event) => {
+						const output = event.data;
+						if (output.kind === "progress") request.onProgress?.({
+							loaded: output.loaded,
+							...output.total === void 0 ? {} : { total: output.total }
+						});
+						else if (output.kind === "complete") finish(() => {
+							resolve({
+								status: output.status,
+								body: output.body
+							});
+						});
+						else finish(() => {
+							reject(new Error(output.message));
+						});
+					};
+					worker.onerror = (event) => {
+						finish(() => {
+							reject(new Error(event.message || "background upload worker failed"));
+						});
+					};
+					if (request.signal?.aborted === true) {
+						abort();
+						return;
+					}
+					request.signal?.addEventListener("abort", abort, { once: true });
+					const message = {
+						url: resolveUrl(request.path).href,
+						body: request.body,
+						headers: request.headers ?? {}
+					};
+					if (request.body instanceof ReadableStream) worker.postMessage(message, [request.body]);
+					else worker.postMessage(message);
+				});
+			} };
+		}
+		function resolveUrl(path) {
+			const pageLocation = Reflect.get(globalThis, "location");
+			const origin = typeof pageLocation === "object" && pageLocation !== null && "origin" in pageLocation && typeof pageLocation.origin === "string" ? pageLocation.origin : void 0;
+			return new URL(path, origin === void 0 || origin === "null" ? "http://dsh.internal" : origin);
+		}
+		function isFixturePage() {
+			const pageLocation = Reflect.get(globalThis, "location");
+			return typeof pageLocation === "object" && pageLocation !== null && "search" in pageLocation && typeof pageLocation.search === "string" && new URLSearchParams(pageLocation.search).has("fixture");
+		}
+		function parseFileUploadResult(body) {
+			const value = JSON.parse(body);
+			if (!isRecord(value) || typeof value.ok !== "boolean") throw new TypeError("file upload transport returned an invalid result");
+			if (!value.ok) {
+				const error = value.error;
+				if (!isRecord(error) || typeof error.code !== "string" || typeof error.message !== "string" || !isRecord(error.details)) throw new TypeError("file upload transport returned an invalid failure");
+				return {
+					ok: false,
+					error: new RemoteError(error.code, error.message, error.details)
+				};
+			}
+			const result = value.value;
+			const file = isRecord(result) ? result.file : void 0;
+			if (!isRecord(result) || typeof result.receiptId !== "string" || !isRecord(file) || typeof file.attachmentId !== "string" || typeof file.name !== "string" || typeof file.bytes !== "number" || !Number.isSafeInteger(file.bytes) || file.bytes < 0) throw new TypeError("file upload transport returned an invalid receipt");
+			return {
+				ok: true,
+				value: {
+					receiptId: result.receiptId,
+					file: {
+						attachmentId: file.attachmentId,
+						name: file.name,
+						bytes: file.bytes
+					}
+				}
+			};
+		}
+		function isRecord(value) {
+			return typeof value === "object" && value !== null && !Array.isArray(value);
+		}
+		//#endregion
+		//#region lib/types/client/index.js
+		/** Browser background-upload Cordis service. */
+		/** The upload service uses the generated Remote fallback. */
+		const inject = ["remote"];
+		/**
+		* Provide the browser background-upload service.
+		* @param ctx - Client plugin context.
+		*/
+		function apply(ctx) {
+			ctx.plugin(FileUploadRuntime);
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map