react-native-buffered-blob 1.0.0

package/ios/HandleTypes.m

@@ -0,0 +1,333 @@
+#import "HandleTypes.h"
+
+// ──────────────────────────────────────────────────────────────────────
+#pragma mark - ReaderHandleIOS
+// ──────────────────────────────────────────────────────────────────────
+
+@implementation ReaderHandleIOS {
+  NSLock *_lock;
+  int64_t _bytesReadBacking;
+  BOOL _isEOFBacking;
+  BOOL _isClosedBacking;
+}
+
+static NSInteger _readerNextId = 0;
+static NSLock *_readerIdLock = nil;
+
++ (void)initialize {
+  if (self == [ReaderHandleIOS class]) {
+    _readerIdLock = [NSLock new];
+  }
+}
+
++ (NSInteger)nextUniqueId {
+  [_readerIdLock lock];
+  NSInteger uid = ++_readerNextId;
+  [_readerIdLock unlock];
+  return uid;
+}
+
+- (nullable instancetype)initWithPath:(NSString *)path
+                           bufferSize:(NSInteger)bufferSize
+                                error:(NSError **)error {
+  self = [super init];
+  if (!self) return nil;
+
+  NSInputStream *stream = [NSInputStream inputStreamWithFileAtPath:path];
+  if (!stream) {
+    if (error) {
+      *error = [NSError errorWithDomain:@"BufferedBlob" code:1
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"[FILE_NOT_FOUND] Could not open file: %@", path]}];
+    }
+    return nil;
+  }
+
+  _inputStream = stream;
+  _bufferSize = bufferSize;
+  _lock = [NSLock new];
+  _bytesReadBacking = 0;
+  _isEOFBacking = NO;
+  _isClosedBacking = NO;
+
+  NSString *label = [NSString stringWithFormat:@"com.bufferedblob.reader.%ld", (long)[ReaderHandleIOS nextUniqueId]];
+  _queue = dispatch_queue_create(label.UTF8String, DISPATCH_QUEUE_SERIAL);
+  dispatch_set_target_queue(_queue, dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0));
+
+  // Get file size
+  NSDictionary *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:path error:error];
+  if (!attrs) return nil;
+  _fileSize = [attrs[NSFileSize] longLongValue];
+
+  [stream open];
+  if (stream.streamStatus == NSStreamStatusError) {
+    [stream close];
+    if (error) {
+      *error = [NSError errorWithDomain:@"BufferedBlob" code:1
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"[FILE_NOT_FOUND] Failed to open stream: %@", path]}];
+    }
+    return nil;
+  }
+
+  return self;
+}
+
+- (int64_t)bytesRead {
+  [_lock lock];
+  int64_t val = _bytesReadBacking;
+  [_lock unlock];
+  return val;
+}
+
+- (void)setBytesRead:(int64_t)bytesRead {
+  [_lock lock];
+  _bytesReadBacking = bytesRead;
+  [_lock unlock];
+}
+
+- (BOOL)isEOF {
+  [_lock lock];
+  BOOL val = _isEOFBacking;
+  [_lock unlock];
+  return val;
+}
+
+- (void)setIsEOF:(BOOL)isEOF {
+  [_lock lock];
+  _isEOFBacking = isEOF;
+  [_lock unlock];
+}
+
+- (BOOL)isClosed {
+  [_lock lock];
+  BOOL val = _isClosedBacking;
+  [_lock unlock];
+  return val;
+}
+
+- (void)setIsClosed:(BOOL)isClosed {
+  [_lock lock];
+  _isClosedBacking = isClosed;
+  [_lock unlock];
+}
+
+- (void)closeHandle {
+  [_lock lock];
+  if (_isClosedBacking) {
+    [_lock unlock];
+    return;
+  }
+  _isClosedBacking = YES;
+  NSInputStream *stream = _inputStream;
+  [_lock unlock];
+  // Dispatch stream close to the serial queue so it runs AFTER
+  // all pending I/O blocks have drained.
+  dispatch_async(_queue, ^{
+    [stream close];
+  });
+}
+
+- (void)dealloc {
+  [self closeHandle];
+}
+
+@end
+
+// ──────────────────────────────────────────────────────────────────────
+#pragma mark - WriterHandleIOS
+// ──────────────────────────────────────────────────────────────────────
+
+@implementation WriterHandleIOS {
+  NSLock *_lock;
+  int64_t _bytesWrittenBacking;
+  BOOL _isClosedBacking;
+}
+
+static NSInteger _writerNextId = 0;
+static NSLock *_writerIdLock = nil;
+
++ (void)initialize {
+  if (self == [WriterHandleIOS class]) {
+    _writerIdLock = [NSLock new];
+  }
+}
+
++ (NSInteger)nextUniqueId {
+  [_writerIdLock lock];
+  NSInteger uid = ++_writerNextId;
+  [_writerIdLock unlock];
+  return uid;
+}
+
+- (nullable instancetype)initWithPath:(NSString *)path
+                               append:(BOOL)append
+                                error:(NSError **)error {
+  self = [super init];
+  if (!self) return nil;
+
+  NSOutputStream *stream = [NSOutputStream outputStreamToFileAtPath:path append:append];
+  if (!stream) {
+    if (error) {
+      *error = [NSError errorWithDomain:@"BufferedBlob" code:1
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"[FILE_NOT_FOUND] Could not open file for writing: %@", path]}];
+    }
+    return nil;
+  }
+
+  _outputStream = stream;
+  _lock = [NSLock new];
+  _bytesWrittenBacking = 0;
+  _isClosedBacking = NO;
+
+  NSString *label = [NSString stringWithFormat:@"com.bufferedblob.writer.%ld", (long)[WriterHandleIOS nextUniqueId]];
+  _queue = dispatch_queue_create(label.UTF8String, DISPATCH_QUEUE_SERIAL);
+  dispatch_set_target_queue(_queue, dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0));
+
+  [stream open];
+  if (stream.streamStatus == NSStreamStatusError) {
+    [stream close];
+    if (error) {
+      *error = [NSError errorWithDomain:@"BufferedBlob" code:1
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"[FILE_NOT_FOUND] Failed to open write stream: %@", path]}];
+    }
+    return nil;
+  }
+
+  return self;
+}
+
+- (int64_t)bytesWritten {
+  [_lock lock];
+  int64_t val = _bytesWrittenBacking;
+  [_lock unlock];
+  return val;
+}
+
+- (void)setBytesWritten:(int64_t)bytesWritten {
+  [_lock lock];
+  _bytesWrittenBacking = bytesWritten;
+  [_lock unlock];
+}
+
+- (BOOL)isClosed {
+  [_lock lock];
+  BOOL val = _isClosedBacking;
+  [_lock unlock];
+  return val;
+}
+
+- (void)setIsClosed:(BOOL)isClosed {
+  [_lock lock];
+  _isClosedBacking = isClosed;
+  [_lock unlock];
+}
+
+- (void)closeHandle {
+  [_lock lock];
+  if (_isClosedBacking) {
+    [_lock unlock];
+    return;
+  }
+  _isClosedBacking = YES;
+  NSOutputStream *stream = _outputStream;
+  [_lock unlock];
+  dispatch_async(_queue, ^{
+    [stream close];
+  });
+}
+
+- (void)dealloc {
+  [self closeHandle];
+}
+
+@end
+
+// ──────────────────────────────────────────────────────────────────────
+#pragma mark - DownloaderHandleIOS
+// ──────────────────────────────────────────────────────────────────────
+
+@implementation DownloaderHandleIOS {
+  NSLock *_lock;
+  BOOL _isCancelledBacking;
+  NSURLSession *_session;
+  NSURLSessionTask *_task;
+}
+
+static NSInteger _downloaderNextId = 0;
+static NSLock *_downloaderIdLock = nil;
+
++ (void)initialize {
+  if (self == [DownloaderHandleIOS class]) {
+    _downloaderIdLock = [NSLock new];
+  }
+}
+
++ (NSInteger)nextUniqueId {
+  [_downloaderIdLock lock];
+  NSInteger uid = ++_downloaderNextId;
+  [_downloaderIdLock unlock];
+  return uid;
+}
+
+- (instancetype)initWithURL:(NSString *)url
+                   destPath:(NSString *)destPath
+                    headers:(NSDictionary<NSString *, NSString *> *)headers {
+  self = [super init];
+  if (self) {
+    _url = [url copy];
+    _destPath = [destPath copy];
+    _headers = [headers copy];
+    _lock = [NSLock new];
+    _isCancelledBacking = NO;
+
+    NSString *label = [NSString stringWithFormat:@"com.bufferedblob.downloader.%ld", (long)[DownloaderHandleIOS nextUniqueId]];
+    _queue = dispatch_queue_create(label.UTF8String, DISPATCH_QUEUE_SERIAL);
+    dispatch_set_target_queue(_queue, dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0));
+  }
+  return self;
+}
+
+- (BOOL)isCancelled {
+  [_lock lock];
+  BOOL val = _isCancelledBacking;
+  [_lock unlock];
+  return val;
+}
+
+- (void)setIsCancelled:(BOOL)isCancelled {
+  [_lock lock];
+  _isCancelledBacking = isCancelled;
+  [_lock unlock];
+}
+
+- (void)storeSession:(NSURLSession *)session task:(NSURLSessionTask *)task {
+  [_lock lock];
+  _session = session;
+  _task = task;
+  [_lock unlock];
+}
+
+- (void)cancel {
+  [_lock lock];
+  if (_isCancelledBacking) {
+    [_lock unlock];
+    return;
+  }
+  _isCancelledBacking = YES;
+  NSURLSession *session = _session;
+  NSURLSessionTask *task = _task;
+  [_lock unlock];
+
+  // Cancel outside the lock to avoid potential deadlock with delegate callbacks
+  [task cancel];
+  [session invalidateAndCancel];
+}
+
+- (void)closeHandle {
+  [self cancel];
+}
+
+@end

