rac-delta 1.0.0

package/dist/infrastructure/pipelines/default-url-download-pipeline.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultUrlDownloadPipeline = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const pipelines_1 = require("../../core/pipelines");
+const stream_to_buffer_1 = require("../../core/utils/stream-to-buffer");
+const storage_chunk_source_1 = require("../chunk-sources/storage-chunk-source");
+const memory_chunk_source_1 = require("../chunk-sources/memory-chunk-source");
+const disk_chunk_source_1 = require("../chunk-sources/disk-chunk-source");
+class DefaultUrlDownloadPipeline extends pipelines_1.UrlDownloadPipeline {
+    storage;
+    reconstruction;
+    validation;
+    delta;
+    config;
+    constructor(storage, reconstruction, validation, delta, config) {
+        super(storage, reconstruction, validation, delta, config);
+        this.storage = storage;
+        this.reconstruction = reconstruction;
+        this.validation = validation;
+        this.delta = delta;
+        this.config = config;
+    }
+    async execute(localDir, urls, strategy, plan, options) {
+        this.changeState('scanning', options);
+        const remoteIndex = await this.storage.getRemoteIndexByUrl(urls.indexUrl);
+        if (!remoteIndex) {
+            throw new Error(`No remote rd-index found with the url: ${urls.indexUrl}`);
+        }
+        const localIndex = plan
+            ? null
+            : options?.useExistingIndex
+                ? await this.findLocalIndex(localDir)
+                : await this.loadLocalIndex(localDir);
+        const planToUse = plan ? plan : await this.delta.compareForDownload(localIndex, remoteIndex);
+        let chunkSource = null;
+        if (strategy === pipelines_1.UpdateStrategy.DownloadAllFirstToMemory) {
+            this.changeState('downloading', options);
+            chunkSource = await this.downloadAllMissingChunks(urls.downloadUrls, 'memory', options);
+        }
+        if (strategy === pipelines_1.UpdateStrategy.DownloadAllFirstToDisk) {
+            this.changeState('downloading', options);
+            chunkSource = await this.downloadAllMissingChunks(urls.downloadUrls, 'disk', options);
+        }
+        if (strategy === pipelines_1.UpdateStrategy.StreamFromNetwork) {
+            const map = new Map(Object.entries(urls.downloadUrls).map(([key, value]) => [key, value.url]));
+            chunkSource = new storage_chunk_source_1.StorageChunkSource(this.storage, map);
+        }
+        if (!chunkSource) {
+            throw new Error('No chunkSource found');
+        }
+        if (planToUse.newAndModifiedFiles.length) {
+            this.changeState('reconstructing', options);
+            await this.reconstruction.reconstructAll(planToUse, localDir, chunkSource, {
+                forceRebuild: options?.force,
+                verifyAfterRebuild: true,
+                fileConcurrency: options?.fileReconstructionConcurrency,
+                inPlaceReconstructionThreshold: options?.inPlaceReconstructionThreshold,
+                onProgress: (reconstructProgress, diskSpeed, networkProgress, networkSpeed) => {
+                    this.updateProgress(reconstructProgress, 'reconstructing', diskSpeed, undefined, options);
+                    if (networkProgress) {
+                        this.updateProgress(networkProgress, 'download', 0, networkSpeed, options);
+                    }
+                },
+            });
+        }
+        if (planToUse.obsoleteChunks || planToUse.deletedFiles) {
+            this.changeState('cleaning', options);
+            await this.verifyAndDeleteObsoleteChunks(planToUse, localDir, remoteIndex, chunkSource, options);
+        }
+        await this.saveLocalIndex(localDir, remoteIndex);
+        if (chunkSource instanceof disk_chunk_source_1.DiskChunkSource) {
+            chunkSource.clear();
+        }
+    }
+    async findLocalIndex(localDir) {
+        const dir = (0, path_1.isAbsolute)(localDir) ? localDir : (0, path_1.resolve)(process.cwd(), localDir);
+        const files = await (0, promises_1.readdir)(dir);
+        const indexFile = files.find((f) => f === 'rd-index.json');
+        if (!indexFile) {
+            return null;
+        }
+        const filePath = (0, path_1.join)(localDir, indexFile);
+        const data = await (0, promises_1.readFile)(filePath, 'utf-8');
+        try {
+            const parsed = JSON.parse(data);
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Invalid RDIndex JSON at ${filePath}: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    async loadLocalIndex(localDir) {
+        const localIndex = await this.delta.createIndexFromDirectory(localDir, this.config.chunkSize, this.config.maxConcurrency);
+        return localIndex;
+    }
+    async downloadAllMissingChunks(downloadUrls, target, options) {
+        if (target === 'disk' && !options?.chunksSavePath) {
+            throw new Error('Error: chunksSavePath must be provided under options');
+        }
+        let chunksSavePath = undefined;
+        if (target === 'disk' && options?.chunksSavePath) {
+            chunksSavePath = (0, path_1.isAbsolute)(options?.chunksSavePath)
+                ? options?.chunksSavePath
+                : (0, path_1.resolve)(process.cwd(), options?.chunksSavePath);
+        }
+        const chunkSource = target === 'memory' ? new memory_chunk_source_1.MemoryChunkSource() : new disk_chunk_source_1.DiskChunkSource(chunksSavePath);
+        const entries = Object.entries(downloadUrls);
+        let completed = 0;
+        let totalBytes = 0;
+        const concurrency = this.config.maxConcurrency ?? 6;
+        const queue = [...entries];
+        let lastUpdateTime = Date.now();
+        let lastBytes = 0;
+        const worker = async () => {
+            while (queue.length) {
+                const [hash, info] = queue.pop();
+                const readable = await this.storage.getChunkByUrl(info.url);
+                if (!readable) {
+                    throw new Error(`Chunk missing: ${hash}`);
+                }
+                const buffer = await (0, stream_to_buffer_1.streamToBuffer)(readable);
+                chunkSource.setChunk(hash, buffer);
+                completed++;
+                totalBytes += buffer.length;
+                const now = Date.now();
+                const elapsed = now - lastUpdateTime;
+                // each 100ms
+                if (elapsed >= 100) {
+                    const bytesDiff = totalBytes - lastBytes;
+                    const speed = bytesDiff / (elapsed / 1000);
+                    lastUpdateTime = now;
+                    lastBytes = totalBytes;
+                    const percent = ((completed / entries.length) * 100).toFixed(1);
+                    this.updateProgress(Number(percent), 'download', 0, speed, options);
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: concurrency }, () => worker()));
+        const percent = 100;
+        const totalTime = (Date.now() - lastUpdateTime) / 1000;
+        const avgSpeed = totalBytes / (totalTime || 1);
+        this.updateProgress(percent, 'download', 0, avgSpeed, options);
+        return chunkSource;
+    }
+    async verifyAndDeleteObsoleteChunks(plan, localDir, remoteIndex, chunkSource, options) {
+        const dir = (0, path_1.isAbsolute)(localDir) ? localDir : (0, path_1.resolve)(process.cwd(), localDir);
+        const obsoleteByFile = this.groupByFile(plan.obsoleteChunks);
+        const deletedFiles = [];
+        const verifiedFiles = [];
+        const rebuiltFiles = [];
+        const allFiles = new Set([...plan.deletedFiles, ...obsoleteByFile.keys()]);
+        const totalFiles = allFiles.size;
+        let completedFiles = 0;
+        for (const filePath of allFiles) {
+            const absPath = (0, path_1.join)(dir, filePath);
+            const remoteFile = remoteIndex.files.find((file) => file.path === filePath);
+            // Fully removed file
+            if (!remoteFile || plan.deletedFiles.includes(filePath)) {
+                await (0, promises_1.rm)(absPath, { force: true });
+                deletedFiles.push(filePath);
+            }
+            else {
+                const isValid = await this.validation.validateFile(remoteFile, absPath);
+                if (!isValid) {
+                    await this.reconstruction.reconstructFile(remoteFile, absPath, chunkSource);
+                    rebuiltFiles.push(filePath);
+                }
+                else {
+                    verifiedFiles.push(filePath);
+                }
+            }
+            completedFiles++;
+            this.updateProgress((completedFiles / totalFiles) * 100, 'deleting', undefined, undefined, options);
+        }
+        return { deletedFiles, verifiedFiles, rebuiltFiles };
+    }
+    async saveLocalIndex(localDir, index) {
+        const dir = (0, path_1.isAbsolute)(localDir) ? localDir : (0, path_1.resolve)(process.cwd(), localDir);
+        const indexPath = (0, path_1.join)(dir, 'rd-index.json');
+        await (0, promises_1.writeFile)(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+    }
+    groupByFile(chunks) {
+        const map = new Map();
+        for (const chunk of chunks) {
+            if (!map.has(chunk.filePath)) {
+                map.set(chunk.filePath, []);
+            }
+            map.get(chunk.filePath).push(chunk);
+        }
+        return map;
+    }
+}
+exports.DefaultUrlDownloadPipeline = DefaultUrlDownloadPipeline;

package/dist/infrastructure/pipelines/default-url-upload-pipeline.d.ts

@@ -0,0 +1,20 @@
+import { UploadOptions, UrlUploadPipeline } from '../../core/pipelines';
+import { ChunkUrlInfo, RDIndex } from '../../core/models';
+import { UrlStorageAdapter } from '../../core/adapters';
+import { RacDeltaConfig } from '../../core/config';
+import { Nullish } from '../../core/types';
+export declare class DefaultUrlUploadPipeline extends UrlUploadPipeline {
+    protected readonly storage: UrlStorageAdapter;
+    protected readonly config: RacDeltaConfig;
+    constructor(storage: UrlStorageAdapter, config: RacDeltaConfig);
+    execute(localIndex: RDIndex, urls: {
+        uploadUrls: Record<string, ChunkUrlInfo>;
+        deleteUrls?: Nullish<string[]>;
+        indexUrl: string;
+    }, options?: Nullish<UploadOptions>): Promise<RDIndex>;
+    uploadMissingChunks(uploadUrls: Record<string, ChunkUrlInfo>, options?: Nullish<UploadOptions>): Promise<void>;
+    deleteObsoleteChunks(deleteUrls: string[], options?: UploadOptions): Promise<void>;
+    uploadIndex(index: RDIndex, indexUrl: string): Promise<void>;
+    private groupChunksByFile;
+}
+//# sourceMappingURL=default-url-upload-pipeline.d.ts.map

package/dist/infrastructure/pipelines/default-url-upload-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-url-upload-pipeline.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/pipelines/default-url-upload-pipeline.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,wBAAyB,SAAQ,iBAAiB;IAE3D,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,iBAAiB;IAC7C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc;gBADtB,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,cAAc;IAKrC,OAAO,CACX,UAAU,EAAE,OAAO,EACnB,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QACzC,UAAU,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAC/B,QAAQ,EAAE,MAAM,CAAC;KAClB,EACD,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC/B,OAAO,CAAC,OAAO,CAAC;IAiBb,mBAAmB,CACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACxC,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC;IAmDV,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAoDlE,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM;IAIlD,OAAO,CAAC,iBAAiB;CAa1B"}

package/dist/infrastructure/pipelines/default-url-upload-pipeline.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultUrlUploadPipeline = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const stream_1 = require("stream");
+const pipelines_1 = require("../../core/pipelines");
+class DefaultUrlUploadPipeline extends pipelines_1.UrlUploadPipeline {
+    storage;
+    config;
+    constructor(storage, config) {
+        super(storage, config);
+        this.storage = storage;
+        this.config = config;
+    }
+    async execute(localIndex, urls, options) {
+        if (urls.uploadUrls.length) {
+            this.changeState('uploading', options);
+            await this.uploadMissingChunks(urls.uploadUrls, options);
+        }
+        if (urls.deleteUrls?.length) {
+            this.changeState('cleaning', options);
+            await this.deleteObsoleteChunks(urls.deleteUrls, options);
+        }
+        this.changeState('finalizing', options);
+        await this.uploadIndex(localIndex, urls.indexUrl);
+        return localIndex;
+    }
+    async uploadMissingChunks(uploadUrls, options) {
+        const chunks = Object.values(uploadUrls);
+        if (!chunks.length) {
+            return;
+        }
+        const concurrency = this.config.maxConcurrency ?? 5;
+        const grouped = this.groupChunksByFile(chunks);
+        const totalChunks = chunks.length;
+        let uploadedChunks = 0;
+        let uploadedBytes = 0;
+        const startTime = Date.now();
+        const queue = [...grouped];
+        const worker = async () => {
+            while (queue.length) {
+                const [filePath, fileChunks] = queue.pop();
+                fileChunks.sort((a, b) => a.offset - b.offset);
+                const finalFilePath = (0, path_1.isAbsolute)(filePath) ? filePath : (0, path_1.resolve)(process.cwd(), filePath);
+                const fileHandle = await (0, promises_1.open)(finalFilePath, 'r');
+                const buffer = Buffer.alloc(this.config.chunkSize);
+                try {
+                    for (const chunk of fileChunks) {
+                        const { url, offset, size } = chunk;
+                        const { bytesRead } = await fileHandle.read(buffer, 0, size, offset);
+                        const data = buffer.subarray(0, bytesRead);
+                        await this.storage.putChunkByUrl(url, stream_1.Readable.from(data));
+                        uploadedChunks++;
+                        uploadedBytes += bytesRead;
+                        const percent = ((uploadedChunks / totalChunks) * 100).toFixed(1);
+                        const elapsed = (Date.now() - startTime) / 1000; // seconds
+                        const speed = uploadedBytes / elapsed;
+                        this.updateProgress(Number(percent), 'upload', speed, options);
+                    }
+                }
+                finally {
+                    await fileHandle.close();
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: concurrency }, () => worker()));
+    }
+    async deleteObsoleteChunks(deleteUrls, options) {
+        if (!deleteUrls.length) {
+            return;
+        }
+        const concurrency = this.config.maxConcurrency ?? 5;
+        const queue = [...deleteUrls];
+        const total = queue.length;
+        let deleted = 0;
+        if (total === 0) {
+            return;
+        }
+        const failed = [];
+        const maxRetries = 3;
+        const worker = async () => {
+            while (queue.length) {
+                const url = queue.pop();
+                if (!url) {
+                    break;
+                }
+                let success = false;
+                for (let attempt = 1; attempt <= maxRetries && !success; attempt++) {
+                    try {
+                        await this.storage.deleteChunkByUrl(url);
+                        success = true;
+                    }
+                    catch (err) {
+                        if (attempt === maxRetries) {
+                            failed.push(url);
+                        }
+                        else {
+                            await new Promise((res) => setTimeout(res, 100 * attempt));
+                        }
+                    }
+                }
+                deleted++;
+                this.updateProgress(deleted / total, 'deleting', undefined, options);
+            }
+        };
+        await Promise.all(Array.from({ length: concurrency }, () => worker()));
+        if (failed.length > 0) {
+            throw new Error(`Failed to delete ${failed.length}/${total} chunks: ${failed.join(', ')}`);
+        }
+    }
+    async uploadIndex(index, indexUrl) {
+        await this.storage.putRemoteIndexByUrl(indexUrl, index);
+    }
+    groupChunksByFile(chunks) {
+        const groups = new Map();
+        for (const chunk of chunks) {
+            if (!groups.has(chunk.filePath)) {
+                groups.set(chunk.filePath, []);
+            }
+            groups.get(chunk.filePath).push(chunk);
+        }
+        return Array.from(groups.entries());
+    }
+}
+exports.DefaultUrlUploadPipeline = DefaultUrlUploadPipeline;

package/dist/infrastructure/services/hash-wasm-hasher-service.d.ts

@@ -0,0 +1,13 @@
+import { HasherService, StreamingHasher } from '../../core/services';
+import { AsyncChunkStream } from '../../core/services';
+import { FileEntry, Chunk } from '../../core/models';
+import { Nullish } from '../../core/types';
+export declare class HashWasmHasherService implements HasherService {
+    hashFile(filePath: string, rootDir: string, chunkSize: number): Promise<FileEntry>;
+    hashStream(stream: AsyncChunkStream, onChunk?: Nullish<(chunk: Uint8Array) => void>): Promise<Chunk[]>;
+    verifyChunk(data: Uint8Array, expectedHash: string): Promise<boolean>;
+    hashBuffer(data: Uint8Array): Promise<string>;
+    verifyFile(path: string, expectedHash: string): Promise<boolean>;
+    createStreamingHasher(): Promise<StreamingHasher>;
+}
+//# sourceMappingURL=hash-wasm-hasher-service.d.ts.map

package/dist/infrastructure/services/hash-wasm-hasher-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-wasm-hasher-service.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/services/hash-wasm-hasher-service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,qBAAsB,YAAW,aAAa;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAiDlF,UAAU,CACd,MAAM,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC,GAC7C,OAAO,CAAC,KAAK,EAAE,CAAC;IAqCb,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQrE,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAM7C,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBhE,qBAAqB,IAAI,OAAO,CAAC,eAAe,CAAC;CAYxD"}

package/dist/infrastructure/services/hash-wasm-hasher-service.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashWasmHasherService = void 0;
+const path_1 = require("path");
+const hash_wasm_1 = require("hash-wasm");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const invariant_1 = require("../../core/utils/invariant");
+class HashWasmHasherService {
+    async hashFile(filePath, rootDir, chunkSize) {
+        (0, invariant_1.invariant)('path must be a valid string', typeof filePath === 'string' && filePath !== '');
+        (0, invariant_1.invariant)('chunkSize must be a valid number > 0', chunkSize > 0);
+        const dir = (0, path_1.isAbsolute)(rootDir) ? rootDir : (0, path_1.resolve)(process.cwd(), rootDir);
+        const finalFilePath = (0, path_1.join)(dir, filePath);
+        try {
+            const stats = await (0, promises_1.stat)(finalFilePath);
+            const fileHasher = await (0, hash_wasm_1.createBLAKE3)();
+            const chunks = [];
+            let offset = 0;
+            const stream = (0, fs_1.createReadStream)(finalFilePath, { highWaterMark: chunkSize });
+            for await (const chunk of stream) {
+                const chunkHasher = await (0, hash_wasm_1.createBLAKE3)();
+                chunkHasher.update(chunk);
+                const chunkHash = chunkHasher.digest('hex');
+                fileHasher.update(chunk);
+                chunks.push({
+                    hash: chunkHash,
+                    offset,
+                    size: chunk.length,
+                });
+                offset += chunk.length;
+            }
+            const fileHash = fileHasher.digest('hex');
+            return {
+                path: filePath,
+                size: stats.size,
+                modifiedAt: stats.mtimeMs,
+                hash: fileHash,
+                chunks,
+            };
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw new Error(`HasherService.hashFile failed: ${err.message}`);
+            }
+            throw err;
+        }
+    }
+    async hashStream(stream, onChunk) {
+        const chunks = [];
+        let offset = 0;
+        try {
+            for await (const chunk of stream) {
+                const chunkHasher = await (0, hash_wasm_1.createBLAKE3)();
+                chunkHasher.update(chunk);
+                const chunkHash = chunkHasher.digest('hex');
+                if (onChunk) {
+                    onChunk(chunk);
+                }
+                chunks.push({
+                    hash: chunkHash,
+                    offset,
+                    size: chunk.length,
+                });
+                offset += chunk.length;
+            }
+            if (stream.close) {
+                await stream.close();
+            }
+            return chunks;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw new Error(`HasherService.hashStream failed: ${err.message}`);
+            }
+            throw err;
+        }
+    }
+    async verifyChunk(data, expectedHash) {
+        const hasher = await (0, hash_wasm_1.createBLAKE3)();
+        hasher.update(data);
+        const actualHash = hasher.digest('hex');
+        return actualHash === expectedHash;
+    }
+    async hashBuffer(data) {
+        const hasher = await (0, hash_wasm_1.createBLAKE3)();
+        hasher.update(data);
+        return hasher.digest('hex');
+    }
+    async verifyFile(path, expectedHash) {
+        (0, invariant_1.invariant)('path must be a valid string', typeof path === 'string' && path !== '');
+        const finalPath = (0, path_1.isAbsolute)(path) ? path : (0, path_1.resolve)(process.cwd(), path);
+        const hasher = await (0, hash_wasm_1.createBLAKE3)();
+        const stream = (0, fs_1.createReadStream)(finalPath);
+        for await (const chunk of stream) {
+            hasher.update(chunk);
+        }
+        const actualHash = hasher.digest('hex');
+        return actualHash === expectedHash;
+    }
+    async createStreamingHasher() {
+        const native = await (0, hash_wasm_1.createBLAKE3)();
+        return {
+            update(data) {
+                native.update(data);
+            },
+            digest(encoding = 'hex') {
+                return native.digest(encoding);
+            },
+        };
+    }
+}
+exports.HashWasmHasherService = HashWasmHasherService;

package/dist/infrastructure/services/memory-delta-service.d.ts

@@ -0,0 +1,17 @@
+import { AsyncChunkStream, DeltaService, HasherService } from '../../core/services';
+import { RDIndex, DeltaPlan, FileEntry } from '../../core/models';
+import { Nullish } from '../../core/types';
+export declare class MemoryDeltaService implements DeltaService {
+    private readonly hasher;
+    constructor(hasher: HasherService);
+    createIndexFromDirectory(rootPath: string, chunkSize: number, concurrency?: number, ignorePatterns?: Nullish<string[]>): Promise<RDIndex>;
+    createFileEntryFromStream(stream: AsyncChunkStream, path: string): Promise<FileEntry>;
+    private walkFiles;
+    private matchesAnyPattern;
+    private globToRegex;
+    compare(source: RDIndex, target: RDIndex | null): DeltaPlan;
+    mergePlans(base: DeltaPlan, updates: DeltaPlan): DeltaPlan;
+    compareForUpload(localIndex: RDIndex, remoteIndex: RDIndex | null): Promise<DeltaPlan>;
+    compareForDownload(localIndex: RDIndex | null, remoteIndex: RDIndex): Promise<DeltaPlan>;
+}
+//# sourceMappingURL=memory-delta-service.d.ts.map

package/dist/infrastructure/services/memory-delta-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-delta-service.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/services/memory-delta-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAc,MAAM,mBAAmB,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,kBAAmB,YAAW,YAAY;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAE5C,wBAAwB,CAC5B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,SAAI,EACf,cAAc,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,GACjC,OAAO,CAAC,OAAO,CAAC;IA8Cb,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;YAqB5E,SAAS;IAuBxB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS;IAiE3D,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,SAAS;IA0CpD,gBAAgB,CAAC,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC;IAkBtF,kBAAkB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC;CAG/F"}