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

package/dist/client.d.ts

@@ -1,618 +1,6 @@
-import { AttachmentHash, AttachmentRef, JwtHandler } from "@powerhousedao/reactor";
+import { A as ReserveAttachmentOptions, B as SizeMismatch, C as AttachmentMetadata, D as AttachmentUploadResult, E as AttachmentTransportConfig, F as AttachmentNotFound, I as AttachmentPending, L as HashMismatch, M as TransportResponse, N as UploadFirstReserveAttachmentOptions, O as HashFirstReserveAttachmentOptions, P as AttachmentAlreadyExists, R as InvalidAttachmentRef, S as AttachmentHeader, T as AttachmentStatus, V as UploadTooLarge, _ as IAttachmentTransport, a as RemoteAttachmentUpload, b as IAttachmentUploadFactory, c as SwitchboardAttachmentTransport, d as createRef, f as parseRef, g as IAttachmentStore, h as IAttachmentService, i as RemoteAttachmentUploadFactory, j as TransportFetchResult, k as Reservation, l as SwitchboardTransportConfig, m as IAttachmentReader, n as createRemoteAttachmentService, o as RemoteReservationStore, p as AttachmentService, r as RemoteAttachmentStore, s as SwitchboardClientConfig, t as NullAttachmentTransport, u as ParsedRef, v as IAttachmentTransportFactory, w as AttachmentResponse, x as IReservationStore, y as IAttachmentUpload, z as ReservationNotFound } from "./null-attachment-transport-BBhQIk5A.js";
+import { AttachmentHash, AttachmentRef } from "@powerhousedao/reactor";
 