package/lib/module/AGENTS.md

@@ -0,0 +1,70 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-02-15 -->
+
+# src/
+
+TypeScript API layer: Turbo Module spec, native module interface, streaming proxy, and high-level file operations.
+
+## Purpose
+
+Provides the JavaScript interface to the native BufferedBlob module:
+- **Turbo Module specification** (NativeBufferedBlob.ts) — codegen input for handle factories and FS ops
+- **Streaming proxy** (module.ts) — JSI HostObject accessor, install() wiring
+- **Type wrappers** (types.ts) — BlobReader/BlobWriter interfaces with property proxying
+- **Error handling** (errors.ts) — ErrorCode enum and wrapError() utility
+- **Paths** (paths.ts) — Dirs constants and path utilities
+
+## Key Files
+
+| File | Description |
+|------|-------------|
+| `NativeBufferedBlob.ts` | Turbo Module spec: install(), handle factories, FS ops, hashFile. Codegen input. |
+| `module.ts` | NativeModule (TurboModuleRegistry), StreamingProxy interface, getStreamingProxy() |
+| `types.ts` | HashAlgorithm, FileType enums; FileInfo, BlobReader, BlobWriter interfaces; wrapReader/wrapWriter |
+| `errors.ts` | BlobError class, ErrorCode enum, wrapError() helper |
+| `paths.ts` | Dirs constants (documentDir, cacheDir, tempDir, downloadDir); join(), dirname(), basename(), extname() |
+| `index.ts` | Barrel exports for public API |
+
+## Subdirectories
+
+| Directory | Purpose |
+|-----------|---------|
+| `api/` | High-level file operations, download, hashing, streaming wrappers |
+
+## For AI Agents
+
+### Working In This Directory
+
+1. **Turbo Module spec**: Changes to `NativeBufferedBlob.ts` trigger codegen. After editing, run `yarn prepare` to regenerate native module headers.
+2. **Streaming proxy access**: `getStreamingProxy()` returns the JSI HostObject installed by native code. Always call `NativeModule.install()` first (done in module.ts).
+3. **Handle pattern**: Turbo Module returns numeric handles. Pass to streaming proxy methods. Always close handles to release native resources.
+4. **Type safety**: Use strict TypeScript. BlobReader/BlobWriter are interface wrappers; do NOT spread HostObject properties (getters would be lost).
+5. **Error propagation**: Catch errors from native calls; use `wrapError()` to normalize error messages.
+
+### Testing Requirements
+
+- **Type checking**: Verify no TypeScript errors in strict mode
+- **Module loading**: Verify `install()` succeeds and JSI HostObject is wired
+- **Handle cleanup**: Verify handles are closed; no dangling native resources
+- **Error cases**: Test file not found, invalid paths, invalid buffer sizes, cancelled operations
+
+### Common Patterns
+
+1. **Create reader**: `const handle = NativeModule.openRead(path, bufferSize)` -> `const reader = wrapReader(handle, proxy)` -> `reader.readNextChunk()` -> `reader.close()`
+2. **Create writer**: `const handle = NativeModule.openWrite(path, append)` -> `const writer = wrapWriter(handle, proxy)` -> `writer.write(data)` -> `writer.flush()` -> `writer.close()`
+3. **File ops**: `exists()`, `stat()`, `mkdir()`, `ls()`, `cp()`, `mv()`, `unlink()` all return Promises
+4. **Hash file**: `hashFile(path, 'sha256' | 'md5')` streams file without loading into memory
+5. **Download with progress**: Use `download({ url, destPath, onProgress })` API; streaming proxy handles details
+
+## Dependencies
+
+### Internal
+- Turbo Module spec generated from `NativeBufferedBlob.ts` at build time
+- `module.ts` calls `install()` on first import (side effect)
+- `api/` layer depends on NativeModule and getStreamingProxy()
+
+### External
+- **React Native** >= 0.76.0 (TurboModuleRegistry, JSI)
+- **TypeScript** ^5.9.2 (type checking, codegen)
+
+<!-- MANUAL: Document API changes, Turbo Module version bumps, deprecations -->

