rac-delta 1.0.0

package/dist/infrastructure/adapters/url-storage-adapter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultUrlStorageAdapter = void 0;
+const stream_1 = require("stream");
+const adapters_1 = require("../../core/adapters");
+const exceptions_1 = require("../../core/exceptions");
+class DefaultUrlStorageAdapter extends adapters_1.UrlStorageAdapter {
+    async dispose() {
+        return;
+    }
+    async getChunkByUrl(url) {
+        const res = await fetch(url, { method: 'GET', headers: {} });
+        if (res.status === 404) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new exceptions_1.GetChunkException(`${res.status} ${res.statusText}`);
+        }
+        return stream_1.Readable.fromWeb(res.body);
+    }
+    async putChunkByUrl(url, data) {
+        const res = await fetch(url, {
+            method: 'PUT',
+            headers: { ...{}, 'Content-Type': 'application/octet-stream' },
+            body: data,
+        });
+        if (!res.ok) {
+            throw new exceptions_1.PutChunkException(`${res.status} ${res.statusText}`);
+        }
+    }
+    async chunkExistsByUrl(url) {
+        const res = await fetch(url, { method: 'HEAD', headers: {} });
+        if (res.status === 404) {
+            return false;
+        }
+        if (!res.ok && res.status !== 200) {
+            throw new exceptions_1.HeadChunkException(`${res.status} ${res.statusText}`);
+        }
+        return res.ok;
+    }
+    async deleteChunkByUrl(url) {
+        const res = await fetch(url, { method: 'DELETE', headers: {} });
+        if (res.status === 404) {
+            return;
+        }
+        if (!res.ok) {
+            throw new exceptions_1.DeleteChunkException(`${res.status} ${res.statusText}`);
+        }
+    }
+    async getChunkInfoByUrl(hash, url) {
+        const res = await fetch(url, { method: 'HEAD', headers: {} });
+        if (res.status === 404) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new exceptions_1.HeadChunkException(`${res.status} ${res.statusText}`);
+        }
+        const size = Number(res.headers.get('content-length')) || 0;
+        const modified = res.headers.get('last-modified')
+            ? new Date(res.headers.get('last-modified'))
+            : undefined;
+        const metadata = {};
+        for (const [k, v] of res.headers.entries()) {
+            if (k.startsWith('x-meta-'))
+                metadata[k.substring(7)] = v;
+        }
+        return { hash, size, modified, metadata };
+    }
+    async getRemoteIndexByUrl(url) {
+        const res = await fetch(url, { method: 'GET', headers: {} });
+        if (res.status === 404) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new exceptions_1.GetRemoteIndexException(`${res.status} ${res.statusText}`);
+        }
+        return (await res.json());
+    }
+    async putRemoteIndexByUrl(url, index) {
+        const res = await fetch(url, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(index, null, 2),
+        });
+        if (!res.ok) {
+            throw new exceptions_1.PutRemoteIndexException(`${res.status} ${res.statusText}`);
+        }
+    }
+}
+exports.DefaultUrlStorageAdapter = DefaultUrlStorageAdapter;

package/dist/infrastructure/chunk-sources/disk-chunk-source.d.ts

