local-lite 0.0.21 → 0.0.22

package/dist/storage/expo.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoFileDriver = void 0;
+exports.bytesToBase64 = bytesToBase64;
+exports.base64ToBytes = base64ToBytes;
+/**
+ * Universal binary <-> base64 utilities compatible with Node, Browser, and React Native (Hermes).
+ */
+function bytesToBase64(bytes) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64');
+    }
+    let binary = '';
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+function base64ToBytes(base64) {
+    if (typeof Buffer !== 'undefined') {
+        const buf = Buffer.from(base64, 'base64');
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * FileDriver implementation for Expo / React Native environments.
+ * Uses modern Expo (>57/58) `File`, `Directory`, and `Paths` APIs when available,
+ * with seamless fallback for legacy `expo-file-system` environments.
+ */
+class ExpoFileDriver {
+    FileClass;
+    DirectoryClass;
+    PathsObj;
+    legacyFs;
+    baseDirOption;
+    useCache;
+    resolvedBaseDir = null;
+    resolvedBaseDirPath = null;
+    ensuredDirs = new Set();
+    constructor(options = {}) {
+        this.FileClass = options.File ?? options.fileSystem?.File;
+        this.DirectoryClass = options.Directory ?? options.fileSystem?.Directory;
+        this.PathsObj = options.Paths ?? options.fileSystem?.Paths;
+        this.legacyFs = options.fileSystem;
+        this.baseDirOption = options.baseDir;
+        this.useCache = Boolean(options.useCache);
+    }
+    async resolveClasses() {
+        if (!this.FileClass || !this.DirectoryClass || !this.PathsObj) {
+            try {
+                // @ts-ignore
+                const mod = await import('expo-file-system');
+                this.FileClass = this.FileClass ?? mod.File;
+                this.DirectoryClass = this.DirectoryClass ?? mod.Directory;
+                this.PathsObj = this.PathsObj ?? mod.Paths;
+                this.legacyFs = this.legacyFs ?? mod;
+            }
+            catch {
+                // Dynamic import may fail if not installed or bundler forbids
+            }
+        }
+        return {
+            FileClass: this.FileClass,
+            DirectoryClass: this.DirectoryClass,
+            PathsObj: this.PathsObj,
+            legacyFs: this.legacyFs,
+        };
+    }
+    async getBaseDirectory() {
+        if (this.resolvedBaseDir)
+            return this.resolvedBaseDir;
+        const { DirectoryClass, PathsObj, legacyFs } = await this.resolveClasses();
+        if (this.baseDirOption) {
+            if (typeof this.baseDirOption === 'string') {
+                if (DirectoryClass) {
+                    this.resolvedBaseDir = new DirectoryClass(this.baseDirOption);
+                }
+                else {
+                    this.resolvedBaseDirPath = this.baseDirOption.endsWith('/')
+                        ? this.baseDirOption
+                        : `${this.baseDirOption}/`;
+                }
+            }
+            else {
+                this.resolvedBaseDir = this.baseDirOption;
+            }
+        }
+        else if (DirectoryClass && PathsObj) {
+            const root = this.useCache ? PathsObj.cache : PathsObj.document;
+            this.resolvedBaseDir = new DirectoryClass(root, 'local-lite-blobs');
+        }
+        else if (legacyFs) {
+            const root = this.useCache ? legacyFs.cacheDirectory : legacyFs.documentDirectory;
+            if (!root) {
+                throw new Error('ExpoFileDriver: FileSystem documentDirectory is null or unavailable.');
+            }
+            this.resolvedBaseDirPath = root.endsWith('/') ? `${root}local-lite-blobs/` : `${root}/local-lite-blobs/`;
+        }
+        if (this.resolvedBaseDir) {
+            try {
+                if (!this.resolvedBaseDir.exists && typeof this.resolvedBaseDir.create === 'function') {
+                    this.resolvedBaseDir.create({ idempotent: true });
+                }
+            }
+            catch { }
+        }
+        return this.resolvedBaseDir;
+    }
+    /**
+     * Resolves a key to a modern Expo `File` instance (if File class is available)
+     * or a string URI path.
+     */
+    async resolveFileOrUri(key) {
+        const { FileClass, DirectoryClass } = await this.resolveClasses();
+        const baseDir = await this.getBaseDirectory();
+        const safeKey = key.replace(/\.\./g, '_').replace(/^[/\\?%*:|"<>]+/, '');
+        // Modern Expo File & Directory path
+        if (FileClass && baseDir) {
+            const segments = safeKey.split('/').filter(Boolean);
+            const fileName = segments.pop() || 'blob';
+            let currentDir = baseDir;
+            for (const seg of segments) {
+                const safeSeg = seg.replace(/[/\\?%*:|"<>]/g, '_');
+                if (DirectoryClass) {
+                    const subDir = new DirectoryClass(currentDir, safeSeg);
+                    try {
+                        if (!subDir.exists && typeof subDir.create === 'function') {
+                            subDir.create({ idempotent: true });
+                        }
+                    }
+                    catch { }
+                    currentDir = subDir;
+                }
+            }
+            const safeFileName = fileName.replace(/[/\\?%*:|"<>]/g, '_');
+            const file = new FileClass(currentDir, safeFileName);
+            return { file, uri: file.uri };
+        }
+        // Legacy URI resolution
+        const basePath = this.resolvedBaseDirPath ||
+            (this.resolvedBaseDir?.uri
+                ? this.resolvedBaseDir.uri.endsWith('/')
+                    ? this.resolvedBaseDir.uri
+                    : `${this.resolvedBaseDir.uri}/`
+                : 'file:///local-lite-blobs/');
+        const uri = `${basePath}${safeKey}`;
+        return { file: null, uri };
+    }
+    async resolveUri(key) {
+        const { uri } = await this.resolveFileOrUri(key);
+        return uri;
+    }
+    async getUri(key) {
+        return this.resolveUri(key);
+    }
+    async ensureDirectory(fileUri) {
+        const { legacyFs } = await this.resolveClasses();
+        if (!legacyFs || typeof legacyFs.makeDirectoryAsync !== 'function')
+            return;
+        const lastSlash = fileUri.lastIndexOf('/');
+        if (lastSlash === -1)
+            return;
+        const dir = fileUri.substring(0, lastSlash);
+        if (this.ensuredDirs.has(dir))
+            return;
+        try {
+            await legacyFs.makeDirectoryAsync(dir, { intermediates: true });
+            this.ensuredDirs.add(dir);
+        }
+        catch {
+            this.ensuredDirs.add(dir);
+        }
+    }
+    async write(key, data) {
+        const { file, uri } = await this.resolveFileOrUri(key);
+        // Modern Expo File (>57/58)
+        if (file) {
+            // Ensure parent directory exists before writing
+            try {
+                if (file.parentDirectory && !file.parentDirectory.exists) {
+                    file.parentDirectory.create({ idempotent: true });
+                }
+            }
+            catch { }
+            if (typeof file.write === 'function') {
+                await file.write(data);
+                return file.uri;
+            }
+            if (typeof file.writeSync === 'function') {
+                file.writeSync(data);
+                return file.uri;
+            }
+        }
+        // Legacy FileSystem API
+        const { legacyFs } = await this.resolveClasses();
+        if (legacyFs && typeof legacyFs.writeAsStringAsync === 'function') {
+            await this.ensureDirectory(uri);
+            const base64 = bytesToBase64(data);
+            const encoding = legacyFs.EncodingType?.Base64 ?? 'base64';
+            await legacyFs.writeAsStringAsync(uri, base64, { encoding });
+            return uri;
+        }
+        throw new Error('ExpoFileDriver: No supported File or write method found on expo-file-system.');
+    }
+    async read(key) {
+        const { file, uri } = await this.resolveFileOrUri(key);
+        // Modern Expo File (>57/58)
+        if (file) {
+            try {
+                if (!file.exists) {
+                    return null;
+                }
+                if (typeof file.bytes === 'function') {
+                    const res = await file.bytes();
+                    return new Uint8Array(res);
+                }
+                if (typeof file.bytesSync === 'function') {
+                    return new Uint8Array(file.bytesSync());
+                }
+                if (typeof file.arrayBuffer === 'function') {
+                    const ab = await file.arrayBuffer();
+                    return new Uint8Array(ab);
+                }
+                if (typeof file.base64 === 'function') {
+                    const b64 = await file.base64();
+                    return base64ToBytes(b64);
+                }
+                if (typeof file.base64Sync === 'function') {
+                    return base64ToBytes(file.base64Sync());
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        // Legacy FileSystem API
+        const { legacyFs } = await this.resolveClasses();
+        if (legacyFs && typeof legacyFs.readAsStringAsync === 'function') {
+            try {
+                if (typeof legacyFs.getInfoAsync === 'function') {
+                    const info = await legacyFs.getInfoAsync(uri);
+                    if (!info.exists)
+                        return null;
+                }
+                const encoding = legacyFs.EncodingType?.Base64 ?? 'base64';
+                const base64 = await legacyFs.readAsStringAsync(uri, { encoding });
+                return base64ToBytes(base64);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    async delete(key) {
+        const { file, uri } = await this.resolveFileOrUri(key);
+        // Modern Expo File (>57/58)
+        if (file) {
+            try {
+                if (file.exists && typeof file.delete === 'function') {
+                    file.delete();
+                }
+                return;
+            }
+            catch {
+                return;
+            }
+        }
+        // Legacy FileSystem API
+        const { legacyFs } = await this.resolveClasses();
+        if (legacyFs && typeof legacyFs.deleteAsync === 'function') {
+            try {
+                await legacyFs.deleteAsync(uri, { idempotent: true });
+            }
+            catch { }
+        }
+    }
+    async exists(key) {
+        const { file, uri } = await this.resolveFileOrUri(key);
+        // Modern Expo File (>57/58)
+        if (file) {
+            try {
+                return Boolean(file.exists);
+            }
+            catch {
+                return false;
+            }
+        }
+        // Legacy FileSystem API
+        const { legacyFs } = await this.resolveClasses();
+        if (legacyFs && typeof legacyFs.getInfoAsync === 'function') {
+            try {
+                const info = await legacyFs.getInfoAsync(uri);
+                return Boolean(info.exists);
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    async getSize(key) {
+        const { file, uri } = await this.resolveFileOrUri(key);
+        // Modern Expo File (>57/58)
+        if (file) {
+            try {
+                if (!file.exists)
+                    return 0;
+                if (typeof file.size === 'number')
+                    return file.size;
+                if (typeof file.info === 'function') {
+                    const info = file.info();
+                    return info?.size ?? 0;
+                }
+            }
+            catch {
+                return 0;
+            }
+        }
+        // Legacy FileSystem API
+        const { legacyFs } = await this.resolveClasses();
+        if (legacyFs && typeof legacyFs.getInfoAsync === 'function') {
+            try {
+                const info = await legacyFs.getInfoAsync(uri, { size: true });
+                return info.size ?? 0;
+            }
+            catch {
+                return 0;
+            }
+        }
+        return 0;
+    }
+    /**
+     * Fast file copy from an existing local URI (e.g. from expo-image-picker or expo-document-picker)
+     * into local-lite managed storage without reading entire file contents into memory.
+     */
+    async copyFrom(sourceUri, key) {
+        const { file, uri } = await this.resolveFileOrUri(key);
+        const { FileClass, legacyFs } = await this.resolveClasses();
+        // Modern Expo File (>57/58)
+        if (file && FileClass) {
+            try {
+                const srcFile = new FileClass(sourceUri);
+                if (srcFile.exists && typeof srcFile.copy === 'function') {
+                    if (file.parentDirectory && !file.parentDirectory.exists) {
+                        file.parentDirectory.create({ idempotent: true });
+                    }
+                    await srcFile.copy(file);
+                    return file.uri;
+                }
+            }
+            catch { }
+        }
+        // Legacy FileSystem API
+        if (legacyFs && typeof legacyFs.copyAsync === 'function') {
+            await this.ensureDirectory(uri);
+            await legacyFs.copyAsync({ from: sourceUri, to: uri });
+            return uri;
+        }
+        // Fallback: read bytes and write
+        if (legacyFs && typeof legacyFs.readAsStringAsync === 'function') {
+            const encoding = legacyFs.EncodingType?.Base64 ?? 'base64';
+            const content = await legacyFs.readAsStringAsync(sourceUri, { encoding });
+            await this.write(key, base64ToBytes(content));
+            return uri;
+        }
+        return uri;
+    }
+    /**
+     * Downloads a remote URL directly to the destination key on disk.
+     */
+    async downloadFrom(remoteUrl, key) {
+        const { file, uri } = await this.resolveFileOrUri(key);
+        const { FileClass, legacyFs } = await this.resolveClasses();
+        // Modern Expo File (>57/58)
+        if (file && FileClass && typeof FileClass.downloadFileAsync === 'function') {
+            try {
+                if (file.parentDirectory && !file.parentDirectory.exists) {
+                    file.parentDirectory.create({ idempotent: true });
+                }
+                await FileClass.downloadFileAsync(remoteUrl, file, { idempotent: true });
+                return file.uri;
+            }
+            catch { }
+        }
+        // Legacy FileSystem API
+        if (legacyFs && typeof legacyFs.downloadAsync === 'function') {
+            await this.ensureDirectory(uri);
+            const res = await legacyFs.downloadAsync(remoteUrl, uri);
+            return res.uri;
+        }
+        // Universal fetch fallback
+        const response = await fetch(remoteUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to download file from "${remoteUrl}": ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return await this.write(key, new Uint8Array(arrayBuffer));
+    }
+}
+exports.ExpoFileDriver = ExpoFileDriver;

package/dist/storage/factory.d.ts

@@ -0,0 +1,16 @@
+import { RemoteStorageUploader, StorageProviderType } from './types.js';
+import { SupabaseStorageUploaderOptions } from './supabase.js';
+import { ConvexStorageUploaderOptions } from './convex.js';
+import { FirebaseStorageUploaderOptions } from './firebase.js';
+export type UnifiedStorageOptions = ({
+    provider: 'supabase';
+} & SupabaseStorageUploaderOptions) | ({
+    provider: 'convex';
+} & ConvexStorageUploaderOptions) | ({
+    provider: 'firebase';
+} & FirebaseStorageUploaderOptions);
+/**
+ * Universal factory function to create a remote storage uploader for any supported provider:
+ * 'supabase', 'convex', or 'firebase'.
+ */
+export declare function createStorageUploader(provider: StorageProviderType, client: any, options?: any): RemoteStorageUploader;

package/dist/storage/factory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStorageUploader = createStorageUploader;
+const supabase_js_1 = require("./supabase.js");
+const convex_js_1 = require("./convex.js");
+const firebase_js_1 = require("./firebase.js");
+/**
+ * Universal factory function to create a remote storage uploader for any supported provider:
+ * 'supabase', 'convex', or 'firebase'.
+ */
+function createStorageUploader(provider, client, options = {}) {
+    switch (provider) {
+        case 'supabase':
+            return (0, supabase_js_1.createSupabaseStorageUploader)(client, options);
+        case 'convex':
+            return (0, convex_js_1.createConvexStorageUploader)(client, options);
+        case 'firebase':
+            return (0, firebase_js_1.createFirebaseStorageUploader)(client, options);
+        default:
+            throw new Error(`Unsupported storage provider "${provider}". Supported providers: "supabase", "convex", "firebase".`);
+    }
+}

package/dist/storage/firebase.d.ts

@@ -0,0 +1,44 @@
+import { BlobRecord, RemoteStorageUploader } from './types.js';
+export interface FirebaseStorageModule {
+    ref?: (storage: any, path: string) => any;
+    uploadBytes?: (ref: any, data: Uint8Array | Blob | ArrayBuffer, metadata?: any) => Promise<any>;
+    getDownloadURL?: (ref: any) => Promise<string>;
+    deleteObject?: (ref: any) => Promise<void>;
+}
+export interface FirebaseStorageUploaderOptions {
+    /**
+     * Optional bucket name or gs:// bucket URL.
+     */
+    bucket?: string;
+    /**
+     * Base folder or path prefix in Firebase Storage (e.g. 'media/').
+     */
+    basePath?: string;
+    /**
+     * Custom path transformation function.
+     * Default: `${basePath}/${key}`
+     */
+    pathTransform?: (key: string, blob?: BlobRecord) => string;
+    /**
+     * Optional reference to modular `firebase/storage` functions
+     * (e.g. `import * as storageModule from 'firebase/storage'`).
+     */
+    storageModule?: FirebaseStorageModule;
+    /**
+     * Optional custom metadata attached to uploaded blobs.
+     */
+    customMetadata?: Record<string, string> | ((blob: BlobRecord) => Record<string, string>);
+    /**
+     * Cache control HTTP header (e.g. 'public, max-age=31536000').
+     */
+    cacheControl?: string;
+}
+export interface FirebaseStorageUploaderInstance extends RemoteStorageUploader {
+    getDownloadUrl(keyOrPath: string): Promise<string>;
+    delete(keyOrPath: string): Promise<void>;
+}
+/**
+ * Creates a RemoteStorageUploader that syncs binary files to Firebase Cloud Storage.
+ * Supports both Firebase v9+ modular SDK and v8/compat SDKs.
+ */
+export declare function createFirebaseStorageUploader(storageOrApp: any, options?: FirebaseStorageUploaderOptions): FirebaseStorageUploaderInstance;

package/dist/storage/firebase.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFirebaseStorageUploader = createFirebaseStorageUploader;
+/**
+ * Creates a RemoteStorageUploader that syncs binary files to Firebase Cloud Storage.
+ * Supports both Firebase v9+ modular SDK and v8/compat SDKs.
+ */
+function createFirebaseStorageUploader(storageOrApp, options = {}) {
+    if (!storageOrApp) {
+        throw new Error('Firebase Storage instance, app, or modular client must be provided.');
+    }
+    // Determine storage instance
+    let storageInstance = storageOrApp;
+    if (typeof storageOrApp.storage === 'function') {
+        // FirebaseApp compat
+        storageInstance = storageOrApp.storage(options.bucket);
+    }
+    const mod = options.storageModule || {};
+    const resolveRemotePath = (key, blob) => {
+        if (options.pathTransform) {
+            return options.pathTransform(key, blob);
+        }
+        const cleanKey = key.replace(/^\/+/, '');
+        if (options.basePath) {
+            const cleanBase = options.basePath.replace(/^\/+|\/+$/g, '');
+            return `${cleanBase}/${cleanKey}`;
+        }
+        return cleanKey;
+    };
+    const getRef = (path) => {
+        // 1. Modular SDK ref(storage, path)
+        if (typeof mod.ref === 'function') {
+            return mod.ref(storageInstance, path);
+        }
+        // 2. Storage instance ref(path) method
+        if (typeof storageInstance.ref === 'function') {
+            return storageInstance.ref(path);
+        }
+        // 3. Storage instance from bucket
+        if (typeof storageInstance.bucket === 'function') {
+            const b = storageInstance.bucket(options.bucket);
+            return typeof b.file === 'function' ? b.file(path) : b;
+        }
+        throw new Error('Cannot resolve Firebase Storage reference. Pass storageModule ({ ref, uploadBytes, getDownloadURL }) or a FirebaseStorage instance.');
+    };
+    return {
+        async upload(blob, data) {
+            const remotePath = resolveRemotePath(blob.key, blob);
+            const fileRef = getRef(remotePath);
+            const metadata = {
+                contentType: blob.mimeType || 'application/octet-stream',
+            };
+            if (options.cacheControl) {
+                metadata.cacheControl = options.cacheControl;
+            }
+            if (options.customMetadata) {
+                const extra = typeof options.customMetadata === 'function'
+                    ? options.customMetadata(blob)
+                    : options.customMetadata;
+                metadata.customMetadata = extra;
+            }
+            // Method A: Modular SDK uploadBytes
+            if (typeof mod.uploadBytes === 'function') {
+                await mod.uploadBytes(fileRef, data, metadata);
+                let remoteUrl = remotePath;
+                if (typeof mod.getDownloadURL === 'function') {
+                    remoteUrl = await mod.getDownloadURL(fileRef);
+                }
+                return { remoteUrl, metadata };
+            }
+            // Method B: Compat put() or upload()
+            if (typeof fileRef.put === 'function') {
+                const snapshot = await fileRef.put(data, metadata);
+                let remoteUrl;
+                if (typeof snapshot?.ref?.getDownloadURL === 'function') {
+                    remoteUrl = await snapshot.ref.getDownloadURL();
+                }
+                else if (typeof fileRef.getDownloadURL === 'function') {
+                    remoteUrl = await fileRef.getDownloadURL();
+                }
+                else {
+                    remoteUrl = remotePath;
+                }
+                return { remoteUrl, metadata };
+            }
+            // Method C: GCS admin save()
+            if (typeof fileRef.save === 'function') {
+                await fileRef.save(Buffer.isBuffer(data) ? data : Buffer.from(data), {
+                    contentType: metadata.contentType,
+                    metadata: metadata.customMetadata,
+                });
+                let remoteUrl = remotePath;
+                if (typeof fileRef.getSignedUrl === 'function') {
+                    const [url] = await fileRef.getSignedUrl({
+                        action: 'read',
+                        expires: Date.now() + 86400 * 1000,
+                    });
+                    remoteUrl = url;
+                }
+                return { remoteUrl, metadata };
+            }
+            throw new Error('Unsupported Firebase Storage client: missing uploadBytes, put, or save method.');
+        },
+        async getDownloadUrl(keyOrPath) {
+            const remotePath = resolveRemotePath(keyOrPath);
+            const fileRef = getRef(remotePath);
+            if (typeof mod.getDownloadURL === 'function') {
+                return await mod.getDownloadURL(fileRef);
+            }
+            if (typeof fileRef.getDownloadURL === 'function') {
+                return await fileRef.getDownloadURL();
+            }
+            if (typeof fileRef.getSignedUrl === 'function') {
+                const [url] = await fileRef.getSignedUrl({
+                    action: 'read',
+                    expires: Date.now() + 86400 * 1000,
+                });
+                return url;
+            }
+            return remotePath;
+        },
+        async delete(keyOrPath) {
+            const remotePath = resolveRemotePath(keyOrPath);
+            const fileRef = getRef(remotePath);
+            if (typeof mod.deleteObject === 'function') {
+                await mod.deleteObject(fileRef);
+                return;
+            }
+            if (typeof fileRef.delete === 'function') {
+                await fileRef.delete();
+                return;
+            }
+        },
+    };
+}

package/dist/storage/index.d.ts

@@ -2,3 +2,8 @@ export * from './types.js';
 export * from './driver.js';
 export * from './store.js';
 export * from './manager.js';
+export * from './expo.js';
+export * from './supabase.js';
+export * from './convex.js';
+export * from './firebase.js';
+export * from './factory.js';

package/dist/storage/index.js

@@ -18,3 +18,8 @@ __exportStar(require("./types.js"), exports);
 __exportStar(require("./driver.js"), exports);
 __exportStar(require("./store.js"), exports);
 __exportStar(require("./manager.js"), exports);
+__exportStar(require("./expo.js"), exports);
+__exportStar(require("./supabase.js"), exports);
+__exportStar(require("./convex.js"), exports);
+__exportStar(require("./firebase.js"), exports);
+__exportStar(require("./factory.js"), exports);

package/dist/storage/manager.d.ts

@@ -6,6 +6,7 @@ export declare class BlobStorageManager {
     private uploader?;
     private network?;
     private tableName;
+    private deleteRemoteOnDelete;
     constructor(db: DBExecutable, options?: BlobStorageManagerOptions);
     initialize(): Promise<void>;
     setDriver(driver: FileDriver): void;
@@ -38,6 +39,25 @@ export declare class BlobStorageManager {
      * Deletes the blob binary and metadata record.
      */
     delete(key: string): Promise<void>;
+    /**
+     * Retrieves the remote download/serving URL for a stored blob key.
+     */
+    getDownloadUrl(key: string): Promise<string | null>;
+    /**
+     * Retrieves the local file path or URI (e.g. file:///... on mobile) for a stored blob key.
+     * Ideal for React Native <Image source={{ uri }} /> without loading bytes into JS memory.
+     */
+    getLocalUri(key: string): Promise<string | null>;
+    /**
+     * Directly imports a file from a local filesystem URI (e.g. expo-image-picker or expo-document-picker)
+     * into local-lite managed storage without having to manually read and encode byte arrays in memory.
+     */
+    saveFromUri(key: string, sourceUri: string, options?: SaveBlobOptions): Promise<BlobRecord>;
+    /**
+     * Downloads a remote asset (e.g. from Supabase Storage) and saves it to local disk.
+     * Caches metadata with status 'UPLOADED'.
+     */
+    download(key: string, remoteUrl: string, options?: SaveBlobOptions): Promise<BlobRecord>;
     /**
      * Flushes and syncs pending or failed uploads to the remote storage uploader.
      */