@statewalker/webrun-files-rpc 0.1.0 → 0.1.2

package/README.md

@@ -7,7 +7,7 @@ A `FilesApi` (from `@statewalker/webrun-files`) over any RPC, with streamed read
 - **Server** (`newFilesRpcServer({ fs })`): serves any `FilesApi` as plain method calls.
 - **Client** (`newFilesRpcClient({ rpc })`): a `FilesApi` whose every call goes through those
   methods: a Durable Object or Workers RPC stub, comlink, `@statewalker/webrun-rpc`, or the server
-  object itself.
+  object itself. It also appends (`append(path, content)`), which `FilesApi` does not.
 
 Content moves as **chunks keyed by `(streamId, chunkId)`**. Both sides keep chunks by their key
 and wait for the ones still on their way:
@@ -37,10 +37,13 @@ Keys make the calls safe on real transports:
   - a chunk read twice is answered twice;
   - an open with the same `streamId` opens one stream;
   - a `closeWrite` delivered again answers as the first did.
-  - Metadata calls carry no key. Delivered twice with no other write in between, `mkdir`,
-    `remove`, `move` and `copy` end in the same state, but each answers for the state it finds: a
-    `remove`, `move` or `copy` delivered twice may report `false` though the first one did it. A
-    `copy` retried after something else wrote to the target copies again.
+  - a metadata call (`mkdir`, `remove`, `move`, `copy`) with a `requestId` runs once: delivered
+    again, concurrently or later, it gets the first answer (or failure). The server keeps answers
+    for `idleTimeout`, at most `maxRequests` of them. The client sends a fresh `requestId` with
+    every such call.
+  - Without a `requestId`, a metadata call delivered twice runs twice: the end state is the same
+    when nothing else writes in between, but the second may report `false` though the first did
+    it, and a late `copy` retry copies again.
 
 ## How to use
 
@@ -58,8 +61,8 @@ Exports:
 - `newFilesRpcServer`, `newFilesRpcClient`, `FilesRpcClient`;
 - `FilesRpcError` and `errorCode`;
 - types `FilesRpc`, `FilesRpcServer`, `FilesRpcServerOptions`, `FilesRpcClientOptions`,
-  `ReadResult`, `ListPage`, `ListPageOptions`, `OpenOptions`, `OpenReadOptions`,
-  `FilesRpcErrorCode`.
+  `AppendableFilesApi`, `ReadResult`, `ListPage`, `ListPageOptions`, `OpenOptions`,
+  `OpenReadOptions`, `OpenWriteOptions`, `RequestOptions`, `FilesRpcErrorCode`.
 
 ### `newFilesRpcServer(options)`
 
@@ -75,6 +78,7 @@ Exports:
 | `idleTimeout` | 2 min | A stream not used for this long is dropped (a read closed, a write aborted). |
 | `maxStreams` | 256 | Open streams at most (`TOO_MANY_STREAMS` beyond). |
 | `maxPageSize` | 256 | Largest listing page. |
+| `maxRequests` | 1024 | Answers of metadata calls kept by `requestId` (oldest dropped beyond). |
 | `sweepInterval` | none | Sweep idle streams every this many ms. Without it, opening a stream sweeps; a server that stops receiving opens needs this (or calls to `sweep()`). |
 | `now` | `Date.now` | The clock (tests). |
 
@@ -94,6 +98,9 @@ The server is a `FilesRpc` plus:
 | `writeAhead` | 4 | `writeChunk` calls not yet answered while writing. |
 | `pageSize` | 256 | Listing page size. |
 
+Besides the `FilesApi` methods, the client has `append(path, content)`: it adds `content` to the
+end of `path` (creating it if it does not exist), streamed exactly as `write` streams.
+
 ### The protocol (`FilesRpc`)
 
 Every argument and result is a plain value: strings, numbers, booleans, plain objects and
@@ -104,12 +111,13 @@ Every argument and result is a plain value: strings, numbers, booleans, plain ob
 | `openRead(path, {start?, length?, streamId?})` | `{streamId}`; a file that does not exist reads as nothing |
 | `readChunk(streamId, chunkId)` | `{data, done}` once chunk `chunkId` exists; past the end `{data: empty, done: true}` |
 | `closeRead(streamId)` | ends the stream (unknown or ended: nothing happens) |
