@powerhousedao/reactor-attachments 6.1.0 → 6.2.0-dev.1

package/dist/client.d.ts

@@ -0,0 +1,23 @@
+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/client.d.ts
+type PreprocessResult = {
+  ref: AttachmentRef;
+  hash: AttachmentHash;
+  sizeBytes: number;
+  options: HashFirstReserveAttachmentOptions;
+  data: ReadableStream<Uint8Array>;
+  stream: () => ReadableStream<Uint8Array>;
+};
+interface IAttachmentClient {
+  preprocess(file: Blob, opts?: {
+    fileName?: string;
+    mimeType?: string;
+  }): Promise<PreprocessResult>;
+  reserve(options: HashFirstReserveAttachmentOptions, send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>): Promise<AttachmentUploadResult>;
+}
+declare function createAttachmentClient(service: IAttachmentService): IAttachmentClient;
+//#endregion
+export { AttachmentAlreadyExists, type AttachmentHeader, type AttachmentMetadata, AttachmentNotFound, AttachmentPending, type AttachmentResponse, AttachmentService, type AttachmentStatus, type AttachmentTransportConfig, type AttachmentUploadResult, type HashFirstReserveAttachmentOptions, HashMismatch, IAttachmentClient, type IAttachmentReader, type IAttachmentService, type IAttachmentStore, type IAttachmentTransport, type IAttachmentTransportFactory, type IAttachmentUpload, type IAttachmentUploadFactory, type IReservationStore, InvalidAttachmentRef, NullAttachmentTransport, type ParsedRef, PreprocessResult, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, type Reservation, ReservationNotFound, type ReserveAttachmentOptions, SizeMismatch, SwitchboardAttachmentTransport, type SwitchboardClientConfig, type SwitchboardTransportConfig, type TransportFetchResult, type TransportResponse, type UploadFirstReserveAttachmentOptions, UploadTooLarge, createAttachmentClient, createRef, createRemoteAttachmentService, parseRef };
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"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"}

package/dist/client.js