@@ -0,0 +1,12 @@
+import { Readable } from 'stream';
+import { ChunkSource } from '../../core/services';
+export declare class DiskChunkSource implements ChunkSource {
+    private cacheDir;
+    constructor(cacheDir: string);
+    getChunk(hash: string): Promise<Buffer>;
+    getChunks(hashes: string[]): Promise<Map<string, Buffer>>;
+    hasChunk(hash: string): Promise<boolean>;
+    setChunk(hash: string, data: Buffer | Readable): Promise<void>;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=disk-chunk-source.d.ts.map

package/dist/infrastructure/chunk-sources/disk-chunk-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk-chunk-source.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/chunk-sources/disk-chunk-source.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,qBAAa,eAAgB,YAAW,WAAW;IACjD,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,EAAE,MAAM;IAItB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAcvC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAWzD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUxC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/infrastructure/chunk-sources/disk-chunk-source.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskChunkSource = void 0;
+const promises_1 = require("fs/promises");
+const promises_2 = require("stream/promises");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const stream_1 = require("stream");
+const exceptions_1 = require("../../core/exceptions");
+class DiskChunkSource {
+    cacheDir;
+    constructor(cacheDir) {
+        this.cacheDir = cacheDir;
+    }
+    async getChunk(hash) {
+        const filePath = (0, path_1.join)(this.cacheDir, hash);
+        try {
+            const stats = await (0, promises_1.stat)(filePath);
+            if (!stats.isFile()) {
+                throw new Error(`Resource is not a file`);
+            }
+            return (0, promises_1.readFile)(filePath);
+        }
+        catch {
+            throw new exceptions_1.ChunkNotFoundException(`${hash} not found on disk`);
+        }
+    }
+    async getChunks(hashes) {
+        const results = new Map();
+        for (const hash of hashes) {
+            const buffer = await this.getChunk(hash);
+            results.set(hash, buffer);
+        }
+        return results;
+    }
+    async hasChunk(hash) {
+        const filePath = (0, path_1.join)(this.cacheDir, hash);
+        try {
+            await (0, promises_1.access)(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async setChunk(hash, data) {
+        const filePath = (0, path_1.join)(this.cacheDir, hash);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(filePath), { recursive: true });
+        if (data instanceof stream_1.Readable) {
+            const writeStream = (0, fs_1.createWriteStream)(filePath);
+            await (0, promises_2.pipeline)(data, writeStream);
+        }
+        else {
+            await (0, promises_1.writeFile)(filePath, data);
+        }
+    }
+    async clear() {
+        await (0, promises_1.rm)(this.cacheDir, { recursive: true, force: true });
+    }
+}
+exports.DiskChunkSource = DiskChunkSource;

package/dist/infrastructure/chunk-sources/index.d.ts

@@ -0,0 +1,4 @@
+export * from './disk-chunk-source';
+export * from './memory-chunk-source';
+export * from './storage-chunk-source';
+//# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/chunk-sources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/chunk-sources/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/dist/infrastructure/chunk-sources/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./disk-chunk-source"), exports);
+__exportStar(require("./memory-chunk-source"), exports);
+__exportStar(require("./storage-chunk-source"), exports);

package/dist/infrastructure/chunk-sources/memory-chunk-source.d.ts

@@ -0,0 +1,9 @@
+import { ChunkSource } from '../../core/services';
+export declare class MemoryChunkSource implements ChunkSource {
+    private cache;
+    getChunk(hash: string): Promise<Buffer>;
+    getChunks(hashes: string[]): Promise<Map<string, Buffer>>;
+    hasChunk(hash: string): boolean;
+    setChunk(hash: string, data: Buffer): void;
+}
+//# sourceMappingURL=memory-chunk-source.d.ts.map

package/dist/infrastructure/chunk-sources/memory-chunk-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-chunk-source.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/chunk-sources/memory-chunk-source.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,qBAAa,iBAAkB,YAAW,WAAW;IACnD,OAAO,CAAC,KAAK,CAA6B;IAEpC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUvC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAW/D,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI/B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAG3C"}

package/dist/infrastructure/chunk-sources/memory-chunk-source.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryChunkSource = void 0;
+const exceptions_1 = require("../../core/exceptions");
+class MemoryChunkSource {
+    cache = new Map();
+    async getChunk(hash) {
+        const chunk = this.cache.get(hash);
+        if (!chunk) {
+            throw new exceptions_1.ChunkNotFoundException(`${hash} not found in memory`);
+        }
+        return chunk;
+    }
+    async getChunks(hashes) {
+        const results = new Map();
+        for (const hash of hashes) {
+            const chunk = await this.getChunk(hash);
+            results.set(hash, chunk);
+        }
+        return results;
+    }
+    hasChunk(hash) {
+        return this.cache.has(hash);
+    }
+    setChunk(hash, data) {
+        this.cache.set(hash, data);
+    }
+}
+exports.MemoryChunkSource = MemoryChunkSource;

package/dist/infrastructure/chunk-sources/storage-chunk-source.d.ts

@@ -0,0 +1,21 @@
+import { StorageAdapter } from '../../core/adapters';
+import { ChunkSource } from '../../core/services';
+import { Nullish } from '../../core/types';
+import { Readable } from 'stream';
+export declare class StorageChunkSource implements ChunkSource {
+    private readonly storage;
+    private readonly urlsMap?;
+    constructor(storage: StorageAdapter, urlsMap?: Nullish<Map<string, string>>);
+    getChunk(hash: string): Promise<Buffer>;
+    getChunks(hashes: string[], { concurrency }?: {
+        concurrency?: number;
+    }): Promise<Map<string, Buffer>>;
+    streamChunks(hashes: string[], { concurrency, preserveOrder, }?: {
+        concurrency?: number;
+        preserveOrder?: boolean;
+    }): AsyncGenerator<{
+        hash: string;
+        data: Readable;
+    }>;
+}
+//# sourceMappingURL=storage-chunk-source.d.ts.map

package/dist/infrastructure/chunk-sources/storage-chunk-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-chunk-source.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/chunk-sources/storage-chunk-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,cAAc,EAAqB,MAAM,qBAAqB,CAAC;AAG5F,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,OAAO,EAAE,QAAQ,EAAe,MAAM,QAAQ,CAAC;AAE/C,qBAAa,kBAAmB,YAAW,WAAW;IAElD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;gBADR,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAGnD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBvC,SAAS,CACb,MAAM,EAAE,MAAM,EAAE,EAChB,EAAE,WAAe,EAAE,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GACjD,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAoBxB,YAAY,CACjB,MAAM,EAAE,MAAM,EAAE,EAChB,EACE,WAAe,EACf,aAAoB,GACrB,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KAAO,GACxD,cAAc,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC;CAkIpD"}

package/dist/infrastructure/chunk-sources/storage-chunk-source.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageChunkSource = void 0;
+const stream_to_buffer_1 = require("../../core/utils/stream-to-buffer");
+const exceptions_1 = require("../../core/exceptions");
+const stream_1 = require("stream");
+class StorageChunkSource {
+    storage;
+    urlsMap;
+    constructor(storage, urlsMap) {
+        this.storage = storage;
+        this.urlsMap = urlsMap;
+    }
+    async getChunk(hash) {
+        const url = this.urlsMap?.get(hash);
+        if (!url && this.storage.type === 'url') {
+            throw new Error(`No URL found for hash: ${hash}`);
+        }
+        const stream = this.storage.type === 'hash'
+            ? await this.storage.getChunk(hash)
+            : await this.storage.getChunkByUrl(url);
+        if (!stream) {
+            throw new exceptions_1.ChunkNotFoundException(`${hash} not found in storage`);
+        }
+        return (0, stream_to_buffer_1.streamToBuffer)(stream);
+    }
+    async getChunks(hashes, { concurrency = 8 } = {}) {
+        const results = new Map();
+        const queue = [...hashes];
+        const workers = Array.from({ length: concurrency }).map(async () => {
+            while (queue.length > 0) {
+                const hash = queue.shift();
+                if (!hash) {
+                    break;
+                }
+                const data = await this.getChunk(hash);
+                results.set(hash, data);
+            }
+        });
+        await Promise.all(workers);
+        return results;
+    }
+    async *streamChunks(hashes, { concurrency = 4, preserveOrder = true, } = {}) {
+        if (hashes.length === 0) {
+            return;
+        }
+        const controller = new AbortController();
+        const queue = hashes.map((hash, index) => ({ hash, index }));
+        const results = new Map();
+        let nextIndexToEmit = 0;
+        let activeWorkers = 0;
+        let workersDone = false;
+        const pendingResolvers = [];
+        let workerError = null;
+        const signalNext = () => {
+            const resolver = pendingResolvers.shift();
+            if (resolver) {
+                resolver();
+            }
+        };
+        const waitForData = async () => {
+            while ((preserveOrder && !results.has(nextIndexToEmit) && workerError === null) ||
+                (!preserveOrder && results.size === 0 && workerError === null)) {
+                await new Promise((resolve) => pendingResolvers.push(resolve));
+            }
+        };
+        const worker = async () => {
+            activeWorkers++;
+            try {
+                while (queue.length > 0 && !controller.signal.aborted) {
+                    const { hash, index } = queue.shift();
+                    try {
+                        const url = this.urlsMap?.get(hash);
+                        if (!url && this.storage.type === 'url') {
+                            throw new Error(`No URL found for hash: ${hash}`);
+                        }
+                        const stream = this.storage.type === 'hash'
+                            ? await this.storage.getChunk(hash)
+                            : await this.storage.getChunkByUrl(url);
+                        if (!stream) {
+                            throw new exceptions_1.ChunkNotFoundException(`${hash} not found in storage`);
+                        }
+                        const pass = new stream_1.PassThrough({ highWaterMark: 64 * 1024 });
+                        stream.on('error', (err) => {
+                            workerError = err instanceof Error ? err : new Error(String(err));
+                            controller.abort();
+                            signalNext();
+                        });
+                        pass.on('error', (err) => {
+                            workerError = err instanceof Error ? err : new Error(String(err));
+                            controller.abort();
+                            signalNext();
+                        });
+                        stream.pipe(pass);
+                        results.set(index, { hash, data: pass });
+                        signalNext();
+                    }
+                    catch (error) {
+                        workerError = error instanceof Error ? error : new Error(String(error));
+                        controller.abort();
+                        signalNext();
+                        return;
+                    }
+                }
+            }
+            finally {
+                activeWorkers--;
+                if (activeWorkers === 0) {
+                    workersDone = true;
+                    signalNext();
+                }
+            }
+        };
+        const workers = Array.from({ length: Math.min(concurrency, queue.length) }, worker);
+        try {
+            while (true) {
+                await waitForData();
+                if (workerError) {
+                    // ensure workers settle so their promise rejections don't become unhandled
+                    await Promise.allSettled(workers);
+                    throw workerError;
+                }
+                // Emit strictly in order
+                if (preserveOrder) {
+                    while (results.has(nextIndexToEmit)) {
+                        yield results.get(nextIndexToEmit);
+                        results.delete(nextIndexToEmit);
+                        nextIndexToEmit++;
+                    }
+                }
+                // Emit as soon as any result is ready
+                if (!preserveOrder) {
+                    const [index, value] = results.entries().next().value ?? [];
+                    if (value !== undefined && index !== undefined) {
+                        yield value;
+                        results.delete(index);
+                    }
+                }
+                if (workersDone && results.size === 0) {
+                    break;
+                }
+            }
+        }
+        finally {
+            controller.abort();
+            await Promise.allSettled(workers);
+        }
+    }
+}
+exports.StorageChunkSource = StorageChunkSource;

package/dist/infrastructure/client.d.ts

@@ -0,0 +1,45 @@
+import { RacDeltaConfig, StorageConfig } from '../core/config';
+import { DeltaService, HasherService, ReconstructionService, ValidationService } from '../core/services';
+import { PipelineBundleFor } from './factories/pipeline-factory';
+import { AdapterFromConfig } from './factories/storage-adpater-factory';
+/**
+ * Main entry point of the RacDelta SDK.
+ *
+ * `RacDeltaClient` acts as a high-level orchestrator that initializes all
+ * core services, adapters, and pipelines used for differential upload and
+ * download operations.
+ *
+ * It is designed to provide a single, easy-to-use API for performing
+ * file synchronization, hashing, validation, and reconstruction.
+ *
+ * ---
+ * ### Example
+ * ```ts
+ * import { RacDeltaClient } from 'rac-delta';
+ *
+ * const client = new RacDeltaClient({
+ *   storage: { type: 'local', basePath: './remote' },
+ *   maxConcurrency: 4,
+ * });
+ *
+ * const delta = await client.compareForDownload(localIndex, remoteIndex);
+ * console.log(delta);
+ * ```
+ *
+ * ---
+ */
+export declare class RacDeltaClient<C extends StorageConfig = StorageConfig> {
+    readonly config: RacDeltaConfig & {
+        storage: C;
+    };
+    readonly storage: AdapterFromConfig<C>;
+    readonly delta: DeltaService;
+    readonly hasher: HasherService;
+    readonly validation: ValidationService;
+    readonly reconstruction: ReconstructionService;
+    readonly pipelines: PipelineBundleFor<AdapterFromConfig<C>>;
+    constructor(config: RacDeltaConfig & {
+        storage: C;
+    });
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/infrastructure/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/infrastructure/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EACL,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,iBAAiB,EAAmB,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAyB,MAAM,qCAAqC,CAAC;AAG/F;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,cAAc,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa;IACjE,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG;QAAE,OAAO,EAAE,CAAC,CAAA;KAAE,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEhD,MAAM,EAAE,cAAc,GAAG;QAAE,OAAO,EAAE,CAAC,CAAA;KAAE;CAapD"}

package/dist/infrastructure/client.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RacDeltaClient = void 0;
+const pipeline_factory_1 = require("./factories/pipeline-factory");
+const storage_adpater_factory_1 = require("./factories/storage-adpater-factory");
+const service_factory_1 = require("./factories/service-factory");
+/**
+ * Main entry point of the RacDelta SDK.
+ *
+ * `RacDeltaClient` acts as a high-level orchestrator that initializes all
+ * core services, adapters, and pipelines used for differential upload and
+ * download operations.
+ *
+ * It is designed to provide a single, easy-to-use API for performing
+ * file synchronization, hashing, validation, and reconstruction.
+ *
+ * ---
+ * ### Example
+ * ```ts
+ * import { RacDeltaClient } from 'rac-delta';
+ *
+ * const client = new RacDeltaClient({
+ *   storage: { type: 'local', basePath: './remote' },
+ *   maxConcurrency: 4,
+ * });
+ *
+ * const delta = await client.compareForDownload(localIndex, remoteIndex);
+ * console.log(delta);
+ * ```
+ *
+ * ---
+ */
+class RacDeltaClient {
+    config;
+    storage;
+    delta;
+    hasher;
+    validation;
+    reconstruction;
+    pipelines;
+    constructor(config) {
+        this.config = config;
+        this.storage = storage_adpater_factory_1.StorageAdapterFactory.create(config.storage);
+        const services = service_factory_1.ServiceFactory.create();
+        this.delta = services.delta;
+        this.hasher = services.hasher;
+        this.validation = services.validation;
+        this.reconstruction = services.reconstruction;
+        this.pipelines = pipeline_factory_1.PipelineFactory.create(this.storage, services, config);
+    }
+}
+exports.RacDeltaClient = RacDeltaClient;

package/dist/infrastructure/factories/pipeline-factory.d.ts

@@ -0,0 +1,15 @@
+import { HashDownloadPipeline, HashUploadPipeline, UrlDownloadPipeline, UrlUploadPipeline } from '../../core/pipelines';
+import { RacDeltaConfig } from '../../core/config';
+import { StorageAdapter } from '../../core/adapters';
+import { ServiceBundle } from './service-factory';
+export type PipelineBundleFor<S extends StorageAdapter> = S['type'] extends 'hash' ? {
+    upload: HashUploadPipeline;
+    download: HashDownloadPipeline;
+} : S['type'] extends 'url' ? {
+    upload: UrlUploadPipeline;
+    download: UrlDownloadPipeline;
+} : never;
+export declare class PipelineFactory {
+    static create<S extends StorageAdapter>(storage: S, services: ServiceBundle, config: RacDeltaConfig): PipelineBundleFor<S>;
+}
+//# sourceMappingURL=pipeline-factory.d.ts.map

package/dist/infrastructure/factories/pipeline-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-factory.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/factories/pipeline-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAsB,cAAc,EAAqB,MAAM,qBAAqB,CAAC;AAO5F,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,cAAc,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,MAAM,GAC9E;IACE,MAAM,EAAE,kBAAkB,CAAC;IAC3B,QAAQ,EAAE,oBAAoB,CAAC;CAChC,GACD,CAAC,CAAC,MAAM,CAAC,SAAS,KAAK,GACrB;IACE,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,mBAAmB,CAAC;CAC/B,GACD,KAAK,CAAC;AAEZ,qBAAa,eAAe;IAC1B,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,cAAc,EACpC,OAAO,EAAE,CAAC,EACV,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,cAAc,GACrB,iBAAiB,CAAC,CAAC,CAAC;CA6BxB"}

package/dist/infrastructure/factories/pipeline-factory.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineFactory = void 0;
+const adapters_1 = require("../../core/adapters");
+const default_hash_download_pipeline_1 = require("../pipelines/default-hash-download-pipeline");
+const default_url_download_pipeline_1 = require("../pipelines/default-url-download-pipeline");
+const default_hash_upload_pipeline_1 = require("../pipelines/default-hash-upload-pipeline");
+const default_url_upload_pipeline_1 = require("../pipelines/default-url-upload-pipeline");
+class PipelineFactory {
+    static create(storage, services, config) {
+        if (storage instanceof adapters_1.HashStorageAdapter) {
+            return {
+                upload: new default_hash_upload_pipeline_1.DefaultHashUploadPipeline(storage, services.delta, config),
+                download: new default_hash_download_pipeline_1.DefaultHashDownloadPipeline(services.reconstruction, services.validation, storage, config, services.delta),
+            };
+        }
+        if (storage instanceof adapters_1.UrlStorageAdapter) {
+            return {
+                upload: new default_url_upload_pipeline_1.DefaultUrlUploadPipeline(storage, config),
+                download: new default_url_download_pipeline_1.DefaultUrlDownloadPipeline(storage, services.reconstruction, services.validation, services.delta, config),
+            };
+        }
+        throw new Error(`Unsupported storage adapter type: ${storage.type}`);
+    }
+}
+exports.PipelineFactory = PipelineFactory;

package/dist/infrastructure/factories/service-factory.d.ts

@@ -0,0 +1,11 @@
+import { DeltaService, HasherService, ReconstructionService, ValidationService } from '../../core/services';
+export interface ServiceBundle {
+    delta: DeltaService;
+    hasher: HasherService;
+    validation: ValidationService;
+    reconstruction: ReconstructionService;
+}
+export declare class ServiceFactory {
+    static create(): ServiceBundle;
+}
+//# sourceMappingURL=service-factory.d.ts.map

package/dist/infrastructure/factories/service-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-factory.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/factories/service-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,qBAAqB,CAAC;AAO7B,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,cAAc,EAAE,qBAAqB,CAAC;CACvC;AAED,qBAAa,cAAc;IACzB,MAAM,CAAC,MAAM,IAAI,aAAa;CAQ/B"}

package/dist/infrastructure/factories/service-factory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceFactory = void 0;
+const memory_reconstruction_service_1 = require("../services/memory-reconstruction-service");
+const memory_validation_service_1 = require("../services/memory-validation-service");
+const hash_wasm_hasher_service_1 = require("../services/hash-wasm-hasher-service");
+const memory_delta_service_1 = require("../services/memory-delta-service");
+class ServiceFactory {
+    static create() {
+        const hasher = new hash_wasm_hasher_service_1.HashWasmHasherService();
+        const delta = new memory_delta_service_1.MemoryDeltaService(hasher);
+        const validation = new memory_validation_service_1.MemoryValidationService(hasher);
+        const reconstruction = new memory_reconstruction_service_1.MemoryReconstructionService(hasher);
+        return { delta, hasher, validation, reconstruction };
+    }
+}
+exports.ServiceFactory = ServiceFactory;

package/dist/infrastructure/factories/storage-adpater-factory.d.ts

@@ -0,0 +1,41 @@
+import { StorageConfig } from '../../core/config';
+import { AzureBlobStorageAdapter } from '../adapters/azure-blob-storage-adapter';
+import { DefaultUrlStorageAdapter } from '../adapters/url-storage-adapter';
+import { LocalStorageAdapter } from '../adapters/local-storage-adapter';
+import { HTTPStorageAdapter } from '../adapters/http-storage-adapter';
+import { GCSStorageAdapter } from '../adapters/gcs-storage-adapter';
+import { SSHStorageAdapter } from '../adapters/ssh-storage-adapter';
+import { S3StorageAdapter } from '../adapters/s3-storage-adapter';
+export type StorageAdapterMap = {
+    local: LocalStorageAdapter;
+    http: HTTPStorageAdapter;
+    s3: S3StorageAdapter;
+    azure: AzureBlobStorageAdapter;
+    gcs: GCSStorageAdapter;
+    ssh: SSHStorageAdapter;
+    url: DefaultUrlStorageAdapter;
+};
+export type StorageTypeKey = keyof StorageAdapterMap;
+export type AdapterFromConfig<T extends StorageConfig> = T extends {
+    type: StorageTypeKey;
+} ? StorageAdapterMap[T['type']] : never;
+type StorageAdapterByConfigType<C extends StorageConfig> = C extends {
+    type: 'local';
+} ? LocalStorageAdapter : C extends {
+    type: 'http';
+} ? HTTPStorageAdapter : C extends {
+    type: 's3';
+} ? S3StorageAdapter : C extends {
+    type: 'azure';
+} ? AzureBlobStorageAdapter : C extends {
+    type: 'gcs';
+} ? GCSStorageAdapter : C extends {
+    type: 'ssh';
+} ? SSHStorageAdapter : C extends {
+    type: 'url';
+} ? DefaultUrlStorageAdapter : never;
+export declare class StorageAdapterFactory {
+    static create<C extends StorageConfig>(config: C): StorageAdapterByConfigType<C>;
+}
+export {};
+//# sourceMappingURL=storage-adpater-factory.d.ts.map

package/dist/infrastructure/factories/storage-adpater-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-adpater-factory.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/factories/storage-adpater-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAGlE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,mBAAmB,CAAC;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,EAAE,EAAE,gBAAgB,CAAC;IACrB,KAAK,EAAE,uBAAuB,CAAC;IAC/B,GAAG,EAAE,iBAAiB,CAAC;IACvB,GAAG,EAAE,iBAAiB,CAAC;IACvB,GAAG,EAAE,wBAAwB,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,iBAAiB,CAAC;AAErD,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,aAAa,IAAI,CAAC,SAAS;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACvF,iBAAiB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAC5B,KAAK,CAAC;AAEV,KAAK,0BAA0B,CAAC,CAAC,SAAS,aAAa,IAAI,CAAC,SAAS;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GAClF,mBAAmB,GACnB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GACxB,kBAAkB,GAClB,CAAC,SAAS;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACtB,gBAAgB,GAChB,CAAC,SAAS;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACzB,uBAAuB,GACvB,CAAC,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACvB,iBAAiB,GACjB,CAAC,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACvB,iBAAiB,GACjB,CAAC,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACvB,wBAAwB,GACxB,KAAK,CAAC;AAEtB,qBAAa,qBAAqB;IAChC,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,MAAM,EAAE,CAAC,GAAG,0BAA0B,CAAC,CAAC,CAAC;CAoBjF"}