-| `openWrite(path, {streamId?})` | `{streamId}`; the `FilesApi`'s `write` starts consuming chunks in order |
+| `openWrite(path, {streamId?, append?})` | `{streamId}`; the `FilesApi`'s `write` (or, with `append`, the append) starts consuming chunks in order |
 | `writeChunk(streamId, chunkId, data)` | resolves once the chunk is kept (within `writeWindow` of the next to write: at once) |
 | `closeWrite(streamId, chunks)` | resolves once all `chunks` chunks are written |
 | `abortWrite(streamId, reason?)` | cancels the write (unknown or ended: nothing happens) |
 | `list(path, {recursive?, after?, limit?})` | `{entries, more}`; ask again with `after` = the last path |
-| `stats`, `exists`, `mkdir`, `remove`, `move`, `copy` | as the `FilesApi` |
+| `stats`, `exists` | as the `FilesApi` |
+| `mkdir(path, {requestId?})`, `remove(path, {requestId?})`, `move(source, target, {requestId?})`, `copy(source, target, {requestId?})` | as the `FilesApi`; with a `requestId`, once (a call delivered again gets the first answer) |
 
 - **Stream ids:** `streamId` may be chosen by the caller: 16 to 128 characters of `[A-Za-z0-9_-]`,
   random, such as `crypto.randomUUID()` without dashes. Then an open delivered twice opens one
@@ -216,6 +224,27 @@ await server.closeRead(r);
     keeps what it had.
   - `write()` starts at `openWrite`, not at the first chunk. A FilesApi that truncates when a
     write starts has emptied the file already if the write is then aborted.
+- **Appends:** `openWrite(path, { append: true })` streams like a write, and the chunks go to the
+  end of the file.
+  - A served FilesApi with an `append(path, content)` method (`AppendableFilesApi`) appends
+    through it, with whatever atomicity it gives.
+  - Any other FilesApi is appended to with `read`, `write` and `remove` only, in two steps:
+    1. the file's content and the chunks are written to a temporary sibling,
+       `.<name>.append-<id>` (the name cut to 64 characters, the stream id to 16);
+    2. the sibling is written back over the file, then removed.
+  - It never reads and writes one path at once, so a FilesApi that empties a file when a write
+    starts is safe. Only a directory is refused (`INVALID`); `stats` saying the file is missing is
+    not trusted, since reading a missing file yields nothing and the file is created all the same.
+  - A failure or an abort during step 1 leaves the file as it was and removes the sibling. An
+    abort counts until step 2 starts, even after every chunk was sent. A failure during step 2
+    may leave the file incomplete, so the sibling, the only complete copy, is kept and its path
+    is in the error.
+  - Appends to one file (by its normal path) through one server run one after the other. Other
+    writers are not excluded. The emulation copies the file twice and shows the sibling in
+    listings while it runs.
+  - `close()` and expiry leave a write whose outcome is the FilesApi's alone (every chunk handed
+    over, or an emulated append writing back), so a `closeWrite` waiting on it gets the real
+    outcome.
 - **Ended streams:** ids that ended are remembered for `idleTimeout`. Within that time, an open
   delivered after its stream ended does not reopen it, and a `closeWrite` delivered again gets the
   first answer.
@@ -235,8 +264,8 @@ await server.closeRead(r);
 - **The client:**
   - **Read:** it keeps `readAhead` `readChunk` calls in flight and yields the answers in key
     order. Breaking out of the loop, or aborting through `signal`, closes the stream.
-  - **Write:** it cuts any sequence of byte arrays into chunks of exactly `chunkSize` and keeps
-    `writeAhead` unanswered. Any failure (of the source, or of a call) aborts the write.
+  - **Write and append:** it cuts any sequence of byte arrays into chunks of exactly `chunkSize`
+    and keeps `writeAhead` unanswered. Any failure (of the source, or of a call) aborts the write.
   - **List:** it asks page after page with `after`. The server also applies `after` itself, in
     code-point order, so a FilesApi that ignores it cannot make pages repeat.
 - **Not covered:**
@@ -257,9 +286,10 @@ encoding come from `webrun-files-tests`.
 | `server-read.test.ts` | numbered chunks with `done`, out-of-order and concurrent requests, ranges, missing files, retries, release, bounded read-ahead, closing, failing sources |
 | `server-write.test.ts` | in-order and out-of-order chunks, duplicates, backpressure, `closeWrite` waiting for a gap or refusing a wrong count, empty files, abort, failing writes, byte types |
 | `server-lifecycle.test.ts` | idle expiry, the stream limit, `close()`, unguessable ids, paged listing, metadata |