@@ -0,0 +1,61 @@
+import { _ as SizeMismatch, a as RemoteAttachmentUpload, c as AttachmentService, d as AttachmentAlreadyExists, f as AttachmentNotFound, g as ReservationNotFound, h as InvalidAttachmentRef, i as RemoteAttachmentUploadFactory, l as createRef, m as HashMismatch, n as createRemoteAttachmentService, o as RemoteReservationStore, p as AttachmentPending, r as RemoteAttachmentStore, s as SwitchboardAttachmentTransport, t as NullAttachmentTransport, u as parseRef, v as UploadTooLarge } from "./null-attachment-transport-Drx03s02.js";
+//#region src/client.ts
+function streamFromBuffer(buf) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(buf);
+		controller.close();
+	} });
+}
+var AttachmentClientImpl = class {
+	constructor(service) {
+		this.service = service;
+	}
+	async preprocess(file, opts) {
+		const buf = await file.arrayBuffer();
+		const bytes = new Uint8Array(buf);
+		const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+		const hash = Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+		const ref = createRef(hash);
+		const sizeBytes = file.size;
+		const options = {
+			mimeType: opts?.mimeType ?? file.type,
+			fileName: opts?.fileName ?? (file instanceof File ? file.name : "attachment"),
+			clientHash: hash,
+			sizeBytes
+		};
+		const data = streamFromBuffer(bytes);
+		const stream = () => streamFromBuffer(bytes);
+		return {
+			ref,
+			hash,
+			sizeBytes,
+			options,
+			data,
+			stream
+		};
+	}
+	async reserve(options, send) {
+		let handle;
+		try {
+			handle = await this.service.reserve(options);
+		} catch (err) {
+			if (err instanceof AttachmentAlreadyExists) {
+				const header = await this.service.stat(err.ref);
+				return {
+					hash: err.hash,
+					ref: err.ref,
+					header
+				};
+			}
+			throw err;
+		}
+		return send(handle);
+	}
+};
+function createAttachmentClient(service) {
+	return new AttachmentClientImpl(service);
+}
+//#endregion
+export { AttachmentAlreadyExists, AttachmentNotFound, AttachmentPending, AttachmentService, HashMismatch, InvalidAttachmentRef, NullAttachmentTransport, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, ReservationNotFound, SizeMismatch, SwitchboardAttachmentTransport, UploadTooLarge, createAttachmentClient, createRef, createRemoteAttachmentService, parseRef };
+
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../src/client.ts"],"sourcesContent":["import type { AttachmentHash, AttachmentRef } from \"@powerhousedao/reactor\";\nimport { AttachmentAlreadyExists } from \"./errors.js\";\nimport type { IAttachmentService, IAttachmentUpload } from \"./interfaces.js\";\nimport { createRef } from \"./ref.js\";\nimport type {\n  AttachmentUploadResult,\n  HashFirstReserveAttachmentOptions,\n} from \"./types.js\";\n\nexport { AttachmentService } from \"./attachment-service.js\";\nexport {\n  AttachmentAlreadyExists,\n  AttachmentNotFound,\n  AttachmentPending,\n  HashMismatch,\n  InvalidAttachmentRef,\n  ReservationNotFound,\n  SizeMismatch,\n  UploadTooLarge,\n} from \"./errors.js\";\nexport type {\n  IAttachmentReader,\n  IAttachmentService,\n  IAttachmentStore,\n  IAttachmentTransport,\n  IAttachmentTransportFactory,\n  IAttachmentUpload,\n  IAttachmentUploadFactory,\n  IReservationStore,\n} from \"./interfaces.js\";\nexport { parseRef, createRef } from \"./ref.js\";\nexport type { ParsedRef } from \"./ref.js\";\nexport type {\n  AttachmentHeader,\n  AttachmentMetadata,\n  AttachmentResponse,\n  AttachmentStatus,\n  AttachmentTransportConfig,\n  AttachmentUploadResult,\n  HashFirstReserveAttachmentOptions,\n  UploadFirstReserveAttachmentOptions,\n  Reservation,\n  ReserveAttachmentOptions,\n  TransportFetchResult,\n  TransportResponse,\n} from \"./types.js\";\nexport {\n  SwitchboardAttachmentTransport,\n  type SwitchboardTransportConfig,\n  RemoteReservationStore,\n  type SwitchboardClientConfig,\n  RemoteAttachmentUpload,\n  RemoteAttachmentUploadFactory,\n  RemoteAttachmentStore,\n  createRemoteAttachmentService,\n} from \"./switchboard/index.js\";\nexport { NullAttachmentTransport } from \"./null-attachment-transport.js\";\n\nexport type PreprocessResult = {\n  ref: AttachmentRef;\n  hash: AttachmentHash;\n  sizeBytes: number;\n  options: HashFirstReserveAttachmentOptions;\n  data: ReadableStream<Uint8Array>;\n  stream: () => ReadableStream<Uint8Array>;\n};\n\nexport interface IAttachmentClient {\n  preprocess(\n    file: Blob,\n    opts?: { fileName?: string; mimeType?: string },\n  ): Promise<PreprocessResult>;\n  reserve(\n    options: HashFirstReserveAttachmentOptions,\n    send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>,\n  ): Promise<AttachmentUploadResult>;\n}\n\nfunction streamFromBuffer(buf: Uint8Array): ReadableStream<Uint8Array> {\n  return new ReadableStream({\n    start(controller) {\n      controller.enqueue(buf);\n      controller.close();\n    },\n  });\n}\n\nclass AttachmentClientImpl implements IAttachmentClient {\n  constructor(private readonly service: IAttachmentService) {}\n\n  async preprocess(\n    file: Blob,\n    opts?: { fileName?: string; mimeType?: string },\n  ): Promise<PreprocessResult> {\n    const buf = await file.arrayBuffer();\n    const bytes = new Uint8Array(buf);\n    const digest = await globalThis.crypto.subtle.digest(\"SHA-256\", bytes);\n    const hash = Array.from(new Uint8Array(digest))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\") as AttachmentHash;\n    const ref = createRef(hash);\n    const sizeBytes = file.size;\n    const mimeType = opts?.mimeType ?? file.type;\n    const fileName =\n      opts?.fileName ?? (file instanceof File ? file.name : \"attachment\");\n    const options: HashFirstReserveAttachmentOptions = {\n      mimeType,\n      fileName,\n      clientHash: hash,\n      sizeBytes,\n    };\n    const data = streamFromBuffer(bytes);\n    const stream = (): ReadableStream<Uint8Array> => streamFromBuffer(bytes);\n    return { ref, hash, sizeBytes, options, data, stream };\n  }\n\n  async reserve(\n    options: HashFirstReserveAttachmentOptions,\n    send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>,\n  ): Promise<AttachmentUploadResult> {\n    let handle: IAttachmentUpload;\n    try {\n      handle = await this.service.reserve(options);\n    } catch (err) {\n      if (err instanceof AttachmentAlreadyExists) {\n        const header = await this.service.stat(err.ref);\n        return { hash: err.hash, ref: err.ref, header };\n      }\n      throw err;\n    }\n    return send(handle);\n  }\n}\n\nexport function createAttachmentClient(\n  service: IAttachmentService,\n): IAttachmentClient {\n  return new AttachmentClientImpl(service);\n}\n"],"mappings":";;AA8EA,SAAS,iBAAiB,KAA6C;AACrE,QAAO,IAAI,eAAe,EACxB,MAAM,YAAY;AAChB,aAAW,QAAQ,IAAI;AACvB,aAAW,OAAO;IAErB,CAAC;;AAGJ,IAAM,uBAAN,MAAwD;CACtD,YAAY,SAA8C;AAA7B,OAAA,UAAA;;CAE7B,MAAM,WACJ,MACA,MAC2B;EAC3B,MAAM,MAAM,MAAM,KAAK,aAAa;EACpC,MAAM,QAAQ,IAAI,WAAW,IAAI;EACjC,MAAM,SAAS,MAAM,WAAW,OAAO,OAAO,OAAO,WAAW,MAAM;EACtE,MAAM,OAAO,MAAM,KAAK,IAAI,WAAW,OAAO,CAAC,CAC5C,KAAK,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAC3C,KAAK,GAAG;EACX,MAAM,MAAM,UAAU,KAAK;EAC3B,MAAM,YAAY,KAAK;EAIvB,MAAM,UAA6C;GACjD,UAJe,MAAM,YAAY,KAAK;GAKtC,UAHA,MAAM,aAAa,gBAAgB,OAAO,KAAK,OAAO;GAItD,YAAY;GACZ;GACD;EACD,MAAM,OAAO,iBAAiB,MAAM;EACpC,MAAM,eAA2C,iBAAiB,MAAM;AACxE,SAAO;GAAE;GAAK;GAAM;GAAW;GAAS;GAAM;GAAQ;;CAGxD,MAAM,QACJ,SACA,MACiC;EACjC,IAAI;AACJ,MAAI;AACF,YAAS,MAAM,KAAK,QAAQ,QAAQ,QAAQ;WACrC,KAAK;AACZ,OAAI,eAAe,yBAAyB;IAC1C,MAAM,SAAS,MAAM,KAAK,QAAQ,KAAK,IAAI,IAAI;AAC/C,WAAO;KAAE,MAAM,IAAI;KAAM,KAAK,IAAI;KAAK;KAAQ;;AAEjD,SAAM;;AAER,SAAO,KAAK,OAAO;;;AAIvB,SAAgB,uBACd,SACmB;AACnB,QAAO,IAAI,qBAAqB,QAAQ"}

