@visulima/storage 1.0.0-alpha.8 → 1.0.0

package/dist/storage/pocketbase/index.d.ts

@@ -0,0 +1,172 @@
+import { F as File, L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, d as FileInit, O as OperationOptions, e as FilePart, f as FileQuery, g as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-D9PBfkn6.js";
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare class PocketBaseFile extends File {
+  bucket?: string;
+  path?: string;
+  publicUrl?: string;
+}
+declare class PocketBaseMetaStorage extends LocalMetaStorage<PocketBaseFile> {
+  constructor(config?: LocalMetaStorageOptions);
+}
+/**
+* Minimal structural type for the PocketBase client used by the adapter.
+* Declared locally so the package does not require `pocketbase` to be
+* installed for type-checking (it is an optional peer dependency).
+*/
+interface PocketBaseClientLike {
+  authStore: {
+    isValid: boolean;
+    save: (token: string, model: unknown) => void;
+  };
+  collection: (name: string) => {
+    authWithPassword: (email: string, password: string) => Promise<unknown>;
+    create: (body: unknown) => Promise<PocketBaseRecord>;
+    delete: (id: string) => Promise<boolean>;
+    getFirstListItem: (filter: string) => Promise<PocketBaseRecord>;
+    getList: (page: number, perPage: number) => Promise<{
+      items: PocketBaseRecord[];
+    }>;
+    update: (id: string, body: unknown) => Promise<PocketBaseRecord>;
+  };
+  files: {
+    getToken: () => Promise<string>;
+    getURL?: (record: PocketBaseRecord, filename: string, options?: {
+      token?: string;
+    }) => string;
+    getUrl?: (record: PocketBaseRecord, filename: string, options?: {
+      token?: string;
+    }) => string;
+  };
+  filter: (raw: string, parameters?: Record<string, unknown>) => string;
+}
+/**
+* Minimal structural type for a PocketBase record. The file field holds the
+* stored filename string; the key field holds the logical object key.
+*/
+interface PocketBaseRecord {
+  [field: string]: unknown;
+  id: string;
+}
+interface PocketBaseStorageOptions extends BaseStorageOptions {
+  /**
+  * Superuser email used for lazy authentication. Ignored when `client` or
+  * `authToken` is supplied. Falls back to `POCKETBASE_ADMIN_EMAIL`.
+  */
+  adminEmail?: string;
+  /**
+  * Superuser password used for lazy authentication. Ignored when `client`
+  * or `authToken` is supplied. Falls back to `POCKETBASE_ADMIN_PASSWORD`.
+  */
+  adminPassword?: string;
+  /**
+  * Pre-saved auth token stored on the client's `authStore`. Ignored when
+  * `client` is supplied. Falls back to `POCKETBASE_AUTH_TOKEN`.
+  */
+  authToken?: string;
+  /**
+  * Pre-built `PocketBase` instance. Mutually exclusive with `url`. When
+  * supplied it is used as-is and no authentication is performed.
+  */
+  client?: PocketBaseClientLike;
+  /**
+  * Collection name backing the object store. Each record holds exactly one
+  * file. Required — the adapter does not create the collection.
+  */
+  collection: string;
+  /**
+  * Default expiry, in seconds, for `getReadUrl`. PocketBase file tokens are
+  * short-lived; a fresh token is requested per call. Defaults to 3600.
+  */
+  defaultUrlExpiresIn?: number;
+  /**
+  * File field on the collection holding the stored file. Defaults to `file`.
+  */
+  fileField?: string;
+  /**
+  * Text field on the collection holding the logical object key. Defaults
+  * to `key`.
+  */
+  keyField?: string;
+  /**
+  * Configure metafiles storage. Used for TUS-style resumable upload
+  * bookkeeping. Defaults to {@link LocalMetaStorage} under the OS tmp
+  * directory.
+  */
+  metaStorageConfig?: LocalMetaStorageOptions;
+  /**
+  * Public base URL for served files. When set, `getReadUrl` returns
+  * `${publicBaseUrl}/${key}` without requesting a file token.
+  */
+  publicBaseUrl?: string;
+  /**
+  * PocketBase instance URL (e.g. `https://pb.example.com`). Ignored when
+  * `client` is supplied. Falls back to `POCKETBASE_URL`.
+  */
+  url?: string;
+}
+/**
+* PocketBase storage backend.
+*
+* PocketBase is record-based: a collection where each record holds exactly
+* one file. This adapter maps the object store onto such a collection,
+* keying records by a text field (`keyField`) and storing bytes in a file
+* field (`fileField`). Uploads are single-shot — the part stream is buffered
+* and sent as one multipart request.
+* @example
+* ```ts
+* import { PocketBaseStorage } from "@visulima/storage/provider/pocketbase";
+*
+* const storage = new PocketBaseStorage({
+*   url: process.env.POCKETBASE_URL,
+*   adminEmail: process.env.POCKETBASE_ADMIN_EMAIL,
+*   adminPassword: process.env.POCKETBASE_ADMIN_PASSWORD,
+*   collection: "uploads",
+* });
+* ```
+* @remarks
+* - ⚠️ Per-operation `signal`/`timeout` are best-effort: the underlying SDK does not support request cancellation, so an in-flight call may complete server-side even after abort. `retries` is honored.
+*/
+declare class PocketBaseStorage extends BaseStorage<PocketBaseFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  protected meta: MetaStorage<PocketBaseFile>;
+  private readonly client;
+  private readonly collectionName;
+  private readonly defaultUrlExpiresIn;
+  private readonly fileField;
+  private readonly keyField;
+  private readonly publicBaseUrl?;
+  private ensureAuth;
+  constructor(config: PocketBaseStorageOptions);
+  override get raw(): PocketBaseClientLike;
+  create(config: FileInit, _options?: OperationOptions): Promise<PocketBaseFile>;
+  write(part: FilePart | FileQuery | PocketBaseFile, options?: OperationOptions): Promise<PocketBaseFile>;
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<PocketBaseFile>;
+  override exists({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<boolean>;
+  get({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<PocketBaseFile>;
+  move(name: string, destination: string, options?: OperationOptions): Promise<PocketBaseFile>;
+  override list(limit?: number, options?: OperationOptions): Promise<PocketBaseFile[]>;
+  override getReadUrl(key: string, options?: {
+    expiresIn?: number;
+    responseContentDisposition?: string;
+    responseContentType?: string;
+  }): Promise<string>;
+  private findRecord;
+  private putRecord;
+  private getMetaSafe;
+  private internalOnComplete;
+}
+export { PocketBaseFile, PocketBaseMetaStorage, PocketBaseStorage, type PocketBaseStorageOptions };

package/dist/storage/pocketbase/index.js

@@ -0,0 +1 @@
+import{default as t}from"../../packem_shared/PocketBaseFile-DpJpxl3e.js";import{default as r}from"../../packem_shared/PocketBaseMetaStorage-CpvDRnSu.js";import{default as s}from"../../packem_shared/PocketBaseStorage-BPil-koe.js";export{t as PocketBaseFile,r as PocketBaseMetaStorage,s as PocketBaseStorage};

package/dist/storage/sftp/index.d.ts

@@ -0,0 +1,92 @@
+import { F as File, L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, d as FileInit, O as OperationOptions, e as FilePart, f as FileQuery, g as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-D9PBfkn6.js";
+import { ConnectOptions } from 'ssh2-sftp-client';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare class SftpFile extends File {
+  path?: string;
+}
+declare class SftpMetaStorage extends LocalMetaStorage<SftpFile> {
+  constructor(config?: LocalMetaStorageOptions);
+}
+interface SftpStorageOptions extends BaseStorageOptions {
+  /**
+  * ssh2-sftp-client connection options (`host`, `port`, `username`,
+  * `password`, `privateKey`, `passphrase`, …). A fresh connection is
+  * opened and closed around every storage operation — the underlying
+  * SSH channel is not safe for concurrent use, so the adapter does not
+  * pool connections.
+  */
+  connection: ConnectOptions;
+  /**
+  * Configure metafile storage. SFTP has no native arbitrary-metadata
+  * field, so upload metadata is stored as sidecar JSON on the local
+  * disk (defaults to the OS temp directory).
+  */
+  metaStorageConfig?: LocalMetaStorageOptions;
+  /**
+  * Logical "bucket root" — virtual keys live under this remote directory.
+  * The adapter creates intermediate directories on write. Leading/trailing
+  * slashes are normalized. Defaults to the connection's home directory.
+  */
+  rootFolderPath?: string;
+}
+/**
+* SFTP storage backend (built on `ssh2-sftp-client`).
+*
+* Routes virtual keys onto remote paths under `rootFolderPath`. SFTP has no
+* native metadata store, so upload metadata is kept as sidecar JSON on the
+* local disk (see `SftpMetaStorage`).
+*
+* A fresh SFTP connection is opened and closed around every operation: the
+* underlying SSH channel is not safe for concurrent use, so the adapter does
+* not pool connections.
+*
+* **Limitations**:
+* - `write()` buffers the full part in memory before uploading (no remote append), so chunked uploads overwrite rather than append.
+* - `getReadUrl` / `getUploadUrl` are not supported — SFTP has no signed-URL concept.
+*/
+declare class SftpStorage extends BaseStorage<SftpFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  override readonly supportsRange: boolean;
+  protected meta: MetaStorage<SftpFile>;
+  private readonly connection;
+  private readonly rootFolderPath;
+  constructor(config: SftpStorageOptions);
+  create(config: FileInit, _options?: OperationOptions): Promise<SftpFile>;
+  write(part: FilePart | FileQuery | SftpFile, options?: OperationOptions): Promise<SftpFile>;
+  get({
+    id
+  }: FileQuery, options?: OperationOptions & {
+    range?: {
+      end?: number;
+      start: number;
+    };
+  }): Promise<FileReturn>;
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<SftpFile>;
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<SftpFile>;
+  move(name: string, destination: string, options?: OperationOptions): Promise<SftpFile>;
+  override list(_limit?: number, options?: OperationOptions): Promise<SftpFile[]>;
+  override exists({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<boolean>;
+  private walkList;
+  /**
+  * Opens a fresh single-session SFTP connection for one operation.
+  * `ssh2-sftp-client` has no `AbortSignal` hook, so cancellation is
+  * best-effort: an abort ends the SSH channel via `client.end()`, which
+  * rejects any in-flight transfer. The rejection is normalized to an
+  * `AbortError`.
+  */
+  private run;
+  private keyToPath;
+  private pathToKey;
+}
+export { SftpFile, SftpMetaStorage, SftpStorage, type SftpStorageOptions };

package/dist/storage/sftp/index.js

@@ -0,0 +1 @@
+import{default as a}from"../../packem_shared/SftpFile-ClWDYnt2.js";import{default as o}from"../../packem_shared/SftpMetaStorage-DFwhEI9C.js";import{default as p}from"../../packem_shared/SftpStorage-BVbMtS2b.js";export{a as SftpFile,o as SftpMetaStorage,p as SftpStorage};

package/dist/storage/sharepoint/index.d.ts

@@ -0,0 +1,180 @@
+import { O as OneDriveFile, a as OneDriveStorageOptions } from "../../packem_shared/types.d-Bon9GVVe.js";
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-D9PBfkn6.js";
+import { L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, d as FileInit, O as OperationOptions, e as FilePart, f as FileQuery, g as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-CEM1upWM.js";
+import { Readable } from 'node:stream';
+import { Client } from '@microsoft/microsoft-graph-client';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare class SharePointFile extends OneDriveFile {}
+declare class SharePointMetaStorage extends LocalMetaStorage<SharePointFile> {
+  constructor(config?: LocalMetaStorageOptions);
+}
+/**
+* Options for the SharePoint storage backend.
+*
+* A SharePoint document library is a Microsoft Graph drive. This adapter
+* resolves a site + document library down to a `driveId` and then delegates
+* every storage operation to an internal {@link OneDriveStorage}.
+*
+* **Site targeting** (resolved in this order):
+* 1. `driveId` (env `SHAREPOINT_DRIVE_ID`) — short-circuits site resolution.
+* 2. `siteId` (env `SHAREPOINT_SITE_ID`).
+* 3. `siteUrl` (env `SHAREPOINT_SITE_URL`) — parsed into hostname + path.
+* 4. `hostname` (env `SHAREPOINT_HOSTNAME`) + `sitePath`.
+*
+* Once the site is known, `documentLibrary` selects a specific drive from the
+* site's drive list by display name; otherwise the site's default drive is
+* used.
+*
+* **Auth** mirrors {@link OneDriveStorageOptions}. Env fallbacks resolve the
+* `SHAREPOINT_*` variables first and then the matching `ONEDRIVE_*`
+* variables.
+*/
+interface SharePointStorageOptions extends BaseStorageOptions {
+  /**
+  * Static or dynamic access token. Pass a string for a one-shot token, or
+  * a function returning a fresh token on each call.
+  */
+  accessToken?: string | (() => string | Promise<string>);
+  /**
+  * Pre-built `@microsoft/microsoft-graph-client` `Client`. Escape hatch for
+  * callers that wire up their own `AuthenticationProvider` and also used to
+  * resolve the site/library when site targeting is required.
+  */
+  client?: Client;
+  /**
+  * Client-credentials auth — for app-only / daemon scenarios. Same shape as
+  * {@link OneDriveStorageOptions.clientCredentials}.
+  */
+  clientCredentials?: OneDriveStorageOptions["clientCredentials"];
+  /**
+  * Timeout, in milliseconds, for polling the async-copy monitor URL.
+  * Defaults to 60_000 (60s).
+  */
+  copyTimeoutMs?: number;
+  /**
+  * Display name of the document library (drive) to target within the
+  * resolved site. When omitted, the site's default drive is used.
+  */
+  documentLibrary?: string;
+  /**
+  * Target drive (document library) by ID. Short-circuits site resolution.
+  * Env fallback: `SHAREPOINT_DRIVE_ID`.
+  */
+  driveId?: string;
+  /**
+  * SharePoint host name (e.g. `contoso.sharepoint.com`). Combined with
+  * `sitePath` to resolve the site. Env fallback: `SHAREPOINT_HOSTNAME`.
+  */
+  hostname?: string;
+  /**
+  * Configure metafiles storage. Defaults to local tmp directory.
+  */
+  metaStorageConfig?: LocalMetaStorageOptions;
+  /**
+  * OAuth2 refresh-token auth — for delegated user scenarios. Same shape as
+  * {@link OneDriveStorageOptions.oauth}.
+  */
+  oauth?: OneDriveStorageOptions["oauth"];
+  /**
+  * When `true`, `getReadUrl` creates an anonymous shared link with `view`
+  * permission. Otherwise it returns the short-lived pre-authenticated
+  * `@microsoft.graph.downloadUrl` from the item metadata.
+  */
+  publicByDefault?: boolean;
+  /**
+  * Logical "bucket root" — virtual keys live under this folder path within
+  * the target drive. Must already exist. Defaults to drive root.
+  */
+  rootFolderPath?: string;
+  /**
+  * Target a SharePoint site by its Graph site ID. Env fallback:
+  * `SHAREPOINT_SITE_ID`.
+  */
+  siteId?: string;
+  /**
+  * Server-relative site path (e.g. `/sites/Marketing`). Combined with
+  * `hostname` to resolve the site.
+  */
+  sitePath?: string;
+  /**
+  * Full SharePoint site URL (e.g.
+  * `https://contoso.sharepoint.com/sites/Marketing`). Parsed into a host
+  * name + server-relative path. Env fallback: `SHAREPOINT_SITE_URL`.
+  */
+  siteUrl?: string;
+}
+/**
+* SharePoint document-library storage backend (Microsoft Graph).
+*
+* A SharePoint document library is a Microsoft Graph drive. This adapter
+* resolves a site + document library to a `driveId` and then delegates every
+* storage operation to an internal {@link OneDriveStorage}. No Graph upload
+* logic is reimplemented here.
+*
+* Site resolution is lazy: the Graph client is built eagerly (so auth errors
+* surface at construction) but the site/library → `driveId` lookup runs on the
+* first storage operation, because resolution is async and constructors cannot
+* be.
+* @example
+* ```ts
+* import { SharePointStorage } from "@visulima/storage/provider/sharepoint";
+*
+* const storage = new SharePointStorage({
+*   siteUrl: "https://contoso.sharepoint.com/sites/Marketing",
+*   documentLibrary: "Documents",
+*   clientCredentials: { tenantId, clientId, clientSecret },
+* });
+* ```
+* @remarks
+* - ⚠️ Per-operation `signal`/`timeout` are best-effort: the underlying SDK does not support request cancellation, so an in-flight call may complete server-side even after abort. `retries` is honored.
+*/
+declare class SharePointStorage extends BaseStorage<SharePointFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  protected meta: MetaStorage<SharePointFile>;
+  private readonly client;
+  private inner?;
+  private innerPromise?;
+  private readonly oneDriveAuth;
+  private readonly resolvedConfig;
+  constructor(config: SharePointStorageOptions);
+  override get raw(): Client;
+  create(config: FileInit, options?: OperationOptions): Promise<SharePointFile>;
+  write(part: FilePart | FileQuery | SharePointFile, options?: OperationOptions): Promise<SharePointFile>;
+  delete(query: FileQuery, options?: OperationOptions): Promise<SharePointFile>;
+  get(query: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<SharePointFile>;
+  move(name: string, destination: string, options?: OperationOptions): Promise<SharePointFile>;
+  override exists(query: FileQuery, _options?: OperationOptions): Promise<boolean>;
+  override list(limit?: number, options?: OperationOptions): Promise<SharePointFile[]>;
+  override update(query: FileQuery, metadata: Partial<SharePointFile>, _options?: OperationOptions): Promise<SharePointFile>;
+  override getStream(query: FileQuery, _options?: OperationOptions): Promise<{
+    headers?: Record<string, string>;
+    size?: number;
+    stream: Readable;
+  }>;
+  override getReadUrl(key: string, options?: {
+    expiresIn?: number;
+    responseContentDisposition?: string;
+    responseContentType?: string;
+  }): Promise<string>;
+  override getUploadUrl(key: string, options?: {
+    contentLength?: number;
+    contentType?: string;
+    expiresIn?: number;
+  }): Promise<string>;
+  /**
+  * Resolve the target document library to a `driveId` and construct the
+  * internal {@link OneDriveStorage}. Memoized so resolution runs at most
+  * once.
+  */
+  private getInner;
+  private buildInner;
+  private resolveDriveId;
+  private resolveSiteId;
+}
+export { SharePointFile, SharePointMetaStorage, SharePointStorage, type SharePointStorageOptions };

package/dist/storage/sharepoint/index.js

@@ -0,0 +1 @@
+import{default as t}from"../../packem_shared/SharePointFile-Blz9FS4h.js";import{default as r}from"../../packem_shared/SharePointMetaStorage-DFwhEI9C.js";import{default as S}from"../../packem_shared/SharePointStorage-DWjvR5oZ.js";export{t as SharePointFile,r as SharePointMetaStorage,S as SharePointStorage};

package/dist/storage/supabase/index.d.ts

@@ -0,0 +1,115 @@
+import { F as File, L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, d as FileInit, O as OperationOptions, e as FilePart, f as FileQuery, g as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-D9PBfkn6.js";
+import { StorageClient } from '@supabase/storage-js';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare class SupabaseFile extends File {
+  bucket?: string;
+  path?: string;
+  publicUrl?: string;
+}
+declare class SupabaseMetaStorage extends LocalMetaStorage<SupabaseFile> {
+  constructor(config?: LocalMetaStorageOptions);
+}
+interface SupabaseStorageOptions extends BaseStorageOptions {
+  /**
+  * Storage bucket name. Created in the Supabase dashboard. The adapter
+  * does not create or delete buckets.
+  */
+  bucket: string;
+  /**
+  * Pre-built `StorageClient` from `@supabase/storage-js`. Mutually
+  * exclusive with `serviceKey` + `url`. Use this when you want to share
+  * a `StorageClient` instance, customize `fetch`, or pass extra headers.
+  */
+  client?: StorageClient;
+  /**
+  * Default expiry, in seconds, for `getReadUrl`. Capped at 1 week (Supabase
+  * maximum). Defaults to 3600 (1 hour).
+  */
+  defaultUrlExpiresIn?: number;
+  /**
+  * Override the global `fetch` (e.g. for tests, custom timeouts, retries).
+  * Ignored when `client` is supplied.
+  */
+  fetch?: typeof globalThis.fetch;
+  /**
+  * Configure metafiles storage. Used for TUS-style resumable upload
+  * bookkeeping. Defaults to {@link LocalMetaStorage} under the OS tmp
+  * directory.
+  */
+  metaStorageConfig?: LocalMetaStorageOptions;
+  /**
+  * Supabase service-role key (or anon key with appropriate RLS).
+  * Ignored when `client` is supplied. Falls back to `SUPABASE_SERVICE_ROLE_KEY`
+  * or `SUPABASE_KEY`.
+  */
+  serviceKey?: string;
+  /**
+  * Supabase project URL (e.g. `https://abc.supabase.co`). The adapter
+  * appends `/storage/v1` automatically. Ignored when `client` is supplied.
+  * Falls back to `SUPABASE_URL`.
+  */
+  url?: string;
+}
+/**
+* Supabase Storage backend.
+*
+* Single-shot uploads only — Supabase Storage exposes a TUS endpoint but
+* the JS SDK's `upload()` is HTTP `POST` with the full body. This adapter
+* buffers the part stream and uploads in one request. Use `signedUploadUrl`
+* for direct-from-client large transfers.
+* @example
+* ```ts
+* import { SupabaseStorage } from "@visulima/storage/provider/supabase";
+*
+* const storage = new SupabaseStorage({
+*   url: process.env.SUPABASE_URL,
+*   serviceKey: process.env.SUPABASE_SERVICE_ROLE_KEY,
+*   bucket: "avatars",
+* });
+* ```
+* @remarks
+* - ⚠️ Per-operation `signal`/`timeout` are best-effort: the underlying SDK does not support request cancellation, so an in-flight call may complete server-side even after abort. `retries` is honored.
+*/
+declare class SupabaseStorage extends BaseStorage<SupabaseFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  protected meta: MetaStorage<SupabaseFile>;
+  private readonly bucket;
+  private readonly defaultUrlExpiresIn;
+  private readonly storageClient;
+  constructor(config: SupabaseStorageOptions);
+  override get raw(): StorageClient;
+  create(config: FileInit, _options?: OperationOptions): Promise<SupabaseFile>;
+  write(part: FilePart | FileQuery | SupabaseFile, options?: OperationOptions): Promise<SupabaseFile>;
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<SupabaseFile>;
+  override exists({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<boolean>;
+  get({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<SupabaseFile>;
+  move(name: string, destination: string, options?: OperationOptions): Promise<SupabaseFile>;
+  override list(limit?: number, options?: OperationOptions): Promise<SupabaseFile[]>;
+  override getReadUrl(key: string, options?: {
+    expiresIn?: number;
+    responseContentDisposition?: string;
+    responseContentType?: string;
+  }): Promise<string>;
+  override getUploadUrl(key: string, options?: {
+    contentLength?: number;
+    contentType?: string;
+    expiresIn?: number;
+  }): Promise<string>;
+  private getMetaSafe;
+  private internalOnComplete;
+}
+export { SupabaseFile, SupabaseMetaStorage, SupabaseStorage, type SupabaseStorageOptions };

package/dist/storage/supabase/index.js

@@ -0,0 +1 @@
+import{default as t}from"../../packem_shared/SupabaseFile-Bo5B-vM1.js";import{default as r}from"../../packem_shared/SupabaseMetaStorage-DqkgoE46.js";import{default as p}from"../../packem_shared/SupabaseStorage-BiKmYKb6.js";export{t as SupabaseFile,r as SupabaseMetaStorage,p as SupabaseStorage};

package/dist/storage/uploadthing/index.d.ts

@@ -0,0 +1,95 @@
+import { UTApi } from 'uploadthing/server';
+import { L as LocalMetaStorageOptions, l as BaseStorageOptions, F as File, M as MetaStorage, d as FileInit, O as OperationOptions, e as FilePart, f as FileQuery, g as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-D9PBfkn6.js";
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+interface UploadThingStorageOptions extends BaseStorageOptions {
+  /**
+  * ACL applied to uploads. Drives `getReadUrl` behavior — `"public-read"`
+  * returns the permanent CDN URL, `"private"` mints a short-lived signed
+  * URL via `generateSignedURL`. Defaults to `"public-read"`.
+  */
+  acl?: "private" | "public-read";
+  /**
+  * Pre-built `UTApi` instance. Use this to share an instance, customize
+  * `fetch`, or inject test stubs. Mutually exclusive with `token`.
+  */
+  client?: UTApi;
+  /**
+  * Default expiry (seconds) for `getReadUrl` when `acl` is `"private"`.
+  * Capped at 7 days (UploadThing maximum). Defaults to 3600 (1 hour).
+  */
+  defaultUrlExpiresIn?: number;
+  /**
+  * Configure metafiles storage for resumable-upload bookkeeping.
+  */
+  metaStorageConfig?: LocalMetaStorageOptions;
+  /**
+  * UploadThing token (base64-encoded JSON: `{ apiKey, appId, regions[] }`).
+  * Falls back to `UPLOADTHING_TOKEN`. Ignored when `client` is supplied.
+  */
+  token?: string;
+}
+declare class UploadThingFile extends File {
+  customId?: string;
+  fileHash?: string;
+  ufsKey?: string;
+  url?: string;
+}
+declare class UploadThingMetaStorage extends LocalMetaStorage<UploadThingFile> {
+  constructor(config?: LocalMetaStorageOptions);
+}
+/**
+* UploadThing storage backend.
+*
+* Uses `UTApi` from `uploadthing/server`. Uploads via `uploadFiles(UTFile)`,
+* keyed by user-supplied `customId` so subsequent operations (delete, signed
+* URL, list) round-trip on the user's key, not UploadThing's internal fileKey.
+*
+* **Limitations**:
+* - No native server-side `copy` — implemented as download + re-upload.
+* - `list` has no server-side prefix filter; prefix filtering happens client-
+*   side within a page.
+* - No `responseContentDisposition` override on signed URLs.
+* @remarks
+* - ⚠️ Per-operation `signal`/`timeout` are best-effort: the underlying SDK does not support request cancellation, so an in-flight call may complete server-side even after abort. `retries` is honored.
+*/
+declare class UploadThingStorage extends BaseStorage<UploadThingFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  protected meta: MetaStorage<UploadThingFile>;
+  private readonly acl;
+  private readonly appId;
+  private readonly defaultUrlExpiresIn;
+  private readonly utapi;
+  constructor(config: UploadThingStorageOptions);
+  override get raw(): UTApi;
+  create(config: FileInit, _options?: OperationOptions): Promise<UploadThingFile>;
+  write(part: FilePart | FileQuery | UploadThingFile, options?: OperationOptions): Promise<UploadThingFile>;
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<UploadThingFile>;
+  get({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<UploadThingFile>;
+  move(name: string, destination: string, options?: OperationOptions): Promise<UploadThingFile>;
+  override list(limit?: number, options?: OperationOptions): Promise<UploadThingFile[]>;
+  override getReadUrl(key: string, options?: {
+    expiresIn?: number;
+    responseContentDisposition?: string;
+    responseContentType?: string;
+  }): Promise<string>;
+  override getUploadUrl(_key: string, _options?: {
+    contentLength?: number;
+    contentType?: string;
+    expiresIn?: number;
+  }): Promise<string>;
+  private resolveFetchUrl;
+  private internalOnComplete;
+}
+export { UploadThingFile, UploadThingMetaStorage, UploadThingStorage, type UploadThingStorageOptions };

package/dist/storage/uploadthing/index.js

@@ -0,0 +1 @@
+import{default as e}from"../../packem_shared/UploadThingFile-BTFMpcIA.js";import{default as r}from"../../packem_shared/UploadThingMetaStorage-D_vNzewL.js";import{default as d}from"../../packem_shared/UploadThingStorage-jrEnANC5.js";export{e as UploadThingFile,r as UploadThingMetaStorage,d as UploadThingStorage};