@powerhousedao/reactor-attachments 6.1.0-dev.2 → 6.1.0-dev.20

package/dist/null-attachment-transport-Drx03s02.js

@@ -0,0 +1,686 @@
+//#region src/errors.ts
+/**
+* Thrown when an attachment ref or hash is not known to the store.
+*/
+var AttachmentNotFound = class extends Error {
+	constructor(identifier) {
+		super(`Attachment not found: ${identifier}`);
+		this.name = "AttachmentNotFound";
+	}
+};
+/**
+* Thrown when a reservation ID is not found in the reservation store.
+*/
+var ReservationNotFound = class extends Error {
+	constructor(reservationId) {
+		super(`Reservation not found: ${reservationId}`);
+		this.name = "ReservationNotFound";
+	}
+};
+/**
+* Thrown when an attachment ref string does not match the expected format.
+*/
+var InvalidAttachmentRef = class extends Error {
+	constructor(ref) {
+		super(`Invalid attachment ref: ${ref}`);
+		this.name = "InvalidAttachmentRef";
+	}
+};
+/**
+* Thrown when an upload exceeds the configured maximum byte cap.
+* Route handlers should map this to HTTP 413 Payload Too Large.
+*/
+var UploadTooLarge = class extends Error {
+	maxBytes;
+	constructor(maxBytes) {
+		super(`Upload exceeds maximum size of ${maxBytes} bytes`);
+		this.name = "UploadTooLarge";
+		this.maxBytes = maxBytes;
+	}
+};
+/**
+* Thrown by reserve() when the claimed hash is already available in the store.
+* The caller should use err.ref directly and upload nothing -- this is the
+* dedup fast path: duplicate content never leaves the client.
+*/
+var AttachmentAlreadyExists = class extends Error {
+	hash;
+	ref;
+	constructor(hash, ref) {
+		super(`Attachment already exists for hash: ${hash}`);
+		this.name = "AttachmentAlreadyExists";
+		this.hash = hash;
+		this.ref = ref;
+	}
+};
+/**
+* Thrown by send() when the server-computed hash of the uploaded bytes
+* does not match the hash claimed at reservation time. Nothing is committed;
+* the reservation is retained so the client can retry with correct bytes.
+*/
+var HashMismatch = class extends Error {
+	claimed;
+	actual;
+	constructor(claimed, actual) {
+		super(`Hash mismatch: claimed ${claimed} but computed ${actual}`);
+		this.name = "HashMismatch";
+		this.claimed = claimed;
+		this.actual = actual;
+	}
+};
+/**
+* Thrown by send() when the uploaded byte count does not equal the
+* sizeBytes declared at reservation time. The handle may reject
+* mid-stream as soon as the count exceeds the declaration.
+* Nothing is committed; the reservation is retained for retry.
+*
+* "actual" is the byte count received from the stream before aborting --
+* it includes the chunk that crossed the declaration and can exceed bytes
+* persisted. On mid-stream aborts the true total is unknown; at least
+* "actual" bytes were sent.
+*/
+var SizeMismatch = class extends Error {
+	declared;
+	actual;
+	constructor(declared, actual) {
+		super(`Size mismatch: declared ${declared} bytes but received ${actual}`);
+		this.name = "SizeMismatch";
+		this.declared = declared;
+		this.actual = actual;
+	}
+};
+/**
+* Thrown by get() when the hash is reserved by an in-flight upload and
+* bytes are not yet available anywhere. Deliberately NOT a subclass of
+* AttachmentNotFound -- callers must distinguish "retry later" from "unknown".
+* After expiresAtUtc has passed the hash reads as not found.
+*
+* metadata is populated when the reservation is local and its fields are
+* known (mimeType, fileName, sizeBytes). It is undefined when the pending
+* state is learned from a remote transport that did not supply the full
+* Attachment-Pending header (transport-pending / degraded wire case).
+*/
+var AttachmentPending = class extends Error {
+	hash;
+	expiresAtUtc;
+	metadata;
+	constructor(hash, expiresAtUtc, meta) {
+		super(`Attachment pending upload for hash: ${hash}, expires: ${expiresAtUtc}`);
+		this.name = "AttachmentPending";
+		this.hash = hash;
+		this.expiresAtUtc = expiresAtUtc;
+		this.metadata = meta;
+	}
+};
+//#endregion
+//#region src/ref.ts
+const REF_PATTERN = /^attachment:\/\/v(\d+):(.+)$/;
+const DEFAULT_VERSION = 1;
+function parseRef(ref) {
+	const match = REF_PATTERN.exec(ref);
+	if (!match) throw new InvalidAttachmentRef(ref);
+	return {
+		version: Number(match[1]),
+		hash: match[2]
+	};
+}
+function createRef(hash, version = DEFAULT_VERSION) {
+	return `attachment://v${version}:${hash}`;
+}
+//#endregion
+//#region src/attachment-service.ts
+const CLIENT_HASH_PATTERN = /^[a-f0-9]{64}$/;
+var AttachmentService = class {
+	constructor(store, reservations, uploadFactory) {
+		this.store = store;
+		this.reservations = reservations;
+		this.uploadFactory = uploadFactory;
+	}
+	async reserve(options) {
+		if (options.clientHash !== void 0) return this.reserveHashFirst(options);
+		const reservation = await this.reservations.create(options);
+		return this.uploadFactory.createUpload(reservation);
+	}
+	async stat(ref) {
+		const { hash } = parseRef(ref);
+		return this.store.stat(hash);
+	}
+	async get(ref, signal) {
+		const { hash } = parseRef(ref);
+		return this.store.get(hash, signal);
+	}
+	async reserveHashFirst(options) {
+		const normalized = options.clientHash.toLowerCase();
+		if (!CLIENT_HASH_PATTERN.test(normalized)) throw new Error(`clientHash must be a 64-character lowercase hex string, got: ${options.clientHash}`);
+		if (options.sizeBytes === void 0 || !Number.isInteger(options.sizeBytes) || options.sizeBytes <= 0 || !Number.isSafeInteger(options.sizeBytes)) throw new Error("sizeBytes must be a positive safe integer when clientHash is provided");
+		const normalizedOptions = {
+			...options,
+			clientHash: normalized
+		};
+		let existingHeader = null;
+		try {
+			existingHeader = await this.store.stat(normalized);
+		} catch (err) {
+			if (!(err instanceof AttachmentNotFound) && !(err instanceof AttachmentPending)) throw err;
+		}
+		if (existingHeader !== null && existingHeader.status === "available") throw new AttachmentAlreadyExists(normalized, createRef(normalized));
+		const reservation = await this.reservations.create(normalizedOptions);
+		return this.uploadFactory.createUpload(reservation);
+	}
+};
+//#endregion
+//#region src/switchboard/build-auth-headers.ts
+async function buildAuthHeaders(url, jwtHandler) {
+	const headers = {};
+	if (jwtHandler) {
+		const token = await jwtHandler(url);
+		if (token) headers["Authorization"] = `Bearer ${token}`;
+	}
+	return headers;
+}
+//#endregion
+//#region src/switchboard/switchboard-attachment-transport.ts
+var SwitchboardAttachmentTransport = class {
+	remoteUrl;
+	jwtHandler;
+	fetchFn;
+	constructor(config) {
+		this.remoteUrl = config.remoteUrl;
+		this.jwtHandler = config.jwtHandler;
+		this.fetchFn = (config.fetchFn ?? globalThis.fetch).bind(globalThis);
+	}
+	async fetch(hash, signal) {
+		const url = `${this.remoteUrl}/attachments/${hash}`;
+		const headers = await buildAuthHeaders(url, this.jwtHandler);
+		const response = await this.fetchFn(url, {
+			signal,
+			headers
+		});
+		if (response.status === 202) {
+			const expiresAtUtc = this.parsePendingExpiry(response);
+			if (!expiresAtUtc) throw new Error("Attachment fetch returned 202 with missing or malformed Attachment-Pending header");
+			return {
+				kind: "pending",
+				hash,
+				expiresAtUtc,
+				retryAfterMs: parseRetryAfterMs(response)
+			};
+		}
+		if (response.status === 404) return { kind: "not-found" };
+		if (!response.ok) throw new Error(`Attachment fetch failed: ${response.status} ${response.statusText}`);
+		const metadata = this.parseMetadataHeaders(response);
+		const body = response.body;
+		if (!body) throw new Error("Response body is null");
+		return {
+			kind: "data",
+			response: {
+				hash,
+				metadata,
+				body
+			}
+		};
+	}
+	async announce(_hash) {}
+	async push(hash, remote, data) {
+		const url = `${remote}/attachments/${hash}`;
+		const headers = await buildAuthHeaders(url, this.jwtHandler);
+		const response = await this.fetchFn(url, {
+			method: "PUT",
+			body: data,
+			headers,
+			duplex: "half"
+		});
+		if (!response.ok) throw new Error(`Attachment push failed: ${response.status} ${response.statusText}`);
+	}
+	parsePendingExpiry(response) {
+		const header = response.headers.get("Attachment-Pending");
+		if (!header) return null;
+		try {
+			const parsed = JSON.parse(header);
+			if (!isRecord$3(parsed)) return null;
+			if (typeof parsed.expiresAtUtc !== "string") return null;
+			return parsed.expiresAtUtc;
+		} catch {
+			return null;
+		}
+	}
+	parseMetadataHeaders(response) {
+		let fallbackCache;
+		const fallback = () => {
+			if (fallbackCache === void 0) fallbackCache = contentTypeFallback$1(response);
+			return fallbackCache;
+		};
+		const metaHeader = response.headers.get("Attachment-Metadata");
+		if (metaHeader) try {
+			const parsed = JSON.parse(metaHeader);
+			if (isRecord$3(parsed)) {
+				if (parsed.extension === void 0) parsed.extension = null;
+				if (parsed.createdAtUtc === void 0) parsed.createdAtUtc = fallback().createdAtUtc;
+				if (parsed.lastAccessedAtUtc === void 0) parsed.lastAccessedAtUtc = fallback().lastAccessedAtUtc;
+			}
+			if (isAttachmentMetadata$1(parsed)) return parsed;
+		} catch {}
+		return fallback();
+	}
+};
+const DEFAULT_RETRY_AFTER_MS = 5e3;
+function parseRetryAfterMs(response) {
+	const retryAfter = response.headers.get("Retry-After");
+	if (!retryAfter) return DEFAULT_RETRY_AFTER_MS;
+	const seconds = Number(retryAfter);
+	if (!Number.isFinite(seconds) || seconds < 0) return DEFAULT_RETRY_AFTER_MS;
+	return Math.round(seconds * 1e3);
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAttachmentMetadata$1(value) {
+	if (!isRecord$3(value)) return false;
+	if (typeof value.mimeType !== "string") return false;
+	if (typeof value.fileName !== "string") return false;
+	if (typeof value.sizeBytes !== "number" || !Number.isFinite(value.sizeBytes) || value.sizeBytes < 0) return false;
+	if (value.extension !== null && typeof value.extension !== "string") return false;
+	if (typeof value.createdAtUtc !== "string") return false;
+	if (value.lastAccessedAtUtc !== void 0 && typeof value.lastAccessedAtUtc !== "string") return false;
+	return true;
+}
+function contentTypeFallback$1(response) {
+	const contentLength = response.headers.get("Content-Length");
+	if (contentLength === null) throw new Error("Switchboard response missing both Attachment-Metadata and Content-Length headers");
+	const sizeBytes = Number(contentLength);
+	if (!Number.isInteger(sizeBytes) || sizeBytes < 0) throw new Error(`Switchboard response has invalid Content-Length header: ${JSON.stringify(contentLength)}`);
+	const lastModified = response.headers.get("Last-Modified");
+	const dateHeader = response.headers.get("Date");
+	const createdAtUtc = lastModified ? new Date(lastModified).toISOString() : dateHeader ? new Date(dateHeader).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		mimeType: response.headers.get("Content-Type") ?? "application/octet-stream",
+		fileName: "unknown",
+		sizeBytes,
+		extension: null,
+		createdAtUtc,
+		lastAccessedAtUtc: createdAtUtc
+	};
+}
+//#endregion
+//#region src/switchboard/remote-reservation-store.ts
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deriveExtension(fileName) {
+	const idx = fileName.lastIndexOf(".");
+	if (idx <= 0 || idx === fileName.length - 1) return null;
+	return fileName.slice(idx + 1).toLowerCase();
+}
+function isReservationBase(value) {
+	if (!isRecord$2(value)) return false;
+	if (typeof value.reservationId !== "string") return false;
+	if (typeof value.mimeType !== "string") return false;
+	if (typeof value.fileName !== "string") return false;
+	if (value.extension !== null && typeof value.extension !== "string") return false;
+	if (typeof value.createdAtUtc !== "string") return false;
+	if (typeof value.expiresAtUtc !== "string") return false;
+	return true;
+}
+function isReservation(value) {
+	if (!isReservationBase(value)) return false;
+	if (value.clientHash !== void 0 && value.clientHash !== null && typeof value.clientHash !== "string") return false;
+	if (value.sizeBytes !== void 0 && value.sizeBytes !== null && typeof value.sizeBytes !== "number") return false;
+	return true;
+}
+var RemoteReservationStore = class {
+	remoteUrl;
+	jwtHandler;
+	fetchFn;
+	constructor(config) {
+		this.remoteUrl = config.remoteUrl;
+		this.jwtHandler = config.jwtHandler;
+		this.fetchFn = (config.fetchFn ?? globalThis.fetch).bind(globalThis);
+	}
+	async create(options) {
+		const url = `${this.remoteUrl}/attachments/reservations`;
+		const authHeaders = await buildAuthHeaders(url, this.jwtHandler);
+		const extension = options.extension ?? deriveExtension(options.fileName);
+		const bodyObj = {
+			mimeType: options.mimeType,
+			fileName: options.fileName,
+			extension
+		};
+		if (options.clientHash !== void 0) bodyObj.clientHash = options.clientHash;
+		if (options.sizeBytes !== void 0) bodyObj.sizeBytes = options.sizeBytes;
+		const response = await this.fetchFn(url, {
+			method: "POST",
+			headers: {
+				...authHeaders,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(bodyObj)
+		});
+		if (response.status === 409) {
+			let body;
+			try {
+				body = await response.json();
+			} catch {
+				throw new Error(`Reservation create failed: ${response.status} ${response.statusText}`);
+			}
+			if (isRecord$2(body) && body.error === "already_exists" && options.clientHash !== void 0) {
+				let ref;
+				if (typeof body.ref === "string") try {
+					parseRef(body.ref);
+					ref = body.ref;
+				} catch {
+					ref = createRef(options.clientHash);
+				}
+				else ref = createRef(options.clientHash);
+				throw new AttachmentAlreadyExists(options.clientHash, ref);
+			}
+			throw new Error(`Reservation create failed: ${response.status} ${response.statusText}`);
+		}
+		if (!response.ok) throw new Error(`Reservation create failed: ${response.status} ${response.statusText}`);
+		let json;
+		try {
+			json = await response.json();
+		} catch {
+			throw new Error("Reservation create returned non-JSON response");
+		}
+		if (typeof json !== "object" || json === null || typeof json.reservationId !== "string" || json.reservationId.length === 0) throw new Error("Reservation create returned a payload missing a non-empty reservationId string");
+		const body = json;
+		const now = /* @__PURE__ */ new Date();
+		return {
+			reservationId: body.reservationId,
+			mimeType: options.mimeType,
+			fileName: options.fileName,
+			extension,
+			createdAtUtc: body.createdAtUtc ?? now.toISOString(),
+			expiresAtUtc: body.expiresAtUtc ?? new Date(now.getTime() + 1440 * 60 * 1e3).toISOString(),
+			clientHash: options.clientHash ?? null,
+			sizeBytes: options.sizeBytes ?? null
+		};
+	}
+	async get(reservationId) {
+		const url = `${this.remoteUrl}/attachments/reservations/${encodeURIComponent(reservationId)}`;
+		const authHeaders = await buildAuthHeaders(url, this.jwtHandler);
+		const response = await this.fetchFn(url, { headers: authHeaders });
+		if (response.status === 404) throw new ReservationNotFound(reservationId);
+		if (!response.ok) throw new Error(`Reservation get failed: ${response.status} ${response.statusText}`);
+		let parsed;
+		try {
+			parsed = await response.json();
+		} catch {
+			throw new Error("Reservation get returned non-JSON response");
+		}
+		if (!isReservation(parsed)) throw new Error("Reservation get returned a payload that does not match the Reservation shape");
+		return {
+			reservationId: parsed.reservationId,
+			mimeType: parsed.mimeType,
+			fileName: parsed.fileName,
+			extension: parsed.extension,
+			createdAtUtc: parsed.createdAtUtc,
+			expiresAtUtc: parsed.expiresAtUtc,
+			clientHash: parsed.clientHash ?? null,
+			sizeBytes: parsed.sizeBytes ?? null
+		};
+	}
+	async delete(reservationId) {
+		const url = `${this.remoteUrl}/attachments/reservations/${encodeURIComponent(reservationId)}`;
+		const authHeaders = await buildAuthHeaders(url, this.jwtHandler);
+		const response = await this.fetchFn(url, {
+			method: "DELETE",
+			headers: authHeaders
+		});
+		if (!response.ok && response.status !== 404 && response.status !== 410) throw new Error(`Reservation delete failed: ${response.status} ${response.statusText}`);
+	}
+	deleteExpired() {
+		return Promise.reject(/* @__PURE__ */ new Error("RemoteReservationStore.deleteExpired is not supported"));
+	}
+};
+//#endregion
+//#region src/switchboard/remote-attachment-upload.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var RemoteAttachmentUpload = class {
+	reservationId;
+	ref;
+	expiresAtUtc;
+	remoteUrl;
+	jwtHandler;
+	fetchFn;
+	constructor(reservation, config) {
+		this.reservationId = reservation.reservationId;
+		this.ref = reservation.clientHash !== null ? createRef(reservation.clientHash) : null;
+		this.expiresAtUtc = reservation.expiresAtUtc;
+		this.remoteUrl = config.remoteUrl;
+		this.jwtHandler = config.jwtHandler;
+		this.fetchFn = (config.fetchFn ?? globalThis.fetch).bind(globalThis);
+	}
+	async send(data) {
+		const url = `${this.remoteUrl}/attachments/reservations/${this.reservationId}`;
+		const authHeaders = await buildAuthHeaders(url, this.jwtHandler);
+		const body = await new Response(data).blob();
+		const response = await this.fetchFn(url, {
+			method: "PUT",
+			headers: {
+				...authHeaders,
+				"Content-Type": "application/octet-stream"
+			},
+			body
+		});
+		if (response.status === 422) {
+			let errorBody;
+			try {
+				errorBody = await response.json();
+			} catch {
+				throw new Error(`Attachment upload failed: ${response.status} ${response.statusText}`);
+			}
+			if (isRecord$1(errorBody)) {
+				if (errorBody.error === "hash_mismatch" && typeof errorBody.claimed === "string" && typeof errorBody.actual === "string") throw new HashMismatch(errorBody.claimed, errorBody.actual);
+				if (errorBody.error === "size_mismatch" && typeof errorBody.declared === "number" && typeof errorBody.actual === "number") throw new SizeMismatch(errorBody.declared, errorBody.actual);
+			}
+			throw new Error(`Attachment upload failed: ${response.status} ${response.statusText}`);
+		}
+		if (!response.ok) throw new Error(`Attachment upload failed: ${response.status} ${response.statusText}`);
+		return await response.json();
+	}
+};
+//#endregion
+//#region src/switchboard/remote-attachment-upload-factory.ts
+var RemoteAttachmentUploadFactory = class {
+	constructor(config) {
+		this.config = config;
+	}
+	createUpload(reservation) {
+		return new RemoteAttachmentUpload(reservation, this.config);
+	}
+};
+//#endregion
+//#region src/switchboard/remote-attachment-store.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAttachmentMetadata(value) {
+	if (!isRecord(value)) return false;
+	if (typeof value.mimeType !== "string") return false;
+	if (typeof value.fileName !== "string") return false;
+	if (typeof value.sizeBytes !== "number" || !Number.isFinite(value.sizeBytes) || value.sizeBytes < 0) return false;
+	if (value.extension !== null && typeof value.extension !== "string") return false;
+	if (typeof value.createdAtUtc !== "string") return false;
+	if (value.lastAccessedAtUtc !== void 0 && typeof value.lastAccessedAtUtc !== "string") return false;
+	return true;
+}
+function contentTypeFallback(response) {
+	const contentLength = response.headers.get("Content-Length");
+	if (contentLength === null) throw new Error("Switchboard response missing both Attachment-Metadata and Content-Length headers");
+	const sizeBytes = Number(contentLength);
+	if (!Number.isInteger(sizeBytes) || sizeBytes < 0) throw new Error(`Switchboard response has invalid Content-Length header: ${JSON.stringify(contentLength)}`);
+	const lastModified = response.headers.get("Last-Modified");
+	const dateHeader = response.headers.get("Date");
+	const createdAtUtc = lastModified ? new Date(lastModified).toISOString() : dateHeader ? new Date(dateHeader).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		mimeType: response.headers.get("Content-Type") ?? "application/octet-stream",
+		fileName: "unknown",
+		sizeBytes,
+		extension: null,
+		createdAtUtc,
+		lastAccessedAtUtc: createdAtUtc
+	};
+}
+function parseMetadata(response) {
+	let fallbackCache;
+	const fallback = () => {
+		if (fallbackCache === void 0) fallbackCache = contentTypeFallback(response);
+		return fallbackCache;
+	};
+	const metaHeader = response.headers.get("Attachment-Metadata");
+	if (metaHeader) try {
+		const parsed = JSON.parse(metaHeader);
+		if (isRecord(parsed)) {
+			if (parsed.extension === void 0) parsed.extension = null;
+			if (parsed.createdAtUtc === void 0) parsed.createdAtUtc = fallback().createdAtUtc;
+			if (parsed.lastAccessedAtUtc === void 0) parsed.lastAccessedAtUtc = fallback().lastAccessedAtUtc;
+		}
+		if (isAttachmentMetadata(parsed)) return parsed;
+	} catch {}
+	return fallback();
+}
+function parsePendingExpiry(response) {
+	const header = response.headers.get("Attachment-Pending");
+	if (!header) return null;
+	try {
+		const parsed = JSON.parse(header);
+		if (!isRecord(parsed)) return null;
+		if (typeof parsed.expiresAtUtc !== "string") return null;
+		const result = { expiresAtUtc: parsed.expiresAtUtc };
+		if (typeof parsed.mimeType === "string") result.mimeType = parsed.mimeType;
+		if (typeof parsed.fileName === "string") result.fileName = parsed.fileName;
+		if (typeof parsed.sizeBytes === "number" && Number.isFinite(parsed.sizeBytes) && parsed.sizeBytes >= 0) result.sizeBytes = parsed.sizeBytes;
+		return result;
+	} catch {
+		return null;
+	}
+}
+function parsePendingHeader(response) {
+	const partial = parsePendingExpiry(response);
+	if (!partial) return null;
+	if (typeof partial.mimeType !== "string" || typeof partial.fileName !== "string" || partial.sizeBytes === void 0) return null;
+	return {
+		expiresAtUtc: partial.expiresAtUtc,
+		mimeType: partial.mimeType,
+		fileName: partial.fileName,
+		sizeBytes: partial.sizeBytes
+	};
+}
+var RemoteAttachmentStore = class {
+	remoteUrl;
+	jwtHandler;
+	fetchFn;
+	constructor(config) {
+		this.remoteUrl = config.remoteUrl;
+		this.jwtHandler = config.jwtHandler;
+		this.fetchFn = (config.fetchFn ?? globalThis.fetch).bind(globalThis);
+	}
+	/**
+	* Get attachment metadata. Normally returns a pending AttachmentHeader
+	* (status: 'pending') when the server responds 202 with a full
+	* Attachment-Pending header. When only expiresAtUtc is present in the
+	* header (degraded wire), throws AttachmentPending instead -- the
+	* AttachmentPending throw is the degraded-wire case.
+	*/
+	async stat(hash) {
+		const url = `${this.remoteUrl}/attachments/${hash}`;
+		const authHeaders = await buildAuthHeaders(url, this.jwtHandler);
+		const response = await this.fetchFn(url, {
+			method: "HEAD",
+			headers: authHeaders
+		});
+		if (response.status === 202) {
+			const fullPending = parsePendingHeader(response);
+			if (fullPending) return buildPendingHeader(hash, fullPending);
+			const partial = parsePendingExpiry(response);
+			if (partial) throw new AttachmentPending(hash, partial.expiresAtUtc);
+			throw new Error("Attachment stat returned 202 with missing or malformed Attachment-Pending header");
+		}
+		if (response.status === 404) throw new AttachmentNotFound(hash);
+		if (!response.ok) throw new Error(`Attachment stat failed: ${response.status} ${response.statusText}`);
+		return buildHeader(hash, parseMetadata(response));
+	}
+	async get(hash, signal) {
+		return this.fetchAttachment(hash, signal);
+	}
+	async fetchAttachment(hash, signal) {
+		const url = `${this.remoteUrl}/attachments/${hash}`;
+		const headers = await buildAuthHeaders(url, this.jwtHandler);
+		const response = await this.fetchFn(url, {
+			signal,
+			headers
+		});
+		if (response.status === 202) {
+			const pending = parsePendingExpiry(response);
+			if (!pending) throw new Error("Attachment fetch returned 202 with missing or malformed Attachment-Pending header");
+			throw new AttachmentPending(hash, pending.expiresAtUtc);
+		}
+		if (response.status === 404) throw new AttachmentNotFound(hash);
+		if (!response.ok) throw new Error(`Attachment fetch failed: ${response.status} ${response.statusText}`);
+		if (!response.body) throw new Error("Response body is null");
+		return {
+			header: buildHeader(hash, parseMetadata(response)),
+			body: response.body
+		};
+	}
+};
+function buildHeader(hash, metadata) {
+	return {
+		hash,
+		mimeType: metadata.mimeType,
+		fileName: metadata.fileName,
+		sizeBytes: metadata.sizeBytes,
+		extension: metadata.extension,
+		status: "available",
+		source: "sync",
+		createdAtUtc: metadata.createdAtUtc,
+		lastAccessedAtUtc: metadata.lastAccessedAtUtc ?? metadata.createdAtUtc,
+		expiresAtUtc: null
+	};
+}
+function buildPendingHeader(hash, pending) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		hash,
+		mimeType: pending.mimeType,
+		fileName: pending.fileName,
+		sizeBytes: pending.sizeBytes,
+		extension: null,
+		status: "pending",
+		source: "sync",
+		createdAtUtc: now,
+		lastAccessedAtUtc: now,
+		expiresAtUtc: pending.expiresAtUtc
+	};
+}
+//#endregion
+//#region src/switchboard/create-remote-attachment-service.ts
+function createRemoteAttachmentService(config) {
+	const reservations = new RemoteReservationStore(config);
+	const uploadFactory = new RemoteAttachmentUploadFactory(config);
+	return new AttachmentService(new RemoteAttachmentStore(config), reservations, uploadFactory);
+}
+//#endregion
+//#region src/null-attachment-transport.ts
+/**
+* No-op transport for deployments without remote sync.
+* fetch() always returns not-found, announce() and push() are no-ops.
+*/
+var NullAttachmentTransport = class {
+	fetch() {
+		return Promise.resolve({ kind: "not-found" });
+	}
+	announce() {
+		return Promise.resolve();
+	}
+	push() {
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { SizeMismatch as _, RemoteAttachmentUpload as a, AttachmentService as c, AttachmentAlreadyExists as d, AttachmentNotFound as f, ReservationNotFound as g, InvalidAttachmentRef as h, RemoteAttachmentUploadFactory as i, createRef as l, HashMismatch as m, createRemoteAttachmentService as n, RemoteReservationStore as o, AttachmentPending as p, RemoteAttachmentStore as r, SwitchboardAttachmentTransport as s, NullAttachmentTransport as t, parseRef as u, UploadTooLarge as v };
+
+//# sourceMappingURL=null-attachment-transport-Drx03s02.js.map