@powerhousedao/reactor-attachments 6.2.2-dev.7 → 6.2.2-dev.71

package/dist/{null-attachment-transport-BBhQIk5A.d.ts → null-attachment-transport-CMrO_ZKA.d.ts}

@@ -74,6 +74,17 @@ declare class SizeMismatch extends Error {
  * 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;
@@ -90,6 +101,11 @@ declare class AttachmentPending extends Error {
 }
 //#endregion
 //#region src/types.d.ts
+type AttachmentBackendKind = "filesystem" | "s3";
+type AttachmentBackendHealth = {
+  kind: AttachmentBackendKind;
+  ready: boolean;
+};
 /**
  * Status of attachment data in the local store.
  * 'pending' is a virtual status synthesized at query time from live,
@@ -193,6 +209,72 @@ type AttachmentUploadResult = {
   ref: AttachmentRef;
   header: AttachmentHeader;
 };
+/**
+ * Options for one byte transfer through an upload handle.
+ *
+ * `onProgress` is best-effort: a transport that cannot observe its own
+ * upload bytes (notably `fetch`, which exposes no upload-side progress)
+ * simply never calls it. Absence is the signal — there is no capability
+ * negotiation.
+ */
+type AttachmentSendOptions = {
+  onProgress?: (loaded: number, total?: number) => void;
+  signal?: AbortSignal;
+};
+/**
+ * Options form of IAttachmentService.get. `documentId` anchors the download
+ * authorization for remote readers; it never becomes part of the ref or any
+ * global configuration.
+ */
+type AttachmentDownloadOptions = {
+  documentId?: string;
+  signal?: AbortSignal;
+};
+/**
+ * Options for minting a raw download target without transferring bytes
+ * (previews, share links). `documentId` is required: targets are always
+ * document-authorized. `expiresIn` (seconds) requests a caller-chosen
+ * target lifetime; the server clamps it to its configured maximum.
+ */
+type AttachmentDownloadTargetOptions = {
+  documentId: string;
+  expiresIn?: number;
+  signal?: AbortSignal;
+};
+/** Exact HTTP headers that must be sent with an attachment transfer target. */
+type AttachmentTargetHeaders = Readonly<Record<string, string>>;
+type SwitchboardAttachmentUploadTarget = {
+  kind: "switchboard";
+  method: "PUT";
+  url: string;
+  headers: AttachmentTargetHeaders;
+  expiresAtUtc?: string;
+};
+type PresignedPutAttachmentUploadTarget = {
+  kind: "presigned-put";
+  method: "PUT";
+  url: string;
+  headers: AttachmentTargetHeaders;
+  expiresAtUtc: string;
+};
+/** Provider-neutral target returned to a client that needs to upload bytes. */
+type AttachmentUploadTarget = SwitchboardAttachmentUploadTarget | PresignedPutAttachmentUploadTarget;
+type SwitchboardAttachmentDownloadTarget = {
+  kind: "switchboard";
+  method: "GET";
+  url: string;
+  headers: AttachmentTargetHeaders;
+  expiresAtUtc?: string;
+};
+type PresignedGetAttachmentDownloadTarget = {
+  kind: "presigned-get";
+  method: "GET";
+  url: string;
+  headers: AttachmentTargetHeaders;
+  expiresAtUtc: string;
+};
+/** Provider-neutral target returned to a client that needs to download bytes. */
+type AttachmentDownloadTarget = SwitchboardAttachmentDownloadTarget | PresignedGetAttachmentDownloadTarget;
 /**
  * Response when retrieving attachment data from the local store.
  */
@@ -251,6 +333,12 @@ type Reservation = {
   expiresAtUtc: string;
   clientHash: string | null;
   sizeBytes: number | null;
+  /**
+   * Additive wire contract. Older Switchboards omit this field; current
+   * upload handles therefore continue to support their established send()
+   * behavior while target-aware clients are introduced incrementally.
+   */
+  uploadTarget?: AttachmentUploadTarget;
 };
 //#endregion
 //#region src/interfaces.d.ts
@@ -299,8 +387,23 @@ interface IAttachmentService {
    *         expiresAtUtc. A wait inside get() would hold request handlers
    *         open across multi-second windows and hide retry policy where
    *         callers cannot tune it.
+   *
+   * The options form carries the document id that authorizes a remote
+   * download; local/direct readers ignore it. The bare-signal form remains
+   * supported for source compatibility.
+   */
+  get(ref: AttachmentRef, options?: AbortSignal | AttachmentDownloadOptions): Promise<AttachmentResponse>;
+  /**
+   * Obtain the raw, document-authorized download target for a ref without
+   * transferring any bytes. Used to mint direct URLs (previews, share
+   * links): a presigned target URL is a self-contained public capability
+   * until its expiry. `expiresIn` (seconds) requests a caller-chosen
+   * lifetime; the server clamps it to its configured maximum.
+   *
+   * @throws when the underlying store cannot produce download targets
+   *         (local/direct stores serve bytes, not URLs).
    */
-  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
+  getDownloadTarget(ref: AttachmentRef, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
 }
 /**
  * Upload handle returned by reserve(). Encapsulates all transport-specific
@@ -323,6 +426,8 @@ interface IAttachmentUpload {
    * Clients use this to bound retry windows and populate the pending-upload queue.
    */
   readonly expiresAtUtc: string;
+  /** Direct transfer target returned by target-capable server backends. */
+  readonly uploadTarget?: AttachmentUploadTarget;
   /**
    * Stream attachment data through this handle.
    *
@@ -345,8 +450,19 @@ interface IAttachmentUpload {
    *   so the client can retry with the correct bytes.
    *
    * @returns The content hash, ref, and header for the uploaded attachment.
+   *
+   * `options.onProgress` reports bytes handed to the transport, when the
+   * transport can observe them at all -- some cannot, so it may never fire,
+   * and an implementation is free to ignore it.
+   *
+   * `options.signal` aborts the transfer in flight, and any implementation
+   * that moves bytes must honour it: reject with an `AbortError` and commit
+   * nothing. `useAttachmentUpload().cancel()` promises exactly that, so an
+   * implementation that quietly ran to completion would report a cancelled
+   * upload as done. A handle that transfers nothing itself (the S3 handle,
+   * which requires its presigned target) has nothing to abort.
    */
-  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
+  send(data: ReadableStream<Uint8Array>, options?: AttachmentSendOptions): Promise<AttachmentUploadResult>;
 }
 /**
  * Read-only subset of IAttachmentStore.
@@ -383,8 +499,17 @@ interface IAttachmentReader {
    * @throws AttachmentPending if the hash is reserved by an in-flight
    *         upload; bytes are not yet available. There is no store-level
    *         wait -- polling is the caller's responsibility.
+   *
+   * `documentId` is the authorization anchor for remote readers that must
+   * negotiate a download target; local/direct readers ignore it.
+   */
+  get(hash: AttachmentHash, signal?: AbortSignal, documentId?: string): Promise<AttachmentResponse>;
+  /**
+   * Optional capability: readers that negotiate download targets with a
+   * remote control plane can expose the raw target so callers may mint
+   * direct URLs (previews, share links). Local/direct readers omit it.
    */
-  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
+  getDownloadTarget?(hash: AttachmentHash, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
 }
 /**
  * Reactor-facing interface for managing local attachment data.
@@ -506,16 +631,39 @@ interface IReservationStore {
 interface IAttachmentUploadFactory {
   createUpload(reservation: Reservation): IAttachmentUpload;
 }
+/**
+ * Server-side storage capability boundary. Authorization happens before these
+ * methods are called; actor, policy, and document concepts intentionally do
+ * not cross into the byte-storage backend.
+ */
+interface IAttachmentBackend {
+  readonly kind: AttachmentBackendKind;
+  prepareUploadTarget(reservation: Reservation): Promise<AttachmentUploadTarget>;
+  /**
+   * `ttlSeconds` overrides the backend's configured download TTL for this
+   * one target (used for caller-chosen share-link lifetimes). Callers are
+   * responsible for bounding it; backends may still reject absurd values.
+   */
+  prepareDownloadTarget(hash: AttachmentHash, ttlSeconds?: number): Promise<AttachmentDownloadTarget>;
+  exists(hash: AttachmentHash): Promise<boolean>;
+  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;
-  constructor(store: IAttachmentReader, reservations: IReservationStore, uploadFactory: IAttachmentUploadFactory);
+  private readonly backend?;
+  constructor(store: IAttachmentReader, reservations: IReservationStore, uploadFactory: IAttachmentUploadFactory, backend?: IAttachmentBackend | undefined);
   reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
   stat(ref: AttachmentRef): Promise<AttachmentHeader>;
-  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
+  get(ref: AttachmentRef, options?: AbortSignal | AttachmentDownloadOptions): Promise<AttachmentResponse>;
+  getDownloadTarget(ref: AttachmentRef, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
   private reserveHashFirst;
 }
 //#endregion
@@ -545,11 +693,86 @@ declare class SwitchboardAttachmentTransport implements IAttachmentTransport {
   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;
@@ -567,11 +790,21 @@ 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 fetchFn;
+  private readonly uploadTransport;
   constructor(reservation: Reservation, config: SwitchboardClientConfig);
-  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
+  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
@@ -595,7 +828,21 @@ declare class RemoteAttachmentStore implements IAttachmentReader {
    * AttachmentPending throw is the degraded-wire case.
    */
   stat(hash: AttachmentHash): Promise<AttachmentHeader>;
-  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
+  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
@@ -613,5 +860,5 @@ declare class NullAttachmentTransport implements IAttachmentTransport {
   push(): Promise<void>;
 }
 //#endregion
-export { ReserveAttachmentOptions as A, SizeMismatch as B, AttachmentMetadata as C, AttachmentUploadResult as D, AttachmentTransportConfig as E, AttachmentNotFound as F, AttachmentPending as I, HashMismatch as L, TransportResponse as M, UploadFirstReserveAttachmentOptions as N, HashFirstReserveAttachmentOptions as O, AttachmentAlreadyExists as P, InvalidAttachmentRef as R, AttachmentHeader as S, AttachmentStatus as T, UploadTooLarge as V, IAttachmentTransport as _, RemoteAttachmentUpload as a, IAttachmentUploadFactory as b, SwitchboardAttachmentTransport as c, createRef as d, parseRef as f, IAttachmentStore as g, IAttachmentService as h, RemoteAttachmentUploadFactory as i, TransportFetchResult as j, Reservation as k, SwitchboardTransportConfig as l, IAttachmentReader as m, createRemoteAttachmentService as n, RemoteReservationStore as o, AttachmentService as p, RemoteAttachmentStore as r, SwitchboardClientConfig as s, NullAttachmentTransport as t, ParsedRef as u, IAttachmentTransportFactory as v, AttachmentResponse as w, IReservationStore as x, IAttachmentUpload as y, ReservationNotFound as z };
-//# sourceMappingURL=null-attachment-transport-BBhQIk5A.d.ts.map
+export { AttachmentPending as $, IReservationStore as A, AttachmentStatus as B, IAttachmentReader as C, IAttachmentTransportFactory as D, IAttachmentTransport as E, AttachmentDownloadTargetOptions as F, HashFirstReserveAttachmentOptions as G, AttachmentTransportConfig as H, AttachmentHeader as I, TransportFetchResult as J, Reservation as K, AttachmentMetadata as L, AttachmentBackendKind as M, AttachmentDownloadOptions as N, IAttachmentUpload as O, AttachmentDownloadTarget as P, AttachmentNotFound as Q, AttachmentResponse as R, IAttachmentBackend as S, IAttachmentStore as T, AttachmentUploadResult as U, AttachmentTargetHeaders as V, AttachmentUploadTarget as W, UploadFirstReserveAttachmentOptions as X, TransportResponse as Y, AttachmentAlreadyExists as Z, createRef as _, RemoteAttachmentUpload as a, SizeMismatch as at, parseAttachmentDownloadTarget as b, XhrUploadTransportOptions as c, AttachmentUploadResponse as d, AttachmentTransferError as et, AttachmentUploadTransport as f, ParsedRef as g, SwitchboardTransportConfig as h, RemoteAttachmentUploadFactory as i, ReservationNotFound as it, AttachmentBackendHealth as j, IAttachmentUploadFactory as k, createXhrUploadTransport as l, SwitchboardAttachmentTransport as m, createRemoteAttachmentService as n, HashMismatch as nt, RemoteReservationStore as o, UploadTooLarge as ot, createFetchUploadTransport as p, ReserveAttachmentOptions as q, RemoteAttachmentStore as r, InvalidAttachmentRef as rt, SwitchboardClientConfig as s, NullAttachmentTransport as t, AttachmentTransferStage as tt, AttachmentUploadRequest as u, parseRef as v, IAttachmentService as w, parseAttachmentUploadTarget as x, AttachmentService as y, AttachmentSendOptions as z };
+//# sourceMappingURL=null-attachment-transport-CMrO_ZKA.d.ts.map

package/dist/null-attachment-transport-CMrO_ZKA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-attachment-transport-CMrO_ZKA.d.ts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/interfaces.ts","../src/targets.ts","../src/attachment-service.ts","../src/ref.ts","../src/switchboard/switchboard-attachment-transport.ts","../src/switchboard/upload-transport.ts","../src/switchboard/xhr-upload-transport.ts","../src/switchboard/remote-reservation-store.ts","../src/switchboard/remote-attachment-upload.ts","../src/switchboard/remote-attachment-upload-factory.ts","../src/switchboard/remote-attachment-store.ts","../src/switchboard/create-remote-attachment-service.ts","../src/null-attachment-transport.ts"],"mappings":"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"}