package/lib/module/NativeBufferedBlob.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('BufferedBlob');
+//# sourceMappingURL=NativeBufferedBlob.js.map

package/lib/module/NativeBufferedBlob.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeBufferedBlob.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAoDlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,cAAc,CAAC","ignoreList":[]}

package/lib/module/api/AGENTS.md

@@ -0,0 +1,62 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-02-15 -->
+
+# src/api/
+
+High-level convenience APIs for file operations, streaming, hashing, and downloads.
+
+## Purpose
+
+Provide idiomatic TypeScript wrappers around Turbo Module calls and JSI HostObject streaming:
+- **File operations**: exists, stat, mkdir, ls, cp, mv, unlink
+- **Streaming**: readFile (deprecated), writeFile (deprecated)
+- **Hashing**: hashFile with streaming (SHA256, MD5)
+- **Downloads**: download with progress callback
+
+## Key Files
+
+| File | Description |
+|------|-------------|
+| `fileOps.ts` | FS operations: exists, stat, mkdir, ls, cp, mv, unlink. All return Promises. |
+| `hash.ts` | hashFile(path, algorithm) → Promise<string>. Streams file; supports 'sha256', 'md5'. |
+| `download.ts` | download(options) → Promise<void>. Returns DownloadOptions interface, handles progress callback. |
+| `readFile.ts` | DEPRECATED: createReader(path, bufferSize) → BlobReader. Use openRead() + wrapReader() directly. |
+| `writeFile.ts` | DEPRECATED: createWriter(path, append) → BlobWriter. Use openWrite() + wrapWriter() directly. |
+
+## For AI Agents
+
+### Working In This Directory
+
+1. **File operations**: All async. Return Promises that resolve/reject with platform-specific error codes.
+2. **Streaming shortcuts**: readFile/writeFile are deprecated convenience wrappers. New code should use `openRead()` + `wrapReader()` directly for explicit handle management.
+3. **Download pattern**: `download()` creates handle, calls JSI streaming startDownload, manages progress callback, cleans up handle in finally block.
+4. **Error handling**: Use `wrapError()` from parent module to normalize native errors.
+5. **Handle lifecycle**: Always close streaming handles (readFile/writeFile do this implicitly; direct handle usage requires explicit close).
+
+### Testing Requirements
+
+- **File ops**: Create temp files, test exists/stat/mkdir/ls/cp/mv/unlink
+- **Hashing**: Verify hash output against known digests (sha256, md5)
+- **Download**: Test with HTTP server, verify progress callback fires, verify file written
+- **Error cases**: Test file not found, permission denied, invalid paths, cancelled downloads
+
+### Common Patterns
+
+1. **Check file exists**: `const exists = await exists(path)`
+2. **Get file info**: `const info = await stat(path)` → {path, name, size, type, lastModified}
+3. **List directory**: `const files = await ls(dirPath)` → FileInfo[]
+4. **Copy file**: `await cp(srcPath, destPath)`
+5. **Hash file**: `const hash = await hashFile(path, 'sha256')`
+6. **Download with progress**: `await download({ url, destPath, headers: {}, onProgress: (p) => console.log(p.progress) })`
+
+## Dependencies
+
+### Internal
+- `../module.ts` — NativeModule, getStreamingProxy()
+- `../types.ts` — BlobReader, BlobWriter, FileInfo, DownloadProgress, HashAlgorithm
+- `../errors.ts` — wrapError()
+
+### External
+- **React Native** >= 0.76.0 (TurboModuleRegistry for NativeModule calls)
+
+<!-- MANUAL: Document deprecated APIs, migration guides for readFile/writeFile users -->

