@powerhousedao/reactor-attachments 6.2.2-dev.6 → 6.2.2-dev.60

package/dist/client.js

@@ -1,11 +1,281 @@
-import { _ as SizeMismatch, a as RemoteAttachmentUpload, c as AttachmentService, d as AttachmentAlreadyExists, f as AttachmentNotFound, g as ReservationNotFound, h as InvalidAttachmentRef, i as RemoteAttachmentUploadFactory, l as createRef, m as HashMismatch, n as createRemoteAttachmentService, o as RemoteReservationStore, p as AttachmentPending, r as RemoteAttachmentStore, s as SwitchboardAttachmentTransport, t as NullAttachmentTransport, u as parseRef, v as UploadTooLarge } from "./null-attachment-transport-Drx03s02.js";
+import { C as UploadTooLarge, S as SizeMismatch, _ as AttachmentPending, a as RemoteAttachmentUpload, b as InvalidAttachmentRef, c as createFetchUploadTransport, d as createRef, f as parseRef, g as AttachmentNotFound, h as AttachmentAlreadyExists, i as RemoteAttachmentUploadFactory, l as SwitchboardAttachmentTransport, m as parseAttachmentUploadTarget, n as createRemoteAttachmentService, o as RemoteReservationStore, p as parseAttachmentDownloadTarget, r as RemoteAttachmentStore, s as createXhrUploadTransport, t as NullAttachmentTransport, u as AttachmentService, v as AttachmentTransferError, x as ReservationNotFound, y as HashMismatch } from "./null-attachment-transport-CrsUafCi.js";
+//#region src/concurrency.ts
+/**
+* Runs `worker` over `items` with a hard upper bound on simultaneous
+* executions. Bounding starts (not just transfers) is what keeps memory flat:
+* an item's preprocessing (hashing/buffering) only begins when a slot frees.
+*/
+async function runWithConcurrency(items, worker, options) {
+	const { concurrency, signal, onSettled } = options;
+	if (!Number.isInteger(concurrency) || concurrency < 1) throw new Error(`concurrency must be a positive integer, got: ${concurrency}`);
+	const results = new Array(items.length);
+	let nextIndex = 0;
+	async function runLane() {
+		for (;;) {
+			const index = nextIndex++;
+			if (index >= items.length) return;
+			if (signal?.aborted) {
+				results[index] = {
+					index,
+					status: "rejected",
+					error: signalReason(signal)
+				};
+				onSettled?.(results[index]);
+				continue;
+			}
+			try {
+				results[index] = {
+					index,
+					status: "fulfilled",
+					value: await worker(items[index], index)
+				};
+			} catch (error) {
+				results[index] = {
+					index,
+					status: "rejected",
+					error
+				};
+			}
+			onSettled?.(results[index]);
+		}
+	}
+	const lanes = Array.from({ length: Math.min(concurrency, items.length) }, () => runLane());
+	await Promise.all(lanes);
+	return results;
+}
+function signalReason(signal) {
+	return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+//#endregion
+//#region src/progress.ts
+const DEFAULT_PROGRESS_THROTTLE_MS = 100;
+/**
+* Fraction in 0..1 for a progress event. Indeterminate and unknown-total
+* events read as 0 — a bar cannot honestly show a position it does not know.
+* A zero total is complete by definition (the dedup case moves no bytes).
+*/
+function progressFraction(progress) {
+	if (progress.indeterminate) return 0;
+	if (progress.total === void 0) return 0;
+	if (progress.total === 0) return 1;
+	const fraction = progress.loaded / progress.total;
+	if (fraction < 0) return 0;
+	return fraction > 1 ? 1 : fraction;
+}
+/**
+* Emits `AttachmentProgress` for one single-item operation, upholding:
+*
+* - **I1** exactly one terminal event (`done` or `error`) — never both, never twice.
+* - **I2** on `done`: `indeterminate === false`, `total` is a number, `loaded === total`.
+* - **I3** `loaded` is non-decreasing within a stage and resets to 0 on stage change.
+* - **I4** the terminal event bypasses the throttle unconditionally.
+* - **I5** `error` carries the last known `loaded`/`total`.
+*
+* Leading edge: the first `bytes()` after a `stage()` always emits, so a bar
+* leaves 0 immediately. There is deliberately no trailing-edge timer — it
+* would leak on throw, could fire after the terminal event and violate I1's
+* ordering, and is unnecessary because `finish()` always emits
+* `loaded === total`, making a dropped last intra-stage tick invisible.
+*/
+var ProgressEmitter = class {
+	listener;
+	throttleMs;
+	now;
+	currentStage;
+	loaded = 0;
+	total;
+	emittedBytesInStage = false;
+	lastEmitAt = Number.NEGATIVE_INFINITY;
+	settled = false;
+	constructor(options) {
+		this.listener = options?.onProgress;
+		this.throttleMs = options?.throttleMs ?? 100;
+		this.now = options?.now ?? (() => Date.now());
+	}
+	/** True when a listener is attached; lets callers skip instrumentation entirely. */
+	get active() {
+		return this.listener !== void 0;
+	}
+	/**
+	* Enter a stage. Always emits and resets `loaded` to 0. Entry is always
+	* indeterminate: no bytes have moved yet, and whether they can be observed
+	* at all is only proven by a transport actually calling back.
+	*/
+	stage(stage, options) {
+		if (this.settled) return;
+		this.currentStage = stage;
+		this.loaded = 0;
+		this.total = options?.total;
+		this.emittedBytesInStage = false;
+		this.emit({
+			stage,
+			loaded: 0,
+			total: this.total,
+			indeterminate: true
+		});
+	}
+	/**
+	* Report observed bytes within the current stage. Throttled by time, with
+	* the first observation after a stage change always emitted.
+	*/
+	bytes(loaded, total) {
+		if (this.settled || this.currentStage === void 0) return;
+		if (total !== void 0) this.total = total;
+		if (loaded > this.loaded) this.loaded = loaded;
+		if (!!this.emittedBytesInStage && this.now() - this.lastEmitAt < this.throttleMs) return;
+		this.emittedBytesInStage = true;
+		this.emit({
+			stage: this.currentStage,
+			loaded: this.loaded,
+			total: this.total,
+			indeterminate: false
+		});
+	}
+	/**
+	* Terminal success. `total` defaults to the bytes actually seen so a stage
+	* with no known denominator still satisfies I2.
+	*/
+	finish(override) {
+		if (this.settled) return;
+		this.settled = true;
+		const total = override?.total ?? this.total ?? this.loaded;
+		const loaded = override?.loaded ?? total;
+		this.emit({
+			stage: "done",
+			loaded,
+			total,
+			indeterminate: false,
+			...override?.deduped ? { deduped: true } : {}
+		});
+	}
+	/** Terminal success for a confirmed dedup: no bytes moved, and none needed to. */
+	finishDeduped() {
+		this.finish({
+			loaded: 0,
+			total: 0,
+			deduped: true
+		});
+	}
+	/** Terminal failure, carrying the last known byte counts. */
+	fail() {
+		if (this.settled) return;
+		this.settled = true;
+		this.emit({
+			stage: "error",
+			loaded: this.loaded,
+			total: this.total,
+			indeterminate: false
+		});
+	}
+	emit(progress) {
+		this.lastEmitAt = this.now();
+		this.listener?.(progress);
+	}
+};
+/**
+* Count bytes as a consumer reads them.
+*
+* Uses the manual-reader form rather than `pipeThrough`, whose internal queue
+* reads far ahead of the consumer and would make `loaded` overstate what was
+* actually received. `highWaterMark: 0` is load-bearing for the same reason:
+* at the default of 1 the wrapper pulls one chunk the instant it is
+* constructed, so a caller who never reads still sees bytes counted.
+*
+* `cancel` propagates to the source, which is what keeps reader refcounts
+* (e.g. `KyselyAttachmentStore`'s) correct. Cancelling is an abandonment, not
+* a completion, so it reports `onError` — never `onDone` — carrying the
+* cancel reason the way an `AbortSignal` carries its own, with the DOM's
+* default `AbortError` when the canceller gave none.
+*
+* Returns `source` unchanged when no hook is supplied, so a caller with no
+* listener pays nothing.
+*/
+function withByteProgress(source, hooks) {
+	if (!hooks.onBytes && !hooks.onDone && !hooks.onError) return source;
+	let loaded = 0;
+	let cancelled = false;
+	const reader = source.getReader();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (cancelled) return;
+				if (done) {
+					hooks.onDone?.();
+					controller.close();
+					return;
+				}
+				loaded += value.byteLength;
+				hooks.onBytes?.(loaded);
+				controller.enqueue(value);
+			} catch (err) {
+				if (cancelled) return;
+				hooks.onError?.(err);
+				controller.error(err);
+			}
+		},
+		cancel(reason) {
+			cancelled = true;
+			reader.cancel(reason).catch(() => {});
+			hooks.onError?.(reason ?? abortError());
+		}
+	}, { highWaterMark: 0 });
+}
+/** What an `AbortSignal` carries when `abort()` is called with no reason. */
+function abortError() {
+	return new DOMException("The operation was aborted", "AbortError");
+}
+//#endregion
 //#region src/client.ts
