@visulima/storage 1.0.0-alpha.27 → 1.0.0-alpha.29

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

@@ -1,113 +1,15 @@
-import { F as File, L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, e as FileInit, f as FilePart, g as FileQuery, a as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-Cr6f2lac.js";
-import 'node:stream';
-import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-B5R1nswK.js";
+import { O as OneDriveFile, a as OneDriveStorageOptions } from "../../packem_shared/types.d-ChNXbbHG.js";
+export { type b as OneDriveClientCredentialsAuth, type c as OneDriveOAuthRefreshAuth } from "../../packem_shared/types.d-ChNXbbHG.js";
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-B11vHYNm.js";
+import { L as LocalMetaStorageOptions, M as MetaStorage, e as FileInit, O as OperationOptions, f as FilePart, g as FileQuery, a as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-RteRC-cG.js";
 import { Client } from '@microsoft/microsoft-graph-client';
+import 'node:stream';
 import 'node:crypto';
 import 'node:http';
 import 'lru-cache';
-declare class OneDriveFile extends File {
-  driveItemId?: string;
-  eTag?: string;
-  webUrl?: string;
-}
 declare class OneDriveMetaStorage extends LocalMetaStorage<OneDriveFile> {
   constructor(config?: LocalMetaStorageOptions);
 }
-interface OneDriveClientCredentialsAuth {
-  /**
-  * Microsoft Entra (Azure AD) application (client) ID.
-  */
-  clientId: string;
-  /**
-  * Application (client) secret.
-  */
-  clientSecret: string;
-  /**
-  * Microsoft Entra tenant ID (GUID or domain name).
-  */
-  tenantId: string;
-}
-interface OneDriveOAuthRefreshAuth {
-  /**
-  * Microsoft Entra application (client) ID.
-  */
-  clientId: string;
-  /**
-  * Application client secret. Required for confidential clients (default).
-  * Public clients may omit it if the app registration allows.
-  */
-  clientSecret?: string;
-  /**
-  * OAuth2 refresh token obtained from an interactive sign-in flow.
-  */
-  refreshToken: string;
-  /**
-  * Tenant ID — `"common"`, `"consumers"`, `"organizations"`, or a tenant
-  * GUID/domain. Defaults to `"common"`.
-  */
-  tenantId?: string;
-}
-interface OneDriveStorageOptions 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` (e.g. with
-  * `@azure/identity` or `@azure/msal-node`).
-  */
-  client?: Client;
-  /**
-  * Client-credentials auth — for app-only / daemon scenarios.
-  * Cannot be used with `/me/drive`; you must target via `driveId`,
-  * `siteId`, or `userId`.
-  */
-  clientCredentials?: OneDriveClientCredentialsAuth;
-  /**
-  * Timeout, in milliseconds, for polling the async-copy monitor URL.
-  * Defaults to 60_000 (60s).
-  */
-  copyTimeoutMs?: number;
-  /**
-  * Target drive by ID. Mutually exclusive with `siteId` and `userId`.
-  */
-  driveId?: string;
-  /**
-  * Configure metafiles storage. Defaults to local tmp directory.
-  */
-  metaStorageConfig?: LocalMetaStorageOptions;
-  /**
-  * OAuth2 refresh-token auth — for delegated user scenarios. Exchanges
-  * the refresh token at the Microsoft identity platform and caches the
-  * resulting access token until ~60s before expiry.
-  */
-  oauth?: OneDriveOAuthRefreshAuth;
-  /**
-  * 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; the adapter does not create
-  * folders. Defaults to drive root.
-  */
-  rootFolderPath?: string;
-  /**
-  * Target a SharePoint site's default drive. Mutually exclusive with
-  * `driveId` and `userId`.
-  */
-  siteId?: string;
-  /**
-  * Target a specific user's drive. Mutually exclusive with `driveId` and
-  * `siteId`. Required when using `clientCredentials` auth (Graph does not
-  * accept `/me/drive` for app-only tokens).
-  */
-  userId?: string;
-}
 /**
 * OneDrive / SharePoint storage backend (Microsoft Graph).
 *
@@ -140,6 +42,7 @@ interface OneDriveStorageOptions extends BaseStorageOptions {
 *   simple `PUT :/content` and upload-session paths. For multi-GB transfers
 *   prefer `getUploadUrl()` and stream chunks directly to the returned
 *   upload-session URL from the client.
+* - ⚠️ 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 OneDriveStorage extends BaseStorage<OneDriveFile> {
   static override readonly name: string;
@@ -152,17 +55,19 @@ declare class OneDriveStorage extends BaseStorage<OneDriveFile> {
   private readonly rootFolderPath;
   constructor(config: OneDriveStorageOptions);
   override get raw(): Client;
-  create(config: FileInit): Promise<OneDriveFile>;
-  write(part: FilePart | FileQuery | OneDriveFile): Promise<OneDriveFile>;
+  create(config: FileInit, _options?: OperationOptions): Promise<OneDriveFile>;
+  write(part: FilePart | FileQuery | OneDriveFile, options?: OperationOptions): Promise<OneDriveFile>;
   delete({
     id
-  }: FileQuery): Promise<OneDriveFile>;
+  }: FileQuery, options?: OperationOptions): Promise<OneDriveFile>;
   get({
     id
-  }: FileQuery): Promise<FileReturn>;
-  copy(name: string, destination: string): Promise<OneDriveFile>;
-  move(name: string, destination: string): Promise<OneDriveFile>;
-  override list(limit?: number): Promise<OneDriveFile[]>;
+  }: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<OneDriveFile>;
+  move(name: string, destination: string, options?: OperationOptions): Promise<OneDriveFile>;
+  override list(limit?: number, options?: OperationOptions): Promise<OneDriveFile[]>;
   override getReadUrl(key: string, options?: {
     expiresIn?: number;
     responseContentDisposition?: string;
@@ -189,4 +94,10 @@ declare class OneDriveStorage extends BaseStorage<OneDriveFile> {
   private pollCopyMonitor;
   private internalOnComplete;
 }
-export { type OneDriveClientCredentialsAuth, OneDriveFile, OneDriveMetaStorage, type OneDriveOAuthRefreshAuth, OneDriveStorage, type OneDriveStorageOptions };
+/**
+* Builds a Microsoft Graph `Client` from the OneDrive auth options (same
+* precedence as the constructor). Exposed so the SharePoint adapter can
+* resolve a site/document library to a `driveId` before delegating to an
+* inner `OneDriveStorage`, without duplicating the auth-building logic.
+*/
+export { OneDriveFile, OneDriveMetaStorage, OneDriveStorage, type OneDriveStorageOptions };

package/dist/storage/onedrive/index.js

@@ -1 +1 @@
-import{default as a}from"../../packem_shared/OneDriveFile-XbVVKIJh.js";import{default as o}from"../../packem_shared/OneDriveMetaStorage-B_BkGLzW.js";import{default as i}from"../../packem_shared/OneDriveStorage-Cu0cGcrh.js";export{a as OneDriveFile,o as OneDriveMetaStorage,i as OneDriveStorage};
+import{default as a}from"../../packem_shared/OneDriveFile-XbVVKIJh.js";import{default as o}from"../../packem_shared/OneDriveMetaStorage-DS4f83X2.js";import{default as i}from"../../packem_shared/OneDriveStorage-jAN46vRm.js";export{a as OneDriveFile,o as OneDriveMetaStorage,i as OneDriveStorage};

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

@@ -0,0 +1,172 @@
+import { F as File, L as LocalMetaStorageOptions, i as BaseStorageOptions, M as MetaStorage, e as FileInit, O as OperationOptions, f as FilePart, g as FileQuery, a as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-RteRC-cG.js";
+import 'node:stream';
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-B11vHYNm.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-CkAiSBb0.js";import{default as r}from"../../packem_shared/PocketBaseMetaStorage-B6utPncj.js";import{default as s}from"../../packem_shared/PocketBaseStorage-DpOjOKAt.js";export{t as PocketBaseFile,r as PocketBaseMetaStorage,s as PocketBaseStorage};

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

@@ -0,0 +1,86 @@
+import { F as File, L as LocalMetaStorageOptions, i as BaseStorageOptions, M as MetaStorage, e as FileInit, O as OperationOptions, f as FilePart, g as FileQuery, a as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-RteRC-cG.js";
+import 'node:stream';
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-B11vHYNm.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[];
+  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): 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-CQCxZNVq.js";import{default as o}from"../../packem_shared/SftpMetaStorage-DYqXwCdM.js";import{default as p}from"../../packem_shared/SftpStorage-Ban-WN8v.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-ChNXbbHG.js";
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-B11vHYNm.js";
+import { L as LocalMetaStorageOptions, i as BaseStorageOptions, M as MetaStorage, e as FileInit, O as OperationOptions, f as FilePart, g as FileQuery, a as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-RteRC-cG.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-BA6X9Sxr.js";import{default as r}from"../../packem_shared/SharePointMetaStorage-DVM5-X6g.js";import{default as S}from"../../packem_shared/SharePointStorage-BY90zh1c.js";export{t as SharePointFile,r as SharePointMetaStorage,S as SharePointStorage};

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

@@ -1,6 +1,6 @@
-import { F as File, L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, e as FileInit, f as FilePart, g as FileQuery, a as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-Cr6f2lac.js";
+import { F as File, L as LocalMetaStorageOptions, i as BaseStorageOptions, M as MetaStorage, e as FileInit, O as OperationOptions, f as FilePart, g as FileQuery, a as FileReturn, B as BaseStorage } from "../../packem_shared/storage.d-RteRC-cG.js";
 import 'node:stream';
-import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-B5R1nswK.js";
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-B11vHYNm.js";
 import { StorageClient } from '@supabase/storage-js';
 import 'node:crypto';
 import 'node:http';
@@ -71,6 +71,8 @@ interface SupabaseStorageOptions extends BaseStorageOptions {
 *   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;
@@ -81,20 +83,22 @@ declare class SupabaseStorage extends BaseStorage<SupabaseFile> {
   private readonly storageClient;
   constructor(config: SupabaseStorageOptions);
   override get raw(): StorageClient;
-  create(config: FileInit): Promise<SupabaseFile>;
-  write(part: FilePart | FileQuery | SupabaseFile): Promise<SupabaseFile>;
+  create(config: FileInit, _options?: OperationOptions): Promise<SupabaseFile>;
+  write(part: FilePart | FileQuery | SupabaseFile, options?: OperationOptions): Promise<SupabaseFile>;
   delete({
     id
-  }: FileQuery): Promise<SupabaseFile>;
+  }: FileQuery, options?: OperationOptions): Promise<SupabaseFile>;
   override exists({
     id
-  }: FileQuery): Promise<boolean>;
+  }: FileQuery, options?: OperationOptions): Promise<boolean>;
   get({
     id
-  }: FileQuery): Promise<FileReturn>;
-  copy(name: string, destination: string): Promise<SupabaseFile>;
-  move(name: string, destination: string): Promise<SupabaseFile>;
-  override list(limit?: number): Promise<SupabaseFile[]>;
+  }: 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;

package/dist/storage/supabase/index.js

@@ -1 +1 @@
-import{default as t}from"../../packem_shared/SupabaseFile-DZ1iv9gM.js";import{default as r}from"../../packem_shared/SupabaseMetaStorage-BR1UGqnj.js";import{default as p}from"../../packem_shared/SupabaseStorage-CCtMTiN5.js";export{t as SupabaseFile,r as SupabaseMetaStorage,p as SupabaseStorage};
+import{default as t}from"../../packem_shared/SupabaseFile-DZ1iv9gM.js";import{default as r}from"../../packem_shared/SupabaseMetaStorage-ivXoYVUu.js";import{default as p}from"../../packem_shared/SupabaseStorage-pNbHAE1Y.js";export{t as SupabaseFile,r as SupabaseMetaStorage,p as SupabaseStorage};