package/lib/module/api/download.js

@@ -0,0 +1,40 @@
+"use strict";
+
+import { NativeModule, getStreamingProxy } from "../module.js";
+import { wrapError } from "../errors.js";
+export function download(options) {
+  const {
+    url,
+    destPath,
+    headers = {},
+    onProgress
+  } = options;
+  try {
+    const handleId = NativeModule.createDownload(url, destPath, headers);
+    const streaming = getStreamingProxy();
+    const progressCallback = onProgress ? (bytesDownloaded, totalBytes, progress) => {
+      onProgress({
+        bytesDownloaded,
+        totalBytes,
+        progress
+      });
+    } : (_b, _t, _p) => {};
+    const promise = (async () => {
+      try {
+        await streaming.startDownload(handleId, progressCallback);
+      } finally {
+        NativeModule.closeHandle(handleId);
+      }
+    })();
+    const cancel = () => {
+      streaming.cancelDownload(handleId);
+    };
+    return {
+      promise,
+      cancel
+    };
+  } catch (e) {
+    throw wrapError(e, destPath);
+  }
+}
+//# sourceMappingURL=download.js.map

package/lib/module/api/download.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModule","getStreamingProxy","wrapError","download","options","url","destPath","headers","onProgress","handleId","createDownload","streaming","progressCallback","bytesDownloaded","totalBytes","progress","_b","_t","_p","promise","startDownload","closeHandle","cancel","cancelDownload","e"],"sourceRoot":"../../../src","sources":["api/download.ts"],"mappings":";;AAAA,SAASA,YAAY,EAAEC,iBAAiB,QAAQ,cAAW;AAC3D,SAASC,SAAS,QAAQ,cAAW;AAerC,OAAO,SAASC,QAAQA,CAACC,OAAwB,EAAkB;EACjE,MAAM;IAAEC,GAAG;IAAEC,QAAQ;IAAEC,OAAO,GAAG,CAAC,CAAC;IAAEC;EAAW,CAAC,GAAGJ,OAAO;EAE3D,IAAI;IACF,MAAMK,QAAQ,GAAGT,YAAY,CAACU,cAAc,CAACL,GAAG,EAAEC,QAAQ,EAAEC,OAAO,CAAC;IACpE,MAAMI,SAAS,GAAGV,iBAAiB,CAAC,CAAC;IAErC,MAAMW,gBAAgB,GAAGJ,UAAU,GAC/B,CAACK,eAAuB,EAAEC,UAAkB,EAAEC,QAAgB,KAAK;MACjEP,UAAU,CAAC;QAAEK,eAAe;QAAEC,UAAU;QAAEC;MAAS,CAAC,CAAC;IACvD,CAAC,GACD,CAACC,EAAU,EAAEC,EAAU,EAAEC,EAAU,KAAK,CAAC,CAAC;IAE9C,MAAMC,OAAO,GAAG,CAAC,YAAY;MAC3B,IAAI;QACF,MAAMR,SAAS,CAACS,aAAa,CAACX,QAAQ,EAAEG,gBAAgB,CAAC;MAC3D,CAAC,SAAS;QACRZ,YAAY,CAACqB,WAAW,CAACZ,QAAQ,CAAC;MACpC;IACF,CAAC,EAAE,CAAC;IAEJ,MAAMa,MAAM,GAAGA,CAAA,KAAM;MACnBX,SAAS,CAACY,cAAc,CAACd,QAAQ,CAAC;IACpC,CAAC;IAED,OAAO;MAAEU,OAAO;MAAEG;IAAO,CAAC;EAC5B,CAAC,CAAC,OAAOE,CAAC,EAAE;IACV,MAAMtB,SAAS,CAACsB,CAAC,EAAElB,QAAQ,CAAC;EAC9B;AACF","ignoreList":[]}