package/dist/index.d.ts

@@ -1,352 +1,7 @@
+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 { Kysely } from "kysely";
-import { AttachmentHash, AttachmentRef, JwtHandler } from "@powerhousedao/reactor";
+import { AttachmentHash, AttachmentRef } 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);
-}
-//#endregion
-//#region src/types.d.ts
-/**
- * Status of attachment data in the local store.
- */
-type AttachmentStatus = "available" | "evicted";
-/**
- * Metadata about an attachment. Only exists after data is stored
- * (via upload.send for client uploads, or put for sync).
- */
-type AttachmentHeader = {
-  hash: AttachmentHash;
-  mimeType: string;
-  fileName: string;
-  sizeBytes: number;
-  extension: string | null;
-  status: AttachmentStatus;
-  source: "local" | "sync";
-  createdAtUtc: string;
-  lastAccessedAtUtc: string;
-};
-/**
- * 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;
-};
-/**
- * Options provided when reserving an attachment slot.
- */
-type ReserveAttachmentOptions = {
-  mimeType: string;
-  fileName: string;
-  extension?: string | null;
-};
-/**
- * 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>;
-};
-/**
- * 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.
- */
-type Reservation = {
-  reservationId: string;
-  mimeType: string;
-  fileName: string;
-  extension: string | null;
-  createdAtUtc: string;
-  expiresAtUtc: string;
-};
-//#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.
-   *
-   * The handle abstracts the transport -- the caller streams data
-   * through it without knowing whether bytes flow via HTTP, S3,
-   * or any other mechanism.
-   */
-  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
-  /**
-   * Get attachment metadata by ref.
-   *
-   * @throws AttachmentNotFound if the ref is unknown.
-   */
-  stat(ref: AttachmentRef): Promise<AttachmentHeader>;
-  /**
-   * Retrieve attachment data.
-   *
-   * Always succeeds for any known ref. The underlying store handles
-   * re-fetching evicted data from the transport transparently.
-   */
-  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;
-  /**
-   * 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.
-   *
-   * @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.
-   */
-  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 hash.
-   *
-   * @throws AttachmentNotFound if the hash is unknown (no metadata
-   *         record exists).
-   */
-  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.
-   */
-  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.
-   *
-   * The transport resolves the hash to a data source (server endpoint,
-   * S3 presigned URL, etc.) and returns a stream.
-   *
-   * @param hash - Content hash of the attachment
-   * @param signal - Abort signal for cancellation
-   * @returns The attachment data with metadata, or null if not available.
-   *          Returns TransportResponse (not AttachmentResponse) because
-   *          remote peers cannot populate local concerns like status/source.
-   */
-  fetch(hash: AttachmentHash, signal?: AbortSignal): Promise<TransportResponse | null>;
-  /**
-   * 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(reservationId: string, options: ReserveAttachmentOptions): 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>;
-}
-//#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/storage/kysely/types.d.ts
 interface AttachmentTable {
   hash: string;
@@ -368,6 +23,8 @@ interface AttachmentReservationTable {
   created_at_utc: string;
   expires_at_utc: string;
   deleted_at_utc: string | null;
+  client_hash: string | null;
+  size_bytes: number | null;
 }
 interface AttachmentDatabase {
   attachment: AttachmentTable;
@@ -387,12 +44,14 @@ declare class KyselyAttachmentStore implements IAttachmentStore {
   put(hash: AttachmentHash, metadata: AttachmentMetadata, data: ReadableStream<Uint8Array>): Promise<void>;
   evict(hash: AttachmentHash): Promise<void>;
   storageUsed(): Promise<number>;
+  private findPendingReservation;
   private acquireReader;
   private releaseReader;
   private hasActiveReaders;
 }
 //#endregion
 //#region src/storage/kysely/reservation-store.d.ts
+declare const DEFAULT_RESERVATION_TTL_MS: number;
 declare class KyselyReservationStore implements IReservationStore {
   private readonly db;
   private readonly ttlMs;
@@ -414,13 +73,15 @@ declare function runAttachmentMigrations(db: Kysely<any>, schema?: string): Prom
 //#endregion
 //#region src/direct/direct-attachment-upload.d.ts
 declare class DirectAttachmentUpload implements IAttachmentUpload {
-  private readonly options;
+  private readonly reservation;
   private readonly db;
   private readonly basePath;
   private readonly reservations;
   private readonly maxBytes?;
   readonly reservationId: string;
-  constructor(reservationId: string, options: ReserveAttachmentOptions, db: Kysely<AttachmentDatabase>, basePath: string, reservations: IReservationStore, maxBytes?: number | undefined);
+  readonly ref: AttachmentRef | null;
+  readonly expiresAtUtc: string;
+  constructor(reservation: Reservation, db: Kysely<AttachmentDatabase>, basePath: string, reservations: IReservationStore, maxBytes?: number | undefined);
   send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
 }
 //#endregion
@@ -431,84 +92,7 @@ declare class DirectAttachmentUploadFactory implements IAttachmentUploadFactory
   private readonly reservations;
   private readonly maxBytes?;
   constructor(db: Kysely<AttachmentDatabase>, basePath: string, reservations: IReservationStore, maxBytes?: number | undefined);
-  createUpload(reservationId: string, options: ReserveAttachmentOptions): IAttachmentUpload;
-}
-//#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<TransportResponse | null>;
-  announce(_hash: AttachmentHash): Promise<void>;
-  push(hash: AttachmentHash, remote: string, data: ReadableStream<Uint8Array>): Promise<void>;
-  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;
-  private readonly remoteUrl;
-  private readonly jwtHandler?;
-  private readonly fetchFn;
-  private readonly options;
-  constructor(reservationId: string, options: ReserveAttachmentOptions, 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(reservationId: string, options: ReserveAttachmentOptions): 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);
-  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 null, announce() and push() are no-ops.
- */
-declare class NullAttachmentTransport implements IAttachmentTransport {
-  fetch(): Promise<TransportResponse | null>;
-  announce(): Promise<void>;
-  push(): Promise<void>;
+  createUpload(reservation: Reservation): IAttachmentUpload;
 }
 //#endregion
 //#region src/attachment-builder.d.ts
