@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/data-locks.test.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const SQLiteDB = require("better-sqlite3");
 const utils_1 = require("../utils");
 const data_locks_1 = require("./data-locks");
+const group_member_roles_1 = require("./group-member-roles");
 const sql_data_source_1 = require("./orm/sql.data-source");
 const types_1 = require("./orm/types");
-const group_member_roles_1 = require("./group-member-roles");
 class DBHarness {
     _db = null;
     get database() {
         if (!this._db) {
-            this._db = new SQLiteDB(':memory:');
-            this._db.pragma('journal_mode = WAL');
+            this._db = new SQLiteDB(":memory:");
+            this._db.pragma("journal_mode = WAL");
         }
         return this._db;
     }
@@ -32,8 +32,8 @@ class DBHarness {
 }
 // Mock peer device for testing
 class MockPeerDevice {
-    deviceId = 'mock-device';
-    userId = 'mock-user';
+    deviceId = "mock-device";
+    userId = "mock-user";
     role = group_member_roles_1.GroupMemberRole.Owner;
     connections = [];
     changes = [];
@@ -42,7 +42,7 @@ class MockPeerDevice {
             deviceId: `peer-${i}`,
             latencyMs: 50,
             errorRate: 0,
-            timestampLastApplied: Date.now()
+            timestampLastApplied: Date.now(),
         }));
     }
     async getNetworkInfo() {
@@ -59,11 +59,11 @@ class MockPeerDevice {
     async listChanges(query) {
         if (!query)
             return this.changes;
-        return this.changes.filter(change => change.tableName === query.tableName &&
+        return this.changes.filter((change) => change.tableName === query.tableName &&
             change.recordId === query.recordId &&
             change.op === query.op);
     }
-    async notifyOfChanges(deviceId, timestampLastApplied) {
+    async notifyOfChanges(_deviceId, _timestampLastApplied) {
         // Mock implementation
     }
     async downloadFileChunk(_chunkHash) {
@@ -77,10 +77,10 @@ class MockPeerDevice {
     addAcknowledgment(recordId, acknowledged) {
         this.changes.push({
             changeId: (0, utils_1.newid)(),
-            tableName: 'DataLocks',
+            tableName: "DataLocks",
             recordId,
-            op: 'set',
-            path: '/acknowledged',
+            op: "set",
+            path: "/acknowledged",
             value: acknowledged,
             createdAt: Date.now(),
             appliedAt: Date.now(),
@@ -91,14 +91,14 @@ class MockPeerDevice {
             deviceId: `peer-${i}`,
             latencyMs: 50,
             errorRate: 0,
-            timestampLastApplied: Date.now()
+            timestampLastApplied: Date.now(),
         }));
     }
-    sendDeviceMessage(message) {
-        throw new Error('Method not implemented.');
+    sendDeviceMessage(_message) {
+        throw new Error("Method not implemented.");
     }
 }
-describe('data-locks.ts', () => {
+describe("data-locks.ts", () => {
     const fiveMinutesMs = 5 * 60 * 1000;
     jest.setTimeout(fiveMinutesMs);
     let db;
@@ -106,30 +106,28 @@ describe('data-locks.ts', () => {
     let dataLocksTable;
     let mockPeerDevice;
     const dataLocksTableMetaData = {
-        name: 'DataLocks',
-        primaryKeyName: 'dataLockId',
-        description: 'Data locks table to track exclusive write access to records in other tables.',
+        name: "DataLocks",
+        primaryKeyName: "dataLockId",
+        description: "Data locks table to track exclusive write access to records in other tables.",
         fields: (0, types_1.schemaToFields)(data_locks_1.dataLockSchema),
-        indexes: [
-            { fields: ['recordId'] },
-        ],
+        indexes: [{ fields: ["recordId"] }],
     };
     beforeAll(async () => {
         db = new DBHarness();
         dataSource = new sql_data_source_1.SQLDataSource(db, dataLocksTableMetaData);
         const mockDataContextForRegistry = {
-            dataContextId: 'data-locks-test'
+            dataContextId: "data-locks-test",
         };
-        const { EventRegistry } = require('./orm/event-registry');
+        const { EventRegistry } = require("./orm/event-registry");
         const eventRegistry = new EventRegistry(mockDataContextForRegistry);
-        const mockDataContext = {
+        const _mockDataContext = {
             dataSourceFactory: () => dataSource,
-            eventRegistry: eventRegistry
+            eventRegistry: eventRegistry,
         };
         const deps = {
             dataSource,
             eventRegistry,
-            schema: data_locks_1.dataLockSchema
+            schema: data_locks_1.dataLockSchema,
         };
         dataLocksTable = new data_locks_1.DataLocksTable(dataLocksTableMetaData, deps);
         mockPeerDevice = new MockPeerDevice();
@@ -147,23 +145,23 @@ describe('data-locks.ts', () => {
         }
         mockPeerDevice.setConnectionCount(3);
     });
-    describe('DataLocksTable', () => {
-        describe('constructor', () => {
-            it('should create a DataLocksTable instance with default constants', () => {
+    describe("DataLocksTable", () => {
+        describe("constructor", () => {
+            it("should create a DataLocksTable instance with default constants", () => {
                 expect(dataLocksTable.DEFAULT_LOCK_TIME_MS).toBe(300_000); // 5 minutes
                 expect(dataLocksTable.DEFAULT_TIMEOUT_MS).toBe(20_000); // 20 seconds
                 expect(dataLocksTable.DEAD_PERIOD_MS).toBe(10_000); // 10 seconds
             });
-            it('should have peerDevice property', () => {
+            it("should have peerDevice property", () => {
                 expect(dataLocksTable.peerDevice).toBeDefined();
             });
         });
-        describe('getCurrentLock', () => {
-            it('should return undefined when no locks exist for recordId', async () => {
-                const result = await dataLocksTable.getCurrentLock('nonexistent-record');
+        describe("getCurrentLock", () => {
+            it("should return undefined when no locks exist for recordId", async () => {
+                const result = await dataLocksTable.getCurrentLock("nonexistent-record");
                 expect(result).toBeUndefined();
             });
-            it('should return undefined when only expired locks exist', async () => {
+            it("should return undefined when only expired locks exist", async () => {
                 const recordId = (0, utils_1.newid)();
                 const expiredLock = {
                     dataLockId: (0, utils_1.newid)(),
@@ -174,7 +172,7 @@ describe('data-locks.ts', () => {
                 const result = await dataLocksTable.getCurrentLock(recordId);
                 expect(result).toBeUndefined();
             });
-            it('should return the current valid lock', async () => {
+            it("should return the current valid lock", async () => {
                 const recordId = (0, utils_1.newid)();
                 const validLock = {
                     dataLockId: (0, utils_1.newid)(),
@@ -185,7 +183,7 @@ describe('data-locks.ts', () => {
                 const result = await dataLocksTable.getCurrentLock(recordId);
                 expect(result).toEqual(validLock);
             });
-            it('should return the earliest lock when multiple valid locks exist', async () => {
+            it("should return the earliest lock when multiple valid locks exist", async () => {
                 const recordId = (0, utils_1.newid)();
                 const lock1 = {
                     dataLockId: (0, utils_1.newid)(),
@@ -206,8 +204,8 @@ describe('data-locks.ts', () => {
                 expect(result?.dataLockId).toBe(firstLock.dataLockId);
             });
         });
-        describe('releaseLock', () => {
-            it('should delete the lock from the database', async () => {
+        describe("releaseLock", () => {
+            it("should delete the lock from the database", async () => {
                 const lock = {
                     dataLockId: (0, utils_1.newid)(),
                     recordId: (0, utils_1.newid)(),
@@ -219,11 +217,11 @@ describe('data-locks.ts', () => {
                 expect(await dataLocksTable.get(lock.dataLockId)).toBeUndefined();
             });
         });
-        describe('acquireLock', () => {
-            it('should acquire a lock when no existing locks', async () => {
+        describe("acquireLock", () => {
+            it("should acquire a lock when no existing locks", async () => {
                 const recordId = (0, utils_1.newid)();
                 // Mock sufficient acknowledgments for lock confirmation
-                const mockAcquireLock = jest.spyOn(dataLocksTable, 'acquireLock');
+                const mockAcquireLock = jest.spyOn(dataLocksTable, "acquireLock");
                 mockAcquireLock.mockImplementation(async () => {
                     const lock = {
                         dataLockId: (0, utils_1.newid)(),
@@ -239,11 +237,11 @@ describe('data-locks.ts', () => {
                 expect(result?.lockedUntil).toBeGreaterThan(Date.now());
                 mockAcquireLock.mockRestore();
             });
-            it('should use custom timeout and lock time', async () => {
+            it("should use custom timeout and lock time", async () => {
                 const recordId = (0, utils_1.newid)();
                 const customTimeout = 5000;
                 const customLockTime = 120000;
-                const mockAcquireLock = jest.spyOn(dataLocksTable, 'acquireLock');
+                const mockAcquireLock = jest.spyOn(dataLocksTable, "acquireLock");
                 mockAcquireLock.mockImplementation(async (recordId, timeoutMs, lockTimeMs) => {
                     expect(timeoutMs).toBe(customTimeout);
                     expect(lockTimeMs).toBe(customLockTime);
@@ -257,8 +255,8 @@ describe('data-locks.ts', () => {
                 mockAcquireLock.mockRestore();
             });
         });
-        describe('renewLock', () => {
-            it('should renew a valid lock', async () => {
+        describe("renewLock", () => {
+            it("should renew a valid lock", async () => {
                 const lock = {
                     dataLockId: (0, utils_1.newid)(),
                     recordId: (0, utils_1.newid)(),
@@ -267,13 +265,13 @@ describe('data-locks.ts', () => {
                 await dataLocksTable.insert(lock);
                 const originalLockedUntil = lock.lockedUntil;
                 // Small delay to ensure time difference
-                const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+                const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
                 await sleep(10);
                 const renewedLock = await dataLocksTable.renewLock(lock, 120000);
                 expect(renewedLock).toBeDefined();
                 expect(renewedLock?.lockedUntil).toBeGreaterThan(originalLockedUntil);
             });
-            it('should reject renewal of expired lock', async () => {
+            it("should reject renewal of expired lock", async () => {
                 const lock = {
                     dataLockId: (0, utils_1.newid)(),
                     recordId: (0, utils_1.newid)(),
@@ -283,7 +281,7 @@ describe('data-locks.ts', () => {
                 const result = await dataLocksTable.renewLock(lock);
                 expect(result).toBeUndefined();
             });
-            it('should reject renewal when lock is no longer current', async () => {
+            it("should reject renewal when lock is no longer current", async () => {
                 const recordId = (0, utils_1.newid)();
                 // getCurrentLock returns the lock with the lexicographically first dataLockId,
                 // so ensure newLockId sorts before oldLockId
@@ -305,8 +303,8 @@ describe('data-locks.ts', () => {
                 expect(result).toBeUndefined();
             });
         });
-        describe('lockStatus', () => {
-            it('should return confirmed when sufficient acknowledgments', async () => {
+        describe("lockStatus", () => {
+            it("should return confirmed when sufficient acknowledgments", async () => {
                 const lock = {
                     dataLockId: (0, utils_1.newid)(),
                     recordId: (0, utils_1.newid)(),
@@ -318,9 +316,9 @@ describe('data-locks.ts', () => {
                 mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now() + 2);
                 mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now() + 3);
                 const status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe('confirmed');
+                expect(status).toBe("confirmed");
             });
-            it('should return pending when insufficient acknowledgments', async () => {
+            it("should return pending when insufficient acknowledgments", async () => {
                 const lock = {
                     dataLockId: (0, utils_1.newid)(),
                     recordId: (0, utils_1.newid)(),
@@ -329,9 +327,9 @@ describe('data-locks.ts', () => {
                 // Add insufficient acknowledgments (only 1, need 4)
                 mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now());
                 const status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe('pending');
+                expect(status).toBe("pending");
             });
-            it('should calculate acknowledgments needed correctly for different network sizes', async () => {
+            it("should calculate acknowledgments needed correctly for different network sizes", async () => {
                 const lock = {
                     dataLockId: (0, utils_1.newid)(),
                     recordId: (0, utils_1.newid)(),
@@ -342,13 +340,13 @@ describe('data-locks.ts', () => {
                 mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now());
                 mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now() + 1);
                 let status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe('confirmed');
+                expect(status).toBe("confirmed");
                 // Test with 5 connections (need Math.ceil(5 * 0.7) + 1 = 5 acknowledgments)
                 mockPeerDevice.setConnectionCount(5);
                 status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe('pending'); // Still only 2 acknowledgments, need 5
+                expect(status).toBe("pending"); // Still only 2 acknowledgments, need 5
             });
-            it('should throw error when peerDevice is not set', async () => {
+            it("should throw error when peerDevice is not set", async () => {
                 const lock = {
                     dataLockId: (0, utils_1.newid)(),
                     recordId: (0, utils_1.newid)(),
@@ -356,41 +354,41 @@ describe('data-locks.ts', () => {
                 };
                 const originalPeerDevice = dataLocksTable.peerDevice;
                 dataLocksTable.peerDevice = undefined;
-                await expect(dataLocksTable.lockStatus(lock)).rejects.toThrow('Peer device not set for DataLocksTable');
+                await expect(dataLocksTable.lockStatus(lock)).rejects.toThrow("Peer device not set for DataLocksTable");
                 dataLocksTable.peerDevice = originalPeerDevice;
             });
         });
     });
-    describe('dataLockSchema', () => {
-        it('should validate valid lock data', () => {
+    describe("dataLockSchema", () => {
+        it("should validate valid lock data", () => {
             const validLock = {
                 dataLockId: (0, utils_1.newid)(),
-                recordId: 'test-record',
+                recordId: "test-record",
                 lockedUntil: Date.now() + 60000,
             };
             const result = data_locks_1.dataLockSchema.safeParse(validLock);
             expect(result.success).toBe(true);
         });
-        it('should validate lock with acknowledgment', () => {
+        it("should validate lock with acknowledgment", () => {
             const validLock = {
                 dataLockId: (0, utils_1.newid)(),
-                recordId: 'test-record',
+                recordId: "test-record",
                 lockedUntil: Date.now() + 60000,
                 acknowledged: Date.now(),
             };
             const result = data_locks_1.dataLockSchema.safeParse(validLock);
             expect(result.success).toBe(true);
         });
-        it('should reject invalid lock data', () => {
+        it("should reject invalid lock data", () => {
             const invalidLock = {
                 dataLockId: 123, // Should be string
-                recordId: 'test-record',
-                lockedUntil: 'invalid', // Should be number
+                recordId: "test-record",
+                lockedUntil: "invalid", // Should be number
             };
             const result = data_locks_1.dataLockSchema.safeParse(invalidLock);
             expect(result.success).toBe(false);
         });
-        it('should reject missing required fields', () => {
+        it("should reject missing required fields", () => {
             const incompleteLock = {
                 dataLockId: (0, utils_1.newid)(),
                 // Missing recordId and lockedUntil
@@ -399,17 +397,17 @@ describe('data-locks.ts', () => {
             expect(result.success).toBe(false);
         });
     });
-    describe('DataLocks factory function', () => {
-        it('should return a DataLocksTable instance', () => {
+    describe("DataLocks factory function", () => {
+        it("should return a DataLocksTable instance", () => {
             // This is a simplified test - in practice you'd need to set up the factory properly
-            expect(typeof data_locks_1.DataLocks).toBe('function');
+            expect(typeof data_locks_1.DataLocks).toBe("function");
         });
     });
-    describe('integration scenarios', () => {
-        it('should handle concurrent lock attempts', async () => {
+    describe("integration scenarios", () => {
+        it("should handle concurrent lock attempts", async () => {
             const recordId = (0, utils_1.newid)();
             // This is a simplified version - real concurrent testing would require more complex setup
-            const mockInsert = jest.spyOn(dataLocksTable, 'insert');
+            const mockInsert = jest.spyOn(dataLocksTable, "insert");
             let insertCount = 0;
             mockInsert.mockImplementation(async (lock) => {
                 insertCount++;
@@ -425,7 +423,7 @@ describe('data-locks.ts', () => {
             expect(insertCount).toBe(3);
             mockInsert.mockRestore();
         });
-        it('should handle lock expiration cleanup', async () => {
+        it("should handle lock expiration cleanup", async () => {
             const recordId = (0, utils_1.newid)();
             const expiredLock = {
                 dataLockId: (0, utils_1.newid)(),
@@ -442,7 +440,7 @@ describe('data-locks.ts', () => {
             const currentLock = await dataLocksTable.getCurrentLock(recordId);
             expect(currentLock?.dataLockId).toBe(validLock.dataLockId);
         });
-        it('should handle multiple records with independent locks', async () => {
+        it("should handle multiple records with independent locks", async () => {
             const record1 = (0, utils_1.newid)();
             const record2 = (0, utils_1.newid)();
             const lock1 = {

package/dist/data/device-sync-info.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { ITableMetaData } from "./orm";
 import type { DataContext } from "../context/data-context";
+import { type ITableMetaData } from "./orm";
 export declare const deviceSyncInfoSchema: z.ZodObject<{
     deviceId: z.ZodEffects<z.ZodString, string, string>;
     timestampAppliedLast: z.ZodNumber;

package/dist/data/device-sync-info.js

@@ -3,18 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deviceSyncInfoMetaData = exports.deviceSyncInfoSchema = void 0;
 exports.DeviceSyncInfos = DeviceSyncInfos;
 const zod_1 = require("zod");
+const context_1 = require("../context");
 const zod_types_1 = require("../types/zod-types");
 const orm_1 = require("./orm");
-const context_1 = require("../context");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 exports.deviceSyncInfoSchema = zod_1.z.object({
     deviceId: zod_types_1.zodPeerId,
     timestampAppliedLast: zod_1.z.number(),
 });
 exports.deviceSyncInfoMetaData = {
-    name: 'DeviceSyncTracking',
-    primaryKeyName: 'deviceId',
-    description: 'Sync tracking table',
+    name: "DeviceSyncTracking",
+    primaryKeyName: "deviceId",
+    description: "Sync tracking table",
     fields: (0, orm_1.schemaToFields)(exports.deviceSyncInfoSchema),
     localOnly: true,
 };

package/dist/data/devices.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { TrustLevel } from "../device/socket.type";
 import type { DataContext } from "../context/data-context";
+import { TrustLevel } from "../device/socket.type";
 export declare const deviceSchema: z.ZodObject<{
     deviceId: z.ZodEffects<z.ZodString, string, string>;
     userId: z.ZodEffects<z.ZodString, string, string>;

package/dist/data/devices.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.thisDeviceId = exports.trustedServers = exports.deviceSchema = void 0;
 exports.Devices = Devices;
 const zod_1 = require("zod");
-const types_1 = require("./orm/types");
-const persistent_vars_1 = require("./persistent-vars");
 const user_context_singleton_1 = require("../context/user-context-singleton");
-const table_definitions_system_1 = require("./orm/table-definitions.system");
 const socket_type_1 = require("../device/socket.type");
 const zod_types_1 = require("../types/zod-types");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
+const persistent_vars_1 = require("./persistent-vars");
 exports.deviceSchema = zod_1.z.object({
     deviceId: zod_types_1.zodPeerId,
     userId: zod_types_1.zodPeerId,
@@ -19,19 +19,16 @@ exports.deviceSchema = zod_1.z.object({
     trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel),
 });
 const metaData = {
-    name: 'Devices',
-    description: 'The Peer devices that this computer is aware of',
-    primaryKeyName: 'deviceId',
+    name: "Devices",
+    description: "The Peer devices that this computer is aware of",
+    primaryKeyName: "deviceId",
     fields: (0, types_1.schemaToFields)(exports.deviceSchema),
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.deviceSchema);
 function Devices(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.deviceSchema);
 }
-exports.trustedServers = (0, persistent_vars_1.groupVar)('trustedServers', {
-    defaultValue: [
-        'https://peers.app',
-        'https://peers-services.azurewebsites.net',
-    ],
+exports.trustedServers = (0, persistent_vars_1.groupVar)("trustedServers", {
+    defaultValue: ["https://peers.app", "https://peers-services.azurewebsites.net"],
 });
-exports.thisDeviceId = (0, persistent_vars_1.deviceVar)('thisDeviceId');
+exports.thisDeviceId = (0, persistent_vars_1.deviceVar)("thisDeviceId");

package/dist/data/embeddings.js

@@ -3,29 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.embeddingSchema = void 0;
 exports.Embeddings = Embeddings;
 const zod_1 = require("zod");
-const zod_types_1 = require("../types/zod-types");
-const types_1 = require("./orm/types");
 const user_context_singleton_1 = require("../context/user-context-singleton");
+const zod_types_1 = require("../types/zod-types");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
 exports.embeddingSchema = zod_1.z.object({
     embeddingId: zod_types_1.zodPeerId,
-    textHash: zod_1.z.string().describe('The hash of the text'),
-    embedding: zod_1.z.array(zod_1.z.number()).describe('The embedding of the text'),
-    embeddingType: zod_1.z.string().describe('The type of embedding used'),
-    metadata: zod_1.z.object({
+    textHash: zod_1.z.string().describe("The hash of the text"),
+    embedding: zod_1.z.array(zod_1.z.number()).describe("The embedding of the text"),
+    embeddingType: zod_1.z.string().describe("The type of embedding used"),
+    metadata: zod_1.z
+        .object({
         fkId: zod_1.z.string().optional(),
         // fkTable: z.string().optional(),
         // fkIdFieldName: z.string().optional(),
-    }).catchall(zod_1.z.any()).describe('Any metadata associated with the embedding'),
+    })
+        .catchall(zod_1.z.any())
+        .describe("Any metadata associated with the embedding"),
 });
 const metaData = {
-    name: 'Embeddings',
-    description: 'The embeddings for some specific text',
-    primaryKeyName: 'embeddingId',
+    name: "Embeddings",
+    description: "The embeddings for some specific text",
+    primaryKeyName: "embeddingId",
     fields: (0, types_1.schemaToFields)(exports.embeddingSchema),
     indexes: [
         {
-            fields: ['textHash', 'embeddingType'],
+            fields: ["textHash", "embeddingType"],
             unique: true,
         },
     ],

package/dist/data/files/file-read-stream.d.ts

@@ -1,5 +1,5 @@
-import { IFile } from './file.types';
-import type { FilesTable } from './files';
+import { type IFile } from "./file.types";
+import type { FilesTable } from "./files";
 export declare class FileReadStream {
     private fileRecord;
     private fileTable;

package/dist/data/files/file-read-stream.js

@@ -39,10 +39,11 @@ class FileReadStream {
     }
     async loadChunkByIndex(chunkIndex) {
         await this.loadChunkHashes();
-        if (chunkIndex >= this.chunkHashes.length) {
+        const chunkHashes = this.chunkHashes;
+        if (chunkIndex >= chunkHashes.length) {
             throw new Error(`Chunk index ${chunkIndex} out of bounds`);
         }
-        const chunkHash = this.chunkHashes[chunkIndex];
+        const chunkHash = chunkHashes[chunkIndex];
         const ops = await (0, file_types_1.getFileOps)();
         const chunkPath = `${file_types_1.CHUNKS_DIR}/${chunkHash}`;
         let chunk;
@@ -68,16 +69,17 @@ class FileReadStream {
     }
     async preloadChunks() {
         await this.loadChunkHashes();
+        const chunkHashes = this.chunkHashes;
         // Start from current chunk and preload up to preloadChunksCount ahead
         for (let offset = 0; offset < this.preloadChunksCount; offset++) {
             const chunkIndex = this.currentChunkIndex + offset;
-            if (chunkIndex >= this.chunkHashes.length) {
+            if (chunkIndex >= chunkHashes.length) {
                 break; // No more chunks to preload
             }
             if (!this.chunkPromises.has(chunkIndex)) {
                 // Start preload but don't await it - let it happen in background
                 // Add error handling to prevent unhandled promise rejections
-                const safeChunkPromise = this.loadChunkByIndex(chunkIndex).catch(error => {
+                const safeChunkPromise = this.loadChunkByIndex(chunkIndex).catch((error) => {
                     // Re-throw so error is available when promise is consumed
                     throw error;
                 });
@@ -89,7 +91,8 @@ class FileReadStream {
     }
     async loadCurrentChunk() {
         await this.preloadChunks();
-        if (this.currentChunkIndex >= this.chunkHashes.length) {
+        const chunkHashes = this.chunkHashes;
+        if (this.currentChunkIndex >= chunkHashes.length) {
             this.eof = true;
             this.currentChunkBuffer = null;
             this.chunkPromises.clear();
@@ -118,15 +121,16 @@ class FileReadStream {
                 }
             }
             // Read from current chunk
-            const availableInChunk = this.currentChunkBuffer.length - this.positionInChunk;
+            const buf = this.currentChunkBuffer;
+            const availableInChunk = buf.length - this.positionInChunk;
             const bytesToRead = Math.min(remainingBytes, availableInChunk);
-            const chunkPortion = this.currentChunkBuffer.subarray(this.positionInChunk, this.positionInChunk + bytesToRead);
+            const chunkPortion = buf.subarray(this.positionInChunk, this.positionInChunk + bytesToRead);
             chunks.push(chunkPortion);
             remainingBytes -= bytesToRead;
             this.positionInChunk += bytesToRead;
             this.totalPosition += bytesToRead;
             // If we've consumed the entire chunk, move to next one
-            if (this.positionInChunk >= this.currentChunkBuffer.length) {
+            if (this.positionInChunk >= buf.length) {
                 this.currentChunkIndex++;
                 this.currentChunkBuffer = null;
                 this.positionInChunk = 0;
@@ -137,12 +141,13 @@ class FileReadStream {
     }
     async seek(position) {
         if (position < 0) {
-            throw new Error('Seek position cannot be negative');
+            throw new Error("Seek position cannot be negative");
         }
         if (position > this.fileRecord.fileSize) {
-            throw new Error('Seek position beyond file size');
+            throw new Error("Seek position beyond file size");
         }
         await this.loadChunkHashes();
+        const chunkHashes = this.chunkHashes;
         // Calculate which chunk contains the target position
         const targetChunkIndex = Math.floor(position / file_types_1.FILE_CHUNK_SIZE);
         const positionInTargetChunk = position % file_types_1.FILE_CHUNK_SIZE;
@@ -151,7 +156,7 @@ class FileReadStream {
         this.totalPosition = position;
         this.currentChunkBuffer = null; // Will be loaded on next read
         // Only set EOF if we're seeking beyond the last chunk OR at the very end of the file
-        this.eof = (targetChunkIndex >= this.chunkHashes.length) || (position >= this.fileRecord.fileSize);
+        this.eof = targetChunkIndex >= chunkHashes.length || position >= this.fileRecord.fileSize;
         this.chunkPromises.clear();
         await this.preloadChunks();
     }
@@ -176,7 +181,11 @@ class FileReadStream {
         const chunks = [];
         let chunk;
         try {
-            while ((chunk = await this.read()) !== null) {
+            while (true) {
+                chunk = await this.read();
+                if (chunk === null) {
+                    break;
+                }
                 chunks.push(chunk);
             }
             return new Uint8Array(Buffer.concat(chunks));
@@ -185,8 +194,8 @@ class FileReadStream {
             // Only return null for chunk-specific errors (not found, download failed)
             // Rethrow other errors like index file issues
             if (error instanceof Error &&
-                (error.message.includes('Chunk') &&
-                    (error.message.includes('not found') || error.message.includes('integrity check failed')))) {
+                error.message.includes("Chunk") &&
+                (error.message.includes("not found") || error.message.includes("integrity check failed"))) {
                 return null;
             }
             throw error;

package/dist/data/files/file-write-stream.d.ts

@@ -1,5 +1,5 @@
-import { IFile, IFileInput } from './file.types';
-import type { FilesTable } from './files';
+import { type IFile, type IFileInput } from "./file.types";
+import type { FilesTable } from "./files";
 export declare class FileWriteStream {
     private metadata;
     private fileTable;