package/lib/module/api/fileOps.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import { NativeModule } from "../module.js";
+import { wrapError } from "../errors.js";
+import { FileType } from "../types.js";
+function toFileType(raw) {
+  const values = Object.values(FileType);
+  return values.includes(raw) ? raw : FileType.UNKNOWN;
+}
+function mapFileInfo(raw) {
+  return {
+    path: raw.path,
+    name: raw.name,
+    size: raw.size,
+    type: toFileType(raw.type),
+    lastModified: raw.lastModified
+  };
+}
+export async function exists(path) {
+  try {
+    return await NativeModule.exists(path);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+export async function stat(path) {
+  try {
+    const raw = await NativeModule.stat(path);
+    return mapFileInfo(raw);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+export async function unlink(path) {
+  try {
+    await NativeModule.unlink(path);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+export async function mkdir(path) {
+  try {
+    await NativeModule.mkdir(path);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+export async function ls(path) {
+  try {
+    const rawList = await NativeModule.ls(path);
+    return rawList.map(mapFileInfo);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+export async function cp(srcPath, destPath) {
+  try {
+    await NativeModule.cp(srcPath, destPath);
+  } catch (e) {
+    throw wrapError(e, srcPath);
+  }
+}
+export async function mv(srcPath, destPath) {
+  try {
+    await NativeModule.mv(srcPath, destPath);
+  } catch (e) {
+    throw wrapError(e, srcPath);
+  }
+}
+//# sourceMappingURL=fileOps.js.map

package/lib/module/api/fileOps.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModule","wrapError","FileType","toFileType","raw","values","Object","includes","UNKNOWN","mapFileInfo","path","name","size","type","lastModified","exists","e","stat","unlink","mkdir","ls","rawList","map","cp","srcPath","destPath","mv"],"sourceRoot":"../../../src","sources":["api/fileOps.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,cAAW;AACxC,SAASC,SAAS,QAAQ,cAAW;AAErC,SAASC,QAAQ,QAAQ,aAAU;AAEnC,SAASC,UAAUA,CAACC,GAAW,EAAY;EACzC,MAAMC,MAAgB,GAAGC,MAAM,CAACD,MAAM,CAACH,QAAQ,CAAC;EAChD,OAAOG,MAAM,CAACE,QAAQ,CAACH,GAAG,CAAC,GAAIA,GAAG,GAAgBF,QAAQ,CAACM,OAAO;AACpE;AAEA,SAASC,WAAWA,CAACL,GAMpB,EAAY;EACX,OAAO;IACLM,IAAI,EAAEN,GAAG,CAACM,IAAI;IACdC,IAAI,EAAEP,GAAG,CAACO,IAAI;IACdC,IAAI,EAAER,GAAG,CAACQ,IAAI;IACdC,IAAI,EAAEV,UAAU,CAACC,GAAG,CAACS,IAAI,CAAC;IAC1BC,YAAY,EAAEV,GAAG,CAACU;EACpB,CAAC;AACH;AAEA,OAAO,eAAeC,MAAMA,CAACL,IAAY,EAAoB;EAC3D,IAAI;IACF,OAAO,MAAMV,YAAY,CAACe,MAAM,CAACL,IAAI,CAAC;EACxC,CAAC,CAAC,OAAOM,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAEN,IAAI,CAAC;EAC1B;AACF;AAEA,OAAO,eAAeO,IAAIA,CAACP,IAAY,EAAqB;EAC1D,IAAI;IACF,MAAMN,GAAG,GAAG,MAAMJ,YAAY,CAACiB,IAAI,CAACP,IAAI,CAAC;IACzC,OAAOD,WAAW,CAACL,GAAG,CAAC;EACzB,CAAC,CAAC,OAAOY,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAEN,IAAI,CAAC;EAC1B;AACF;AAEA,OAAO,eAAeQ,MAAMA,CAACR,IAAY,EAAiB;EACxD,IAAI;IACF,MAAMV,YAAY,CAACkB,MAAM,CAACR,IAAI,CAAC;EACjC,CAAC,CAAC,OAAOM,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAEN,IAAI,CAAC;EAC1B;AACF;AAEA,OAAO,eAAeS,KAAKA,CAACT,IAAY,EAAiB;EACvD,IAAI;IACF,MAAMV,YAAY,CAACmB,KAAK,CAACT,IAAI,CAAC;EAChC,CAAC,CAAC,OAAOM,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAEN,IAAI,CAAC;EAC1B;AACF;AAEA,OAAO,eAAeU,EAAEA,CAACV,IAAY,EAAuB;EAC1D,IAAI;IACF,MAAMW,OAAO,GAAG,MAAMrB,YAAY,CAACoB,EAAE,CAACV,IAAI,CAAC;IAC3C,OAAOW,OAAO,CAACC,GAAG,CAACb,WAAW,CAAC;EACjC,CAAC,CAAC,OAAOO,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAEN,IAAI,CAAC;EAC1B;AACF;AAEA,OAAO,eAAea,EAAEA,CAACC,OAAe,EAAEC,QAAgB,EAAiB;EACzE,IAAI;IACF,MAAMzB,YAAY,CAACuB,EAAE,CAACC,OAAO,EAAEC,QAAQ,CAAC;EAC1C,CAAC,CAAC,OAAOT,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAEQ,OAAO,CAAC;EAC7B;AACF;AAEA,OAAO,eAAeE,EAAEA,CAACF,OAAe,EAAEC,QAAgB,EAAiB;EACzE,IAAI;IACF,MAAMzB,YAAY,CAAC0B,EAAE,CAACF,OAAO,EAAEC,QAAQ,CAAC;EAC1C,CAAC,CAAC,OAAOT,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAEQ,OAAO,CAAC;EAC7B;AACF","ignoreList":[]}

package/lib/module/api/hash.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { NativeModule } from "../module.js";
+import { wrapError } from "../errors.js";
+import { HashAlgorithm } from "../types.js";
+export async function hashFile(path, algorithm = HashAlgorithm.SHA256) {
+  try {
+    return await NativeModule.hashFile(path, algorithm);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+//# sourceMappingURL=hash.js.map

package/lib/module/api/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModule","wrapError","HashAlgorithm","hashFile","path","algorithm","SHA256","e"],"sourceRoot":"../../../src","sources":["api/hash.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,cAAW;AACxC,SAASC,SAAS,QAAQ,cAAW;AACrC,SAASC,aAAa,QAAQ,aAAU;AAExC,OAAO,eAAeC,QAAQA,CAC5BC,IAAY,EACZC,SAAwB,GAAGH,aAAa,CAACI,MAAM,EAC9B;EACjB,IAAI;IACF,OAAO,MAAMN,YAAY,CAACG,QAAQ,CAACC,IAAI,EAAEC,SAAS,CAAC;EACrD,CAAC,CAAC,OAAOE,CAAC,EAAE;IACV,MAAMN,SAAS,CAACM,CAAC,EAAEH,IAAI,CAAC;EAC1B;AACF","ignoreList":[]}

package/lib/module/api/readFile.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { NativeModule, getStreamingProxy } from "../module.js";
+import { wrapError, BlobError, ErrorCode } from "../errors.js";
+import { wrapReader } from "../wrappers.js";
+const DEFAULT_BUFFER_SIZE = 65536; // 64KB
+
+export function createReader(path, bufferSize = DEFAULT_BUFFER_SIZE) {
+  try {
+    if (!Number.isFinite(bufferSize) || bufferSize < 4096 || bufferSize > 4194304) {
+      throw new BlobError(ErrorCode.INVALID_ARGUMENT, `bufferSize must be between 4096 and 4194304, got ${bufferSize}`, path);
+    }
+    const handleId = NativeModule.openRead(path, bufferSize);
+    if (handleId < 0) {
+      throw new BlobError(ErrorCode.IO_ERROR, 'Failed to open file for reading', path);
+    }
+    const streaming = getStreamingProxy();
+    return wrapReader(handleId, streaming);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+//# sourceMappingURL=readFile.js.map

package/lib/module/api/readFile.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModule","getStreamingProxy","wrapError","BlobError","ErrorCode","wrapReader","DEFAULT_BUFFER_SIZE","createReader","path","bufferSize","Number","isFinite","INVALID_ARGUMENT","handleId","openRead","IO_ERROR","streaming","e"],"sourceRoot":"../../../src","sources":["api/readFile.ts"],"mappings":";;AAAA,SAASA,YAAY,EAAEC,iBAAiB,QAAQ,cAAW;AAC3D,SAASC,SAAS,EAAEC,SAAS,EAAEC,SAAS,QAAQ,cAAW;AAC3D,SAASC,UAAU,QAAQ,gBAAa;AAGxC,MAAMC,mBAAmB,GAAG,KAAK,CAAC,CAAC;;AAEnC,OAAO,SAASC,YAAYA,CAC1BC,IAAY,EACZC,UAAkB,GAAGH,mBAAmB,EAC5B;EACZ,IAAI;IACF,IACE,CAACI,MAAM,CAACC,QAAQ,CAACF,UAAU,CAAC,IAC5BA,UAAU,GAAG,IAAI,IACjBA,UAAU,GAAG,OAAO,EACpB;MACA,MAAM,IAAIN,SAAS,CACjBC,SAAS,CAACQ,gBAAgB,EAC1B,oDAAoDH,UAAU,EAAE,EAChED,IACF,CAAC;IACH;IACA,MAAMK,QAAQ,GAAGb,YAAY,CAACc,QAAQ,CAACN,IAAI,EAAEC,UAAU,CAAC;IACxD,IAAII,QAAQ,GAAG,CAAC,EAAE;MAChB,MAAM,IAAIV,SAAS,CACjBC,SAAS,CAACW,QAAQ,EAClB,iCAAiC,EACjCP,IACF,CAAC;IACH;IACA,MAAMQ,SAAS,GAAGf,iBAAiB,CAAC,CAAC;IACrC,OAAOI,UAAU,CAACQ,QAAQ,EAAEG,SAAS,CAAC;EACxC,CAAC,CAAC,OAAOC,CAAC,EAAE;IACV,MAAMf,SAAS,CAACe,CAAC,EAAET,IAAI,CAAC;EAC1B;AACF","ignoreList":[]}

package/lib/module/api/writeFile.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { NativeModule, getStreamingProxy } from "../module.js";
+import { wrapError, BlobError, ErrorCode } from "../errors.js";
+import { wrapWriter } from "../wrappers.js";
+export function createWriter(path, append = false) {
+  try {
+    const handleId = NativeModule.openWrite(path, append);
+    if (handleId < 0) {
+      throw new BlobError(ErrorCode.IO_ERROR, 'Failed to open file for writing', path);
+    }
+    const streaming = getStreamingProxy();
+    return wrapWriter(handleId, streaming);
+  } catch (e) {
+    throw wrapError(e, path);
+  }
+}
+//# sourceMappingURL=writeFile.js.map

package/lib/module/api/writeFile.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModule","getStreamingProxy","wrapError","BlobError","ErrorCode","wrapWriter","createWriter","path","append","handleId","openWrite","IO_ERROR","streaming","e"],"sourceRoot":"../../../src","sources":["api/writeFile.ts"],"mappings":";;AAAA,SAASA,YAAY,EAAEC,iBAAiB,QAAQ,cAAW;AAC3D,SAASC,SAAS,EAAEC,SAAS,EAAEC,SAAS,QAAQ,cAAW;AAC3D,SAASC,UAAU,QAAQ,gBAAa;AAGxC,OAAO,SAASC,YAAYA,CAC1BC,IAAY,EACZC,MAAe,GAAG,KAAK,EACX;EACZ,IAAI;IACF,MAAMC,QAAQ,GAAGT,YAAY,CAACU,SAAS,CAACH,IAAI,EAAEC,MAAM,CAAC;IACrD,IAAIC,QAAQ,GAAG,CAAC,EAAE;MAChB,MAAM,IAAIN,SAAS,CACjBC,SAAS,CAACO,QAAQ,EAClB,iCAAiC,EACjCJ,IACF,CAAC;IACH;IACA,MAAMK,SAAS,GAAGX,iBAAiB,CAAC,CAAC;IACrC,OAAOI,UAAU,CAACI,QAAQ,EAAEG,SAAS,CAAC;EACxC,CAAC,CAAC,OAAOC,CAAC,EAAE;IACV,MAAMX,SAAS,CAACW,CAAC,EAAEN,IAAI,CAAC;EAC1B;AACF","ignoreList":[]}