-| `protocol.test.ts` | caller-chosen keys (opens and `closeWrite` delivered twice, after the end), what is refused, waiting requests failed by a close, error codes across a structured clone, many streams at once, release never dropping an undelivered chunk, metadata calls delivered twice |
+| `protocol.test.ts` | caller-chosen keys (opens and `closeWrite` delivered twice, after the end), what is refused, waiting requests failed by a close, error codes across a structured clone, many streams at once, release never dropping an undelivered chunk, metadata calls delivered twice (with a `requestId`: once, the same answer, failures too, kept for `idleTimeout` and `maxRequests`; without: the same end state) |
 | `robustness.test.ts` | the window (huge chunk ids refused at once, bounded pulls), busy streams not swept, writes too far ahead refused, writes waiting for the holder swept, the sweep timer, a failing write's error reaching the client, a late abort not undoing a commit, a source yielding non-bytes, waiters past the count, aborting a hanging read, `close()` not hanging, listing with a FilesApi that ignores `after` |
 | `client.test.ts` | the `FilesApi` round trip, iterables, ranges, pipelining depth, early stop and abort, failing sources, write depth, listing; delayed, reordered and duplicated calls (five seeds) |
-| `conformance.test.ts` | the repository's `FilesApi` suite (`webrun-files-tests`) on the client over the server: directly, and through the transport simulator (cloned, reordered, every call but `remove`/`move`/`copy` delivered twice at random) |
+| `append.test.ts` | appends through the FilesApi's own `append` and through the emulation, also on a FilesApi that writes as it goes: existing and missing files, large files, aborts (also after every chunk was sent) and failing sources leaving the file unchanged and no temporary file, a failed write-back keeping the temporary copy, `close()` during the write-back, two appends at once, `stats` not trusted, odd paths and long names, directories refused; over the transport simulator; an open delivered twice |
+| `conformance.test.ts` | the repository's `FilesApi` suite (`webrun-files-tests`) on the client over the server: directly, and through the transport simulator (cloned, reordered, every call delivered twice at random) |
 | `big-files.test.ts` | the repository's big-file suite (64 MiB) on the client over the server, every call structured-cloned |
 | `readme.test.ts` | the examples above |

package/dist/cjs/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/client.ts
+// src/client.ts
 const toBytes$1 = (v) => v instanceof Uint8Array ? v : ArrayBuffer.isView(v) ? new Uint8Array(v.buffer, v.byteOffset, v.byteLength) : new Uint8Array(v);
 const newStreamId$1 = () => crypto.randomUUID().replace(/-/g, "");
 /** Cuts any sequence of byte arrays into chunks of exactly `size` bytes (the last may be shorter). */
@@ -56,8 +56,9 @@ var FilesRpcClient = class {
 			streamId: newStreamId$1()
 		});
 		const pending = /* @__PURE__ */ new Map();
+		let fail;
 		const aborted = signal ? new Promise((_, reject) => {
-			const fail = () => reject(signal.reason ?? /* @__PURE__ */ new Error("aborted"));
+			fail = () => reject(signal.reason ?? /* @__PURE__ */ new Error("aborted"));
 			if (signal.aborted) fail();
 			else signal.addEventListener("abort", fail, { once: true });
 		}) : void 0;
@@ -82,6 +83,7 @@ var FilesRpcClient = class {
 				signal?.throwIfAborted();
 			}
 		} finally {
+			if (fail) signal?.removeEventListener("abort", fail);
 			await this.#rpc.closeRead(streamId).catch(() => {});
 		}
 	}
@@ -90,7 +92,20 @@ var FilesRpcClient = class {
 	* then `closeWrite` with their count; any failure aborts the write.
 	*/
 	async write(path, content) {
-		const { streamId } = await this.#rpc.openWrite(path, { streamId: newStreamId$1() });
+		return this.#send(path, content, false);
+	}
+	/**
+	* Adds `content` to the end of `path` (creating it if it does not exist), streamed as `write`
+	* streams. The server appends through the served FilesApi's own `append`, or emulates it.
+	*/
+	async append(path, content) {
+		return this.#send(path, content, true);
+	}
+	async #send(path, content, append) {
+		const { streamId } = await this.#rpc.openWrite(path, {
+			streamId: newStreamId$1(),
+			...append ? { append: true } : {}
+		});
 		const inFlight = /* @__PURE__ */ new Set();
 		let failure;
 		let count = 0;