-//#region src/types.d.ts
-/**
- * Status of attachment data in the local store.
- * 'pending' is a virtual status synthesized at query time from live,
- * hash-bearing reservations -- it never appears in the attachment table.
- */
-type AttachmentStatus = "available" | "evicted" | "pending";
-/**
- * Metadata about an attachment. For committed attachments (available/evicted),
- * expiresAtUtc is null. For pending attachments synthesized from a live
- * reservation, expiresAtUtc carries the reservation expiry so callers can
- * emit Retry-After or bound polling loops.
- */
-type AttachmentHeader = {
-  hash: AttachmentHash;
-  mimeType: string;
-  fileName: string;
-  sizeBytes: number;
-  extension: string | null;
-  status: AttachmentStatus;
-  source: "local" | "sync";
-  createdAtUtc: string;
-  lastAccessedAtUtc: string;
-  expiresAtUtc: string | null;
-};
-/**
- * Metadata provided alongside attachment data during sync, and returned
- * via the switchboard's `Attachment-Metadata` header on GET/HEAD.
- * `createdAtUtc` is the original upload time, propagated from the source
- * so that the receiving store preserves it instead of synthesizing the
- * fetch time. `lastAccessedAtUtc` is the source reactor's most recent
- * access time; it is optional because not every producer (e.g. a fresh
- * `put` from a transport) tracks access yet. Receiving stores that
- * persist locally (LRU concerns) reset it on every read regardless.
- *
- * Reliability note: `lastAccessedAtUtc` arriving over the wire is
- * best-effort. When the producer omits it, the consumer (see
- * `RemoteAttachmentStore` / `SwitchboardAttachmentTransport`) coalesces
- * with `createdAtUtc`, so the field can silently equal `createdAtUtc`
- * even on a server that has never been read. Do NOT use the wire value
- * for LRU eviction or staleness decisions on remote data; always read
- * the field from the local store after persistence, where the receiving
- * store is the authority.
- */
-type AttachmentMetadata = {
-  mimeType: string;
-  fileName: string;
-  sizeBytes: number;
-  extension: string | null;
-  createdAtUtc: string;
-  lastAccessedAtUtc?: string;
-};
-/**
- * Upload-first reservation. clientHash and sizeBytes are absent;
- * the ref is only known after send() completes.
- */
-type UploadFirstReserveAttachmentOptions = {
-  mimeType: string;
-  fileName: string;
-  extension?: string | null;
-  clientHash?: undefined;
-  sizeBytes?: undefined;
-};
-/**
- * Hash-first reservation. clientHash is present and sizeBytes is required.
- * The ref is known at reservation time; send() verifies the uploaded bytes
- * against the claimed hash and declared size. The explicit "?: undefined"
- * on UploadFirstReserveAttachmentOptions makes clientHash a narrowing discriminant:
- * checking options.clientHash !== undefined narrows sizeBytes to number.
- */
-type HashFirstReserveAttachmentOptions = {
-  mimeType: string;
-  fileName: string;
-  extension?: string | null;
-  /**
-   * Content hash claimed by the client (lowercase SHA-256 hex).
-   */
-  clientHash: AttachmentHash;
-  /**
-   * Declared size in bytes. Required when clientHash is present.
-   * Reported by stat() during the pending window and enforced on
-   * ingest: an upload whose actual byte count differs is rejected.
-   */
-  sizeBytes: number;
-};
-/**
- * Options provided when reserving an attachment slot.
- *
- * Use HashFirstReserveAttachmentOptions when clientHash is known up front;
- * the service then operates in hash-first mode: reserve() rejects if the
- * content is already available, and send() verifies the uploaded bytes.
- *
- * Use UploadFirstReserveAttachmentOptions (or omit clientHash) for the
- * upload-first flow where the ref is only known after send() completes.
- */
-type ReserveAttachmentOptions = UploadFirstReserveAttachmentOptions | HashFirstReserveAttachmentOptions;
-/**
- * Result of uploading attachment data through a handle.
- */
-type AttachmentUploadResult = {
-  hash: AttachmentHash;
-  ref: AttachmentRef;
-  header: AttachmentHeader;
-};
-/**
- * Response when retrieving attachment data from the local store.
- */
-type AttachmentResponse = {
-  header: AttachmentHeader;
-  body: ReadableStream<Uint8Array>;
-};
-/**
- * Response when fetching attachment data from a remote transport.
- * Lighter than AttachmentResponse -- a remote peer cannot meaningfully
- * populate status or source, which are local reactor concerns.
- * The store assigns those fields when it calls put() on receipt.
- */
-type TransportResponse = {
-  hash: AttachmentHash;
-  metadata: AttachmentMetadata;
-  body: ReadableStream<Uint8Array>;
-};
-/**
- * Three-way result from IAttachmentTransport.fetch(). Replaces
- * TransportResponse | null to make the pending state explicit, so
- * peers receiving a synced operation whose attachment is in-flight can
- * distinguish "retry later" from "permanently unknown".
- */
-type TransportFetchResult = {
-  kind: "data";
-  response: TransportResponse;
-} | {
-  kind: "pending";
-  hash: AttachmentHash;
-  expiresAtUtc: string;
-  retryAfterMs: number;
-} | {
-  kind: "not-found";
-};
-/**
- * Configuration for creating an attachment transport instance.
- */
-type AttachmentTransportConfig = {
-  type: string;
-  parameters: Record<string, unknown>;
-};
-/**
- * A reservation for an in-progress attachment upload.
- * Created by reserve(), deleted when upload.send() completes or
- * once expiresAtUtc has passed and a sweep runs.
- * clientHash and sizeBytes are set in hash-first mode and null in
- * upload-first mode.
- */
-type Reservation = {
-  reservationId: string;
-  mimeType: string;
-  fileName: string;
-  extension: string | null;
-  createdAtUtc: string;
-  expiresAtUtc: string;
-  clientHash: string | null;
-  sizeBytes: number | null;
-};
-//#endregion
-//#region src/interfaces.d.ts
-/**
- * Client-facing interface for uploading, querying, and retrieving attachments.
- * This is what applications (editors, Connect, CLI tools) interact with.
- */
-interface IAttachmentService {
-  /**
-   * Reserve a new attachment slot and return an upload handle.
-   *
-   * When options.clientHash is provided (hash-first mode):
-   * - @throws AttachmentAlreadyExists if data for that hash is currently
-   *   available. The error carries the canonical ref; the caller uses it
-   *   directly and uploads nothing (dedup fast path).
-   * - If the hash is evicted, the reservation is created: the client holds
-   *   the bytes and the upload restores them.
-   * - If the hash is pending (another in-flight reservation), the
-   *   reservation is created: concurrent reservations are deliberately
-   *   permitted (see design doc -- no uniqueness race).
-   * - The returned handle's ref field is set immediately to the computed ref.
-   *
-   * When options.clientHash is absent (upload-first mode):
-   * - No pre-check against the store.
-   * - The returned handle's ref field is null until send() completes.
-   */
-  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
-  /**
-   * Get attachment metadata by ref.
-   *
-   * @throws AttachmentNotFound if the ref is unknown.
-   * Returns an AttachmentHeader with status='pending' and expiresAtUtc set if
-   * the hash has an active reservation but no committed bytes. Callers must
-   * check header.status to distinguish pending from available.
-   */
-  stat(ref: AttachmentRef): Promise<AttachmentHeader>;
-  /**
-   * Retrieve attachment data.
-   *
-   * Always succeeds for any known, available ref. The underlying store
-   * handles re-fetching evicted data from the transport transparently.
-   *
-   * @throws AttachmentPending if the hash is reserved but bytes not yet
-   *         available. There is no store-level wait; polling across the
-   *         pending window is the caller's loop, bounded by the error's
-   *         expiresAtUtc. A wait inside get() would hold request handlers
-   *         open across multi-second windows and hide retry policy where
-   *         callers cannot tune it.
-   */
-  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
-}
-/**
- * Upload handle returned by reserve(). Encapsulates all transport-specific
- * concerns (URLs, credentials, streaming protocols) behind a single send() method.
- */
-interface IAttachmentUpload {
-  /**
-   * Unique identifier for this reservation.
-   */
-  reservationId: string;
-  /**
-   * The ref this upload will produce. Set immediately when the
-   * reservation carries a client hash (hash-first mode); null in the
-   * upload-first flow, where the ref is only known after send() completes.
-   */
-  ref: AttachmentRef | null;
-  /**
-   * Reservation TTL contract, from the server in remote mode.
-   * ISO 8601 UTC string indicating when the reservation expires.
-   * Clients use this to bound retry windows and populate the pending-upload queue.
-   */
-  readonly expiresAtUtc: string;
-  /**
-   * Stream attachment data through this handle.
-   *
-   * The handle manages the full upload lifecycle internally:
-   * writing bytes to the backing store, computing or verifying
-   * the content hash, creating the attachment record, and
-   * cleaning up the reservation.
-   *
-   * Dedup: if an attachment with the same content hash already
-   * exists, send() returns the existing ref. Content-addressed
-   * storage means identical uploads converge on the same hash.
-   *
-   * When the reservation carries a client hash, the handle verifies
-   * the received bytes against the claims:
-   * - @throws SizeMismatch if the byte count differs from the declared
-   *   sizeBytes. The handle may reject mid-stream as soon as the count
-   *   exceeds the declaration, without consuming the rest.
-   * - @throws HashMismatch if the server-computed hash differs from the
-   *   claimed hash. Nothing is committed; the reservation is retained
-   *   so the client can retry with the correct bytes.
-   *
-   * @returns The content hash, ref, and header for the uploaded attachment.
-   */
-  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
-}
-/**
- * Read-only subset of IAttachmentStore.
- *
- * Adapters that cannot safely support the local-only write/GC surface
- * (remote stores, forwarding caches) implement this narrow interface
- * instead of stub-rejecting unsupported methods. Consumers that only
- * need to query metadata or stream attachment bytes can take this type
- * to make their dependency requirements explicit.
- */
-interface IAttachmentReader {
-  /**
-   * Get attachment metadata without streaming body data.
-   * Does NOT update lastAccessedAtUtc -- this is a metadata check,
-   * not a data access.
-   *
-   * @throws AttachmentNotFound if the hash is unknown.
-   * Returns an AttachmentHeader with status='pending' and expiresAtUtc set if
-   * the hash has an active reservation but no committed bytes. Callers must
-   * check header.status to distinguish pending from available.
-   */
-  stat(hash: AttachmentHash): Promise<AttachmentHeader>;
-  /**
-   * Retrieve attachment header and data stream by hash.
-   * Updates lastAccessedAtUtc on access.
-   *
-   * If the data has been evicted, re-fetches it from the transport,
-   * restores it locally via put(), and returns the data. This makes
-   * eviction transparent to callers -- get() always succeeds for
-   * any known, available hash.
-   *
-   * @throws AttachmentNotFound if the hash is unknown (no metadata
-   *         record exists and no pending reservation).
-   * @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.
-   */
-  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
-}
-/**
- * Reactor-facing interface for managing local attachment data.
- * The IAttachmentTransport calls put when it receives data from a remote.
- * The store notifies its configured transport when new data arrives,
- * forming a bidirectional store-transport pair.
- */
-interface IAttachmentStore extends IAttachmentReader {
-  /**
-   * Check whether attachment data is available locally.
-   * Returns true if the bytes can be served from this reactor's store
-   * without a transport round-trip. Does not trigger a remote fetch.
-   * Returns false for pending and evicted hashes.
-   */
-  has(hash: AttachmentHash): Promise<boolean>;
-  /**
-   * Store attachment data received from a remote (during sync or re-fetch).
-   * Called by IAttachmentTransport implementations during sync, and
-   * internally by get() when restoring evicted data.
-   *
-   * Behavior depends on existing state:
-   * - No existing row: INSERT with source='sync', status='available'.
-   * - Existing row with status='evicted': restore data, set status
-   *   to 'available'.
-   * - Existing row with status='available': no-op (dedup).
-   */
-  put(hash: AttachmentHash, metadata: AttachmentMetadata, data: ReadableStream<Uint8Array>): Promise<void>;
-  /**
-   * Evict attachment data to reclaim storage.
-   *
-   * Removes the local bytes and sets status to 'evicted'. The
-   * metadata record is retained so the hash is still known. If the
-   * data is needed again, the service fetches it via the transport.
-   *
-   * Eviction must not destroy data while a get() stream is in
-   * flight. Implementations must skip hashes with active readers
-   * (e.g. via a refcount or lease) and revisit them on the next
-   * GC pass.
-   *
-   * On immutable backends, this unpins/stops serving rather
-   * than deleting.
-   */
-  evict(hash: AttachmentHash): Promise<void>;
-  /**
-   * Get the total storage used by locally available attachment data.
-   * Used by the GC policy to decide when to evict.
-   */
-  storageUsed(): Promise<number>;
-}
-/**
- * Transport for moving attachment data between reactors.
- *
- * Forms a bidirectional pair with IAttachmentStore. The store calls
- * announce/push when new data arrives locally. The transport calls
- * store.put() when data arrives from a remote.
- */
-interface IAttachmentTransport {
-  /**
-   * Fetch attachment data by hash from a remote source.
-   *
-   * Returns a three-way discriminated union so callers can distinguish
-   * "data available", "upload in flight -- retry after expiry", and
-   * "not found -- possibly permanently". Conflating the last two would
-   * cause callers to apply long backoff to transient pending state,
-   * or to retry indefinitely on a permanently missing hash.
-   *
-   * @param hash - Content hash of the attachment
-   * @param signal - Abort signal for cancellation
-   */
-  fetch(hash: AttachmentHash, signal?: AbortSignal): Promise<TransportFetchResult>;
-  /**
-   * Announce that this reactor has attachment data available.
-   *
-   * For server-centric transports, this may be a no-op (the server
-   * already has the data after upload).
-   */
-  announce(hash: AttachmentHash): Promise<void>;
-  /**
-   * Push attachment data to a specific remote.
-   *
-   * Used for eager replication strategies where the source reactor
-   * pushes data to known peers rather than waiting for pull requests.
-   *
-   * @param hash - Content hash of the attachment
-   * @param remote - Target remote identifier
-   * @param data - The attachment data stream
-   */
-  push(hash: AttachmentHash, remote: string, data: ReadableStream<Uint8Array>): Promise<void>;
-}
-/**
- * Factory for creating attachment transport instances.
- * Mirrors IChannelFactory for operation sync.
- */
-interface IAttachmentTransportFactory {
-  instance(config: AttachmentTransportConfig): IAttachmentTransport;
-}
-/**
- * Store for managing attachment reservations.
- * Reservations are transient records tracking in-progress uploads.
- */
-interface IReservationStore {
-  create(options: ReserveAttachmentOptions): Promise<Reservation>;
-  get(reservationId: string): Promise<Reservation>;
-  delete(reservationId: string): Promise<void>;
-  /**
-   * Delete reservations whose expires_at_utc is at or before `now`.
-   * Returns the number of rows deleted.
-   *
-   * Reservations are not auto-swept; consumers should call this on a
-   * cron / interval to clean up rows left behind by aborted uploads.
-   */
-  deleteExpired(now?: Date): Promise<number>;
-}
-/**
- * Factory for creating transport-specific upload handles.
- * The service calls this during reserve() to create a handle
- * that knows how to stream bytes to the appropriate backend.
- */
-interface IAttachmentUploadFactory {
-  createUpload(reservation: Reservation): IAttachmentUpload;
-}
-//#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);
-  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
-  stat(ref: AttachmentRef): Promise<AttachmentHeader>;
-  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
-  private reserveHashFirst;
-}
-//#endregion
-//#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);
-}
-/**
- * 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).
- */
-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
-//#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, 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/remote-reservation-store.d.ts
-type SwitchboardClientConfig = {
-  remoteUrl: string;
-  jwtHandler?: JwtHandler;
-  fetchFn?: typeof fetch;
-};
-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;
-  private readonly remoteUrl;
-  private readonly jwtHandler?;
-  private readonly fetchFn;
-  constructor(reservation: Reservation, config: SwitchboardClientConfig);
-  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
-}
-//#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): Promise<AttachmentHeader>;
-  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
-  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
 //#region src/client.d.ts
 type PreprocessResult = {
   ref: AttachmentRef;

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","names":[],"sources":["../src/types.ts","../src/interfaces.ts","../src/attachment-service.ts","../src/errors.ts","../src/ref.ts","../src/switchboard/switchboard-attachment-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","../src/client.ts"],"mappings":"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"}
+{"version":3,"file":"client.d.ts","names":[],"sources":["../src/client.ts"],"mappings":";;;;KA0DY,gBAAA;EACV,GAAA,EAAK,aAAA;EACL,IAAA,EAAM,cAAA;EACN,SAAA;EACA,OAAA,EAAS,iCAAA;EACT,IAAA,EAAM,cAAA,CAAe,UAAA;EACrB,MAAA,QAAc,cAAA,CAAe,UAAA;AAAA;AAAA,UAGd,iBAAA;EACf,UAAA,CACE,IAAA,EAAM,IAAA,EACN,IAAA;IAAS,QAAA;IAAmB,QAAA;EAAA,IAC3B,OAAA,CAAQ,gBAAA;EACX,OAAA,CACE,OAAA,EAAS,iCAAA,EACT,IAAA,GAAO,MAAA,EAAQ,iBAAA,KAAsB,OAAA,CAAQ,sBAAA,IAC5C,OAAA,CAAQ,sBAAA;AAAA;AAAA,iBA2DG,sBAAA,CACd,OAAA,EAAS,kBAAA,GACR,iBAAA"}