+const DEFAULT_ATTACHMENT_BATCH_CONCURRENCY = 4;
+/**
+* Duck-typed dedup detection: bundlers (notably Vite dev pre-bundling) can
+* load two copies of this package's error classes, one for the service and
+* one for the client wrapper, making a plain instanceof check miss the
+* cross-copy throw. Name plus payload shape identifies the error reliably.
+*/
+function isAttachmentAlreadyExists(err) {
+	if (err instanceof AttachmentAlreadyExists) return true;
+	return err instanceof Error && err.name === "AttachmentAlreadyExists" && typeof err.hash === "string" && typeof err.ref === "string";
+}
 function streamFromBuffer(buf) {
 	return new ReadableStream({ start(controller) {
 		controller.enqueue(buf);
 		controller.close();
 	} });
 }
+/** Stamps an item's index onto its progress events. */
+function itemProgress(options, index) {
+	if (!options?.onProgress && options?.throttleMs === void 0) return;
+	return {
+		...options.onProgress ? { onProgress: (progress) => options.onProgress?.({
+			...progress,
+			index
+		}) } : {},
+		...options.throttleMs !== void 0 ? { throttleMs: options.throttleMs } : {}
+	};
+}
+function batchRunOptions(total, options) {
+	const onItemSettled = options?.onItemSettled;
+	let settled = 0;
+	let completed = 0;
+	let failed = 0;
+	return {
+		concurrency: options?.concurrency ?? 4,
+		...options?.signal ? { signal: options.signal } : {},
+		...onItemSettled ? { onSettled: (result) => {
+			settled += 1;
+			if (result.status === "fulfilled") completed += 1;
+			else failed += 1;
+			onItemSettled({
+				settled,
+				completed,
+				failed,
+				total
+			});
+		} } : {}
+	};
+}
 var AttachmentClientImpl = class {
 	constructor(service) {
 		this.service = service;
@@ -34,28 +304,193 @@ var AttachmentClientImpl = class {
 			stream
 		};
 	}
-	async reserve(options, send) {
-		let handle;
+	/**
+	* Reserve, distinguishing a confirmed dedup from a live upload handle in the
+	* type rather than with a flag: the two outcomes move a different number of
+	* bytes, and every caller has to account for that.
+	*/
+	async reserveOrDedup(options) {
 		try {
-			handle = await this.service.reserve(options);
+			return {
+				kind: "handle",
+				handle: await this.service.reserve(options)
+			};
 		} catch (err) {
-			if (err instanceof AttachmentAlreadyExists) {
-				const header = await this.service.stat(err.ref);
-				return {
+			if (!isAttachmentAlreadyExists(err)) throw err;
+			const header = await this.service.stat(err.ref);
+			return {
+				kind: "deduped",
+				result: {
 					hash: err.hash,
 					ref: err.ref,
 					header
-				};
+				}
+			};
+		}
+	}
+	async reserve(options, send) {
+		const outcome = await this.reserveOrDedup(options);
+		if (outcome.kind === "deduped") return outcome.result;
+		return send(outcome.handle);
+	}
+	async upload(input, options) {
+		const emitter = new ProgressEmitter(options);
+		const signal = input.signal;
+		try {
+			signal?.throwIfAborted();
+			let preprocessed;
+			if ("preprocessed" in input) preprocessed = input.preprocessed;
+			else {
+				emitter.stage("hashing", { total: input.file.size });
+				preprocessed = await this.preprocess(input.file, {
+					...input.fileName !== void 0 ? { fileName: input.fileName } : {},
+					...input.mimeType !== void 0 ? { mimeType: input.mimeType } : {}
+				});
+			}
+			const sizeBytes = preprocessed.sizeBytes;
+			signal?.throwIfAborted();
+			emitter.stage("reserving");
+			const outcome = await this.reserveOrDedup(preprocessed.options);
+			if (outcome.kind === "deduped") {
+				emitter.finishDeduped();
+				return outcome.result;
+			}
+			signal?.throwIfAborted();
+			emitter.stage("uploading", { total: sizeBytes });
+			const sendOptions = {
+				...emitter.active ? { onProgress: (loaded, total) => emitter.bytes(loaded, total ?? sizeBytes) } : {},
+				...signal ? { signal } : {}
+			};
+			const result = await outcome.handle.send(preprocessed.stream(), sendOptions);
+			emitter.finish();
+			return result;
+		} catch (err) {
+			emitter.fail();
+			throw err;
+		}
+	}
+	/**
+	* The single site where download bytes are instrumented.
+	*
+	* It sits here, above the service, rather than in any store or transport:
+	* one logical get can be several byte streams underneath (an evicted
+	* attachment is fetched from the transport, written to disk, then re-read),
+	* so counting lower down would double-count that path and still miss
+	* local-filesystem reads. Wrapping what `service.get` returns covers the
+	* presigned, switchboard, legacy and local paths by construction, and
+	* `downloadBlob`/`saveAttachment`/`downloadObjectUrl` inherit it.
+	*/
+	async getWithProgress(input, emitter) {
+		const { header, body } = await this.service.get(input.ref, {
+			documentId: input.documentId,
+			signal: input.signal
+		});
+		emitter.stage("downloading", { total: header.sizeBytes });
+		if (!emitter.active) return {
+			header,
+			body
+		};
+		return {
+			header,
+			body: withByteProgress(body, {
+				onBytes: (loaded) => emitter.bytes(loaded),
+				onDone: () => emitter.finish(),
+				onError: () => emitter.fail()
+			})
+		};
+	}
+	async download(input, options) {
+		const emitter = new ProgressEmitter(options);
+		try {
+			input.signal?.throwIfAborted();
+			emitter.stage("requesting-download-target");
+			return await this.getWithProgress(input, emitter);
+		} catch (err) {
+			emitter.fail();
+			throw err;
+		}
+	}
+	async downloadBlob(input, options) {
+		const emitter = new ProgressEmitter(options);
+		try {
+			input.signal?.throwIfAborted();
+			emitter.stage("requesting-download-target");
+			const { header, body } = await this.getWithProgress(input, emitter);
+			const reader = body.getReader();
+			const chunks = [];
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				chunks.push(value);
 			}
+			const blob = new Blob(chunks, { type: options?.mimeType ?? header.mimeType });
+			emitter.finish();
+			return {
+				blob,
+				header
+			};
+		} catch (err) {
+			emitter.fail();
 			throw err;
 		}
-		return send(handle);
+	}
+	async saveAttachment(input, options) {
+		if (typeof document === "undefined") throw new Error("saveAttachment requires a browser environment; use downloadBlob elsewhere");
+		const { blob, header } = await this.downloadBlob(input, options);
+		const url = URL.createObjectURL(blob);
+		try {
+			const anchor = document.createElement("a");
+			anchor.href = url;
+			anchor.download = options?.fileName ?? header.fileName;
+			anchor.click();
+		} finally {
+			URL.revokeObjectURL(url);
+		}
+	}
+	async downloadObjectUrl(input, options) {
+		const { blob, header } = await this.downloadBlob(input, options);
+		const url = URL.createObjectURL(blob);
+		let revoked = false;
+		return {
+			url,
+			header,
+			revoke: () => {
+				if (revoked) return;
+				revoked = true;
+				URL.revokeObjectURL(url);
+			}
+		};
+	}
+	async getShareLink(input) {
+		input.signal?.throwIfAborted();
+		const target = await this.service.getDownloadTarget(input.ref, {
+			documentId: input.documentId,
+			...input.expiresIn !== void 0 ? { expiresIn: input.expiresIn } : {},
+			...input.signal !== void 0 ? { signal: input.signal } : {}
+		});
+		if (target.kind !== "presigned-get") throw new Error("Public share links require a presigned-capable storage backend (S3); this server answered with an authenticated target");
+		return {
+			url: target.url,
+			expiresAtUtc: target.expiresAtUtc
+		};
+	}
+	uploadMany(inputs, options) {
+		return runWithConcurrency(inputs, (input, index) => this.upload(input, itemProgress(options, index)), batchRunOptions(inputs.length, options));
+	}
+	/**
+	* `concurrency` bounds download-target negotiation, not simultaneous byte
+	* transfer: each item resolves when its stream is handed over, and the bytes
+	* move only as the caller reads. Byte progress makes that pre-existing
+	* behavior visible; it does not change it.
+	*/
+	downloadMany(inputs, options) {
+		return runWithConcurrency(inputs, (input, index) => this.download(input, itemProgress(options, index)), batchRunOptions(inputs.length, options));
 	}
 };
 function createAttachmentClient(service) {
 	return new AttachmentClientImpl(service);
 }
 //#endregion
-export { AttachmentAlreadyExists, AttachmentNotFound, AttachmentPending, AttachmentService, HashMismatch, InvalidAttachmentRef, NullAttachmentTransport, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, ReservationNotFound, SizeMismatch, SwitchboardAttachmentTransport, UploadTooLarge, createAttachmentClient, createRef, createRemoteAttachmentService, parseRef };
+export { AttachmentAlreadyExists, AttachmentNotFound, AttachmentPending, AttachmentService, AttachmentTransferError, DEFAULT_ATTACHMENT_BATCH_CONCURRENCY, DEFAULT_PROGRESS_THROTTLE_MS, HashMismatch, InvalidAttachmentRef, NullAttachmentTransport, ProgressEmitter, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, ReservationNotFound, SizeMismatch, SwitchboardAttachmentTransport, UploadTooLarge, createAttachmentClient, createFetchUploadTransport, createRef, createRemoteAttachmentService, createXhrUploadTransport, parseAttachmentDownloadTarget, parseAttachmentUploadTarget, parseRef, progressFraction, runWithConcurrency, withByteProgress };
 
 //# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","names":[],"sources":["../src/client.ts"],"sourcesContent":["import type { AttachmentHash, AttachmentRef } from \"@powerhousedao/reactor\";\nimport { AttachmentAlreadyExists } from \"./errors.js\";\nimport type { IAttachmentService, IAttachmentUpload } from \"./interfaces.js\";\nimport { createRef } from \"./ref.js\";\nimport type {\n  AttachmentUploadResult,\n  HashFirstReserveAttachmentOptions,\n} from \"./types.js\";\n\nexport { AttachmentService } from \"./attachment-service.js\";\nexport {\n  AttachmentAlreadyExists,\n  AttachmentNotFound,\n  AttachmentPending,\n  HashMismatch,\n  InvalidAttachmentRef,\n  ReservationNotFound,\n  SizeMismatch,\n  UploadTooLarge,\n} from \"./errors.js\";\nexport type {\n  IAttachmentReader,\n  IAttachmentService,\n  IAttachmentStore,\n  IAttachmentTransport,\n  IAttachmentTransportFactory,\n  IAttachmentUpload,\n  IAttachmentUploadFactory,\n  IReservationStore,\n} from \"./interfaces.js\";\nexport { parseRef, createRef } from \"./ref.js\";\nexport type { ParsedRef } from \"./ref.js\";\nexport type {\n  AttachmentHeader,\n  AttachmentMetadata,\n  AttachmentResponse,\n  AttachmentStatus,\n  AttachmentTransportConfig,\n  AttachmentUploadResult,\n  HashFirstReserveAttachmentOptions,\n  UploadFirstReserveAttachmentOptions,\n  Reservation,\n  ReserveAttachmentOptions,\n  TransportFetchResult,\n  TransportResponse,\n} from \"./types.js\";\nexport {\n  SwitchboardAttachmentTransport,\n  type SwitchboardTransportConfig,\n  RemoteReservationStore,\n  type SwitchboardClientConfig,\n  RemoteAttachmentUpload,\n  RemoteAttachmentUploadFactory,\n  RemoteAttachmentStore,\n  createRemoteAttachmentService,\n} from \"./switchboard/index.js\";\nexport { NullAttachmentTransport } from \"./null-attachment-transport.js\";\n\nexport type PreprocessResult = {\n  ref: AttachmentRef;\n  hash: AttachmentHash;\n  sizeBytes: number;\n  options: HashFirstReserveAttachmentOptions;\n  data: ReadableStream<Uint8Array>;\n  stream: () => ReadableStream<Uint8Array>;\n};\n\nexport interface IAttachmentClient {\n  preprocess(\n    file: Blob,\n    opts?: { fileName?: string; mimeType?: string },\n  ): Promise<PreprocessResult>;\n  reserve(\n    options: HashFirstReserveAttachmentOptions,\n    send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>,\n  ): Promise<AttachmentUploadResult>;\n}\n\nfunction streamFromBuffer(buf: Uint8Array): ReadableStream<Uint8Array> {\n  return new ReadableStream({\n    start(controller) {\n      controller.enqueue(buf);\n      controller.close();\n    },\n  });\n}\n\nclass AttachmentClientImpl implements IAttachmentClient {\n  constructor(private readonly service: IAttachmentService) {}\n\n  async preprocess(\n    file: Blob,\n    opts?: { fileName?: string; mimeType?: string },\n  ): Promise<PreprocessResult> {\n    const buf = await file.arrayBuffer();\n    const bytes = new Uint8Array(buf);\n    const digest = await globalThis.crypto.subtle.digest(\"SHA-256\", bytes);\n    const hash = Array.from(new Uint8Array(digest))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\") as AttachmentHash;\n    const ref = createRef(hash);\n    const sizeBytes = file.size;\n    const mimeType = opts?.mimeType ?? file.type;\n    const fileName =\n      opts?.fileName ?? (file instanceof File ? file.name : \"attachment\");\n    const options: HashFirstReserveAttachmentOptions = {\n      mimeType,\n      fileName,\n      clientHash: hash,\n      sizeBytes,\n    };\n    const data = streamFromBuffer(bytes);\n    const stream = (): ReadableStream<Uint8Array> => streamFromBuffer(bytes);\n    return { ref, hash, sizeBytes, options, data, stream };\n  }\n\n  async reserve(\n    options: HashFirstReserveAttachmentOptions,\n    send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>,\n  ): Promise<AttachmentUploadResult> {\n    let handle: IAttachmentUpload;\n    try {\n      handle = await this.service.reserve(options);\n    } catch (err) {\n      if (err instanceof AttachmentAlreadyExists) {\n        const header = await this.service.stat(err.ref);\n        return { hash: err.hash, ref: err.ref, header };\n      }\n      throw err;\n    }\n    return send(handle);\n  }\n}\n\nexport function createAttachmentClient(\n  service: IAttachmentService,\n): IAttachmentClient {\n  return new AttachmentClientImpl(service);\n}\n"],"mappings":";;AA8EA,SAAS,iBAAiB,KAA6C;AACrE,QAAO,IAAI,eAAe,EACxB,MAAM,YAAY;AAChB,aAAW,QAAQ,IAAI;AACvB,aAAW,OAAO;IAErB,CAAC;;AAGJ,IAAM,uBAAN,MAAwD;CACtD,YAAY,SAA8C;AAA7B,OAAA,UAAA;;CAE7B,MAAM,WACJ,MACA,MAC2B;EAC3B,MAAM,MAAM,MAAM,KAAK,aAAa;EACpC,MAAM,QAAQ,IAAI,WAAW,IAAI;EACjC,MAAM,SAAS,MAAM,WAAW,OAAO,OAAO,OAAO,WAAW,MAAM;EACtE,MAAM,OAAO,MAAM,KAAK,IAAI,WAAW,OAAO,CAAC,CAC5C,KAAK,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAC3C,KAAK,GAAG;EACX,MAAM,MAAM,UAAU,KAAK;EAC3B,MAAM,YAAY,KAAK;EAIvB,MAAM,UAA6C;GACjD,UAJe,MAAM,YAAY,KAAK;GAKtC,UAHA,MAAM,aAAa,gBAAgB,OAAO,KAAK,OAAO;GAItD,YAAY;GACZ;GACD;EACD,MAAM,OAAO,iBAAiB,MAAM;EACpC,MAAM,eAA2C,iBAAiB,MAAM;AACxE,SAAO;GAAE;GAAK;GAAM;GAAW;GAAS;GAAM;GAAQ;;CAGxD,MAAM,QACJ,SACA,MACiC;EACjC,IAAI;AACJ,MAAI;AACF,YAAS,MAAM,KAAK,QAAQ,QAAQ,QAAQ;WACrC,KAAK;AACZ,OAAI,eAAe,yBAAyB;IAC1C,MAAM,SAAS,MAAM,KAAK,QAAQ,KAAK,IAAI,IAAI;AAC/C,WAAO;KAAE,MAAM,IAAI;KAAM,KAAK,IAAI;KAAK;KAAQ;;AAEjD,SAAM;;AAER,SAAO,KAAK,OAAO;;;AAIvB,SAAgB,uBACd,SACmB;AACnB,QAAO,IAAI,qBAAqB,QAAQ"}
+{"version":3,"file":"client.js","names":[],"sources":["../src/concurrency.ts","../src/progress.ts","../src/client.ts"],"sourcesContent":["/**\n * Ordered result of one batch item. `index` always mirrors the input\n * position, so callers can correlate results with inputs regardless of\n * completion order, and successes are retained when siblings fail.\n */\nexport type BatchItemResult<R> =\n  | { index: number; status: \"fulfilled\"; value: R }\n  | { index: number; status: \"rejected\"; error: unknown };\n\nexport type RunWithConcurrencyOptions<R = unknown> = {\n  /** Maximum simultaneously running workers. Must be a positive integer. */\n  concurrency: number;\n  /**\n   * Whole-batch cancellation: unstarted items are rejected with the signal's\n   * reason without ever starting, while already-started items keep running —\n   * per-item signals are the mechanism for interrupting active work.\n   */\n  signal?: AbortSignal;\n  /**\n   * Called once per item as it settles, in completion order, including items\n   * the signal skipped before they ever started. That completeness is the\n   * point: a caller counting settlements must still reach `items.length`\n   * after a whole-batch abort.\n   */\n  onSettled?: (result: BatchItemResult<R>) => void;\n};\n\n/**\n * Runs `worker` over `items` with a hard upper bound on simultaneous\n * executions. Bounding starts (not just transfers) is what keeps memory flat:\n * an item's preprocessing (hashing/buffering) only begins when a slot frees.\n */\nexport async function runWithConcurrency<T, R>(\n  items: readonly T[],\n  worker: (item: T, index: number) => Promise<R>,\n  options: RunWithConcurrencyOptions<R>,\n): Promise<BatchItemResult<R>[]> {\n  const { concurrency, signal, onSettled } = options;\n  if (!Number.isInteger(concurrency) || concurrency < 1) {\n    throw new Error(\n      `concurrency must be a positive integer, got: ${concurrency}`,\n    );\n  }\n\n  const results: BatchItemResult<R>[] = new Array<BatchItemResult<R>>(\n    items.length,\n  );\n  let nextIndex = 0;\n\n  async function runLane(): Promise<void> {\n    for (;;) {\n      const index = nextIndex++;\n      if (index >= items.length) return;\n      if (signal?.aborted) {\n        results[index] = {\n          index,\n          status: \"rejected\",\n          error: signalReason(signal),\n        };\n        onSettled?.(results[index]);\n        continue;\n      }\n      try {\n        const value = await worker(items[index], index);\n        results[index] = { index, status: \"fulfilled\", value };\n      } catch (error) {\n        results[index] = { index, status: \"rejected\", error };\n      }\n      onSettled?.(results[index]);\n    }\n  }\n\n  const lanes = Array.from(\n    { length: Math.min(concurrency, items.length) },\n    () => runLane(),\n  );\n  await Promise.all(lanes);\n  return results;\n}\n\nfunction signalReason(signal: AbortSignal): unknown {\n  return (\n    (signal as { reason?: unknown }).reason ??\n    new DOMException(\"The operation was aborted\", \"AbortError\")\n  );\n}\n","/**\n * Byte-level progress for attachment transfers.\n *\n * `loaded`/`total` are per-stage, never per-operation. A per-operation\n * denominator would have to weight hashing against transfer, and a confirmed\n * dedup would shrink it mid-flight from 2N to N — the bar would run backwards.\n * Choosing that weighting is a UI decision the client cannot make.\n */\n\nexport type AttachmentStage =\n  | \"hashing\"\n  | \"reserving\"\n  | \"uploading\"\n  | \"requesting-download-target\"\n  | \"downloading\"\n  | \"done\"\n  | \"error\";\n\nexport type AttachmentProgress = {\n  stage: AttachmentStage;\n  /** Bytes moved so far within `stage`. */\n  loaded: number;\n  /** Denominator for `stage`: file.size for uploads, header.sizeBytes for downloads. */\n  total: number | undefined;\n  /** True when the stage is running but bytes cannot (yet) be observed. */\n  indeterminate: boolean;\n  /** Only on a terminal `done` where dedup skipped the transfer entirely. */\n  deduped?: true;\n};\n\nexport type AttachmentProgressListener = (progress: AttachmentProgress) => void;\n\nexport type AttachmentProgressOptions = {\n  onProgress?: AttachmentProgressListener;\n  /** Min ms between byte events within a stage. Default 100. 0 emits every observation. */\n  throttleMs?: number;\n};\n\nexport const DEFAULT_PROGRESS_THROTTLE_MS = 100;\n\n/**\n * Fraction in 0..1 for a progress event. Indeterminate and unknown-total\n * events read as 0 — a bar cannot honestly show a position it does not know.\n * A zero total is complete by definition (the dedup case moves no bytes).\n */\nexport function progressFraction(progress: AttachmentProgress): number {\n  if (progress.indeterminate) return 0;\n  if (progress.total === undefined) return 0;\n  if (progress.total === 0) return 1;\n  const fraction = progress.loaded / progress.total;\n  if (fraction < 0) return 0;\n  return fraction > 1 ? 1 : fraction;\n}\n\nexport type ProgressEmitterOptions = AttachmentProgressOptions & {\n  /** Injected clock so throttle tests stay synchronous. */\n  now?: () => number;\n};\n\n/**\n * Emits `AttachmentProgress` for one single-item operation, upholding:\n *\n * - **I1** exactly one terminal event (`done` or `error`) — never both, never twice.\n * - **I2** on `done`: `indeterminate === false`, `total` is a number, `loaded === total`.\n * - **I3** `loaded` is non-decreasing within a stage and resets to 0 on stage change.\n * - **I4** the terminal event bypasses the throttle unconditionally.\n * - **I5** `error` carries the last known `loaded`/`total`.\n *\n * Leading edge: the first `bytes()` after a `stage()` always emits, so a bar\n * leaves 0 immediately. There is deliberately no trailing-edge timer — it\n * would leak on throw, could fire after the terminal event and violate I1's\n * ordering, and is unnecessary because `finish()` always emits\n * `loaded === total`, making a dropped last intra-stage tick invisible.\n */\nexport class ProgressEmitter {\n  private readonly listener: AttachmentProgressListener | undefined;\n  private readonly throttleMs: number;\n  private readonly now: () => number;\n\n  private currentStage: AttachmentStage | undefined;\n  private loaded = 0;\n  private total: number | undefined;\n  private emittedBytesInStage = false;\n  private lastEmitAt = Number.NEGATIVE_INFINITY;\n  private settled = false;\n\n  constructor(options?: ProgressEmitterOptions) {\n    this.listener = options?.onProgress;\n    this.throttleMs = options?.throttleMs ?? DEFAULT_PROGRESS_THROTTLE_MS;\n    this.now = options?.now ?? (() => Date.now());\n  }\n\n  /** True when a listener is attached; lets callers skip instrumentation entirely. */\n  get active(): boolean {\n    return this.listener !== undefined;\n  }\n\n  /**\n   * Enter a stage. Always emits and resets `loaded` to 0. Entry is always\n   * indeterminate: no bytes have moved yet, and whether they can be observed\n   * at all is only proven by a transport actually calling back.\n   */\n  stage(stage: AttachmentStage, options?: { total?: number }): void {\n    if (this.settled) return;\n    this.currentStage = stage;\n    this.loaded = 0;\n    this.total = options?.total;\n    this.emittedBytesInStage = false;\n    this.emit({\n      stage,\n      loaded: 0,\n      total: this.total,\n      indeterminate: true,\n    });\n  }\n\n  /**\n   * Report observed bytes within the current stage. Throttled by time, with\n   * the first observation after a stage change always emitted.\n   */\n  bytes(loaded: number, total?: number): void {\n    if (this.settled || this.currentStage === undefined) return;\n    if (total !== undefined) this.total = total;\n    if (loaded > this.loaded) this.loaded = loaded;\n\n    const leadingEdge = !this.emittedBytesInStage;\n    if (!leadingEdge && this.now() - this.lastEmitAt < this.throttleMs) return;\n    this.emittedBytesInStage = true;\n    this.emit({\n      stage: this.currentStage,\n      loaded: this.loaded,\n      total: this.total,\n      indeterminate: false,\n    });\n  }\n\n  /**\n   * Terminal success. `total` defaults to the bytes actually seen so a stage\n   * with no known denominator still satisfies I2.\n   */\n  finish(override?: { loaded?: number; total?: number; deduped?: true }): void {\n    if (this.settled) return;\n    this.settled = true;\n    const total = override?.total ?? this.total ?? this.loaded;\n    const loaded = override?.loaded ?? total;\n    this.emit({\n      stage: \"done\",\n      loaded,\n      total,\n      indeterminate: false,\n      ...(override?.deduped ? { deduped: true as const } : {}),\n    });\n  }\n\n  /** Terminal success for a confirmed dedup: no bytes moved, and none needed to. */\n  finishDeduped(): void {\n    this.finish({ loaded: 0, total: 0, deduped: true });\n  }\n\n  /** Terminal failure, carrying the last known byte counts. */\n  fail(): void {\n    if (this.settled) return;\n    this.settled = true;\n    this.emit({\n      stage: \"error\",\n      loaded: this.loaded,\n      total: this.total,\n      indeterminate: false,\n    });\n  }\n\n  private emit(progress: AttachmentProgress): void {\n    this.lastEmitAt = this.now();\n    this.listener?.(progress);\n  }\n}\n\nexport type ByteProgressHooks = {\n  /** Cumulative bytes handed to the consumer. */\n  onBytes?: (loaded: number) => void;\n  /** The source ended and every byte reached the consumer. */\n  onDone?: () => void;\n  onError?: (error: unknown) => void;\n};\n\n/**\n * Count bytes as a consumer reads them.\n *\n * Uses the manual-reader form rather than `pipeThrough`, whose internal queue\n * reads far ahead of the consumer and would make `loaded` overstate what was\n * actually received. `highWaterMark: 0` is load-bearing for the same reason:\n * at the default of 1 the wrapper pulls one chunk the instant it is\n * constructed, so a caller who never reads still sees bytes counted.\n *\n * `cancel` propagates to the source, which is what keeps reader refcounts\n * (e.g. `KyselyAttachmentStore`'s) correct. Cancelling is an abandonment, not\n * a completion, so it reports `onError` — never `onDone` — carrying the\n * cancel reason the way an `AbortSignal` carries its own, with the DOM's\n * default `AbortError` when the canceller gave none.\n *\n * Returns `source` unchanged when no hook is supplied, so a caller with no\n * listener pays nothing.\n */\nexport function withByteProgress(\n  source: ReadableStream<Uint8Array>,\n  hooks: ByteProgressHooks,\n): ReadableStream<Uint8Array> {\n  if (!hooks.onBytes && !hooks.onDone && !hooks.onError) return source;\n\n  let loaded = 0;\n  let cancelled = false;\n  const reader = source.getReader();\n  return new ReadableStream<Uint8Array>(\n    {\n      async pull(controller) {\n        try {\n          const { done, value } = await reader.read();\n          // A cancel that lands while this read is in flight resolves it as\n          // `done`, and closes the stream. Bailing out here is what stops an\n          // abandoned transfer from reporting completion, and stops the\n          // already-closed controller from throwing a fabricated error into\n          // the catch below.\n          if (cancelled) return;\n          if (done) {\n            hooks.onDone?.();\n            controller.close();\n            return;\n          }\n          loaded += value.byteLength;\n          hooks.onBytes?.(loaded);\n          controller.enqueue(value);\n        } catch (err) {\n          if (cancelled) return;\n          hooks.onError?.(err);\n          controller.error(err);\n        }\n      },\n      cancel(reason) {\n        cancelled = true;\n        reader.cancel(reason).catch(() => {});\n        hooks.onError?.(reason ?? abortError());\n      },\n    },\n    { highWaterMark: 0 },\n  );\n}\n\n/** What an `AbortSignal` carries when `abort()` is called with no reason. */\nfunction abortError(): DOMException {\n  return new DOMException(\"The operation was aborted\", \"AbortError\");\n}\n","import type { AttachmentHash, AttachmentRef } from \"@powerhousedao/reactor\";\nimport {\n  runWithConcurrency,\n  type BatchItemResult,\n  type RunWithConcurrencyOptions,\n} from \"./concurrency.js\";\nimport { AttachmentAlreadyExists } from \"./errors.js\";\nexport type { AttachmentTransferStage } from \"./errors.js\";\nexport {\n  runWithConcurrency,\n  type BatchItemResult,\n  type RunWithConcurrencyOptions,\n} from \"./concurrency.js\";\nimport type { IAttachmentService, IAttachmentUpload } from \"./interfaces.js\";\nimport {\n  ProgressEmitter,\n  withByteProgress,\n  type AttachmentProgress,\n  type AttachmentProgressOptions,\n} from \"./progress.js\";\nimport { createRef } from \"./ref.js\";\nimport type {\n  AttachmentHeader,\n  AttachmentResponse,\n  AttachmentSendOptions,\n  AttachmentUploadResult,\n  HashFirstReserveAttachmentOptions,\n} from \"./types.js\";\n\nexport { AttachmentService } from \"./attachment-service.js\";\nexport {\n  AttachmentAlreadyExists,\n  AttachmentNotFound,\n  AttachmentPending,\n  AttachmentTransferError,\n  HashMismatch,\n  InvalidAttachmentRef,\n  ReservationNotFound,\n  SizeMismatch,\n  UploadTooLarge,\n} from \"./errors.js\";\nexport type {\n  IAttachmentReader,\n  IAttachmentService,\n  IAttachmentStore,\n  IAttachmentTransport,\n  IAttachmentTransportFactory,\n  IAttachmentUpload,\n  IAttachmentUploadFactory,\n  IReservationStore,\n} from \"./interfaces.js\";\nexport { parseRef, createRef } from \"./ref.js\";\nexport type { ParsedRef } from \"./ref.js\";\nexport type {\n  AttachmentDownloadOptions,\n  AttachmentDownloadTarget,\n  AttachmentDownloadTargetOptions,\n  AttachmentHeader,\n  AttachmentMetadata,\n  AttachmentResponse,\n  AttachmentSendOptions,\n  AttachmentStatus,\n  AttachmentTransportConfig,\n  AttachmentUploadResult,\n  AttachmentTargetHeaders,\n  AttachmentUploadTarget,\n  HashFirstReserveAttachmentOptions,\n  UploadFirstReserveAttachmentOptions,\n  Reservation,\n  ReserveAttachmentOptions,\n  TransportFetchResult,\n  TransportResponse,\n} from \"./types.js\";\nexport {\n  parseAttachmentDownloadTarget,\n  parseAttachmentUploadTarget,\n} from \"./targets.js\";\nexport {\n  SwitchboardAttachmentTransport,\n  type SwitchboardTransportConfig,\n  RemoteReservationStore,\n  type SwitchboardClientConfig,\n  RemoteAttachmentUpload,\n  RemoteAttachmentUploadFactory,\n  RemoteAttachmentStore,\n  createRemoteAttachmentService,\n  createFetchUploadTransport,\n  createXhrUploadTransport,\n  type AttachmentUploadRequest,\n  type AttachmentUploadResponse,\n  type AttachmentUploadTransport,\n  type XhrUploadTransportOptions,\n} from \"./switchboard/index.js\";\nexport { NullAttachmentTransport } from \"./null-attachment-transport.js\";\nexport {\n  DEFAULT_PROGRESS_THROTTLE_MS,\n  progressFraction,\n  ProgressEmitter,\n  withByteProgress,\n  type AttachmentProgress,\n  type AttachmentProgressListener,\n  type AttachmentProgressOptions,\n  type AttachmentStage,\n  type ByteProgressHooks,\n  type ProgressEmitterOptions,\n} from \"./progress.js\";\n\nexport type PreprocessResult = {\n  ref: AttachmentRef;\n  hash: AttachmentHash;\n  sizeBytes: number;\n  options: HashFirstReserveAttachmentOptions;\n  data: ReadableStream<Uint8Array>;\n  stream: () => ReadableStream<Uint8Array>;\n};\n\nexport type AttachmentUploadInput = {\n  file: Blob;\n  fileName?: string;\n  mimeType?: string;\n  /** Per-item cancellation, checked between stages. */\n  signal?: AbortSignal;\n};\n\n/**\n * Upload bytes that were already hashed by a separate `preprocess()` call.\n *\n * This is the canonical two-call flow: the ref must reach the document before\n * the bytes are committed, so callers preprocess, dispatch the operation, then\n * upload. Passing the result back in skips the hashing stage rather than\n * faking a zero-millisecond one.\n */\nexport type AttachmentPreprocessedUploadInput = {\n  preprocessed: PreprocessResult;\n  signal?: AbortSignal;\n};\n\n/**\n * Every remote download names the document that authorizes its ref; batches\n * may freely mix documents because the anchor travels with each item.\n */\nexport type AttachmentDownloadInput = {\n  documentId: string;\n  ref: AttachmentRef;\n  signal?: AbortSignal;\n};\n\n/**\n * The document keeps its own name and type for an attachment (the same\n * bytes may appear under different names in different documents), so the\n * blob-producing conveniences let callers override what the server header\n * reports from upload time.\n */\nexport type AttachmentBlobOptions = {\n  mimeType?: string;\n};\n\nexport type AttachmentSaveOptions = {\n  fileName?: string;\n  mimeType?: string;\n};\n\nexport type AttachmentBlobResult = {\n  blob: Blob;\n  header: AttachmentHeader;\n};\n\nexport type AttachmentObjectUrl = {\n  /** Ready for img/iframe/video src. Pins memory until revoke() is called. */\n  url: string;\n  header: AttachmentHeader;\n  revoke: () => void;\n};\n\nexport type AttachmentShareLinkInput = {\n  documentId: string;\n  ref: AttachmentRef;\n  /** Requested link lifetime in seconds; the server clamps to its maximum. */\n  expiresIn?: number;\n  signal?: AbortSignal;\n};\n\n/**\n * A self-contained public URL: anyone holding it can fetch the bytes until\n * expiresAtUtc, with no login and no document access. Minting one requires\n * document read access; once minted it cannot be revoked before expiry.\n */\nexport type AttachmentShareLink = {\n  url: string;\n  expiresAtUtc: string;\n};\n\n/**\n * Batch progress is per item, carrying the item's `index`. There is\n * deliberately no batch-wide byte total: weighting items against each other is\n * a presentation decision the client cannot make, and a confirmed dedup would\n * shrink the denominator mid-flight.\n */\nexport type AttachmentBatchOptions = {\n  /** Bounds preprocessing and transfer together. Defaults to 4. */\n  concurrency?: number;\n  /** Whole-batch cancellation: stops unstarted items. */\n  signal?: AbortSignal;\n  onProgress?: (progress: AttachmentProgress & { index: number }) => void;\n  /**\n   * Fired as each item settles, including items the signal skipped before they\n   * started, so `settled` always reaches `total`.\n   */\n  onItemSettled?: (counts: AttachmentBatchCounts) => void;\n  /** Min ms between byte events, applied per item rather than batch-wide. */\n  throttleMs?: number;\n};\n\nexport type AttachmentBatchCounts = {\n  settled: number;\n  completed: number;\n  failed: number;\n  total: number;\n};\n\nexport const DEFAULT_ATTACHMENT_BATCH_CONCURRENCY = 4;\n\nexport interface IAttachmentClient {\n  preprocess(\n    file: Blob,\n    opts?: { fileName?: string; mimeType?: string },\n  ): Promise<PreprocessResult>;\n  reserve(\n    options: HashFirstReserveAttachmentOptions,\n    send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>,\n  ): Promise<AttachmentUploadResult>;\n  /**\n   * Hash, reserve, and transfer one file; a confirmed dedup skips the transfer\n   * and reports a terminal `done` carrying `deduped: true` and zero bytes.\n   *\n   * Also accepts an already-preprocessed payload, so the canonical\n   * preprocess -> dispatch -> upload flow reports progress too.\n   */\n  upload(\n    input: AttachmentUploadInput | AttachmentPreprocessedUploadInput,\n    options?: AttachmentProgressOptions,\n  ): Promise<AttachmentUploadResult>;\n  /**\n   * Document-authorized download of one ref.\n   *\n   * Resolves as soon as the byte stream is available, with `downloading` as\n   * the last event emitted and `loaded: 0`. Byte events and the terminal\n   * `done` arrive as the caller reads the stream — and never arrive at all if\n   * the caller abandons it.\n   */\n  download(\n    input: AttachmentDownloadInput,\n    options?: AttachmentProgressOptions,\n  ): Promise<AttachmentResponse>;\n  /**\n   * Document-authorized download materialized as a typed Blob. The Blob's\n   * type comes from the server header unless overridden — that's what makes\n   * browsers render PDFs inline and images correctly.\n   */\n  downloadBlob(\n    input: AttachmentDownloadInput,\n    options?: AttachmentBlobOptions & AttachmentProgressOptions,\n  ): Promise<AttachmentBlobResult>;\n  /**\n   * Download and hand the bytes to the browser's save-file flow. Browser\n   * only. fileName defaults to the server header's; pass the document's own\n   * name for per-document naming.\n   */\n  saveAttachment(\n    input: AttachmentDownloadInput,\n    options?: AttachmentSaveOptions & AttachmentProgressOptions,\n  ): Promise<void>;\n  /**\n   * Download and expose the bytes as an object URL for inline rendering\n   * (img/iframe/video src). Callers MUST call revoke() when done — the URL\n   * pins the blob in memory until then.\n   */\n  downloadObjectUrl(\n    input: AttachmentDownloadInput,\n    options?: AttachmentBlobOptions & AttachmentProgressOptions,\n  ): Promise<AttachmentObjectUrl>;\n  /**\n   * Mint a public share link: a presigned URL anyone can fetch until it\n   * expires, with no login. Authorized exactly like a download (document\n   * read access + the reference index). Requires a presigned-capable\n   * storage backend (S3); rejects when the server answers with an\n   * authenticated switchboard target, which would not be public.\n   */\n  getShareLink(input: AttachmentShareLinkInput): Promise<AttachmentShareLink>;\n  uploadMany(\n    inputs: readonly AttachmentUploadInput[],\n    options?: AttachmentBatchOptions,\n  ): Promise<BatchItemResult<AttachmentUploadResult>[]>;\n  downloadMany(\n    inputs: readonly AttachmentDownloadInput[],\n    options?: AttachmentBatchOptions,\n  ): Promise<BatchItemResult<AttachmentResponse>[]>;\n}\n\n/**\n * Duck-typed dedup detection: bundlers (notably Vite dev pre-bundling) can\n * load two copies of this package's error classes, one for the service and\n * one for the client wrapper, making a plain instanceof check miss the\n * cross-copy throw. Name plus payload shape identifies the error reliably.\n */\nfunction isAttachmentAlreadyExists(\n  err: unknown,\n): err is AttachmentAlreadyExists {\n  if (err instanceof AttachmentAlreadyExists) return true;\n  return (\n    err instanceof Error &&\n    err.name === \"AttachmentAlreadyExists\" &&\n    typeof (err as { hash?: unknown }).hash === \"string\" &&\n    typeof (err as { ref?: unknown }).ref === \"string\"\n  );\n}\n\nfunction streamFromBuffer(buf: Uint8Array): ReadableStream<Uint8Array> {\n  return new ReadableStream({\n    start(controller) {\n      controller.enqueue(buf);\n      controller.close();\n    },\n  });\n}\n\n/** Stamps an item's index onto its progress events. */\nfunction itemProgress(\n  options: AttachmentBatchOptions | undefined,\n  index: number,\n): AttachmentProgressOptions | undefined {\n  if (!options?.onProgress && options?.throttleMs === undefined) {\n    return undefined;\n  }\n  return {\n    ...(options.onProgress\n      ? {\n          onProgress: (progress: AttachmentProgress) =>\n            options.onProgress?.({ ...progress, index }),\n        }\n      : {}),\n    ...(options.throttleMs !== undefined\n      ? { throttleMs: options.throttleMs }\n      : {}),\n  };\n}\n\nfunction batchRunOptions<R>(\n  total: number,\n  options: AttachmentBatchOptions | undefined,\n): RunWithConcurrencyOptions<R> {\n  const onItemSettled = options?.onItemSettled;\n  let settled = 0;\n  let completed = 0;\n  let failed = 0;\n  return {\n    concurrency: options?.concurrency ?? DEFAULT_ATTACHMENT_BATCH_CONCURRENCY,\n    ...(options?.signal ? { signal: options.signal } : {}),\n    ...(onItemSettled\n      ? {\n          onSettled: (result: BatchItemResult<R>) => {\n            settled += 1;\n            if (result.status === \"fulfilled\") completed += 1;\n            else failed += 1;\n            onItemSettled({ settled, completed, failed, total });\n          },\n        }\n      : {}),\n  };\n}\n\nclass AttachmentClientImpl implements IAttachmentClient {\n  constructor(private readonly service: IAttachmentService) {}\n\n  async preprocess(\n    file: Blob,\n    opts?: { fileName?: string; mimeType?: string },\n  ): Promise<PreprocessResult> {\n    const buf = await file.arrayBuffer();\n    const bytes = new Uint8Array(buf);\n    const digest = await globalThis.crypto.subtle.digest(\"SHA-256\", bytes);\n    const hash = Array.from(new Uint8Array(digest))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\") as AttachmentHash;\n    const ref = createRef(hash);\n    const sizeBytes = file.size;\n    const mimeType = opts?.mimeType ?? file.type;\n    const fileName =\n      opts?.fileName ?? (file instanceof File ? file.name : \"attachment\");\n    const options: HashFirstReserveAttachmentOptions = {\n      mimeType,\n      fileName,\n      clientHash: hash,\n      sizeBytes,\n    };\n    const data = streamFromBuffer(bytes);\n    const stream = (): ReadableStream<Uint8Array> => streamFromBuffer(bytes);\n    return { ref, hash, sizeBytes, options, data, stream };\n  }\n\n  /**\n   * Reserve, distinguishing a confirmed dedup from a live upload handle in the\n   * type rather than with a flag: the two outcomes move a different number of\n   * bytes, and every caller has to account for that.\n   */\n  private async reserveOrDedup(\n    options: HashFirstReserveAttachmentOptions,\n  ): Promise<\n    | { kind: \"handle\"; handle: IAttachmentUpload }\n    | { kind: \"deduped\"; result: AttachmentUploadResult }\n  > {\n    try {\n      return { kind: \"handle\", handle: await this.service.reserve(options) };\n    } catch (err) {\n      if (!isAttachmentAlreadyExists(err)) throw err;\n      const header = await this.service.stat(err.ref);\n      return {\n        kind: \"deduped\",\n        result: { hash: err.hash, ref: err.ref, header },\n      };\n    }\n  }\n\n  async reserve(\n    options: HashFirstReserveAttachmentOptions,\n    send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>,\n  ): Promise<AttachmentUploadResult> {\n    const outcome = await this.reserveOrDedup(options);\n    if (outcome.kind === \"deduped\") return outcome.result;\n    return send(outcome.handle);\n  }\n\n  async upload(\n    input: AttachmentUploadInput | AttachmentPreprocessedUploadInput,\n    options?: AttachmentProgressOptions,\n  ): Promise<AttachmentUploadResult> {\n    const emitter = new ProgressEmitter(options);\n    const signal = input.signal;\n    try {\n      signal?.throwIfAborted();\n\n      let preprocessed: PreprocessResult;\n      if (\"preprocessed\" in input) {\n        preprocessed = input.preprocessed;\n      } else {\n        // Hashing is genuinely unobservable: preprocess() runs one\n        // crypto.subtle.digest over the whole buffer and WebCrypto has no\n        // streaming digest. The stage is still reported, with a denominator\n        // and indeterminate never cleared, so a UI can name what it waits on.\n        emitter.stage(\"hashing\", { total: input.file.size });\n        preprocessed = await this.preprocess(input.file, {\n          ...(input.fileName !== undefined ? { fileName: input.fileName } : {}),\n          ...(input.mimeType !== undefined ? { mimeType: input.mimeType } : {}),\n        });\n      }\n      const sizeBytes = preprocessed.sizeBytes;\n\n      signal?.throwIfAborted();\n      emitter.stage(\"reserving\");\n      const outcome = await this.reserveOrDedup(preprocessed.options);\n\n      // A confirmed dedup never enters `uploading` — the server already holds\n      // these bytes, so none are sent. Reporting zero of zero keeps the byte\n      // model honest instead of stalling at 0 and then jumping to done.\n      if (outcome.kind === \"deduped\") {\n        emitter.finishDeduped();\n        return outcome.result;\n      }\n\n      signal?.throwIfAborted();\n      emitter.stage(\"uploading\", { total: sizeBytes });\n      // `onProgress` only when someone is listening. The XHR transport keys\n      // its `upload.onprogress` registration off the option being present, and\n      // that registration alone forces a CORS preflight on a presigned PUT —\n      // a cost an unwatched upload must not pay for a callback that would\n      // discard every event anyway.\n      const sendOptions: AttachmentSendOptions = {\n        ...(emitter.active\n          ? {\n              onProgress: (loaded: number, total?: number) =>\n                emitter.bytes(loaded, total ?? sizeBytes),\n            }\n          : {}),\n        ...(signal ? { signal } : {}),\n      };\n      const result = await outcome.handle.send(\n        preprocessed.stream(),\n        sendOptions,\n      );\n      emitter.finish();\n      return result;\n    } catch (err) {\n      emitter.fail();\n      throw err;\n    }\n  }\n\n  /**\n   * The single site where download bytes are instrumented.\n   *\n   * It sits here, above the service, rather than in any store or transport:\n   * one logical get can be several byte streams underneath (an evicted\n   * attachment is fetched from the transport, written to disk, then re-read),\n   * so counting lower down would double-count that path and still miss\n   * local-filesystem reads. Wrapping what `service.get` returns covers the\n   * presigned, switchboard, legacy and local paths by construction, and\n   * `downloadBlob`/`saveAttachment`/`downloadObjectUrl` inherit it.\n   */\n  private async getWithProgress(\n    input: AttachmentDownloadInput,\n    emitter: ProgressEmitter,\n  ): Promise<AttachmentResponse> {\n    const { header, body } = await this.service.get(input.ref, {\n      documentId: input.documentId,\n      signal: input.signal,\n    });\n    emitter.stage(\"downloading\", { total: header.sizeBytes });\n    if (!emitter.active) return { header, body };\n    return {\n      header,\n      body: withByteProgress(body, {\n        onBytes: (loaded) => emitter.bytes(loaded),\n        onDone: () => emitter.finish(),\n        onError: () => emitter.fail(),\n      }),\n    };\n  }\n\n  async download(\n    input: AttachmentDownloadInput,\n    options?: AttachmentProgressOptions,\n  ): Promise<AttachmentResponse> {\n    const emitter = new ProgressEmitter(options);\n    try {\n      input.signal?.throwIfAborted();\n      emitter.stage(\"requesting-download-target\");\n      return await this.getWithProgress(input, emitter);\n    } catch (err) {\n      emitter.fail();\n      throw err;\n    }\n  }\n\n  async downloadBlob(\n    input: AttachmentDownloadInput,\n    options?: AttachmentBlobOptions & AttachmentProgressOptions,\n  ): Promise<AttachmentBlobResult> {\n    const emitter = new ProgressEmitter(options);\n    try {\n      input.signal?.throwIfAborted();\n      emitter.stage(\"requesting-download-target\");\n      const { header, body } = await this.getWithProgress(input, emitter);\n      const reader = body.getReader();\n      const chunks: BlobPart[] = [];\n      for (;;) {\n        const { done, value } = await reader.read();\n        if (done) break;\n        chunks.push(value as BlobPart);\n      }\n      const blob = new Blob(chunks, {\n        type: options?.mimeType ?? header.mimeType,\n      });\n      // Draining the stream already finished the emitter; latching makes this\n      // a no-op there, and a guarantee for any body that closes without one.\n      emitter.finish();\n      return { blob, header };\n    } catch (err) {\n      emitter.fail();\n      throw err;\n    }\n  }\n\n  async saveAttachment(\n    input: AttachmentDownloadInput,\n    options?: AttachmentSaveOptions & AttachmentProgressOptions,\n  ): Promise<void> {\n    if (typeof document === \"undefined\") {\n      throw new Error(\n        \"saveAttachment requires a browser environment; use downloadBlob elsewhere\",\n      );\n    }\n    const { blob, header } = await this.downloadBlob(input, options);\n    const url = URL.createObjectURL(blob);\n    try {\n      const anchor = document.createElement(\"a\");\n      anchor.href = url;\n      anchor.download = options?.fileName ?? header.fileName;\n      anchor.click();\n    } finally {\n      URL.revokeObjectURL(url);\n    }\n  }\n\n  async downloadObjectUrl(\n    input: AttachmentDownloadInput,\n    options?: AttachmentBlobOptions & AttachmentProgressOptions,\n  ): Promise<AttachmentObjectUrl> {\n    const { blob, header } = await this.downloadBlob(input, options);\n    const url = URL.createObjectURL(blob);\n    let revoked = false;\n    return {\n      url,\n      header,\n      revoke: () => {\n        if (revoked) return;\n        revoked = true;\n        URL.revokeObjectURL(url);\n      },\n    };\n  }\n\n  async getShareLink(\n    input: AttachmentShareLinkInput,\n  ): Promise<AttachmentShareLink> {\n    input.signal?.throwIfAborted();\n    const target = await this.service.getDownloadTarget(input.ref, {\n      documentId: input.documentId,\n      ...(input.expiresIn !== undefined ? { expiresIn: input.expiresIn } : {}),\n      ...(input.signal !== undefined ? { signal: input.signal } : {}),\n    });\n    if (target.kind !== \"presigned-get\") {\n      throw new Error(\n        \"Public share links require a presigned-capable storage backend (S3); this server answered with an authenticated target\",\n      );\n    }\n    return { url: target.url, expiresAtUtc: target.expiresAtUtc };\n  }\n\n  uploadMany(\n    inputs: readonly AttachmentUploadInput[],\n    options?: AttachmentBatchOptions,\n  ): Promise<BatchItemResult<AttachmentUploadResult>[]> {\n    return runWithConcurrency(\n      inputs,\n      (input, index) => this.upload(input, itemProgress(options, index)),\n      batchRunOptions(inputs.length, options),\n    );\n  }\n\n  /**\n   * `concurrency` bounds download-target negotiation, not simultaneous byte\n   * transfer: each item resolves when its stream is handed over, and the bytes\n   * move only as the caller reads. Byte progress makes that pre-existing\n   * behavior visible; it does not change it.\n   */\n  downloadMany(\n    inputs: readonly AttachmentDownloadInput[],\n    options?: AttachmentBatchOptions,\n  ): Promise<BatchItemResult<AttachmentResponse>[]> {\n    return runWithConcurrency(\n      inputs,\n      (input, index) => this.download(input, itemProgress(options, index)),\n      batchRunOptions(inputs.length, options),\n    );\n  }\n}\n\nexport function createAttachmentClient(\n  service: IAttachmentService,\n): IAttachmentClient {\n  return new AttachmentClientImpl(service);\n}\n"],"mappings":"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"}