@visulima/storage 1.0.0-alpha.9 → 1.0.0

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

@@ -1,5 +1,195 @@
-export { default as GCSConfig } from "./gcs-config.d.ts";
-export { default as GCSFile } from "./gcs-file.d.ts";
-export { default as GCSMetaStorage } from "./gcs-meta-storage.d.ts";
-export { default as GCStorage } from "./gcs-storage.d.ts";
-export type { ClientError, GCSMetaStorageOptions, GCStorageOptions } from "./types.d.ts";
+import { F as File, k as MetaStorageOptions, L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, H as HttpError, 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 { RetryConfig } from 'gaxios';
+import { GoogleAuthOptions, GoogleAuth } from 'google-auth-library';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare const GCSConfig: Record<string, string | string[]>;
+declare class GCSFile extends File {
+  GCSUploadURI?: string;
+  uri?: string;
+}
+interface StorageSettings {
+  projectId: string;
+  retryOptions?: RetryConfig;
+  storageAPI?: string;
+  uploadAPI?: string;
+  useAuthWithCustomEndpoint?: boolean;
+  userProject?: string;
+}
+interface ClientError extends Error {
+  code: string;
+  config: Record<string, unknown>;
+  response?: Record<string, unknown>;
+}
+interface GCStorageOptions extends BaseStorageOptions, Omit<GoogleAuthOptions, "authClient" | "projectId">, StorageSettings {
+  /**
+  * Google Cloud Storage bucket
+  */
+  bucket?: string;
+  /**
+  * Force compatible client upload directly to GCS
+  */
+  clientDirectUpload?: boolean;
+  /**
+  * Configure metafiles storage
+  * @example
+  * ```ts
+  * Using local metafiles
+  * const storage = new GCStorage({
+  *   bucket: 'upload',
+  *   metaStorageConfig: { directory: '/tmp/upload-metafiles' }
+  * })
+  * ```
+  * Using a separate bucket for metafiles
+  * ```ts
+  * const storage = new GCStorage({
+  *   bucket: 'upload',
+  *   metaStorageConfig: { bucket: 'upload-metafiles' }
+  * })
+  * ```
+  */
+  metaStorageConfig?: GCSMetaStorageOptions | LocalMetaStorageOptions;
+}
+interface GCSMetaStorageOptions extends MetaStorageOptions, Omit<GoogleAuthOptions, "authClient" | "projectId">, StorageSettings {
+  bucket?: string;
+}
+declare class GCSMetaStorage<T extends File = File> extends MetaStorage<T> {
+  readonly config: GCSMetaStorageOptions;
+  private authClient;
+  private readonly storageBaseURI;
+  private readonly uploadBaseURI;
+  private readonly isCustomEndpoint;
+  private readonly retryOptions;
+  private readonly useAuthWithCustomEndpoint;
+  private readonly userProject;
+  constructor(config: GCSMetaStorageOptions);
+  override save(id: string, file: T): Promise<T>;
+  override delete(id: string): Promise<void>;
+  override get(id: string): Promise<T>;
+  override touch(id: string, file: T): Promise<T>;
+  private accessCheck;
+  /**
+  * Returns metafile URL path for the given upload ID.
+  * @param id Upload ID to get metafile path for
+  * @returns Full URL path to the metafile in GCS
+  */
+  private getMetaPath;
+  private makeRequest;
+}
+/**
+* Google cloud storage based backend.
+* @example
+* ```ts
+*  const storage = new GCStorage({
+*    bucket: <YOUR_BUCKET>,
+*    keyFile: <PATH_TO_KEY_FILE>,
+*    metaStorage: new MetaStorage(),
+*    clientDirectUpload: true,
+*    maxUploadSize: '15GB',
+*    allowMIME: ['video/*', 'image/*'],
+*    filename: file => file.originalName
+*  });
+* ```
+* @remarks
+* ## Supported Operations
+* - ✅ create, write, delete, get, list, update, copy, move
+* - ✅ Batch operations: deleteBatch, copyBatch, moveBatch (inherited from BaseStorage)
+* - ✅ exists: Implemented (checks metadata and GCS object)
+* - ❌ getStream: Not implemented (use get() for file retrieval)
+* - ❌ getUrl: Not implemented (GCS public URLs not supported)
+* - ❌ getUploadUrl: Not implemented (resumable upload URLs handled internally)
+*/
+declare class GCStorage extends BaseStorage<GCSFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  override readonly supportsDelimiter: boolean;
+  override get raw(): GoogleAuth;
+  protected meta: MetaStorage;
+  private readonly bucket;
+  private authClient;
+  private readonly storageBaseURI;
+  private readonly uploadBaseURI;
+  private readonly isCustomEndpoint;
+  private readonly retryOptions;
+  private readonly useAuthWithCustomEndpoint;
+  private readonly userProject;
+  constructor(config: GCStorageOptions);
+  override normalizeError(error: ClientError): HttpError;
+  create(config: FileInit, options?: OperationOptions): Promise<GCSFile>;
+  write(part: FilePart | FileQuery | GCSFile, options?: OperationOptions): Promise<GCSFile>;
+  /**
+  * Deletes an upload and its metadata.
+  * @param query File query containing the file ID to delete.
+  * @param query.id File ID to delete.
+  * @returns Promise resolving to the deleted file object with status: "deleted".
+  * @throws {UploadError} If the file metadata cannot be found.
+  */
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<GCSFile>;
+  /**
+  * Copies an upload file to a new location.
+  * @param name Source file name/ID.
+  * @param destination Destination file name/ID.
+  * @returns Promise resolving to the copied file object.
+  * @throws {UploadError} If the source file cannot be found.
+  */
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<GCSFile>;
+  /**
+  * Moves an upload file to a new location.
+  * @param name Source file name/ID.
+  * @param destination Destination file name/ID.
+  * @returns Promise resolving to the moved file object.
+  * @throws {UploadError} If the source file cannot be found.
+  */
+  move(name: string, destination: string, options?: OperationOptions): Promise<GCSFile>;
+  /**
+  * Gets an uploaded file by ID with content buffer.
+  * @param query File query object containing the file ID.
+  * @param query.id Unique identifier of the file to retrieve.
+  * @returns Promise resolving to file object with content buffer.
+  * @throws {UploadError} If the file cannot be found (ERRORS.FILE_NOT_FOUND) or has expired (ERRORS.GONE).
+  */
+  get({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  /**
+  * Checks if a file exists by verifying both metadata and the actual GCS object.
+  * Returns true only if both the metadata and the GCS object exist.
+  * @param query File query containing the file ID to check.
+  * @returns Promise resolving to true if both metadata and GCS object exist, false otherwise.
+  */
+  override exists({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<boolean>;
+  override list(limit?: number, options?: OperationOptions): Promise<GCSFile[]>;
+  /**
+  * Directory-style listing via the GCS JSON API's native `delimiter`/`prefix` — the API returns
+  * the direct child objects in `items` and the common prefixes ("subdirectories") in `prefixes`,
+  * so the subtree is never fully walked. Pages until exhausted or `limit` files are collected.
+  */
+  override listDirectory(options?: OperationOptions & {
+    delimiter: string;
+    limit?: number;
+    prefix?: string;
+  }): Promise<{
+    files: GCSFile[];
+    prefixes: string[];
+  }>;
+  protected internalWrite(part: GCSFile & Partial<FilePart>, callOptions?: OperationOptions): Promise<number>;
+  private internalOnComplete;
+  /**
+  * Merge a body-level abort signal with the caller's per-operation
+  * `options.signal` so gaxios cancels the in-flight request on either.
+  * `options.timeout` is handed to gaxios' native `timeout` instead of a
+  * second `AbortSignal.timeout` to avoid two competing deadlines.
+  */
+  private static buildCallSignal;
+  private makeRequest;
+  private accessCheck;
+}
+export { type ClientError, GCSConfig, GCSFile, GCSMetaStorage, type GCSMetaStorageOptions, GCStorage, type GCStorageOptions };

package/dist/storage/gcs/index.js

@@ -1,4 +1 @@
-export { default as GCSConfig } from '../../packem_shared/GCSConfig-vPP22kN6.js';
-export { default as GCSFile } from '../../packem_shared/GCSFile-BIEunhAN.js';
-export { G as GCSMetaStorage } from '../../packem_shared/gcs-meta-storage-CJ8Uts_d.js';
-export { default as GCStorage } from '../../packem_shared/GCStorage-C-gAuP0j.js';
+import{default as a}from"../../packem_shared/GCSConfig-BQ0OpVhe.js";import{default as t}from"../../packem_shared/GCSFile-Cero7qZN.js";import{v as C}from"../../packem_shared/gcs-meta-storage-Dy37wCjI.js";import{default as l}from"../../packem_shared/GCStorage-DUfwVFd3.js";export{a as GCSConfig,t as GCSFile,C as GCSMetaStorage,l as GCStorage};

package/dist/storage/google-drive/index.d.ts

@@ -0,0 +1,148 @@
+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 { drive_v3 } from '@googleapis/drive';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare class GoogleDriveFile extends File {
+  driveFileId?: string;
+  mimeType?: string;
+  publicUrl?: string;
+}
+declare class GoogleDriveMetaStorage extends LocalMetaStorage<GoogleDriveFile> {
+  constructor(config?: LocalMetaStorageOptions);
+}
+interface GoogleDriveStorageOptions extends BaseStorageOptions {
+  /**
+  * Pre-built `@googleapis/drive` v3 client. Escape hatch for callers that
+  * have already wired auth (workload identity, ADC, etc.). When set, the
+  * adapter uses it directly and `getUploadUrl()` will throw because there's
+  * no stable way to recover the underlying auth handle.
+  */
+  client?: drive_v3.Drive;
+  /**
+  * Inline service-account credentials. Mints a `JWT` auth client with
+  * `https://www.googleapis.com/auth/drive` scope. Mutually exclusive with
+  * the other auth shapes.
+  */
+  credentials?: {
+    client_email: string;
+    private_key: string;
+  };
+  /**
+  * Shared Drive id. **Strongly recommended for service-account auth** —
+  * service accounts have a 15 GB personal quota; production workloads
+  * should target a Shared Drive with the service account added as a member.
+  */
+  driveId?: string;
+  /**
+  * LRU capacity for the in-memory virtual-key → fileId cache. Drive has
+  * no native key field; every read after the first round-trips a
+  * `files.list` to resolve the id, which the cache amortizes. Defaults to
+  * 1024.
+  */
+  fileIdCacheSize?: number;
+  /**
+  * Path to a service-account JSON file. Mutually exclusive with the other
+  * auth shapes.
+  */
+  keyFilename?: string;
+  /**
+  * Configure metafiles storage. Defaults to local tmp directory.
+  */
+  metaStorageConfig?: LocalMetaStorageOptions;
+  /**
+  * OAuth refresh token (3-legged OAuth, end-user Drive). The adapter mints
+  * fresh access tokens against `clientId`/`clientSecret`. Mutually
+  * exclusive with the other auth shapes.
+  */
+  oauth?: {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+  };
+  /**
+  * When `true`, `write()` also creates an "anyone with link, reader"
+  * permission and `getReadUrl()` returns the Drive public download URL.
+  * When `false` (default), `getReadUrl()` throws — Drive has no signed-URL
+  * primitive.
+  */
+  publicByDefault?: boolean;
+  /**
+  * Logical "bucket root" — virtual keys live under this folder. Defaults
+  * to `"root"` (My Drive root) or, when `driveId` is set, the Shared
+  * Drive root id should be used here.
+  */
+  rootFolderId?: string;
+  /**
+  * Domain-wide delegation subject (the user to impersonate). Only honored
+  * with `credentials` or `keyFilename`.
+  */
+  subject?: string;
+}
+/**
+* Google Drive storage backend.
+*
+* Drive is **not** a key-value store — it organizes files by `fileId`, and a
+* single virtual key (e.g. `"docs/report.pdf"`) can map to multiple Drive
+* files. The adapter routes by `appProperties.fsdkKey`, which it sets on
+* every upload and resolves via `files.list` on every read. An LRU cache
+* amortizes the resolve cost.
+*
+* **Auth precedence**:
+* 1. `client` (pre-built `drive_v3.Drive`)
+* 2. `credentials` (inline service account)
+* 3. `keyFilename` (service-account JSON path)
+* 4. `oauth` (refresh token + clientId/clientSecret)
+* 5. Env fallback: `GOOGLE_DRIVE_CLIENT_EMAIL` + `GOOGLE_DRIVE_PRIVATE_KEY`, or
+*    `GOOGLE_DRIVE_KEY_FILE` (optional: `GOOGLE_DRIVE_SUBJECT` for DWD).
+*
+* **Limitations**:
+* - `getReadUrl()` only works with `publicByDefault: true` — Drive has no
+*   signed-URL primitive.
+* - `responseContentDisposition` is not supported.
+* - `getUploadUrl()` requires explicit `credentials`/`keyFilename`/`oauth`
+*   (not a pre-built `client`) so we can mint access tokens for the
+*   resumable session.
+* - ⚠️ 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 GoogleDriveStorage extends BaseStorage<GoogleDriveFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  protected meta: MetaStorage<GoogleDriveFile>;
+  private readonly authForTokens;
+  private readonly driveClient;
+  private readonly fileIdCache;
+  private readonly publicByDefault;
+  private readonly rootFolderId;
+  private readonly sharedDriveParams;
+  constructor(config: GoogleDriveStorageOptions);
+  override get raw(): drive_v3.Drive;
+  create(config: FileInit, _options?: OperationOptions): Promise<GoogleDriveFile>;
+  write(part: FilePart | FileQuery | GoogleDriveFile, options?: OperationOptions): Promise<GoogleDriveFile>;
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<GoogleDriveFile>;
+  get({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<GoogleDriveFile>;
+  move(name: string, destination: string, options?: OperationOptions): Promise<GoogleDriveFile>;
+  override list(limit?: number, options?: OperationOptions): Promise<GoogleDriveFile[]>;
+  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 resolveFileId;
+  private internalOnComplete;
+}
+export { GoogleDriveFile, GoogleDriveMetaStorage, GoogleDriveStorage, type GoogleDriveStorageOptions };

package/dist/storage/google-drive/index.js

@@ -0,0 +1 @@
+import{default as r}from"../../packem_shared/GoogleDriveFile-DHpLhzg9.js";import{default as t}from"../../packem_shared/GoogleDriveMetaStorage-DqkgoE46.js";import{default as f}from"../../packem_shared/GoogleDriveStorage-D0-5egHE.js";export{r as GoogleDriveFile,t as GoogleDriveMetaStorage,f as GoogleDriveStorage};

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

@@ -1,4 +1,7 @@
-export { default as DiskStorage } from "./disk-storage.d.ts";
-export { default as DiskStorageWithChecksum } from "./disk-storage-with-checksum.d.ts";
-export type { LocalMetaStorageOptions } from "./local-meta-storage.d.ts";
-export { default as LocalMetaStorage } from "./local-meta-storage.d.ts";
+export { D as DiskStorage, a as DiskStorageWithChecksum } from "../../packem_shared/disk-storage-with-checksum.d-B-VGEsfl.js";
+export { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-D9PBfkn6.js";
+export type { L as LocalMetaStorageOptions } from "../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';

package/dist/storage/local/index.js

@@ -1,3 +1 @@
-export { D as DiskStorage } from '../../packem_shared/disk-storage-CD47QI30.js';
-export { default as DiskStorageWithChecksum } from '../../packem_shared/DiskStorageWithChecksum-BRl-V5x2.js';
-export { L as LocalMetaStorage } from '../../packem_shared/local-meta-storage-By-3SNBI.js';
+import{F as e}from"../../packem_shared/disk-storage-DIn-VnCh.js";import{default as t}from"../../packem_shared/DiskStorageWithChecksum-Bh6w-Iu8.js";import{y as f}from"../../packem_shared/local-meta-storage-C2T92TYb.js";export{e as DiskStorage,t as DiskStorageWithChecksum,f as LocalMetaStorage};

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

@@ -0,0 +1,6 @@
+export { M as MemoryMetaStorage, a as MemoryStorage, type b as MemoryStorageOptions, a as default } from "../../packem_shared/memory-storage.d-4EU1cMt1.js";
+import 'node:stream';
+import "../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';

package/dist/storage/memory/index.js

@@ -0,0 +1 @@
+import{default as o}from"../../packem_shared/MemoryMetaStorage-Ksgh9pe7.js";import{default as t,default as f}from"../../packem_shared/MemoryStorage-DzSTdlAq.js";export{o as MemoryMetaStorage,t as MemoryStorage,f as default};

package/dist/storage/netlify-blob/index.d.ts

@@ -1,4 +1,147 @@
-export { default as NetlifyBlobFile } from "./netlify-blob-file.d.ts";
-export { default as NetlifyBlobMetaStorage } from "./netlify-blob-meta-storage.d.ts";
-export { default as NetlifyBlobStorage } from "./netlify-blob-storage.d.ts";
-export type { NetlifyBlobStorageOptions } from "./types.d.ts";
+import { F as File, L as LocalMetaStorageOptions, l as BaseStorageOptions, M as MetaStorage, R as RetryConfig, 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 { getStore } from '@netlify/blobs';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare class NetlifyBlobFile extends File {
+  /**
+  * The blob's public URL
+  */
+  url?: string;
+  /**
+  * The blob's pathname within the store
+  */
+  pathname?: string;
+}
+declare class NetlifyBlobMetaStorage extends LocalMetaStorage {
+  constructor(config?: LocalMetaStorageOptions);
+}
+interface NetlifyBlobStorageOptions extends BaseStorageOptions {
+  /**
+  * Configure metafiles storage
+  * @example
+  * Using local metafiles
+  * ```ts
+  * const storage = new NetlifyBlobStorage({
+  *   storeName: 'uploads',
+  *   metaStorageConfig: { directory: '/tmp/upload-metafiles' }
+  * })
+  * ```
+  */
+  metaStorageConfig?: LocalMetaStorageOptions;
+  /**
+  * Netlify site ID (optional, used for explicit store access)
+  */
+  siteID?: string;
+  /**
+  * Netlify Blob store name
+  * @default 'default'
+  */
+  storeName?: string;
+  /**
+  * Netlify API token (optional, can use environment variable NETLIFY_TOKEN)
+  */
+  token?: string;
+}
+/**
+* Netlify Blob storage based backend.
+* @example
+* ```ts
+* const storage = new NetlifyBlobStorage({
+*   storeName: 'uploads',
+*   metaStorageConfig: { directory: '/tmp/upload-metafiles' }
+* });
+* ```
+* @remarks
+* ## Supported Operations
+* - ✅ create, write, delete, get, list, copy, move
+* - ✅ Batch operations: deleteBatch, copyBatch, moveBatch (inherited from BaseStorage)
+* - ✅ exists: Implemented (checks metadata and Netlify Blob)
+* - ✅ update: Implemented (updates metadata file, Netlify Blob API doesn't support blob metadata updates)
+* - ❌ getStream: Not implemented (use get() for file retrieval)
+* - ❌ getUrl: Not implemented (Netlify Blob URLs available via Netlify Blob API)
+* - ❌ getUploadUrl: Not implemented (Netlify Blob upload URLs handled internally)
+*/
+declare class NetlifyBlobStorage extends BaseStorage<NetlifyBlobFile> {
+  static override readonly name: string;
+  override checksumTypes: string[];
+  override get raw(): ReturnType<typeof getStore>;
+  protected meta: MetaStorage;
+  private readonly storeName;
+  private readonly siteID?;
+  private readonly token?;
+  private store;
+  private readonly resolvedRetryConfig;
+  constructor(config: NetlifyBlobStorageOptions);
+  protected override getRetryConfig(): RetryConfig;
+  create(config: FileInit, _options?: OperationOptions): Promise<NetlifyBlobFile>;
+  write(part: FilePart | FileQuery | NetlifyBlobFile, options?: OperationOptions): Promise<NetlifyBlobFile>;
+  /**
+  * Deletes an upload and its metadata.
+  * @param query File query containing the file ID to delete.
+  * @param query.id File ID to delete.
+  * @returns Promise resolving to the deleted file object with status: "deleted".
+  * @throws {UploadError} If the file metadata cannot be found.
+  */
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<NetlifyBlobFile>;
+  /**
+  * Checks if a file exists by verifying both metadata and the actual Netlify Blob.
+  * Returns true only if both the metadata and the blob exist.
+  * @param query File query containing the file ID to check.
+  * @returns Promise resolving to true if both metadata and blob exist, false otherwise.
+  */
+  override exists({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<boolean>;
+  get({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<FileReturn>;
+  /**
+  * Copies an upload file to a new location.
+  * @param name Source file name/ID.
+  * @param destination Destination file name/ID.
+  * @returns Promise resolving to the copied file object.
+  * @throws {UploadError} If the source file cannot be found.
+  */
+  copy(name: string, destination: string, options?: OperationOptions & {
+    storageClass?: string;
+  }): Promise<NetlifyBlobFile>;
+  /**
+  * Moves an upload file to a new location.
+  * @param name Source file name/ID.
+  * @param destination Destination file name/ID.
+  * @returns Promise resolving to the moved file object.
+  * @throws {UploadError} If the source file cannot be found.
+  */
+  move(name: string, destination: string, options?: OperationOptions): Promise<NetlifyBlobFile>;
+  /**
+  * Updates file metadata with user-provided key-value pairs.
+  * Updates the metadata file (overwrites it) but does not update Netlify Blob metadata
+  * since the Netlify Blob API doesn't support metadata updates.
+  * @param query File query containing the file ID to update.
+  * @param query.id File ID to update.
+  * @param metadata Partial file object containing fields to update.
+  * @returns Promise resolving to the updated file object.
+  * @throws {UploadError} If the file cannot be found (ERRORS.FILE_NOT_FOUND).
+  * @remarks
+  * Supports TTL (time-to-live) option: if metadata contains a 'ttl' field,
+  * it will be converted to an 'expiredAt' timestamp.
+  * TTL can be a number (milliseconds) or string (e.g., "1h", "30m", "7d").
+  */
+  override update({
+    id
+  }: FileQuery, metadata: Partial<NetlifyBlobFile>, _options?: OperationOptions): Promise<NetlifyBlobFile>;
+  override list(limit?: number, options?: OperationOptions): Promise<NetlifyBlobFile[]>;
+  private internalOnComplete;
+  /**
+  * Generate a URL for a blob in Netlify Blob store
+  * Note: Netlify Blob doesn't provide direct public URLs like Vercel Blob
+  * In production, you would typically serve these through Netlify Functions or Edge Functions
+  */
+  private getBlobUrl;
+}
+export { NetlifyBlobFile, NetlifyBlobMetaStorage, NetlifyBlobStorage, type NetlifyBlobStorageOptions };

package/dist/storage/netlify-blob/index.js

@@ -1,3 +1 @@
-export { default as NetlifyBlobFile } from '../../packem_shared/NetlifyBlobFile-CXzyjqrD.js';
-export { default as NetlifyBlobMetaStorage } from '../../packem_shared/NetlifyBlobMetaStorage-DxZ5aDvD.js';
-export { default as NetlifyBlobStorage } from '../../packem_shared/NetlifyBlobStorage-CLPtjHqd.js';
+import{default as o}from"../../packem_shared/NetlifyBlobFile-DoFhkzaH.js";import{default as a}from"../../packem_shared/NetlifyBlobMetaStorage-D_vNzewL.js";import{default as r}from"../../packem_shared/NetlifyBlobStorage-DZdCmOVW.js";export{o as NetlifyBlobFile,a as NetlifyBlobMetaStorage,r as NetlifyBlobStorage};

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

@@ -0,0 +1,103 @@
+import { O as OneDriveFile, a as OneDriveStorageOptions } from "../../packem_shared/types.d-Bon9GVVe.js";
+export type { b as OneDriveClientCredentialsAuth, c as OneDriveOAuthRefreshAuth } from "../../packem_shared/types.d-Bon9GVVe.js";
+import { L as LocalMetaStorage } from "../../packem_shared/local-meta-storage.d-D9PBfkn6.js";
+import { L as LocalMetaStorageOptions, 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 { Client } from '@microsoft/microsoft-graph-client';
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+declare class OneDriveMetaStorage extends LocalMetaStorage<OneDriveFile> {
+  constructor(config?: LocalMetaStorageOptions);
+}
+/**
+* OneDrive / SharePoint storage backend (Microsoft Graph).
+*
+* Routes virtual keys onto items under `rootFolderPath` in the target drive.
+* Uploads use a single `PUT :/content` request up to 250 MB and switch to
+* Microsoft Graph upload sessions above that threshold.
+*
+* **Auth precedence**:
+* 1. `client` (pre-built `@microsoft/microsoft-graph-client` `Client`)
+* 2. `accessToken` (string or `() => string | Promise&lt;string>`)
+* 3. `clientCredentials` (`tenantId` + `clientId` + `clientSecret`) — app-only
+* 4. `oauth` (`refreshToken` + `clientId` [+ `clientSecret`, `tenantId`]) — delegated
+* 5. Env fallback: `ONEDRIVE_ACCESS_TOKEN`; or `ONEDRIVE_REFRESH_TOKEN` +
+*    `ONEDRIVE_CLIENT_ID` (+ optional `ONEDRIVE_CLIENT_SECRET`, `ONEDRIVE_TENANT_ID`);
+*    or `ONEDRIVE_CLIENT_ID` + `ONEDRIVE_CLIENT_SECRET` + `ONEDRIVE_TENANT_ID`.
+*
+* **Targeting**: at most one of `driveId`, `siteId`, `userId`. With no
+* targeting and delegated auth, defaults to `/me/drive`. App-only auth
+* (`clientCredentials`) cannot use `/me/drive` — pick a target explicitly.
+*
+* **Limitations**:
+* - `cacheControl` is not supported.
+* - `metadata` is preserved via the local metafile only; Graph does not store
+*   arbitrary key/value metadata on `driveItem`.
+* - `getUploadUrl` returns an upload-session URL — clients should `PUT` chunks
+*   directly to it with `Content-Range` headers (not a PUT-with-body URL).
+* - `responseContentDisposition` and `responseContentType` are not supported
+*   on signed download URLs (Graph downloadUrls have no overrides).
+* - `write()` buffers the full part body in memory before deciding between
+*   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;
+  override checksumTypes: string[];
+  protected meta: MetaStorage<OneDriveFile>;
+  private readonly basePath;
+  private readonly client;
+  private readonly copyTimeoutMs;
+  private readonly publicByDefault;
+  private readonly rootFolderPath;
+  constructor(config: OneDriveStorageOptions);
+  override get raw(): Client;
+  create(config: FileInit, _options?: OperationOptions): Promise<OneDriveFile>;
+  write(part: FilePart | FileQuery | OneDriveFile, options?: OperationOptions): Promise<OneDriveFile>;
+  delete({
+    id
+  }: FileQuery, options?: OperationOptions): Promise<OneDriveFile>;
+  get({
+    id
+  }: 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;
+    responseContentType?: string;
+  }): Promise<string>;
+  override getUploadUrl(key: string, options?: {
+    contentLength?: number;
+    contentType?: string;
+    expiresIn?: number;
+  }): Promise<string>;
+  private keyParts;
+  private itemApiPath;
+  private itemActionPath;
+  private folderListChildrenPath;
+  /**
+  * Build a `parentReference.path` for move/copy. Microsoft Graph requires
+  * this path to be relative to the drive, prefixed with `/drive/root:` —
+  * **not** with the configured base path (`/me/drive`, `/drives/{id}`, …).
+  */
+  private parentReferencePath;
+  private itemPathToKey;
+  private uploadSimple;
+  private uploadSession;
+  private pollCopyMonitor;
+  private internalOnComplete;
+}
+/**
+* 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

@@ -0,0 +1 @@
+import{default as a}from"../../packem_shared/OneDriveFile-CNNJYI43.js";import{default as o}from"../../packem_shared/OneDriveMetaStorage-DqkgoE46.js";import{default as i}from"../../packem_shared/OneDriveStorage-CvJetV7_.js";export{a as OneDriveFile,o as OneDriveMetaStorage,i as OneDriveStorage};