@@ -516,7 +100,8 @@ type AttachmentBuildResult = {
   service: AttachmentService;
   store: KyselyAttachmentStore;
   reservations: KyselyReservationStore;
-  uploadFactory: IAttachmentUploadFactory;
+  uploadFactory: IAttachmentUploadFactory; /** Stops the reservation sweep timer, if one was configured via withReservationSweepMs(). */
+  destroy: () => void;
 };
 declare class AttachmentBuilder {
   private readonly db;
@@ -524,12 +109,22 @@ declare class AttachmentBuilder {
   private transport;
   private customUploadFactory?;
   private maxUploadBytes?;
+  private reservationSweepMs?;
   constructor(db: Kysely<any>, storagePath: string);
   withTransport(transport: IAttachmentTransport): this;
   withUploadFactory(factory: IAttachmentUploadFactory): this;
   withMaxUploadBytes(maxBytes: number): this;
+  /**
+   * Configure a recurring sweep that deletes expired reservations.
+   * The sweep calls reservations.deleteExpired() on the given interval.
+   * When set, the built result's destroy() clears the timer.
+   * Without this option no sweep runs -- deleteExpired() is never called
+   * automatically. Call withReservationSweepMs in production to prevent
+   * expired reservation rows from accumulating indefinitely.
+   */
+  withReservationSweepMs(intervalMs: number): this;
   build(): Promise<AttachmentBuildResult>;
 }
 //#endregion
-export { ATTACHMENT_SCHEMA, type AttachmentBuildResult, AttachmentBuilder, type AttachmentDatabase, type AttachmentHeader, type AttachmentMetadata, AttachmentNotFound, type AttachmentResponse, AttachmentService, type AttachmentStatus, type AttachmentTransportConfig, type AttachmentUploadResult, DirectAttachmentUpload, DirectAttachmentUploadFactory, type IAttachmentService, type IAttachmentStore, type IAttachmentTransport, type IAttachmentTransportFactory, type IAttachmentUpload, type IAttachmentUploadFactory, type IReservationStore, InvalidAttachmentRef, KyselyAttachmentStore, KyselyReservationStore, NullAttachmentTransport, type ParsedRef, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, type Reservation, ReservationNotFound, type ReserveAttachmentOptions, SwitchboardAttachmentTransport, type SwitchboardClientConfig, type SwitchboardTransportConfig, type TransportResponse, createRef, createRemoteAttachmentService, parseRef, runAttachmentMigrations };
+export { ATTACHMENT_SCHEMA, AttachmentAlreadyExists, type AttachmentBuildResult, AttachmentBuilder, type AttachmentDatabase, type AttachmentHeader, type AttachmentMetadata, AttachmentNotFound, AttachmentPending, type AttachmentResponse, AttachmentService, type AttachmentStatus, type AttachmentTransportConfig, type AttachmentUploadResult, DEFAULT_RESERVATION_TTL_MS, DirectAttachmentUpload, DirectAttachmentUploadFactory, type HashFirstReserveAttachmentOptions, HashMismatch, type IAttachmentReader, type IAttachmentService, type IAttachmentStore, type IAttachmentTransport, type IAttachmentTransportFactory, type IAttachmentUpload, type IAttachmentUploadFactory, type IReservationStore, InvalidAttachmentRef, KyselyAttachmentStore, KyselyReservationStore, NullAttachmentTransport, type ParsedRef, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, type Reservation, ReservationNotFound, type ReserveAttachmentOptions, SizeMismatch, SwitchboardAttachmentTransport, type SwitchboardClientConfig, type SwitchboardTransportConfig, type TransportFetchResult, type TransportResponse, type UploadFirstReserveAttachmentOptions, UploadTooLarge, createRef, createRemoteAttachmentService, parseRef, runAttachmentMigrations };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/interfaces.ts","../src/attachment-service.ts","../src/ref.ts","../src/storage/kysely/types.ts","../src/storage/kysely/attachment-store.ts","../src/storage/kysely/reservation-store.ts","../src/storage/migrations/migrator.ts","../src/direct/direct-attachment-upload.ts","../src/direct/direct-attachment-upload-factory.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/attachment-builder.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/storage/kysely/types.ts","../src/storage/kysely/attachment-store.ts","../src/storage/kysely/reservation-store.ts","../src/storage/migrations/migrator.ts","../src/direct/direct-attachment-upload.ts","../src/direct/direct-attachment-upload-factory.ts","../src/attachment-builder.ts"],"mappings":"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"}