@@ -115,7 +130,7 @@ var FilesRpcClient = class {
 		}
 	}
 	async mkdir(path) {
-		await this.#rpc.mkdir(path);
+		await this.#rpc.mkdir(path, { requestId: newStreamId$1() });
 	}
 	/** Pages of `pageSize`, each asked after the last path of the one before. */
 	async *list(path, options = {}) {
@@ -138,21 +153,20 @@ var FilesRpcClient = class {
 		return this.#rpc.exists(path);
 	}
 	remove(path) {
-		return this.#rpc.remove(path);
+		return this.#rpc.remove(path, { requestId: newStreamId$1() });
 	}
 	move(source, target) {
-		return this.#rpc.move(source, target);
+		return this.#rpc.move(source, target, { requestId: newStreamId$1() });
 	}
 	copy(source, target) {
-		return this.#rpc.copy(source, target);
+		return this.#rpc.copy(source, target, { requestId: newStreamId$1() });
 	}
 };
 /** A FilesApi over a FilesRpc. */
 function newFilesRpcClient(options) {
 	return new FilesRpcClient(options);
 }
-//#endregion
-//#region src/errors.ts
+// src/errors.ts
 /**
 * An error of the protocol itself. The code also leads the message (`UNKNOWN_STREAM: …`), since
 * a structured clone keeps an error's name and message but not its other properties:
@@ -169,11 +183,19 @@ var FilesRpcError = class extends Error {
 /** The FilesRpcError code of an error, also after it crossed a transport; undefined otherwise. */
 function errorCode(e) {
 	const code = e?.code;
-	if (typeof code === "string") return code;
-	return /^(UNKNOWN_STREAM|CHUNK_RELEASED|TOO_MANY_STREAMS|ABORTED|INVALID):/.exec(String(e?.message ?? ""))?.[1];
+	if (typeof code === "string" && CODES.has(code)) return code;
+	return LEADING_CODE.exec(String(e?.message ?? ""))?.[1];
 }
