@powerhousedao/reactor-attachments 6.2.3-dev.50 → 6.2.3-dev.52

package/dist/{null-attachment-transport-jZmzFncu.d.ts → interfaces-jHW9JXv1.d.ts}

@@ -1,114 +1,4 @@
-import { AttachmentHash, AttachmentRef, JwtHandler } from "@powerhousedao/reactor";
-//#region src/errors.d.ts
-/**
- * Thrown when an attachment ref or hash is not known to the store.
- */
-declare class AttachmentNotFound extends Error {
-  constructor(identifier: string);
-}
-/**
- * Thrown when a reservation ID is not found in the reservation store.
- */
-declare class ReservationNotFound extends Error {
-  constructor(reservationId: string);
-}
-/**
- * Thrown when an attachment ref string does not match the expected format.
- */
-declare class InvalidAttachmentRef extends Error {
-  constructor(ref: string);
-}
-/** The reserve metadata field that failed validation. */
-type AttachmentMetadataField = "mimeType" | "fileName" | "extension";
-/**
- * Thrown when reserve metadata (MIME type, file name or extension) is not
- * acceptable. Route handlers should map this to HTTP 400 Bad Request.
- */
-declare class InvalidAttachmentMetadata extends Error {
-  readonly field: AttachmentMetadataField;
-  constructor(field: AttachmentMetadataField);
-}
-/**
- * Thrown when an upload exceeds the configured maximum byte cap.
- * Route handlers should map this to HTTP 413 Payload Too Large.
- */
-declare class UploadTooLarge extends Error {
-  readonly maxBytes: number;
-  constructor(maxBytes: number);
-}
-/**
- * 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.
- */
-declare class AttachmentAlreadyExists extends Error {
-  readonly hash: AttachmentHash;
-  readonly ref: AttachmentRef;
-  constructor(hash: AttachmentHash, ref: AttachmentRef);
-}
-/**
- * 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.
- */
-declare class HashMismatch extends Error {
-  readonly claimed: AttachmentHash;
-  readonly actual: AttachmentHash;
-  constructor(claimed: AttachmentHash, actual: AttachmentHash);
-}
-/**
- * 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.
- */
-declare class SizeMismatch extends Error {
-  readonly declared: number;
-  readonly actual: number;
-  constructor(declared: number, actual: number);
-}
-/**
- * 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).
- */
-type AttachmentTransferStage = "download-target" | "switchboard-get" | "presigned-get" | "presigned-put";
-/**
- * Thrown when a remote transfer step fails. Identifies the stage only; it
- * intentionally carries no URL, signature query, bucket key, or bearer
- * material so it is always safe to log or surface.
- */
-declare class AttachmentTransferError extends Error {
-  readonly stage: AttachmentTransferStage;
-  readonly status: number | undefined;
-  constructor(stage: AttachmentTransferStage, status?: number);
-}
-declare class AttachmentPending extends Error {
-  readonly hash: AttachmentHash;
-  readonly expiresAtUtc: string;
-  readonly metadata: {
-    readonly mimeType: string;
-    readonly fileName: string;
-    readonly sizeBytes: number;
-  } | undefined;
-  constructor(hash: AttachmentHash, expiresAtUtc: string, meta?: {
-    mimeType: string;
-    fileName: string;
-    sizeBytes: number;
-  });
-}
-//#endregion
+import { AttachmentHash, AttachmentRef } from "@powerhousedao/reactor";
 //#region src/types.d.ts
 type AttachmentBackendKind = "filesystem" | "s3";
 type AttachmentBackendHealth = {
@@ -320,6 +210,10 @@ type TransportFetchResult = {
   hash: AttachmentHash;
   expiresAtUtc: string;
   retryAfterMs: number;
+  /** The source is at capacity and did not look; not a reservation. */
+  busy?: true;
+  /** With `busy`: every source that was not busy answered not-found. */
+  othersNotFound?: true;
 } | {
   kind: "not-found";
 };
@@ -669,218 +563,6 @@ interface IAttachmentBackend {
   health(): Promise<AttachmentBackendHealth>;
 }
 //#endregion
-//#region src/targets.d.ts
-declare function parseAttachmentUploadTarget(value: unknown): AttachmentUploadTarget;
-declare function parseAttachmentDownloadTarget(value: unknown): AttachmentDownloadTarget;
-//#endregion
-//#region src/attachment-service.d.ts
-declare class AttachmentService implements IAttachmentService {
-  private readonly store;
-  private readonly reservations;
-  private readonly uploadFactory;
-  private readonly backend?;
-  constructor(store: IAttachmentReader, reservations: IReservationStore, uploadFactory: IAttachmentUploadFactory, backend?: IAttachmentBackend | undefined);
-  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
-  stat(ref: AttachmentRef, options?: AttachmentStatOptions): Promise<AttachmentHeader>;
-  get(ref: AttachmentRef, options?: AbortSignal | AttachmentDownloadOptions): Promise<AttachmentResponse>;
-  getDownloadTarget(ref: AttachmentRef, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
-  private reserveHashFirst;
-}
-//#endregion
-//#region src/ref.d.ts
-type ParsedRef = {
-  version: number;
-  hash: AttachmentHash;
-};
-declare function parseRef(ref: AttachmentRef): ParsedRef;
-declare function createRef(hash: AttachmentHash, version?: number): AttachmentRef;
-//#endregion
-//#region src/switchboard/switchboard-attachment-transport.d.ts
-type SwitchboardTransportConfig = {
-  remoteUrl: string;
-  jwtHandler?: JwtHandler;
-  fetchFn?: typeof fetch;
-};
-declare class SwitchboardAttachmentTransport implements IAttachmentTransport {
-  private readonly remoteUrl;
-  private readonly jwtHandler?;
-  private readonly fetchFn;
-  constructor(config: SwitchboardTransportConfig);
-  fetch(hash: AttachmentHash, documentId: string, signal?: AbortSignal): Promise<TransportFetchResult>;
-  announce(_hash: AttachmentHash): Promise<void>;
-  push(hash: AttachmentHash, remote: string, data: ReadableStream<Uint8Array>): Promise<void>;
-  private parsePendingExpiry;
-  private parseMetadataHeaders;
-}
-//#endregion
-//#region src/switchboard/upload-transport.d.ts
-/**
- * The seam every attachment upload PUT goes through.
- *
- * It exists because `fetch` cannot report upload-side progress: there is no
- * event between "request issued" and "response received". Naming the transport
- * lets an implementation that *can* count bytes (see
- * `createXhrUploadTransport`) be substituted without the upload code knowing
- * which one it holds — and it is also the right seam for a future multipart
- * upload, which needs one request per part.
- */
-/**
- * Headers are forwarded VERBATIM. A presigned target's headers are part of a
- * signature: normalizing their casing, or adding so much as one header,
- * invalidates it.
- */
-type AttachmentUploadRequest = {
-  url: string;
-  method: "PUT";
-  headers: Record<string, string>;
-  body: Blob;
-  /** Called with cumulative bytes handed to the socket, when observable. */
-  onProgress?: (loaded: number, total: number) => void;
-  signal?: AbortSignal;
-};
-/**
- * The only response surface the upload code reads. A real `Response`
- * satisfies this structurally, which is what lets the fetch transport be an
- * identity pass-through rather than an adapter.
- */
-type AttachmentUploadResponse = {
-  readonly status: number;
-  readonly statusText: string;
-  readonly ok: boolean;
-  json(): Promise<unknown>;
-};
-type AttachmentUploadTransport = (request: AttachmentUploadRequest) => Promise<AttachmentUploadResponse>;
-/**
- * The default transport. Ignores `onProgress` — fetch has no upload-side
- * progress event, and silence is how a transport reports that bytes are
- * unobservable.
- */
-declare function createFetchUploadTransport(fetchFn: typeof fetch): AttachmentUploadTransport;
-//#endregion
-//#region src/switchboard/xhr-upload-transport.d.ts
-type XhrUploadTransportOptions = {
-  /**
-   * Used where `XMLHttpRequest` does not exist (Node). Defaults to the global
-   * fetch, resolved at call time.
-   */
-  fetchFn?: typeof fetch;
-};
-/**
- * Upload transport backed by `XMLHttpRequest`, the only browser API that
- * reports upload-side byte progress (`xhr.upload.onprogress`). Everything else
- * about the request is identical to the fetch path.
- *
- * Capability detection happens **inside** the returned function, never at
- * module load: this module is reachable from the client entry, which is
- * executed in Node by the entrypoint tests, and Node has no
- * `XMLHttpRequest`. Detecting per call also means a test can install a fake on
- * `globalThis` without any module-registry reset.
- */
-declare function createXhrUploadTransport(options?: XhrUploadTransportOptions): AttachmentUploadTransport;
-//#endregion
-//#region src/switchboard/remote-reservation-store.d.ts
-type SwitchboardClientConfig = {
-  remoteUrl: string;
-  jwtHandler?: JwtHandler;
-  fetchFn?: typeof fetch;
-  /**
-   * Transport for upload PUTs only, so a browser host can opt into
-   * XMLHttpRequest and get real upload progress.
-   *
-   * An explicit `fetchFn` always wins over this. The precedence is
-   * one-directional on purpose: under this rule, adding `uploadTransport` to a
-   * config that already pins `fetchFn` is a provable no-op, whereas the
-   * reverse rule would let `{ ...config, uploadTransport }` silently route the
-   * largest request in the system around a test's mock and onto the network.
-   */
-  uploadTransport?: AttachmentUploadTransport;
-};
-declare class RemoteReservationStore implements IReservationStore {
-  private readonly remoteUrl;
-  private readonly jwtHandler?;
-  private readonly fetchFn;
-  constructor(config: SwitchboardClientConfig);
-  create(options: ReserveAttachmentOptions): Promise<Reservation>;
-  get(reservationId: string): Promise<Reservation>;
-  delete(reservationId: string): Promise<void>;
-  deleteExpired(): Promise<number>;
-}
-//#endregion
-//#region src/switchboard/remote-attachment-upload.d.ts
-declare class RemoteAttachmentUpload implements IAttachmentUpload {
-  readonly reservationId: string;
-  readonly ref: AttachmentRef | null;
-  readonly expiresAtUtc: string;
-  readonly uploadTarget?: AttachmentUploadTarget;
-  private readonly reservation;
-  private readonly remoteUrl;
-  private readonly jwtHandler?;
-  private readonly uploadTransport;
-  constructor(reservation: Reservation, config: SwitchboardClientConfig);
-  send(data: ReadableStream<Uint8Array>, options?: AttachmentSendOptions): Promise<AttachmentUploadResult>;
-  /**
-   * Direct provider upload: PUT the bytes to the presigned URL with exactly
-   * the returned headers — never the Switchboard JWT — and treat any 2xx as
-   * final success with no follow-up control request. The result is
-   * synthesized from the hash-first reservation, which is the only path that
-   * can produce a presigned target.
-   */
-  private sendPresigned;
-}
-//#endregion
-//#region src/switchboard/remote-attachment-upload-factory.d.ts
-declare class RemoteAttachmentUploadFactory implements IAttachmentUploadFactory {
-  private readonly config;
-  constructor(config: SwitchboardClientConfig);
-  createUpload(reservation: Reservation): IAttachmentUpload;
-}
-//#endregion
-//#region src/switchboard/remote-attachment-store.d.ts
-declare class RemoteAttachmentStore implements IAttachmentReader {
-  private readonly remoteUrl;
-  private readonly jwtHandler?;
-  private readonly fetchFn;
-  constructor(config: SwitchboardClientConfig);
-  /**
-   * 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.
-   */
-  stat(hash: AttachmentHash, documentId?: string): Promise<AttachmentHeader>;
-  get(hash: AttachmentHash, signal?: AbortSignal, documentId?: string): Promise<AttachmentResponse>;
-  /**
-   * Asks Switchboard for an authorized download target. The request carries
-   * the JWT; the response is runtime-validated before any byte transfer.
-   * Public so callers can mint direct URLs (previews, share links) without
-   * transferring bytes; `expiresIn` requests a caller-chosen lifetime.
-   */
-  getDownloadTarget(hash: AttachmentHash, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
-  /**
-   * Executes a presigned GET with exactly the returned headers and no JWT.
-   * A provider 404 means the object is missing despite available metadata
-   * (the accepted abandoned-upload trade-off) and surfaces as the same typed
-   * not-found error callers already handle.
-   */
-  private fetchPresigned;
-  private fetchAttachment;
-}
-//#endregion
-//#region src/switchboard/create-remote-attachment-service.d.ts
-declare function createRemoteAttachmentService(config: SwitchboardClientConfig): IAttachmentService;
-//#endregion
-//#region src/null-attachment-transport.d.ts
-/**
- * No-op transport for deployments without remote sync.
- * fetch() always returns not-found, announce() and push() are no-ops.
- */
-declare class NullAttachmentTransport implements IAttachmentTransport {
-  fetch(): Promise<TransportFetchResult>;
-  announce(): Promise<void>;
-  push(): Promise<void>;
-}
-//#endregion
-export { AttachmentMetadataField as $, IReservationStore as A, AttachmentStatOptions as B, IAttachmentReader as C, IAttachmentTransportFactory as D, IAttachmentTransport as E, AttachmentDownloadTargetOptions as F, AttachmentUploadTarget as G, AttachmentTargetHeaders as H, AttachmentHeader as I, ReserveAttachmentOptions as J, HashFirstReserveAttachmentOptions as K, AttachmentMetadata as L, AttachmentBackendKind as M, AttachmentDownloadOptions as N, IAttachmentUpload as O, AttachmentDownloadTarget as P, AttachmentAlreadyExists as Q, AttachmentResponse as R, IAttachmentBackend as S, IAttachmentStore as T, AttachmentTransportConfig as U, AttachmentStatus as V, AttachmentUploadResult as W, TransportResponse as X, TransportFetchResult as Y, UploadFirstReserveAttachmentOptions as Z, createRef as _, RemoteAttachmentUpload as a, InvalidAttachmentMetadata as at, parseAttachmentDownloadTarget as b, XhrUploadTransportOptions as c, SizeMismatch as ct, AttachmentUploadResponse as d, AttachmentNotFound as et, AttachmentUploadTransport as f, ParsedRef as g, SwitchboardTransportConfig as h, RemoteAttachmentUploadFactory as i, HashMismatch as it, AttachmentBackendHealth as j, IAttachmentUploadFactory as k, createXhrUploadTransport as l, UploadTooLarge as lt, SwitchboardAttachmentTransport as m, createRemoteAttachmentService as n, AttachmentTransferError as nt, RemoteReservationStore as o, InvalidAttachmentRef as ot, createFetchUploadTransport as p, Reservation as q, RemoteAttachmentStore as r, AttachmentTransferStage as rt, SwitchboardClientConfig as s, ReservationNotFound as st, NullAttachmentTransport as t, AttachmentPending as tt, AttachmentUploadRequest as u, parseRef as v, IAttachmentService as w, parseAttachmentUploadTarget as x, AttachmentService as y, AttachmentSendOptions as z };
+export { UploadFirstReserveAttachmentOptions as A, AttachmentUploadResult as C, ReserveAttachmentOptions as D, Reservation as E, TransportFetchResult as O, AttachmentTransportConfig as S, HashFirstReserveAttachmentOptions as T, AttachmentResponse as _, IAttachmentTransport as a, AttachmentStatus as b, IAttachmentUploadFactory as c, AttachmentBackendKind as d, AttachmentDownloadOptions as f, AttachmentMetadata as g, AttachmentHeader as h, IAttachmentStore as i, TransportResponse as k, IReservationStore as l, AttachmentDownloadTargetOptions as m, IAttachmentReader as n, IAttachmentTransportFactory as o, AttachmentDownloadTarget as p, IAttachmentService as r, IAttachmentUpload as s, IAttachmentBackend as t, AttachmentBackendHealth as u, AttachmentSendOptions as v, AttachmentUploadTarget as w, AttachmentTargetHeaders as x, AttachmentStatOptions as y };
 export {};
-//# sourceMappingURL=null-attachment-transport-jZmzFncu.d.ts.map
+//# sourceMappingURL=interfaces-jHW9JXv1.d.ts.map

package/dist/interfaces-jHW9JXv1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces-jHW9JXv1.d.ts","names":[],"sources":["../src/types.ts","../src/interfaces.ts"],"mappings":";;KAEY;KAEA;EACV,MAAM;EACN;;;;;;;KAQU;;;;;;;KAQA;EACV,MAAM;EACN;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;KAsBU;EACV;EACA;EACA;EACA;EACA;EACA;;;;;;KAOU;EACV;EACA;EACA;EACA;EACA;;;;;;;;;KAUU;EACV;EACA;EACA;;;;EAIA,YAAY;;;;;;EAMZ;;;;;;;;;;;;KAaU,2BACR,sCACA;;;;KAKQ;EACV,MAAM;EACN,KAAK;EACL,QAAQ;;;;;;;;;;KAWE;EACV,cAAc,gBAAgB;EAC9B,SAAS;;;;;;;KAQC;EACV;EACA,SAAS;;;KAIC;EACV;;;;;;;;KASU;EACV;EACA;EACA,SAAS;;;KAIC,0BAA0B,SAAS;KAEnC;EACV;EACA;EACA;EACA,SAAS;EACT;;KAGU;EACV;EACA;EACA;EACA,SAAS;EACT;;;KAIU,yBACR,oCACA;KAEQ;EACV;EACA;EACA;EACA,SAAS;EACT;;KAGU;EACV;EACA;EACA;EACA,SAAS;EACT;;;KAIU,2BACR,sCACA;;;;KAKQ;EACV,QAAQ;EACR,MAAM,eAAe;;;;;;;;KASX;EACV,MAAM;EACN,UAAU;EACV,MAAM,eAAe;;;;;;;;KASX;EACN;EAAc,UAAU;;EAExB;EACA,MAAM;EACN;EACA;;EAEA;;EAEA;;EAEA;;;;;KAKM;EACV;EACA,YAAY;;;;;;;;;KAUF;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;EAMA,eAAe;;;;;;;;UC3PA;;;;;;;;;;;;;;;;;;;EAmBf,QAAQ,SAAS,2BAA2B,QAAQ;;;;;;;;;;;;EAapD,KACE,KAAK,eACL,UAAU,wBACT,QAAQ;;;;;;;;;;;;;;;;;EAkBX,IACE,KAAK,eACL,UAAU,cAAc,4BACvB,QAAQ;;;;;;;;;;;EAYX,kBACE,KAAK,eACL,SAAS,kCACR,QAAQ;;;;;;UAOI;;;;EAIf;;;;;;EAOA,KAAK;;;;;;WAOI;;WAGA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCxB,KACE,MAAM,eAAe,aACrB,UAAU,wBACT,QAAQ;;;;;;;;;;;UAYI;;;;;;;;;;;;;;EAcf,KAAK,MAAM,gBAAgB,sBAAsB,QAAQ;;;;;;;;;;;;;;;;;;;EAoBzD,IACE,MAAM,gBACN,SAAS,aACT,sBACC,QAAQ;;;;;;EAOX,mBACE,MAAM,gBACN,SAAS,kCACR,QAAQ;;;;;;;;UASI,yBAAyB;;;;;;;EAOxC,IAAI,MAAM,iBAAiB;;;;;;;;;;;;EAa3B,IACE,MAAM,gBACN,UAAU,oBACV,MAAM,eAAe,cACpB;;;;;;;;;;;;;;;;EAiBH,MAAM,MAAM,iBAAiB;;;;;EAM7B,eAAe;;;;;;;;;UAUA;;;;;;;;;;;;;;;EAef,MACE,MAAM,gBACN,oBACA,SAAS,cACR,QAAQ;;;;;;;EAQX,SAAS,MAAM,iBAAiB;;;;;;;;;;;EAYhC,KACE,MAAM,gBACN,gBACA,MAAM,eAAe,cACpB;;;;;;UAOY;EACf,SAAS,QAAQ,4BAA4B;;;;;;UAO9B;EACf,OAAO,SAAS,2BAA2B,QAAQ;EACnD,IAAI,wBAAwB,QAAQ;EACpC,OAAO,wBAAwB;;;;;;;;EAS/B,cAAc,MAAM,OAAO;;;;;;;UAQZ;EACf,aAAa,aAAa,cAAc;;;;;;;UAQzB;WACN,MAAM;EACf,oBACE,aAAa,cACZ,QAAQ;;;;;;EAMX,sBACE,MAAM,gBACN,sBACC,QAAQ;EACX,OAAO,MAAM,iBAAiB;EAC9B,UAAU,QAAQ"}

package/dist/{null-attachment-transport-CUDNBfd5.js → null-attachment-transport-BGG9cRC-.js}

@@ -1,136 +1,6 @@
-//#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 reserve metadata (MIME type, file name or extension) is not
-* acceptable. Route handlers should map this to HTTP 400 Bad Request.
-*/
-var InvalidAttachmentMetadata = class extends Error {
-	field;
-	constructor(field) {
-		super(`Invalid attachment ${field}`);
-		this.name = "InvalidAttachmentMetadata";
-		this.field = field;
-	}
-};
-/**
-* 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 when a remote transfer step fails. Identifies the stage only; it
-* intentionally carries no URL, signature query, bucket key, or bearer
-* material so it is always safe to log or surface.
-*/
-var AttachmentTransferError = class extends Error {
-	stage;
-	status;
-	constructor(stage, status) {
-		super(status === void 0 ? `Attachment ${stage} request failed` : `Attachment ${stage} request failed with status ${status}`);
-		this.name = "AttachmentTransferError";
-		this.stage = stage;
-		this.status = status;
-	}
-};
-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
+import { a as parseRef, c as AttachmentPending, i as createRef, l as AttachmentTransferError, m as SizeMismatch, n as buildAuthHeaders, o as AttachmentAlreadyExists, p as ReservationNotFound, s as AttachmentNotFound, u as HashMismatch } from "./switchboard-attachment-transport-BH3ZAmxE.js";
 //#region src/targets.ts
-function isRecord$4(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseUrl(value) {
@@ -146,7 +16,7 @@ function parseUrl(value) {
 	return value;
 }
 function parseHeaders(value) {
-	if (!isRecord$4(value)) throw new Error("Attachment target headers must be an object");
+	if (!isRecord$3(value)) throw new Error("Attachment target headers must be an object");
 	const headers = Object.create(null);
 	const headerName = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
 	for (const [name, headerValue] of Object.entries(value)) {
@@ -178,7 +48,7 @@ function parseExpiry(value, required) {
 	return value;
 }
 function parseAttachmentUploadTarget(value) {
-	if (!isRecord$4(value)) throw new Error("Attachment upload target must be an object");
+	if (!isRecord$3(value)) throw new Error("Attachment upload target must be an object");
 	const url = parseUrl(value.url);
 	const headers = parseHeaders(value.headers);
 	switch (value.kind) {
@@ -204,7 +74,7 @@ function parseAttachmentUploadTarget(value) {
 	}
 }
 function parseAttachmentDownloadTarget(value) {
-	if (!isRecord$4(value)) throw new Error("Attachment download target must be an object");
+	if (!isRecord$3(value)) throw new Error("Attachment download target must be an object");
 	const url = parseUrl(value.url);
 	const headers = parseHeaders(value.headers);
 	switch (value.kind) {
@@ -230,21 +100,6 @@ function parseAttachmentDownloadTarget(value) {
 	}
 }
 //#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 {
@@ -308,139 +163,6 @@ var AttachmentService = class {
 	}
 };
 //#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, documentId, signal) {
-		const url = `${this.remoteUrl}/attachments/${hash}?documentId=${encodeURIComponent(documentId)}`;
-		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/upload-transport.ts
 /**
 * The default transport. Ignores `onProgress` — fetch has no upload-side
@@ -1034,6 +756,6 @@ var NullAttachmentTransport = class {
 	}
 };
 //#endregion
-export { SizeMismatch as C, ReservationNotFound as S, AttachmentPending as _, RemoteAttachmentUpload as a, InvalidAttachmentMetadata as b, createFetchUploadTransport as c, createRef as d, parseRef as f, AttachmentNotFound as g, AttachmentAlreadyExists as h, RemoteAttachmentUploadFactory as i, SwitchboardAttachmentTransport as l, parseAttachmentUploadTarget as m, createRemoteAttachmentService as n, RemoteReservationStore as o, parseAttachmentDownloadTarget as p, RemoteAttachmentStore as r, createXhrUploadTransport as s, NullAttachmentTransport as t, AttachmentService as u, AttachmentTransferError as v, UploadTooLarge as w, InvalidAttachmentRef as x, HashMismatch as y };
+export { RemoteAttachmentUpload as a, createFetchUploadTransport as c, parseAttachmentUploadTarget as d, RemoteAttachmentUploadFactory as i, AttachmentService as l, createRemoteAttachmentService as n, RemoteReservationStore as o, RemoteAttachmentStore as r, createXhrUploadTransport as s, NullAttachmentTransport as t, parseAttachmentDownloadTarget as u };
 
-//# sourceMappingURL=null-attachment-transport-CUDNBfd5.js.map
+//# sourceMappingURL=null-attachment-transport-BGG9cRC-.js.map