-//#endregion
-//#region src/keyed.ts
+const CODES = /* @__PURE__ */ new Set([
+	"UNKNOWN_STREAM",
+	"CHUNK_RELEASED",
+	"TOO_MANY_STREAMS",
+	"ABORTED",
+	"INVALID"
+]);
+/** A message led by a code, as FilesRpcError writes it (`CODE: …`). */
+const LEADING_CODE = new RegExp(`^(${[...CODES].join("|")}):`);
+// src/keyed.ts
 /**
 * Values kept by key, and waiters for keys that have no value yet: what both ends of a stream
 * use to keep chunks by chunkId and wait for the ones still on their way.
@@ -236,8 +258,23 @@ var Keyed = class {
 		this.#waiters.clear();
 	}
 };
-//#endregion
-//#region src/server.ts
+// src/server.ts
+/**
+* Whether a write's outcome is the FilesApi's alone: every chunk was handed to it (an emulated
+* append, until its write-back starts, can still be cancelled).
+*/
+const committed = (s) => s.total !== void 0 && s.next >= s.total && (!s.emulated || s.committing === true);
+/** `path` in normal form: one leading slash, no empty, "." or ".." segments, no trailing slash. */
+function normalPath(path) {
+	const out = [];
+	for (const seg of String(path).split("/")) {
+		if (!seg || seg === ".") continue;
+		if (seg === "..") out.pop();
+		else out.push(seg);
+	}
+	return `/${out.join("/")}`;
+}
+const messageOf = (e) => String(e?.message ?? e);
 const EMPTY = /* @__PURE__ */ new Uint8Array();
 const STREAM_ID = /^[A-Za-z0-9_-]{16,128}$/;
 function newStreamId() {
@@ -300,6 +337,40 @@ function newFilesRpcServer(options) {
 	* open it anew, and a closeWrite delivered again answers as the first one did.
 	*/
 	const ended = /* @__PURE__ */ new Map();
+	/** Answers of metadata calls, by method and requestId, oldest first. */
+	const requests = /* @__PURE__ */ new Map();
+	const maxRequests = Math.max(1, options.maxRequests ?? 1024);
+	/** Runs `call` once per requestId (within idleTimeout): a call delivered again gets its answer. */
+	const once = (method, opts, call) => {
+		const id = opts?.requestId;
+		if (id === void 0) return call();
+		if (typeof id !== "string" || !STREAM_ID.test(id)) return Promise.reject(new FilesRpcError("INVALID", "a requestId is 16 to 128 characters of [A-Za-z0-9_-]"));
+		const key = `${method} ${id}`;
+		const kept = requests.get(key);
+		if (kept) return kept.answer;
+		const answer = call();
+		answer.catch(() => {});
+		const entry = {
+			at: now(),
+			settled: false,
+			answer
+		};
+		requests.set(key, entry);
+		const settle = () => {
+			entry.at = now();
+			entry.settled = true;
+		};
+		answer.then(settle, settle);
+		while (requests.size > maxRequests) {
+			let victim;
+			for (const [k, r] of requests) if (r.settled) {
+				victim = k;
+				break;
+			}
+			requests.delete(victim ?? requests.keys().next().value);
+		}
+		return answer;
+	};
 	const finish = (id, failure) => {
 		streams.delete(id);
 		ended.set(id, {
@@ -442,6 +513,52 @@ function newFilesRpcServer(options) {
 			s.wake = void 0;
 		}
 	}
+	/** Emulated appends in progress, by normal path: one at a time per file. */
+	const appending = /* @__PURE__ */ new Map();
+	/**
+	* Appends `content` to `path`: through the FilesApi's own `append`, or with read, write and
+	* remove only. The emulation never reads and writes one path at once (a FilesApi may empty a
+	* file when a write starts):
+	*  1. the file's content and the chunks go to a temporary sibling;
+	*  2. that sibling is written back over the file, then removed.
+	* A failure or an abort in step 1 leaves the file as it was and removes the sibling. A failure
+	* in step 2 keeps the sibling (the only complete copy) and names it in the error. Appends to
+	* one file through this server run one after the other; other writers are not excluded.
+	*/
+	const append = async (path, content, id, s) => {
+		const own = fs.append;
+		if (typeof own === "function") return own.call(fs, path, content);
+		s.emulated = true;
+		const file = normalPath(path);
+		const run = (appending.get(file) ?? Promise.resolve()).then(async () => {
+			if ((await fs.stats(file))?.kind === "directory") throw new FilesRpcError("INVALID", `cannot append to a directory: ${file}`);
+			const slash = file.lastIndexOf("/");
+			const temp = `${file.slice(0, slash + 1)}.${file.slice(slash + 1, slash + 65)}.append-${id.slice(0, 16)}`;
+			try {
+				await fs.write(temp, (async function* () {
+					yield* fs.read(file);
+					yield* content;
+				})());
+				if (s.failure !== void 0) throw s.failure;
+			} catch (e) {
+				await fs.remove(temp).catch(() => {});
+				throw e;
+			}
+			s.committing = true;
+			try {
+				await fs.write(file, fs.read(temp));
+			} catch (e) {
+				throw Object.assign(/* @__PURE__ */ new Error(`${messageOf(e)} (the append failed while writing ${file} back: it may be incomplete; its content and the appended chunks are kept in ${temp})`), { cause: e });
+			}
+			await fs.remove(temp).catch(() => {});
+		});
+		const settled = run.catch(() => {});
+		appending.set(file, settled);
+		settled.then(() => {
+			if (appending.get(file) === settled) appending.delete(file);
+		});
+		return run;
+	};
 	const failWrite = (s, failure) => {
 		s.failure ??= failure;
 		for (const r of s.room.splice(0)) r.reject(s.failure);
@@ -454,17 +571,17 @@ function newFilesRpcServer(options) {
 		async exists(path) {
 			return fs.exists(path);
 		},
-		async mkdir(path) {
-			await fs.mkdir(path);
+		async mkdir(path, opts) {
+			await once("mkdir", opts, () => fs.mkdir(path));
 		},
-		async remove(path) {
-			return fs.remove(path);
+		async remove(path, opts) {
+			return once("remove", opts, () => fs.remove(path));
 		},
-		async move(source, target) {
-			return fs.move(source, target);
+		async move(source, target, opts) {
+			return once("move", opts, () => fs.move(source, target));
 		},
-		async copy(source, target) {
-			return fs.copy(source, target);
+		async copy(source, target, opts) {
+			return once("copy", opts, () => fs.copy(source, target));
 		},
 		async list(path, opts = {}) {
 			const limit = Math.min(Math.max(1, Math.floor(Number(opts.limit) || maxPageSize)), maxPageSize);
@@ -557,7 +674,7 @@ function newFilesRpcServer(options) {
 				room: [],
 				done: Promise.resolve()
 			};
-			s.done = fs.write(path, ordered(s)).then(() => {
+			s.done = (opts.append ? append(path, ordered(s), id, s) : fs.write(path, ordered(s))).then(() => {
 				if (s.failure !== void 0) throw s.failure;
 			}, (e) => {
 				failWrite(s, e);
@@ -621,7 +738,7 @@ function newFilesRpcServer(options) {
 			const id = String(streamId);
 			const s = streams.get(id);
 			if (s?.kind !== "write") return;
-			if (s.total !== void 0 && s.next >= s.total) return;
+			if (committed(s)) return;
 			const error = new FilesRpcError("ABORTED", reason ? String(reason) : "the write was aborted");
 			finish(id, error);
 			failWrite(s, error);
@@ -640,6 +757,7 @@ function newFilesRpcServer(options) {
 				else failWrite(s, error);
 			}
 			for (const [id, e] of [...ended]) if (t - e.at > idleTimeout) ended.delete(id);
+			for (const [key, r] of [...requests]) if (r.settled && t - r.at > idleTimeout) requests.delete(key);
 			return dropped;
 		},
 		openStreams() {
@@ -649,6 +767,10 @@ function newFilesRpcServer(options) {
 			if (timer) clearInterval(timer);
 			const sources = [];
 			for (const [id, s] of [...streams]) {
+				if (s.kind === "write" && committed(s)) {
+					streams.delete(id);
+					continue;
+				}
 				const error = new FilesRpcError("ABORTED", "the server closed");
 				finish(id, error);
 				if (s.kind === "read") sources.push(closeSource(s));
@@ -663,7 +785,6 @@ function newFilesRpcServer(options) {
 	timer?.unref?.();
 	return server;
 }
-//#endregion
 exports.FilesRpcClient = FilesRpcClient;
 exports.FilesRpcError = FilesRpcError;
 exports.errorCode = errorCode;

package/dist/client.d.ts

@@ -26,6 +26,11 @@ export declare class FilesRpcClient implements FilesApi {
      * then `closeWrite` with their count; any failure aborts the write.
      */
     write(path: string, content: Iterable<Uint8Array> | AsyncIterable<Uint8Array>): Promise<void>;
+    /**
+     * Adds `content` to the end of `path` (creating it if it does not exist), streamed as `write`
+     * streams. The server appends through the served FilesApi's own `append`, or emulates it.
+     */
+    append(path: string, content: Iterable<Uint8Array> | AsyncIterable<Uint8Array>): Promise<void>;
     mkdir(path: string): Promise<void>;
     /** Pages of `pageSize`, each asked after the last path of the one before. */
     list(path: string, options?: ListOptions): AsyncIterable<FileInfo>;

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,WAAW,EACZ,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,qBAAqB;IACpC,wFAAwF;IACxF,GAAG,EAAE,QAAQ,CAAC;IACd,8FAA8F;IAC9F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAyCD,0FAA0F;AAC1F,qBAAa,cAAe,YAAW,QAAQ;;IAO7C,YAAY,OAAO,EAAE,qBAAqB,EAMzC;IAED;;;OAGG;IACI,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CAAC,UAAU,CAAC,CAyC9E;IAED;;;OAGG;IACG,KAAK,CACT,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,CA2Bf;IAEK,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvC;IAED,6EAA6E;IACtE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CAAC,QAAQ,CAAC,CAY5E;IAED,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAElD;IACD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErC;IACD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErC;IACD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErD;IACD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErD;CACF;AAED,kCAAkC;AAClC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAEhF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,WAAW,EACZ,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,qBAAqB;IACpC,wFAAwF;IACxF,GAAG,EAAE,QAAQ,CAAC;IACd,8FAA8F;IAC9F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAyCD,0FAA0F;AAC1F,qBAAa,cAAe,YAAW,QAAQ;;IAO7C,YAAY,OAAO,EAAE,qBAAqB,EAMzC;IAED;;;OAGG;IACI,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CAAC,UAAU,CAAC,CA4C9E;IAED;;;OAGG;IACG,KAAK,CACT,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,CAEf;IAED;;;OAGG;IACG,MAAM,CACV,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,CAEf;IAsCK,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvC;IAED,6EAA6E;IACtE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CAAC,QAAQ,CAAC,CAY5E;IAED,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAElD;IACD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErC;IACD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErC;IACD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErD;IACD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErD;CACF;AAED,kCAAkC;AAClC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAEhF"}

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,YAAY,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAInD;CACF;AAED,kGAAkG;AAClG,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAOnE"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,YAAY,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAInD;CACF;AAED,kGAAkG;AAClG,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAMnE"}